RegExp

Pacote	Nível superior
Classe	public dynamic class RegExp
Herança	RegExp Object

Versão da linguagem:

ActionScript 3.0

Versões de runtime:

AIR 1.0, Flash Player 9, Flash Lite 4

A classe RegExp permite trabalhar com expressões regulares, que são padrões que você pode usar para fazer pesquisas em strings e substituir o texto em strings.

Você pode criar um novo objeto RegExp usando o construtor new RegExp() ou atribuindo um literal de RegExp a uma variável:

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

Para obter mais informações, consulte "Usando Expressões Regulares" no Guia do Desenvolvedor do ActionScript 3.0.

Veja os exemplos

Elementos da API relacionados

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

Propriedades públicas

Ocultar propriedades públicas herdadas

Mostrar propriedades públicas herdadas

	Propriedade		Definido por
		constructor : Object Uma referência ao objeto de classe ou à função de construtor de uma determinada ocorrência de objeto.	Object
		dotall : Boolean [somente leitura] Especifica se o caractere de ponto (.) em um padrão de expressão regular coincide com caracteres de nova linha.	RegExp
		extended : Boolean [somente leitura] Especifica se o modo estendido será ou não usado para a expressão regular.	RegExp
		global : Boolean [somente leitura] Especifica se a correspondência global será ou não usada para a expressão regular.	RegExp
		ignoreCase : Boolean [somente leitura] Especifica se a expressão regular trata igualmente maiúsculas e minúsculas.	RegExp
		lastIndex : Number Especifica a posição do índice na string na qual iniciar a próxima pesquisa.	RegExp
		multiline : Boolean [somente leitura] Especifica se o sinalizador m (multiline) está definido.	RegExp
		source : String [somente leitura] Especifica a parte de padrão da expressão regular.	RegExp

Métodos públicos

Ocultar métodos públicos herdados

Mostrar métodos públicos herdados

	Método		Definido por
		RegExp(re:String, flags:String) Permite construir uma expressão regular a partir de duas strings.	RegExp
		exec(str:String):Object Faz uma pesquisa pela expressão regular na string str especificada.	RegExp
		hasOwnProperty(name:String):Boolean Indica se um objeto tem uma propriedade especificada definida.	Object
		isPrototypeOf(theClass:Object):Boolean Indica se uma ocorrência da classe Object está na cadeia de protótipos do objeto especificado como o parâmetro.	Object
		propertyIsEnumerable(name:String):Boolean Indica se a propriedade especificada existe e é enumerável.	Object
		setPropertyIsEnumerable(name:String, isEnum:Boolean = true):void Define a disponibilidade de uma propriedade dinâmica para operações de repetição.	Object
		test(str:String):Boolean Faz testes para a correspondência da expressão regular na string str especificada.	RegExp
		toLocaleString():String Retorna a representação da string deste objeto, formatado segundo as convenções específicas para a localidade.	Object
		toString():String Retorna a representação de string do objeto especificado.	Object
		valueOf():Object Retorna o valor primitivo do objeto especificado.	Object

Detalhes da propriedade

dotall

propriedade

dotall:Boolean [somente leitura]

Versão da linguagem:

ActionScript 3.0

Versões de runtime:

AIR 1.0, Flash Player 9, Flash Lite 4

Especifica se o caractere de ponto (.) em um padrão de expressão regular coincide com caracteres de nova linha. Use o sinalizador s ao construir uma expressão regular para definir dotall = true.

Implementação
public function get dotall():Boolean

Exemplo ( Como usar este exemplo )

O exemplo a seguir mostra o efeito do sinalizador s (dotall) em uma expressão regular:

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

propriedade

extended:Boolean [somente leitura]

Versão da linguagem:

ActionScript 3.0

Versões de runtime:

AIR 1.0, Flash Player 9, Flash Lite 4

Especifica se o modo estendido será ou não usado para a expressão regular. Quando um objeto RegExp está no modo estendido, os caracteres de espaço em branco na string do construtor são ignorados. Isso é feito para permitir construtores mais legíveis.

Use o sinalizador x ao construir uma expressão regular para definir extended = true.

Implementação
public function get extended():Boolean

Exemplo ( Como usar este exemplo )

O exemplo a seguir mostra diferentes formas de construir a mesma expressão regular. Em cada uma, a expressão regular deve coincidir com um padrão de número de telefone de xxx-xxx-xxxx ou (xxx) xxx-xxxx ou (xxx)xxx-xxxx. A segunda expressão regular usa o sinalizador x, fazendo com que os espaços em branco na string sejam ignorados.

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

propriedade

global:Boolean [somente leitura]

Versão da linguagem:

