Maîtriser les chaînes de caractères PowerShell : Concaténer, diviser et plus encore

Les chaînes de caractères dans PowerShell sont probablement le type de données le plus utilisé dans PowerShell. Qu’il s’agisse d’afficher des messages, de demander une entrée ou d’envoyer des données à des fichiers, il est presque impossible d’écrire des scripts sans que les chaînes de caractères soient impliquées.

Dans cet article, vous apprendrez que les chaînes de caractères ne servent pas seulement à lire et à afficher. Elles peuvent également être manipulées pour s’adapter à l’objectif de la tâche pour laquelle vous pouvez écrire le script. Par exemple, remplacer des caractères ou des mots entiers, concaténer des chaînes de caractères pour former une nouvelle chaîne, ou même diviser une chaîne en plusieurs chaînes.

Comprendre les chaînes de caractères

Selon la définition .NET d’une chaîne – « Une chaîne est une collection séquentielle de caractères qui est utilisée pour représenter du texte ». En résumé, tant qu’il y a une séquence de caractères formant un texte, il y a une chaîne.

Définir les chaînes système dans PowerShell

Les chaînes sont définies en enfermant une série de caractères entre des guillemets simples ou doubles. Voici des exemples de chaîne.

PS> 'Hello PowerShell - Today is $(Get-Date)'PS> "Hello PowerShell - Today is $(Get-Date)"

Les chaînes sont en fait des System.Strings en .NET.

Comme vous pouvez le voir dans l’exemple ci-dessus, la première chaîne est enfermée entre des guillemets simples et la deuxième chaîne est enfermée entre des guillemets doubles. Si vous vous demandez, la seule différence entre les deux est que les chaînes entre guillemets doubles supportent l’expansion des chaînes, alors qu’un guillemet simple ne représentera que des chaînes littérales.

Pour confirmer le concept des guillemets simples contre doubles, lorsque vous collez les deux chaînes de l’exemple ci-dessus dans PowerShell.

La capture d’écran ci-dessous montre qu’une chaîne entre guillemets simples renvoie exactement la chaîne littérale définie. Alors que la chaîne entre guillemets doubles renvoie la chaîne avec le résultat de l’expression de la commande Get-Date.

Single Quote vs. Double-Quote String Output

Le résultat indiqué ci-dessus démontre la distinction entre l’utilisation de guillemets simples ou doubles lors de la définition de chaînes.

L’objet string

Comme indiqué dans la section précédente, la collection de caractères formant un texte est une chaîne (string). La valeur résultante de la chaîne est un objet String. L’objet String est un objet .NET de type [System.String].

Et puisque System.String est un objet, il possède des propriétés auxquelles vous pouvez accéder à l’aide de la commande Get-Member. Ci-dessous, nous insérons une variable à l’intérieur d’une chaîne entre guillemets doubles.

PS> "Hello PowerShell - Today is $(Get-Date)" | Get-Member=

La capture d’écran ci-dessous montre le TypeName et la liste partielle des propriétés de l’objet String.

String Object properties

Concaténation de chaînes PowerShell

La concaténation de chaînes est décrite comme la fusion de deux ou plusieurs chaînes ensemble, créant essentiellement un seul objet string à partir de plusieurs objets string séparés. Il existe plusieurs méthodes pour concaténer des chaînes en PowerShell. Chaque méthode est différente et celle à utiliser dépend de la façon dont vous prévoyez d’implémenter la concaténation de chaînes.

A typical example of using string concatenation in the real world is Active Directory user creation. Perhaps you’re creating a user creation script that takes the first name, last name, and department values from a list.

En utilisant la concaténation de chaînes, vous pouvez formuler la convention de dénomination standard pour le nom, le nom d’affichage, le nom d’utilisateur et l’adresse e-mail. Pour cet exemple, vous travaillerez avec les chaînes indiquées ci-dessous. Copiez ce code ci-dessous et collez-le dans votre session PowerShell.

