Subtekenreeksen en patronen zoeken in tekenreeksen

Flash Player 9 of hoger, Adobe AIR 1.0 of hoger

Subtekenreeksen zijn opeenvolgende tekens binnen een tekenreeks. De tekenreeks "abc" heeft bijvoorbeeld de volgende subtekenreeksen: "", "a", "ab", "abc", "b", "bc" en "c". Met ActionScript-methoden kunt u zoeken naar subtekenreeksen van een tekenreeks.

Patronen worden in ActionScript gedefinieerd door tekenreeksen of door reguliere expressies. De volgende reguliere expressie definieert bijvoorbeeld een specifiek patroon: de letters A, B en C gevolgd door een cijferteken (de slashes zijn reguliere-expressiescheidingstekens):

/ABC\d/

ActionScript bevat methoden voor het zoeken van patronen in tekenreeksen en voor het vervangen van gevonden overeenkomsten met vervangende subtekenreeksen. Deze methoden worden beschreven in de volgende secties.

Reguliere expressies kunnen ingewikkelde patronen definiëren. Zie Reguliere expressies gebruiken voor meer informatie over reguliere expressies.

Een subtekenreeks zoeken op tekenpositie

De methoden substr() en substring() zijn vergelijkbaar. Beide methoden retourneren een subtekenreeks van een tekenreeks. Beide hebben twee parameters. In beide methoden is de eerste parameter de positie van het teken aan het begin van de tekenreeks. In de methode substr() is de tweede parameter echter de lengte van de subtekenreeks die wordt geretourneerd; in de methode substring() is de tweede parameter de positie van het teken aan het einde van de subtekenreeks (die niet is opgenomen in de geretourneerde tekenreeks). Dit voorbeeld laat het verschil zien tussen deze twee methoden:

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

De methode slice() werkt ongeveer op dezelfde manier als de methode substring(). Met twee niet-negatieve gehele getallen als parameters werken ze exact gelijk. De methode slice() kan echter negatieve gehele getallen als parameters hebben. In dit geval wordt de tekenpositie vanuit het einde van de tekenreeks gehaald, zoals in het volgende voorbeeld wordt getoond:

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

U kunt niet-negatieve en negatieve gehele getallen combineren als parameters van de methode slice().

De tekenpositie zoeken van een overeenkomende subtekenreeks

Met de methoden indexOf() en lastIndexOf() kunt u overeenkomende subtekenreeksen opzoeken in een tekenreeks, zoals in het volgende voorbeeld wordt getoond:

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

De methode indexOf() maakt onderscheid tussen hoofd- en kleine letters.

U kunt als volgt een tweede parameter opgeven om de indexpositie aan te geven in de tekenreeks van waaruit de zoekopdracht wordt gestart:

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

De methode lastIndexOf() zoekt naar de laatste instantie van een subtekenreeks in de tekenreeks:

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

Bij het gebruik van een tweede parameter bij de methode lastIndexOf(), wordt de zoekopdracht in achterwaartse richting (van rechts naar links) uitgevoerd vanaf de desbetreffende indexpositie in de tekenreeks.

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

Een array subtekenreeksen maken met behulp van een scheidingsteken

Met de methode split() kunt u een array subtekenreeksen maken met behulp van een scheidingsteken. U kunt bijvoorbeeld een tekenreeks met door komma's of tabs gescheiden waarden segmenteren in meerdere tekenreeksen.

Het volgende voorbeeld laat zien hoe u een array kunt opsplitsen in subtekenreeksen met de ampersand (&) als scheidingsteken:

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

De tweede parameter van de methode split(), die optioneel is, definieert de maximumgrootte van de array die wordt geretourneerd.

U kunt ook een reguliere expressie gebruiken als scheidingsteken:

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

Zie Reguliere expressies gebruiken en de Naslaggids voor ActionScript 3.0 voor het Adobe Flash-platform voor meer informatie.

Patronen in tekenreeksen zoeken en subtekenreeksen vervangen

De klasse String bevat de volgende methoden voor het werken met patronen in tekenreeksen:

  • Gebruik de methoden match() en search() om subtekenreeksen te zoeken die overeenkomen met een patroon.

  • Gebruik de methode replace() om subtekenreeksen te zoeken die overeenkomen met een patroon en deze subtekenreeksen te vervangen met een opgegeven subtekenreeks.

Deze methoden worden beschreven in de volgende secties.

