Un guide complet pour les ingénieurs en automatisation / Blogs / Perficient

Les expressions régulières, souvent abrégées en regex, constituent des atouts indispensables pour les ingénieurs automation. Ces constructions dynamiques facilitent la mise en correspondance de modèles et la manipulation de texte, formant une base solide pour des tâches allant de la validation des données aux opérations complexes de recherche et de remplacement. Ce guide complet vise à naviguer à travers les subtilités des regex, s’adressant à différents niveaux de compétence — des débutants aux utilisateurs intermédiaires et avancés.

Regex adapté aux débutants

\d – Correspondance des chiffres

L’expression \d est un outil fondamental pour identifier les chiffres compris entre 0 et 9. Par exemple, l’utilisation de \d{3} permet une capture précise de trois chiffres consécutifs, offrant une reconnaissance précise des modèles numériques. Dans un scénario pratique :

import java.util.regex.*;

public class Main {

    public static void main(String[] args) {

        String text = "The price is $500.";

        Pattern pattern = Pattern.compile("\\d{3}");

        Matcher matcher = pattern.matcher(text);

        if (matcher.find()) {

            System.out.println("Found: " + matcher.group());

        }

    }

}

\w – Adopter les caractères des mots

\w s’avère utile pour reconnaître les caractères de mots, englobant les caractères alphanumériques et les traits de soulignement. Lorsqu’il est couplé au quantificateur + (\w+), il se transforme en un outil polyvalent pour capturer un ou plusieurs caractères de mots. Par exemple:

import java.util.regex.*;

public class Main {

    public static void main(String[] args) {

        String text = "User_ID: john_doe_123";

        Pattern pattern = Pattern.compile("\\w+");

        Matcher matcher = pattern.matcher(text);

        if (matcher.find()) {

            System.out.println("Found: " + matcher.group());

        }

    }

}

\s – Reconnaître les caractères d’espacement

\s devient l’expression préférée pour identifier les caractères d’espacement, y compris les espaces, les tabulations et les sauts de ligne. La flexibilité de \s* permet la reconnaissance de zéro ou plusieurs caractères d’espacement. Un exemple:

import java.util.regex.*;

public class Main {

    public static void main(String[] args) {

        String text = "   This is a sentence with spaces.   ";

        Pattern pattern = Pattern.compile("\\s*");

        Matcher matcher = pattern.matcher(text);

        if (matcher.find()) {

            System.out.println("Found: " + matcher.group());

        }

    }

}

Techniques d’expression régulière intermédiaires

\D – Reconnaissance de caractères non numériques

S’appuyant sur la fondation \d, \D complète en identifiant tout caractère qui n’est pas un chiffre. L’application de \D+ capture efficacement un ou plusieurs caractères non numériques. Considérer ce qui suit:

import java.util.regex.*;

public class Main {

    public static void main(String[] args) {

        String text = "#XYZ123";

        Pattern pattern = Pattern.compile("\\D+");

        Matcher matcher = pattern.matcher(text);

        if (matcher.find()) {

            System.out.println("Found: " + matcher.group());

        }

    }

}

\W – Identification de caractères non-verbaux

Parallèlement à \w, \W élargit l’horizon en identifiant tout caractère qui n’est pas un caractère de mot. Considérez \W{2,} pour capturer deux ou plusieurs caractères autres que des mots. Exemple:

import java.util.regex.*;

public class Main {

    public static void main(String[] args) {

        String text = "Special characters: @$!%";

        Pattern pattern = Pattern.compile("\\W{2,}");

        Matcher matcher = pattern.matcher(text);

        if (matcher.find()) {

            System.out.println("Found: " + matcher.group());

        }

    }

}

Tactiques avancées de Regex

[g-s] – Inclusion de la plage de caractères

Présentation du concept de plages de caractères, [g-s] identifie tout caractère compris entre « g » et « s », inclus. Cela s’avère utile pour capturer un ensemble spécifique de caractères dans une plage définie. Par exemple:

import java.util.regex.*;

public class Main {

    public static void main(String[] args) {

        String text = "The highlighted section goes from g to s.";

        Pattern pattern = Pattern.compile("[g-s]+", Pattern.CASE_INSENSITIVE);

        Matcher matcher = pattern.matcher(text);

        if (matcher.find()) {

            System.out.println("Found: " + matcher.group());

        }

    }

}

Application de données réelles

La véritable maîtrise des regex réside dans son application pratique aux données du monde réel. S’entraîner régulièrement avec des ensembles de données authentiques améliore la compréhension et la compétence.

Supposons que vous disposiez d’un ensemble de données de numéros de téléphone et que vous souhaitiez extraire tous les indicatifs régionaux. Vous pouvez utiliser l’expression régulière suivante :

import java.util.regex.*;
import java.util.ArrayList;
import java.util.List;

public class Main {

    public static void main(String[] args) {

        String data = "Phone numbers: (123) 456-7890, (987) 654-3210, (555) 123-4567";

        Pattern pattern = Pattern.compile("\\(\\d{3}\\)");

        Matcher matcher = pattern.matcher(data);

        List<String> areaCodes = new ArrayList<>();

        while (matcher.find()) {

            areaCodes.add(matcher.group());

        }

        System.out.println("Area Codes: " + areaCodes);

    }

}

Sortir:

En conclusion:

En conclusion, les expressions régulières se présentent comme un outil puissant qui, lorsqu’il est utilisé à bon escient, permet aux ingénieurs en automatisation de relever divers défis en matière de développement et de test de logiciels. En comprenant les nuances des expressions regex à différents niveaux de compétence, les ingénieurs peuvent améliorer leur capacité à créer des scripts d’automatisation efficaces et efficients.