Variables nulles dans PowerShell

1. Introduction à la variable Null dans PowerShell
2. Impacts de la variable Null dans PowerShell
3. Vérification des valeurs null dans PowerShell
4. Conclusion

PowerShell traite l’objet $Null avec la valeur null, et certaines commandes nécessitent une sortie pour générer. Elles génèrent la valeur null s’il y a une erreur et peuvent également être utiles dans le but de dépannage dans les scripts pour vérifier si la commande génère une valeur.

Cet article parle de la variable null, des impacts de l’utilisation de la variable null dans différentes syntaxes dans PowerShell, et des moyens de vérifier les valeurs null.

Introduction à la variable Null dans PowerShell

Nous pouvons penser à NULL comme une valeur inconnue ou vide. Par exemple, une variable est NULL jusqu’à ce que vous lui assigniez une valeur ou un objet.

Cette variable peut être importante parce que certaines commandes nécessitent une valeur et échoueront si la valeur est NULL.

La variable $null est une variable automatique dans PowerShell utilisée pour représenter NULL. Nous pouvons l’assigner à des variables, l’utiliser dans des comparaisons et l’utiliser comme un espace réservé pour NULL dans une collection.

PowerShell traite $null comme un objet avec la valeur NULL. Par conséquent, cette variable est différente de ce que vous pourriez attendre si vous venez d’un autre langage.

Impacts de la variable Null dans PowerShell

Le comportement des valeurs $null peut varier en fonction de l’endroit où elles apparaissent dans votre code. Explorons comment les variables NULL affectent différents aspects de la script PowerShell.

Impact sur les chaînes

Si vous utilisez $null dans une chaîne, cela sera une chaîne vide (ou une valeur blanche).

$value = $null
Write-Output "The value is $value."

Sortie :

The value is .

Pour maintenir la clarté dans vos scripts, il est conseillé de mettre les variables entre crochets ([]) lors de leur utilisation dans des messages de journal, surtout lorsque la valeur de la variable se trouve à la fin de la chaîne.

$value = $null
Write-Output "The value is [$value]"

Sortie :

The value is []

Cette pratique aide à distinguer les chaînes vides des valeurs $null.

Impact sur les équations numériques

Lorsqu’une variable $null est utilisée dans une équation numérique, nos résultats seront invalides s’ils ne produisent pas d’erreur. Parfois, la variable $null peut évaluer à 0, ou elle peut rendre tout le résultat $null.

Considérez cet exemple impliquant la multiplication, qui produit soit 0, soit $null en fonction de l’ordre des valeurs.

$null * 5
$null -eq ( $null * 5 )

Sortie :

True

Impact sur les collections

Une collection nous permet d’utiliser un index pour accéder aux valeurs. Si nous essayons d’indexer dans une collection null, nous obtiendrons cette erreur "Impossible d'indexer une tableau null".

$value = $null
$value[10]

Sortie :

Cannot index into a null array.
At line:2 char:1
+ $value[10]
+ ~~~~~~~~~~
    + CategoryInfo          : InvalidOperation: (:) [], RuntimeException
    + FullyQualifiedErrorId : NullArray

Cependant, si vous avez une collection et que vous essayez de récupérer un élément qui n’existe pas dans la collection, vous recevrez un résultat $null.

$array = @( 'one', 'two', 'three' )
$null -eq $array[100]

Sortie :

True

Impacts sur les objets

Si nous essayons d’accéder à une propriété ou une sous-propriété d’un objet sans propriété spécifiée, nous pouvons obtenir une variable $null comme vous le feriez pour une variable non définie. Peu importe si la valeur est $null ou un objet réel dans ce cas.

$null -eq $undefined.not.existing

Sortie :

True

Impacts sur les méthodes

Appeler une méthode sur une variable $null générera une exception RuntimeException.

$value = $null
$value.toString()

Sortie :

You cannot call a method on a null valued expression.
At line:2 char:1
+ $value.toString()
+ ~~~~~~~~~~~~~~~~~
    + CategoryInfo          : InvalidOperation: (:) [], RuntimeException
    + FullyQualifiedErrorId : InvokeMethodOnNull

Chaque fois que vous rencontrez la phrase "Vous ne pouvez pas appeler une méthode sur une expression ayant une valeur null", c’est un signal pour inspecter votre code pour voir où une méthode est appelée sur une variable sans d’abord vérifier les valeurs $null.

Vérification des valeurs null dans PowerShell

Utiliser les opérateurs de comparaison -eq et -ne pour vérifier les valeurs null dans PowerShell

Lors de la vérification des valeurs $null dans PowerShell, il est recommandé de placer la variable $null du côté gauche des comparaisons. Ce style d’écriture est non seulement intentionnel mais aussi accepté comme une bonne pratique de PowerShell.

