Como você pode testar se um objeto tem uma propriedade específica?

Como você pode testar se um objeto tem uma propriedade específica?

Agradeço o que posso fazer ...

$members = Get-Member -InputObject $myobject 

e depois foreachatravés do $members, mas há uma função para testar se o objeto tem uma propriedade específica?

Informações adicionais: o problema é que estou importando dois tipos diferentes de arquivo CSV, um com duas colunas e outro com três. Não consegui fazer o cheque funcionar com "Property", apenas com "NoteProperty" ... seja qual for a diferença

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

Como isso?

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

Você pode usar Get-Member

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

Isso é sucinto e legível:

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

Podemos colocá-lo em uma função:

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

Eu tenho usado o seguinte que retorna o valor da propriedade, como seria acessado via$thing.$prop , se a "propriedade" existir e não lançar uma exceção aleatória. Se a propriedade "não existe" (ou tem um valor nulo), então $nullé retornado: esta abordagem funciona em / é útil para o modo estrito , porque, bem, vou pegar todos.

Acho essa abordagem útil porque permite que Objetos personalizados PS, objetos .NET normais, HashTables PS e coleções .NET como o Dicionário sejam tratados como "equivalente digitado em pato" , que considero um ajuste bastante adequado para PowerShell.

Claro, isso não atende à definição estrita de "tem uma propriedade" .. à qual esta questão pode ser explicitamente limitada. Se aceitar a definição mais ampla de "propriedade" assumida aqui, o método pode ser modificado trivialmente para retornar um booleano.

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

Exemplos:

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"

E, este comportamento pode não ser [sempre] desejado .. ie. não é possível distinguir entre x.Counte x["Count"].

Se você estiver usando StrictMode e o psobject estiver vazio, ocorrerá um erro.

Para todos os efeitos, isso fará:

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

Para mim MyProperty" -in $MyObject.PSobject.Properties.Namenão funcionou, no entanto

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

trabalho

Realmente semelhante a uma verificação de javascript:

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

Só para esclarecer dado o seguinte objeto

$Object

Com as seguintes propriedades

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

O seguinte é verdadeiro

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

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

Portanto, as respostas anteriores que verificam explicitamente a propriedade pelo nome são a maneira mais correta de verificar se essa propriedade não está presente.

Basta verificar em relação a null.

($myObject.MyProperty -ne $null)

Se você não definiu PowerShell como StrictMode , isso funcionará mesmo se a propriedade não existir:

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

Acabei com a seguinte função ...

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

Recentemente, mudei para definir o modo estrito - versão 2.0 e meus testes nulos falharam.

Eu adicionei uma função:

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

Agora eu codifico

if (exists $run main) { ...

ao invés de

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

e estamos a caminho. Parece funcionar em objetos e hashtables

Como um benefício indesejado, é menos digitação.

Acabei de começar a usar o PowerShell com PowerShell Core 6.0 (beta) e o seguinte simplesmente funciona:

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

ou

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

Você pode verificar com:

($Member.PropertyNames -contains "Name") isso irá verificar a propriedade nomeada

Para identificar quais objetos em uma matriz têm uma propriedade

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