| Pacote | Nível superior |
| Classe | public dynamic class Array |
| Herança | Array  Object |
| Versão da linguagem: | ActionScript 3.0 |
| Versões de runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
[0], o segundo é [1] e assim por diante. Para criar um objeto Array, use o construtor new Array(). Array() também pode ser chamado como uma função. Além disso, você pode usar o operador de acesso à matriz ([]) para inicializar uma matriz ou acessar os elementos de uma matriz.
É possível armazenar uma ampla variedade de tipos de dados em um elemento de matriz, incluindo números, strings, objetos e até mesmo outras matrizes. Você pode criar uma matriz multidimensional criando uma matriz indexada e atribuindo a cada um dos seus elementos uma matriz indexada diferente. Essa matriz é considerada multidimensional porque pode ser usada para representar dados em uma tabela.
Matrizes são sparse arrays; ou seja, pode haver um elemento no índice 0 e outro no índice 5, mas nada nas posições de índice entre esses dois elementos. Nesse caso, os elementos nas posições de 1 a 4 são indefinidos, o que indica a ausência de um elemento e não necessariamente a presença de um elemento com o valor undefined.
A atribuição de matriz é feita por referência em vez de por valor. Quando você atribui uma variável de matriz a outra variável de matriz, ambas fazem referência à mesma matriz:
var oneArray:Array = new Array("a", "b", "c");
var twoArray:Array = oneArray; // Both array variables refer to the same array.
twoArray[0] = "z";
trace(oneArray); // Output: z,b,c.
Não use a classe Array para criar associative arrays (também chamadas de hashes), que são estruturas de dados contendo elementos nomeados em vezes de elementos numerados. Para criar matrizes associativas, use a classe Object. Embora ActionScript permita criar matrizes associativas usando a classe Array, você não pode usar nenhum dos métodos ou propriedades da classe Array com matrizes associativas.
É possível estender a classe Array e substituir ou adicionar métodos. Entretanto, você precisa especificar a subclasse como dynamic, ou perderá a capacidade de armazenar dados em uma matriz.
Elementos da API relacionados
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 | |
| length : uint
Um inteiro não negativo que especifica o número de elementos na matriz. | Array | ||
| Método | Definido por | ||
|---|---|---|---|
Permite criar uma matriz que contenha os elementos especificados. | Array | ||
Permite criar uma matriz do número especificado de elementos. | Array | ||
Concatena os elementos especificados nos parâmetros com os elementos em uma matriz e cria uma nova matriz. | Array | ||
Executa uma função de teste em cada item da matriz até que seja alcançado um item que retorne "false" para a função especificada. | Array | ||
Executa uma função de teste em cada item da matriz e constrói uma nova matriz para todos os itens que retornarem "true" para a função especificada. | Array | ||
Executa uma função em cada item da matriz. | Array | ||
|
Indica se um objeto tem uma propriedade especificada definida. | Object | |
Procura um item em uma matriz, usando a igualdade estrita (===), e retorna a posição de índice do item. | Array | ||
Inserir um único elemento em uma matriz. | Array | ||
|
Indica se uma ocorrência da classe Object está na cadeia de protótipos do objeto especificado como o parâmetro. | Object | |
Converte em strings os elementos de uma matriz, insere o separador especificado entre os elementos, faz a sua concatenação e retorna a string resultante. | Array | ||
Procura um item em uma matriz, operando para trás a partir do último item, e retorna a posição do índice do item correspondente usando a igualdade estrita (===). | Array | ||
Executa uma função em cada item de uma matriz e constrói uma nova matriz de itens correspondentes aos resultados da função em cada item na matriz original. | Array | ||
Remove o último elemento de uma matriz e retorna o valor desse elemento. | Array | ||
|
Indica se a propriedade especificada existe e é enumerável. | Object | |
Adiciona um ou mais elementos ao final de uma matriz e retorna o novo comprimento dessa matriz. | Array | ||
Remover um único elemento de uma matriz. | Array | ||
Inverte a matriz no lugar. | Array | ||
|
Define a disponibilidade de uma propriedade dinâmica para operações de repetição. | Object | |
Remove o primeiro elemento de uma matriz e retorna esse elemento. | Array | ||
Retorna uma nova matriz que consiste em uma faixa de elementos a partir da matriz original, sem modificar a matriz original. | Array | ||
Executa uma função de teste em cada item da matriz até que seja alcançado um item que retorne "true". | Array | ||
Classifica os elementos em uma matriz. | Array | ||
Classifica os elementos em uma matriz de acordo com um ou mais campos nessa matriz. | Array | ||
Adiciona ou remove elementos de uma matriz. | Array | ||
Retorna uma string que representa os elementos na matriz especificada. | Array | ||
Retorna uma string que representa os elementos na matriz especificada. | Array | ||
Adiciona um ou mais elementos ao início de uma matriz e retorna o novo comprimento dessa matriz. | Array | ||
|
Retorna o valor primitivo do objeto especificado. | Object | |
| Constante | Definido por | ||
|---|---|---|---|
| CASEINSENSITIVE : uint = 1 [estático]
Especifica a classificação sem distinção entre maiúsculas e minúsculas para os métodos de classificação da classe Array. | Array | ||
| DESCENDING : uint = 2 [estático]
Especifica a classificação decrescente para os métodos de classificação da classe Array. | Array | ||
| NUMERIC : uint = 16 [estático]
Especifica a classificação numérica (em vez de string de caracteres) para os métodos de classificação da classe Array. | Array | ||
| RETURNINDEXEDARRAY : uint = 8 [estático]
Especifica que uma classificação retorna uma matriz que consiste em índices de matriz. | Array | ||
| UNIQUESORT : uint = 4 [estático]
Especifica a exigência de classificação exclusiva para os métodos de classificação da classe Array. | Array | ||
length | propriedade |
length:uint| Versão da linguagem: | ActionScript 3.0 |
| Versões de runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Um inteiro não negativo que especifica o número de elementos na matriz. Essa propriedade é automaticamente atualizada quando novos elementos são adicionados à matriz. Quando você atribui um valor a um elemento de matriz (por exemplo, my_array[index] = value), se index for um número e index+1 for maior do que a propriedade length, essa propriedade length será atualizada para index+1.
Nota: se você atribuir um valor à propriedade length que seja menor do que o comprimento existente, a matriz será truncada.
Implementação
public function get length():uint public function set length(value:uint):voidExemplo ( Como usar este exemplo )
names com o elemento de string Bill. Em seguida, ele usa o método push() para adicionar outro elemento de string Kyle. O comprimento da matriz, determinado pela propriedade length, era de um elemento antes do uso de push() e é de dois elementos após a chamada de push(). Outra string, Jeff, é adicionada para que o comprimento de names seja de três elementos. O método shift() é então chamado duas vezes para remover Bill e Kyle, fazendo com que a matriz final de length seja um.
var names:Array = new Array("Bill");
names.push("Kyle");
trace(names.length); // 2
names.push("Jeff");
trace(names.length); // 3
names.shift();
names.shift();
trace(names.length); // 1
Array | () | Construtor |
public function Array(... values)| Versão da linguagem: | ActionScript 3.0 |
| Versões de runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Permite criar uma matriz que contenha os elementos especificados. Você pode especificar valores de qualquer tipo. O primeiro elemento de uma matriz sempre tem um índice (ou posição) de 0.
Nota: esta classe mostra duas entradas de construtor, uma vez que o construtor aceita tipos variáveis de argumentos. O construtor se comporta de forma diferente dependendo do tipo e do número de argumentos transmitidos, conforme detalhado em cada entrada. O ActionScript 3.0 não oferece suporte à sobrecarga de métodos ou construtores.
Parâmetros... values — Uma lista separada por vírgulas de um ou mais valores arbitrários.
Nota: se apenas um parâmetro numérico for transmitido ao construtor de Array, ficará suposto que ele especificará a propriedade |
Lança
RangeError — O argumento é um número que não é um inteiro maior do que ou igual a 0.
|
Elementos da API relacionados
Exemplo ( Como usar este exemplo )
one, two e three e então converte os elementos em uma string.
package {
import flash.display.Sprite;
public class Array_Array_3 extends Sprite {
public function Array_Array_3() {
var myArr:Array = new Array("one", "two", "three");
trace(myArr.length); // 3
trace(myArr); // one,two,three
}
}
}
Array | () | Construtor |
public function Array(numElements:int = 0)| Versão da linguagem: | ActionScript 3.0 |
| Versões de runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Permite criar uma matriz do número especificado de elementos. Se você não especificar parâmetros, será criada uma matriz contendo 0 elementos. Se você especificar um número de elementos, será criada uma matriz com o número de elementos de numElements.
Nota: esta classe mostra duas entradas de método de construtor, uma vez que o construtor aceita tipos variáveis de argumentos. O construtor se comporta de forma diferente dependendo do tipo e do número de argumentos transmitidos, conforme detalhado em cada entrada. O ActionScript 3.0 não oferece suporte à sobrecarga de métodos ou construtores.
ParâmetrosnumElements:int (default = 0) |
Lança
RangeError — O argumento é um número que não é um inteiro maior do que ou igual a 0.
|
Elementos da API relacionados
Exemplo ( Como usar este exemplo )
myArr sem argumentos e com um comprimento inicial de 0:
package {
import flash.display.Sprite;
public class Array_Array extends Sprite {
public function Array_Array() {
var myArr:Array = new Array();
trace(myArr.length); // 0
}
}
}
"one" e adiciona o elemento de string "six" ao final da matriz usando o método push():
package {
import flash.display.Sprite;
public class Array_Array_2 extends Sprite {
public function Array_Array_2() {
var myArr:Array = new Array(5);
trace(myArr.length); // 5
myArr[0] = "one";
myArr.push("six");
trace(myArr); // one,,,,,six
trace(myArr.length); // 6
}
}
}
concat | () | método |
AS3 function concat(... args):Array| Versão da linguagem: | ActionScript 3.0 |
| Versões de runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Concatena os elementos especificados nos parâmetros com os elementos em uma matriz e cria uma nova matriz. Se os parâmetros especificarem uma matriz, os elementos dessa matriz serão concatenados. Se você não transmitir nenhum parâmetro, a nova matriz será uma duplicata (clone superficial) da matriz original.
Parâmetros
... args — Um valor de qualquer tipo de dados (como números, elementos ou strings) a ser concatenado em uma nova matriz.
|
Array — Uma matriz que contém os elementos dessa matriz seguidos dos elementos dos parâmetros.
|
Exemplo ( Como usar este exemplo )
- A matriz
numbers, que contém os números1,2e3. - A matriz
letters, que contém as letrasa,bec. - A matriz
numbersAndLetters, que chama o métodoconcat()a fim de gerar a matriz[1,2,3,a,b,c]. - A matriz
lettersAndNumbers, que chama o métodoconcat()a fim de gerar a matriz[a,b,c,1,2,3].
var numbers:Array = new Array(1, 2, 3);
var letters:Array = new Array("a", "b", "c");
var numbersAndLetters:Array = numbers.concat(letters);
var lettersAndNumbers:Array = letters.concat(numbers);
trace(numbers); // 1,2,3
trace(letters); // a,b,c
trace(numbersAndLetters); // 1,2,3,a,b,c
trace(lettersAndNumbers); // a,b,c,1,2,3
every | () | método |
AS3 function every(callback:Function, thisObject:* = null):Boolean| Versão da linguagem: | ActionScript 3.0 |
| Versões de runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Executa uma função de teste em cada item da matriz até que seja alcançado um item que retorne false para a função especificada. Use este método para determinar se todos os itens de uma matriz atendem a um critério, como ter valores menores do que um certo número.
Para esse método, o segundo parâmetro, thisObject, deverá ser null se o primeiro parâmetro, callback, for um fechamento de método. Suponha que você crie uma função em um clipe de vídeo denominada me:
function myFunction(obj:Object):void {
//your code here
}
Em seguida, suponha que você use o método every() em uma matriz denominada myArray:
myArray.every(myFunction, me);
Como myFunction é um membro da classe Timeline, que não pode ser substituída por me, o tempo de execução do Flash lançará uma exceção. Esse erro de tempo de execução pode ser evitado atribuindo a função a uma variável, desta forma:
var myFunction:Function = function(obj:Object):void {
//your code here
};
myArray.every(myFunction, me);
Parâmetros
callback:Function — A função a ser executada em cada item da matriz. Esta função pode obter uma comparação simples (por exemplo, item < 20) ou uma operação mais complexa e é chamada com três argumentos; o valor de um item, o índice de um item e o objeto Array:
function callback(item:*, index:int, array:Array):Boolean; | |
thisObject:* (default = null)this para a função.
|
Boolean — Um valor booliano de true se todos os itens da matriz retornarem true para a função especificada; caso contrário, false.
|
Elementos da API relacionados
Exemplo ( Como usar este exemplo )
isNumeric é true para a primeira matriz e false para a segunda:
package {
import flash.display.Sprite;
public class Array_every extends Sprite {
public function Array_every() {
var arr1:Array = new Array(1, 2, 4);
var res1:Boolean = arr1.every(isNumeric);
trace("isNumeric:", res1); // true
var arr2:Array = new Array(1, 2, "ham");
var res2:Boolean = arr2.every(isNumeric);
trace("isNumeric:", res2); // false
}
private function isNumeric(element:*, index:int, arr:Array):Boolean {
return (element is Number);
}
}
}
filter | () | método |
AS3 function filter(callback:Function, thisObject:* = null):Array| Versão da linguagem: | ActionScript 3.0 |
| Versões de runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Executa uma função de teste em cada item da matriz e constrói uma nova matriz para todos os itens que retornarem true para a função especificada. Se um item retornar false, ele não será incluso na nova matriz.
Para esse método, o segundo parâmetro, thisObject, deverá ser null se o primeiro parâmetro, callback, for um fechamento de método. Suponha que você crie uma função em um clipe de vídeo denominada me:
function myFunction(obj:Object):void {
//your code here
}
Em seguida, suponha que você use o método filter() em uma matriz denominada myArray:
myArray.filter(myFunction, me);
Como myFunction é um membro da classe Timeline, que não pode ser substituída por me, o tempo de execução do Flash lançará uma exceção. Esse erro de tempo de execução pode ser evitado atribuindo a função a uma variável, desta forma:
var myFunction:Function = function(obj:Object):void {
//your code here
};
myArray.filter(myFunction, me);
Parâmetros
callback:Function — A função a ser executada em cada item da matriz. Esta função pode obter uma comparação simples (por exemplo, item < 20) ou uma operação mais complexa e é chamada com três argumentos; o valor de um item, o índice de um item e o objeto Array:
function callback(item:*, index:int, array:Array):Boolean; | |
thisObject:* (default = null)this para a função.
|
Array — Uma nova matriz que contém todos os itens da matriz original que retornaram true.
|
Elementos da API relacionados
Exemplo ( Como usar este exemplo )
package {
import flash.display.Sprite;
public class Array_filter extends Sprite {
public function Array_filter() {
var employees:Array = new Array();
employees.push({name:"Employee 1", manager:false});
employees.push({name:"Employee 2", manager:true});
employees.push({name:"Employee 3", manager:false});
trace("Employees:");
employees.forEach(traceEmployee);
var managers:Array = employees.filter(isManager);
trace("Managers:");
managers.forEach(traceEmployee);
}
private function isManager(element:*, index:int, arr:Array):Boolean {
return (element.manager == true);
}
private function traceEmployee(element:*, index:int, arr:Array):void {
trace("\t" + element.name + ((element.manager) ? " (manager)" : ""));
}
}
}
forEach | () | método |
AS3 function forEach(callback:Function, thisObject:* = null):void| Versão da linguagem: | ActionScript 3.0 |
| Versões de runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Executa uma função em cada item da matriz.
Para esse método, o segundo parâmetro, thisObject, deverá ser null se o primeiro parâmetro, callback, for um fechamento de método. Suponha que você crie uma função em um clipe de vídeo denominada me:
function myFunction(obj:Object):void {
//your code here
}
Em seguida, suponha que você use o método forEach() em uma matriz denominada myArray:
myArray.forEach(myFunction, me);
Como myFunction é um membro da classe Timeline, que não pode ser substituída por me, o tempo de execução do Flash lançará uma exceção. Esse erro de tempo de execução pode ser evitado atribuindo a função a uma variável, desta forma:
var myFunction:Function = function(obj:Object):void {
//your code here
};
myArray.forEach(myFunction, me);
Parâmetros
callback:Function — A função a ser executada em cada item da matriz. Esta função pode obter um comando simples (por exemplo, uma instrução trace()) ou uma operação mais complexa e é chamada com três argumentos; o valor de um item, o índice de um item e o objeto Array:
function callback(item:*, index:int, array:Array):void; | |
thisObject:* (default = null)this para a função.
|
Exemplo ( Como usar este exemplo )
trace() na função traceEmployee() em cada item da matriz:
package {
import flash.display.Sprite;
public class Array_forEach extends Sprite {
public function Array_forEach() {
var employees:Array = new Array();
employees.push({name:"Employee 1", manager:false});
employees.push({name:"Employee 2", manager:true});
employees.push({name:"Employee 3", manager:false});
trace(employees);
employees.forEach(traceEmployee);
}
private function traceEmployee(element:*, index:int, arr:Array):void {
trace(element.name + " (" + element.manager + ")");
}
}
}
trace() em uma função traceEmployee() um pouco modificada em cada item da matriz:
package {
import flash.display.Sprite;
public class Array_forEach_2 extends Sprite {
public function Array_forEach_2() {
var employeeXML:XML = <employees>
<employee name="Steven" manager="false" />
<employee name="Bruce" manager="true" />
<employee name="Rob" manager="false" />
</employees>;
var employeesList:XMLList = employeeXML.employee;
var employeesArray:Array = new Array();
for each (var tempXML:XML in employeesList) {
employeesArray.push(tempXML);
}
employeesArray.sortOn("@name");
employeesArray.forEach(traceEmployee);
}
private function traceEmployee(element:*, index:Number, arr:Array):void {
trace(element.@name + ((element.@manager == "true") ? " (manager)" : ""));
}
}
}
indexOf | () | método |
AS3 function indexOf(searchElement:*, fromIndex:int = 0):int| Versão da linguagem: | ActionScript 3.0 |
| Versões de runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Procura um item em uma matriz, usando a igualdade estrita (===), e retorna a posição de índice do item.
Parâmetros
searchElement:* — O item a ser localizado na matriz.
| |
fromIndex:int (default = 0) |
int — Uma posição de índice com base em zero do item na matriz. Se o argumento searchElement não for encontrado, o valor de retorno será -1.
|
Elementos da API relacionados
Exemplo ( Como usar este exemplo )
package {
import flash.display.Sprite;
public class Array_indexOf extends Sprite {
public function Array_indexOf() {
var arr:Array = new Array(123,45,6789);
arr.push("123-45-6789");
arr.push("987-65-4321");
var index:int = arr.indexOf("123");
trace(index); // -1
var index2:int = arr.indexOf(123);
trace(index2); // 0
}
}
}
insertAt | () | método |
AS3 function insertAt(index:int, element:*):void| Versão da linguagem: | ActionScript 3.0 |
| Versões de runtime: | Flash Player 19, AIR 19 |
Inserir um único elemento em uma matriz. Este método modifica a matriz sem fazer uma cópia.
Parâmetros
index:int — Um número inteiro que especifica a posição, na matriz, onde o elemento deve ser inserido. Você pode usar um inteiro negativo para especificar uma posição relativa ao fim da matriz (por exemplo, -1 é o último elemento da matriz).
| |
element:* |
join | () | método |
AS3 function join(sep:*):String| Versão da linguagem: | ActionScript 3.0 |
| Versões de runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Converte em strings os elementos de uma matriz, insere o separador especificado entre os elementos, faz a sua concatenação e retorna a string resultante. Uma matriz aninhada é sempre separada por uma vírgula (,) e não pelo separador transmitido ao método join().
Parâmetros
sep:* (default = NaN) |
String — Uma string que consiste nos elementos de uma matriz convertidos em strings e separados pelo parâmetro especificado.
|
Elementos da API relacionados
Exemplo ( Como usar este exemplo )
myArr com os elementos one, two e three e uma string contendo one and two and three usando o método join().
var myArr:Array = new Array("one", "two", "three");
var myStr:String = myArr.join(" and ");
trace(myArr); // one,two,three
trace(myStr); // one and two and three
specialChars com os elementos (, ), - e um espaço em branco e, em seguida, cria uma string contendo (888) 867-5309. Em seguida, usando uma repetição for, ele remove cada tipo de caractere especial listado em specialChars de forma a gerar uma string (myStr) que contenha apenas os dígitos do número de telefone restante: 888675309. Observe que outros caracteres, como +, poderiam ter sido adicionados a specialChars e essa rotina funcionaria com formatos de número de telefone internacionais.
var phoneString:String = "(888) 867-5309";
var specialChars:Array = new Array("(", ")", "-", " ");
var myStr:String = phoneString;
var ln:uint = specialChars.length;
for(var i:uint; i < ln; i++) {
myStr = myStr.split(specialChars[i]).join("");
}
var phoneNumber:Number = new Number(myStr);
trace(phoneString); // (888) 867-5309
trace(phoneNumber); // 8888675309
lastIndexOf | () | método |
AS3 function lastIndexOf(searchElement:*, fromIndex:int = 0x7fffffff):int| Versão da linguagem: | ActionScript 3.0 |
| Versões de runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Procura um item em uma matriz, operando para trás a partir do último item, e retorna a posição do índice do item correspondente usando a igualdade estrita (===).
Parâmetros
searchElement:* — O item a ser localizado na matriz.
| |
fromIndex:int (default = 0x7fffffff)fromIndex, a pesquisa começará no último item da matriz.
|
int — Uma posição de índice com base em zero do item na matriz. Se o argumento searchElement não for encontrado, o valor de retorno será -1.
|
Elementos da API relacionados
Exemplo ( Como usar este exemplo )
package {
import flash.display.Sprite;
public class Array_lastIndexOf extends Sprite {
public function Array_lastIndexOf() {
var arr:Array = new Array(123,45,6789,123,984,323,123,32);
var index:int = arr.indexOf(123);
trace(index); // 0
var index2:int = arr.lastIndexOf(123);
trace(index2); // 6
}
}
}
map | () | método |
AS3 function map(callback:Function, thisObject:* = null):Array| Versão da linguagem: | ActionScript 3.0 |
| Versões de runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Executa uma função em cada item de uma matriz e constrói uma nova matriz de itens correspondentes aos resultados da função em cada item na matriz original.
Para esse método, o segundo parâmetro, thisObject, deverá ser null se o primeiro parâmetro, callback, for um fechamento de método. Suponha que você crie uma função em um clipe de vídeo denominada me:
function myFunction(obj:Object):void {
//your code here
}
Em seguida, suponha que você use o método map() em uma matriz denominada myArray:
myArray.map(myFunction, me);
Como myFunction é um membro da classe Timeline, que não pode ser substituída por me, o tempo de execução do Flash lançará uma exceção. Esse erro de tempo de execução pode ser evitado atribuindo a função a uma variável, desta forma:
var myFunction:Function = function(obj:Object):void {
//your code here
};
myArray.map(myFunction, me);
Parâmetros
callback:Function — A função a ser executada em cada item da matriz. Esta função pode obter um comando simples (por exemplo, alterar a formatação de maiúsculas e minúsculas de uma matriz de strings) ou uma operação mais complexa, e é chamada com três argumentos; o valor de um item, o índice de um item e o objeto Array:
function callback(item:*, index:int, array:Array):String; | |
thisObject:* (default = null)this para a função.
|
Array — Uma nova matriz que contém os resultados da função em cada item na matriz original.
|
Elementos da API relacionados
Exemplo ( Como usar este exemplo )
package {
import flash.display.Sprite;
public class Array_map extends Sprite {
public function Array_map() {
var arr:Array = new Array("one", "two", "Three");
trace(arr); // one,two,Three
var upperArr:Array = arr.map(toUpper);
trace(upperArr); // ONE,TWO,THREE
}
private function toUpper(element:*, index:int, arr:Array):String {
return String(element).toUpperCase();
}
}
}
pop | () | método |
AS3 function pop():*| Versão da linguagem: | ActionScript 3.0 |
| Versões de runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Remove o último elemento de uma matriz e retorna o valor desse elemento.
Retorna* — O valor do último elemento (de qualquer tipo de dados) na matriz especificada.
|
Elementos da API relacionados
Exemplo ( Como usar este exemplo )
letters com os elementos a, b e c. O último elemento (c) é então removido da matriz usando o método pop() e á atribuído ao objeto de String letter.
var letters:Array = new Array("a", "b", "c");
trace(letters); // a,b,c
var letter:String = letters.pop();
trace(letters); // a,b
trace(letter); // c
push | () | método |
AS3 function push(... args):uint| Versão da linguagem: | ActionScript 3.0 |
| Versões de runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Adiciona um ou mais elementos ao final de uma matriz e retorna o novo comprimento dessa matriz.
Parâmetros
... args — Um ou mais valores a serem acrescentados à matriz.
|
uint — Um inteiro representando o comprimento da nova matriz.
|
Elementos da API relacionados
Exemplo ( Como usar este exemplo )
letters vazio e preenche a matriz com os elementos a, b e c usando o método push().
var letters:Array = new Array();
letters.push("a");
letters.push("b");
letters.push("c");
trace(letters.toString()); // a,b,c
letters, que é inicialmente preenchido com o elemento a. O método push() é então usado uma vez para adicionar os elementos b e c ao final da matriz, que consiste em três elementos após a expansão.
var letters:Array = new Array("a");
var count:uint = letters.push("b", "c");
trace(letters); // a,b,c
trace(count); // 3
removeAt | () | método |
AS3 function removeAt(index:int):*| Versão da linguagem: | ActionScript 3.0 |
| Versões de runtime: | Flash Player 19, AIR 19 |
Remover um único elemento de uma matriz. Este método modifica a matriz sem fazer uma cópia.
Parâmetros
index:int — Um número inteiro que especifica o índice do elemento na matriz, que será excluído. Você pode usar um inteiro negativo para especificar uma posição relativa ao fim da matriz (por exemplo, -1 é o último elemento da matriz).
|
* — O elemento que foi removido da matriz original.
|
reverse | () | método |
AS3 function reverse():Array| Versão da linguagem: | ActionScript 3.0 |
| Versões de runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Inverte a matriz no lugar.
RetornaArray — A nova matriz.
|
Exemplo ( Como usar este exemplo )
letters com os elementos a, b e c. A ordem dos elementos da matriz é então invertida usando o método reverse() para gerar a matriz [c,b,a].
var letters:Array = new Array("a", "b", "c");
trace(letters); // a,b,c
letters.reverse();
trace(letters); // c,b,a
shift | () | método |
AS3 function shift():*| Versão da linguagem: | ActionScript 3.0 |
| Versões de runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Remove o primeiro elemento de uma matriz e retorna esse elemento. Os elementos restantes da matriz são movidos da posição original, i, a i-1.
Retorna* — O primeiro elemento (de qualquer tipo de dados) em uma matriz.
|
Elementos da API relacionados
Exemplo ( Como usar este exemplo )
letters com os elementos a, b e c. O método shift() é então usado para remover o primeiro elemento (a) de letters e atribuí-lo à string firstLetter.
var letters:Array = new Array("a", "b", "c");
var firstLetter:String = letters.shift();
trace(letters); // b,c
trace(firstLetter); // a
slice | () | método |
AS3 function slice(startIndex:int = 0, endIndex:int = 16777215):Array| Versão da linguagem: | ActionScript 3.0 |
| Versões de runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Retorna uma nova matriz que consiste em uma faixa de elementos a partir da matriz original, sem modificar a matriz original. A matriz retornada inclui o elemento startIndex e todos os elementos até, mas sem incluir, o elemento endIndex.
Se você não transmitir nenhum parâmetro, a nova matriz será uma duplicata (clone superficial) da matriz original.
Parâmetros
startIndex:int (default = 0)startIndex for um número negativo, o índice de início começará no final da matriz, em que -1 é o último elemento.
| |
endIndex:int (default = 16777215)endIndex for um número negativo, o ponto de término será especificado a partir do final da matriz, em que -1 é o último elemento.
|
Array — Uma matriz que consiste em uma faixa de elementos a partir da matriz original.
|
Exemplo ( Como usar este exemplo )
letters com os elementos [a,b,c,d,e,f]. A matriz someLetters é então criada chamando-se o método slice() nos elementos de um (b) a três (d), resultando em uma matriz com os elementos b e c.
var letters:Array = new Array("a", "b", "c", "d", "e", "f");
var someLetters:Array = letters.slice(1,3);
trace(letters); // a,b,c,d,e,f
trace(someLetters); // b,c
letters com os elementos [a,b,c,d,e,f]. A matriz someLetters é então criada chamando-se o método slice() no elemento dois (c), resultando em uma matriz com os elementos [c,d,e,f].
var letters:Array = new Array("a", "b", "c", "d", "e", "f");
var someLetters:Array = letters.slice(2);
trace(letters); // a,b,c,d,e,f
trace(someLetters); // c,d,e,f
letters com os elementos [a,b,c,d,e,f]. A matriz someLetters é então criada chamando-se o método slice() no segundo ao último elemento a partir do fim (e), resultando em uma matriz com os elementos e e f.
var letters:Array = new Array("a", "b", "c", "d", "e", "f");
var someLetters:Array = letters.slice(-2);
trace(letters); // a,b,c,d,e,f
trace(someLetters); // e,f
some | () | método |
AS3 function some(callback:Function, thisObject:* = null):Boolean| Versão da linguagem: | ActionScript 3.0 |
| Versões de runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Executa uma função de teste em cada item da matriz até que seja alcançado um item que retorne true. Use este método para determinar se todos os itens de uma matriz atendem a um critério, como ter um valor menor do que um certo número.
Para esse método, o segundo parâmetro, thisObject, deverá ser null se o primeiro parâmetro, callback, for um fechamento de método. Suponha que você crie uma função em um clipe de vídeo denominada me:
function myFunction(obj:Object):void {
//your code here
}
Em seguida, suponha que você use o método some() em uma matriz denominada myArray:
myArray.some(myFunction, me);
Como myFunction é um membro da classe Timeline, que não pode ser substituída por me, o tempo de execução do Flash lançará uma exceção. Esse erro de tempo de execução pode ser evitado atribuindo a função a uma variável, desta forma:
var myFunction:Function = function(obj:Object):void {
//your code here
};
myArray.some(myFunction, me);
Parâmetros
callback:Function — A função a ser executada em cada item da matriz. Essa função pode obter uma comparação simples (por exemplo, item < 20) ou uma operação mais complexa e é chamada com três argumentos; o valor de um item, o índice de um item e o objeto Array:
function callback(item:*, index:int, array:Array):Boolean; | |
thisObject:* (default = null)this para a função.
|
Boolean — Um valor booliano de true se todos os itens da matriz retornarem true para a função especificada; caso contrário, false.
|
Elementos da API relacionados
Exemplo ( Como usar este exemplo )
package {
import flash.display.Sprite;
public class Array_some extends Sprite {
public function Array_some() {
var arr:Array = new Array();
arr[0] = "one";
arr[1] = "two";
arr[3] = "four";
var isUndef:Boolean = arr.some(isUndefined);
if (isUndef) {
trace("array contains undefined values: " + arr);
} else {
trace("array contains no undefined values.");
}
}
private function isUndefined(element:*, index:int, arr:Array):Boolean {
return (element == undefined);
}
}
}
sort | () | método |
AS3 function sort(... args):Array| Versão da linguagem: | ActionScript 3.0 |
| Versões de runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Classifica os elementos em uma matriz. Esse método classifica de acordo com valores Unicode. (ASCII é um subconjunto de Unicode.)
Por padrão, Array.sort() funciona da seguinte maneira:
- A classificação faz distinção entre maiúsculas e minúsculas (Z precede a).
- A classificação é ascendente (a precede b).
- A matriz é modificada para refletir a ordem de classificação; vários elementos que têm campos de classificação idênticos são inseridos consecutivamente na matriz classificada, sem nenhuma ordem em particular.
- Todos os elementos, independentemente do tipo de dados, são classificados como se fossem strings. Sendo assim, 100 precede 99, já que "1" é um valor de string menor do que "9".
Para classificar uma matriz usando configurações diferentes das configurações padrão, você pode usar uma das opções de classificação descritas na parte sortOptions da descrição do parâmetro ...args ou pode criar a sua própria função personalizada para fazer a classificação. Se você criar uma função personalizada, chame o método sort() e use o nome da sua função personalizada como primeiro argumento (compareFunction)
Parâmetros
... args — Os argumentos que especificam uma função de comparação e um ou mais valores que determinam o comportamento da classificação.
Esse método usa a ordem de sintaxe e argumentos
|
Array — O valor de retorno depende do fato de você transmitir ou não argumentos, conforme descrito na lista a seguir:
|
Elementos da API relacionados
Exemplo ( Como usar este exemplo )
vegetables com os elementos [spinach, green pepper, cilantro, onion, avocado] A matriz é então classificada pelo método sort(), que é chamado sem parâmetros. O resultado é que a matriz de vegetables é classificada em ordem alfabética ([avocado, cilantro, green pepper, onion, spinach]).
var vegetables:Array = new Array("spinach",
"green pepper",
"cilantro",
"onion",
"avocado");
trace(vegetables); // spinach,green pepper,cilantro,onion,avocado
vegetables.sort();
trace(vegetables); // avocado,cilantro,green pepper,onion,spinach
vegetables com os elementos [spinach, green pepper, Cilantro, Onion, and Avocado] A matriz é então classificada pelo método sort(), que é chamado sem parâmetros da primeira vez. O resultado é [Avocado,Cilantro,Onion,green pepper,spinach]. Em seguida, sort() é chamado em vegetables novamente com a constante CASEINSENSITIVE como parâmetro. O resultado é que a matriz de vegetables é classificada em ordem alfabética ([avocado, cilantro, green pepper, onion, spinach]).
var vegetables:Array = new Array("spinach",
"green pepper",
"Cilantro",
"Onion",
"Avocado");
vegetables.sort();
trace(vegetables); // Avocado,Cilantro,Onion,green pepper,spinach
vegetables.sort(Array.CASEINSENSITIVE);
trace(vegetables); // Avocado,Cilantro,green pepper,Onion,spinach
vegetables, que é preenchido ao longo de cinco chamadas a push() Sempre que push() é chamado, um novo objeto Vegetable é criado por uma chamada ao construtor Vegetable(), que aceita um objeto String (name) e Number (price). Chamar push() cinco vezes com os valores mostrados resulta na seguinte matriz: [lettuce:1.49, spinach:1.89, asparagus:3.99, celery:1.29, squash:1.44]. O método push() é então usado para classificar a matriz, resultando na matriz [asparagus:3.99, celery:1.29, lettuce:1.49, spinach:1.89, squash:1.44].
var vegetables:Array = new Array();
vegetables.push(new Vegetable("lettuce", 1.49));
vegetables.push(new Vegetable("spinach", 1.89));
vegetables.push(new Vegetable("asparagus", 3.99));
vegetables.push(new Vegetable("celery", 1.29));
vegetables.push(new Vegetable("squash", 1.44));
trace(vegetables);
// lettuce:1.49, spinach:1.89, asparagus:3.99, celery:1.29, squash:1.44
vegetables.sort();
trace(vegetables);
// asparagus:3.99, celery:1.29, lettuce:1.49, spinach:1.89, squash:1.44
//The following code defines the Vegetable class
class Vegetable {
private var name:String;
private var price:Number;
public function Vegetable(name:String, price:Number) {
this.name = name;
this.price = price;
}
public function toString():String {
return " " + name + ":" + price;
}
}
sort() é usado com uma função de classificação personalizada (sortOnPrice), que classifica de acordo com o preço em vez de alfabeticamente. Observe que a nova função getPrice() extrai o preço.
var vegetables:Array = new Array();
vegetables.push(new Vegetable("lettuce", 1.49));
vegetables.push(new Vegetable("spinach", 1.89));
vegetables.push(new Vegetable("asparagus", 3.99));
vegetables.push(new Vegetable("celery", 1.29));
vegetables.push(new Vegetable("squash", 1.44));
trace(vegetables);
// lettuce:1.49, spinach:1.89, asparagus:3.99, celery:1.29, squash:1.44
vegetables.sort(sortOnPrice);
trace(vegetables);
// celery:1.29, squash:1.44, lettuce:1.49, spinach:1.89, asparagus:3.99
function sortOnPrice(a:Vegetable, b:Vegetable):Number {
var aPrice:Number = a.getPrice();
var bPrice:Number = b.getPrice();
if(aPrice > bPrice) {
return 1;
} else if(aPrice < bPrice) {
return -1;
} else {
//aPrice == bPrice
return 0;
}
}
// The following code defines the Vegetable class and should be in a separate package.
class Vegetable {
private var name:String;
private var price:Number;
public function Vegetable(name:String, price:Number) {
this.name = name;
this.price = price;
}
public function getPrice():Number {
return price;
}
public function toString():String {
return " " + name + ":" + price;
}
}
números com os elementos [3,5,100,34,10]. Uma chamada a sort() sem parâmetros classifica alfabeticamente, produzindo o resultado indesejado [10,100,3,34,5]. Para classificar valores numéricos adequadamente, você deve transmitir a constante NUMERIC ao método sort(), que classifica numbers da seguinte maneira: [3,5,10,34,100].
Nota: o comportamento padrão da função sort() é manipular cada entidade como uma string. Se você usa o argumento Array.NUMERIC, o tempo de execução do Flash tenta converter qualquer valor não numérico para números inteiros para fins de classificação. Se isso falhar, o tempo de execução emite um erro. Por exemplo, o tempo de execução pode converter com sucesso o valor de uma String de "6" para um número inteiro, mas vai emitir um erro se encontrar o valor de String "six".
var numbers:Array = new Array(3,5,100,34,10); trace(numbers); // 3,5,100,34,10 numbers.sort(); trace(numbers); // 10,100,3,34,5 numbers.sort(Array.NUMERIC); trace(numbers); // 3,5,10,34,100
sortOn | () | método |
AS3 function sortOn(fieldName:Object, options:Object = null):Array| Versão da linguagem: | ActionScript 3.0 |
| Versões de runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Classifica os elementos em uma matriz de acordo com um ou mais campos nessa matriz. A matriz deve ter as seguintes características:
- A matriz é indexada e não associativa.
- Cada elemento da matriz contém um objeto com uma ou mais propriedades.
- Todos os objetos têm pelo menos uma propriedade em comum, cujos valores podem ser usados para classificar a matriz. Essa propriedade é chamada de field.
Se você transmitir vários parâmetros fieldName, o primeiro campo representará o campo de classificação principal, o segundo representará o próximo campo de classificação e assim por diante. O Flash classifica de acordo com valores Unicode. (ASCII é um subconjunto de Unicode.) Se um dos elementos que estiver sendo comparado não contiver o campo especificado no parâmetro fieldName, ficará pressuposto que esse campo deve ser definido como undefined e que os elementos devem ser inseridos consecutivamente na matriz classificada, sem nenhuma ordem em particular.
Por padrão, Array.sortOn() funciona da seguinte maneira:
- A classificação faz distinção entre maiúsculas e minúsculas (Z precede a).
- A classificação é ascendente (a precede b).
- A matriz é modificada para refletir a ordem de classificação; vários elementos que têm campos de classificação idênticos são inseridos consecutivamente na matriz classificada, sem nenhuma ordem em particular.
- Os campos numéricos são classificados como se fossem strings. Sendo assim, 100 precede 99, já que "1" é um valor de string menor do que "9".
O Flash Player 7 adicionou o parâmetro options, que você pode usar para substituir o comportamento de classificação padrão. Para classificar uma matriz simples (por exemplo, uma matriz com apenas um campo) ou para especificar uma ordem de classificação não suportada pelo parâmetro options, use Array.sort().
Para transmitir vários sinalizadores, separe-os com o operador OR bit a bit (|):
my_array.sortOn(someFieldName, Array.DESCENDING | Array.NUMERIC);
O Flash Player 8 adicionou a capacidade de especificar uma opção de classificação diferente para cada campo ao classificar de acordo com mais de um campo. No Flash Player 8 e superior, o parâmetro options aceita uma matriz de opções de classificação, de forma que cada opção de classificação corresponda a um campo de classificação no parâmetro fieldName. O exemplo a seguir classifica o campo de classificação primário, a, usando uma classificação decrescente; o segundo campo de classificação, b, usando uma classificação numérica e o campo de classificação terciário, c, usando uma classificação sem distinção entre maiúsculas e minúsculas:
Array.sortOn (["a", "b", "c"], [Array.DESCENDING, Array.NUMERIC, Array.CASEINSENSITIVE]);
Nota: as matrizes fieldName e options devem ter o mesmo número de elementos; caso contrário a matriz options será ignorada. Além disso, as opções Array.UNIQUESORT e Array.RETURNINDEXEDARRAY apenas podem ser usadas como o primeiro elemento na matriz; caso contrário, serão ignoradas.
Parâmetros
fieldName:Object — Uma string que identifica um campo a ser usado como valor de classificação ou uma matriz na qual o primeiro elemento representa o campo de classificação principal, o segundo representa o campo de classificação secundário e assim por diante.
| |
options:Object (default = null)bitwise OR (|), que altera o comportamento da classificação. Os valores a seguir são aceitáveis para o parâmetro options:
A referência de código será ativada se você usar o formato de string do sinalizador (por exemplo, |
Array — O valor de retorno depende de você transmitir ou não parâmetros:
|
Elementos da API relacionados
Exemplo ( Como usar este exemplo )
vegetables e a matriz é então preenchida usando cinco chamadas a push(). Sempre que push() é chamado, um novo objeto Vegetable é criado por uma chamada ao construtor Vegetable(), que aceita um objeto String (name) e Number (price). Chamar push() cinco vezes com os valores mostrados resulta na seguinte matriz: [lettuce:1.49, spinach:1.89, asparagus:3.99, celery:1.29, squash:1.44]. O método sortOn() é então usado com o parâmetro name para gerar a seguinte matriz: [asparagus:3.99, celery:1.29, lettuce:1.49, spinach:1.89, squash:1.44]. O método sortOn() é então chamado novamente com o parâmetro de preço e as constantes NUMERIC e DESCENDING para gerar uma matriz classificada por números em ordem decrescente: [asparagus:3.99, spinach:1.89, lettuce:1.49, squash:1.44, celery:1.29].
var vegetables:Array = new Array();
vegetables.push(new Vegetable("lettuce", 1.49));
vegetables.push(new Vegetable("spinach", 1.89));
vegetables.push(new Vegetable("asparagus", 3.99));
vegetables.push(new Vegetable("celery", 1.29));
vegetables.push(new Vegetable("squash", 1.44));
trace(vegetables);
// lettuce:1.49, spinach:1.89, asparagus:3.99, celery:1.29, squash:1.44
vegetables.sortOn("name");
trace(vegetables);
// asparagus:3.99, celery:1.29, lettuce:1.49, spinach:1.89, squash:1.44
vegetables.sortOn("price", Array.NUMERIC | Array.DESCENDING);
trace(vegetables);
// asparagus:3.99, spinach:1.89, lettuce:1.49, squash:1.44, celery:1.29
class Vegetable {
public var name:String;
public var price:Number;
public function Vegetable(name:String, price:Number) {
this.name = name;
this.price = price;
}
public function toString():String {
return " " + name + ":" + price;
}
}
records e a matriz é então preenchida usando três chamadas a push(). Sempre que push() for chamado, as strings name e city e um número de zip serão adicionados a records. Três loops for são usadas para imprimir os elementos da matriz. O primeiro loop for imprime os elementos na ordem em que eles foram adicionados. O segundo loop for será executado depois que records tiverem sido classificados por nome e então por cidade usando o método sortOn(). O terceiro loop for gera uma saída diferente porque records são reclassificados por cidade e então por nome.
var records:Array = new Array();
records.push({name:"john", city:"omaha", zip:68144});
records.push({name:"john", city:"kansas city", zip:72345});
records.push({name:"bob", city:"omaha", zip:94010});
for(var i:uint = 0; i < records.length; i++) {
trace(records[i].name + ", " + records[i].city);
}
// Results:
// john, omaha
// john, kansas city
// bob, omaha
trace("records.sortOn('name', 'city');");
records.sortOn(["name", "city"]);
for(var i:uint = 0; i < records.length; i++) {
trace(records[i].name + ", " + records[i].city);
}
// Results:
// bob, omaha
// john, kansas city
// john, omaha
trace("records.sortOn('city', 'name');");
records.sortOn(["city", "name"]);
for(var i:uint = 0; i < records.length; i++) {
trace(records[i].name + ", " + records[i].city);
}
// Results:
// john, kansas city
// bob, omaha
// john, omaha
users e a matriz é então preenchida usando quatro chamadas através de push(). Sempre que push() for chamado, um objeto User será criado com o construtor User(), uma string name e um uint idade serão adicionados aos usuários. O conjunto de matrizes resultante é [Bob:3,barb:35,abcd:3,catchy:4].
A matriz é então classificada das seguintes maneiras:
- Somente por nome, gerando a matriz
[Bob:3,abcd:3,barb:35,catchy:4] - Por nome e usando a constante
CASEINSENSITIVE, gerando a matriz[abcd:3,barb:35,Bob:3,catchy:4] - Por nome e usando as constantes
CASEINSENSITIVEeDESCENDING, gerando a matriz[catchy:4,Bob:3,barb:35,abcd:3] - Somente por idade, gerando a matriz
[abcd:3,Bob:3,barb:35,catchy:4] - Por idade e usando a constante
NUMERIC, gerando a matriz[Bob:3,abcd:3,catchy:4,barb:35] - Por idade e usando as constantes
DESCENDINGeNUMERIC, gerando a matriz[barb:35,catchy:4,Bob:3,abcd:3]
Uma matriz denominada indices é então criada e atribuída aos resultados de uma classificação por idade e usando as constantes NUMERIC e RETURNINDEXEDARRAY, resultando na matriz [Bob:3,abcd:3,catchy:4,barb:35], que é impressa com o uso de um loop for.
class User {
public var name:String;
public var age:Number;
public function User(name:String, age:uint) {
this.name = name;
this.age = age;
}
public function toString():String {
return this.name + ":" + this.age;
}
}
var users:Array = new Array();
users.push(new User("Bob", 3));
users.push(new User("barb", 35));
users.push(new User("abcd", 3));
users.push(new User("catchy", 4));
trace(users); // Bob:3,barb:35,abcd:3,catchy:4
users.sortOn("name");
trace(users); // Bob:3,abcd:3,barb:35,catchy:4
users.sortOn("name", Array.CASEINSENSITIVE);
trace(users); // abcd:3,barb:35,Bob:3,catchy:4
users.sortOn("name", Array.CASEINSENSITIVE | Array.DESCENDING);
trace(users); // catchy:4,Bob:3,barb:35,abcd:3
users.sortOn("age");
trace(users); // abcd:3,Bob:3,barb:35,catchy:4
users.sortOn("age", Array.NUMERIC);
trace(users); // Bob:3,abcd:3,catchy:4,barb:35
users.sortOn("age", Array.DESCENDING | Array.NUMERIC);
trace(users); // barb:35,catchy:4,Bob:3,abcd:3
var indices:Array = users.sortOn("age", Array.NUMERIC | Array.RETURNINDEXEDARRAY);
var index:uint;
for(var i:uint = 0; i < indices.length; i++) {
index = indices[i];
trace(users[index].name, ": " + users[index].age);
}
// Results:
// Bob : 3
// abcd : 3
// catchy : 4
// barb : 35
splice | () | método |
AS3 function splice(startIndex:int, deleteCount:uint, ... values):Array| Versão da linguagem: | ActionScript 3.0 |
| Versões de runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Adiciona ou remove elementos de uma matriz. Este método modifica a matriz sem fazer uma cópia.
Nota: para substituir este método em uma subclasse de Array, use ...args para os parâmetros, como mostra este exemplo:
public override function splice(...args) {
// your statements here
}
Parâmetros
startIndex:int — Um inteiro que especifica o índice do elemento na matriz em que a inserção ou exclusão é iniciada. Você pode usar um inteiro negativo para especificar uma posição relativa ao fim da matriz (por exemplo, -1 é o último elemento da matriz).
| |
deleteCount:uint — Um inteiro que especifica o número de elementos a serem excluídos. Esse número inclui o elemento especificado no parâmetro startIndex. Se você não especificar um valor para o parâmetro deleteCount, o método excluirá todos os valores do elemento startIndex até o último elemento da matriz. Se o valor for 0, nenhum elemento será excluído.
| |
... values — Uma lista opcional de um ou mais valores separados por vírgula, para inserir na matriz na matriz na posição especificada pelo parâmetro startIndex. Se um valor inserido for do tipo Matriz, a matriz ficará intacta e será inserida como um elemento simples. Por exemplo, se você unir uma matriz existente do comprimento três com outra matriz do comprimento três, a matriz resultante terá apenas quatro elementos. Um dos elementos, contudo, será uma matriz de comprimento três.
|
Array — Uma matriz contendo os elementos que foram removidos da matriz original.
|
Exemplo ( Como usar este exemplo )
vegetables com os elementos [spinach, green pepper, cilantro, onion, avocado]. O método splice() é então chamado com os parâmetros 2 e 2, que atribuem cilantro e onion à matriz spliced. A matriz vegetables contém então [spinach,green pepper,avocado]. O método splice() é chamado pela segunda vez usando os parâmetros 1, 0 e a matriz spliced para atribuir [cilantro,onion] como segundo elemento em vegetables.
var vegetables:Array = new Array("spinach",
"green pepper",
"cilantro",
"onion",
"avocado");
var spliced:Array = vegetables.splice(2, 2);
trace(vegetables); // spinach,green pepper,avocado
trace(spliced); // cilantro,onion
vegetables.splice(1, 0, spliced);
trace(vegetables); // spinach,cilantro,onion,green pepper,avocado
cilantro e onion são delineados como se vegetables tivesse 5 elementos, embora essa matriz tenha quatro na verdade (e o segundo elemento é outra matriz contendo dois elementos). Para adicionar cilantro e onion individualmente, use o seguinte:
var vegetables:Array = new Array("spinach",
"green pepper",
"cilantro",
"onion",
"avocado");
var spliced:Array = vegetables.splice(2, 2);
trace(vegetables); // spinach,green pepper,avocado
trace(spliced); // cilantro,onion
vegetables.splice(1, 0, "cilantro", "onion");
trace(vegetables); // spinach,cilantro,onion,green pepper,avocado
toLocaleString | () | método |
public function toLocaleString():String| Versão da linguagem: | ActionScript 3.0 |
| Versões de runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Retorna uma string que representa os elementos na matriz especificada. Cada elemento na matriz, começando com o índice 0 e terminando no índice mais alto, é convertido em uma string concatenada e separado por vírgulas. Na implementação ActionScript 3.0, esse método retorna o mesmo valor que o método Array.toString().
String — Uma string de elementos de matriz.
|
Elementos da API relacionados
toString | () | método |
public function toString():String| Versão da linguagem: | ActionScript 3.0 |
| Versões de runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Retorna uma string que representa os elementos na matriz especificada. Cada elemento na matriz, começando com o índice 0 e terminando no índice mais alto, é convertido em uma string concatenada e separado por vírgulas. Para especificar um separador personalizado, use o método Array.join().
String — Uma string de elementos de matriz.
|
Elementos da API relacionados
Exemplo ( Como usar este exemplo )
vegnums do tipo de dados String.
var vegetables:Array = new Array(); vegetables.push(1); vegetables.push(2); vegetables.push(3); vegetables.push(4); vegetables.push(5); var vegnums:String = vegetables.toString(); trace(vegnums+",6"); // 1,2,3,4,5,6
unshift | () | método |
AS3 function unshift(... args):uint| Versão da linguagem: | ActionScript 3.0 |
| Versões de runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Adiciona um ou mais elementos ao início de uma matriz e retorna o novo comprimento dessa matriz. Os outros elementos da matriz são movidos da posição original, i, a i+1.
Parâmetros
... args — Um ou mais números, elementos ou variáveis a serem inseridos no início da matriz.
|
uint — Um inteiro representando o novo comprimento da matriz.
|
Elementos da API relacionados
Exemplo ( Como usar este exemplo )
names. As strings Bill e Jeff são adicionadas pelo método push() e, em seguida, as strings Alfred e Kyle são adicionadas ao início de names por duas chamadas ao método unshift().
var names:Array = new Array();
names.push("Bill");
names.push("Jeff");
trace(names); // Bill,Jeff
names.unshift("Alfred");
names.unshift("Kyle");
trace(names); // Kyle,Alfred,Bill,Jeff
CASEINSENSITIVE | Constante |
public static const CASEINSENSITIVE:uint = 1| Versão da linguagem: | ActionScript 3.0 |
| Versões de runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Especifica a classificação sem distinção entre maiúsculas e minúsculas para os métodos de classificação da classe Array. Você pode usar essa constante para o parâmetro options no método sort() ou sortOn().
O valor dessa constante é 1.
Elementos da API relacionados
DESCENDING | Constante |
public static const DESCENDING:uint = 2| Versão da linguagem: | ActionScript 3.0 |
| Versões de runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Especifica a classificação decrescente para os métodos de classificação da classe Array. Você pode usar essa constante para o parâmetro options no método sort() ou sortOn().
O valor dessa constante é 2.
Elementos da API relacionados
NUMERIC | Constante |
public static const NUMERIC:uint = 16| Versão da linguagem: | ActionScript 3.0 |
| Versões de runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Especifica a classificação numérica (em vez de string de caracteres) para os métodos de classificação da classe Array. A inclusão dessa constante no parâmetro options faz com que os métodos sort() e sortOn() classifiquem números como valores numéricos e não como strings de caracteres numéricos. Sem a constante NUMERIC, a classificação trata cada elemento da matriz como uma string de caractere e gera os resultados na ordem Unicode.
Por exemplo, considerando a matriz de valores [2005, 7, 35], se a constante NUMERIC não estiver inclusa no parâmetro options, a matriz classificada será [2005, 35, 7]; mas, se a constante NUMERIC estiver inclusa, a matriz classificada será [7, 35, 2005].
Essa constante aplica-se somente aos números na matriz e não se aplica a strings que contenham dados numéricos, como ["23", "5"].
O valor dessa constante é 16.
Elementos da API relacionados
RETURNINDEXEDARRAY | Constante |
public static const RETURNINDEXEDARRAY:uint = 8| Versão da linguagem: | ActionScript 3.0 |
| Versões de runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Especifica que uma classificação retorna uma matriz que consiste em índices de matriz. Você pode usar essa constante para o parâmetro options no método sort() ou sortOn(), de modo a ter acesso a várias exibições dos elementos da matriz, enquanto a matriz original permanece inalterada.
O valor dessa constante é 8.
Elementos da API relacionados
UNIQUESORT | Constante |
public static const UNIQUESORT:uint = 4| Versão da linguagem: | ActionScript 3.0 |
| Versões de runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Especifica a exigência de classificação exclusiva para os métodos de classificação da classe Array. Você pode usar essa constante para o parâmetro options no método sort() ou sortOn(). A opção de classificação exclusiva terminará a classificação se quaisquer dois elementos ou campos que estiverem sendo classificados tiverem valores idênticos.
O valor dessa constante é 4.
Elementos da API relacionados
myArr sem argumentos e com um comprimento inicial de 0:
package {
import flash.display.Sprite;
public class ArrayExample extends Sprite {
public function ArrayExample() {
var myArr:Array = new Array();
trace(myArr.length); // 0
}
}
}
Wed Jun 13 2018, 11:10 AM Z