U kunt tekenreeksen of reguliere expressies gebruiken om patronen die in deze methoden worden gebruikt, te definiëren. Zie Reguliere expressies gebruiken voor meer informatie over reguliere expressies.

Overeenkomende subtekenreeksen zoeken

De methode search() retourneert de indexpositie van de eerste subtekenreeks die overeenkomt met een gegeven patroon, zoals in dit voorbeeld wordt getoond:

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

U kunt ook reguliere expressies gebruiken om het patroon waarmee moet worden overeengekomen te definiëren, zoals in dit voorbeeld wordt getoond:

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

De uitvoer van de methode trace() is 0, omdat het eerste teken in de tekenreeks indexpositie 0 is. De markering i wordt ingesteld in de reguliere expressie, zodat de zoekopdracht geen onderscheid maakt tussen hoofd- en kleine letters.

De methode search() vindt slechts een overeenkomst en retourneert de beginindexpositie, zelfs als de markering g (global) is ingesteld in de reguliere expressie.

In het volgende voorbeeld wordt een ingewikkeldere reguliere expressie getoond, die overeenkomt met een tekenreeks tussen dubbele aanhalingstekens:

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.)

De methode match() werkt ongeveer op dezelfde manier. De methode zoekt naar een overeenkomende subtekenreeks. Wanneer u echter de algemene markering gebruikt in een reguliere-expressiepatroon, zoals in het volgende voorbeeld, retourneert match() een array van overeenkomende subtekenreeksen:

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

De array results wordt op het volgende ingesteld:

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

Zie Reguliere expressies gebruiken voor meer informatie over reguliere expressies.

Overeenkomende subtekenreeksen vervangen

Met de methode replace() kunt u in een tekenreeks zoeken naar een opgegeven patroon en overeenkomende items vervangen door de opgegeven vervangende tekenreeks, zoals in het volgende voorbeeld wordt getoond:

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. 

In dit voorbeeld wordt voor de overeenkomende tekenreeksen geen onderscheid gemaakt tussen hoofd- en kleine letters, omdat de markering i (ignoreCase) is ingesteld in de reguliere expressie, en meerdere overeenkomende items worden vervangen, omdat de markering g (global) is ingesteld. Zie Reguliere expressies gebruiken voor meer informatie.

U kunt de volgende $-vervangingscodes in de vervangende tekenreeks opnemen: De vervangende tekst die in de volgende tabel wordt getoond, wordt ingevoegd op de plaats van de vervangingscode $:

$-code

Vervangingstekst

$$

$

$&

De overeenkomende subtekenreeks.

$`

Het gedeelte van de tekenreeks dat voorafgaat aan de overeenkomende subtekenreeks. In deze code wordt het rechte enkele aanhalingsteken links (`) gebruikt, niet het rechte enkele aanhalingsteken (') of het gekrulde enkele aanhalingsteken links (').

$'

Het gedeelte van de tekenreeks dat volgt na de overeenkomende subtekenreeks. Deze code gebruikt rechte enkele aanhalingstekens (').

$n

De n-de vastgelegde overeenkomende groep tussen ronde haakjes, waarbij n een cijfer (1-9) is en $n niet wordt gevolgd door een decimaal cijfer.

$nn

De nn-de vastgelegde overeenkomende groep tussen ronde haakjes, waarbij nn een tweecijferig decimaal getal is (01–99). Als de nn-de vastlegging niet gedefinieerd is, is de vervangende tekst een lege tekenreeks.

Hierna volgt een voorbeeld van de vervangingscodes $2 en $1, die de eerste en tweede vastgelegde overeenkomende groep vertegenwoordigen:

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

U kunt ook een functie gebruiken als tweede parameter van de methode replace(). De overeenkomende tekst is vervangen door de geretourneerde waarde van de functie.

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; 
}

Wanneer u een functie opgeeft als tweede parameter van de methode replace(), worden de volgende argumenten doorgegeven aan de functie:

  • Het overeenkomende gedeelte van de tekenreeks.

  • Alle vastleggende overeenkomende groepen tussen ronde haakjes. Het aantal doorgegeven argumenten hangt af van het aantal overeenkomsten tussen ronde haakjes. U kunt het aantal overeenkomsten tussen ronde haakjes vaststellen door arguments.length - 3 binnen de functiecode te controleren.

  • De indexpositie in de tekenreeks waar de overeenkomst begint.

  • De volledige tekenreeks.