Opérateur Like de PowerShell et plus encore : Améliorez vos compétences en script

Comme de nombreux autres langages de programmation, PowerShell dispose de différents opérateurs de comparaison. Cependant, contrairement à d’autres langages, ces opérateurs de comparaison peuvent sembler un peu étranges. Au lieu de ==, vous avez eq. Au lieu de <>, vous avez ne. Cela peut être déroutant pour les débutants. Jetons un coup d’œil à l’opérateur de comparaison PowerShell et à d’autres opérateurs de comparaison dans cet article.

Vérification de l’égalité avec les opérateurs eq et ceq

Pour vérifier si un objet est égal à un autre objet dans PowerShell, on utilise l’opérateur eq. L’opérateur eq compare des objets simples de nombreux types tels que des chaînes de caractères, des valeurs booléennes, des entiers, etc. Lorsqu’il est utilisé, l’opérateur eq renverra soit une valeur booléenne Vrai ou Faux en fonction du résultat.

L’opérateur -eq nécessite deux valeurs à comparer. Disons que vous attribuez une chaîne de caractères à une variable appelée $chaine. Vous souhaitez comparer la valeur de cette variable à la valeur de la chaîne "PowerShell" pour vous assurer qu’elles sont égales.

Dans l’exemple suivant, vous pouvez voir que nous attribuons la valeur PowerShell à la variable $string. Ensuite, en utilisant l’opérateur eq, l’exemple compare la valeur de $string avec la chaîne powershell. Assez simple, non ? Mais attends, ils ne sont pas vraiment les mêmes pourtant.

PS> $string = "PowerShell"
PS> $string -eq "powershell"
True

Notez que = est un opérateur d’attribution et NON un opérateur de comparaison. Vous ne pouvez pas utiliser = pour comparer une valeur à une autre en PowerShell.

Test de la sensibilité à la casse avec l’opérateur ceq

Dans l’exemple ci-dessus, remarquez comment eq a renvoyé une valeur booléenne True même lorsque la chaîne n’était pas la même. Ce comportement se produit car l’opérateur eq est insensible à la casse. Pour tester l’égalité sensible à la casse, utilisez l’opérateur ceq. L’opérateur ceq est exactement le même que eq à l’exception de sa sensibilité à la casse.

Vous pouvez voir un exemple d’utilisation de ceq dans l’extrait de code suivant. Remarquez maintenant la différence sensible à la casse que PowerShell voit.

PS> $string -ceq "PowerShell"
True 
PS> $string -ceq "powershell"
False

Test d’inégalité avec les opérateurs ne et cne

Tout comme eq et ceq testent l’égalité, PowerShell possède une paire d’opérateurs qui font exactement l’opposé appelés ne et cne. Comme leurs homologues, ces deux opérateurs effectuent exactement la même opération mais dans le sens inverse.

PS> $string = "PowerShell"
PS> $string -ne "PowerShell"
False
PS> $string -cne "PowerShell"
False
PS> $string -cne "powershell"
True

Test d’éléments dans une collection

Typiquement, les opérateurs eq et ceq sont utilisés pour des valeurs scalaires ou uniques comme des chaînes de caractères, des entiers et des valeurs booléennes. Mais ces opérateurs peuvent également trouver des occurrences de valeurs particulières contenues dans une collection comme un tableau.

Remarquez dans l’exemple ci-dessous que nous créons un tableau avec 12 entiers. Peut-être aimeriez-vous trouver toutes les occurrences dans ce tableau qui sont égales au nombre 9. Pas de problème, utilisez l’opérateur eq contre le tableau pour retourner toutes les instances de l’entier comparé.

PS> $array =@(1,2,3,4,5,6,7,8,9,9,9,9)
PS> $array -eq 9
9
9
9
9
PS> ($array -eq 9).Count
4

Test des collections pour contenir des valeurs

Depuis que vous venez d’apprendre à utiliser l’opérateur eq pour trouver des occurrences dans des tableaux, allons un peu plus loin et introduisons les opérateurs de « contenement ». Ces opérateurs sont contains, notcontains, in et notin. Ces opérateurs retournent une valeur booléenne True ou False si une collection contient une instance ou non.

Jetez un coup d’œil à l’exemple suivant. Dans cet exemple, nous créons un tableau avec neuf entiers. Si vous voulez une réponse simple Oui/Non pour savoir si ce tableau contient un certain entier, vous pouvez l’obtenir en utilisant contains ou notcontains.

PS> $array = @(2,4,5,6,8,8,9,9,9)
PS> $array -contains 9
True
PS> $array -notcontains 9
False
PS> $array -contains 5

De même, vous avez les opérateurs in et notin. Ces opérateurs sont presque identiques à contains et notcontains avec une exception : la valeur à comparer est à gauche au lieu de la droite.

$array = @(2,4,5,6,8,8,9,9,9)
9 -in $array
True
9 -notin $array
False

Test de « Supérieur à » Avec les opérateurs gt et ge

Que se passe-t-il si vous devez tester si un nombre (un entier) est supérieur à un autre nombre ou peut-être supérieur ou égal à un autre nombre ? Vous utiliserez les opérateurs gt et ge. Ces opérateurs comparent des entiers.

