RegExp

Pakiet	Najwyższy poziom
Klasa	public dynamic class RegExp
Dziedziczenie	RegExp Object

Wersja języka:

ActionScript 3.0

Wersje środowiska wykonawczego:

AIR 1.0, Flash Player 9, Flash Lite 4

Klasa RegExp pozwala korzystać z wyrażeń regularnych, które stanowią wzorce stosowane podczas przeszukiwania i zastępowania ciągów znaków.

Nowy obiekt RegExp można utworzyć za pomocą konstruktora new RegExp() lub poprzez przypisanie literału RegExp zmiennej:

 var pattern1:RegExp = new RegExp("test-\\d", "i");
     var pattern2:RegExp = /test-\d/i;

Więcej informacji zawiera rozdział „Korzystanie z wyrażeń regularnych” w publikacji ActionScript 3.0 — Podręcznik dla programistów.

Wyświetl przykłady

Powiązane elementy interfejsu API

String.match()
String.replace()
String.search()

Właściwości publiczne

Ukryj dziedziczone właściwości publiczne

Pokaż dziedziczone właściwości publiczne

	Właściwość		Zdefiniowane przez
		constructor : Object Odwołanie do obiektu klasy lub funkcji konstruktora, dotyczące danej instancji obiektu.	Object
		dotall : Boolean [tylko do odczytu] Określa, czy znak kropki (.) w wyrażeniu regularnym odpowiada znakom nowego wiersza.	RegExp
		extended : Boolean [tylko do odczytu] Określa, czy wyrażenie regularne ma być używane w trybie rozszerzonym.	RegExp
		global : Boolean [tylko do odczytu] Określa, czy wyrażenie regularne ma być używane w trybie globalnej zgodności.	RegExp
		ignoreCase : Boolean [tylko do odczytu] Określa, czy w przypadku wyrażenia regularnego ma być uwzględniana wielkość liter.	RegExp
		lastIndex : Number Określa indeks ciągu znakowego, od którego ma się rozpocząć następne wyszukiwanie.	RegExp
		multiline : Boolean [tylko do odczytu] Określa, czy jest ustawiona flaga m (flaga wielu wierszy).	RegExp
		source : String [tylko do odczytu] Określa wzorzec występujący w wyrażeniu regularnym.	RegExp

Metody publiczne

Ukryj dziedziczone metody publiczne

Pokaż dziedziczone metody publiczne

	Metoda		Zdefiniowane przez
		RegExp(re:String, flags:String) Pozwala zbudować z dwóch ciągów znakowych wyrażenie regularne.	RegExp
		exec(str:String):Object Umożliwia wyszukiwanie ciągów znakowych na podstawie wyrażenia regularnego.	RegExp
		hasOwnProperty(name:String):Boolean Wskazuje, czy dla obiektu zdefiniowano określoną właściwość.	Object
		isPrototypeOf(theClass:Object):Boolean Wskazuje, czy instancja klasy Object należy do łańcucha prototypów obiektu określonego jako parametr.	Object
		propertyIsEnumerable(name:String):Boolean Wskazuje, czy określona właściwość istnieje i jest przeliczalna.	Object
		setPropertyIsEnumerable(name:String, isEnum:Boolean = true):void Ustawia dostępność właściwości dynamicznej używanej w pętlach.	Object
		test(str:String):Boolean Umożliwia sprawdzenie zgodności wyrażenia regularnego z danym ciągiem znakowym.	RegExp
		toLocaleString():String Zwraca ciąg reprezentujący obiekt — sformatowany zgodnie z konwencjami właściwymi dla ustawień regionalnych.	Object
		toString():String Zwraca ciąg reprezentujący określony obiekt.	Object
		valueOf():Object Zwraca pierwotną wartość dla określonego obiektu.	Object

Szczegół właściwości

dotall

właściwość

dotall:Boolean [tylko do odczytu]

Wersja języka:

ActionScript 3.0

Wersje środowiska wykonawczego:

AIR 1.0, Flash Player 9, Flash Lite 4

Określa, czy znak kropki (.) w wyrażeniu regularnym odpowiada znakom nowego wiersza. Podczas budowania wyrażenia regularnego dla ustawienia dotall = true należy użyć flagi s.

Implementacja
public function get dotall():Boolean

Przykład ( Sposób korzystania z tego przykładu )

Poniższy przykład ilustruje rezultaty ustawienia flagi s (dotall) dla wyrażenia regularnego:

