Les expressions régulières sont très puissantes, mais elles sont difficiles à lire et souvent on ne profite pas de leur plein potentiel à cause de ça.
Lorsqu’on utilise les expressions régulières pour la validation d’un formulaire, on aimerait parfois pouvoir vérifier plusieurs critères avec une seule regex.
Par exemple, on pourrait demander à un numéro de téléphone de contenir au moins dix chiffres ET de contenir seulement certains caractères.
On ne sait pas forcément qu’elles nous permettent de faire précisément ça, et bien d’autres choses incroyables !

Ce que nous voulons c’est que notre chaine de caractères corresponde à un numéro de téléphone (français) typique, avec ou sans son préfixe international.
Ça pourrait prendre l’une de ces formes :
01 23 45 67 89
01.23.45.67.89
+33-123.456.789
+(33)1 234-567-89
ou d’autres variations.
Simplement, ce que nous voulons c’est au moins dix chiffres, et seulement des nombres, espaces, tirets et points, éventuellement précédés par un + et un jeu de parenthèses autour de deux chiffres (le code international).

Comme d’habitude, nous allons commencer par un exemple complet, puis le détailler.
Voici à quoi ça ressemble pour notre exemple :

/^\+{0,1}(?=(?:\D*\d){10}$)[\d .()-]+$/

Comment avons-nous construit ceci ?

Les parties

On peut utiliser

/^\+{0,1}/

pour dire que notre chaine de caractères peut commencer (^) par un + (échappé pour conserver sa signification littérale) 0 ou 1 fois.

On peut aussi utiliser

/(\D*\d){10}$/

pour dire que l’on veut qu’elle finisse ($) par 10 occurrences d’un chiffre (\d) avec n’importe quels autres caractères non numériques (\D*)
Ici nous vérifions simplement que l’on a 10 chiffres dans notre chaine de caractères.

En outre, on pourrait utiliser

/[\d .()-]+$/

pour forcer la chaine de caractères à se terminer ($) par seulement des nombres (\d) et certains caractères choisis.

On n’a pas besoin d’échapper le point ou les parenthèses ici. Comme ils sont entre crochets, il sont toujours utilisés littéralement.
Par contre, le tiret (-) a une signification spéciale au sein des crochets : il sert à déclarer des intervalles comme [a-z]. Ici, on n’a pas besoin de l’échapper par ce que c’est le dernier caractère. Si ce n’était pas le cas, il faudrait l’échapper.
C’est à dire qu’on pourrait écrire la même chose comme ceci : [\d .\-()]+

L’ingrédient principal

Afin de cumuler les deux dernières règles dans une seule regex, on utilise le positive lookahead.
Tout ce qu’il vous faut savoir est que sa syntaxe est un point d’interrogation suivit par un signe égal au début d’un jeu de parenthèses, c’est à dire (?=…)

Sa fonction est de vérifier que la suite de la chaine de caractères correspond à une expression régulière donnée (sans inclure cette partie pour référence ultérieure).
Le « positive lookahead » est là où la magie se passe. C’est un peu comme si ce n’était pas vraiment une partie de l’expression régulière, sauf que ça crée tout de même une contrainte. Ça veut dire que l’on peut cumuler d’autres règles comme si celle-ci n’avait jamais existé !

On a aussi ajouté un point d’interrogation suivi de deux-points (?:…) au début du jeu de parenthèses au sein de notre « lookahead » mais c’est optionnel. Cette instruction est là pour dire que ce jeu de parenthèses aussi ne doit pas créer de référence pour un usage ultérieur. Ça ne change pas grand chose, mais ça aidera le moteur d’expressions régulières à aller un petit peu plus vite (au détriment de la lisibilité). A vous de voir.

Cumuler le tout

Revenons à notre premier bout de code, voici ce qu’il fait

/^\+{0,1}(?=(?:\D*\d){10}$)[\d .()-]+$/

Il recherche d’abord un + au début de la chaine de caractères testée, qui peut ne pas être présent ou être présent une seule fois: ^\+{0,1}
Ensuite, il vérifie « plus loin » qu’on trouve à la fin de la chaine une série de 10 chiffres mélangée avec d’autres caractères, sans conserver la trace de leur existence: (?=(?:\D*\d){10}$)
Enfin, il reprend où il en était en vérifiant que la chaine testée contient uniquement des chiffres, espaces, parenthèses et tirets jusqu’au bout: [\d .()-]+$

J’espère que ça vous sera utile !

Quand on utilise WordPress comme un CMS, il est possible que l’on aie envie de créer une page complètement dynamique et de donner le nom qu’on veut au fichier appelé sans avoir à l’associer avec une page bidon dans la base de données.
Par exemple, vous pourriez avoir envie d’une page dynamique qui affiche un mix de tous les posts actuels, et qui peut vivre indépendamment du reste.
C’est ce que nous allons réaliser ici.

Pour un coup d’œil rapide sur comment faire, voici le code complet :

