Znajdowanie podciągów i wzorców w ciągach znaków

Flash Player 9 i nowsze wersje, Adobe AIR 1.0 i nowsze wersje

Podciągi do fragmenty ciągów znaków złożone z sąsiadujących ze sobą znaków. Na przykład ciąg znaków "abc" zawiera następujące podciągi: "", "a", "ab", "abc", "b", "bc", "c". W języku ActionScript dostępne są metody służące do wyszukiwania podciągów w ciągu znaków.

Wzorce w języku ActionScript definiuje się w postaci ciągów znaków lub wyrażeń regularnych. Na przykład poniższe wyrażenie regularne definiuje konkretny wzorzec — litery A, B i C, po których następuje cyfra (ukośniki pełnią rolę ograniczników wyrażeń regularnych):

/ABC\d/

Język ActionScript oferuje metody do znajdowania wzorców w ciągach znaków i do zastępowania znalezionych fragmentów określonymi podciągami. Metody te zostały opisane w następnych sekcjach.

Wyrażenia regularne umożliwiają definiowanie skomplikowanych wzorców. Więcej informacji zawiera rozdział Korzystanie z wyrażeń regularnych.

Znajdowanie podciągu na podstawie pozycji znaku

Metody substr() i substring() działają w podobny sposób. Obie zwracają podciąg z ciągu znaków. Obie mają po dwa parametry. W obu metodach pierwszy parametr określa pozycję pierwszego znaku podciągu w danym ciągu znaków. Jednak w metodzie substr() drugi parametr jest długością podciągu, jaki ma być zwrócony, a w metodzie substring() drugi parametr to pozycja znaku znajdującego się za końcem podciągu (ten znak nie jest zwracany w podciągu). Poniższy przykład ilustruje różnicę między tymi dwiema metodami: 

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

Metoda slice() działa podobnie, jak metoda substring(). Gdy jej parametry są nieujemnymi liczbami całkowitymi, działa dokładnie tak samo. Jednak parametrami metody slice() mogą być także ujemne liczby całkowite, i wówczas pozycje znakowe są liczone od końca ciągu znaków, tak jak w poniższym przykładzie:

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

W jednym wywołaniu metody slice() można podać zarówno parametry nieujemne, jak i ujemne.

Znajdowanie pozycji znakowa dopasowanego podciągu

Metody indexOf() i lastIndexOf() służą do znajdowania dopasowanych podciągów wewnątrz ciągu znaku, co ilustruje poniższy przykład:

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

Należy zwrócić uwagę, że metoda indexOf() rozróżnia wielkość liter.

Można określić drugi parametr oznaczający indeks, od którego należy rozpocząć poszukiwanie podciągu:

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

Metoda lastIndexOf() znajduje ostatnie wystąpienie podciągu wewnątrz ciągu znaków:

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

Jeśli w wywołaniu metody lastIndexOf() zostanie podany drugi parametr, poszukiwanie podciągu rozpocznie się od wskazanego indeksu i będzie postępować w kierunku początku ciągu (od prawej do lewej strony):

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

Tworzenie tablicy z podciągów rozdzielonych ogranicznikami

Metoda split() umożliwia utworzenie tablicy złożonej z podciągów wyodrębnionych na podstawie rozmieszczenia ograniczników w ciągu znaków. W ten sposób można na przykład podzielić na wiele podciągów jeden ciąg znaków zawierający dane rozdzielone przecinkami lub znakami tabulacji.

Poniższy przykład ilustruje rozbicie ciągu na tablicę podciągów, przy czym znakiem ogranicznika jest w tym przypadku ampersand (&):

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

Drugi, opcjonalny, parametr metody split(), określa maksymalny rozmiar zwracanej tablicy.

W charakterze ogranicznika można też użyć wyrażenia regularnego: 

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

Więcej informacji zawiera sekcja Korzystanie z wyrażeń regularnych oraz Skorowidz języka ActionScript 3.0 dla platformy Adobe Flash.

Znajdowanie wzorców w ciągach znaków i zastępowanie ciągów cząstkowych

Klasa String udostępnia następujące metody służące do operowania na wzorcach w ciągach znaków:

  • Metody match() i search() umożliwiają znajdowanie podciągów zgodnych ze wzorcem.

  • Metoda replace() służy do znajdowania podciągów zgodnych ze wzorcem i zastępowania ich określonym podciągiem.

