Boîtier de commutation PowerShell avec Regex

Récemment, je travaillais sur quelques exemples du cas du commutateur PowerShell et j'ai appris à utiliser Regex dans le cas du commutateur dans PowerShell. Laissez-moi vous expliquer avec quelques exemples.

Avant de discuter de l'utilisation de regex avec l'instruction PowerShell Switch the, permettez-moi de vous montrer un exemple simple de l'instruction switch.

Déclaration de commutateur PowerShell

L'instruction Switch dans PowerShell est similaire aux instructions switch ou case que l'on trouve dans d'autres langages de programmation. Il évalue une expression et exécute le bloc de code correspondant en fonction de la valeur de cette expression. Voici un exemple de base :

$fruit = "apple"

Switch ($fruit) {
    "apple" { Write-Output "This is an apple." }
    "banana" { Write-Output "This is a banana." }
    "orange" { Write-Output "This is an orange." }
    default { Write-Output "Unknown fruit." }
}

Dans cet exemple, l'instruction Switch vérifie la valeur de la variable $fruit et exécute le bloc de code correspondant. Si $fruit est "pomme", il affiche "Ceci est une pomme". Si c'est « banane », il affiche « Ceci est une banane. », et ainsi de suite. Si aucun des cas ne correspond, le bloc default est exécuté.

Maintenant, laissez-moi vous montrer comment utiliser Regex dans une instruction switch PowerShell.

Regex dans l'instruction PowerShell Switch

Les expressions régulières sont des séquences de caractères qui définissent un modèle de recherche. Dans PowerShell, vous pouvez utiliser l'expression régulière avec l'opérateur -match ou dans une instruction Switch à l'aide du paramètre -regex .

Pour utiliser une expression régulière dans une instruction Switch , vous devez spécifier le paramètre -regex . Cela indique à PowerShell d'interpréter les valeurs de cas comme des expressions régulières. Voici un exemple :

$text = "San Francisco, new york, LOS ANGELES, Dallas, miami"

Switch -Regex -CaseSensitive ($text) {
    "^San Francisco" { Write-Output "The text starts with 'San Francisco'." }
    "new york" { Write-Output "The text contains the city 'new york'." }
    "LOS ANGELES" { Write-Output "The text contains the city 'LOS ANGELES'." }
    "miami$" { Write-Output "The text ends with 'miami'." }
    default { Write-Output "No match found." }
}

Dans cet exemple, l'instruction Switch utilise une expression régulière pour faire correspondre les modèles dans la variable $text .

Après avoir exécuté le script PowerShell ci-dessus, vous pouvez voir le résultat dans la capture d'écran ci-dessous :

Lire la boucle PowerShell ForEach

Correspondance insensible à la casse avec PowerShell Switch et Regex

Par défaut, l'instruction PowerShell Switch n'est pas sensible à la casse lors de l'utilisation d'expressions régulières. Cela signifie qu'il correspondra aux modèles quelle que soit la casse des caractères dans la chaîne d'entrée. Cependant, vous pouvez spécifier explicitement le respect de la casse si nécessaire. Explorons un exemple de correspondance insensible à la casse à l'aide de l'instruction Switch avec regex.

Exemple : correspondance insensible à la casse avec Regex

Supposons que vous disposiez d'une liste PowerShell de chaînes qui représentent différents types de fruits et que vous souhaitiez les classer quelle que soit la casse (majuscule ou minuscule). Voici comment procéder avec le script PowerShell ci-dessous.

$fruits = @("Apple", "banana", "CHERRY", "mango", "Pineapple")

foreach ($fruit in $fruits) {
    Switch -Regex ($fruit) {
        "apple" { Write-Output "Found an apple." }
        "banana" { Write-Output "Found a banana." }
        "cherry" { Write-Output "Found a cherry." }
        "mango" { Write-Output "Found a mango." }
        "pineapple" { Write-Output "Found a pineapple." }
        default { Write-Output "Unknown fruit: $fruit" }
    }
}

L'instruction Switch utilise des modèles d'expression régulière pour correspondre aux noms de fruits dans cet exemple. Parce que Switch Par défaut, l'instruction n'est pas sensible à la casse ; il correspondra correctement à « Apple », « banane », « CERISE », « mangue » et « Ananas », quelle que soit leur casse.

Vous pouvez voir le résultat dans la capture d'écran suivante après avoir exécuté le script PowerShell ci-dessus.

Découvrez la chaîne de commutateur PowerShell contient

Exemple : correspondance sensible à la casse avec Regex

Si vous devez respecter le respect de la casse, utilisez le paramètre -casesensitive dans l'instruction PowerShell Switch . Voici comment modifier l’exemple précédent pour qu’il soit sensible à la casse :

foreach ($fruit in $fruits) {
    Switch -Regex -CaseSensitive ($fruit) {
        "apple" { Write-Output "Found an apple." }
        "banana" { Write-Output "Found a banana." }
        "cherry" { Write-Output "Found a cherry." }
        "mango" { Write-Output "Found a mango." }
        "pineapple" { Write-Output "Found a pineapple." }
        default { Write-Output "Unknown fruit: $fruit" }
    }
}

Dans cet exemple modifié, l'instruction Switch ne correspondra aux noms de fruits que si la casse correspond exactement aux modèles spécifiés (par exemple, « apple » ne correspondra pas à « Apple »).

Lire la boucle while dans PowerShell

Cas de commutateur PowerShell avec exemples d'expressions régulières

Laissez-moi vous montrer quelques exemples du cas PowerShell Switch avec Regex.

Exemple 1 : faire correspondre les chiffres

Pour faire correspondre les chiffres d'une chaîne, vous pouvez utiliser le modèle \d dans une instruction Switch avec Regex. Voici un exemple.