var str:String = "<p>Hello\n"
        + "again</p>"
        + "<p>Hello</p>";

var pattern:RegExp = /<p>.*?<\/p>/;
trace(pattern.dotall) // false
trace(pattern.exec(str)); // <p>Hello</p>

pattern = /<p>.*?<\/p>/s;
trace(pattern.dotall) // true
trace(pattern.exec(str));

extended

właściwość

extended:Boolean [tylko do odczytu]

Wersja języka:

ActionScript 3.0

Wersje środowiska wykonawczego:

AIR 1.0, Flash Player 9, Flash Lite 4

Określa, czy wyrażenie regularne ma być używane w trybie rozszerzonym. Jeśli obiekt RegExp jest w trybie rozszerzonym, białe znaki w ciągu konstruktora będą pomijane. Pomijanie znaków ma na celu zwiększenie czytelności konstruktora.

Podczas budowania wyrażenia regularnego dla ustawienia extended = true należy użyć flagi x.

Implementacja
public function get extended():Boolean

Przykład ( Sposób korzystania z tego przykładu )

Poniższy przykład ilustruje różne sposoby budowania tego samego wyrażenia regularnego. W każdym z nich wyrażenie regularne ma być zgodne ze wzorcem numeru telefonu xxx-xxx-xxxx lub (xxx) xxx-xxxx lub (xxx)xxx-xxxx. Dzięki fladze x ustawionej dla drugiego wyrażenia regularnego białe znaki w ciągu znaków są pomijane.

var rePhonePattern1:RegExp = /\d{3}-\d{3}-\d{4}|\(\d{3}\)\s?\d{3}-\d{4}/; 
var str:String = "The phone number is (415)555-1212.";

trace(rePhonePattern1.extended) // false
trace(rePhonePattern1.exec(str)); // (415)555-1212

var rePhonePattern2:RegExp = / \d{3}-\d{3}-\d{4}  |   \( \d{3} \) \ ? \d{3}-\d{4}  /x; 
trace(rePhonePattern2.extended) // true
trace(rePhonePattern2.exec(str)); // (415)555-1212

global

właściwość

global:Boolean [tylko do odczytu]

Wersja języka:

ActionScript 3.0

Wersje środowiska wykonawczego:

AIR 1.0, Flash Player 9, Flash Lite 4

Określa, czy wyrażenie regularne ma być używane w trybie globalnej zgodności. Dla ustawienia global == true właściwość lastIndex jest wybierana w przypadku znalezienia zgodności. Kolejne żądanie uruchamia przeszukiwanie wyrażenia regularnego w miejscu określonym przez wartość pozycji lastIndex w ciągu znaków. Podczas budowania wyrażenia regularnego dla ustawienia właściwości global na wartość true należy użyć flagi g.

Implementacja
public function get global():Boolean

Przykład ( Sposób korzystania z tego przykładu )

Poniższy przykład ilustruje rezultaty dla ustawienia flagi g (global) przy użyciu metody exec():

var pattern:RegExp = /foo\d/; 
var str:String = "foo1 foo2";
trace(pattern.global); // false
trace(pattern.exec(str)); // foo1
trace(pattern.lastIndex); // 0
trace(pattern.exec(str)); // foo1

pattern = /foo\d/g;
trace(pattern.global); // true
trace(pattern.exec(str)); // foo1
trace(pattern.lastIndex); // 4
trace(pattern.exec(str)); // foo2

ignoreCase

właściwość

ignoreCase:Boolean [tylko do odczytu]

Wersja języka:

ActionScript 3.0

Wersje środowiska wykonawczego:

AIR 1.0, Flash Player 9

Określa, czy w przypadku wyrażenia regularnego ma być uwzględniana wielkość liter. Podczas budowania wyrażenia regularnego dla ustawienia ignoreCase = true należy użyć flagi i.

Implementacja
public function get ignoreCase():Boolean

Przykład ( Sposób korzystania z tego przykładu )

Poniższy przykład ilustruje rezultaty ustawienia flagi i (ignoreCase):

var pattern:RegExp = /bob/; 
var str:String = "Bob bob";
trace(pattern.ignoreCase); // false
trace(pattern.exec(str)); // bob

pattern = /bob/i;
trace(pattern.ignoreCase); // true
trace(pattern.exec(str)); // Bob

lastIndex

właściwość

lastIndex:Number

Wersja języka:

ActionScript 3.0

Wersje środowiska wykonawczego:

AIR 1.0, Flash Player 9, Flash Lite 4

Określa indeks w ciągu znaków, od którego ma się rozpocząć następne wyszukiwanie. Ta właściwość wpływa na metody exec() oraz test() klasy RegExp. W przypadku metod match(), replace() oraz search() klasy String właściwość lastIndex jest pomijana, a wyszukiwanie następuje od samego początku ciągu znaków.

Jeśli metoda exec() lub test() wyszuka zgodność, a dla wyrażenia regularnego flaga g (global) będzie ustawiona na wartość true, metoda automatycznie ustawia właściwość lastIndex na wartość indeksu znaku znajdującego się po ostatnim znaku ostatniego zgodnego fragmentu ciągu. W przypadku gdy flaga g (global) zostanie ustawiona na wartość false, metoda nie ustawi właściwości lastIndex.

Aby określić położenie początkowe w ciągu znaków dla wyszukiwania zgodności wyrażenia regularnego, należy ustawić właściwość lastIndex.

Implementacja
public function get lastIndex():Number
public function set lastIndex(value:Number):void

Przykład ( Sposób korzystania z tego przykładu )

Poniższy przykład ilustruje rezultaty ustawienia właściwości lastIndex i pokazuje jej aktualizacje po wywołaniu metody exec() dla wyrażenia regularnego, w którym została ustawiona flaga g (global):

var pattern:RegExp = /\w\d/g; 
var str:String = "a1 b2 c3 d4";
pattern.lastIndex = 2; 
trace(pattern.exec(str)); // b2
trace(pattern.lastIndex); // 5
trace(pattern.exec(str)); // c3
trace(pattern.lastIndex); // 8
trace(pattern.exec(str)); // d4
trace(pattern.lastIndex); // 11
trace(pattern.exec(str)); // null

multiline

właściwość

multiline:Boolean [tylko do odczytu]

Wersja języka:

ActionScript 3.0

Wersje środowiska wykonawczego:

AIR 1.0, Flash Player 9, Flash Lite 4

Określa, czy jest ustawiona flaga m (multiline). Jeśli jest ustawiona, znak karetki (^) oraz symbol dolara ($) w wyrażeniu regularnym określają zgodność przed i po znakach nowego wiersza. Do budowania wyrażenia regularnego dla ustawienia multiline = true należy użyć flagi m.

Implementacja
public function get multiline():Boolean

Przykład ( Sposób korzystania z tego przykładu )

Poniższy przykład ilustruje rezultaty ustawienia flagi m (multiline):

var pattern:RegExp = /^bob/; 
var str:String = "foo\n"
                + "bob";
trace(pattern.multiline); // false
trace(pattern.exec(str)); // null

pattern = /^bob/m;
trace(pattern.multiline); // true
trace(pattern.exec(str)); // bob

source

właściwość

source:String [tylko do odczytu]

Wersja języka:

ActionScript 3.0

Wersje środowiska wykonawczego:

AIR 1.0, Flash Player 9, Flash Lite 4

Określa wzorzec występujący w wyrażeniu regularnym.

Implementacja
public function get source():String

Przykład ( Sposób korzystania z tego przykładu )

Rezultatem poniższego kodu jest parametr source dla dwóch wyrażeń regularnych:

var re1:RegExp = /aabb/gi;
trace (re1.source); // aabb

var re2:RegExp = new RegExp("x+y*", "i");
trace(re2.source); // x+y*

Konstruktor Szczegół

()

Konstruktor

public function RegExp(re:String, flags:String)

Wersja języka:

ActionScript 3.0

Wersje środowiska wykonawczego:

AIR 1.0, Flash Player 9

Pozwala zbudować wyrażenie regularne z dwóch ciągów znaków. Jeden ciąg znaków określa wzorzec regularnego wyrażenia, a drugi definiuje flagi użyte w tym wyrażeniu.

Parametry

re:String — Wzorzec wyrażenia regularnego (znany również jako ciąg znaków konstruktora). Jest to główny fragment wyrażenia regularnego (fragment znajdujący się między znakami „/”).

Uwagi:

Nie należy uwzględniać początkowych oraz końcowych znaków „/”. Można je stosować jedynie podczas definiowania literału wyrażenia regularnego bez użycia konstruktora. Na przykład dwa poniższe wyrażenia regularne są równoważne:
```
 var re1:RegExp = new RegExp("bob", "i"); 
        var re2:RegExp = /bob/i;
```
Aby użyć metasekwencji rozpoczynającej się znakiem ukośnika w tył (\), jak np. \d (oznacza dowolna cyfrę), w wyrażeniu regularnym utworzonym za pomocą konstruktora RegExp(), należy dwa razy wpisać znak ukośnika w tył. Na przykład dwa poniższe wyrażenia regularne są równoważne:
```
 var re1:RegExp = new RegExp("\\d+", ""); 
        var re2:RegExp = /\d/;
```
W pierwszym wyrażeniu znak ukośnika w tył należy wpisać dwa razy, ponieważ pierwszy parametr metody konstruktora RegExp() stanowi ciąg znaków. Natomiast w literale ciągu znaków należy znak ukośnika w tył wpisać dwa razy, aby został rozpoznany jako pojedynczy znak ukośnika w tył.

flags:String — Modyfikatory wyrażenia regularnego. Mogą zawierać następujące elementy:

g — Ten modyfikator należy określić w przypadku korzystania z metody replace() klasy String w celu zastąpienia wszystkich, a nie tylko pierwszej zgodności. Ten modyfikator odpowiada właściwości global instancji RegExp.
i — Wyrażenie regularne jest interpretowane z pominięciem wielkości liter. Ten modyfikator odpowiada właściwości ignoreCase instancji RegExp.
s — Znak kropki (.) określa zgodność ze znakiem nowego wiersza. Uwaga: ten modyfikator odpowiada właściwości dotall instancji RegExp.
m — Znak karetki (^) oraz symbol dolara ($) określają zgodność przed i po znaku nowego wiersza. Ten modyfikator odpowiada właściwości multiline instancji RegExp.
x — Białe znaki w ciągu znaków re są pomijane, co umożliwia tworzenie bardziej czytelnych konstruktorów. Ten modyfikator odpowiada właściwości extended instancji RegExp.

Pozostałe znaki w ciągu znaków flags są pomijane.

Szczegół metody

exec

()

metoda

AS3 function exec(str:String):Object

Wersja języka:

ActionScript 3.0

Wersje środowiska wykonawczego:

AIR 1.0, Flash Player 9, Flash Lite 4

Umożliwia wyszukanie wyrażenia regularnego w danym ciągu znaków str.

Jeśli dla wyrażenia regularnego nie została ustawiona flaga g (global), wówczas wyszukiwanie rozpoczyna się na początku ciągu znaków (w indeksie 0). Podczas wyszukiwania właściwość lastIndex regularnego wyrażenia jest pomijana.

Jeśli dla wyrażenia regularnego została ustawiona flaga g (global), wówczas wyszukiwanie rozpoczyna się w pozycji indeksu określonego przez właściwość lastIndex wyrażenia regularnego. Jeśli podczas wyszukiwania zgodny fragment ciągu zostanie odnaleziony, wartość właściwości lastIndex ulega zmianie na wartość pozycji końca zgodnego fragmentu ciągu.

Parametry

str:String — Ciąg znaków, który będzie wyszukiwany.

Zwraca

Object — W przypadku braku zgodności wyświetlana jest wartość null; w sytuacji odwrotnej, wyświetlony zostanie obiekt o następujących właściwościach:

Tablica, w której element 0 zawiera całkowicie zgodny fragment ciągu, a pozostałe elementy tablicy (od 1 do n) zawierają fragmenty ciągu, które są zgodne z ujętymi w nawiasy grupami wyrażenia regularnego.
index — Pozycja znaku w zgodnym fragmencie ciągu znaków.
input — Ciąg (str)

Powiązane elementy interfejsu API

String.match()
String.search()

Przykład ( Sposób korzystania z tego przykładu )

W przypadku, gdy dla wyrażenia regularnego flaga g (global) nie została ustawiona, można użyć metody exec(), aby znaleźć pierwszy zgodny fragment ciągu:

         var myPattern:RegExp = /(\w*)sh(\w*)/ig;   
         var str:String = "She sells seashells by the seashore";
         var result:Object = myPattern.exec(str);
         trace(result);

Obiekt result wygląda następująco:

result[0] jest ustawiony na wartość "She" (całkowita zgodność).
result[1] jest ustawiony na pusty ciąg znaków (pierwsza zgodna grupa ujęta w nawiasach).
result[2] jest ustawiony na wartość "e" (druga zgodna grupa ujęta w nawiasach).
Parametr result.index jest ustawiony na wartość 0.
Parametr result.input jest ustawiony na ciąg wejściowy: "She sells seashells by the seashore".