$domain = 'contoso.com'
$firstname = 'Jack'
$lastname = 'Ripper'
$department = 'Health'

En utilisant les valeurs de variable d’exemple ci-dessus, l’objectif est de dériver les valeurs suivantes en concaténant des chaînes.

  • Nom = prénom nom
  • Nom d’affichage = prénom nom (département)
  • SamAccountName = prénom.nom
  • Adresse e-mail = pré[email protected]

Dans les sections suivantes, les valeurs énumérées ci-dessus seront créées en utilisant les différentes méthodes de concaténation de chaînes disponibles dans PowerShell.

Commençons !

Utilisation de l’opérateur de concaténation de chaînes PowerShell

Les langages de programmation ont leur propre opérateur de concaténation de chaînes utilisé pour concaténer des chaînes. Par exemple, en Visual Basic, la méthode de concaténation est le signe esperluette (&). PowerShell a également sa propre méthode de concaténation, qui est le signe plus (+).

En utilisant l’opérateur de concaténation de chaînes, vous pouvez concaténer des chaînes en utilisant le code ci-dessous.

## Nom
$firstname + ' ' + $lastname
## Nom d'affichage
$firstname + ' ' + $lastname + ' (' + $department + ')'
## SamAccountName
$firstname + '.' + $lastname
## Adresse e-mail
$firstname + '.' + $lastname + '@' + $domain

Utilisation de l’extension de chaînes dans PowerShell

L’utilisation de l’extension de chaînes peut être la méthode la plus concise pour concaténer des chaînes. Comme le montre le code ci-dessous, il suffit de disposer les chaînes dans l’ordre souhaité et de les encadrer de guillemets doubles.

# Utilisation de l'extension de chaînes
## Nom
"$firstname $lastname"
## Nom d'affichage
"$firstname $lastname ($department)"
## SamAccountName
"$firstname.$lastname"
## Adresse e-mail
"$firstname.$lastname@$domain"

PowerShell interprète et gère ensuite l’extension de chaînes à l’intérieur des guillemets doubles pour produire la chaîne concaténée en résultat. Vous pouvez vous référer à l’exemple de sortie ci-dessous.

Using String Expansion

Utilisation de l’opérateur de formatage dans PowerShell

L’opérateur de formatage (-f) est principalement utilisé pour le formatage composite. Il est important de se rappeler que cette méthode comporte trois parties lors de l’utilisation de -f.

Référez-vous à la troisième ligne du code ci-dessous. "{0} {1}" représente le format et les espaces réservés. Les nombres entre les accolades indiquent l’index de la chaîne dans la collection à afficher à sa place. Les guillemets peuvent être simples ou doubles.

La collection de chaînes en entrée dans cet exemple est représentée par $firstname,$lastname. Cela signifie que l’index de la variable $firstname est 0, tandis que celui de $lastname est 1.

Enfin, -f est l’endroit entre le paramètre et la collection de chaînes représentée par (-f).

## Nom
"{0} {1}" -f $firstname,$lastname
## Nom d'affichage
"{0} {1} ({2})" -f $firstname,$lastname,$department
## SamAccountName
"{0}.{1}" -f $firstname,$lastname
## Adresse e-mail
"{0}.{1}@{2}" -f $firstname,$lastname,$domain

Le code ci-dessus donnera les résultats indiqués ci-dessous.

Using the Format Operator

Utilisation de l’opérateur PowerShell -Join

L’opérateur -Join peut être utilisé pour joindre des chaînes en une seule chaîne de deux manières.

La première façon d’utiliser -Join est de le suivre avec le tableau de chaînes que vous souhaitez concaténer. L’opérateur -Join ne permet pas d’ajouter un délimiteur. Toutes les chaînes du tableau seront collées ensemble sans rien entre elles.

-Join <String[]>

La deuxième façon d’utiliser l’opérateur -Join est de spécifier le délimiteur à utiliser. Le tableau de chaînes sera joint, mais le caractère de délimiteur spécifié sera inséré entre chaque chaîne.

