about_Comparison_Operators

Description courte

Les opérateurs de comparaison dans PowerShell peuvent comparer deux valeurs ou filtrer des éléments d’une collection par rapport à une valeur d’entrée.

Description longue

Les opérateurs de comparaison vous permettent de comparer des valeurs ou de rechercher des valeurs qui correspondent à des modèles spécifiés. PowerShell inclut les opérateurs de comparaison suivants :

Égalité

  • -eq, -ieq, -ceq - est égal à
  • -ne, -ine, -cne - n’est pas égal à
  • -gt, -igt, -cgt - supérieur à
  • -ge, -ige, -cge - supérieur ou égal à
  • -lt, -ilt, -clt - inférieur à
  • -le, -ile, -cle - inférieur ou égal à

Matching

  • -like, -ilike- -clike chaîne correspond au modèle générique
  • -notlike, -inotlike, -cnotlike - la chaîne ne correspond pas au modèle générique
  • -match, -imatch, -cmatch - chaîne correspond au modèle regex
  • -notmatch, -inotmatch- -cnotmatch chaîne ne correspond pas au modèle regex

Remplacement

  • -replace, -ireplace, -creplace - remplace les chaînes correspondant à un modèle regex

Containment

  • -contains, -icontains- -ccontains collection contient une valeur
  • -notcontains, -inotcontains, -cnotcontains - la collection ne contient pas de valeur
  • -in - la valeur se trouve dans une collection
  • -notin - la valeur n’est pas dans une collection

Type

  • -is - les deux objets sont du même type
  • -isnot - les objets ne sont pas du même type

Fonctionnalités communes

Les comparaisons de chaînes ne respectent pas la casse, sauf si vous utilisez l’opérateur explicite respectant la casse. Pour qu’un opérateur de comparaison respecte la casse, ajoutez un c après le -. Par exemple, -ceq est la version respectant la casse de -eq. Pour rendre l’insensibilité à la casse explicite, ajoutez un i après -. Par exemple, -ieq est la version explicitement insensible à la casse de -eq.

Lorsque l’entrée d’un opérateur est une valeur scalaire, l’opérateur retourne une valeur booléenne . Lorsque l’entrée est une collection, l’opérateur retourne les éléments de la collection qui correspondent à la valeur de droite de l’expression. S’il n’y a aucune correspondance dans la collection, les opérateurs de comparaison retournent un tableau vide. Par exemple :

$a = (1, 2) -eq 3
$a.GetType().Name
$a.Count
Object[]
0

Il existe quelques exceptions :

  • Les opérateurs de confinement et de type retournent toujours une valeur booléenne
  • L’opérateur -replace retourne le résultat de remplacement
  • Les -match opérateurs et -notmatch remplissent également la $Matches variable automatique, sauf si le côté gauche de l’expression est une collection.

Opérateurs d’égalité

-eq et -ne

Lorsque le côté gauche est scalaire, -eq retourne True si le côté droit correspond exactement, sinon, -eq retourne False. -ne fait le contraire; il retourne False lorsque les deux côtés correspondent ; dans le cas contraire, -ne retourne true.

Exemple :

2 -eq 2                 # Output: True
2 -eq 3                 # Output: False
"abc" -eq "abc"         # Output: True
"abc" -eq "abc", "def"  # Output: False
"abc" -ne "def"         # Output: True
"abc" -ne "abc"         # Output: False
"abc" -ne "abc", "def"  # Output: True

Lorsque le côté gauche est une collection, -eq retourne les membres qui correspondent au côté droit, tout en -ne les filtre.

Exemple :

1,2,3 -eq 2             # Output: 2
"abc", "def" -eq "abc"  # Output: abc
"abc", "def" -ne "abc"  # Output: def

Ces opérateurs traitent tous les éléments de la collection. Exemple :

"zzz", "def", "zzz" -eq "zzz"
zzz
zzz

L’opérateur d’égalité peut comparer des objets de différents types. Il est important de comprendre que la valeur se trouve sur le côté droit de la comparaison peut être convertie en type de la valeur de gauche à des fins de comparaison.

Par exemple, la chaîne '1.0' est convertie en entier à comparer à la valeur 1. Cet exemple retourne True.

PS> 1 -eq '1.0'
True

Dans cet exemple, la valeur 1 est convertie en chaîne à comparer à la chaîne '1.0'. Cet exemple retourne False.

PS> '1.0' -eq 1
False

