Powershell: Tout ce que vous vouliez savoir sur L’instruction IF

les Variations:

• -like casse générique
• -ilike casse générique
• -clike casse
• -notlike casse génériques pas de correspondance
• -inotlike casse génériques pas de correspondance
• -cnotlike casse pas de correspondance

-correspondance d’expression régulière

Le -match opérateur permet de vérifier une chaîne pour une expression régulière en fonction de correspondance., Utilisez-le lorsque les motifs génériques ne sont pas assez flexibles pour vous.

 $value = 'S-ATX-SQL01' if ( $value -match 'S-\w\w\w-SQL\d\d') { # do something }

Une expression régulière pattern match de n’importe où dans la chaîne de caractères par défaut. Vous pouvez donc spécifier une sous-chaîne que vous souhaitez apparier comme ceci:

 $value = 'S-ATX-SQL01' if ( $value -match 'SQL') { # do something }

Regex est un langage complexe qui lui est propre et qui mérite d’être examiné. Je parle plus de -match et des nombreuses façons d’utiliser regex dans un autre article.,

Variations:

• -match case insensitive regex
• -imatch case insensitive regex
• -cmatch case sensitive regex
• -notmatch case insensitive regex not matched
• -inotmatch case insensitive regex not matched
• -cnotmatch case sensitive regex not matched

-is of type

You are able to check a value’s type with the -is operator.,

 if ( $value -is ) { # do something }

Vous pouvez utiliser cette option si vous travaillez avec des classes ou d’accepter des objets divers sur le gazoduc. Vous pouvez avoir un service ou un nom de service comme entrée. Vérifiez ensuite si vous avez un service et récupérez le service si vous n’avez que le nom.,

 if ( $Service -isnot ) { $Service = Get-Service -Name $Service }

les Variations:

• -is type
• -isnot de type

Collection les opérateurs

Lorsque vous utilisez les opérateurs précédents, avec une seule valeur, le résultat est: $true ou $false. Ceci est géré légèrement différemment lorsque vous travaillez avec une collection. Chaque élément de la collection est évalué et l’opérateur retournera à la place chaque valeur évaluée à $true.,

 PS> 1,2,3,4 -eq 3 3

Cela fonctionne encore correctement dans un if déclaration. Donc, une valeur est renvoyée par votre opérateur, alors l’instruction entière est $true.

 $array = 1..6 if ( $array -gt 3 ) { # do something }

Il y a un petit piège se cachant dans les détails ici que je dois le souligner. Lorsque vous utilisez l’opérateur -ne de cette façon, il est facile de regarder à tort la logique à l’envers., L’utilisation de -ne avec une collection renverra $true si un élément de la collection ne correspond pas à votre valeur.

 PS> 1,2,3 -ne 4 1 2 3

Cela peut ressembler à une astuce, mais nous avons opérateurs -contains et -in qui gèrent plus efficacement et -notcontains va faire correctement ce que vous attendez.

-contient

Le -contains opérateur de vérifier le prélèvement de votre valeur., Dès qu’il trouve une correspondance, il renvoie $true.

 $array = 1..6 if ( $array -contains 3 ) { # do something }

C’est la meilleure façon de voir si la collection contient votre valeur. L’utilisation de Where-Object ( ou -eq) parcourra la liste entière à chaque fois et sera considérablement plus lente.,

les Variations:

• -contains casse match
• -icontains casse match
• -ccontains casse match
• -notcontains casse pas de correspondance
• -inotcontains casse pas de correspondance
• -cnotcontains casse pas de correspondance

en

Le -in opérateur est comme la balise -contains opérateur à l’exception de la collection est sur le côté droit.,

 $array = 1..6 if ( 3 -in $array ) { # do something }

Variations:

• -in case insensitive match
• -iin case insensitive match
• -cin case sensitive match
• -notin case insensitive not matched
• -inotin case insensitive not matched
• -cnotin case sensitive not matched

Logical operators

Logical operators are used to invert or combine other expressions.,

-non

Le -not opérateur retourne une expression de $false de $true ou de $true de $false. Voici un exemple où nous voulons effectuer une action lorsque Test-Path est $false.

 if ( -not ( Test-Path -Path $path ) )

la Plupart des opérateurs, nous avons parlé de faire avoir une variation où vous n’auriez pas besoin d’utiliser la balise -not opérateur, mais il ya encore des moments que vous pouvez l’utiliser.

!,

Vous pouvez utiliser ! comme un alias pour -not.

 if ( -not $value ){} if ( !$value ){}

Vous allez voir ! utilisé plus par des gens qui viennent d’un autre langages tels que le C#. Je préfère le taper parce que j’ai du mal à voir en regardant rapidement mes scripts.

et

Vous pouvez combiner les expressions avec le -and opérateur. Lorsque vous faites cela, les deux parties doivent être $true pour l’ensemble de l’expression $true.,

 if ( ($age -gt 13) -and ($age -lt 55) )

Dans cet exemple, la balise $age doit être de 13 ans ou plus pour le côté gauche et à moins de 55 pour le côté droit. J’ai ajouté des parenthèses supplémentaires pour le rendre plus clair dans cet exemple, mais elles sont facultatives tant que l’expression est simple. Voici le même exemple sans eux.

 if ( $age -gt 13 -and $age -lt 55 )

Évaluation s’effectue de gauche à droite. Si le premier élément est évalué à $false, il se quittera plus tôt et n’effectuera pas la bonne comparaison., C’est pratique lorsque vous devez vous assurer qu’une valeur existe avant de l’utiliser. Test-Path par exemple, provoquera une erreur si vous lui donnez un $null chemin d’accès.

 if ( $null -ne $path -and (Test-Path -Path $path) )

ou

Le -or permet de spécifier deux expressions et retourne $true si l’un d’eux est $true.

 if ( $age -le 13 -or $age -ge 55 )

tout comme avec la balise -and opérateur, l’évaluation s’effectue de gauche à droite., Sauf que, si la première partie est $true, alors l’ensemble de l’énoncé est: $true et il ne traitera pas le reste de l’expression.

notez également comment la syntaxe fonctionne pour ces opérateurs. Vous avez besoin de deux expressions distinctes. J’ai vu des utilisateurs essayer de faire quelque chose comme ceci $value -eq 5 -or 6 sans se rendre compte de leur erreur.

-ou exclusif xor

celui-ci est un peu inhabituel. -xor ne permet qu’une expression à évaluer de $true., Donc, si les deux éléments sont $false ou les deux éléments sont $true, l’expression complète est: $false. Une autre façon de voir cela est l’expression n’est $true lorsque les résultats de l’expression sont différents.

Il est rare que quelqu’un utilise cet opérateur logique et je ne peux pas trouver un bon exemple pour expliquer pourquoi je l’utiliserais.

opérateurs bit à bit

Les opérateurs bit à bit effectuent des calculs sur les bits dans les valeurs et produisent une nouvelle valeur comme résultat., L’enseignement des opérateurs bit à bit dépasse le cadre de cet article, mais voici la liste les.

• -band binaire ET
• -bor binaire OU
• -bxor OU exclusif binaire
• -bnot binaire NON
• -shl maj gauche
• -shr décalage à droite

PowerShell expressions

Nous pouvons normal d’utilisation de PowerShell à l’intérieur de l’état.,

 if ( Test-Path -Path $Path )

Test-Path renvoie $true ou $false lorsqu’il exécute. Cela s’applique également aux commandes qui renvoient d’autres valeurs.

 if ( Get-Process Notepad* )

Elle permettra d’évaluer de $true si il est retourné processus et $false si il n’y a rien., Il est parfaitement valide d’utiliser des expressions de pipeline ou d’autres instructions PowerShell comme celle-ci:

 if ( Get-Process | Where Name -eq Notepad )

ces expressions peuvent être combinées entre elles avec les opérateurs -and Et -or, mais vous utiliser des parenthèses pour les diviser en sous-expressions.

 if ( (Get-Process) -and (Get-Service) )

la Vérification de $null

Ayant un pas de résultat ou un $null valeur prend la valeur $false dans le if déclaration., Lors de la vérification spécifiquement pour les $null, il est recommandé de placer la balise $null sur le côté gauche.

 if ( $null -eq $value )

Il y a assez peu de nuances lorsque l’on traite avec des $null valeurs dans PowerShell. Si vous êtes intéressé à plonger plus profondément, j’ai un article sur tout ce que vous vouliez savoir sur null null.

affectation de Variable

j’ai presque oublié d’ajouter celui-ci jusqu’à ce que Prasoon Karunan V me le rappelle.,

Normalement, lorsque vous affectez une valeur à une variable, la valeur n’est pas passée sur le pipeline ou d’une console. Lorsque vous effectuez une affectation de variable dans une sous-expression, elle est transmise au pipeline.

 PS> $first = 1 PS> ($second = 2) 2

Voir la façon dont le $first cession a pas de sortie et le $second cession n’? Lorsqu’une affectation est effectuée dans une instructionif, elle s’exécute comme l’affectation$second ci-dessus., Voici un exemple propre sur comment vous pourriez l’utiliser:

 if ( $process = Get-Process Notepad* ) { $process | Stop-Process }

Si $process est affectée d’une valeur, puis la déclaration sera $true et le $process va être arrêté.

assurez-vous de ne pas confondre cela avec-eq car ce n’est pas une vérification d’égalité. C’est une caractéristique plus obscure que la plupart des gens ne réalisent pas fonctionne de cette façon.,

Suppléant chemin d’exécution

Le if instruction permet de définir une action pour non seulement lorsque l’instruction est $true, mais aussi lorsqu’il est $false. C’est là que l’instruction else entre en jeu.

else

Le else instruction est toujours la dernière partie de la if déclaration lors de son utilisation.

dans cet exemple, nous vérifions le $path pour nous assurer qu’il s’agit d’un fichier. Si nous trouvons le fichier, nous le déplaçons. Si non, nous allons écrire un avertissement., Ce type de logique de branchement est très commun.

imbriqué si

les instructionsif Etelse prennent un bloc de script, nous pouvons donc y placer n’importe quelle commande PowerShell, y compris une autre instructionif. Cela vous permet d’utiliser une logique beaucoup plus compliquée.

dans cet exemple, nous testons d’abord le chemin heureux, puis nous agissons dessus. Si cela échoue, nous effectuons une autre vérification et fournissons des informations plus détaillées à l’utilisateur.

elseif

Nous ne sommes pas limités à un seul contrôle conditionnel., Nous pouvons enchaîner les instructionsif etelse au lieu de les imbriquer en utilisant l’instructionelseif.

l’exécution se fait de haut en bas. L’instruction top if est évaluée en premier. Si c’est $false, puis il se déplace vers le bas à la prochaine elseif ou else dans la liste. Ce dernier else est la valeur par défaut si aucun des autres de retour $true.,

switch

Au Point tis, je dois mentionner l’instructionswitch. Il fournit une syntaxe alternative pour effectuer plusieurs comparaisons avec une valeur. Avec switch, vous spécifiez une expression et ce résultat est comparé à plusieurs valeurs différentes. Si l’une de ces valeurs mach, le bloc de code correspondant est exécuté. Jetez un oeil à cet exemple:

 $itemType = 'Role' switch ( $itemType ) { 'Component' { 'is a component' } 'Role' { 'is a role' } 'Location' { 'is a location' } }

Il y a trois valeurs possibles qui peuvent correspondre à la balise $itemType., Dans ce cas, il correspondra avec des Role et le is a role serait exécuté. J’ai utilisé un exemple très simple juste pour vous donner une certaine exposition à l’opérateur switch. Je parle plus de tout ce que vous avez toujours voulu savoir sur la déclaration switch dans un autre article.

Pipeline

le pipeline est une caractéristique unique et importante de PowerShell. Toute valeur qui n’est pas supprimée ou affectée à une variable est placée dans le pipeline., Le if nous fournit un moyen de tirer parti du pipeline d’une manière qui n’est pas toujours évidente.

 $discount = if ( $age -ge 55 ) { Get-SeniorDiscount } elseif ( $age -le 13 ) { Get-ChildDiscount } else { 0.00 }

Chaque bloc de script est à placer les résultats des commandes ou de la valeur dans le pipeline. Ensuite, nous affectons le résultat de l’instruction if à la variable $discount. Cet exemple aurait pu tout aussi facilement affecter ces valeurs à la variable $discount directement dans chaque scriptblock., Je ne peux pas dire que je l’utilise très souvent avec l’instruction if, mais j’ai un exemple où je l’ai utilisé récemment.

tableau en ligne

j’ai une fonction appelée Invoke-SnowSql qui lance un exécutable avec plusieurs arguments de ligne de commande. Voici un clip de cette fonction où je construis le tableau d’arguments.

Le $Debug et $Path variables sont les paramètres de la fonction sont fournies par l’utilisateur final. Je les évalue en ligne dans l’initialisation de mon tableau., Si $Debug est vrai, alors ces valeurs tombent dans le $snowSqlParam au bon endroit. Il en va de même pour la variable $Path.

simplifiez les opérations complexes

Il est inévitable que vous rencontriez une situation qui a beaucoup trop de comparaisons à vérifier et votre instruction if défile sur le côté droit de l’écran.

ils peuvent être difficiles à lire et vous rendre plus enclin à faire des erreurs. Il ya quelques choses que nous pouvons faire à ce sujet.,

continuation de la ligne

Il y a des opérateurs dans PowerShell qui vous permettent d’envelopper votre commande à la ligne suivante. Les opérateurs logiques -and et -or sont de bons opérateurs à utiliser si vous souhaitez rompre votre expression en plusieurs lignes.

il se passe encore beaucoup de choses, mais placer chaque pièce sur sa propre ligne fait une grande différence. Je ne le fais généralement que lorsque j’obtiens plus de deux comparaisons ou si je dois faire défiler vers la droite pour lire l’un des ligiques.,

Pré-calcul des résultats

Nous pouvons prendre cette déclaration de l’instruction si et seulement vérifier le résultat.

cela semble juste beaucoup plus propre que l’exemple précédent. Vous avez également la possibilité d’utiliser un nom de variable qui explique ce que vous vérifiez vraiment. C’est aussi un exemple de code auto-documenté qui enregistre les commentaires inutiles.

plusieurs instructions if

Nous pouvons diviser cela en plusieurs instructions et les vérifier une à la fois. Dans ce cas, nous utiliserons un indicateur ou une variable de suivi pour combiner les résultats.,

j’ai dû inverser la logique pour que la logique de drapeau fonctionne correctement. Chaque évaluation est une instruction individuelle if. L’avantage de ceci est que lorsque vous déboguez, vous pouvez dire exactement ce que fait la logique. J’ai pu ajouter une beaucoup meilleure verbosité en même temps.

l’inconvénient évident est qu’il est tellement plus de code à écrire. Le code est plus complexe à regarder qu’une seule ligne, de la logique et explose en 25 lignes ou plus.

en utilisant des fonctions

Nous pouvons également déplacer toute cette logique de validation dans une fonction., Regardez à quel point cela semble propre en un coup d’œil.

 if ( Test-SecureDriveConfiguration -ADUser $user ) { # do something }

Vous avez encore créer la fonction pour procéder à la validation, mais il fait ce code beaucoup plus facile de travailler avec. Cela rend ce code plus facile à tester. Dans vos tests, vous pouvez simuler l’appel à Test-ADDriveConfiguration et vous n’avez besoin que de deux tests pour cette fonction. L’une où il renvoie $true et un autre où il retourne $false. Tester l’autre fonction sera plus simple car elle est si petite.,

le corps de cette fonction pourrait toujours être celui avec lequel nous avons commencé ou la logique éclatée que nous avons utilisée dans la dernière section. Cela fonctionne bien pour les deux scénarios et vous permet de modifier facilement cette implémentation plus tard.

gestion des erreurs

Une utilisation très importante de l’instructionif consiste à vérifier les conditions d’erreur avant de rencontrer des erreurs. Un bon exemple est de vérifier si un dossier existe déjà avant d’essayer de le créer.,

 if ( -not (Test-Path -Path $folder) ) { New-Item -Type Directory -Path $folder }

je tiens à dire que si vous vous attendez à une exception arriver, ce n’est pas vraiment une exception. Vérifiez donc vos valeurs et validez vos conditions où vous le pouvez.

Si vous voulez plonger un peu plus dans la gestion réelle des exceptions, j’ai un article sur tout ce que vous avez toujours voulu savoir sur les exceptions.

derniers mots

Le if déclaration est une déclaration simple mais est très fondamentale morceau de PowerShell. Vous vous retrouverez à l’utiliser plusieurs fois dans presque tous les scripts que vous écrivez., J’espère que vous avez une meilleure compréhension que vous aviez avant.