Groupes

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*/ ; 
// matches the character a followed by 
// zero or more occurrences of the character b 
 
pattern = /a\d+/;  
// matches the character a followed by  
// one or more digits 
 
pattern = /a[123]{1,3}/; 
// matches the character a followed by  
// one to three occurrences of either 1, 2, or 3

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

var pattern:RegExp = /(ab)*/; 
// matches zero or more occurrences of the character a  
// followed by the character b, such as ababab 
 
pattern = /(a\d)+/; 
// matches one or more occurrences of the character a followed by  
// a digit, such as a1a5a8a3 
 
pattern = /(spam ){1,3}/;  
// matches 1 to 3 occurrences of the word spam followed by a space

Pour plus d’informations sur les quantificateurs, voir Quantificateurs .

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/; 
// matches cat or dog 
 
pattern = /ca(t|d)og/; 
// matches catog or 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/; 
// matches the following: 48-by-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.")); 
  // output: Bob, hello.

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@example.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@example.com,bob,example,com 
 
//noncapturing: 
var pattern:RegExp = /(\w+)@(\w+).(?:com|org)/; 
var str:String = "bob@example.com"; 
trace(pattern.exec(str)); 
  // bob@example.com,bob,example

Un type spécial de groupe non capturé est le groupe d’animation dont il existe deux types : le groupe d’animation positif et le groupe d’animation 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. 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<name> 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); // example