Recherche de sous-chaînes et de modèles dans des chaînes

Recherche de sous-chaînes correspondantes

La méthode search() renvoie la position de l’index de la première sous-chaîne qui correspond à un modèle donné, comme illustré dans cet exemple :

var str:String = "The more the merrier."; 
// (This search is case-sensitive.) 
trace(str.search("the")); // output: 9 

Vous pouvez également utiliser des expressions régulières pour définir le modèle pour lequel établir une correspondance, comme illustré dans cet exemple :

var pattern:RegExp = /the/i; 
var str:String = "The more the merrier."; 
trace(str.search(pattern)); // 0

Le résultat de la méthode trace() est 0, car le premier caractère dans la chaîne est la position de l’index 0. L’indicateur i est défini dans l’expression régulière. Par conséquent, la recherche n’est pas sensible à la casse.

La méthode search() trouve une seule correspondance et renvoie sa position d’index de début, même si l’indicateur g (global) est défini dans l’expression régulière.

L’exemple suivant présente une expression régulière plus compliquée qui correspond à une chaîne dans des guillemets doubles :

var pattern:RegExp = /"[^"]*"/; 
var str:String = "The \"more\" the merrier."; 
trace(str.search(pattern)); // output: 4 
 
str = "The \"more the merrier."; 
trace(str.search(pattern)); // output: -1  
// (Indicates no match, since there is no closing double quotation mark.)

La méthode match() fonctionne de façon similaire. Elle recherche une sous-chaîne correspondante. Néanmoins, lorsque vous utilisez l’indicateur global dans un modèle d’expression régulière (comme dans l’exemple suivant), match() renvoie un tableau de sous-chaînes correspondantes :

var str:String = "bob@example.com, omar@example.org"; 
var pattern:RegExp = /\w*@\w*\.[org|com]+/g; 
var results:Array = str.match(pattern);

Le tableau results est défini comme suit :

["bob@example.com","omar@example.org"]

Pour plus d’informations sur les expressions régulières, voir Utilisation d’expressions régulières .

Remplacement de sous-chaînes mises en correspondance

Vous pouvez utiliser la méthode replace() pour rechercher un modèle spécifié dans une chaîne et remplacer les correspondances par la chaîne de remplacement spécifiée, comme illustré dans l’exemple suivant :

var str:String = "She sells seashells by the seashore."; 
var pattern:RegExp = /sh/gi; 
trace(str.replace(pattern, "sch")); //sche sells seaschells by the seaschore. 

Dans cet exemple, les chaînes mises en correspondance ne sont pas sensibles à la casse car l’indicateur i ( ignoreCase ) est défini dans l’expression régulière, et plusieurs correspondances sont remplacées car l’indicateur g ( global ) est défini. Pour plus d’informations, voir Utilisation d’expressions régulières .

Vous pouvez inclure les codes de remplacement $ suivants dans la chaîne de remplacement. Le texte de remplacement indiqué dans le tableau suivant est inséré à la place du code de remplacement $ :

L’exemple suivant illustre l’utilisation des codes de remplacement $2 et $1 , qui représentent le premier et le deuxième groupes capturés correspondants :

var str:String = "flip-flop"; 
var pattern:RegExp = /(\w+)-(\w+)/g; 
trace(str.replace(pattern, "$2-$1")); // flop-flip

Vous pouvez également utiliser une fonction comme deuxième paramètre de la méthode replace() . Le texte correspondant est remplacé par la valeur renvoyée de la fonction.

var str:String = "Now only $9.95!"; 
var price:RegExp = /\$([\d,]+.\d+)+/i; 
trace(str.replace(price, usdToEuro)); 
 
function usdToEuro(matchedSubstring:String,                                  capturedMatch1:String,                                  index:int,                                  str:String):String 
{ 
    var usd:String = capturedMatch1; 
    usd = usd.replace(",", ""); 
    var exchangeRate:Number = 0.853690; 
    var euro:Number = parseFloat(usd) * exchangeRate; 
    const euroSymbol:String = String.fromCharCode(8364); 
    return euro.toFixed(2) + " " + euroSymbol; 
}

Lorsque vous utilisez une fonction comme deuxième paramètre de la méthode replace() , les arguments suivants sont transmis à la fonction :

• La partie correspondante de la chaîne.

• Tout groupe entre parenthèses capturé correspondant. Le nombre d’arguments transmis de cette façon varie selon le nombre de correspondances entre parenthèses. Pour déterminer le nombre de correspondances entre parenthèses, vérifiez arguments.length - 3 dans le code de la fonction.

• La position d’index dans la chaîne où débute la correspondance.

• La chaîne complète.