about_Comparison_Operators

  • Article

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 aux modèles spécifiés. PowerShell inclut les opérateurs de comparaison suivants :

Égalité

  • -eq, , -ceq - -ieqégal à
  • -ne, , -ine- -cne non égal
  • -gt, , -cgt - -igtsupérieur à
  • -ge, , - -ige-cge supérieur ou égal à
  • -lt, , -ilt-clt - inférieur à
  • -le, , -ile-cle - inférieur ou égal à

Correspondance

  • -like, , -ilike- -clike chaîne correspond à wild carte pattern
  • -notlike, , - -inotlike-cnotlike la chaîne ne correspond pas au modèle wild carte
  • -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 d’expression régulière

Endiguement

  • -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 rendre un opérateur de comparaison sensible à la casse, ajoutez un c après le -. Par exemple, -ceq est la version sensible à la casse de -eq. Pour rendre explicite l’insensitivité de la casse, ajoutez une i fois -. Par exemple, -ieq est la version explicite non sensible à la casse de -eq.

Les comparaisons de chaînes utilisent InvariantCulture pour les comparaisons respectant la casse et sans respect de la casse. Les comparaisons sont entre les points de code Unicode et n’utilisent pas l’ordre de classement propre à la culture. Les résultats sont identiques, 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’existe 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 conteneur 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 les opérateurs 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 ; retourne False lorsque les deux côtés sont équivalents ; sinon, -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 du côté droit de la comparaison peut être convertie en type de la valeur de gauche pour la 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 une scalaire ou une collection. Toutefois, le résultat de comparaison n’est pas garanti 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 a 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. Mais 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 fait de le placer sur le côté droit ne fait pas ce que vous attendez.

Par exemple, supposons qu’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 fileurs sortent tous les éléments null 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 très 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 comparent :

Opérateur Renvoie 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

Remarque

Dans la plupart des langages de programmation, l’opérateur supérieur à celui-ci 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 dis carte 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 qui est 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 déclenchent une erreur sans fin.

Opérateurs correspondants

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 carte (contenant*, ?et ), tandis -match qu’elle [ ]-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, elles 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 les opérateurs retournent respectivement tous les membres correspondants et non correspondants. Toutefois, les -like opérateurs retournent -notlike les membres sous forme de chaînes. Chaîne retournée pour un membre de la collection par -like et -notlike est la chaîne utilisée pour la comparaison et obtenue en cas de conversion du membre en chaîne.

-like et -notlike

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

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 le 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 possède toujours une clé nommée « 0 », qui stocke toute la correspondance. Si l’expression régulière contient des groupes de capture, il $Matches contient des 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 correspondant.

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 si 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, elle contiendra la valeur définie précédemment ou $null si la variable n’a pas été définie. Lors du $Matches référencement après l’appel d’un de ces opérateurs, pensez à vérifier que la variable a été définie par l’appel d’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 toute 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 administratives, telles que le renommage de fichiers. Par exemple, la commande suivante modifie les extensions de nom de fichier de tous les .txt fichiers en .log:

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

Par défaut, l’opérateur ne respecte pas la -replace casse. Pour qu’elle respecte la casse, utilisez -creplace. Pour qu’elle ne respecte pas explicitement 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 de gauche dans 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 est 1.21,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 groupes de capture et de substitutions. Les groupes de capture peuvent être référencés dans la <substitute> chaîne à l’aide du caractère signe dollar ($) avant l’identificateur de groupe.

Dans l’exemple suivant, l’opérateur -replace accepte un nom d’utilisateur sous la forme et DomainName\Username 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 PowerShell et dans les expressions 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, elle indique la fin de la ligne.
  • Dans les chaînes de substitution Regex, elle désigne les groupes capturés. Veillez à placer vos expressions régulières entre guillemets simples ou insérer un caractère backtick (`) avant eux.

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 $. Cela $$ 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>-replace est 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

Remplacement 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 équivalents de caractères. Le bloc de script s’exécute pour chaque ensemble de trois chiffres qui doivent être remplacés.

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

Hello

Opérateurs de confinement

Les opérateurs de confinement (-contains, , -in-notcontainset -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 arrêtent 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 retourne True lorsque le côté droit (scalaire-object) correspond à l’un des éléments de l’ensemble. -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 les opérateurs ont été introduits dans PowerShell 3 comme inverse syntaxique des opérateurs et -notcontains des -contains opérateurs. -in retourne 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 à faire, 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 sous forme 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 type (-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