Array

Ir para:

Sumário
Sintaxe
Descrição
Propriedades
Métodos
Instâncias de Array
Métodos genéricos de Array
Exemplos
Especificações
Compatibilidade com os navegadores
Ver também

Sumário

O objeto Array do JavaScript é um objeto global usado na construção de 'arrays': objetos de alto nível semelhantes a listas.

Criando um Array

var frutas = ['Maçã', 'Banana'];

console.log(frutas.length);
// 2

Acessar um item (index) do Array

var primeiro = frutas[0];
// Maçã

var ultimo = frutas[frutas.length - 1];
// Banana

Iterar um Array

frutas.forEach(function (item, indice, array) {
  console.log(item, indice);
});
// Maçã 0
// Banana 1

Adicionar um item ao final do Array

var adicionar = frutas.push('Laranja');
// ['Maçã', 'Banana', 'Laranja']

Remover um item do final do Array

var ultimo = frutas.pop(); // remove Laranja (do final)
// ['Maçã', 'Banana'];

Remover do início do Array

var primeiro = frutas.shift(); // remove Maçã do início
// ['Banana'];

Adicionar ao início do Array

var adicionar = frutas.unshift('Morango') // adiciona ao início
// ['Morango', 'Banana'];

Procurar o índice de um item na Array

frutas.push('Manga');
// ['Morango', 'Banana', 'Manga']

var pos = frutas.indexOf('Banana');
// 1

Remover um item pela posição do índice

var removedItem = frutas.splice(pos, 1); // é assim que se remove um item
// ['Morango', 'Manga']

Remover itens de uma posição de índice

var vegetais = ['Repolho', 'Nabo', 'Rabanete', 'Cenoura'];
console.log(vegetais); 
// ['Repolho', 'Nabo', 'Rabanete', 'Cenoura']

var pos = 1, n = 2;

var itensRemovidos = vegetais.splice(pos, n); 
// Isso é como se faz para remover itens, n define o número de itens a se remover,
// a partir da posição (pos) em direção ao fim da array.

console.log(vegetais); 
// ['Repolho', 'Cenoura'] (o array original é alterado)

console.log(itensRemovidos); 
// ['Nabo', 'Rabanete']

Copiar um Array

var copiar = frutas.slice(); // é assim que se copia
// ['Morango', 'Manga']

Sintaxe

[element0, element1, ..., elementN]
new Array(element0, element1, ..., elementN)
new Array(arrayLength)

element0, element1, ..., elementN: Um array JavaScript é inicializado com os elementos contém, exceto no caso onde um único argumento é passado para o construtor do Array e esse argumento é um número (veja o parâmetro arrayLength abaixo). Esse caso especial só se aplica para os arrays JavaScript criados com o construtor Array , e não para literais de array criados com a sintaxe de colchetes [].
arrayLength: Se o único argumento passado para o construtor do Array for um número inteiro entre 0 and 2³²-1 (inclusive), um novo array com o tamanho desse número é retornado. Se o argumento for qualquer outro número, uma exceção RangeError é lançada.

Descrição

Arrays são objetos semelhantes a listas que vêm com uma série de métodos embutidos para realizar operações de travessia e mutação. Nem o tamanho de um array JavaScript nem os tipos de elementos são fixos. Já que o tamanho de um array pode ser alterado a qualquer momento e os dados podem ser armazenados em posições não contíguas, arrays JavaScript não tem a garantia de serem densos; isso depende de como o programador escolhe usá-los. De uma maneira geral, essas são características convenientes, mas, se esses recursos não são desejáveis para o seu caso em particular, você pode considerar usar arrays tipados.

Arrays não podem usar strings como índices (como em um array associativo), devem ser usados números inteiros. Definir ou acessar não-inteiros usando notação de colchetes (ou notação de ponto) não vai definir ou recuperar um elemento do array em si, mas sim definir ou acessar uma variável associada com a coleção de propriedades de objeto daquele array. As propriedades de objeto do array e a lista de elementos do array são separados, e as operações de travessia e mutação não podem ser aplicadas a essas propriedades nomeadas.

