RegExp

Paket	Översta nivån
Klass	public dynamic class RegExp
Arv	RegExp Object

Språkversion:

ActionScript 3.0

Körningsmiljöversioner:

AIR 1.0, Flash Player 9, Flash Lite 4

Med klassen RegExp kan du arbeta med reguljära uttryck, som är mönster som du kan använda för att göra sökningar i strängar och för att ersätta text i strängar.

Du kan skapa ett nytt RegExp-objekt genom att använda konstruktorn new RegExp() eller genom att tilldela en RegExp-litteral till en variabel:

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

Ytterligare information finns i kapitlet ”Använda reguljära uttryck” i Utvecklarhandbok för Adobe ActionScript 3.0.

Visa exemplen

Relaterade API-element

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

Publika egenskaper

Dölj ärvda publika egenskaper

Visa ärvda publika egenskaper

	Egenskap		Definieras med
		constructor : Object En referens till klassobjektet eller konstruktorfunktionen för en given objektinstans.	Object
		dotall : Boolean [skrivskyddad] Anger om tecknet punkt (.) i ett reguljärt uttrycksmönster matchar radbrytningstecken.	RegExp
		extended : Boolean [skrivskyddad] Anger om utökat läge ska användas för det reguljära uttrycket.	RegExp
		global : Boolean [skrivskyddad] Anger om global sökning ska användas för det reguljära uttrycket.	RegExp
		ignoreCase : Boolean [skrivskyddad] Anger om det reguljära uttrycket ska ignorera skiftlägeskänslighet.	RegExp
		lastIndex : Number Anger indexpositionen i strängen som nästa sökning ska starta vid.	RegExp
		multiline : Boolean [skrivskyddad] Anger om flaggan m (multiline) är inställd.	RegExp
		source : String [skrivskyddad] Anger det reguljära uttryckets mönsterdel.	RegExp

Publika metoder

Dölj ärvda publika metoder

Visa ärvda publika metoder

	Metod		Definieras med
		RegExp(re:String, flags:String) Gör att du kan skapa ett reguljärt uttryck av två strängar.	RegExp
		exec(str:String):Object Gör en sökning efter det reguljära uttrycket i den givna strängen str.	RegExp
		hasOwnProperty(name:String):Boolean Anger om det finns en egenskap angiven för ett objekt.	Object
		isPrototypeOf(theClass:Object):Boolean Anger om en instans av klassen Object finns i prototypkedjan för objektet som anges som parameter.	Object
		propertyIsEnumerable(name:String):Boolean Anger om den angivna egenskapen finns och är uppräkningsbar.	Object
		setPropertyIsEnumerable(name:String, isEnum:Boolean = true):void Anger tillgänglighet för en dynamisk egenskap för slingåtgärder.	Object
		test(str:String):Boolean Testar om det finns en matchning för det reguljära uttrycket i den givna strängen str.	RegExp
		toLocaleString():String Returnerar det här objektets strängrepresentation, formaterad i enlighet med språkspecifika konventioner.	Object
		toString():String Returnerar det angivna objektets strängbeteckning.	Object
		valueOf():Object Returnerar det angivna objektets primitiva värde.	Object

Egenskapsdetaljer

dotall

egenskap

dotall:Boolean [skrivskyddad]

Språkversion:

ActionScript 3.0

Körningsmiljöversioner:

AIR 1.0, Flash Player 9, Flash Lite 4

Anger om tecknet punkt (.) i ett reguljärt uttrycksmönster matchar radbrytningstecken. Använd flaggan s när du konstruerar ett reguljärt uttryck som ställer in dotall = true.

Implementering
public function get dotall():Boolean

Exempel ( Så här använder du exemplet )

I följande exempel visas effekten av flaggan s (dotall) på ett reguljärt uttryck:

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

egenskap

extended:Boolean [skrivskyddad]

Språkversion:

ActionScript 3.0

Körningsmiljöversioner:

AIR 1.0, Flash Player 9, Flash Lite 4

Anger om utökat läge ska användas för det reguljära uttrycket. När ett RegExp-objekt är i extended-läge ignoreras tomrumstecken i konstruktorsträngen. Detta görs för att konstruktorer som är lättare att läsa ska tillåtas.

Använd flaggan x när du konstruerar ett reguljärt uttryck som ställer in extended = true.

Implementering
public function get extended():Boolean

Exempel ( Så här använder du exemplet )

I följande exempel visas olika sätt att konstruera samma reguljära uttryck. I varje exempel ska det reguljära uttrycket matcha telefonnummermönstret xxx-xxx-xxxx, (xxx) xxx-xxxx eller (xxx)xxx-xxxx. Det andra reguljära uttrycket använder flaggan x som ignorerar tomrum i strängen.

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