Cependant, il existe des scénarios où placer $null du côté droit peut vous donner des résultats inattendus. Examinons le code suivant et essayons de prédire les résultats :

if ( $value -eq $null ) {
    'The array is $null'
}

if ( $value -ne $null ) {
    'The array is not $null'
}

Si nous ne définissons pas $value, le premier évaluera $true, et notre message sera Le tableau est $null. L’avertissement ici est qu’il est possible de créer une $value qui permettra à deux résultats d’être $false.

Sortie :

The array is $null

Dans ce cas, la variable $value est un tableau qui contient un $null.

L’opérateur -eq vérifie chaque valeur dans le tableau et retourne le $null correspondant, ce qui évalue à $false. De même, l’opérateur -ne retourne tout ce qui ne correspond pas à la valeur $null, résultant en aucune sortie (évaluant également à $false).

Par conséquent, aucune condition n’est $true, même si l’une d’elles pourrait être attendue.

Utiliser l’opérateur -not pour vérifier les valeurs null dans PowerShell

L’opérateur -not est un opérateur logique dans PowerShell qui nie une condition. Lorsqu’il est appliqué à une variable, il vérifie si la variable n’est pas null.

$myVariable = $null

if (-not $myVariable) {
    Write-Host "The variable is null."
}

Dans ce morceau de code, nous avons une variable $myVariable initialisée avec une valeur null. L’opérateur -not est utilisé dans la déclaration if pour vérifier si $myVariable n’est pas null.

Si la condition est vraie, le script exécutera le bloc de code à l’intérieur de l’instruction if.

Sortie :

The variable is null.

Comme démontré dans la sortie, le script identifie que $myVariable est null et imprime le message "La variable est null".

Utiliser la méthode IsNullOrEmpty() pour vérifier les valeurs null dans PowerShell

La méthode IsNullOrEmpty() est une méthode de la classe System.String, pas une méthode native de PowerShell. Différents types de données peuvent avoir différentes manières de vérifier les valeurs null ou vides.

Dans ce code, nous créons une variable appelée $myString et lui assignons la valeur $null, qui représente une chaîne null ou vide.

Nous utilisons la méthode [string]::IsNullOrEmpty($myString) pour vérifier si $myString est null ou vide. Cette méthode fait partie de la classe [string] dans le Framework .NET et est utilisée pour déterminer si une chaîne est soit null, soit une chaîne vide.

Si $myString est effectivement null ou vide, la condition est vraie et le script imprime "La chaîne est null ou vide.".

$myString = $null

if ([string]::IsNullOrEmpty($myString)) {
    Write-Host 'The string is null or empty.'
}

Sortie :

The string is null or empty.

Puisque $myString est assigné à la valeur $null, la condition est vraie et le message s’affiche dans la sortie.

Utiliser la méthode IsNullOrWhiteSpace() pour vérifier les valeurs null dans PowerShell

La méthode IsNullOrWhiteSpace() est une méthode utile disponible dans la classe System.String du Framework .NET, et vous pouvez l’utiliser dans PowerShell en l’appelant sur une variable chaîne.

Cette méthode vérifie si une chaîne est soit null, vide, ou ne contient que des caractères d’espaces. Elle est pratique lorsque vous voulez vérifier si une variable chaîne est effectivement vide, même si elle ne contient que des espaces ou des tabulations.

Dans le code ci-dessous, nous créons une variable appelée $myString et lui assignons une chaîne qui ne contient que des caractères d’espacement (espaces).

Ensuite, nous utilisons la méthode [string]::IsNullOrWhiteSpace($myString) pour vérifier si $myString est null ou ne contient que des espaces.

$myString = $null

if ([string]::IsNullOrWhiteSpace($myString)) {
    Write-Host 'The string is null or contains only whitespace.'
}

Sortie :

The string is null or contains only whitespace.

Puisque la condition est vraie ($myString est null), le script imprime "La chaîne est null ou ne contient que des espaces.".

Cette méthode est utile lorsque vous voulez vous assurer qu’une chaîne est réellement vide, même si elle semble être "blanche" à cause des espaces ou des tabulations.

Conclusion

Dans les scripts PowerShell, comprendre comment fonctionnent les variables $null est important car elles peuvent affecter le comportement de vos scripts dans différentes situations. Pour écrire des scripts fiables, c’est une bonne idée de suivre les meilleures pratiques, comme s’assurer de vérifier correctement les valeurs null en plaçant $null du côté gauche.

Que vous soyez nouveau dans la script ou que vous ayez de l’expérience, connaître ces détails vous aidera à mieux utiliser PowerShell.