Come puoi verificare se un oggetto ha una proprietà specifica?

Come puoi verificare se un oggetto ha una proprietà specifica?

Apprezzo che posso fare ...

$members = Get-Member -InputObject $myobject 

e poi foreachtramite $members, ma esiste una funzione per verificare se l'oggetto ha una proprietà specifica?

Informazioni aggiuntive: il problema è che sto importando due diversi tipi di file CSV, uno con due colonne, l'altro con tre. Non sono riuscito a far funzionare l'assegno con "Property", solo con "NoteProperty" ... qualunque sia la differenza

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

Come questo?

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

Puoi usare Get-Member

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

Questo è succinto e leggibile:

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

Possiamo metterlo in una funzione:

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

Ho usato quanto segue che restituisce il valore della proprietà, poiché sarebbe accessibile tramite$thing.$prop , se la "proprietà" dovesse esistere e non generare un'eccezione casuale. Se la proprietà "non esiste" (o ha un valore nullo) $nullviene restituita: questo approccio funziona in / è utile per la modalità rigorosa , perché, beh, Gonna Catch 'em All.

Trovo questo approccio utile perché consente a PS Custom Objects, normali oggetti .NET, PS HashTables e .NET raccolte come Dictionary di essere trattati come "equivalenti a forma di papera" , che trovo siano abbastanza adatti per PowerShell.

Naturalmente, questo non soddisfa la definizione rigorosa di "ha una proprietà" .. a cui questa domanda può essere esplicitamente limitata. Se si accetta la definizione più ampia di "proprietà" qui assunta, il metodo può essere banalmente modificato per restituire un valore booleano.

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

Esempi:

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 questo comportamento potrebbe non [sempre] essere desiderato .. cioè. non è possibile distinguere tra x.Counte x["Count"].

Per me MyProperty" -in $MyObject.PSobject.Properties.Nameperò non ha funzionato

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

lavori

Se stai usando StrictMode e psobject potrebbe essere vuoto, ti darà un errore.

A tutti gli effetti questo farà:

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

Reale simile a un controllo javascript:

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

Giusto per chiarire dato il seguente oggetto

$Object

Con le seguenti proprietà

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

Quanto segue è vero

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

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

Quindi le risposte precedenti che verificano esplicitamente la proprietà in base al nome sono il modo più corretto per verificare che quella proprietà non sia presente.

Controlla solo con null.

($myObject.MyProperty -ne $null)

Se non hai impostato PowerShell su StrictMode , funziona anche se la proprietà non esiste:

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

Ho finito con la seguente funzione ...

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

Di recente sono passato alla versione 2.0 in modalità rigorosa e i miei test nulli non sono riusciti.

Ho aggiunto una funzione:

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

Ora codifico

if (exists $run main) { ...

piuttosto che

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

e siamo in viaggio. Sembra funzionare su oggetti e tabelle hash

Come vantaggio non intenzionale, è meno digitazione.

Volevo solo aggiungere qualcosa alla discussione, perché ho passato ore a eseguire il debug di un codice che funzionava da qualche altra parte.

Risposta di CB. funziona bene per abbinare la variabile con i nomi delle proprietà (come stringhe). Il problema è iniziato quando la variabile corrisponde a una parte del nome di una proprietà.

if([bool]($allFiles.PSobject.Properties.name -match $_.Name) -ne $true){

Successivamente l'ho usato per fare riferimento alla proprietà di un oggetto, ma poiché corrispondeva solo a una parte di un'altra proprietà, quindi una proprietà effettiva con quel nome esatto non esisteva, l'operazione ha restituito il valore "null".

Solo successivamente ho usato la soluzione proposta da dan-gph , che è molto pulita:

if([bool]($_.Name -in $allFiles.PSobject.Properties.Name) -ne $true){

Ciò ha garantito che i due valori fossero identici . Sapevo dove cercare, ma è stato doloroso anche solo capire che il problema è che diversi nomi corrispondono a stringhe con 2 caratteri. prefisso ma per il resto lo stesso.

Ho appena iniziato a utilizzare PowerShell con PowerShell Core 6.0 (beta) e quanto segue funziona semplicemente:

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

o

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

Potresti controllare con:

($Member.PropertyNames -contains "Name") ciò verificherà la proprietà Named

Per identificare quali oggetti in un array hanno una proprietà

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