Localização de substrings e padrões em strings

Flash Player 9 e posterior, Adobe AIR 1.0 e posterior

Substrings são strings dentro de uma string. Por exemplo, a string "abc" tem as seguinte substrings: "" , "a" , "ab" , "abc" , "b" , "bc" , "c" . É possível usar os métodos do ActionScript para localizar substrings de uma string.

Padrões são definidos no ActionScript por strings ou por expressões regulares. Por exemplo, a expressão regular a seguir define um padrão específico, as letras A, B e C seguidas por um caractere de dígito (as barras são delimitadores de expressões regulares): 

/ABC\d/

O ActionScript inclui métodos para localização de padrões em strings e para substituir correspondências localizadas com substrings de substituição. Esses métodos são descritos nas seções a seguir.

Expressões regulares podem definir padrões intrincados. Para obter mais informações, consulte Uso de expressões regulares .

Localização de uma substring pela posição do caractere

Os métodos substr() e substring() são semelhantes. Os dois retornam uma substring de uma string. Os dois utilizam dois parâmetros. Nos dois métodos, o primeiro parâmetro é a posição do caractere inicial na string fornecida. No entanto, no método substr() , o segundo parâmetro é o length da substring a ser retornada e, no método substring() , o segundo parâmetro é a posição do caractere no end da substring (que não é incluída na string retornada). Este exemplo mostra a diferença entre esses dois métodos: 

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

O método slice() funciona de maneira semelhante ao método substring() . Quando recebe dois inteiros não negativos como parâmetros, ele funciona exatamente da mesma forma. No entanto o método slice() pode utilizar inteiros negativos como parâmetros e nesse caso a posição do caractere é utilizada a partir do final da string, conforme mostrado no exemplo a seguir: 

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

É possível combinar inteiros não negativos e negativos como os parâmetros do método slice() .

Localização da posição do caractere de uma substring correspondente

É possível usar os métodos indexOf() e lastIndexOf() para localizar substrings dentro de uma string, conforme mostrado no exemplo a seguir: 

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

Observe que o método indexOf() faz distinção entre maiúsculas e minúsculas.

É possível especificar um segundo parâmetro para indicar a posição do índice na string na qual iniciar a pesquisa, da seguinte maneira: 

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

O método lastIndexOf() localiza a última ocorrência de uma substring na string: 

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

Se você incluir um segundo parâmetro com o método lastIndexOf() , a pesquisa será conduzida naquela posição do índice na string operando retroativamente (da direita para a esquerda): 

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

Criação de uma matriz de substrings segmentadas por um delimitador

É possível usar o método split() para criar uma matriz de substrings que é dividida com base em um delimitador. Por exemplo, é possível segmentar uma string delimitada por vírgula ou por tabulação em várias strings.

O exemplo a seguir mostra como dividir uma matriz em substrings com o caractere e comercial (&) como o delimitador: 

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

O segundo parâmetro do método split() , que é opcional, define o tamanho máximo da matriz retornada.

Também é possível usar uma expressão regular como o caractere delimitador: 

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

Para obter mais informações, consulte Uso de expressões regulares e a Referência do ActionScript® 3.0 para Adobe® Flash® Platform .

Localização de padrões em sequências de caracteres e substituição de subsequências de caracteres

A classe String inclui os seguintes métodos para trabalhar com padrões em strings:

  • Use os métodos match() e search() para localizar substrings que correspondem a um padrão.

  • Use o método replace() para localizar substrings que correspondem a um padrão e substituí-las por uma substring especificada.

Esses métodos são descritos nas seções a seguir.

É possível usar strings ou expressões regulares para definir padrões usados nesses métodos. Para obter mais informações sobre expressões regulares, consulte Uso de expressões regulares .

Adobe recomenda

Cortar 00s anteriores e posteriores de uma sequência de caracteres

Doug Reynolds

Localização de substrings correspondentes

O método search() retorna a posição do índice da primeira substring que corresponde a um determinado padrão, conforme mostrado neste exemplo: 

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

Também é possível usar expressões regulares para definir o padrão a ser correspondido, conforme mostrado no exemplo a seguir: 

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

A saída do método trace() é 0, porque o primeiro caractere na string é a posição 0 do índice. O sinalizador i é definido na expressão regular, portanto a pesquisa não faz distinção entre maiúsculas e minúsculas.

O método search() localiza apenas uma correspondência e retorna sua posição inicial no índice, mesmo que o sinalizador g (global) esteja definido na expressão regular.

O exemplo a seguir mostra uma expressão regular mais intrincada que corresponde a uma string entre aspas duplas: 

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

O método match() funciona de maneira semelhante. Ele pesquisa uma substring correspondente. No entanto quando você usa o sinalizador global em um padrão de expressão regular, como no exemplo a seguir, match() retorna uma matriz de substrings correspondentes: 

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

A matriz results é definida como o seguinte: 

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

Para obter mais informações sobre expressões regulares, consulte Uso de expressões regulares .

Substituição de substrings correspondentes

É possível usar o método replace() para pesquisar um padrão especificado em uma string e substituir correspondências pela string de substituição especificada, conforme mostrado no exemplo a seguir: 

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.

Observe que, neste exemplo, as strings correspondentes não fazem distinção entre maiúsculas e minúsculas porque o sinalizador i ( ignoreCase ) está definido na expressão regular, e várias correspondências são substituídas porque o sinalizador g ( global ) está definido. Para obter mais informações, consulte Uso de expressões regulares .

É possível incluir os seguintes códigos de substituição $ na string de substituição. O texto de substituição mostrado na tabela a seguir é inserido no lugar do código de substituição $ :

$ Code

Texto de substituição

$$

$

$&

A substring correspondida.

$`

A parte da string que precede a substring correspondida. Esse código usa o caractere aspas simples retas esquerdas ( ` ), não aspas simples retas ( ' ) ou aspas simples inglesas esquerdas ( ' ).

$'

A parte da string que segue a substring correspondida. Esse código usa as aspas simples retas ( ' ).

$ n

A n ª correspondência de grupo entre parênteses capturado, em que n é um único dígito, 1 a 9, e $n não é seguido por um dígito decimal.

$ nn

A nn ª correspondência de grupo entre parênteses capturado, em que nn é um número decimal de dois dígitos (01 a 99). Se a nn ª captura estiver indefinida, o texto de substituição será uma string vazia.

Por exemplo, veja a seguir o uso dos códigos de substituição $2 e $1 que representam o primeiro e o segundo grupos de captura correspondidos: 

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

Também é possível usar uma função como o segundo parâmetro do método replace() . O texto correspondente é substituído pelo valor retornado da função. 

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

Ao usar uma função como o segundo parâmetro do método replace() , os seguintes argumentos são passados para a função:

  • A parte correspondente da string.

  • Quaisquer correspondências de grupos entre parênteses capturadas. O número de argumentos transmitidos dessa maneira irá variar dependendo do número de correspondências parentéticas. É possível determinar o número de correspondências entre parênteses verificando arguments.length - 3 no código da função.

  • A posição de índice na string em que a correspondência começa.

  • A string completa.