<String[]> -Join <Delimiter>

Revenons à l’objectif de concaténer des chaînes, le code ci-dessous montre comment utiliser l’opérateur -Join pour assembler des chaînes.

## Nom
$firstname, $lastname -join ' '
## Nom d'affichage
$firstname,$lastname,"($department)" -join ' '
## SamAccountName
-join ($firstname,'.',$lastname)
## Adresse e-mail
-join ($firstname,'.',$lastname,'@',$domain)

Lorsque vous exécutez le code d’exemple ci-dessus dans PowerShell, vous vous attendez à voir une sortie similaire à celle indiquée ci-dessous.

Using the PowerShell Join Operator

La méthode String.Format() de .NET

La méthode String.Format de .NET est l’équivalent de .NET de l’opérateur de formatage de PowerShell. Elle fonctionne de la même manière que l’opérateur de formatage, où le format et les espaces réservés doivent être spécifiés.

## Nom
[string]::Format("{0} {1}",$firstname,$lastname)
## NomAffichage
[string]::Format("{0} {1} ({2})",$firstname,$lastname,$department)
## SamAccountName
[string]::Format("{0}.{1}",$firstname,$lastname)
## Adresse email
[string]::Format("{0}.{1}@{2}",$firstname,$lastname,$domain)

La capture d’écran ci-dessous montre la méthode String.Format en action.

The .NET String.Format Method

La méthode String.Concat() de .NET

Une autre méthode pour concaténer des chaînes est d’utiliser la méthode String.Concat de .NET. La méthode String.Concat de .NET est l’équivalent de .NET de l’opérateur de concaténation de chaînes de PowerShell (+). Mais au lieu d’utiliser le signe + pour joindre les chaînes, vous pouvez ajouter toutes les chaînes à l’intérieur de la méthode comme ceci – [string]::Concat(chaine1, chaine2...).

## Nom
[string]::Concat($firstname,' ',$lastname)
## Nom d'affichage
[string]::Concat($firstname,' ',$lastname,' (',$department,')')
## Nom du compte Sam
[string]::Concat($firstname,'.',$lastname)
## Adresse e-mail
[string]::Concat($firstname,'.',$lastname,'@',$domain)

La capture d’écran ci-dessous montre le résultat de l’invocation de la méthode String.Concat de .NET. Vous pouvez voir que PowerShell a fusionné string1, string2.

Using the .NET String.Concat Method

La méthode .NET String.Join()

La méthode String.Join de .NET est l’équivalent de la méthode PowerShell Join Operator (-join) en .NET. Le format de cette méthode est le suivant : [string]::Join(<délimiteur>,<string1>,<string2>,...).

Le premier élément à l’intérieur de la méthode -Join est toujours le délimiteur. Ensuite, les valeurs des éléments suivants sont les chaînes que vous souhaitez concaténer. Voir l’exemple de code ci-dessous. N’oubliez pas, le premier élément est toujours le délimiteur. Si vous ne souhaitez pas ajouter de délimiteur, vous pouvez le spécifier ainsi : ''.

## Nom
[string]::Join(' ',$firstname,$lastname)
## Nom d'affichage
[string]::Join(' ',$firstname,$lastname,"($department)")
## Nom du compte Sam
[string]::Join('',$firstname,'.',$lastname)
## Adresse e-mail
[string]::Join('',$firstname,'.',$lastname,'@',$domain)
The .NET String.Join Method

Division des chaînes PowerShell

Vous avez vu plusieurs méthodes différentes pour concaténer des chaînes dans la section précédente. Dans cette section, vous apprendrez les différentes façons d’utiliser PowerShell pour diviser des chaînes. La division des chaînes est l’action inverse de la concaténation.

Vous pouvez diviser les chaînes de caractères dans PowerShell de deux manières différentes – la fonction/méthode split() ou l’opérateur split.

Diviser les chaînes de caractères avec la méthode Split()

