¿Cómo se puede probar si un objeto tiene una propiedad específica?

Puedes usar Get-Member

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

Esto es sucinto y legible:

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

Podemos ponerlo en una función:

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

Real similar a una comprobación de javascript:

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

Si está utilizando StrictMode y el psobject puede estar vacío, le dará un error.

Para todos los propósitos esto servirá:

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

He estado usando lo siguiente que devuelve el valor de la propiedad, ya que se accedería a través de $thing.$prop, si la" propiedad " sería existir y no lanzar una excepción aleatoria. Si la propiedad "no existe" (o tiene un valor nulo) entonces se devuelve $null: este enfoque funciona en/es útil para modo estricto, porque, bueno, va a atraparlos a Todos.

Encuentro útil este enfoque porque permite Objetos personalizados de PS, objetos normales. NET, HashTables de PS y. NET las colecciones como Dictionary deben ser tratadas como"duck-typed equivalent" , lo que me parece un ajuste bastante bueno para PowerShell.

Por supuesto, esto no cumple con la definición estricta de "tiene una propiedad".. a los que esta pregunta puede limitarse explícitamente. Si se acepta la definición más amplia de "propiedad" asumida aquí, el método se puede modificar trivialmente para devolver un booleano.

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

Ejemplos:

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"

Y, este comportamiento podría no ser deseado [siempre].. IE. no es posible distinguir entre x.Count y x["Count"].

Simplemente marque con null.

($myObject.MyProperty -ne $null)

Si no ha establecido PowerShell en StrictMode , esto funciona incluso si la propiedad no existe:

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

Terminé con la siguiente función ...

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; 
    }
}

Solo para aclarar dado el siguiente objeto

$Object

Con las siguientes propiedades

type        : message
user        : [email protected]
text        : 
ts          : 11/21/2016 8:59:30 PM

Lo siguiente es cierto

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

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

Así que las respuestas anteriores que comprueban explícitamente la propiedad por nombre es la forma más correcta de verificar que esa propiedad no está presente.

Acabo de empezar a usar PowerShell con PowerShell Core 6.0 (beta) y lo siguiente simplemente funciona:

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

O

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

Recientemente cambié a set strict-mode-version 2.0 y mis pruebas null fallaron.

He añadido una función:

#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
}

Ahora codigo

if (exists $run main) { ...

En lugar de

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

Y estamos en camino. Parece funcionar en objetos y hashtables

Como un beneficio no deseado es menos escribir.

Usted podría comprobar con:

($Member.PropertyNames -contains "Name") esto comprobará la propiedad nombrada