Groupes -- Flash CS3

Vous pouvez spécifier un groupe dans une expression régulière en utilisant des parenthèses, comme suit :

Un groupe est une sous-section d'un modèle. Vous pouvez utiliser des groupes pour effectuer les opérations suivantes :

Les sections suivantes fournissent des détails sur ces utilisations de groupes.

Sous-rubriques

Utilisation de groupes avec des quantificateurs

Si vous n'utilisez pas de groupe, un quantificateur s'applique au caractère ou à la classe de caractère qui le précède, comme indiqué ci-dessous :

var pattern:RegExp = /ab*/ ;
// correspond au caractère a suivi de
// zéro ou plusieurs occurrences du caractère b

pattern = /a\d+/; 
// correspond au caractère a suivi de 
// un ou plusieurs chiffres

pattern = /a[123]{1,3}/;
// correspond au caractère a suivi de 
// l'une des trois occurrences de 1, 2 ou 3

Néanmoins, vous pouvez utiliser un groupe pour appliquer un quantificateur à plusieurs caractères ou classes de caractère :

var pattern:RegExp = /(ab)*/;
// correspond à zéro ou à plusieurs occurrences du caractère a 
// suivi du caractère b, comme ababab

pattern = /(a\d)+/;
// correspond à une ou à plusieurs occurrences du caractère a suivi de  
// un chiffre, tel que a1a5a8a3

pattern = /(spam ){1,3}/; 
// correspond à 1 à 3 occurrences du mot spam suivi d'un espace

Utilisation de groupes avec le permutateur (|)

Vous pouvez utiliser des groupes pour définir le groupe de caractères auquel vous souhaitez appliquer un permutateur (|), comme suit :

var pattern:RegExp = /cat|dog/;
// correspond à cat ou dog

pattern = /ca(t|d)og/;
// correspond à catog ou cadog

Utilisation de groupes pour capturer des correspondances de sous-chaîne

Lorsque vous définissez un groupe entre parenthèses standard dans un modèle, vous pouvez ensuite vous y référer dans l'expression régulière. Il s'agit d'une backreference. Ces types de groupes sont appelés groupes capturés. Par exemple, dans l'expression régulière suivante, la séquence \1 correspond à toute sous-chaîne mise en correspondance avec le groupe entre parenthèses capturé :

var pattern:RegExp = /(\d+)-by-\1/;
// correspond aux éléments suivants : 48-par-48

Vous pouvez spécifier jusqu'à 99 backreferences dans une expression régulière en tapant \1, \2, ... , \99.

De même, dans la méthode replace() de la classe String, vous pouvez utiliser $1-$99 pour insérer des correspondances de chaîne de groupe capturé dans la chaîne de remplacement :

var pattern:RegExp = /Hi, (\w+)\./;
var str:String = "Hi, Bob.";
trace(str.replace(pattern, "$1, hello."));
// résultat : Bob, bonjour.

Si vous utilisez des groupes capturés, la méthode exec() de la classe RegExp et la méthode match() de la classe String renvoient des sous-chaînes qui correspondent aux groupes capturés :

var pattern:RegExp = /(\w+)@(\w+).(\w+)/;
var str:String = "bob@example.com";
trace(pattern.exec(str));
  // bob@test.com,bob,example,com

Utilisation de groupes non capturés et de groupes d'anticipation

Un groupe non capturé est utilisé pour le regroupement uniquement ; il n'est pas « collecté », et il ne correspond pas à des backreferences numérotées. Utilisez (?: et ) pour définir des groupes non capturés, comme suit :

var pattern = /(?:com|org|net);

Par exemple, notez la différence entre mettre (com|org) dans un groupe capturé et dans un groupe non capturé (la méthode exec() répertorie les groupes capturés après la correspondance complète) :

var pattern:RegExp = /(\w+)@(\w+).(com|org)/;
var str:String = "bob@example.com";
trace(pattern.exec(str));
  // bob@test.com,bob,example,com
  
//non capturé :
var pattern:RegExp = /(\w+)@(\w+).(?:com|org)/;
var str:String = "bob@example.com";
trace(pattern.exec(str));
  // bob@test.com,bob,example

Un type spécial de groupe non capturé est le groupe d'anticipation dont il existe deux types : le groupe d'anticipation positif et le groupe d'anticipation négatif.

Utilisez (?= et ) pour définir un groupe d'anticipation positif, qui spécifie que le sous-modèle dans le groupe doit établir une correspondance à la position. Néanmoins, la portion de la chaîne qui correspond au groupe d'anticipation positif peut correspondre aux modèles restants dans l'expression régulière. Par exemple, étant donné que (?=e) est un groupe d'anticipation positif dans le code suivant, le caractère e auquel il correspond peut être mis en correspondance par une partie suivante de l'expression régulière (dans ce cas, le groupe capturé, \w*) :

var pattern:RegExp = /sh(?=e)(\w*)/i;
var str:String = "Shelly sells seashells by the seashore";
trace(pattern.exec(str));
// Shelly,elly

Utilisez (?= et ) pour définir un groupe d'anticipation négatif, qui indique que le sous-modèle dans le groupe ne doit pas établir une correspondance à la position. Voici un exemple :

var pattern:RegExp = /sh(?!e)(\w*)/i;
var str:String = "She sells seashells by the seashore";
trace(pattern.exec(str));
// shore,ore

Utilisation de groupes nommés

Un groupe nommé est un type de groupe dans une expression régulière ayant un identificateur nommé. Utilisez (?P<nom> et ) pour définir le groupe nommé. Par exemple, l'expression régulière suivante inclut un groupe nommé avec l'identificateur nommé digits :

var pattern = /[a-z]+(?P<digits>\d+)[a-z]+/;

Lorsque vous utilisez la méthode exec(), un groupe nommé de correspondance est ajouté comme propriété du tableau result :

var myPattern:RegExp = /([a-z]+)(?P<digits>\d+)[a-z]+/; 
var str:String = "a123bcd";
var result:Array = myPattern.exec(str);
trace(result.digits); // 123

Voici un autre exemple, qui utilise deux groupes nommés, avec les identificateurs name et dom :

var emailPattern:RegExp = 
    /(?P<name>(\w|[_.\-])+)@(?P<dom>((\w|-)+))+\.\w{2,4}+/; 
var address:String = "bob@example.com";
var result:Array = emailPattern.exec(address);
trace(result.name); // bob
trace(result.dom); // exemple