Si vous cherchez un moyen simple de diviser une chaîne de caractères pour créer un tableau, ne cherchez pas plus loin que la méthode split(). La méthode split() est présente sur chaque objet chaîne de caractères et est capable de diviser une chaîne en un tableau en fonction d’un caractère non-regex.

Par exemple, si vous avez une chaîne de caractères comme vert|oeufs|et|jambon et que vous souhaitez créer un tableau comme @('vert','oeufs','et','jambon'), vous pouvez diviser cette chaîne de caractères sur le symbole de pipe (|) comme dans le code suivant.

$string = 'green|eggs|and|ham'
$string.split('|')

Vous verrez alors que PowerShell divise la chaîne de caractères dans le tableau désiré avec le symbole de pipe.

La méthode split() est un moyen simple de diviser les chaînes de caractères, mais elle est limitée. La méthode split() ne permet pas de diviser les chaînes de caractères via des expressions régulières. Si vous avez besoin de fonctionnalités plus avancées pour diviser une chaîne de caractères, vous devrez apprendre à utiliser l’opérateur split.

L’opérateur -split

Le principal opérateur qui peut être utilisé pour diviser les chaînes de caractères dans PowerShell est l’opérateur -Split. En utilisant l’opérateur -Split, les chaînes de caractères sont divisées par défaut entre les espaces, ou avec des caractères de délimitation spécifiques.

Voici la syntaxe de l’opérateur -Split pour votre référence. N’oubliez pas de noter la différence entre la division unaire et binaire.

# Séparation unaire
-Split <String>
-Split (<String[]>)

# Séparation binaire
<String> -Split <Delimiter>[,<Max-substrings>[,"<Options>"]]
<String> -Split {<ScriptBlock>} [,<Max-substrings>]

Dans cet exemple, la variable $string contient la valeur d’une chaîne d’une seule ligne. Ensuite, avec l’opérateur -Split, la chaîne d’une seule ligne sera divisée en un tableau de chaînes PowerShell. La chaîne divisée résultante est enregistrée dans la variable $split.

## Division de chaînes en sous-chaînes
# Affectez une valeur de chaîne à la variable $string
$string = 'This sentence will be split between whitespaces'
# Divisez la valeur de $string et stockez le résultat dans la variable $split
$split = -split $string
# Obtenez le nombre de sous-chaînes résultantes
$split.Count
# Affichez les sous-chaînes résultantes
$split

Comme vous pouvez le voir à partir du résultat ci-dessus, ce qui était initialement une seule chaîne a été divisée en 7 sous-chaînes. Cela démontre comment PowerShell divise une chaîne en un tableau.

Le délimiteur de caractères

Dans l’exemple précédent, l’opérateur -Split a divisé l’objet de chaîne unique en plusieurs sous-chaînes même sans spécifier un délimiteur; c’est parce que le délimiteur par défaut de l’opérateur -Split est l’espace blanc. Cependant, les délimiteurs peuvent également être des caractères, des chaînes, des motifs ou des blocs de script.

Dans cet exemple, le délimiteur utilisé est le point-virgule ;.

## Division de chaînes en sous-chaînes avec un délimiteur
# Attribuer une valeur de chaîne à la variable $string
$string = 'This;sentence;will;be;split;between;semicolons'
# Diviser la valeur de $string et stocker le résultat dans la variable $split
$split = $string -split ";"
# Obtenir le nombre de sous-chaînes résultantes
$split.Count
# Afficher les sous-chaînes résultantes
$split

Lorsque vous testez le code ci-dessus dans PowerShell, vous obtenez le résultat ci-dessous.

Splitting a String into Substrings with Character Delimiter

Vous remarquez à partir de la sortie ci-dessus que le caractère de délimiteur a été omis des sous-chaînes résultantes.

Si, pour une raison quelconque, vous avez besoin de conserver le caractère de délimiteur, le délimiteur peut être conservé en le plaçant entre parenthèses.