// handle custom page
// do flush if changing rule, then reload an admin page
add_action('admin_init', 'handle_custompage_route');
function handle_custompage_route()
{
    add_rewrite_rule('custompage/([^/]+)/?', 'index.php?custompage_var=$matches[1]', 'top');
    flush_rewrite_rules();
}

add_filter('init', 'declare_newsletter_vars');
function declare_newsletter_vars()
{
    add_rewrite_tag('%newsletter_nb%', '([^&]+)');
}

add_filter('template_include', 'my_template', 1, 1);
function my_template($template)
{
    global $wp_query;

    if (isset($wp_query->query_vars['custompage_var'])) {
        return dirname(__FILE__) . '/mycustompage.php';
    }
    return $template;
}

Ce code irait bien sûr dans le functions.php de votre répertoire de thème.

Maintenant, voyons ça en détail :

Ajouter une règle de redirection

// handle custom page
// do flush if changing rule, then reload an admin page
add_action('admin_init', 'handle_custompage_route');

Les règles de redirection sont stockées dans la base de données (dans la table wp_options).
Nous voulons y ajouter une règle une fois pour toutes. Dans le cas d’un plugin, nous ferions cela durant la phase d’activation.
Ici, nous allors nous baser sur l’événement « admin_init », puisqu’il faut(!) être dans le tableau de bord de l’administration pour que la fonction add_rewrite_rule() fonctionne.

Cette fonction aura besoin d’être appelée une seule fois, vous pouvez ensuite la commenter. Il n’y a pas besoin de mettre à jour les règles de redirection à chaque fois que l’on visite la page d’administration, n’est-ce pas ?

Notez que l’on doit toujours rediriger vers index.php, puisque le fichier .htaccess redirige tout dessus par défaut. Si vous voulez rediriger directement vers un fichier, vous pouvez le faire là dedans, mais alors vous n’aurez pas accès aux variables globales de WordPress.

function handle_custompage_route()
{
    add_rewrite_rule('custompage/([^/]+)/?', 'index.php?custompage_var=$matches[1]', 'top');
    flush_rewrite_rules();
}

Ici nous allons faire correspondre http://www.mydomain.com/custompage/myparam1 à http://www.mydomain.com/index.php?custompage_var=myparam1

Le premier argument, custompage/([^/]+)/? est une expression régulière qui décrit « quelquechose qui commence par custompage/, suivi d’un (ou plus) caractère qui ne soit pas un / (les parenthèses gardent cette partie pour référence ultérieure), suivi ou non par un / »

Dans la seconde partie, $matches est un array qui contient toutes les références attrapées par des parenthèses dans l’expression régulière.

Notez que lorsqu’on utilise $matches[] pour récupérer les valeurs du morceau d’URI attrapées, les données du groupe de capture commencent à l’index 1, pas 0.

Le troisième argument précise que cette règle sera ajoutée en haut de liste. En effet, la première règle à laquelle une adresse correspond est utilisée, et nous voulons que la notre soit prioritaire.

Afin que cette règle soit ajoutée de manière permanente, il nous faut appeler flush_rewrite_rules() après que toutes nos règles soient ajoutées.

Declarer les nouvelles variables

add_filter('init', 'declare_custompage_vars');
function declare_custompage_vars()
{
    add_rewrite_tag('%custompage_nb%', '([0-9]+)');
}

Afin que cette nouvelle règle fonctionne correctement, il nous faut faire prendre conscience à WordPress de l’existence des variables que nous allons utiliser.

Ici, nous avons utilisé « custompage_var » dans notre redirection, et WordPress n’a jamais entendu parler d’une variable de ce nom, donc il faut que nous la déclarions.

Il y a plusieurs façons de faire ça. Nous avons utilisé la fonction add_rewrite_tag() lors de l’init, mais on aurait aussi pu insérer notre variable directement dans l’array des query_vars en s’accrochant sur l’événement query_vars comme ceci :

add_filter('query_vars', 'handle_custompage_query_vars');
function handle_custompage_query_vars($query_vars)
{
    $query_vars[] = 'custompage_var';
    return $query_vars;
}

Les deux approches fonctionnent bien.

Appeler le template

add_filter('template_include', 'my_template', 1, 1);
function my_template($template)
{
    global $wp_query;
    if (isset($wp_query->query_vars['custompage_var'])) {
        return dirname(__FILE__) . '/mycustompage.php';
    }
    return $template;
}

Quand l’événement template_include est déclenché, nous pouvons remplacer le template par le contenu que l’on souhaite.
Ici, nous allons vérifier si notre custompage_var est présente, et si oui retourner mycustompage.php pour qu’il soit utilisé à la place de ce que WordPress s’apprêtait à utiliser en guise de template.

Conclusion

Avec cette technique, vous pouvez sortir de la structure de templates de WordPress quand vous voulez, tout en profitant de son environnement (les variables et fonctions globales).
Enjoy