$text = "Order number 12345 has been shipped."

Switch -Regex ($text) {
    "\d+" { Write-Output "The text contains digits." }
    default { Write-Output "No digits found." }
}

Le modèle \d+ fait correspondre un ou plusieurs chiffres dans le texte.

Vous pouvez voir le résultat dans la capture d'écran suivante.

Exemple 2 : faire correspondre les mots

Pour faire correspondre des mots spécifiques dans une chaîne, vous pouvez utiliser des limites de mots \b dans une instruction Switch avec Regex. Voici le script PowerShell complet.

$text = "PowerShell is a powerful scripting language."

Switch -Regex ($text) {
    "\bPowerShell\b" { Write-Output "The text contains the word 'PowerShell'." }
    "\blanguage\b" { Write-Output "The text contains the word 'language'." }
    default { Write-Output "No matching words found." }
}

Exemple 3 : faire correspondre les adresses e-mail

Pour faire correspondre les adresses e-mail, vous pouvez utiliser le modèle d'expression régulière ci-dessous dans un cas de commutation dans PowerShell.

$text = "Contact us at support@example.com for more information."

Switch -Regex ($text) {
    "\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b" { Write-Output "The text contains an email address." }
    default { Write-Output "No email address found." }
}

Ce modèle correspond aux formats d'adresses e-mail les plus courants.

Après avoir exécuté le script PowerShell ci-dessus, vous pouvez voir le résultat dans la capture d'écran ci-dessous.

Exemple 4 : Combiner plusieurs modèles

Ceci est un autre exemple ; Je vais vous montrer comment combiner plusieurs modèles dans une instruction Switch dans PowerShell.

Vous pouvez combiner plusieurs modèles d'expressions régulières dans une seule instruction Switch pour gérer des scénarios plus complexes. Par exemple, disons que vous souhaitez faire correspondre différents types de messages de journal dans un texte, à l'aide du script PowerShell ci-dessous.

$log = "ERROR: Disk space is low. WARNING: CPU usage is high. INFO: System rebooted."

Switch -Regex ($log) {
    "ERROR:.*" { Write-Output "An error occurred." }
    "WARNING:.*" { Write-Output "A warning was issued." }
    "INFO:.*" { Write-Output "Informational message." }
    default { Write-Output "No log messages found." }
}

Dans cet exemple, l'instruction Switch fait correspondre différents types de messages de journal (ERROR, ATTENTION, INFO) et exécute le bloc de code correspondant.

Exemple 5 : analyser les fichiers journaux

Laissez-moi vous montrer un autre exemple de la façon d'analyser un fichier journal à l'aide de l'expression régulière dans une instruction switch.

Voici un fichier journal avec différents types de messages et vous souhaitez les catégoriser à l'aide du script PowerShell ci-dessous.

$logMessages = @(
    "ERROR: Disk space is low.",
    "WARNING: CPU usage is high.",
    "INFO: System rebooted.",
    "ERROR: Network connection lost."
)

foreach ($message in $logMessages) {
    Switch -Regex ($message) {
        "ERROR:.*" { Write-Output "Error: $message" }
        "WARNING:.*" { Write-Output "Warning: $message" }
        "INFO:.*" { Write-Output "Info: $message" }
        default { Write-Output "Unknown message type: $message" }
    }
}

Ce script parcourt chaque message de journal et le catégorise en fonction du type de message (ERREUR, AVERTISSEMENT, INFO) à l'aide de modèles d'expression régulière dans l'instruction Switch .

Regardez la capture d'écran ci-dessous pour le résultat.

Exemple 6 : valider l'entrée de l'utilisateur

Supposons que vous souhaitiez valider les entrées utilisateur pour différents types de données, telles que les adresses e-mail, les numéros de téléphone et les codes postaux. Voici comment procéder en utilisant une expression régulière dans une instruction Switch :

function Validate-UserInput {
    param (
        [string]$input
    )

    Switch -Regex ($input) {
        "^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}$" { Write-Output "Valid email address." }
        "^\d{10}$" { Write-Output "Valid phone number." }
        "^\d{5}(-\d{4})?$" { Write-Output "Valid postal code." }
        default { Write-Output "Invalid input." }
    }
}

# Example usage
Validate-UserInput "john.doe@example.com"
Validate-UserInput "1234567890"
Validate-UserInput "12345-6789"
Validate-UserInput "invalid-input"

Dans cet exemple, la fonction Validate-UserInput() accepte une chaîne de saisie utilisateur. Il utilise une instruction Switch avec des modèles d'expression régulière pour valider si l'entrée est une adresse e-mail, un numéro de téléphone ou un code postal valide. Si l’entrée ne correspond à aucun des modèles, le message « Entrée invalide » s’affiche.

Exemple 7 : extraire des données du texte

Vous pouvez également utiliser l'expression régulière avec l'instruction Switch pour extraire des données spécifiques d'une chaîne de texte. Par exemple, extrayons les dates d'un texte en utilisant Regex avec une instruction Switch.

$text = "The project started on 2024-01-15 and ended on 2024-07-10."

Switch -Regex ($text) {
    "\b\d{4}-\d{2}-\d{2}\b" { Write-Output "Date found: $matches[0]" }
    default { Write-Output "No dates found." }
}

Dans cet exemple, le modèle d'expression régulière \b\d{4}-\d{2}-\d{2}\b correspond aux dates au format AAAA-MM-JJ. L'instruction Switch extrait et imprime toutes les dates trouvées dans le texte.

J'espère que vous savez maintenant comment utiliser Regex avec PowerShell Switch. Nous discutons de nombreux exemples.