$split = $string -split "(;)"
$split.Count
$split

Après avoir modifié le délimiteur de division, comme indiqué ci-dessus, son exécution donnerait le résultat indiqué ci-dessous.

Splitting a string on semicolon

Le résultat ci-dessus montre que les caractères de délimiteur ne sont pas omis et sont comptés dans les sous-chaînes résultantes.

Le délimiteur de chaîne

Les chaînes peuvent également être divisées par une autre chaîne en tant que délimiteur. Dans cet exemple, la chaîne « jour » est utilisée comme délimiteur.

$daysOfTheWeek= 'monday,tuesday,wednesday,thursday,friday,saturday,sunday'
$daysOfTheWeek -split "day"

Le délimiteur de bloc de script

A scriptBlock as the delimiter enables the -Split operator to perform custom or complex splitting of strings.

Dans les exemples précédents, le caractère ou la chaîne de délimiteur est utilisé pour diviser les chaînes. Avec l’utilisation d’un bloc de script, vous pouvez créer une expression qui utilise efficacement plus d’un délimiteur.

L’exemple ci-dessous utilise l’expression {$PSItem -eq 'e' -or $PSItem -eq 'y'}, ce qui signifie que la chaîne sera divisée si le caractère entrant est 'e' ou 'a'.

$daysOfTheWeek= 'monday,tuesday,wednesday,thursday,friday,saturday,sunday'
$daysOfTheWeek -split {$PSItem -eq 'e' -or $PSItem -eq 'y'}

Et lorsque vous exécutez cette commande ci-dessus, la sortie sera des sous-chaînes qui sont divisées avec les caractères délimiteurs spécifiés dans l’expression du bloc de script.

Splitting a String into Substrings with a Script Block Delimiter

Cet exemple suivant fait un peu plus avec un bloc de script. Cette fois, l’expression évalue si :

  • Le caractère entrant passe en tant qu’entier ; et
  • Que sa valeur est supérieure à 1.

Si le résultat de l’évaluation est vrai, alors l’opérateur -Split utilisera ce caractère comme délimiteur. De plus, une gestion des erreurs est ajoutée pour filtrer les erreurs.

$daysOfTheWeek= 'monday1tuesday2wednesday3thursday1friday4saturday8sunday'
$daysOfTheWeek -split {
    try {
        [int]$PSItem -gt 1
    }
    catch {
        #NE RIEN FAIRE
    }
}

Après avoir exécuté le code indiqué ci-dessus, on s’attend à ce que la chaîne soit divisée à l’endroit où la valeur du caractère peut être convertie en entier avec une valeur supérieure à 1. Le résultat attendu est indiqué ci-dessous.

Splitting a String into Substrings with a Script Block Delimiter

Le délimiteur RegEx

Par défaut, l’opérateur -Split utilise une correspondance RegEx pour le délimiteur spécifié. Cela signifie que vous pouvez également utiliser des expressions régulières comme délimiteurs pour diviser les chaînes.

Dans cet exemple suivant, la chaîne contient des caractères de mots et des caractères non-mots. Le but est de diviser la chaîne avec n’importe quel caractère non-mot. En RegEx, les caractères non-mots sont représentés par \W, tandis que les caractères de mots qui correspondent à ces caractères – [a-zA-Z0-9_] – sont représentés par \w.

$daysOfTheWeek= 'monday=tuesday*wednesday^thursday#friday!saturday(sunday'
$daysOfTheWeek -split "\W"

Limitation des sous-chaînes

Il est également possible d’empêcher l’opérateur -Split de diviser une chaîne en un certain nombre de sous-chaînes. L’option qui peut être utilisée pour limiter le résultat des sous-chaînes est le paramètre <Max-sous-chaînes>.

Lorsque vous vous référez à la syntaxe de -Split, le paramètre <Max-sous-chaînes> est le paramètre qui suit directement le paramètre <Délimité>. La syntaxe est à nouveau indiquée ci-dessous à titre de référence.