egenskap

global:Boolean [skrivskyddad]

Språkversion:

ActionScript 3.0

Körningsmiljöversioner:

AIR 1.0, Flash Player 9, Flash Lite 4

Anger om global sökning ska användas för det reguljära uttrycket. När global == true ställs egenskapen lastIndex in efter en matchning. Nästa gång en matchning begärs startar den reguljära uttrycksmotorn från positionen lastIndex i strängen. Använd flaggan x när du konstruerar ett reguljärt uttryck som ställer in extended till true.

Implementering
public function get global():Boolean

Exempel ( Så här använder du exemplet )

I följande exempel visas effekten av att flaggan g (global) ställs in på metoden 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

egenskap

ignoreCase:Boolean [skrivskyddad]

Språkversion:

ActionScript 3.0

Körningsmiljöversioner:

AIR 1.0, Flash Player 9

Anger om det reguljära uttrycket ska ignorera skiftlägeskänslighet. Använd flaggan i när du konstruerar ett reguljärt uttryck som ställer in ignoreCase = true.

Implementering
public function get ignoreCase():Boolean

Exempel ( Så här använder du exemplet )

I följande exempel visas effekten av att ställa in flaggan 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

egenskap

lastIndex:Number

Språkversion:

ActionScript 3.0

Körningsmiljöversioner:

AIR 1.0, Flash Player 9, Flash Lite 4

Anger indexpositionen i strängen som nästa sökning ska starta vid. Egenskapen påverkar metoderna exec() och test() i klassen RegExp. Metoderna match(), replace() och search() i klassen String ignorerar dock egenskapen lastIndex och söker igenom alla strängar från början.

När metoden exec() eller test() hittar en matchning och flaggan g (global) är inställd på true för det reguljära uttrycket ställer metoden automatiskt in egenskapen lastIndex på indexpositionen för tecknet efter den matchande delsträngen i den senaste matchningen. Om flaggan g (global) är inställd på false ställer metoden inte in egenskapen lastIndex.

Du kan ställa in egenskapen lastIndex om du vill justera startpositionen i strängen för reguljär uttrycksmatchning.

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

Exempel ( Så här använder du exemplet )

I följande exempel visas effekten av att ställa in egenskapen lastIndex. Dessutom visas hur den uppdateras efter ett anrop till metoden exec() på ett reguljärt uttryck där flaggan g (global) är inställd:

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

egenskap

multiline:Boolean [skrivskyddad]

Språkversion:

ActionScript 3.0

Körningsmiljöversioner:

AIR 1.0, Flash Player 9, Flash Lite 4

Anger om flaggan m (multiline) är inställd. Om den är inställd kommer cirkumflex- (^) och dollartecknet ($) i ett reguljärt uttryck att matchas före och efter radbrytning. Använd flaggan m när du konstruerar ett reguljärt uttryck som ställer in multiline = true.

Implementering
public function get multiline():Boolean

Exempel ( Så här använder du exemplet )

I följande exempel visas effekten av att ställa in flaggan 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

egenskap

source:String [skrivskyddad]

Språkversion:

ActionScript 3.0

Körningsmiljöversioner:

AIR 1.0, Flash Player 9, Flash Lite 4

Anger det reguljära uttryckets mönsterdel.

Implementering
public function get source():String

Exempel ( Så här använder du exemplet )

Följande kod ger parametern source för två reguljära uttryck:

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

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

Konstruktordetaljer

()

Konstruktor

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

Språkversion:

ActionScript 3.0

Körningsmiljöversioner:

AIR 1.0, Flash Player 9

Gör att du kan skapa ett reguljärt uttryck av två strängar. En sträng definierar det reguljära uttryckets mönster och den andra definierar flaggorna som används i det reguljära uttrycket.

Parametrar

re:String — Det reguljära uttryckets mönster (kallas även konstruktorsträng). Detta är huvuddelen av det reguljära uttrycket (den del som finns mellan "/"-tecknen).

Obs!

Ta inte med de inledande och efterföljande "/"-tecknen. Använd endast dessa när du definierar en reguljär uttryckslitteral utan att använda konstruktorn. Följande två reguljära uttryck är likvärdiga:
```
 var re1:RegExp = new RegExp("bob", "i"); 
        var re2:RegExp = /bob/i;
```
Om du vill använda en metasekvens som börjar med ett omvänt snedstreck (\), till exempel \d (som matchar alla siffror), skriver du det omvända snedstrecket två gånger i det reguljära uttrycket som definieras med konstruktormetoden RegExp(). Följande två reguljära uttryck är likvärdiga:
```
 var re1:RegExp = new RegExp("\\d+", ""); 
        var re2:RegExp = /\d/;
```
I det första uttrycket måste du skriva det omvända snedstrecket två gånger eftersom den första parametern till konstruktormetoden RegExp() är en sträng och i en stränglitteral måste du skriva det omvända snedstrecket två gånger för att det ska kännas igen som ett enkelt omvänt snedstreck.

