RUBRIQUE
about_Comparison_Operators
DESCRIPTION COURTE
Décrit les opérateurs qui comparent des valeurs dans Windows
PowerShell.
DESCRIPTION LONGUE
Les opérateurs de comparaison vous permettent de spécifier des
conditions pour la comparaison de valeurs et la recherche de valeurs
correspondant aux modèles spécifiés. Pour utiliser un opérateur
de comparaison, spécifiez les valeurs à comparer de part et
d'autre de l'opérateur.
Par défaut, tous les opérateurs de comparaison ne respectent pas
la casse. Pour qu'un opérateur de comparaison respecte la casse,
faites précéder son nom de la lettre " c ". Par exemple, la
version respectant la casse de " -eq " est " -ceq ". Pour rendre
le non-respect de la casse explicite, faites précéder l'opérateur
de la lettre " i ". Par exemple, la version ne respectant pas
la casse explicitement de " -eq " est " ieq ".
Tous les opérateurs de comparaison, à l'exception des opérateurs
de relation contenant contenu (-contains, -notcontains) et des
opérateurs de type (-is, -isnot), renvoient une valeur booléenne
lorsque l'entrée de l'opérateur (valeur située à gauche de
l'opérateur) est une valeur unique (scalaire). Lorsque l'entrée
est une collection de valeurs, les opérateurs de relation
contenant contenu et les opérateurs de type retournent n'importe
quelle valeur correspondante. S'il n'existe aucune correspondance
dans une collection, ces opérateurs ne retournent aucune valeur. Les
opérateurs de relation contenant contenu et les opérateurs de type
renvoient toujours une valeur booléenne.
Windows PowerShell prend en charge les opérateurs de comparaison
suivants :
-eq
Description : égal à. Inclut une valeur identique.
Exemple :
C:\PS> "abc", "def" -eq "abc"
abc
-ne
Description : différent de. Inclut une valeur différente.
Exemple :
C:\PS> "abc", "def" -ne "abc"
def
-gt
Description : supérieur à.
Exemple :
C:\PS> 8 -gt 6
True
-ge
Description : supérieur ou égal à.
Exemple :
C:\PS> 8 -ge 8
True
-lt
Description : inférieur à.
Exemple :
C:\PS> 8 -lt 6
False
-le
Description : inférieur ou égal à.
Exemple :
C:\PS> 6 -le 8
True
-like
Description : établit une correspondance à l'aide du caractère
générique (*).
Exemple :
C:\PS> "Windows PowerShell" -like "*shell"
True
-notlike
Description : n'établit pas de correspondance à l'aide du caractère
générique (*).
Exemple :
C:\PS> "Windows PowerShell" -notlike "*shell"
False
-match
Description : met en correspondance une chaîne à l'aide
d'expressions régulières. Si l'entrée est une valeur scalaire,
celle-ci remplit la variable automatique $Matches.
Exemple :
C:\PS> "Septembre" -match "sept"
True
C:\PS> $matches
Name Value
---- -----
0 sept
-notmatch
Description : vérifie l'absence de correspondance avec une
chaîne. Utilise des expressions régulières.
Si l'entrée est une valeur scalaire, celle-ci
remplit la variable automatique $Matches.
Exemple :
C:\PS> "Septembre" -notmatch "sept"
False
C:\PS> $matches
Name Value
---- -----
0 sept
-contains
Description : opérateur de relation contenant contenu. Inclut
une valeur identique qui ne fait pas partie d'une valeur.
Retourne toujours une valeur booléenne.
Exemple :
C:PS> "abc", "def" -contains "def"
True
-notcontains
Description : opérateur de relation contenant contenu. N'inclut
pas de valeur identique. Retourne toujours une valeur booléenne.
Exemple :
C:PS> "Windows", "PowerShell" -notcontains "Shell"
True
-replace
Description : opérateur de remplacement. Modifie les éléments
spécifiés d'une valeur.
Exemple :
C:\PS> "Get-Process" -replace "Get", "Stop"
Stop-Process
Opérateurs d'égalité
Les opérateurs d'égalité (-eq, -ne) renvoient la valeur TRUE ou
les correspondances si une ou plusieurs des valeurs d'entrée sont
identiques au modèle spécifié. Le modèle entier doit correspondre
à une valeur entière.
Les exemples suivants montrent l'effet de l'opérateur Égal à :
C:PS> 1,2,3 -eq 2
2
C:PS> "PowerShell" -eq "Shell"
False
C:PS> "Windows", "PowerShell" -eq "Shell"
C:PS>
C:\PS> "abc", "def", "123" -eq "def"
def
Opérateurs de relation contenant contenu
Les opérateurs de relation contenant contenu (-contains et
-notcontains) sont semblables aux opérateurs d'égalité.
Toutefois, les opérateurs de relation contenant contenu
retournent toujours une valeur booléenne, même quand l'entrée
est une collection.
En outre, contrairement aux opérateurs d'égalité, les
opérateurs de relation contenant contenu renvoient une valeur
dès qu'ils détectent la première correspondance. Les opérateurs
d'égalité évaluent toutes les entrées, puis retournent toutes
les correspondances de la collection.
Les exemples suivants montrent l'effet de l'opérateur -contains :
C:PS> 1,2,3 -contains 2
True
C:PS> "PowerShell" -contains "Shell"
False
C:PS> "Windows", "PowerShell" -contains "Shell"
False
C:\PS> "abc", "def", "123" -contains "def"
True
C:\PS> "vrai", "bleu", "six" -contains "vrai"
True
L'exemple ci-dessous montre la différence entre les opérateurs
de relation contenant contenu et l'opérateur Égal à. Les
opérateurs de relation contenant contenu retournent la valeur
TRUE à la première correspondance.
C:\PS> 1,2,3,4,5,4,3,2,1 -eq 2
2
2
C:\PS> 1,2,3,4,5,4,3,2,1 -contains 2
True
Dans une très grande collection, l'opérateur -contains retourne les
résultats plus rapidement que l'opérateur Égal à.
Opérateurs de correspondance
Les opérateurs de correspondance (-match et -notmatch)
recherchent des éléments correspondant ou non à un modèle
spécifié à l'aide d'expressions régulières.
La syntaxe est la suivante :
<string[]> -match <expression régulière>
<string[]> -notmatch <expression régulière>
Les exemples suivants illustrent quelques emplois possibles de
l'opérateur -match :
C:\PS> "Windows", "PowerShell" -match ".shell"
PowerShell
C:\PS> (get-command get-member -syntax) -match "-vue"
True
C:\PS> (get-command get-member -syntax) -notmatch "-chemin"
True
C:\PS> (get-content servers.txt) -match "^Server\d\d"
Server01
Server02
Les opérateurs de correspondance effectuent la recherche
uniquement dans les chaînes. Ils ne peuvent pas rechercher dans
des tableaux d'entiers ou dans d'autres objets.
Les opérateurs -match et -notmatch remplissent la variable
automatique $Matches lorsque l'entrée (argument situé à gauche) de
l'opérateur correspond à un objet scalaire unique. Si l'entrée est
une valeur scalaire, les opérateurs -match et -notmatch retournent
une valeur booléenne et définissent la valeur de la variable
automatique $Matches sur les composants de l'argument mis en
correspondance.
Si l'entrée est une collection, les opérateurs -match et -notmatch
retournent les membres correspondants de cette collection, mais ne
remplissant pas la variable $Matches.
Par exemple, la commande ci-dessous soumet une collection de
chaînes à l'opérateur -match. L'opérateur -match retourne les
éléments correspondants de la collection. Il ne remplit pas la
variable automatique $Matches.
C:\PS> "Septembre", "Octobre", "Novembre" -match "sept"
Septembre
C:\PS> $matches
C:\PS>
Par opposition, la commande ci-dessous soumet une chaîne unique à
l'opérateur de correspondance. L'opérateur -match retourne une valeur
booléenne et remplit la variable automatique $Matches.
C:\PS> "Septembre" -match "sept"
True
C:\PS> $matches
Name Value
---- -----
0 Sept
L'opérateur -notmatch remplit la variable automatique $Matches
lorsque l'entrée correspond à une valeur scalaire et que le
résultat est False, c'est-à-dire lorsqu'il détecte une
correspondance.
C:\PS> "Septembre" -notmatch "pluie"
True
C:\PS> $matches
C:\PS>
C:\PS> "Minuit" -notmatch "nuit"
False
C:\PS> $matches
C:\PS>
Name Value
---- -----
0 nuit
Opérateur de remplacement
L'opérateur -replace 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 -replace pour de nombreuses tâches
d'administration, telles que la modification des noms de fichiers.
Par exemple, la commande suivante remplace les extensions de noms
de fichiers de tous les fichiers .gif par .jpg :
Get-ChildItem | Rename-Item -NewName { $_ -replace
'.gif$','.jpg$' }
La syntaxe de l'opérateur -replace se présente comme suit, où
l'espace réservé <original> représente les caractères à remplacer
et l'espace réservé <remplacement> correspond aux caractères de
remplacement :
<entrée> <opérateur> <original>, <remplacement>
Par défaut, l'opérateur -replace ne respecte pas la casse. Pour
qu'il respecte la casse, utilisez -creplace. Pour qu'il ne
respecte pas la casse explicitement, utilisez ireplace. Examinez les
exemples suivants :
C:\PS> "verre" -replace "V", "T"
Terre
C:\PS> "verre" -ireplace "V", "T"
Terre
C:\PS> "verre" -creplace "V", "T"
verre
Opérateurs de bits
Windows PowerShell prend en charge les opérateurs de bits
standard, y compris les opérateurs de bits AND (-band), de même
que les opérateurs de bits OR inclusifs et exclusifs (-bor et
-bxor). Depuis Windows PowerShell 2.0, tous les opérateurs de bits
fonctionnent avec les entiers 64 bits.
Windows PowerShell prend en charge les opérateurs de bits suivants :
Opérateur Description Exemple
-------- ---------------------- -------------------
-band Opérateur de bits AND C:\PS> 10 -band 3
2
-bor Opérateur de bits OR C:\PS> 10 -bor 3
(inclusif) 11
-bxor Opérateur de bits OR C:\PS> 10 -bxor 3
(exclusif) 9
Les opérateurs de bits agissent sur le format binaire d'une
valeur. Par exemple, la structure de bits du nombre 10 est
00001010 (sur la base d'un octet) et la structure de bits du
nombre 3 est 00000011. Lorsque vous utilisez un opérateur de
bits pour comparer 10 et 3, la comparaison s'effectue sur
chaque bit de l'octet.
Dans une opération AND au niveau du bit, le bit résultant a la
valeur 1 uniquement lorsque les deux bits d'entrée ont la valeur 1.
00001010 (10)
00000011 ( 3)
------------------ bAND
00000010 ( 2)
Dans une opération OR (inclusif) au niveau du bit, le bit
résultant a la valeur 1 lorsque l'un des bits d'entrée ou les
deux ont la valeur 1. Le bit résultant a la valeur 0 uniquement
lorsque les deux bits d'entrée ont la valeur 0.
00001010 (10)
00000011 ( 3)
------------------ bOR (inclusif)
00001011 (11)
Dans une opération OR (exclusif) au niveau du bit, le bit
résultant a la valeur 1 uniquement lorsqu'un bit d'entrée
a la valeur 1.
00001010 (10)
00000011 ( 3)
------------------ bXOR (exclusif)
00001001 ( 9)
VOIR AUSSI
about_Operators
about_Regular_Expressions
about_Wildcards
Compare-Object