<String> -Split <Delimiter>[,<Max-substrings>[,"<Options>"]]

En suivant la syntaxe ci-dessus, le code d’exemple ci-dessous est modifié pour limiter le nombre de divisions/sous-chaînes à 3.

$daysOfTheWeek= 'monday,tuesday,wednesday,thursday,friday,saturday,sunday'
$daysOfTheWeek -split ",",3

Et, en exécutant le code ci-dessus, le résultat est le suivant. Comme vous pouvez le voir, la chaîne a été divisée en seulement trois sous-chaînes. Les délimiteurs restants ont été ignorés.

Limiting the Number of Substrings starting from the first 3 matched delimiters

Maintenant, si vous voulez limiter les sous-chaînes, mais à l’envers, vous pouvez changer la valeur du paramètre <Max-sous-chaînes> en une valeur négative. Dans cet exemple suivant, le paramètre <Max-sous-chaînes> est modifié en -3.

$daysOfTheWeek= 'monday,tuesday,wednesday,thursday,friday,saturday,sunday'
$daysOfTheWeek -split ",",-3

Et comme résultat du code modifié ci-dessus, la chaîne a été divisée à partir des trois derniers délimiteurs correspondants.

Limiting the Number of Substrings starting from the last 3 matched delimiters

Recherche et Remplacement de Chaînes

Dans cette section, vous apprendrez les deux méthodes qui peuvent être utilisées pour rechercher et effectuer un remplacement de chaîne PowerShell. La méthode Replace() et l’opérateur -Replace.

La méthode Replace()

L’objet de chaîne dispose également d’une méthode intégrée qui peut aider à effectuer des opérations de recherche et de remplacement – la méthode replace(). La méthode replace() prend un maximum de quatre surcharges.

L’ensemble acceptable de surcharges pour la méthode replace() est répertorié ci-dessous.

<String>.Replace(<original>, <substitute>[, <ignoreCase>][, <culture>])

Les seules surcharges requises sont le <original> et le <substitute>. Le <ignoreCase> et le <culture> sont facultatifs.

Dans l’exemple ci-dessous, le code recherchera toutes les occurrences du caractère virgule (,) et les remplacera par un point-virgule (;).

$daysOfTheWeek = 'monday,tuesday,wednesday,thursday,friday,saturday,sunday'
$daysOfTheWeek.Replace(',',';')

En plus de remplacer un seul caractère, vous pouvez également utiliser la méthode replace() pour rechercher et remplacer des chaînes. Le code d’exemple ci-dessous remplace le mot « jour » par « nuit ».

$daysOfTheWeek = 'monday,tuesday,wednesday,thursday,friday,saturday,sunday'
$daysOfTheWeek.Replace('day','NIGHT')
Replacing a matched string using the replace() method

L’opérateur -Replace

La syntaxe de l’opérateur de remplacement est indiquée ci-dessous.

<string> -replace <original>, <substitute>

En utilisant la syntaxe ci-dessus, le code d’exemple ci-dessous remplace le mot « jour » par « Nuit » avec l’opérateur -replace.

$daysOfTheWeek = 'monday,tuesday,wednesday,thursday,friday,saturday,sunday'
$daysOfTheWeek -replace 'day','NIGHT'
Replacing a matched character with the -replace operator

