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 a plataforma Adobe Flash.

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.

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.