Publicité
+ Répondre à la discussion
Affichage des résultats 1 à 2 sur 2
  1. #1
    Membre Expert
    Profil pro
    Inscrit en
    mai 2004
    Messages
    1 254
    Détails du profil
    Informations personnelles :
    Localisation : Belgique

    Informations forums :
    Inscription : mai 2004
    Messages : 1 254
    Points : 1 299
    Points
    1 299

    Par défaut [FAQ] Comment rendre ses expressions rationnelles lisibles et maintenables

    Comment écrire plus facilement des expressions rationnelles (ou régulières)

    Une expression rationnelle est souvent un truc (oui, truc) moche et complètement illisible. Pour pallier à cela, réfléchissez à la manière dont vous voulez construire une expression rationnelle. Et n'hésitez pas à la construire sur plusieurs lignes, et même de la documenter.

    Pour ce faire, deux solutions existent : la première est de créer son expression comme une concaténation de plusieurs chaînes ; la seconde est l'utilisation du flag COMMENT (ou x, en perl).

    Voyons voir une expression rationnelle qui à première vue est illisible :

    Code :
    Pattern regex = Pattern.compile("^((?:ht|f)tps?)://((?:\\p{Alpha}(?:-?\\w+)*\\.)*\\p{Alpha}\\w*|(?:\\d+\\.){3}\\d+)(?::(\\d{1,5}))?/");
    La première solution serait de l'écrire comme ceci :
    Code :
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    Pattern regex = Pattern.compile(
       "^"                               // Début de ligne
     + "((?:ht|f)tps?)"                  // Récupération du protocole : http, https, ftp ou ftps, on oublie le groupe formé par ht|f.
     + "://"                             // séparateur protocole - hôte.
     + "("                               // Nous désirons capturer le nom d'hôte dans son intégralité.
       + "(?:\\p{Alpha}(?:-?\\w+)*\\.)*" // Un nom d'hôte est formé d'une lettre, suivi d'un tiret facultatif et pour chaque tiret, il doit être suivi d'un caractère autre qu'un tiret.
       + "\\p{Alpha}\\w*"                // La dernière partie du nom d'hôte ne peut comporter que des caractères alphanumériques, avec une lettre en première position.
     + "|"                               // ou alors une adresse IP
       + "(?:\d+\.){3}"                  // Une adresse IP v4 est formée de chiffres suivis d'un point, 3 fois
       + "\d+"                           // et se termine par des chiffres.
     + ")"                               // Fin de la capture du nom d'hôte.
     + "(?::(\d{1,5}))?"                 // S'il y a un port, on le récupère également dans son propre groupe. On évite soigneusement de récupérer le "deux-points".
     + "/"                               // Fin de l'expression rationnelle liée à une URL.
    );
    La deuxième solution est d'utiliser des commentaires directement dans l'expression.

    Code :
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    Pattern regex = Pattern.compile("
      ^                                # Début de ligne
      ((?:ht|f)tps?)                   # Récupération du protocole : http, https, ftp ou ftps, on oublie le groupe formé par ht|f.
      ://                              # séparateur protocole - hôte.
      (                                # Nous désirons capturer le nom d'hôte dans son intégralité.
        (?:\\p{Alpha}(?:-?\\w+)*\\.)*  # Un nom d'hôte est formé d'une lettre, suivi d'un tiret facultatif et pour chaque tiret, il doit être suivi d'un caractère autre qu'un tiret.
        \p{Alpha}\w*                   # La dernière partie du nom d'hôte ne peut comporter que des caractères alphanumériques, avec une lettre en première position.
      |                                # ou alors une adresse IP
        (?:\d+\.){3}                   # Une adresse IP v4 est formée de chiffres suivis d'un point, 3 fois
        \d+                            # et se termine par des chiffres.
      )                                # Fin de la capture du nom d'hôte.
      (?::(\d{1,5}))?                  # S'il y a un port, on le récupère également dans son propre groupe. On évite soigneusement de récupérer le "deux-points".
      /                                # Fin de l'expression rationnelle liée à une URL.
    ", Pattern.COMMENT);
    Comme vous pourrez le constater, les trois expressions présentées ici sont parfaitement identiques, mais les deux dernières sont bien plus lisibles.

    Attention, certains EDI, dont Eclipse, ne supportent pas les les chaînes sur plusieurs lignes comme montrée dans le troisième exemple.

  2. #2
    Expert Confirmé Sénior
    Avatar de adiGuba
    Homme Profil pro
    Développeur Java/Web
    Inscrit en
    avril 2002
    Messages
    13 026
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Développeur Java/Web
    Secteur : Transports

    Informations forums :
    Inscription : avril 2002
    Messages : 13 026
    Points : 20 808
    Points
    20 808

    Par défaut

    Citation Envoyé par dingoth Voir le message
    Attention, certains EDI, dont Eclipse, ne supportent pas les les chaînes sur plusieurs lignes comme montrée dans le troisième exemple.
    Euh...
    Sauf erreur c'est le langage tout court qui n'autorise pas cela !?
    Tu as un EDI/compilateur qui accepte cela ???

    a++

Liens sociaux

Règles de messages

  • Vous ne pouvez pas créer de nouvelles discussions
  • Vous ne pouvez pas envoyer des réponses
  • Vous ne pouvez pas envoyer des pièces jointes
  • Vous ne pouvez pas modifier vos messages
  •