Accessando elementos de um array

Arrays JavaScript começam com índice zero: o primeiro elemento de um array está na posição 0 e o último elemento está na posição equivalente ao valor da propriedade length (tamanho) menos 1.

var arr = ['este é o primeiro elemento', 'este é o segundo elemento'];
console.log(arr[0]);              // exibr 'este é o primeiro elemento'
console.log(arr[1]);              // exibe 'este é o segundo elemento'
console.log(arr[arr.length - 1]); // exibe 'este é o segundo elemento'

Elementos de um array são somente propriedades de objetos, da forma que toString é uma propriedade. Contudo, note que tentando acessar o primeiro elemento de um array da seguinte forma causará um erro de sintaxe, pois o nome da propriedade é inválido:

console.log(arr.0); // um erro de sintaxe

Não há nada de especial a respeito de arrays JavaScript e suas propriedades que causam isso. As propriedades JavaScript que começam com um dígito não podem ser referenciadas com notação de ponto. Elas necesitam usar notação de colchetes para poderem ser acessadas. Por exemplo, se você tivesse um objeto com a propriedade "3d", também teria que ser referenciá-la usando notação de colchetes. Por exemplo:

var anos = [1950, 1960, 1970, 1980, 1990, 2000, 2010];
console.log(anos.0); // um erro de sintaxe
console.log(anos[0]); // funciona corretamente

renderer.3d.setTexture(model, 'personagem.png'); // um erro de sintaxe
renderer['3d'].setTexture(model, 'personagem.png'); //funciona corretamente

Note que no exemplo 3d, '3d' teve de ser colocado entre aspas. É possivel também colocar entre aspas os índices de arrays JavaScript (ou seja, years['2'] ao invés de years[2]), contudo isto não é necessário. O valor 2 em years[2] eventualmente será convertido a uma string pela engine do JavaScript através de uma conversão explicita com o método toString. E é por esta razão que '2' e '02' irão referenciar dois slots diferentes no objeto anos e o seguinte exemplo pode ser true:

console.log(anos['2'] != anos['02']);

De forma similar, propriedades de objeto que sejam palavras reservadas(!) só podem ser acessadas como strings em notação de colchetes:

var promessa = {
  'var': 'texto',
  'array': [1, 2, 3, 4]
};

console.log(promessa['var']);

Relação entre `length` e propriedades numéricas

As propriedades length e numéricas de um array Javascript são conectadas. Varios dos métodos javascript pré-definidos (por exemplo, join, slice, indexOf etc.) levam em conta o valor da propriedade length de um array quando eles são chamados. Outros métodos (por exemplo, push, splice etc.) também resultam em uma atualização na propriedade length do array.

var frutas = [];
frutas.push('banana', 'maça', 'pêssego');

console.log(frutas.length); // 3

Quando configurar uma propriedade num array Javascript em que a propriedade é um índice valido do array e este índice está fora do atual limite do array, o array irá crescer para um tamanho grande o suficiente para acomodar o elemento neste índice, e a engine irá atualizar a propriedade length do array de acordo com isto:

frutas[5] = 'manga';
console.log(frutas[5]); // 'manga'
console.log(Object.keys(frutas)); // ['0', '1', '2', '5']
console.log(frutas.length); // 6

Configurar a propriedade length diretamente, também resulta em um comportamento especial:

frutas.length = 10;
console.log(Object.keys(frutas)); // ['0', '1', '2', '5']
console.log(frutas.length); // 10

Diminuir o valor de length, entretanto, apaga elementos:

frutas.length = 2;
console.log(Object.keys(frutas)); // ['0', '1']
console.log(frutas.length); // 2

Criando um array usando o resultado de uma comparação

O resultado de uma comparação entre uma expressão regular e uma string pode criar um array Javascript. Este array tem propriedades e elementos que disponibilizam informações sobre a comparação. Esse array é o valor de retorno dos métodos RegExp.exec, String.match, e String.replace. Para explicar melhor sobre estas propriedades e elementos, veja o seguinte exemplo e então consulte a tabela abaixo:

// Encontra um d seguido por um ou mais b's seguido por um d
// Salva os b's encontrados e o d seguinte
// Ignora caixa (maiúscula/minúscula)

var minhaRegex = /d(b+)(d)/i;
var meuArray = minhaRegex.exec('cdbBdbsbz');

As propriedades e elementos retornados desta comparação são os seguintes:

Propriedade/Elemento	Descrição	Exemplo
`input`	Uma propriedade somente-leitura que reflete a string original a qual a expressão regular foi comparada.	cdbBdbsbz
`index`	Uma propriedade somente-leitura que é o índice baseado em zero da comparação na string.	1
`[0]`	Um elemento somente-leitura que especifica os ultimos caracteres que foram encontrados.	dbBd
`[1], ...[n]`	Elementos somente-leitura que especificam as substrings de comparações entre parênteses encontradas, se incluidas na expressão regular. O número de possíveis substrings entre parenteses é ilimitado.	[1]: bB [2]: d

Propriedades

Array.length: Propriedade comprimento do construtor Array, cujo valor é 1.
get Array[@@species]: A função de construtor que é utilizada para criar objetos derivados.

Array.prototype: Permite a adição de propriedades para todos os objetos array.

Métodos

Array.from(): Cria uma nova instância de Array a partir de um objeto semelhante ou iterável.
Array.isArray(): Retorna true se a variável é um array e false caso contrário.
Array.of(): Cria uma nova instância de Array com um número variável de argumentos, independentemente do número ou tipo dos argumentos.

Instâncias de `Array`

Todas as instâncias de Array herdam de Array.prototype. O protótipo do construtor Array pode ser modificado de forma a afetar todas as instâncias de Array.

Propriedades

Array.prototype.constructor: Specifies the function that creates an object's prototype.
Array.prototype.length: Reflects the number of elements in an array.
Array.prototype[@@unscopables]: A symbol containing property names to exclude from a with binding scope.

Métodos

Métodos modificadores

These methods modify the array:

Array.prototype.copyWithin(): Copies a sequence of array elements within the array.
Array.prototype.fill(): Fills all the elements of an array from a start index to an end index with a static value.
Array.prototype.pop(): Removes the last element from an array and returns that element.
Array.prototype.push(): Adds one or more elements to the end of an array and returns the new length of the array.
Array.prototype.reverse(): Reverses the order of the elements of an array in place — the first becomes the last, and the last becomes the first.
Array.prototype.shift(): Removes the first element from an array and returns that element.
Array.prototype.sort(): Sorts the elements of an array in place and returns the array.
Array.prototype.splice(): Adds and/or removes elements from an array.
Array.prototype.unshift(): Adds one or more elements to the front of an array and returns the new length of the array.

Métodos de acesso

These methods do not modify the array and return some representation of the array.

Array.prototype.concat(): Returns a new array comprised of this array joined with other array(s) and/or value(s).
Array.prototype.includes(): Determines whether an array contains a certain element, returning true or false as appropriate.
Array.prototype.indexOf(): Returns the first (least) index of an element within the array equal to the specified value, or -1 if none is found.
Array.prototype.join(): Joins all elements of an array into a string.
Array.prototype.lastIndexOf(): Returns the last (greatest) index of an element within the array equal to the specified value, or -1 if none is found.
Array.prototype.slice(): Extracts a section of an array and returns a new array.
Array.prototype.toSource(): Returns an array literal representing the specified array; you can use this value to create a new array. Overrides the Object.prototype.toSource() method.
Array.prototype.toString(): Returns a string representing the array and its elements. Overrides the Object.prototype.toString() method.
Array.prototype.toLocaleString(): Returns a localized string representing the array and its elements. Overrides the Object.prototype.toLocaleString() method.

Métodos de iteração

Several methods take as arguments functions to be called back while processing the array. When these methods are called, the length of the array is sampled, and any element added beyond this length from within the callback is not visited. Other changes to the array (setting the value of or deleting an element) may affect the results of the operation if the method visits the changed element afterwards. While the specific behavior of these methods in such cases is well-defined, you should not rely upon it so as not to confuse others who might read your code. If you must mutate the array, copy into a new array instead.

