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
,-igt
- 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
chaîne correspond au modèle générique-notlike
,-inotlike
--cnotlike
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, 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
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 à droite 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 n’ont $a
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
, -lt
et -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
-match
et -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 table de $Matches
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
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 groupes de capture et de 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 syntatiques 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
, -in
et -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 case activée si l’un des éléments du jeu est le 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 case activée si l’un des éléments du jeu est le 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