How can you test if an object has a specific property?

Question

Appreciate I can do ...

$members = Get-Member -InputObject $myobject

and then foreach through the $members, but is there a function to test if the object has a specific property?

Additional Info: The issue is I'm importing two different sorts of CSV file, one with two columns, the other with three. I couldn't get the check to work with "Property", only with "NoteProperty" ... whatever the difference is

if ( ($member.MemberType -eq "NoteProperty" ) -and ($member.Name -eq $propertyName) )

Does it matter if the propery does exist but has a `$null` value — Matt, Nov 18 '14 at 16:11
@arco444 nope -- that requires the property to exist for it to succeed. -- If you have dynamic data (i.e. from a web request) where some rows don't even specify that property, that check will fail. :( — BrainSlugs83, May 25 '18 at 20:15
[The upvotes (at the time of writing this) do not reflect the best answers](https://stackoverflow.com/a/70492574/5765336) (and actually suggest that the slowest answer is better than the fastest answers). — Dave F, Dec 27 '21 at 15:25
@Matt solutions that check if the property exists using `PSObject.Properties` will return a value that evaluates to `$True` even when the property has a value that evaluates to false, such as `$Null`, `$False`, `0`, or the empty string. This is because `PSObject.Properties` is a collection of objects with information about the object's properties (and objects evaluate to true). — Dave F, Dec 27 '21 at 15:35

score 134 · Accepted Answer · answered Nov 18 '14 at 15:42

134

Like this?

 [bool]($myObject.PSobject.Properties.name -match "myPropertyNameToTest")

answered Nov 18 '14 at 15:42

CB.

58,865
9
159
159

17

This answer works only for powerShell v3 or higher. The following should work even with powerShell v2 and above: [bool]($file.psobject.Properties | where { $_.Name -eq "myPropertyNameToTest"}) – Patrick Sep 21 '15 at 12:03
50

`$myObject.PSobject.Properties.Name -contains "myPropertyNameToTest"` is better. No need to worry about possible pattern matching, and you won't need to cast to Boolean then, either. – Bacon Bits Dec 15 '16 at 19:31
4

What if the object has the property `ThisisMyProperty` and you'd like to check for `MyProperty`? All solutions in this answer will result in a false positive. – Zoltán Tamási Sep 13 '17 at 10:23
Honestly, you would be fine in most cases checking `if($obj.prop -eq $null)` – Kellen Stuart Sep 20 '17 at 23:14
5

@KolobCanyon That will not function under Strict Mode. – user2864740 Feb 05 '18 at 20:46
4

This code will give a false positive if for example you where testing for "Count" and the object had a property called "ThingCount". – dan-gph Feb 26 '18 at 06:38
1

The solution is moving in the right direction, an alternative way of implementing the above would be: $myObject.PSobject.Properties.name.contains("PropertyNameToTest") this returns a boolean type – Porky Mar 14 '19 at 09:38
2

String to match is a regular expression, so there will be no false positives if there are anchors around it. Like this: `-match "^myPropertyNameToTest$"`. – Yuhis Aug 19 '19 at 11:11
To get an exact match, you can also use: [bool]($myObject.PSobject.Properties.name -contains "myPropertyNameToTest") – Mars Mar 18 '21 at 20:29

score 97 · Answer 2 · edited Feb 10 '23 at 02:11

97

You can use Get-Member

if (Get-Member -inputobject $var -name "Property" -Membertype Properties) {
    #Property exists
}

edited Feb 10 '23 at 02:11

informatik01

16,038
10
74
104

answered Nov 18 '14 at 15:15

Paul

5,524
1
22
39

16

Best answer IMHO. This works with .NET objects that don't have a PSobject member. We can also remove the -Membertype option if we don't care which type of member the object contains - just the member name. Very useful with Invoke-RestMethod or ConvertFrom-Json objects! – Mister_Tom Apr 14 '17 at 20:59
12

Short syntax without checking type: `if($var | Get-Member Property){ }`, even shorter but less readable: `if($var | gm Property){ }` – zett42 Dec 17 '19 at 13:48
1

This is in my opinion the best answer. – Kiran Hegde Aug 24 '20 at 06:36

dan-gph · Answer 3 · 2018-02-26T06:52:55.840

34

This is succinct and readable:

"MyProperty" -in $MyObject.PSobject.Properties.Name

We can put it in a function:

function HasProperty($object, $propertyName)
{
    $propertyName -in $object.PSobject.Properties.Name
}

edited Feb 26 '18 at 06:52

answered Feb 26 '18 at 06:43

dan-gph

16,301
12
61
79

1

I love this answer, but it seems to not work in some cases where CB's answer does. – hyperupcall Mar 31 '19 at 07:12
Or, where "succinct" = "needless junk introduced via Strict Mode without a good fallback usage case" (ie. no `?.` equivalent) :| This will also fail for certain variations of `$MyObject`, notably $null. Such was not the case with the null-chaining outside of Strict Mode. – user2864740 Sep 06 '19 at 21:25

score 13 · Answer 4 · edited Mar 18 '20 at 08:30

13

For me MyProperty" -in $MyObject.PSobject.Properties.Name didn't work, however

$MyObject.PSobject.Properties.Name.Contains("MyProperty")

works

edited Mar 18 '20 at 08:30

phuclv

37,963
15
156
475

answered Oct 08 '19 at 09:41

sebke CCU

173
1
7

Does not work for hash tables, which do not have a `Name` property. – Diti Jun 21 '22 at 11:40
1

For hashtables you can just use ContainsKey() @Diti – Jon R Nov 02 '22 at 22:09

Dave F · Answer 5 · 2021-12-27T15:23:51.627

There are a number of solutions to this question that work in strict mode, but some are better than others.

Solutions that do not appear to iterate through every property are the fastest solutions.

Solutions that look as though they iterate through every property are slower.

The solution that appears to iterate through every property and uses a regular expression is a little slower than the previous two solutions (because compiling and executing the regular expression takes more time)

CB.'s solution

The solution that uses GetMethod appears to iterate through every property, but its use of GetMethod makes it significantly slower.

Paul's GetMethod solution

The following script was used to compare the previously mentioned solutions in strict mode:

# Tested in PowerShell core 7.2.0

Set-StrictMode -Version Latest

$propertyExistsMethods = New-Object System.Collections.Generic.Dictionary'[string,scriptblock]'

# Fastest
$propertyExistsMethods.Add(
 "PSObject.Properties (Bernie White's solution)",
{
  Param( [PSObject] $Object, [string] $Property )
  [bool]$Object.PSObject.Properties[$Property]
})
$propertyExistsMethods.Add(
 "PSObject.Properties.Item (esskar's solution (modified))",
{
  Param( [PSObject] $Object, [string] $Property )
  [bool]$Object.PSObject.Properties.Item($property)
})

# Not as fast
$propertyExistsMethods.Add(
 "Contains (sebke CCU's solution)",
{
  Param( [PSObject] $Object, [string] $Property )
  $Object.PSobject.Properties.Name.Contains($Property)
})
$propertyExistsMethods.Add(
 "-in (dan-gph's solution)",
{
  Param( [PSObject] $Object, [string] $Property )
  $Property -in $Object.PSobject.Properties.Name
})

# Slower than the previously mentioned solutions
$propertyExistsMethods.Add(
 "-match (CB.'s solution)",
{
  Param( [PSObject] $Object, [string] $Property )
  [bool]($Object.PSobject.Properties.name -match $Property)
})

# Slowest
$propertyExistsMethods.Add(
 "GetMember (Paul's solution)",
{
  Param( [PSObject] $Object, [string] $Property )
  Get-Member -inputobject $Object -name $Property -Membertype Properties
})

foreach ($method in $propertyExistsMethods.Keys) {
  $propertyExists = $propertyExistsMethods[$method]

  $o = @{}
  foreach ($i in 1..100000) {
    $o[$i] = "p$i"
  }

  Write-Host $method
  $measure = Measure-Command {
    foreach ($i in 1..100000) {
      # Always check for a property that does NOT exist
      & $propertyExists -Object $o -Property 'p'
    }
  }
  Write-Host $measure | % { $_.Milliseconds }
  Write-Host ''
}

The output is as follows:

PSObject.Properties (Bernie White's solution)
00:00:03.1437587

PSObject.Properties.Item (esskar's solution)
00:00:03.5833642

Contains (sebke CCU's solution)
00:00:04.4812702

-in (dan-gph's solution)
00:00:04.6507811

-match (CB.'s solution)
00:00:05.1107066

GetMember (Paul's solution)
00:00:14.5305115

score 8 · Answer 6 · answered Jan 19 '21 at 02:20

8

Try this for a one liner that is strict safe.

[bool]$myobject.PSObject.Properties[$propertyName]

For example:

Set-StrictMode -Version latest;
$propertyName = 'Property1';
$myobject = [PSCustomObject]@{ Property0 = 'Value0' };

if ([bool]$myobject.PSObject.Properties[$propertyName]) {
    $value = $myobject.$propertyName;
}

answered Jan 19 '21 at 02:20

Bernie White

4,780
4
23
21

1

This seems to be [the best solution listed](https://stackoverflow.com/a/70492574/5765336). – Dave F Dec 27 '21 at 07:25

score 7 · Answer 7 · edited Sep 16 '21 at 10:58

7

Just check against null.

($myObject.MyProperty -ne $null)

If you have not set PowerShell to StrictMode, this works even if the property does not exist:

$obj = New-Object PSObject;                                                   
Add-Member -InputObject $obj -MemberType NoteProperty -Name Foo -Value "Bar";
$obj.Foo; # Bar                                                                  
($obj.MyProperty -ne $null);  # False, no exception

edited Sep 16 '21 at 10:58

li ki

342
3
11

answered Oct 20 '16 at 17:02

Shaun Luttin

133,272
81
405
467

3

As far as I can see, this works if the property exists and is $null, but not if the property does not exists - attempting to access it to do the null check throws an exception. – Peter Feb 27 '17 at 08:39
@Peter Can you provide an example of the null check throwing an exception when the property does not exist. I have added an example in which a property does not exist and there is no exception. – Shaun Luttin Feb 27 '17 at 17:08
2

Run this: `Set-Strictmode -version Latest;$obj = ConvertFrom-Json -InputObject '{"name":"test", "version":"1.1.0"}';If($obj.StartDate -ne $null){Write-Verbose -Message $obj.startDate -Verbose}` and you will get an error *Property 'StartDate' cannot be found on this object.* **However** I need to qualify my comment - you don't get it if Strictmode is not set. I always have it set, so never realised until I tested for this! Still, I think most people use (or should use) 'Set-Strictmode'. – Peter Feb 28 '17 at 08:01
2

Probably best if you qualify your answer, and I'll remove my downvote? Everyone has learnt something, which is the point :-) – Peter Feb 28 '17 at 08:07

user2864740 · Answer 8 · 2018-05-18T17:36:12.257

I've been using the following which returns the property value, as it would be accessed via $thing.$prop, if the "property" would be to exist and not throw a random exception. If the property "doesn't exist" (or has a null value) then $null is returned: this approach functions in/is useful for strict mode, because, well, Gonna Catch 'em All.

I find this approach useful because it allows PS Custom Objects, normal .NET objects, PS HashTables, and .NET collections like Dictionary to be treated as "duck-typed equivalent", which I find is a fairly good fit for PowerShell.

Of course, this does not meet the strict definition of "has a property".. which this question may be explicitly limited to. If accepting the larger definition of "property" assumed here, the method can be trivially modified to return a boolean.

Function Get-PropOrNull {
    param($thing, [string]$prop)
    Try {
        $thing.$prop
    } Catch {
    }
}

Examples:

Get-PropOrNull (Get-Date) "Date"                   # => Monday, February 05, 2018 12:00:00 AM
Get-PropOrNull (Get-Date) "flub"                   # => $null
Get-PropOrNull (@{x="HashTable"}) "x"              # => "HashTable"
Get-PropOrNull ([PSCustomObject]@{x="Custom"}) "x" # => "Custom"
$oldDict = New-Object "System.Collections.HashTable"
$oldDict["x"] = "OldDict"
Get-PropOrNull $d "x"                              # => "OldDict"

And, this behavior might not [always] be desired.. ie. it's not possible to distinguish between x.Count and x["Count"].

To get a property or `$null` without extra function: `$x = try{ $someObject.someProp } catch{ $null }`. You can omit `$null` from the `catch` block, but IMO it improves readability. — zett42, Nov 17 '20 at 14:15

score 3 · Answer 9 · answered Sep 20 '17 at 14:29

3

If you are using StrictMode and the psobject might be empty, it will give you an error.

For all purposes this will do:

    if (($json.PSobject.Properties | Foreach {$_.Name}) -contains $variable)

answered Sep 20 '17 at 14:29

Ádám Kovács

107
2
10

score 3 · Answer 10 · answered Apr 06 '21 at 19:43

3

I find this method more strict and faster when checking multiple properties

$null -ne $myobject.PSObject.Properties.Item("myPropertyNameToTest")

answered Apr 06 '21 at 19:43

esskar

10,638
3
36
57

3

You don't need to compare the property from `PSObject.Properties` to `$null`. It can be cast to a boolean value like so `[bool]$myobject.PSObject.Properties.Item("myPropertyNameToTest")` – Dave F Dec 27 '21 at 15:00

score 2 · Answer 11 · answered Nov 18 '14 at 15:13

2

Real similar to a javascript check:

foreach($member in $members)
{
    if($member.PropertyName)
    {
        Write $member.PropertyName
    }
    else
    {
        Write "Nope!"
    }
}

answered Nov 18 '14 at 15:13

YtramX

172
10

1

This may not work if the property actually has the value $null. – Tola Odejayi Jan 21 '17 at 02:09
8

This will fail if PowerShell is in strict mode. – Ian Kemp May 11 '17 at 12:24
@IanKemp What is strict mode? Like the Execution Policy? – Kellen Stuart Oct 05 '17 at 15:22
1

@KolobCanyon https://learn.microsoft.com/en-za/powershell/module/Microsoft.PowerShell.Core/Set-StrictMode?view=powershell-4.0 - essentially it's the PS equivalent to JavaScript's `use strict`. – Ian Kemp Oct 06 '17 at 05:46
1

This will also not work if the property exists, and is set to $false. – Mar 06 '19 at 18:14

score 1 · Answer 12 · answered Nov 22 '16 at 14:59

Just to clarify given the following object

$Object

With the following properties

type        : message
user        : john.doe@company.com
text        : 
ts          : 11/21/2016 8:59:30 PM

The following are true

$Object.text -eq $NULL
$Object.NotPresent -eq $NULL

-not $Object.text
-not $Object.NotPresent

So the earlier answers that explicitly check for the property by name is the most correct way to verify that that property is not present.

score 0 · Answer 13 · answered Nov 19 '14 at 10:01

I ended up with the following function ...

function HasNoteProperty(
    [object]$testObject,
    [string]$propertyName
)
{
    $members = Get-Member -InputObject $testObject 
    if ($members -ne $null -and $members.count -gt 0) 
    { 
        foreach($member in $members) 
        { 
            if ( ($member.MemberType -eq "NoteProperty" )  -and `
                 ($member.Name       -eq $propertyName) ) 
            { 
                return $true 
            } 
        } 
        return $false 
    } 
    else 
    { 
        return $false; 
    }
}

score 0 · Answer 14 · answered Aug 29 '18 at 23:03

I recently switch to set strict-mode -version 2.0 and my null tests failed.

I added a function:

#use in strict mode to validate property exists before using
function exists {
  param($obj,$prop)
  try {
    if ($null -ne $obj[$prop]) {return $true}
    return $false
  } catch {
    return $false
  }
  return $false
}

Now I code

if (exists $run main) { ...

rather than

if ($run.main -ne $null) { ...

and we are on our way. Seems to work on objects and hashtables

As an unintended benefit it is less typing.

For null or empty, I've always used: **IF([string]::IsNullOrEmpty($userID)) { write-host "Null or empty"}** — , Mar 06 '19 at 18:27

score 0 · Answer 15 · answered Mar 31 '21 at 19:01

0

for me this work

Set-StrictMode -Version Latest
$TMP = ...

$HAS_SERVERS=($TMP | Select-Object Servers)
if (-not $HAS_SERVERS.Servers){
    echo "No servers. Abort."
} else {
    ...
}

answered Mar 31 '21 at 19:01

Jon Grey

11
1
3

score -1 · Answer 16 · answered Nov 10 '17 at 21:33

-1

I just started using PowerShell with PowerShell Core 6.0 (beta) and following simply works:

if ($members.NoteProperty) {
   # NoteProperty exist
}

or

if (-not $members.NoteProperty) {
   # NoteProperty does not exist
}

answered Nov 10 '17 at 21:33

hshib

1,691
1
17
22

2

Not with strictmode on – Casper Leon Nielsen Aug 22 '19 at 05:35

score -1 · Answer 17 · edited Sep 10 '18 at 08:31

-1

You could check with:

($Member.PropertyNames -contains "Name") this will check for the Named property

edited Sep 10 '18 at 08:31

Matthias

4,481
12
45
84

answered Sep 10 '18 at 07:59

Tom Stryhn

1

score -1 · Answer 18 · answered Nov 14 '18 at 01:14

-1

For identifying which of the objects in an array have a property

$HasProperty = $ArrayOfObjects | Where-Object {$_.MyProperty}

answered Nov 14 '18 at 01:14

corky

185
2
8

1

Fails in StrictMode when the property does not exist. – user2864740 Sep 11 '19 at 20:14

How can you test if an object has a specific property?

18 Answers18

Linked