Groupes

Flash Player 9 et les versions ultérieures, Adobe AIR 1.0 et les versions ultérieures

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

/class-(\d*)/

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

  • Appliquer un quantificateur à plusieurs caractères

  • Délimiter des sous-modèles à appliquer avec la permutation (à l’aide du caractère | )

  • Capturer des correspondances de sous-chaîne (par exemple, en utilisant \1 dans une expression régulière pour établir une correspondance avec un groupe mis en correspondance précédemment, ou en utilisant $1 de la même façon dans la méthode replace() de la classe String)

Les sections suivantes fournissent des détails sur ces utilisations de 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
Remarque : les groupes nommés ne font pas partie de la spécification du langage ECMAScript. Ils représentent une fonction ajoutée dans ActionScript 3.0.