Comme les autres opérateurs, ceux-ci renvoient des valeurs booléennes Vrai ou Faux selon que l’entier de gauche est supérieur à l’entier de droite. Ces deux opérateurs testent si l’entier de gauche est supérieur ou supérieur ou égal à l’entier de droite.

Dans l’exemple ci-dessous, vous pouvez voir comment chacun de ces opérateurs se comporte.

PS> 7 -gt 5
True
PS> 7 -gt 7
False
PS> 7 -ge 7
True

Similaire à l’opérateur eq qui vous permet de trouver des instances dans des collections, vous pouvez faire de même avec les opérateurs ge et gt. PowerShell parcourt chaque élément d’une collection et compare chaque valeur à celle que vous avez fournie. Vous pouvez voir un excellent exemple de cela ci-dessous.

PS> $array =@(1,2,3,4,5,6,7,8,9,9,9,9)
PS> $array -gt 5
6
7
8
9
9
9
9
PS> $array -ge 5
5
6
7
8
9
9
9
9

Test de « inférieur à » avec les opérateurs lt et le

Similairement aux opérateurs gt et ge, les opérateurs lt et le effectuent la même fonction mais à l’inverse. Les opérateurs lt et le comparent deux valeurs en testant si l’entier du côté gauche est inférieur ou inférieur ou égal à l’entier du côté droit.

Vous pouvez voir dans l’exemple ci-dessous que la même fonctionnalité de comparaison de chaque valeur dans une collection s’applique exactement de la même manière qu’avec gt et ge.

PS> $array =@(1,2,3,4,5,6,7,8,9,10)
PS> $array -lt 5
1
2
3
4
PS> $array -le 5 
1
2
3
4
5

Correspondance basée sur les jokers avec l’opérateur Like de PowerShell

Jusqu’à présent, vous avez appris comment effectuer des correspondances 1:1. Tous les opérateurs utilisés jusqu’à présent comparaient une valeur entière à une autre, mais PowerShell a une autre astuce dans sa manche. Vous pouvez également comparer des valeurs en fonction de jokers ou d’astérisques.

Disons que vous ne connaissez que quelques caractères d’une chaîne. Vous ne pouvez pas utiliser eq car eq vous oblige à connaître la chaîne entière. En utilisant l’opérateur like de PowerShell, vous n’avez pas besoin de connaître la chaîne entière. Pour tester si une valeur est like une autre, vous pouvez remplacer la partie que vous ne connaissez pas par un joker.

Comme avec d’autres opérateurs, cette fonctionnalité peut également être appliquée aux collections.

Vous pouvez voir un exemple de l’opérateur like de PowerShell et de son homologue sensible à la casse, clike, ci-dessous.

PS> $string = "PowerShell"
PS> $string -like "*Shell"
True
PS> $array = @("PowerShell","Microsoft")
PS> $array -like "*Shell"
PowerShell
PS> $array -clike "*Shell"
PowerShell

L’opérateur -notlike renvoie le booléen True s’il n’y a pas de correspondance et False s’il y a une correspondance. En cas d’utilisation contre une collection, il renverra toutes les autres valeurs qui ne correspondent pas au motif donné du côté droit de l’opérateur -notlike. Pour ajouter la sensibilité à la casse au motif, utilisez l’opérateur -cnotlike.

$string = "PowerShell" 
$string -notlike "*Shell"
False
$array = @("PowerShell","Microsoft")
$array -notlike "*Shell"
Microsoft
$array -cnotlike "*shell"
PowerShell
Microsoft

Correspondance basée sur les expressions régulières

Le PowerShell, tout comme son opérateur similaire et ses homologues, est pratique, mais dès que vous avez besoin de correspondances plus complexes, vous pouvez plonger dans le monde profond et sombre des expressions régulières (regex). En utilisant les opérateurs match et notmatch, vous pouvez effectuer des correspondances de chaînes extrêmement complexes avec les regex.

Similaire à l’opérateur like de PowerShell, l’opérateur match et son homologue opposé, notmatch, comparent deux chaînes et renvoient une valeur booléenne True ou False. De plus, comme les autres opérateurs, le même comportement peut être appliqué à une collection, comme le montre l’exemple ci-dessous.

PS> $string = "PowerShell"
PS> $string -match "ow"
True 

PS> $array = @("PowerShell","Microsoft")
PS> $array -match "ow"
PowerShell

PS> $string = "PowerShell"
PS> $string -cmatch "po"
False
PS> $string -cmatch "Po"
True

PS> $array = @("PowerShell","Microsoft")
PS> $array -cmatch "Po"
PowerShell

Résumé

Dans cet article, vous avez appris sur l’opérateur like de PowerShell et bien d’autres, et comment utiliser chaque opérateur pour les valeurs individuelles et les collections. Vous avez vu comment la sortie diffère en fonction de l’opérateur et qu’il s’agisse d’un scalaire ou d’une collection.

De plus, vous avez également découvert des opérateurs avec une sensibilité à la casse, des opérateurs de correspondance pour faire correspondre en fonction d’une expression régulière ou d’un joker, et des opérateurs de containment pour tester si l’objet contient une valeur spécifique ou si une valeur existe dans un objet spécifique.

PowerShell Like

Source:
https://adamtheautomator.com/powershell-like/