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

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

Les sous-chaînes sont des caractères consécutifs à l’intérieur d’une chaîne. La chaîne "abc", par exemple, contient les sous-chaînes suivantes : "", "a", "ab", "abc", "b", "bc", "c". Vous pouvez utiliser des méthodes ActionScript pour localiser les sous-chaînes d’une chaîne.

Les modèles sont définis en ActionScript par des chaînes ou par des expressions régulières. Par exemple, l’expression régulière suivante définit un modèle spécifique, les lettres A, B, et C suivies d’un chiffre (les barres de fraction sont des délimiteurs d’expression régulière) :

/ABC\d/

ActionScript comporte des méthodes servant à rechercher des modèles dans des chaînes et à remplacer les correspondances trouvées par des sous-chaînes de substitution. Ces méthodes sont décrites dans les sections suivantes.

Les expressions régulières peuvent définir des modèles compliqués. Pour plus d’informations, voir Utilisation d’expressions régulières.

Recherche d’une sous-chaîne par la position d’un caractère

Les méthodes substr() et substring() sont similaires. Elles renvoient toutes les deux une sous-chaîne d’une chaîne. Elles prennent deux paramètres. Dans les deux méthodes, le premier paramètre est la position du caractère initial dans la chaîne concernée. Toutefois, dans la méthode substr(), le deuxième paramètre est la longueur de la sous-chaîne à renvoyer, alors que dans la méthode substring(), le deuxième paramètre est la position du caractère final de la sous-chaîne (qui ne figure pas dans la chaîne renvoyée). Cet exemple illustre la différence entre ces deux méthodes :

var str:String = "Hello from Paris, Texas!!!"; 
trace(str.substr(11,15)); // output: Paris, Texas!!! 
trace(str.substring(11,15)); // output: Pari

La méthode slice() fonctionne de la même façon que la méthode substring(). Lorsque deux nombres entiers non négatifs sont passés en paramètres, son fonctionnement est identique. Néanmoins, la méthode slice() peut recevoir des entiers négatifs comme paramètres. Dans ce cas, la position des caractères est comptée à partir de la fin de la chaîne, comme dans l’exemple suivant :

var str:String = "Hello from Paris, Texas!!!"; 
trace(str.slice(11,15)); // output: Pari 
trace(str.slice(-3,-1)); // output: !! 
trace(str.slice(-3,26)); // output: !!! 
trace(str.slice(-3,str.length)); // output: !!! 
trace(str.slice(-8,-3)); // output: Texas

Vous pouvez associer des entiers positifs et négatifs comme paramètres de la méthode slice().

Recherche de la position des caractères d’une sous-chaîne correspondante

Vous pouvez utiliser les méthodes indexOf() et lastIndexOf() pour localiser des sous-chaînes correspondantes au sein d’une chaîne, comme dans l’exemple suivant :

var str:String = "The moon, the stars, the sea, the land"; 
trace(str.indexOf("the")); // output: 10

La méthode indexOf() est sensible à la casse.

Vous pouvez spécifier un deuxième paramètre pour indiquer la position de l’index dans la chaîne à partir de laquelle commencer la recherche, comme suit :

var str:String = "The moon, the stars, the sea, the land" 
trace(str.indexOf("the", 11)); // output: 21

La méthode lastIndexOf() trouve la dernière occurrence d’une sous-chaîne dans la chaîne :

var str:String = "The moon, the stars, the sea, the land" 
trace(str.lastIndexOf("the")); // output: 30

Si vous incluez un deuxième paramètre avec la méthode lastIndexOf(), la recherche est effectuée à l’envers à partir de cette position d’index dans la chaîne (de droite à gauche) :

var str:String = "The moon, the stars, the sea, the land" 
trace(str.lastIndexOf("the", 29)); // output: 21

Création d’un tableau de sous-chaînes segmenté par un délimiteur

Vous pouvez utiliser la méthode split() pour créer un tableau de sous-chaînes divisé en fonction d’un caractère délimiteur. Par exemple, vous pouvez segmenter une chaîne séparée par des virgules ou des tabulations en plusieurs chaînes.

L’exemple suivant indique comment diviser un tableau en sous-chaînes avec le caractère esperluette (&) comme délimiteur :

var queryStr:String = "first=joe&last=cheng&title=manager&StartDate=3/6/65"; 
var params:Array = queryStr.split("&", 2); // params == ["first=joe","last=cheng"]

Le deuxième paramètre de la méthode split() (qui est facultatif) définit la taille maximale du tableau renvoyé.

Vous pouvez également utiliser une expression régulière comme caractère délimiteur :

var str:String = "Give me\t5." 
var a:Array = str.split(/\s+/); // a == ["Give","me","5."]

Pour plus d’informations, voir Utilisation d’expressions régulières et le manuel Guide de référence ActionScript 3.0 pour la plate-forme Adobe Flash.

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

La classe String comprend les méthodes suivantes pour utiliser des modèles dans des chaînes :

  • Utilisez les méthodes match() et search() pour localiser des sous-chaînes qui correspondent à un modèle.

  • Utilisez la méthode replace() pour rechercher des sous-chaînes qui correspondent à un modèle et les remplacer par une sous-chaîne spécifiée.

Ces méthodes sont décrites dans les sections suivantes.

Vous pouvez utiliser des chaînes ou des expressions régulières pour définir des modèles utilisés dans ces méthodes. Pour plus d’informations sur les expressions régulières, voir Utilisation d’expressions régulières.

Adobe recommande

Trim Leading and Trailing 00s From a String (disponible en anglais uniquement)

Doug Reynolds

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 $ :

Code $

Texte de remplacement

$$

$

$&

Sous-chaîne correspondante.

$`

Partie de la chaîne qui précède la sous-chaîne correspondante. Ce code utilise les guillemets simples droits gauches (`) et non les guillemets simples droits (') ni les guillemets simples anglais gauches (' ).

$'

Partie de la chaîne qui suit la sous-chaîne correspondante. Ce code utilise les guillemets simples droits (' ).

$n

nième groupe entre parenthèses correspondant capturé, où n est un chiffre compris entre 1 et 9 et $n n’est pas suivi d’une décimale.

$nn

nnième groupe entre parenthèses correspondant capturé, où nn est un nombre décimal à deux chiffres compris entre 01 et 99. Si la nnième capture n’est pas définie, le texte de remplacement est une chaîne vide.

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.