W poniższym przykładzie dla wyrażenia regularnego została ustawiona flaga g (global). Z tego względu można wyszukiwać wielu zgodności poprzez wielokrotne zastosowanie metody exec():

         var myPattern:RegExp = /(\w*)sh(\w*)/ig;  
         var str:String = "She sells seashells by the seashore";
         var result:Object = myPattern.exec(str);
         
         while (result != null) {
             trace ( result.index, "\t", result);
             result = myPattern.exec(str);
         }

Przy użyciu niniejszego kodu można uzyskać następujące wyniki:


            0      She,,e
            10     seashells,sea,ells
            27     seashore,sea,ore

test

()

metoda

AS3 function test(str:String):Boolean

Wersja języka:

ActionScript 3.0

Wersje środowiska wykonawczego:

AIR 1.0, Flash Player 9, Flash Lite 4

Testy na zgodność wyrażenia regularnego w danym ciągu znaków str.

Parametry

str:String — Ciąg znaków, który będzie testowany.

Zwraca

Boolean — Dla zgodności zostaje wyświetlona wartość true; w odwrotnej sytuacji — wartość false.

Przykład ( Sposób korzystania z tego przykładu )

Poniższy przykład ilustruje zastosowanie metody test() w przypadku wyrażenia regularnego, dla którego została ustawiona flaga g (global):

var re1:RegExp = /\w/g;
var str:String = "a b c";
trace (re1.lastIndex); // 0
trace (re1.test(str)); // true
trace (re1.lastIndex); // 1
trace (re1.test(str)); // true
trace (re1.lastIndex); // 3
trace (re1.test(str)); // true
trace (re1.lastIndex); // 5
trace (re1.test(str)); // false

Przykłady Sposób korzystania z tego przykładu

RegExpExample.as

Poniższy przykład ilustruje użycie wyrażeń regularnych do analizy składniowej ciągów znaków w celu wywołania zwrotu nowego ciągu znaków lub wartości typu Boolean w oparciu o przesłany ciąg. Za pomocą metody informalizeGreeting() można zastąpić wyraz „Hello” wyrazem „Hi” bez względu na wielkość liter. Pozwala ona również z nazwy w ciągu znaków usunąć nazwisko (zakładając, że nazwa odpowiada danemu wzorcowi). W przypadku metod validateEmail() oraz validatePhoneNumber() przekazany ciąg znaków jest sprawdzany pod kątem zgodności swojego wzorca z poprawnym wzorcem adresu e-mail lub numeru telefonu, a wartości analizy zwrócone przez te metody są wartościami typu Boolean.

package {
    import flash.display.Sprite;

    public class RegExpExample extends Sprite {        
        public function RegExpExample() {            
            var formalGreeting:String = "Hello, John Smith.";
            trace(informalizeGreeting(formalGreeting));    // Hi, John.

            var validEmail:String = "name@domain.com";
            trace(validateEmail(validEmail));        // true
            
            var invalidEmail:String = "foo";
            trace(validateEmail(invalidEmail));  // false
            
            var validPhoneNumber:String = "415-555-1212";
            trace(validatePhoneNumber(validPhoneNumber));    // true
            
            var invalidPhoneNumber:String = "312-867-530999";
            trace(validatePhoneNumber(invalidPhoneNumber));  // false
        }
        private function informalizeGreeting(str:String):String {
            var pattern:RegExp = new RegExp("hello, (\\w+) \\w+", "i");
            return str.replace(pattern, "Hi, $1");
        }
        private function validateEmail(str:String):Boolean {
            var pattern:RegExp = /(\w|[_.\-])+@((\w|-)+\.)+\w{2,4}+/;
            var result:Object = pattern.exec(str);
            if(result == null) {
                return false;
            }
            return true;
        }
        private function validatePhoneNumber(str:String):Boolean {
            var pattern:RegExp = /^\d{3}-\d{3}-\d{4}$/;
            var result:Object = pattern.exec(str);
            if(result == null) {
                return false;
            }
            return true;
        }
    }
}

Informacje prawne | Zasady prywatności online

RegExp - AS3

Klasy x

dotall

extended

global

ignoreCase

lastIndex

multiline

source

RegExp

exec

test