ActionScript 3.0

Versões de runtime:

AIR 1.0, Flash Player 9, Flash Lite 4

Especifica se a correspondência global será ou não usada para a expressão regular. Quando global == true, a propriedade lastIndex é definida depois que uma correspondência é encontrada. Da próxima vez que uma correspondência for solicitada, o mecanismo da expressão regular começará da posição lastIndex na string. Use o sinalizador g ao construir uma expressão regular para definir global como true.

Implementação
public function get global():Boolean

Exemplo ( Como usar este exemplo )

O exemplo a seguir mostra o efeito de definir o sinalizador g (global) no método 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

propriedade

ignoreCase:Boolean [somente leitura]

Versão da linguagem:

ActionScript 3.0

Versões de runtime:

AIR 1.0, Flash Player 9

Especifica se a expressão regular trata igualmente maiúsculas e minúsculas. Use o sinalizador i ao construir uma expressão regular para definir ignoreCase = true.

Implementação
public function get ignoreCase():Boolean

Exemplo ( Como usar este exemplo )

O exemplo a seguir mostra o efeito de definir o sinalizador 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

propriedade

lastIndex:Number

Versão da linguagem:

ActionScript 3.0

Versões de runtime:

AIR 1.0, Flash Player 9, Flash Lite 4

Especifica a posição do índice na string na qual iniciar a próxima pesquisa. Essa propriedade afeta os métodos exec() e test() da classe RegExp. Entretanto, os métodos match(), replace() e search() da classe String ignoram a propriedade lastIndex e iniciam todas as pesquisas do início da string.

Quando o método exec() ou test() localiza uma correspondência e o sinalizador g (global) está definido como true para a expressão regular, esse método define automaticamente a propriedade lastIndex à posição de índice do caractere após o último caractere na substring correspondente da última correspondência. Se o sinalizador g (global) estiver definido como false, o método não definirá a propriedade lastIndex.

Você pode definir a propriedade lastIndex para ajustar a posição inicial na string para a correspondência da expressão regular.

Implementação
public function get lastIndex():Number
public function set lastIndex(value:Number):void

Exemplo ( Como usar este exemplo )

O exemplo a seguir mostra o efeito de definir a propriedade lastIndex e mostra como ela é atualizada após uma chamada ao método exec() em uma expressão regular na qual o sinalizador g (global) está definido:

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

propriedade

multiline:Boolean [somente leitura]

Versão da linguagem:

ActionScript 3.0

Versões de runtime:

AIR 1.0, Flash Player 9, Flash Lite 4

Especifica se o sinalizador m (multiline) está definido. Se estiver definido, o circunflexo (^) e o sinal de cifrão ($) em uma expressão regular coincidirão antes e depois de novas linhas. Use o sinalizador m ao construir uma expressão regular para definir multiline = true.

Implementação
public function get multiline():Boolean

Exemplo ( Como usar este exemplo )

O exemplo a seguir mostra o efeito de definir o sinalizador 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

propriedade

source:String [somente leitura]

Versão da linguagem:

ActionScript 3.0

Versões de runtime:

AIR 1.0, Flash Player 9, Flash Lite 4

Especifica a parte de padrão da expressão regular.

Implementação
public function get source():String

Exemplo ( Como usar este exemplo )

O código a seguir processa o parâmetro source para duas expressões regulares:

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

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

Detalhes do construtor

()

Construtor

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

Versão da linguagem:

ActionScript 3.0

Versões de runtime:

AIR 1.0, Flash Player 9

Permite construir uma expressão regular a partir de duas strings. Uma string define o padrão da expressão regular, enquanto a outra define os sinalizadores usados na expressão regular.

Parâmetros

re:String — O padrão da expressão regular (também conhecido como a string do construtor). Essa é a parte principal da expressão regular (a parte delimitada pelos caracteres "/").

Observações:

Não inclua os caracteres "/" anterior e posterior; use-os apenas ao definir um literal de expressão regular sem usar o construtor. Por exemplo, as duas expressões regulares a seguir são equivalentes:
```
 var re1:RegExp = new RegExp("bob", "i"); 
        var re2:RegExp = /bob/i;
```
Em uma expressão regular definida com o método do construtor RegExp(), para usar uma metassequência que comece com o caractere de barra invertida (\), como \d (que corresponde a qualquer dígito), digite duas vezes esse caractere de barra invertida. Por exemplo, as duas expressões regulares a seguir são equivalentes:
```
 var re1:RegExp = new RegExp("\\d+", ""); 
        var re2:RegExp = /\d/;
```
Na primeira expressão, é necessário digitar o caractere de barra invertida duas vezes, pois o primeiro parâmetro do método do construtor RegExp() é uma string, e, em um literal de string, é necessário digitar um caractere de barra invertida duas vezes para que ele seja reconhecido como um único caractere de barra invertida.