Array.prototype.entries(): Returns a new Array Iterator object that contains the key/value pairs for each index in the array.
Array.prototype.every(): Returns true if every element in this array satisfies the provided testing function.
Array.prototype.filter(): Creates a new array with all of the elements of this array for which the provided filtering function returns true.
Array.prototype.find(): Returns the found value in the array, if an element in the array satisfies the provided testing function or undefined if not found.
Array.prototype.findIndex(): Returns the found index in the array, if an element in the array satisfies the provided testing function or -1 if not found.
Array.prototype.forEach(): Calls a function for each element in the array.
Array.prototype.keys(): Returns a new Array Iterator that contains the keys for each index in the array.
Array.prototype.map(): Creates a new array with the results of calling a provided function on every element in this array.
Array.prototype.reduce(): Apply a function against an accumulator and each value of the array (from left-to-right) as to reduce it to a single value.
Array.prototype.reduceRight(): Apply a function against an accumulator and each value of the array (from right-to-left) as to reduce it to a single value.
Array.prototype.some(): Returns true if at least one element in this array satisfies the provided testing function.
Array.prototype.values(): Returns a new Array Iterator object that contains the values for each index in the array.
Array.prototype[@@iterator](): Returns a new Array Iterator object that contains the values for each index in the array.

Métodos genéricos de `Array`

Métodos genéricos de arrays não seguem o padrão, são obsoletos e serão removidos em breve.

Algumas vezes você poderá querer aplicar métodos de arrays para strings ou outros objetos parecidos com arrays (como em argumentos de funções). Ao fazer isto, você trata uma string como um array de caracteres (ou em outros casos onde trata-se não-arrays como um array). Por exemplo, para checar se cada caractere em uma varivável str é uma letra, você poderia escrever:

function isLetter(character) {
  return (character >= "a" && character <= "z");
}

if (Array.prototype.every.call(str, isLetter))
  alert("A string '" + str + "' contém somente letras!");

Esta notação é um pouco despendiosa e o JavaScript 1.6 introduziu a seguinte abreviação genérica:

if (Array.every(isLetter, str))
  alert("A string '" + str + "' contém somente letras!");

Generics também estão disponíveis em String.

Estes não são atualmente parte dos padrões ECMAScript (através do ES2015 Array.from() pode se conseguir isto). A seguir segue uma adaptação para permitir o uso em todos os navegadores:

/*globals define*/
// Assumes Array extras already present (one may use shims for these as well)
(function () {
    'use strict';

    var i,
        // We could also build the array of methods with the following, but the
        //   getOwnPropertyNames() method is non-shimable:
        // Object.getOwnPropertyNames(Array).filter(function (methodName) {return typeof Array[methodName] === 'function'});
        methods = [
            'join', 'reverse', 'sort', 'push', 'pop', 'shift', 'unshift',
            'splice', 'concat', 'slice', 'indexOf', 'lastIndexOf',
            'forEach', 'map', 'reduce', 'reduceRight', 'filter',
            'some', 'every', 'isArray'
        ],
        methodCount = methods.length,
        assignArrayGeneric = function (methodName) {
            var method = Array.prototype[methodName];
            Array[methodName] = function (arg1) {
                return method.apply(arg1, Array.prototype.slice.call(arguments, 1));
            };
        };

    for (i = 0; i < methodCount; i++) {
        assignArrayGeneric(methods[i]);
    }
}());

Exemplos

Exemplo: Criando um array

O exemplo a seguir cria um array, msgArray, com length 0, então atribui valores para msgArray[0] e msgArray[99], trocando o length do array para 100.

var msgArray = new Array();
msgArray[0] = "Hello";
msgArray[99] = "world";

if (msgArray.length == 100)
   print("O length é 100.");

Exemplo: Criando um array bi-dimensional

O exemplo a seguir cria um tabuleiro de xadrez usando dois arrays bi-dimensionais de string. A primeira jogada é feita copiando o 'p' em 6,4 para 4,4. A posição antiga de 6,4 é colocada em branco.