Les opérateurs d’égalité acceptent deux objets, pas seulement un scalaire ou une collection. Toutefois, le résultat de la comparaison n’est pas garanti pour être significatif pour l’utilisateur final. L’exemple suivant illustre le problème.

class MyFileInfoSet {
    [String]$File
    [Int64]$Size
}
$a = [MyFileInfoSet]@{File = "C:\Windows\explorer.exe"; Size = 4651032}
$b = [MyFileInfoSet]@{File = "C:\Windows\explorer.exe"; Size = 4651032}
$a -eq $b
False

Dans cet exemple, nous avons créé deux objets avec des propriétés identiques. Pourtant, le résultat du test d’égalité est False , car il s’agit d’objets différents. Pour créer des classes comparables, vous devez implémenter System.IEquatable<T> dans votre classe. L’exemple suivant illustre l’implémentation partielle d’une classe MyFileInfoSet qui implémente System.IEquatable<T> et possède deux propriétés, File et Size. La Equals() méthode retourne True si les propriétés File et Size de deux objets MyFileInfoSet sont identiques.

class MyFileInfoSet : System.IEquatable[Object] {
    [String]$File
    [Int64]$Size

    [bool] Equals([Object] $obj) {
        return ($this.File -eq $obj.File) -and ($this.Size -eq $obj.Size)
    }
}
$a = [MyFileInfoSet]@{File = "C:\Windows\explorer.exe"; Size = 4651032}
$b = [MyFileInfoSet]@{File = "C:\Windows\explorer.exe"; Size = 4651032}
$a -eq $b
True

Un exemple important de comparaison d’objets arbitraires consiste à déterminer s’ils sont null. Toutefois, si vous devez déterminer si une variable est $null, vous devez placer $null sur le côté gauche de l’opérateur d’égalité. Le placer sur le côté droit ne fait pas ce que vous attendez.

Par exemple, soit $a un tableau contenant des éléments null :

$a = 1, 2, $null, 4, $null, 6

Les tests suivants qui $a n’ont pas la valeur Null.

$null -ne $a
True

Toutefois, les éléments suivants permettent d’extraire tous les éléments null à partir de $a:

$a -ne $null # Output: 1, 2, 4, 6
1
2
4
6

-gt, -ge, -lt et -le

-gt, -ge, -ltet -le se comportent de la même manière. Lorsque les deux côtés sont scalaires, ils retournent True ou False en fonction de la façon dont les deux côtés se comparent :

Opérateur Retourne la valeur True lorsque...
-gt Le côté gauche est plus grand
-ge Le côté gauche est supérieur ou égal
-lt Le côté gauche est plus petit
-le Le côté gauche est plus petit ou égal

Dans les exemples suivants, toutes les instructions retournent true.

8 -gt 6  # Output: True
8 -ge 8  # Output: True
6 -lt 8  # Output: True
8 -le 8  # Output: True

Notes

Dans la plupart des langages de programmation, l’opérateur supérieur à est >. Dans PowerShell, ce caractère est utilisé pour la redirection. Pour plus d’informations, consultez about_Redirection.

Lorsque le côté gauche est une collection, ces opérateurs comparent chaque membre de la collection avec le côté droit. Selon leur logique, ils conservent ou ignorent le membre.

Exemple :

$a=5, 6, 7, 8, 9

Write-Output "Test collection:"
$a

Write-Output "`nMembers greater than 7"
$a -gt 7

Write-Output "`nMembers greater than or equal to 7"
$a -ge 7

Write-Output "`nMembers smaller than 7"
$a -lt 7

Write-Output "`nMembers smaller than or equal to 7"
$a -le 7
Test collection:
5
6
7
8
9

Members greater than 7
8
9

Members greater than or equal to 7
7
8
9

Members smaller than 7
5
6

Members smaller than or equal to 7
5
6
7

Ces opérateurs fonctionnent avec n’importe quelle classe qui implémente System.IComparable.

Exemples :

# Date comparison
[DateTime]'2001-11-12' -lt [DateTime]'2020-08-01' # True

# Sorting order comparison
'a' -lt 'z'           # True; 'a' comes before 'z'
'macOS' -ilt 'MacOS'  # False
'MacOS' -ilt 'macOS'  # False
'macOS' -clt 'MacOS'  # True; 'm' comes before 'M'

L’exemple suivant montre qu’il n’existe aucun symbole sur un clavier QWERTY américain trié après « a ». Il alimente un ensemble contenant tous ces symboles à l’opérateur -gt pour les comparer à 'a'. La sortie est un tableau vide.

