about_Comparison_Operators

Article
05/09/2024

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 à

Correspondant

-like, -ilike, -clike - string correspond au modèle de caractères génériques
-notlike, -inotlike, -cnotlike - la chaîne ne correspond pas au modèle générique
-match, -imatch, -cmatch - string correspond au modèle regex
-notmatch, -inotmatch, -cnotmatch - la 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 - 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 sensible à la casse de -eq. Pour rendre explicite l’insensibilité à la casse, ajoutez un i après -. Par exemple, -ieq est la version qui ne respecte pas explicitement la casse de -eq.

Les comparaisons de chaînes utilisent InvariantCulture pour les comparaisons respectant la casse et ne respectant pas la casse. Les comparaisons sont effectuées entre des points de code Unicode et n’utilisent pas l’ordre de classement propre à la culture. Les résultats sont les mêmes quelle que soit la culture actuelle.

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 est équivalent ; sinon, -eq retourne False. -ne fait l’inverse ; elle retourne False lorsque les deux côtés sont équivalents ; dans le cas contraire, -ne retourne La valeur 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 située à droite de la comparaison peut être convertie en type de la valeur du côté 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, il n’est pas garanti que le résultat de la comparaison soit 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 mettre sur le côté droit ne fait pas ce que vous attendez.

Par exemple, il s’agit $a d’un tableau contenant des éléments null :

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

Les tests $a suivants ne sont pas null.

$null -ne $a

True

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

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

-gt, -ge, -lt et -le

-gt, -ge, -ltet -le se comportent de la même façon. 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 abandonnent 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 jeu 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 posent une erreur sans fin.

Opérateurs de correspondance

Les opérateurs correspondants (-like, , -notlike-matchet -notmatch) recherchent des é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, chaque élément de la collection est converti en chaîne à des fins de comparaison. Les -match opérateurs et -notmatch retournent les membres correspondants et non correspondants respectivement. Toutefois, les -like opérateurs et -notlike retournent les membres sous forme de chaînes. La chaîne retournée pour un membre de la collection par -like et -notlike est la chaîne utilisée pour la comparaison et est obtenue en cassant le membre en une chaîne.

-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 en cours de remplacement 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é.

-contains et -notcontains

Syntaxe :

<Collection> -contains <scalar-object>
<Collection> -notcontains <scalar-object>

Ces opérateurs indiquent si un jeu inclut un certain élément. -contains renvoie true lorsque le côté droit (scalaire-object) correspond à l’un des éléments du jeu. -notcontains retourne la valeur False à la place.

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

Lorsque l’opérande de droite est une collection, ces opérateurs convertissent la valeur en sa représentation sous forme de chaîne avant de la comparer à la collection de gauche.

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

# The following statements are equivalent
$a, "ghi" -contains $a           # Output: True
"$a", "ghi" -contains $a         # Output: True
"abc def", "ghi" -contains $a    # Output: True

-in et -notin

Syntaxe :

<scalar-object> -in <Collection>
<scalar-object> -notin <Collection>

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 renvoie true lorsque le côté <scalar-object> gauche correspond à l’un des éléments de la collection. -notin retourne la valeur False à la place.

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

Lorsque l’opérande de gauche est une collection, ces opérateurs convertissent la valeur en sa représentation de chaîne avant de la comparer à la collection de droite.

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

# The following statements are equivalent
$a -in $a, "ghi"           # Output: True
$a -in "$a", "ghi"         # Output: True
$a -in "abc def", "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

Share via

about_Comparison_Operators

Description courte

Description longue

Fonctionnalités communes

Opérateurs d’égalité

-eq et -ne

-gt, -ge, -lt et -le

Opérateurs de correspondance

-like et -notlike

-match et -notmatch

Opérateur de remplacement

Remplacement par des expressions régulières

Substitutions d’expressions régulières

Substitution dans une collection

Remplacer par un bloc de script

Opérateurs de confinement

-contains et -notcontains

-in et -notin

Comparaison de types

Voir aussi

Ressources supplémentaires