le modèle 12 pourrait être réécrit de façon plus lisible

m{
    ^
    (
        ( \d )
        (?(?= ( \d ) ) | $ )
        (?(?{ ord  == 1 + ord  }) (?1) | $ )
    )
    $
}x

il utilise regex recursion , qui se trouve dans de nombreux modèles de moteurs, y compris Perl et tous les langages dérivés PCRE. Mais il utilise aussi un callout de code intégré comme test de son second pattern conditionnel; à ma connaissance, les callouts de code ne sont disponibles qu'en Perl et PCRE.

13-21 ont été dérivés du module Regexp::Common susmentionné. Notez que par souci de brièveté, ils sont tous écrits sans les espaces et les commentaires que vous voudriez certainement dans le code de production. Voici comment cela pourrait ressembler dans /x mode:

$real_rx = qr{ (   # start  to hold entire pattern
    ( [+-]? )                  # optional leading sign, captured into 
    (                          # start 
        (?=                    # look ahead for what next char *will* be
            [0123456789]       #    EITHER:  an ASCII digit
          | [.]                #    OR ELSE: a dot
        )                      # end look ahead
        (                      # start 
           [0123456789]{1,3}       # 1-3 ASCII digits to start the number
           (?:                     # then optionally followed by
               (?: [_,]? )         # an optional grouping separator of comma or underscore
               [0123456789]{3}     # followed by exactly three ASCII digits
           ) *                     # repeated any number of times
        )                          # end 
        (?:                        # begin optional cluster
             ( [.] )               # required literal dot in 
             ( [0123456789]{0,} )  # then optional ASCII digits in 
        ) ?                        # end optional cluster
     )                         # end 
    (?:                        # begin cluster group
        ( [E] )                #   base-10 exponent into 
        (                      #   exponent number into 
            ( [+-] ? )         #     optional sign for exponent into 
            ( [0123456789] + ) #     one or more ASCII digits into 
        )                      #   end 
      |                        #   or else nothing at all
    )                          # end cluster group
) }xi;          # end  and whole pattern, enabling /x and /i modes

du point de vue de l'ingénierie logicielle, il y a encore plusieurs problèmes avec le style utilisé dans la version en mode /x immédiatement ci-dessus. Tout d'abord, il y a beaucoup de répétition de code, où vous voyez le même [0123456789] ; que se passe-t-il si l'une de ces séquences laisse accidentellement un chiffre dehors? Deuxièmement, vous vous en remettez aux paramètres de position, que vous devez compter. Cela signifie que vous pourriez écrire quelque chose comme:

(
  $real_number,          # 
  $real_number_sign,     # 
  $pre_exponent_part,    # 
  $pre_decimal_point,    # 
  $decimal_point,        # 
  $post_decimal_point,   # 
  $exponent_indicator,   # 
  $exponent_number,      # 
  $exponent_sign,        # 
  $exponent_digits,      # 
) = ($string =~ /$real_rx/);

ce qui est franchement abominable! Il est facile d'obtenir la numérotation erronée, difficile de se rappeler quels noms symboliques vont où, et fastidieux à écrire, surtout si vous n'avez pas besoin de toutes ces pièces. Réécrire ça pour utiliser des groupes nommés au lieu de simplement numérotés. Encore une fois, j'utiliserai la syntaxe Perl pour les variables, mais le contenu du Pattern devrait fonctionner n'importe où que les groupes nommés soient pris en charge.

use 5.010;              # Perl got named patterns in 5.10
$real_rx = qr{
  (?<real_number>
    # optional leading sign
    (?<real_number_sign> [+-]? )
    (?<pre_exponent_part>
        (?=                         # look ahead for what next char *will* be
            [0123456789]            #    EITHER:  an ASCII digit
          | [.]                     #    OR ELSE: a dot
        )                           # end look ahead
        (?<pre_decimal_point>
            [0123456789]{1,3}       # 1-3 ASCII digits to start the number
            (?:                     # then optionally followed by
                (?: [_,]? )         # an optional grouping separator of comma or underscore
                [0123456789]{3}     # followed by exactly three ASCII digits
            ) *                     # repeated any number of times
         )                          # end <pre_decimal_part>
         (?:                        # begin optional anon cluster
            (?<decimal_point> [.] ) # required literal dot
            (?<post_decimal_point>
                [0123456789]{0,}  )
         ) ?                        # end optional anon cluster
   )                                # end <pre_exponent_part>
   # begin anon cluster group:
   (?:
       (?<exponent_indicator> [E] ) #   base-10 exponent
       (?<exponent_number>          #   exponent number
           (?<exponent_sign>   [+-] ?         )
           (?<exponent_digits> [0123456789] + )
       )                      #   end <exponent_number>
     |                        #   or else nothing at all
   )                          # end anon cluster group
 )                            # end <real_number>
}xi;

maintenant les abstractions sont nommées, ce qui aide. Vous pouvez retirer les groupes par leur nom, et vous n'avez besoin que de ceux auxquels vous tenez. Par exemple:

if ($string =~ /$real_rx/) {
    ($pre_exponent, $exponent_number) =
        @+{ qw< pre_exponent exponent_number > };
}

il y a encore une chose à faire ce modèle pour le rendre encore plus supportable. Le problème, c'est qu'il y a encore trop de répétitions, ce qui veut dire qu'il est trop facile de le changer à un endroit, mais pas à un autre. Si vous faisiez une analyse McCabe, vous diriez que sa métrique de complexité est trop haut. La plupart d'entre nous dirions que c'est trop indenté. De ce fait, il est difficile de suivre. Pour corriger toutes ces choses, ce dont nous avons besoin est un "modèle grammatical", un avec un bloc de définition pour créer des abstractions nommées, que nous traitons ensuite un peu comme un appel de sous-programme plus tard dans le match.

use 5.010;              # Perl first got regex subs in v5.10
$real__rx = qr{ 

    ^                   # anchor to front
    (?&real_number)     # call &real_number regex sub
    $                   # either at end or before final newline

  ##################################################
  # the rest is definition only; think of         ##
  # each named buffer as declaring a subroutine   ##
  # by that name                                  ##
  ##################################################
  (?(DEFINE)
      (?<real_number>
          (?&mantissa)
          (?&abscissa) ?

      )
      (?<abscissa>
          (?&exponent_indicator)
          (?&exponent)
      )
      (?<exponent>
          (&?sign)    ?
          (?&a_digit) +
      )
      (?<mantissa>
         # expecting either of these....
         (?= (?&a_digit)
           | (?&point)
         )
         (?&a_digit) {1,3}
         (?: (?&digit_separator) ?
             (?&a_digit) {3}
         ) *
         (?: (?&point)
             (?&a_digit) *
         ) ?
      )
      (?<point>               [.]     )
      (?<sign>                [+-]    )
      (?<digit_separator>     [_,]    )
      (?<exponent_indicator>  [Ee]    )
      (?<a_digit>             [0-9]   )
   ) # end DEFINE block
}x;

Voir comment incroyablement mieux la composition grammaticale est que la ligne d'origine-noisy modèle? Il est également beaucoup plus facile d'obtenir la bonne syntaxe: I j'ai tapé ça sans même une erreur de syntaxe de regex à corriger. (Ok bien, j'ai tapé tous les autres sans aucune erreur de syntaxe non plus, mais je fais ça depuis un moment. :)

les modèles grammaticaux ressemblent beaucoup plus à un BNF que les moches vieilles expressions régulières que les gens ont fini par détester. Ils sont beaucoup plus faciles à lire, à écrire et à maintenir. Alors arrêtons d'avoir des motifs moches, D'accord?