Comment vérifier le début d'une chaîne en utilisant PowerShell

1. Utiliser l’opérateur logique -like pour vérifier le début d’une chaîne dans PowerShell
2. Utiliser l’opérateur logique -clike pour vérifier le début d’une chaîne dans PowerShell
3. Utiliser la fonction StartsWith() pour vérifier le début d’une chaîne dans PowerShell
4. Comparaison avec le sous-chaîne pour vérifier le début d’une chaîne dans PowerShell
5. Conclusion

Il peut y avoir des cas où nous rencontrons un cas d’utilisation qui peut nécessiter une fonctionnalité pour vérifier si une variable de chaîne commence par un caractère ou une chaîne. Vérifier si une chaîne commence par un caractère ou une chaîne spécifique est une pratique courante lors de la création de scripts et est également raisonnablement facile à écrire dans Windows PowerShell.

Cet article démontrera comment vérifier le début d’une variable de chaîne en utilisant différentes méthodes dans Windows PowerShell.

Utiliser l’opérateur logique -like pour vérifier le début d’une chaîne dans PowerShell

Dans PowerShell, l’opérateur logique -Like est un outil puissant pour la correspondance de modèles. Lorsqu’il est utilisé pour vérifier le début d’une chaîne, il permet des comparaisons flexibles basées sur des jokers.

Par défaut, l’opérateur -Like ignore l’énoncé sensible à la casse. Cependant, si nous utilisons des opérateurs logiques, il doit être associé à un joker astérisque (*).

Code:

$strVal = 'Hello World'
if ($strVal -like 'hello*') {
    Write-Host "Your string starts with hello."
}
else {
    Write-Host "Your string does not start with hello."
}

Sortie :

Your string starts with hello.

Dans le code, nous initialisons une variable de chaîne, $strVal = 'Hello World'. Nous utilisons ensuite l’opérateur -like pour vérifier si la chaîne ($strVal) commence par le préfixe 'hello'.

L’opérateur -like permet une correspondance de modèles en utilisant des jokers, et dans ce cas, l’astérisque (*) représente zéro ou plusieurs caractères. L’énoncé conditionnel évalue si la chaîne correspond au modèle 'hello*'.

Dans ce cas, la condition est vraie, et la sortie est Votre chaîne commence par hello.

Utiliser l’opérateur logique -clike pour vérifier le début d’une chaîne dans PowerShell

L’opérateur -clike dans PowerShell est utilisé pour effectuer une comparaison de chaîne sensible à la casse. Il vérifie si une chaîne correspond à un modèle spécifié, similaire à l’opérateur -like, mais il est sensible à la casse.

Cela signifie que l’opérateur -clike ne renverra True que si la casse des caractères dans la chaîne correspond exactement à la casse des caractères dans le modèle. Nous pouvons utiliser l’opérateur -cLike pour effectuer une comparaison sensible à la casse.

Code:

$strVal = 'Hello World!'
if ($strVal -clike 'h*') {
    Write-Host "Your string starts with lowercase h."
}
else {
    Write-Host "Your string starts with uppercase H."
}

Sortie :

Your string starts with uppercase H.

Dans ce code, nous initialisons une variable de chaîne, $strVal, avec la valeur 'Hello World!'. Nous employons l’opérateur -clike, qui est utilisé pour une comparaison de chaînes sensible à la casse, pour vérifier si la chaîne commence par la lettre minuscule 'h'.

L’énoncé conditionnel évalue si la chaîne correspond au modèle 'h*' de manière sensible à la casse. Comme la condition est fausse, indiquant que la chaîne commence par un 'H' majuscule, nous sortons Votre chaîne commence par un H majuscule.

N’oubliez pas que l’opérateur -clike est sensible à la casse, donc il ne correspondra pas aux chaînes si la casse des caractères ne correspond pas exactement. Si nous voulons effectuer une comparaison insensible à la casse, nous pouvons utiliser l’opérateur -like à la place.

Utiliser la fonction StartsWith() pour vérifier le début d’une chaîne dans PowerShell

Nous pouvons également utiliser la fonction d’extension de chaîne du framework .NET appelée StartsWith() pour vérifier si une chaîne commence par un ensemble de caractères.

La fonction StartsWith() dans PowerShell est une méthode pour vérifier si une chaîne commence par un préfixe spécifié. La fonction StartsWith() est une méthode intégrée pour les chaînes dans PowerShell qui renvoie une valeur booléenne indiquant si la chaîne donnée commence par le sous-chaîne spécifiée.