Metody te zostały opisane w następnych sekcjach.

Wzorce używane w opisywanych metodach mogą mieć postać ciągów znaków lub wyrażeń regularnych. Więcej informacji na temat wyrażeń regularnych zawiera sekcja Korzystanie z wyrażeń regularnych.

Znajdowanie dopasowanych podciągów

Metoda search() zwraca indeks pierwszego podciągu zgodnego ze wzorcem, co ilustruje poniższy przykład:

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

Poszukiwany wzorzec może być wyrażeniem regularnym, tak jak w poniższym przykładzie:

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

Wynikiem wywołania metody trace() jest 0, ponieważ pierwszy znak w ciągu ma indeks 0. Wyrażenie regularne zawiera ustawioną flagę i, która powoduje, że przy wyszukiwaniu nie jest uwzględniana wielkość liter.

Metoda search() znajduje tylko jeden dopasowany podciąg i zwraca indeks jego pierwszego znaku, nawet jeśli wyrażenie regularne zawiera ustawioną flagę g (global).

W poniższym przykładzie użyto bardziej skomplikowanego wyrażenia regularnego, które znajduje ciąg znaków ujęty w cudzysłów:

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

Metoda match() działa podobnie. Wyszukuje zgodny podciąg. Jednak użycie flagi globalne w wyrażeniu regularnym — tak jak w poniższym przykładzie — spowoduje, że metoda match() zwróci tablicę zawierającą znalezione podciągi:

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

Tablicy results przypisywana jest następująca wartość

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

Więcej informacji na temat wyrażeń regularnych zawiera sekcja Korzystanie z wyrażeń regularnych.

Zastępowanie znalezionych podciągów

Metoda replace() umożliwia wyszukanie w ciągu znaków określonego wzorca i zastąpienie znalezionych podciągów określonym ciągiem zastępczym, co ilustruje poniższy przykład: 

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.

Należy zwrócić uwagę, że w tym przykładzie przy wyszukiwaniu podciągów nie jest rozróżniana wielkość liter, ponieważ wyrażenie regularne zawiera ustawioną flagę i (ignoreCase), a ponadto zastępowanych jest wiele znalezionych podciągów, ponieważ ustawiona jest flaga g (global). Więcej informacji zawiera rozdział Korzystanie z wyrażeń regularnych.

W zastępczym ciągu znaków można umieścić kody zastępcze ($). Teks zastępczy podany w poniższej tabeli zostanie wstawiony w miejsce kodu zastępczego $:

Kod $

Tekst zastępczy

$$

$

$&

Znaleziony podciąg.

$`

Fragment ciągu poprzedzający znaleziony podciąg. Ten kod zawiera lewy pojedynczy prosty cudzysłów (`), a nie prosty apostrof (') ani nie lewy pojedynczy zaokrąglony cudzysłów (' ).

$'

Fragment ciągu następujący poi znalezionym podciągu. Ten kod zawiera prawy pojedynczy prosty cudzysłów (').

$n

Zgodna przechwycona n-ta grupa ujęta w nawias, gdzie wartość n to pojedyncza cyfra z zakresu 1-9, a po $n nie następuje liczba dziesiętna.

$nn

Zgodna przechwycona nn-ta grupa ujęta w nawias, gdzie wartość nn to dwucyfrowa liczba dziesiętna (01-99. Jeśli nn-ta wartość przechwycenia jest niezdefiniowana, tekst zastępczy stanowi pusty ciąg.

Poniższy przykład ilustruje zastosowanie kodów zastępczych $2 i $1 reprezentujących pierwszą i drugą zgodną przechwyconą grupę:

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

W charakterze drugiego parametru metody replace() można też użyć funkcji. Znaleziony tekst zostanie zastąpiony wartością zwróconą przez funkcję.

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

Gdy jako drugi argument w wywołaniu metody replace() zostanie użyta funkcja, do funkcji przekazywane są następujące argumenty:

  • Zgodny fragment ciągu.

  • Zgodne grupy przechwycone ujęte w nawias. Liczba przekazanych w ten sposób argumentów będzie się różnić w zależności od liczby zgodnych grup ujętych w nawias. Można określić liczbę zgodnych grup ujętych w nawias sprawdzając wartość arguments.length - 3 w kodzie funkcji.

  • Położenie indeksu w miejscu rozpoczęcia dopasowania w ciągu znaków.

  • Kompletny ciąg znaków.