Comment tester si un objet a une propriété spécifique?

Comment tester si un objet a une propriété spécifique?

J'apprécie que je puisse faire ...

$members = Get-Member -InputObject $myobject 

puis foreachvia le $members, mais y a-t-il une fonction pour tester si l'objet a une propriété spécifique?

Informations supplémentaires: le problème est que j'importe deux types de fichiers CSV, l'un avec deux colonnes, l'autre avec trois. Je n'ai pas pu faire fonctionner le chèque avec "Propriété", uniquement avec "NoteProperty" ... quelle que soit la différence

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

Comme ça?

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

Vous pouvez utiliser Get-Member

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

Ceci est succinct et lisible:

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

On peut le mettre dans une fonction:

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

J'ai utilisé ce qui suit qui renvoie la valeur de la propriété, car elle serait accessible via$thing.$prop , si la "propriété" devait exister et ne pas lancer une exception aléatoire. Si la propriété "n'existe pas" (ou a une valeur nulle) alors $nullest retournée: cette approche fonctionne en / est utile pour le mode strict , car, eh bien, va les attraper tous.

Je trouve cette approche utile car elle permet aux objets personnalisés PS, aux objets .NET normaux, aux HashTables PS et aux collections .NET comme Dictionary d'être traités comme des «équivalents de type canard» , ce qui, à mon avis, convient assez bien à PowerShell.

Bien entendu, cela ne répond pas à la définition stricte de "possède une propriété" .. à laquelle cette question peut être explicitement limitée. Si vous acceptez la définition plus large de "propriété" supposée ici, la méthode peut être modifiée de manière triviale pour renvoyer un booléen.

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

Exemples:

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"

Et, ce comportement pourrait ne pas [toujours] être souhaité .. ie. il n'est pas possible de faire la distinction entre x.Countet x["Count"].

Pour moi MyProperty" -in $MyObject.PSobject.Properties.Namen'a pas fonctionné, cependant

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

travaux

Si vous utilisez StrictMode et que le psobject est peut-être vide, cela vous donnera une erreur.

À toutes fins, cela fera:

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

Réel similaire à une vérification javascript:

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

Juste pour clarifier compte tenu de l'objet suivant

$Object

Avec les propriétés suivantes

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

Ce qui suit est vrai

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

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

Ainsi, les réponses précédentes qui vérifient explicitement la propriété par son nom sont le moyen le plus correct de vérifier que cette propriété n'est pas présente.

Vérifiez simplement la valeur nulle.

($myObject.MyProperty -ne $null)

Si vous n'avez pas défini PowerShell sur StrictMode , cela fonctionne même si la propriété n'existe pas:

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

J'ai fini avec la fonction suivante ...

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

Je suis récemment passé à la version 2.0 en mode strict et mes tests nuls ont échoué.

J'ai ajouté une fonction:

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

Maintenant je code

if (exists $run main) { ...

plutôt que

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

et nous sommes en route. Semble fonctionner sur des objets et des hashtables

En tant qu'avantage involontaire, c'est moins de frappe.

Je voulais juste ajouter à la discussion, car je viens de passer des heures à déboguer un code qui fonctionnait ailleurs.

Réponse de CB. fonctionne bien pour faire correspondre la variable avec les noms des propriétés (sous forme de chaînes). Le problème a commencé lorsque la variable correspondait à une partie d'un nom de propriété.

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

Plus tard, je l'ai utilisé pour faire référence à la propriété d'un objet, mais comme il ne correspondait qu'à une partie d'une autre propriété, une propriété réelle avec ce nom exact n'existait pas, l'opération a renvoyé la valeur «null».

Ce n'est que plus tard que j'ai utilisé la solution proposée par dan-gph , qui est très soignée:

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

Cela garantissait que les deux valeurs étaient identiques . Je savais où chercher, mais c'était encore difficile de comprendre que le problème était que plusieurs noms correspondent à des chaînes avec 2 caractères. préfixe mais sinon le même.

Je viens de commencer à utiliser PowerShell avec PowerShell Core 6.0 (bêta) et ce qui suit fonctionne simplement:

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

ou

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

Vous pouvez vérifier avec:

($Member.PropertyNames -contains "Name") cela vérifiera la propriété nommée

Pour identifier les objets d'un tableau qui ont une propriété

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