à_propos_des_opérateurs_de_comparaison

Brève description

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, -ieq, -ceq - égaux
• -ne, -ine, -cne - non é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

Correspondance

• -like, -ilike, -clike : la chaîne correspond au motif avec jokers
• -notlike, -inotlike, -cnotlike : la chaîne ne correspond pas au motif avec jokers
• -match, -imatch, -cmatch - chaîne correspond au modèle regex
• -notmatch, -inotmatch, -cnotmatch - la chaîne ne correspond pas au modèle regex

Remplacement

• -replace, , -ireplace- -creplace recherche et remplace les chaînes correspondant à un modèle d’expression régulière

Inclusion

• La collection -contains, -icontains, -ccontains contient une valeur.
• -notcontains, -inotcontains, -cnotcontains - collection ne contient pas de valeur
• -in, -iin, -cin : la valeur se trouve dans une collection
• -notin, -inotin, -cnotin : la valeur ne se trouve 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 courantes

Les comparaisons de chaînes ne tiennent pas compte de la casse à moins que vous n’utilisiez l’opérateur explicite sensible à 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 la non-sensibilité à la casse, ajoutez un i après -. Par exemple, -ieq est la version explicitement non sensible à la casse de -eq.

Les comparaisons de chaînes utilisent la InvariantCulture pour les comparaisons sensibles et non sensibles à 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 la valeur de gauche de l’expression de comparaison est une valeur scalaire, l’opérateur retourne une valeur booléenne. Lorsque la valeur de gauche de l’expression est une collection, l’opérateur retourne les éléments de la collection qui correspondent à la valeur de droite de l’expression. Les valeurs à droite sont toujours traitées comme des instances uniques, même lorsqu’il s’agit de collections. Les opérateurs de comparaison ne peuvent pas comparer efficacement les collections aux collections.

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 d’inclusion et de type renvoient toujours une valeur Boolean.
• L’opérateur -replace renvoie le résultat du remplacement
• Les opérateurs -match et -notmatch remplissent également la variable automatique $Matches, 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 ; 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, tandis que -ne les exclut.

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 au type de la valeur de gauche pour être comparée.

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 n’importe quels deux objets, pas seulement un 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 ils sont différents objets. 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 méthode Equals() 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é. La placer à droite ne donne pas le résultat attendu.

Par exemple, laissez $a être un tableau contenant des éléments Null :

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

Les tests suivants vérifient que $a n'est pas nul.

$null -ne $a

True

Toutefois, le filtre supprime tous les éléments nuls 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 façon. Lorsque les deux côtés sont scalaires, ils retournent True ou False en fonction de leur comparaison.

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

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 rejettent 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 fournit un ensemble contenant tous ces symboles dans l'opérateur -gt pour les comparer avec « 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 génèrent une erreur non-terminante.

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 (contenant *, ?et [ ]), tandis -match qu’il -notmatch accepte une expression régulière (regex).

La syntaxe est la suivante :

<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 opérateurs -match et -notmatch renvoient respectivement tous les éléments correspondants et non correspondants. Cependant, les opérateurs -like et -notlike renvoient les éléments sous forme de chaînes. La chaîne renvoyée pour un élément de la collection par -like et -notlike est celle utilisée par l’opérateur pour la comparaison et est obtenue en convertissant l’élément en chaîne.

-like et -notlike

-like et -notlike se comportent de manière similaire à -eq et -ne, mais le côté droit peut être une chaîne contenant des jokers (wildcards).

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

Pour obtenir de meilleurs résultats, le côté droit des -like opérateurs doit -notlike être un littéral de chaîne contenant l’expression générique. PowerShell transmet l’expression générique à l’analyseur d’expression générique. Pour faire correspondre l’un des caractères génériques (*, ?ou [ ]), vous devez l’échapper avec un caractère backtick (`). Par exemple, pour faire correspondre un littéral ?, utilisez `? dans l’expression générique. Si vous utilisez une expression de chaîne extensible, PowerShell développe la chaîne avant de la transmettre à l’analyseur générique, ce qui entraîne l’envoi de caractères génériques en tant que caractères génériques.

# Escaped literals in an expandable string
PS> "f`?`?"
f??
# Escaped literals in a literal string
PS> 'f`?`?'
f`?`?
# Comparison containing 2 wildcards
PS> 'f??' -like 'f??'
True
PS> 'for' -like 'f??'
True
# Comparison containing literal '?' characters
PS> 'f??' -like 'f`?`?'
True
PS> 'for' -like 'f`?`?'
False

-match et -notmatch

-match et -notmatch utilisent des expressions régulières pour rechercher le motif dans les valeurs du côté 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 des 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 résultat -match est True, ou que le résultat -notmatch est False, ils remplacent la variable automatique $Matches. $Matches est une Hashtable qui possède toujours une clé nommée ’0’, qui contient l’intégralité de la correspondance. Si l’expression régulière contient des groupes de capture, le $Matches contient des clés supplémentaires pour chaque groupe.

Il est important de noter que la table de hachage $Matches 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 résultat -match est False, ou que le résultat -notmatch est True, ou lorsque l’entrée est une collection, la variable automatique $Matches 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. Lorsque vous référencez $Matches après l’appel de l’un de ces opérateurs, vérifiez 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 à propos des expressions régulières et à propos des variables automatiques.

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, elle 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 fichiers .txt en .log:

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

Par défaut, l’opérateur -replace n’est pas sensible à la casse. Pour le rendre sensible à la casse, utilisez -creplace. Pour le rendre explicitement non sensible à 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 instruction d’opérateur -replace n’est pas une chaîne, cet opérande est converti en chaîne. PowerShell effectue une conversion de chaîne indépendante de 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 groupes de capture et de substitutions. Les groupes de capture peuvent être référencés dans la chaîne <substitute> à 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 de DomainName\Username et se convertit au format Username@DomainName :

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

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

John.Doe@Contoso.local

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. Ce $$ dans la chaîne de substitution permet d’inclure un $ littéral dans le remplacement obtenu. Par exemple:

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

Pour en savoir plus, veuillez consulter la section about_Regular_Expressions et Substitutions in Regular Expressions.

Substitution dans une collection

Lorsque l’opérateur <input> appliqué à -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 scriptblock

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

Syntaxe:

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

Dans le scriptblock, 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 équivalents de caractères. Le scriptblock 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, -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 arrêtent de comparer dès qu’ils détectent la première correspondance, tandis que les opérateurs d’égalité évaluent tous les éléments d’entrée. Dans une très grande collection, ces opérateurs renvoient des résultats 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 ensemble inclut un certain élément. -contains renvoie True lorsque la valeur de droite (objet scalaire) 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 opérateurs -in et -notin ont été introduits dans PowerShell 3 comme inverse syntaxique des opérateurs -contains et -notcontains. -in retourne True lorsque la valeur de gauche <scalar-object> correspond à l’un des éléments de la collection. -notin renvoie à la place False.

Les exemples suivants font la même chose que ceux de -contains et -notcontains, 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 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

• à propos des Booleans
• about_Operators
• about_Regular_Expressions
• about_Wildcards
• Comparer-Objet
• ForEach-Object
• Où-Objet