Code:

$strVal = 'Hello World!'
if ($strVal.StartsWith('Hello')) {
    Write-Host 'Your string starts with hello.'
}
else {
    Write-Host 'Your string does not start with hello.'
}

Sortie :

Your string starts with hello.

Dans le code ci-dessus, nous vérifions si la variable de chaîne $strVal commence par 'Hello' en utilisant la méthode StartsWith(). Comme la condition est vraie, nous sortons Votre chaîne commence par hello.

La fonction StartsWith accepte également un autre argument que nous pouvons utiliser pour vérifier les caractères sensibles à la casse. Cet argument est CurrentCultureIgnoreCase.

Nous utiliserons la méthode suivante si nous voulons effectuer une comparaison sensible à la casse.

Code:

$strVal = 'Hello world'
if ($strVal.StartsWith('hello', 'CurrentCultureIgnoreCase')) {
    Write-Host 'True'
}
else {
    Write-Host 'False'
}

Sortie :

True

Dans ce code, nous vérifions si la variable de chaîne $strVal commence par 'hello' de manière insensible à la casse en utilisant la méthode StartsWith() avec le paramètre 'CurrentCultureIgnoreCase'. Comme la condition est vraie, nous sortons True.

Comparaison avec le sous-chaîne pour vérifier le début d’une chaîne dans PowerShell

Dans cette approche, la fonction Substring() est utilisée pour comparer un préfixe spécifié avec la partie initiale d’une chaîne donnée. Cette comparaison aide à déterminer si la chaîne commence par la séquence de caractères prédéfinie.

Dans PowerShell, la méthode Substring permet d’extraire une portion d’une chaîne en fonction de l’index de départ et de la longueur spécifiés. En utilisant cette méthode, nous pouvons acquérir une sous-chaîne à partir de la chaîne d’origine, puis la comparer avec un préfixe souhaité pour vérifier si la chaîne commence par cette séquence spécifique.

Syntaxe de base :

$substringToCompare = $strVal.Substring(0, $prefix.Length)

Paramètres :

• $strVal - C’est la variable contenant la chaîne d’origine dont nous voulons extraire une sous-chaîne.
• 0 - Le 0 est l’index de départ.
• $prefix.Length - C’est la longueur de la sous-chaîne à extraire. Dans notre exemple, c’est la longueur du préfixe que nous voulons vérifier.
• $substringToCompare - C’est une variable qui stocke le résultat de l’opération Substring. Elle contiendra la sous-chaîne extraite de la chaîne d’origine.

La syntaxe ci-dessus crée essentiellement une sous-chaîne à partir de la chaîne d’origine, en commençant par le début, avec une longueur égale à la longueur du préfixe spécifié.

Code:

$strVal = 'Hello World!'
$prefix = 'Hello'

if ($strVal.Substring(0, $prefix.Length) -eq $prefix) {
    Write-Output "String starts with $prefix"
}
else {
    Write-Output "String does not start with $prefix"
}

Sortie :

String starts with Hello

Dans ce code, nous avons une variable de chaîne, $strVal = 'Hello World!' et un préfixe, $prefix = 'Hello'. Nous utilisons la méthode Substring() pour extraire une portion de la chaîne d’origine en commençant par l’index 0 avec une longueur identique à la longueur du préfixe.

Le script compare ensuite cette sous-chaîne extraite avec le préfixe spécifié en utilisant l’opérateur -eq. Comme la condition est vraie, indiquant que la chaîne commence par 'Hello', nous sortons La chaîne commence par Hello.

Conclusion

En conclusion, cet article a démontré diverses méthodes pour vérifier le début d’une variable de chaîne dans Windows PowerShell. Nous avons exploré l’utilisation de l’opérateur logique -like pour la correspondance de modèles, mettant en avant sa flexibilité avec les jokers.

De plus, nous avons approfondi l’opérateur logique -clike pour des comparaisons sensibles à la casse. En outre, nous avons couvert la fonction StartsWith(), utilisant des vérifications sensibles et insensibles à la casse pour déterminer si la chaîne commence par un préfixe spécifié.

Enfin, nous avons examiné la fonction Substring() comme une approche alternative, illustrant son application dans la comparaison d’une sous-chaîne avec une séquence prédéfinie et en produisant des résultats basés sur l’évaluation. Ces méthodes offrent une polyvalence pour différents cas d’utilisation, renforçant les capacités de comparaison de chaînes dans les scripts PowerShell.