flags:String — Det reguljära uttryckets modifierare. Dessa kan vara några av följande:

g – När du använder metoden replace() i klassen String anger den här modifieraren att alla matchningar ska ersättas i stället för endast den första. Modifieraren motsvarar egenskapen global i instansen RegExp.
i – Det reguljära uttrycket utvärderas utan skiftlägeskänslighet. Modifieraren motsvarar egenskapen global i instansen RegExp.
s – Punkten (.) matchar radbrytningstecken. Obs: Modifieraren motsvarar egenskapen dotall i instansen RegExp.
m – Cirkumflextecknet (^) och dollartecknet ($) matchar före och efter radbrytningstecken. Modifieraren motsvarar egenskapen multiline i instansen RegExp.
x – Tomrumstecken i re-strängen ignoreras så att du kan skriva lättlästa konstruktorer. Modifieraren motsvarar egenskapen extended i instansen RegExp.

Alla andra tecken i flags-strängen ignoreras.

Metoddetaljer

exec

()

metod

AS3 function exec(str:String):Object

Språkversion:

ActionScript 3.0

Körningsmiljöversioner:

AIR 1.0, Flash Player 9, Flash Lite 4

Gör en sökning efter det reguljära uttrycket i den givna strängen str.

Om flaggan g (global) inte är inställd för det reguljära uttrycket börjar sökningen i början av strängen (vid indexposition 0). Sökningen ignorerar egenskapen lastIndex i det reguljära uttrycket.

Om flaggan g (global) är inställd för det reguljära uttrycket börjar sökningen vid indexpositionen, som anges av lastIndex i det reguljära uttrycket. Om sökningen matchar en delsträng ändras egenskapen lastIndex för att matcha positionen i slutet av matchningen.

Parametrar

str:String — Strängen som eftersöks.

Returnerar

Object — Om det inte blir någon matchning null; annars ett objekt med följande egenskaper:

En array där element 0 innehåller den kompletta matchande delsträngen och de andra elementen i arrayen (1 till n) innehåller delsträngar som matchar parentetiska grupper i det reguljära uttrycket
index – Teckenpositionen för den matchande delsträngen i strängen
input – Strängen (str)

Relaterade API-element

String.match()
String.search()

Exempel ( Så här använder du exemplet )

Om flaggan g (global) inte är inställd i det reguljära uttrycket kan du använda exec() för att hitta den första matchningen i strängen:

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

Objektet result ställs in på följande:

result[0] är inställt på "She" (den kompletta matchningen).
result[1] är inställt på en tom sträng (den första matchande parentetiska gruppen).
result[2] är inställt på "e" (den andra matchande parentetiska gruppen).
result.index är inställt på 0.
result.input är inställt på indatasträngen: "She sells seashells by the seashore".

I följande exempel är flaggan g (global) inställd i det reguljära uttrycket så att du kan använda exec() upprepade gånger för att hitta flera matchningar:

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

Koden ger följande utdata:


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

test

()

metod

AS3 function test(str:String):Boolean

Språkversion:

ActionScript 3.0

Körningsmiljöversioner:

AIR 1.0, Flash Player 9, Flash Lite 4

Testar om det finns en matchning för det reguljära uttrycket i den givna strängen str.

Parametrar

str:String — Strängen som ska testas.

Returnerar

Boolean — Om det är en matchning true; annars false.

Exempel ( Så här använder du exemplet )

I följande exempel visas hur metoden test() används på ett reguljärt uttryck där flaggan g (global) är inställd:

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

Exempel Så här använder du exemplet

RegExpExample.as

I följande exempel visas hur du kan använda reguljära uttryck när du tolkar strängar och returnerar en ny sträng eller ett booleskt värde, baserat på den sträng som skickades. Metoden informalizeGreeting() ersätter ordet Hello med Hi oavsett skiftläge. Dessutom tas efternamnet bort från en sträng med ett namn (om namnet matchar ett visst angivet mönster). I metoderna validateEmail() och validatePhoneNumber() kontrolleras den inskickade strängen för att se om dess mönster matchar en giltig e-postadress eller ett visst telefonnummermönster. Metoderna returnerar booleska värden baserat på resultaten.

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

Juridiska meddelanden | Onlinesekretesspolicy

RegExp - AS3

Paketx

Språkelement

Bilagor

Klasser x

dotall

extended

global

ignoreCase

lastIndex

multiline

source

RegExp

exec

test