$a=' ','`','~','!','@','#','$','%','^','&','*','(',')','_','+','-','=',
   '{','}','[',']',':',';','"','''','\','|','/','?','.','>',',','<'
$a -gt 'a'
# Output: Nothing

Si les deux côtés des opérateurs ne sont pas raisonnablement comparables, ces opérateurs déclenchent une erreur de non-fin.

Opérateurs de correspondance

Les opérateurs correspondants (-like, , -notlike-matchet -notmatch) recherchent les éléments qui correspondent ou ne correspondent pas à un modèle spécifié. Le modèle pour -like et -notlike est une expression générique (contenant *, ?et [ ]), tandis que -match et -notmatch accepte une expression régulière (Regex).

La syntaxe est :

<string[]> -like    <wildcard-expression>
<string[]> -notlike <wildcard-expression>
<string[]> -match    <regular-expression>
<string[]> -notmatch <regular-expression>

Lorsque l’entrée de ces opérateurs est une valeur scalaire, ils retournent une valeur booléenne . Lorsque l’entrée est une collection de valeurs, les opérateurs retournent les membres correspondants. S’il n’y a aucune correspondance dans une collection, les opérateurs retournent un tableau vide.

-like et -notlike

-like et -notlike se comportent de la même façon que -eq et -ne, mais le côté droit peut être une chaîne contenant des caractères génériques.

Exemple :

"PowerShell" -like    "*shell"           # Output: True
"PowerShell" -notlike "*shell"           # Output: False
"PowerShell" -like    "Power?hell"       # Output: True
"PowerShell" -notlike "Power?hell"       # Output: False
"PowerShell" -like    "Power[p-w]hell"   # Output: True
"PowerShell" -notlike "Power[p-w]hell"   # Output: False

"PowerShell", "Server" -like "*shell"    # Output: PowerShell
"PowerShell", "Server" -notlike "*shell" # Output: Server

-match et -notmatch

-match et -notmatch utilisez des expressions régulières pour rechercher un modèle dans les valeurs de gauche. Les expressions régulières peuvent correspondre à des modèles complexes tels que des adresses e-mail, des chemins UNC ou des numéros de téléphone mis en forme. La chaîne de droite doit respecter les règles d’expressions régulières .

Exemples scalaires :

# Partial match test, showing how differently -match and -like behave
"PowerShell" -match 'shell'        # Output: True
"PowerShell" -like  'shell'        # Output: False

# Regex syntax test
"PowerShell" -match    '^Power\w+' # Output: True
'bag'        -notmatch 'b[iou]g'   # Output: True

Si l’entrée est une collection, les opérateurs retournent les membres correspondants de cette collection.

Exemples de collection :

"PowerShell", "Super PowerShell", "Power's hell" -match '^Power\w+'
# Output: PowerShell

"Rhell", "Chell", "Mel", "Smell", "Shell" -match "hell"
# Output: Rhell, Chell, Shell

"Bag", "Beg", "Big", "Bog", "Bug"  -match 'b[iou]g'
#Output: Big, Bog, Bug

"Bag", "Beg", "Big", "Bog", "Bug"  -notmatch 'b[iou]g'
#Output: Bag, Beg

-match et -notmatch prennent en charge les groupes de capture regex. Chaque fois qu’ils s’exécutent sur une entrée scalaire et que le -match résultat est True ou que le -notmatch résultat est False, ils remplacent la $Matches variable automatique. $Matches est une table de hachage qui a toujours une clé nommée « 0 », qui stocke l’intégralité de la correspondance. Si l’expression régulière contient des groupes de capture, contient des $Matches clés supplémentaires pour chaque groupe.

Il est important de noter que la $Matches table de hachage contient uniquement la première occurrence d’un modèle de correspondance.

Exemple :

$string = 'The last logged on user was CONTOSO\jsmith'
$string -match 'was (?<domain>.+)\\(?<user>.+)'

$Matches

Write-Output "`nDomain name:"
$Matches.domain

Write-Output "`nUser name:"
$Matches.user
True

Name                           Value
----                           -----
domain                         CONTOSO
user                           jsmith
0                              was CONTOSO\jsmith

Domain name:
CONTOSO

User name:
jsmith

Lorsque le -match résultat est False, ou que le -notmatch résultat est True, ou lorsque l’entrée est une collection, la $Matches variable automatique n’est pas remplacée. Par conséquent, il contiendra la valeur précédemment définie, ou $null si la variable n’a pas été définie. Lors de la $Matches référence après l’appel de l’un de ces opérateurs, envisagez de vérifier que la variable a été définie par l’appel de l’opérateur actuel à l’aide d’une instruction de condition.

Exemple :

if ("<version>1.0.0</version>" -match '<version>(.*?)</version>') {
    $Matches
}

Pour plus d’informations , consultez about_Regular_Expressions et about_Automatic_Variables.

Opérateur de remplacement

Remplacement par des expressions régulières

Comme -match, l’opérateur -replace utilise des expressions régulières pour rechercher le modèle spécifié. Mais contrairement à -match, il remplace les correspondances par une autre valeur spécifiée.

Syntaxe :

<input> -replace <regular-expression>, <substitute>

L’opérateur remplace tout ou partie d’une valeur par la valeur spécifiée à l’aide d’expressions régulières. Vous pouvez utiliser l’opérateur pour de nombreuses tâches d’administration, telles que le renommage des fichiers. Par exemple, la commande suivante remplace les extensions de nom de fichier de tous les .txt fichiers par .log:

Get-ChildItem *.txt | Rename-Item -NewName { $_.name -replace '\.txt$','.log' }

Par défaut, l’opérateur -replace ne respecte pas la casse. Pour qu’il respecte la casse, utilisez -creplace. Pour le rendre explicitement insensible à la casse, utilisez -ireplace.

Exemples :

"book" -ireplace "B", "C" # Case insensitive
"book" -creplace "B", "C" # Case-sensitive; hence, nothing to replace
Cook
book

À compter de PowerShell 7.2, lorsque l’opérande gauche d’une -replace instruction d’opérateur n’est pas une chaîne, cet opérande est converti en chaîne. PowerShell effectue une conversion de chaîne non sensible à la culture.

Par exemple, si votre culture est définie sur Français (fr), la conversion de chaîne sensible à la culture de la valeur 1.2 est 1,2.

Avant PowerShell 7.2 :

PS> [cultureinfo]::CurrentCulture = 'fr'
PS> 1.2 -replace ','
12

Dans PowerShell 7.2 et versions ultérieures :

PS> [cultureinfo]::CurrentCulture = 'fr'
PS> 1.2 -replace ','
1.2

Substitutions d’expressions régulières

Il est également possible d’utiliser des expressions régulières pour remplacer dynamiquement du texte à l’aide de la capture de groupes et des substitutions. Les groupes de capture peuvent être référencés dans la chaîne à l’aide <substitute> du caractère signe dollar ($) avant l’identificateur du groupe.

Dans l’exemple suivant, l’opérateur -replace accepte un nom d’utilisateur sous la forme de DomainName\Username et se convertit au Username@DomainName format :

$SearchExp = '^(?<DomainName>[\w-.]+)\\(?<Username>[\w-.]+)$'
$ReplaceExp = '${Username}@${DomainName}'

'Contoso.local\John.Doe' -replace $SearchExp, $ReplaceExp
John.Doe@Contoso.local

Avertissement

Le $ caractère a des rôles syntaxiques dans les expressions PowerShell et régulières :

  • Dans PowerShell, entre guillemets doubles, il désigne des variables et agit comme un opérateur de sous-expression.
  • Dans les chaînes de recherche Regex, il désigne la fin de la ligne.
  • Dans les chaînes de substitution Regex, il désigne les groupes capturés. Veillez à placer vos expressions régulières entre guillemets simples ou à insérer un caractère backtick (`) avant elles.

Par exemple :

$1 = 'Goodbye'

'Hello World' -replace '(\w+) \w+', "$1 Universe"
# Output: Goodbye Universe

'Hello World' -replace '(\w+) \w+', '$1 Universe'
# Output: Hello Universe

$$ dans Regex désigne un littéral $. Ceci $$ dans la chaîne de substitution pour inclure un littéral $ dans le remplacement résultant. Par exemple :

'5.72' -replace '(.+)', '$ $1' # Output: $ 5.72
'5.72' -replace '(.+)', '$$$1' # Output: $5.72
'5.72' -replace '(.+)', '$$1'  # Output: $1

Pour plus d’informations , consultez about_Regular_Expressions et substitutions dans les expressions régulières.

Substitution dans une collection

Lorsque l’opérateur <input> à est -replace une collection, PowerShell applique le remplacement à chaque valeur de la collection. Par exemple :

"B1","B2","B3","B4","B5" -replace "B", 'a'
a1
a2
a3
a4
a5

Remplacer par un bloc de script

Dans PowerShell 6 et versions ultérieures, l’opérateur -replace accepte également un bloc de script qui effectue le remplacement. Le bloc de script s’exécute une fois pour chaque correspondance.

Syntaxe :

<String> -replace <regular-expression>, {<Script-block>}

Dans le bloc de script, utilisez la $_ variable automatique pour accéder au texte d’entrée remplacé et à d’autres informations utiles. Le type de classe de cette variable est System.Text.RegularExpressions.Match.

L’exemple suivant remplace chaque séquence de trois chiffres par les caractères équivalents. Le bloc de script s’exécute pour chaque jeu de trois chiffres qui doit être remplacé.

"072101108108111" -replace "\d{3}", {return [char][int]$_.Value}
Hello

Opérateurs de confinement

Les opérateurs de confinement (-contains, -notcontains, -inet -notin) sont similaires aux opérateurs d’égalité, sauf qu’ils retournent toujours une valeur booléenne , même lorsque l’entrée est une collection. Ces opérateurs cessent de comparer dès qu’ils détectent la première correspondance, tandis que les opérateurs d’égalité évaluent tous les membres d’entrée. Dans une collection très volumineuse, ces opérateurs retournent plus rapidement que les opérateurs d’égalité.

Syntaxe :

<Collection> -contains <Test-object>
<Collection> -notcontains <Test-object>
<Test-object> -in <Collection>
<Test-object> -notin <Collection>

-contains et -notcontains

Ces opérateurs indiquent si un jeu inclut un certain élément. -contains renvoie true lorsque le côté droit (objet de test) correspond à l’un des éléments du jeu. -notcontains retourne la valeur False à la place. Lorsque l’objet de test est une collection, ces opérateurs utilisent l’égalité de référence, c’est-à-dire qu’ils vérifient si l’un des éléments du jeu est la même instance de l’objet de test.

Exemples :

"abc", "def" -contains "def"                  # Output: True
"abc", "def" -notcontains "def"               # Output: False
"Windows", "PowerShell" -contains "Shell"     # Output: False
"Windows", "PowerShell" -notcontains "Shell"  # Output: True
"abc", "def", "ghi" -contains "abc", "def"    # Output: False
"abc", "def", "ghi" -notcontains "abc", "def" # Output: True

Exemples plus complexes :

$DomainServers = "ContosoDC1","ContosoDC2","ContosoFileServer","ContosoDNS",
                 "ContosoDHCP","ContosoWSUS"
$thisComputer  = "ContosoDC2"

$DomainServers -contains $thisComputer
# Output: True

$a = "abc", "def"
"abc", "def", "ghi" -contains $a # Output: False
$a, "ghi" -contains $a           # Output: True

-in et -notin

Les -in opérateurs et -notin ont été introduits dans PowerShell 3 en tant qu’inverse syntaxique des opérateurs de -contains et -notcontains . -in retourne true lorsque le côté <test-object> gauche correspond à l’un des éléments du jeu. -notin retourne la valeur False à la place. Lorsque l’objet de test est un ensemble, ces opérateurs utilisent l’égalité de référence pour vérifier si l’un des éléments du jeu est la même instance de l’objet de test.

Les exemples suivants font la même chose que les exemples pour -contains et -notcontains le font, mais ils sont écrits avec -in et -notin à la place.

"def" -in "abc", "def"                  # Output: True
"def" -notin "abc", "def"               # Output: False
"Shell" -in "Windows", "PowerShell"     # Output: False
"Shell" -notin "Windows", "PowerShell"  # Output: True
"abc", "def" -in "abc", "def", "ghi"    # Output: False
"abc", "def" -notin "abc", "def", "ghi" # Output: True

Exemples plus complexes :

$DomainServers = "ContosoDC1","ContosoDC2","ContosoFileServer","ContosoDNS",
                 "ContosoDHCP","ContosoWSUS"
$thisComputer  = "ContosoDC2"

$thisComputer -in $DomainServers
# Output: True

$a = "abc", "def"
$a -in "abc", "def", "ghi" # Output: False
$a -in $a, "ghi"           # Output: True

Comparaison de types

Les opérateurs de comparaison de types (-is et -isnot) sont utilisés pour déterminer si un objet est un type spécifique.

Syntaxe :

<object> -is <type-reference>
<object> -isnot <type-reference>

Exemple :

$a = 1
$b = "1"
$a -is [int]           # Output: True
$a -is $b.GetType()    # Output: False
$b -isnot [int]        # Output: True
$a -isnot $b.GetType() # Output: True

Voir aussi