Cet exemple suivant utilise une correspondance RegEx pour remplacer des chaînes de caractères avec l’opérateur -replace. Le code ci-dessous recherche la chaîne de caractères ici pour trouver la chaîne qui correspond (#.) et les remplace par rien.

$daysOfTheWeek = @'
1. Line 1
2. Line 2
3. Line 3
4. Line 4
5. Line 5
'@
$daysOfTheWeek -replace "\d.\s",""
Replacing a RegEx match using -replace

Extraire des chaînes de caractères à partir de chaînes de caractères

L’objet chaîne a une méthode appelée SubString(). La méthode SubString() est utilisée pour extraire des chaînes de caractères à l’intérieur de chaînes de caractères à des emplacements spécifiques. La syntaxe de la méthode SubString() est indiquée ci-dessous.

<String>.SubString(<startIndex>[,<length>])

Le startIndex est l’indice de position où la méthode SubString() commencera la recherche. Le paramètre length indique le nombre de caractères à renvoyer à partir de startIndex. Le paramètre length est facultatif, et s’il n’est pas utilisé, la méthode SubString() renverra tous les caractères.

Extraire une sous-chaîne à partir d’une position de départ et d’une longueur fixe

Le code d’exemple ci-dessous récupère la partie de la valeur de chaîne $guid à partir de l’indice 9 et renvoie exactement les 5 caractères qui suivent.

$guid = 'e957d74d-fa16-44bc-9d72-4bea54952d8a'
$guid.SubString(9,5)

Extraire une sous-chaîne à partir d’une position de départ dynamique

Cet exemple suivant montre comment vous pouvez utiliser la propriété de longueur de chaîne PowerShell pour définir dynamiquement un indice de départ.

Le code ci-dessous fait ce qui suit:

  • Obtient la longueur de l’objet chaîne.
  • Obtient l’indice de l’indice médian en divisant la longueur par 2.
  • Utilise l’indice médian comme indice de départ de la sous-chaîne.
$guid = 'e957d74d-fa16-44bc-9d72-4bea54952d8a'
$guid.SubString([int]($guid.Length/2))

Étant donné que la valeur de length n’a pas été spécifiée, la méthode Substring() a renvoyé tous les caractères à partir de l’indice de départ.

Extracting a Substring from a Dynamic Starting Position

Comparaison des chaînes PowerShell

Vous pouvez également utiliser PowerShell pour comparer des chaînes en utilisant les méthodes intégrées de l’objet chaîne telles que CompareTo(), Equals() et Contains(). Ou en utilisant les opérateurs de comparaison PowerShell .

Utilisation de la méthode CompareTo()

La méthode CompareTo() renvoie une valeur de 0 si les deux chaînes ont la même valeur. Par exemple, le code ci-dessous compare deux objets chaîne.

$string1 = "This is a string"
$string2 = "This is a string"
$string1.CompareTo($string2)

Et étant donné que les valeurs sont les mêmes, le résultat devrait être 0, comme indiqué ci-dessous.

Using CompareTo() method to compare strings

Utilisation de la méthode Equals() et de l’opérateur -eq

La méthode Equals() et l’opérateur -eq peuvent être utilisés pour vérifier si la valeur des deux chaînes est égale.

L’exemple ci-dessous utilise la méthode Equals() pour comparer les valeurs de $string1 et $string2.

$string1 = "This is a string"
$string2 = "This is not the same string"
$string1.Equals($string2)

Le code ci-dessus devrait renvoyer False car les valeurs de $string1 et $string2 ne sont pas égales.

Comparing strings with the Equals() method

L’exemple suivant utilise -eq à la place pour comparer les valeurs de $string1 et $string2.

$string1 = "This is a string"
$string2 = "This is not the same string"
$string1 -eq $string2

Comme vous pouvez le voir dans la sortie ci-dessous, le résultat lors de l’utilisation de -eq et de la méthode Equal() est le même.

Comparing strings with the -eq operator

Utilisation de la méthode Contains()

Dans cet exemple, les deux chaînes sont comparées en vérifiant si la chaîne PowerShell contient la sous-chaîne d’une autre chaîne.

Le code ci-dessous montre que les valeurs de $string1 et $string2 ne sont pas égales. Cependant, la valeur de $string2 est une sous-chaîne de $string1.

$string1 = "This is a string 1"
$string2 = "This is a string"
$string1.Contains($string2)

Le résultat du code ci-dessus devrait être True, comme indiqué ci-dessous.

Comparing strings using the Contains() method

Lecture complémentaire

Source:
https://adamtheautomator.com/powershell-strings/