var board = 
[ ['R','N','B','Q','K','B','N','R'],
  ['P','P','P','P','P','P','P','P'],
  [' ',' ',' ',' ',' ',' ',' ',' '],
  [' ',' ',' ',' ',' ',' ',' ',' '],
  [' ',' ',' ',' ',' ',' ',' ',' '],
  [' ',' ',' ',' ',' ',' ',' ',' '],
  ['p','p','p','p','p','p','p','p'],
  ['r','n','b','q','k','b','n','r']];
print(board.join('\n') + '\n\n');

// Fazendo o King's Pawn avançar 2
board[4][4] = board[6][4];
board[6][4] = ' ';
print(board.join('\n'));

Saída:

R,N,B,Q,K,B,N,R
P,P,P,P,P,P,P,P
 , , , , , , , 
 , , , , , , , 
 , , , , , , , 
 , , , , , , , 
p,p,p,p,p,p,p,p
r,n,b,q,k,b,n,r

R,N,B,Q,K,B,N,R
P,P,P,P,P,P,P,P
 , , , , , , , 
 , , , , , , , 
 , , , ,p, , , 
 , , , , , , , 
p,p,p,p, ,p,p,p
r,n,b,q,k,b,n,r

Utilizando um array para tabular um conjunto de valores

values = [];
for (var x = 0; x < 10; x++){
 values.push([
  2 ** x,
  2 * x ** 2
 ])
};
console.table(values)

Saída:

Especificações

Especificação	Status	Comentário
ECMAScript 1st Edition (ECMA-262)	Padrão	Definição inicial
ECMAScript 5.1 (ECMA-262) The definition of 'Array' in that specification.	Padrão	Novos metodos adicionados: `Array.isArray`, `indexOf`, `lastIndexOf`, `every`, `some`, `forEach`, `map`, `filter`, `reduce`, `reduceRight`
ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Array' in that specification.	Padrão	Novos metodos adicionados: `Array.from`, `Array.of`, `find`, `findIndex`, `fill`, `copyWithin`
ECMAScript Latest Draft (ECMA-262) The definition of 'Array' in that specification.	Rascunho	Novo metodo adicionado: `Array.prototype.includes()`

Compatibilidade com os navegadores

We're converting our compatibility data into a machine-readable JSON format. This compatibility table still uses the old format, because we haven't yet converted the data it contains. Find out how you can help!

Desktop
Mobile

Configuração	Chrome	Firefox (Gecko)	Internet Explorer	Opera	Safari (WebKit)
Suporte básico	(Yes)	(Yes)	(Yes)	(Yes)	(Yes)

Configuração	Android	Firefox Mobile (Gecko)	IE Phone	Opera Mobile	Safari Mobile
Suporte básico	(Yes)	(Yes)	(Yes)	(Yes)	(Yes)

Ver também

Etiquetas do documento e colaboradores

Etiquetas:

Colaboradores desta página: caiocaly, ManoelLobo, rafaelbezerra195, gutoribeiro, kdex, biracruz, marcoaure, dsbezerra, deyvid0123, deyvidyury, raduq, RodolfoSilva, FrancisWagner, euconectei, teoli, xhximenes, Sheppy

Última atualização por: caiocaly, Sep 18, 2017, 7:24:15 AM

Tópicos relacionados

Array

Sumário

Sintaxe

Descrição

Accessando elementos de um array

Relação entre length e propriedades numéricas

Criando um array usando o resultado de uma comparação

Propriedades

Métodos

Instâncias de Array

Propriedades

Métodos

Métodos modificadores

Métodos de acesso

Métodos de iteração

Métodos genéricos de Array

Exemplos

Exemplo: Criando um array

Exemplo: Criando um array bi-dimensional

Utilizando um array para tabular um conjunto de valores

Especificações

Compatibilidade com os navegadores

Ver também

Etiquetas do documento e colaboradores

Aprenda o melhor do desenvolvimento web

Obrigado! Por favor, confira sua caixa de entrada para confirmar sua assinatura.

Relação entre `length` e propriedades numéricas

Instâncias de `Array`

Métodos genéricos de `Array`