flags:String — Os modificadores da expressão regular. Estão incluídos:

g — Ao usar o método replace() da classe String, especifique este modificador para substituir todas as correspondências, em vez de substituir apenas a primeira. Este modificador corresponde à propriedade global da instância de RegExp.
i — A expressão regular é avaliada sem diferenciação entre maiúsculas e minúsculas. Este modificador corresponde à propriedade ignoreCase da instância de RegExp.
s — o caractere de ponto (.) corresponde a caracteres de nova linha. Nota: este modificador corresponde à propriedade dotall da instância de RegExp.
m — o caractere de circunflexo (^) e o sinal de cifrão ($) são correspondidos antes e depois de caracteres de nova linha. Este modificador corresponde à propriedade multiline da instância de RegExp.
x — Caracteres de espaço em branco na string re são ignorados, para que você possa gravar construtores mais legíveis. Este modificador corresponde à propriedade extended da ocorrência de RegExp.

Todos os outros caracteres na string flags são ignorados.

Detalhes do método

exec

()

método

AS3 function exec(str:String):Object

Versão da linguagem:

ActionScript 3.0

Versões de runtime:

AIR 1.0, Flash Player 9, Flash Lite 4

Faz uma pesquisa pela expressão regular na string str especificada.

Se o sinalizador g (global) não estiver definido para a expressão regular, a pesquisa começará no início da string (na posição de índice 0); a pesquisa ignora a propriedade lastIndex da expressão regular.

Se o sinalizador g (global) estiver definido para a expressão regular, a pesquisa começará na posição de índice especificada pela propriedade lastIndex da expressão regular. Se a pesquisa coincidir com uma substring, a propriedade lastIndex será alterada de forma a coincidir com o final da correspondência.

Parâmetros

str:String — A string a ser pesquisada.

Retorna

Object — Se não houver correspondência, null; caso contrário, um objeto com as seguintes propriedades:

Uma matriz, na qual o elemento 0 contém a substring de correspondência completa, enquanto os outros elementos da matriz (1 a n) contêm substrings que correspondem a grupos parentéticos na expressão regular
index — a posição de caracteres da substring correspondida dentro da string
input — a string (str)

Elementos da API relacionados

String.match()
String.search()

Exemplo ( Como usar este exemplo )

Quando o sinalizador g (global) não estiver definido na expressão regular, você poderá usar exec() para localizar a primeira correspondência na string:

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

O objeto result é definido como o seguinte:

result[0] é definido como "She" (a correspondência completa).
result[1] é definido como uma string vazia (o primeiro grupo parentético correspondente).
result[2] é definido como "e" (o segundo grupo correspondente de parênteses).
result.index é definido como 0.
result.input é definido como a string de entrada: "She sells seashells by the seashore".

No exemplo a seguir, o sinalizador g (global) está definido na expressão regular e, portanto, você pode usar exec() repetidamente para localizar várias correspondências:

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

Este código resulta na seguinte saída:


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

test

()

método

AS3 function test(str:String):Boolean

Versão da linguagem:

ActionScript 3.0

Versões de runtime:

AIR 1.0, Flash Player 9, Flash Lite 4

Faz testes para a correspondência da expressão regular na string str especificada.

Parâmetros

str:String — A string a ser testada.

Retorna

Boolean — Se houver uma correspondência, true; caso contrário, false.

Exemplo ( Como usar este exemplo )

O exemplo a seguir mostra o uso do método test() em uma expressão regular na qual o sinalizador g (global) está definido:

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

Exemplos Como usar este exemplo

RegExpExample.as

O exemplo a seguir mostra como você pode usar expressões regulares para analisar strings e retornar uma nova string ou valor booliano, com base na string transmitida. O método informalizeGreeting() simplesmente substitui a palavra Hello por Hi, independentemente da formatação de maiúsculas ou minúsculas. Ele também retira o sobrenome no nome da string (pressupondo que o nome corresponda ao padrão especificado). Nos métodos validateEmail() e validatePhoneNumber(), a string transmitida é verificada para que se possa detectar se o seu padrão corresponde a um endereço de email válido ou a um padrão de número de telefone específico, e os métodos retornam valores boolianos com base nos resultados.

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

Aspectos jurídicos | Política de privacidade on-line

RegExp - AS3

Pacotesx

Elementos de linguagem

Apêndices

Classes x

dotall

extended

global

ignoreCase

lastIndex

multiline

source

RegExp

exec

test