Comment tester pour $null tableau en PowerShell

Je suis en utilisant une variable de tableau dans PowerShell 2.0. Si elle n'a pas de valeur, il sera de$, null, je peux tester avec succès:

PS C:\> [array]$foo = $null
PS C:\> $foo -eq $null
True

Mais quand je lui donne une valeur, le test pour $null ne retourne rien:

PS C:\> [array]$foo = @("bar")
PS C:\> $foo -eq $null
PS C:\>

Comment "-eq $null" donnent pas de résultats? C'est soit $null ou pas.

Quelle est la bonne façon de déterminer si un tableau est rempli vs $null?

InformationsquelleAutor Mark Berry | 2011-02-24

null powershell

68

Son un tableau, de sorte que vous êtes à la recherche pour le compte de test pour le contenu.

Je le recommande
```
$foo.count -gt 0
```
Le "pourquoi" de ce qui est lié à la façon dont PSH poignées de comparaison des objets de collection
- Malheureusement ça ne marche pas quand [array]$foo = $null. Au lieu de 0, $foo.count ne retourne rien.
- mais (rien -gt 0 == FALSE), qui est pourquoi j'ai suggéré à l'aide de l'opérateur en question. Si vous de vérifier que vous aurez un vrai/faux, indépendamment de nullness
- Ah, je vois. Oui, c'est plus court et un peu plus intuitif que d'avoir à utiliser le else bloc de if ($foo -eq $null) déclaration. Intéressant de constater que lorsque [array]$foo = $null, $foo.count -eq 0 est Faux, mais $foo.count -lt 0 est Vrai. Je suppose que $null est inférieur à 0. Me demande si c'est documenté quelque part?
- Bien qu'un ensemble est une construction, même quand il est vide .. et le count() est sur la construction de l'objet, non de son contenu, de sorte que la minute vous créez le tableau, il a une propriété count
- Juste de noter que $null.count -lt 0 est Vrai, tandis que $null.count -gt 0 est Faux. Si c'est la garantie de résultat, puis $foo.count -lt 0 pourrait être utilisé pour vérifier les $null, e.g quand je veux faire quelque chose si le tableau n'a pas été créé. Bien que dans ce cas, le if ($foo -eq $null) peut être plus lisible.
- Si vous avez vraiment envie de faire mal à votre tête, powershell vous dira que $null -lt 0 == VRAI, mais $null -lt -1 == FALSE. donc -1 < null < 0
- retourne vide dans le cas où le tableau n'a qu'une valeur
- Cette approche ne tient pas si vous avez Défini-StrictMode -Version plus récente
InformationsquelleAutor Taylor Bird
38

Vous pouvez modifier l'ordre des opérandes:
```
$null -eq $foo
```
Noter que -eq dans PowerShell n'est pas une relation d'équivalence.
- Cool. N'y avait pas pensé. Si l'-eq ne scanne une collection de valeurs si la collection est à la gauche de l'eq.
- En effet. Voir help about_Comparison_Operators où cela est décrit.
- Très bonne solution. Thumbs up!
- Merci pour la solution @Joey Cela fonctionne même en cas de tableau a une valeur ou sans valeur !
InformationsquelleAutor Joey
20
```
if($foo -eq $null) { "yes" } else { "no" }

help about_comparison_operators 
```
affiche l'aide et comprend ce texte:

Tous les opérateurs de comparaison à l'exception de la
le confinement des opérateurs (-contient,
-notcontains) et le type d'opérateurs (-est, -isnot) renvoie une valeur Booléenne lorsque l'entrée de l'opérateur (la valeur
sur le côté gauche de l'opérateur) est un
valeur unique (un scalaire). Lorsque l'
l'entrée est un ensemble de valeurs, l'
le confinement des opérateurs et le type
les opérateurs de retourner toute correspondance de valeurs.
Si il n'y a pas de matches en un
collection, ces opérateurs ne sont pas
renvoie rien. L'enceinte de confinement
les opérateurs et le type des opérateurs de toujours
renvoie une valeur Booléenne.
- Ouais il me manquait l'idée que l'égalisation de l'analyse d'un non-vide de collecte pour la mise en correspondance des valeurs et renvoie la VALEUR Vrai ou Faux. Très déroutant surtout si la collection contient des chaînes vides. Si [array]$foo=@(""), si votre déclaration de travaux, mais l'inverse n'est pas: if($foo -ne $null) { "no" } else { "yes" } retourne "oui". Puisque la principale chose que je veux faire, c'est de tester pour ne PAS null (c'est à dire il y a des éléments à travailler sur), cela signifie que je dois utiliser if($foo -eq $null) { # Do nothing } else { #Do something }.
- Merci. J'ai été à essayer de comprendre pourquoi cela semblait de retour pas de réponse: $a = @(); $a -eq $null
- Dans PowerShell, $null doit être sur le côté gauche de la comparaison.
InformationsquelleAutor John Weldon
8

Si votre solution exige le retour de 0 au lieu de vrai/faux, j'ai trouvé ceci pour être utile:
```
PS C:\> [array]$foo = $null
PS C:\> ($foo | Measure-Object).Count
0
```
Cette opération est différente de la propriété count de la matrice, parce que Measure-Object est de compter les objets. Puisqu'il n'existe pas, il sera de retour 0.

InformationsquelleAutor Anthony Neace
3

Comment vous voulez que les choses se comporter?

Si vous voulez des tableaux avec des éléments à être traités de la même comme non affecté tableaux, utilisation:
```
[array]$foo = @() #example where we'd want TRUE to be returned
@($foo).Count -eq 0
```
Si vous voulez un tableau vide pour être considéré comme ayant une valeur (même vide), utilisation:
```
[array]$foo = @() #example where we'd want FALSE to be returned
$foo.PSObject -eq $null
```
Si vous voulez un tableau qui est rempli avec uniquement des valeurs nulles pour être considérée comme nulle:
```
[array]$foo = $null,$null
@($foo | ?{$_.PSObject}).Count -eq 0 
```
NB: Dans l'au-dessus-je utiliser $_.PSObject sur $_ pour éviter [bool]$false, [int]0, [string]'', etc filtrage; car ici nous sommes concentrés uniquement sur les valeurs null.
- Ceux-ci sont utiles réflexions sur la façon d'initialiser les tableaux pour les différents comportements, mais cela ne répond pas à la question initiale, "Quelle est la bonne façon de déterminer si un tableau est rempli vs $null?" Cela devrait peut-être être modifiée afin d'ajouter, "même si je ne sais pas comment le tableau est initialisé?"
InformationsquelleAutor JohnLBevan

Les autres réponses de l'adresse principale de la poussée de la question, mais juste pour faire un commentaire sur cette partie...

PS C:\> [array]$foo = @("bar")
PS C:\> $foo -eq $null
PS C:\>
Comment "-eq $null" donnent pas de résultats? C'est soit $null ou pas.

C'est déroutant au premier abord, mais qui est de vous donner le résultat de $foo -eq $null, c'est juste que le résultat n'a pas affichables représentation.

Depuis $foo est titulaire d'un tableau, $foo -eq $null signifie "retourner un tableau contenant les éléments de $foo qui sont égales à $null". Existe-il des éléments de $foo qui sont égales à $null? Non, donc $foo -eq $null doit retourner un tableau vide. C'est exactement ce qu'il fait, le problème est que quand un tableau vide est affichée sur la console à vous de voir...rien...

PS> @()
PS>

Le tableau est toujours là, même si vous ne pouvez pas voir l'un de ses éléments...

PS> @().GetType()

IsPublic IsSerial Name                                     BaseType
-------- -------- ----                                     --------
True     True     Object[]                                 System.Array


PS> @().Length
0

Nous pouvons utiliser des commandes similaires à confirmer que $foo -eq $null est renvoyant un tableau que nous ne sommes pas en mesure de "voir"...

PS> $foo -eq $null
PS> ($foo -eq $null).GetType()

IsPublic IsSerial Name                                     BaseType
-------- -------- ----                                     --------
True     True     Object[]                                 System.Array


PS> ($foo -eq $null).Length
0
PS> ($foo -eq $null).GetValue(0)
Exception calling "GetValue" with "1" argument(s): "Index was outside the bounds of the array."
At line:1 char:1
+ ($foo -eq $null).GetValue(0)
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    + CategoryInfo          : NotSpecified: (:) [], MethodInvocationException
    + FullyQualifiedErrorId : IndexOutOfRangeException

Remarque que je suis l'appel de la Array.GetValue méthode au lieu de l'utilisation de l'indexeur (c'est à dire ($foo -eq $null)[0]) parce que celle-ci retourne $null pour invalides indices et il n'y a aucun moyen de les distinguer à partir d'un index valide qui arrive à contenir $null.

Nous voyons un comportement similaire si nous les testons pour $null dans/contre un tableau qui contient $null éléments...

PS> $bar = @($null)
PS> $bar -eq $null
PS> ($bar -eq $null).GetType()

IsPublic IsSerial Name                                     BaseType
-------- -------- ----                                     --------
True     True     Object[]                                 System.Array


PS> ($bar -eq $null).Length
1
PS> ($bar -eq $null).GetValue(0)
PS> $null -eq ($bar -eq $null).GetValue(0)
True
PS> ($bar -eq $null).GetValue(0) -eq $null
True
PS> ($bar -eq $null).GetValue(1)
Exception calling "GetValue" with "1" argument(s): "Index was outside the bounds of the array."
At line:1 char:1
+ ($bar -eq $null).GetValue(1)
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    + CategoryInfo          : NotSpecified: (:) [], MethodInvocationException
    + FullyQualifiedErrorId : IndexOutOfRangeException

Dans ce cas, $bar -eq $null retourne un tableau contenant un élément, $null, qui n'a pas de représentation visuelle à la console...

PS> @($null)
PS> @($null).GetType()

IsPublic IsSerial Name                                     BaseType
-------- -------- ----                                     --------
True     True     Object[]                                 System.Array


PS> @($null).Length
1

Wow. Merci pour l'explication!

InformationsquelleAutor BACON

Vous devez vous connecter pour publier un commentaire.