As palavras anteriores
Existem 22 métodos na matriz. Este artigo os divide em métodos de herança de objetos, métodos de conversão de matrizes, métodos de pilha e fila, métodos de classificação de matrizes, métodos de splicing de matriz, métodos de criação de subarray, métodos de exclusão da matriz, métodos de posição da matriz, métodos de mesclagem de matriz e métodos de iteração de matriz em detalhes.
Método de herança de objetos
Matriz é um objeto especial que herda os métodos ToString (), Tolocalestring () e ValueOf () do objeto do objeto.
【ToString ()】
O método tostring () retorna uma corda separada por vírgula emendada a partir do formulário de string de cada valor na matriz.
[Nota] O valor de retorno deste método é o mesmo que a string retornada chamando o método junção () sem parâmetros.
[1,2,3] .ToString (); // '1,2,3' ['a', 'b', 'c'].
Como o alert () deseja receber parâmetros de string, ele chamará o método ToString () em segundo plano e obterá o mesmo resultado que o método ToString ()
alerta ([1,2,3]); // '1,2,3'
【Tolocalestring ()】
Tolocalestring () é uma versão localizada do método ToString (), que geralmente retorna o mesmo valor que o método ToString (), mas nem sempre é o caso. Porque, ele chama o elemento, o método tolocalestring () converte cada elemento da matriz em uma string
var Person1 = {Tolocalestring: function () {return 'nikolaos';}, tostring: function () {return 'nikolas';}}; var pessoa2 = {tolocalestring: function () {return 'grigorios';}, tostring: function () {return '' Greg; [Person1, Person2]; Console.log (People.ToString ()); // 'Nikolas, Greg'console.log (People.Tolocalestring ()); //' Nikolas, Grigorios 'Se o valor de um item na matriz for nulo ou indefinido, o valor será representado como uma string vazia nos resultados retornados pelos métodos tolocalestring () e tostring ().
var colors = [1, indefinido, 2, null, 3]; console.log (colors.toString ()); // '1 ,, 2 ,, 3'console.log (colors.tolocalestring ()); //' 1, 2,, 3 '
【Valueof ()】
O método valueof () retorna o próprio objeto de matriz
var a = [1, 2, 3]; console.log (a.valueof ()); // [1, 2, 3] console.log (a.valueof () instância de matriz); // true
Método de conversão da matriz
【juntar()】
O método Array.join () é uma operação inversa do método String.split (), que divide a string em vários blocos para criar uma matriz.
Os métodos tolocalestring () e tostring () herdados por matrizes retornarão itens de matriz em caracteres separados por vírgula por padrão; O método junção () pode usar delimitadores diferentes para criar essa string. O método junção () recebe apenas um parâmetro, usado como delimitador, e depois retorna uma string contendo todos os itens da matriz.
Se nenhum valor for passado para o método junção (), use uma vírgula como o separador
var a = [1,2,3]; console.log (A.Join ()); // '1,2,3'Console.log (A.Join (' ')); //' 1 2 3'Console.log (A.Join (''); // '123'Var B = novo Array (10); B.Join ('-'); // '-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------Se o parâmetro do método junção () for indefinido, o navegador padrão retornará a string com uma vírgula como separador, e o navegador IE7 retornará a sequência com 'indefinido' como o separador.
// O navegador padrão é '1,2,3'; IE7-O navegador é '1UNDEFINED2UNDEFINEID3'VAR A = [1,2,3]; console.log (A.Join (indefinido));
Se o valor de um item na matriz for nulo ou indefinido, o valor será representado como uma string vazia no resultado retornado pelo método junção ()
var colors = [1, indefinido, 2, nulo, 3]; console.log (colors.join ()); // '1 ,, 2 ,, 3'
Este método também pode ser usado em objetos de matriz de classe
console.log (Array.prototype.join.call ('hello', '-')); // "hello" var obj = {0: 'a', 1: 'b', comprimento: 2}; console.log (Array.protype.Join.Call (obj, '-') // '[Nota] Se o objeto não tiver um atributo de comprimento, não é uma matriz de classe e o método da matriz não pode ser chamado
var obj = {0: 'a', 1: 'b'}; console.log (typeof Array.prototype.join.call (obj, '-')); // ''Métodos de pilha e fila
Os métodos push () e pop () permitem que as matrizes sejam usadas como pilhas. O comportamento dos métodos não () e shift () é muito semelhante ao push () e pop (). A diferença é que as primeiras inserções e excluem elementos à frente da matriz e não na cauda.
A pilha é uma estrutura de dados LIFO (última primeira e fora, mais tarde na primeira saída), ou seja, o item mais recente adicionado é removido o mais cedo possível. A inserção (chamada de empurrar) e a remoção (chamada pop -up) de itens na pilha só acontecem em um local - a parte superior da pilha. JavaScript fornece métodos push () e pop () especificamente para matrizes para alcançar o comportamento do tipo Stack
A regra de acesso para a estrutura de dados da fila é o FIFO (primeiro na primeira saída, o primeiro a sair). A fila adiciona itens no final da lista e remove os itens da extremidade frontal da lista. Usando os métodos Shift () e Push () em combinação, você pode usar matrizes como filas
【empurrar()】
O método push () pode receber qualquer número de parâmetros, adicioná -los um a um ao final da matriz e retornar o comprimento da matriz modificada. Então, a matriz mudará a matriz original
var a = []; console.log (a, a.push (1)); // [1] 1console.log (a, a.push ('a')); // [1, 'a'] 2console.log (a, a.push (true, {}); // [1, 'a', verdade, {}] 4console.log (a, a.push ([5,6])); // [1, 'a', verdadeiro, {}, [5,6]] 5Se você precisar mesclar duas matrizes, você pode usar o método Apply
var a = [1, 2, 3]; var b = [4, 5, 6]; console.log (a, array.prototype.push.apply (a, b)); // [1,2,3,4,5,6] 6
[Nota] Se você usar o método de chamada, a matriz B será considerada um parâmetro como um todo
var a = [1, 2, 3]; var b = [4, 5, 6]; console.log (a, array.prototype.push.call (a, b)); // [1,2,3, [4,5,6]] 4
O método push () também pode adicionar elementos ao objeto, e o objeto adicionado se torna um objeto de matriz, ou seja, o índice da matriz correspondente da chave do elemento recém -adicionado, e o objeto tem um atributo de comprimento
var obj = {a: 1}; console.log (obj, []. push.call (obj, 2)); // {a: 1, 0: 2, comprimento: 1} console.log (obj, [].【Pop ()】
O método pop () remove o último item do final da matriz, reduz o valor do comprimento da matriz e retorna o item removido. Então, a matriz mudará a matriz original
var a = ['a', 'b', 'c']; console.log (a, a.pop ()); // ['a', 'b'] c '
O uso do método pop () para matrizes vazias não relatará um erro, mas retornará indefinido
var a = []; console.log (a, a.pop ()); // [] indefinido
【mudança()】
O método shift () remove o primeiro item na matriz e retorna o item, enquanto o comprimento da matriz é reduzido em 1. Portanto, a matriz alterará a matriz original
var a = ['a', 'b', 'c']; console.log (a, a.shift ()); // ['b', 'c'] 'a'
Use o método shift () para matrizes vazias, e nenhum erro será relatado, mas retornará indefinido
var a = []; console.log (a, a.shift ()); // [] indefinido
【Netift ()】
O método de não -quedas () adiciona qualquer item na extremidade frontal da matriz e retorna o novo comprimento da matriz. Então, a matriz mudará a matriz original
var a = ['a', 'b', 'c']; console.log (a, a.unshift ('x')); // ['x', 'a', 'b', 'c'] 4Quando o não é chamado com vários parâmetros, os parâmetros são inseridos ao mesmo tempo, em vez de um de cada vez. Isso significa que a ordem dos elementos inseridos na matriz final é consistente com sua ordem na lista de parâmetros
var a = ['a', 'b', 'c']; console.log (a, a.unshift ('x', 'y', 'z')); // ['x', 'y', 'z', 'a', 'b', 'c'] 6[Nota] No IE7-Browser, o método não-definido () retorna sempre indefinido
// No navegador padrão, retorne [1] 1; e no navegador IE7, retorne [1] indefinido a = []; console.log (a, a.unshift (1));
Método de classificação da matriz
Existem dois métodos na matriz que podem ser usados para reordenar diretamente: reverse () e Sort ()
【reverter()】
O método reverse () é usado para reverter a ordem da matriz e retornar a matriz classificada; E a ordem do array original também mudou.
var Array = [1,2,4,3,5]; console.log (Array, Array.Reverse ()); // [5,3,4,2,1] [5,3,4,2,1] var Array = ['str', verdadeiro, 3]; console.log (Array, 3);
【organizar()】
Por padrão, o método Sort () organiza itens de matriz em ordem crescente de strings. O método de classificação chamará o método tosTring () de cada item da matriz e, em seguida, comparará o tipo de string resultante para retornar a matriz classificada e a ordem da matriz original também muda.
var Array = [1,2,4,3,5]; console.log (Array, Array.sort ()); // [1,2,3,4,5] [1,2,3,4,5] var Array = ['3str', 3,2, '2']; [1,5,10,50]; Console.log (Array, Array.sort ()); // [1, 10, 5, 50]
Se a matriz contiver elementos indefinidos, eles serão colocados no final da matriz
var Array = ['3', 3, indefinido, 2, '2']; console.log (Array, Array.sort ()); // ["2", 2, "3", 3, indefinido] ["2", 2, "3", 3, indefinido]
O método stor () pode aceitar uma função de comparação como um argumento para especificar qual valor é precedido por qual valor. A função de comparação recebe dois parâmetros, retorna um número negativo se o primeiro parâmetro deve estar antes do segundo parâmetro, retornará 0 se os dois parâmetros forem iguais e retornará um número positivo se o primeiro parâmetro deve estar após o segundo parâmetro
função compare (value1, value2) {if (value1 <value2) {return -1;} else if (value1> value2) {return 1;} else {return 0;}} var Array = ['5px', 50,1,10]; seconsole.log (Array.sort (compare)); // ["5px", 1, 10, 50]Para tipos numéricos ou método ValueOf (), a função de comparação pode simplificar o tipo de objeto do tipo numérico.
função compare (value1, value2) {return value1 - value2;} var array = ['5px', 50,1,10]; console.log (Array.sort (compare)); // ["5px", 1,10,50] var Array = [5,50,1,10]; Console.log (Array.s.s]Se uma variedade de strings for realizada classificação de alfabetismo insensível, a função de comparação primeiro converte os parâmetros em strings minúsculas e depois inicia a comparação
a = ['Ant', 'Bug', 'Cat', 'Dog']; A.Sort (); // ['Bug', 'Dog', 'Ant', 'Cat']; A.Sort (function (S, T) {var a = S.TolowerCase (); var B = T.Tolower (); if (a <b) -1; se (); 0;}); // ['Ant', 'Bug', 'Cat', 'Dog']【Dicas】 Crie uma matriz aleatória usando o método Sort ()
função compare () {return Math.random () - 0,5;} var Array = [1,2,3,4,5]; console.log (Array.sort (compare)); // [2,1,5,4,3]Método de costura de matriz
【Concat ()】
O método concat () cria uma nova matriz com base em todos os itens na matriz atual. Primeiro, crie uma cópia da matriz atual e adicione os parâmetros recebidos ao final da cópia e finalmente retorna a matriz recém -construída. Portanto, concat () não afeta a matriz original
Se o parâmetro não for passado para o método concat (), ele simplesmente copia a matriz atual; Se o parâmetro for uma ou mais matrizes, o método adicionará cada item nessas matrizes à matriz de resultados; Se o valor passado não for uma matriz, esses valores serão simplesmente adicionados ao final da matriz de resultados
var números = [1,2]; console.log (números, números.concat (3,4)); // [1,2] [1,2,3,4] console.log (números, números.concat ([5,4,3], [3,4,5], 1,2); // [1,2] [1,2,5,4,3,3,4,5,1,2] console.log (números, números.concat (4, [5, [6,7]])); // [1,2] [1,2,4,5, [6,7]]];
Se nenhum parâmetros for fornecido, o método concat () retornará uma cópia rasa da matriz atual. A chamada "cópia rasa" significa que, se o membro da matriz incluir um valor de tipo composto (como um objeto), a nova matriz copiando uma referência ao valor.
// Este método realmente copia apenas a primeira dimensão da matriz. A primeira dimensão da matriz armazena a referência da segunda dimensão, e a segunda dimensão realmente armazena seu conteúdo var números = [1,2]; var newNumbers = números.concat (); console.log (números, newnumbers); // [1,2] [1,2] [0] = 0; [[1,2]]; var newNumbers = número.Concat (); console.log (números, newnumbers); // [[1,2]] [[1,2]] números [0] [0] = 0; console.log (números, newnumbers); // [[0,2]] [[0,2]
O método concat () também pode ser usado para mesclar objetos em matrizes, mas deve ser feito com o método Call ().
var newArray = array.prototype.concat.call ({a: 1}, {b: 2}) console.log (newArray); // [{a: 1}, {b: 2}] console.log (newArray [0] .a); // 1Crie o método de subarray
【fatiar()】
O método Slice () cria uma nova matriz com base em um ou mais itens na matriz atual, aceita um ou dois parâmetros, ou seja, para retornar as posições de início e final do item e, finalmente, retornar a nova matriz, então Slice () não afeta a matriz original
O método Slice (Start, End) requer dois parâmetros iniciais e finais, que retornam um subarray nesta matriz da posição inicial para (mas não contém) posição final; Se o fim for indefinido ou não existir, ele retornará todos os itens da posição inicial ao final da matriz
Se o início for um número negativo, start = max (comprimento + start, 0)
Se o fim for um número negativo, end = max (comprimento + final, 0)
Iniciar e final não podem trocar as posições
Se não houver parâmetros, retorne à matriz original
VAR números = [1,2,3,4,5]; console.log (número.slice (2)); // [3,4,5] console.log (número.slice (2, indefinido)); // [3,4,5] consol e.log (números.slice (2,3)); // [3] console.log (número.slice (2,1)); // [] console.log (número.slice (-3)); //-3+5 = 2 -> [3,4,5] console.log (número.slice (-8)); // max (5 + -8,0) = 0 -> [1,2,3,4,5] console.log (número.slice (0, -3)); // -3 + 5 = 2 -> [1,2] console.log (número.slice (-2, -1)); //-2+5 = 3; -1+5 = 4; -> [4]
Se nenhum parâmetros for fornecido, o método slice () retornará uma cópia rasa da matriz atual
// Este método realmente copia apenas a primeira dimensão da matriz. A primeira dimensão da matriz armazena a referência da segunda dimensão, e a segunda dimensão realmente armazena seu conteúdo var números = [1,2]; var newNumbers = números.slice (); console.log (números, newnumbers); // [1,2] [1,2] [0] = 0; [[1,2]]; var newNumbers = números.slice (); console.log (números, newnumbers); // [[1,2]] [[1,2]] números [0] [0] = 0; console.log (números, newnumbers); // [[0,2]] [[0,2]]
O método Slice () envolve o tipo implícito de conversão da função de transformação número (). Quando o início é convertido em nan, é equivalente a iniciar = 0; Quando o final é convertido em nan (exceto que final é indefinido), uma matriz vazia é emitida
VAR números = [1,2,3,4,5]; console.log (número.slice (nan)); // [1,2,3,4,5] console.log (números.slice (0, nan)); // [] console.log (números.slice (true, [3]); // [2,3] Sole.log (número.slice (nulo, indefinido)); // [1,2,3,4,5] console.log (número.slice ({})); // [1,2,3,4,5] console.log (número.slice ('2', [5]); // [3,44,5]Você pode usar o método slice () para transformar o objeto de matriz de classe em uma matriz real
var arr = Array.prototype.slice.call (Arraylike); array.prototype.slice.call ({0: 'a', 1: 'b', comprimento: 2}) // ['a', 'b'] Array.protype.slice.call (document.QuersetectoralTal (");Método de exclusão de matriz
【Splice ()】
Splice () e Slice () têm nomes muito semelhantes, mas suas funções são essencialmente diferentes. O método Splice () é usado para excluir parte da matriz original e pode adicionar novos membros da matriz no local excluído. Este método mudará a matriz original.
Splice () retorna uma matriz composta por elementos excluídos ou uma matriz vazia se nenhum elemento excluído for retornado.
O primeiro parâmetro de Splice () Iniciar especifica a posição inicial para inserção ou exclusão. Se o início for um número negativo, start = max (comprimento + start, 0); Se o início for nan, é equivalente a iniciar = 0
Se apenas um elemento for fornecido, é equivalente a dividir a matriz original em duas matrizes no local especificado
var a = [1,2,3,4,5,6,7,8]; console.log (a, a.splice ()); // [1,2,3,4,5,6,7,8] [] var a = [1,2,2,4,5,7,7]; console.log (a, a.splice (4); = [1,2,3,4,5,6,7,8]; console.log (a, a.splice (-4)); //-4+8 = 4; [1,2,3,4] [5,6,7,8] var a = [1,2,3,4,5,6,7,8]; console.log (a, a.splice (-9)); // max (-9+8,0) = 0 [] [1,2,3,4,5,6,7,8]; console.log (a, a.splice (nan)); // [] [1,2,3,4,5,6,7,8]
O segundo número do parâmetro especifica o número de elementos que devem ser excluídos da matriz. Se o segundo parâmetro for omitido, todos os elementos do ponto de partida até o final da matriz serão excluídos. Se o número for negativo ou nan ou indefinido, número = 0, então o elemento não é excluído
var a = [1,2,3,4,5,6,7,8]; console.log (a, a.splice (0,2)); // [3,4,5,6,7,8] [1,2] var a = [1,2,4,5,6,8]; Console.Log (A, A.Splice (10,5,5); [1,2,3,4,5,6,7,8] [] var a = [1,2,3,4,5,6,7,8]; console.log (a, a.plice (1.100)); // [1] [2,3,5,6,7,8] var a = [1,2,3,4,5,6,7,8]; console.log (a, a.splice (1, -5)); // [1,2,3,4,5,6,7,8] [] var a = [1,2,3,4,5,6,7,8]; console.log (a, a.plice (1, nan)); // [1,2,3,4,5,6,7,8] [] var a = [1,2,3,4,5,6,7,8]; console.log (a, a.splice (1, indefinido)); // [1,2,3,4,5,6,7,8] [] var a = [1,2,3,4,5,6,7,8]; console.log (a, a.plice (1, indefinido)); // [1,2,3,4,5,6,7,8] []
Se houver mais parâmetros mais tarde, significa que esses são os novos elementos a serem inseridos na matriz
var a = [1,2,3,4,5]; console.log (a, a.splice (2,0, 'a', 'b')); // [1,2, 'a', 'b', 3,4,5] [] console.log (a, a.splice (2,2, [1,2], 3); ['a', 'b']
Método de posição da matriz
O ES5 adiciona dois métodos de posição às instâncias de matriz: indexOf () e LastIndexOF ()
【IndexOf ()】
O método IndexOF (Pesquisar, Iniciar) recebe dois parâmetros pesquisar e iniciar, retornando o local onde a pesquisa aparece primeiro e, se não for encontrada, retorna -1
O parâmetro de pesquisa indica o item a ser pesquisado; Use o Strito Operador de Igualdade (===) para comparação
var arr = [1,2,3, '1', '2', '3']; console.log (arr.indexOf ('2')); // 4console.log (arr.indexOF (3)); // 2console.log (ar.indexof (0); //-1O parâmetro inicial indica a posição inicial da pesquisa. Este método chama implicitamente a função de transformação número () para converter valores não numéricos (exceto indefinidos) em números. Se este parâmetro for ignorado ou se o parâmetro for indefinido ou nan, start = 0
var arr = ['a', 'b', 'c', 'd', 'e', 'a', 'b']; console.log (arr.indexof ('a', indefinido)); // 0console.log (arr.indexOf ('a', nan)); // 0consol e.log (arr.indexOf ('a', 1)); // 5console.log (arr.indexOf ('a', true)); // 5console.log (arr.indexOF ('a',-1)); // max (0, -1+7) = 6; -1console.log (arr.indexof ('a',-5)); // max (0, -5+7) = 2; 5console.log (arr.indexof ('a',-50)); // max (0, -50+7) = 0; 0 var pessoa = {nome: 'nicholas'}; var people = [{name: 'nicholas'}]; var maispeople = [pessoa]; alerta (People.indexof (pessoa)); //-1, porque uma pessoa e pessoas [0] têm os mesmos valores, são duas referências (mais povo.indexof (0); ALERT (MorePeople.IndexOf ({Nome: 'Nicholas'})); //-1, porque eles não são a mesma referênciaMétodo de escrita compatível do método IndexOf ()
if (typeof Array.prototype.indexOf! = "function") {Array.prototype.IndexOF = function (SearchElement, FromIndex) {var index = -1; FromIndex = FromIndex * 1 || 0; para (var k = 0, comprimento = this.length; k <comprimento; k ++) {if (k> = fromIndex && this [k] === SearchElement) {index = k; break;}} Return Index;};}【LastIndexOf ()】
Ao contrário do indexOF (), o LastIndexOF () parece da direita para a esquerda
O método LastIndexOF (pesquisa, start) recebe dois parâmetros pesquisando e iniciando, retornando o local onde a pesquisa aparece primeiro e, se não for encontrada, retorna -1
O parâmetro de pesquisa indica o item a ser pesquisado; Use o Strito Operador de Igualdade (===) para comparação
var arr = [1,2,3, '1', '2', '3']; console.log (arr.LastIndexof ('2')); // 4console.log (arr.LastIndexOf (3)); // 2console.Log (Arr.LastIndexOf (0); //-1 1Iniciar significa que a posição inicial da pesquisa, que chama implicitamente a função de transformação número () para converter valores não numéricos (exceto indefinidos) em números. Se este parâmetro for ignorado ou se o parâmetro for indefinido ou nan, start = 0
Ao contrário do método lastIndexOf () de uma string, quando o método de pesquisa é um número negativo, search = max (0, comprimento+pesquisa)
var arr = ['a', 'b', 'c', 'd', 'e', 'a', 'b']; console.log (ar.LastIndexOf ('b')); // 6console.log (ar.LastIndexOf ('b', indefinido); ndefined)); // 0console.log (Arr.LastIndexOf ('B', NAN)); //-1console.log (arr.LastIndexOf ('B', 1)); // 1Console.log (Arr.LastIndexof ('B',-1)); 6console.log (arr.LastIndexOF ('B',-5)); // max (0, -5+7) = 2; 1console.log (arr.LastIndexOF ('b',-50)); // max (0, -50+7) = 0; -1【Dicas】 Retorna todos os valores de índice dos itens que atendem aos critérios
Todos os itens correspondentes podem ser encontrados em loop para chamar indexof () ou LastIndexOF ()
função allIndexOf (matriz, value) {var resultado = []; var pos = array.indexOf (value); if (pos === -1) {return -1;} while (pos> -1) {resultado.push (pos); pos = array.indexOf (value, POS+1);} retorno resultado; [1,2,3,3,2,1]; console.log (AllIndexOF (Array, 1)); // [0,5]Método de escrita compatível do método lastIndexOf ()
if (typeof Array.prototype.LastIndexOf! = "function") {Array.prototype.LastIndexOf = function (SearchElement, FromIndex) {var index = -1, length = this.length; fromIndex = Fromindex * 1 | 1 | comprimento - 1; para (var k = comprimento - 1; k> -1; k- = 1) {if (k <= fromIndex && this [k] === SearchElement) {index = k; break;}} Return Index;};}Método de mesclagem de matriz
Os métodos de mesclagem de matriz incluem métodos Reduce () e ReduceRight (). Eles usam a função especificada para combinar elementos de matriz para gerar um único valor. Esta é uma operação comum na programação funcional, também conhecida como "injeção" e "colapso"
【reduzir()】
O método reduz () requer dois parâmetros. A primeira é uma função que executa operações simplificadas. A tarefa de simplificar as funções é usar algum método para combinar ou subtrair dois valores em um valor e retornar o valor simplificado.
A função simplificada aceita quatro parâmetros, a saber:
【1】 Variável inicial, padrão para o primeiro valor do elemento da matriz. O valor de retorno após a primeira execução da função é usado como a variável inicial para a segunda execução da função e assim por diante
【2】 A variável atual, se o segundo parâmetro for especificado, a variável é o valor do primeiro elemento da matriz; caso contrário, o valor do segundo elemento é o valor do segundo elemento.
【3】 O índice dos elementos correspondentes à variável atual na matriz (a partir de 0)
【4】 Objeto de matriz original
Entre esses quatro parâmetros da função simplificada, apenas os dois primeiros são necessários, enquanto os dois últimos são opcionais.
valores.Reduce (function (prev, curs, índice, array) {// TODO});O segundo parâmetro (opcional) do método reduz () é um valor inicial passado para a função
var a = [1,2,3,4,5]; var sum = A.Reduce (função (x, y) {return x+y}, 0); // soma da matriz var Product = A.Reduce (function (x, y) {return x*y}, 1); 2, 3, 4, 5]. Reduce (função (prev, cur) {console.log (prev, cur) retorno prev + curs;}); // 1 2 // 3 3 // 6 4 // 10 5 // Último resultado: 15 [1, 3, 3, 4, 5] .Reduce (function, curs, curs) {console) (1, 0, 0, 4, 4, 4, 5]. Reduce (function, curs) {console) (0,10; 3 // 6 4 // 10 5 // Último resultado: 15[Nota] O tipo de retorno do tipo do método Reduce () é o mesmo que o valor inicial passado em
[1, 2, 3, 4, 5]. Reduce (função (prev, cur) {console.log (prev.sum, cur); prev.sum = prev.sum + cur; retorno prev;}, {sum: 0}); // 0 1 // 1 2 // 3 3 // 6 4/10 // objeto {: 15}Usando o método Reduce (), você pode escrever um método de soma para a soma das matrizes
Array.prototype.sum = function () {return this.Reduce (function (prev, cur) {return prept + cur;})}; [3,4,5,6,10] .sum (); // 28Como o método de redução processa cada elemento em sequência, ele pode ser usado para procurar um elemento. Por exemplo, encontre o elemento de matriz mais longo
função findLongest (entradas) {retorna entradas.Reduce (function (prev, cur) {return cur.length> prev.length? curs? cur: prev;}, '');} console.log (findlongest ([1,2,3, 'ab', 4, 'bc', 5,6785,4]);Você pode usar o método Reduce () para obter achatamento de matrizes bidimensionais
var matrix = [[1, 2], [3, 4], [5, 6]]; // Matriz 2D achaten var flatten = matrix.reduce (function (prev, cur) {return prev.Concat (cur);}); console.log (flatten); // [1, 2, 3, 4, 5, 6]Em uma matriz vazia, chamando ReduD () sem o parâmetro de valor inicial resultará em uma exceção de erro de tipo. Se houver apenas um valor quando é chamado - a matriz possui apenas um elemento e nenhum valor inicial é especificado, ou há uma matriz vazia e um valor inicial é especificado - redução () simplesmente retorna esse valor sem chamar a função simplificada
var arr = []; arr.Reduce (function () {}); // não -descoberto TypeError: Reduce de matriz vazia sem nenhum valuevar inicial arr = []; arr.Reduce (function () {}, 1); // 1Método de escrita compatível de Reduce () Método
if (typeof array.prototype.reduce! = "function") {Array.prototype.Reduce = function (retorno de chamada, InitialValue) {var anterior = inicialValue, k = 0, comprimento = this.length; if (typeof InitialValue === "undefined") {anterior = this [0]; k = 1; k ++) {this.hasownProperty (k) && (anterior = retorno de chamada (anterior, este [k], k, this));}} retornar anterior;};}【ReduceRight ()】
ReduceRight () funciona da mesma forma que Reduce (), a diferença é que ele processa a matriz de alta a baixa (direita para esquerda) de acordo com o índice de matriz, e não de baixo a alto
var valores = [1,2,3,4,5]; var sum = valores.Reduteright (função (prev, cur, índice, array) {console.log (prev, cur); retorno previs + cur;}); console.log (soma); // 5 4 // 9 3 // 12 2 // 14 1 // 15Método ReduceRight () Método de Escrita Compatível
if (typeof Array.prototype.RedUtIrigh! = "function") {Array.prototype.RedUrIright = function (retorno de chamada, InitialValue) {var length = this.length, k = comprimento - 1, anterior = inicial; (k; k> -1; k- = 1) {this.HasownProperty (k) && (anterior = retorno de chamada (anterior, este [k], k, this));}} retornar anterior;};}Método de iteração da matriz
O ECMAScript5 define 5 métodos iterativos para matrizes. Cada método recebe dois parâmetros: a função a ser executada em cada item e o objeto de escopo que (opcional) executa a função - afetando o valor disso. As funções passadas para esses métodos recebem três parâmetros: o valor do item da matriz, a posição do item na matriz e o próprio objeto da matriz. Dependendo do método usado, o valor de retorno após a execução desta função pode ou não afetar o valor de retorno acessado
função (item, índice, array) {// TODO}【mapa()】
O método map () executa uma determinada função em cada item da matriz, retornando uma matriz composta pelos resultados de cada chamada de função
// f é a função chamada por cada elemento da matriz. Seu valor de retorno se torna o elemento da matriz de retorno; o é um valor opcional quando f é chamado de matriz.map (f, o); [1,2,3] .map (função (item, índice, arr) {retornar item*item}); // [1,4,9] [1,2,3] .map (function (item, index, arr) {retornar item*}); // [0,2,6]O método map () também pode aceitar um segundo parâmetro, indicando o objeto apontado por isso quando a função de retorno de chamada é executada
var arr = ['a', 'b', 'c']; [1,2] .map (função (item, índice, arr) {return this [item]}, arr); // ['b', 'c']Ao usá -lo na prática, você pode usar o método map () para facilitar a aquisição de valores de atributo específicos na matriz de objetos
var users = [{name: 't1', e -mail:'[email protected] '}, {name:' t2 ', e -mail:'[email protected]'}, {name: 't3', e -mail:'[email protected] '}]; console.log (users.map (função (item, Índice, ARR) {{ART). "[email protected]", "[email protected]"]O método map () também pode ser usado para objetos de matriz de classe
Array.prototype.map.call ('abc', function (item, index, arr) {return item.TOUPCASE ()}); // ["a", "b", "c"]Para matrizes esparsas, o método map () não chama a função no número da sequência em que o elemento não existe.
var a = [1 ,, 3]; console.log (a.map (função (item, índice, arr) {retornar item*2;})); // [2, 2: 6]Método de mapa () método de escrita compatível
if (typeof Array.prototype.map! = "function") {Array.prototype.map = function (fn, context) {var arr = []; if (typeof fn === "function") {para (var k = 0, thength = this.length; k <length; k ++) {para (fn.cn.cl (fn.cl); arr;};}【Foreach ()】
O método foreach () executa uma determinada função em cada item na matriz, e esse método não retorna um valor. Essencialmente, o mesmo que itera sobre uma matriz para loop. Se você precisar de um valor de retorno, geralmente usa o método do mapa
[1,2,3,4] .ForEach (função (item, índice, arr) {console.log (item)}); // 1 // 2 // 3 // 4Semelhante ao loop for abaixo
var array = [1, 2, 3, 4]; para (var k = 0, comprimento = array.length; k <comprimento; k ++) {console.log (array [k]);}Use o método foreach () para implementar adição simples
var sum = 0; [1, 2, 3, 4] .foreach (função (item, índice, array) {sum += item;}); console.log (soma); // 10Além de aceitar um parâmetro de função de retorno de chamada necessário, o segundo parâmetro também pode aceitar um parâmetro de contexto opcional (altere este ponteiro na função de retorno de chamada)
var out = []; [1, 2, 3] .foreach (function (elem) {this.push (elem * elem);}, out); console.log (out); // [1, 4, 9]O segundo parâmetro é muito útil para várias camadas, porque é uma camada multi-camada que geralmente está apontando inconsistente, você pode usar o segundo parâmetro do método foreach () para corrigir isso
var obj = {nome: 'zhang san', horários: [1, 2, 3], print: function () {// Isso isso aponta para objConsole.log (this); this.Times.ForEach (function (n) {// Isso aponta para windowconsole.log (this);});}}; obj.print (); var obj = {nome: 'zhang san', horários: [1, 2, 3], print: function () {// Isso isso aponta para objConsole.log (this); this.Times.ForEach (function (n) {// Isso também aponta para objConsole.log (this);}, this);}}; obj.print ();foreach () loop pode ser usado para objetos de matriz de classe
var str = 'abc'; array.prototype.foreach.call (str, function (item, índice, array) {console.log (item + ':' + index);}); // a: 0 // b: 1 // c: 2Diferentemente do Loops, para matrizes esparsas, o método foreach () não chama a função no número da ordem em que o elemento não existe.
var a = [1,2,3]; exclua a [1]; para (var i = 0; i <a.length; i ++) {console.log (a [i]);} // 1 // indefinido // 3 A.ForEach (function (item, index, arr) {Console.Log (item)}) // 1 // 3O método foreach () não pode encerrar a travessia antes que todos os elementos sejam passados para a função chamada. Ou seja, não existe uma declaração de interrupção correspondente como a usada no loop for. Se você deseja terminar mais cedo, você deve colocar o método foreach () em um bloco de tentativa e lançar uma exceção
para (var i = 0; i <5; i ++) {if (i == 2) quebra;} console.log (i); // 2 var a = [1,2,3,4,5]; console.log (A.ForEach (FUNCH (IMPLEM, INDEX, ARR) {if (index == 2) quebra; //; var a = [1,2,3,4,5]; A.ForEach (function (item, índice, arr) {try {if (item == 2) lançar novo erro;} catch (e) {console.log (item);}});Método de Foreach () Método de Escrita Compatível
if (typeof Array.prototype.ForEach! = 'function') {Array.prototype.ForEach = function (fn, context) {for (var k = 0, length = this.length; Object.prototype.hasownProperty.Call (this, k)) {fn.call (contexto, este [k], k, this);}}}}}【filtro()】
O método filter () executa uma determinada função em cada item da matriz e retorna uma matriz de itens que retornarão true. Este método é frequentemente usado para consultar todos os itens de matriz que atendem aos critérios
[1, 2, 3, 4, 5] .Filter (função (elem) {return (elem> 3);}); // [4, 5] [0, 1, 'a', false] .Filter (boolean); // [1, "A"] [1, 2, 3, 4, 5] .Filter (function; 3, 5]O método filtro () também pode aceitar um segundo parâmetro, especificando o objeto de contexto (este objeto) em que a função de teste está localizada
var obj = function () {this.max = 3;}; var myFilter = function (item) {if (item> this.max) {return true;}}; var arr = [2, 8, 3, 4, 1, 3, 2, 9]; Arr.Filter (MyFilter, New OBJ ());filtro () pulará elementos ausentes em matrizes esparsas. Sua matriz de retorno é sempre densa, para que possa comprimir as lacunas em matrizes esparsas.
var a = [1,2 ,,, 3 ,,, 4]; console.log (a.Length); // densidade 10VAR = a.filter (function () {return true;}) console.log (dense, dense.length); // [1,2,4] 4Se você deseja comprimir vagas e excluir elementos indefinidos e nulos, você pode usar o método filtro () como este
var a = [1,2,, indefinido ,, 3 ,, null ,, 4]; console.log (a.Length); // densidade 10Var = A.Filter (function (item) {retornar item! = indefinido;}) console.log (densidade, densa.length); // [1,2,2,3,4] 4Método de filtro () método de escrita compatível
if (typeof Array.prototype.Filter! = "function") {Array.Prototype.Filter = function (fn, context) {var arr = []; if (typeof fn === "function") {para (var k = 0, thenght = this.length; k <length; k ++) {fn.call (contextn), th That, this.lenngth; k <length; k ++) {para (fn.call, th That, this.lenngth; Arr.push (este [k]);}} retorna arr;};}【alguns()】
O método alguns () executa uma determinada função em cada item na matriz e, se a função retornar true para qualquer um dos itens, ele retornará true. E se e somente se todos os elementos no valor chamar a função de decisão retornar FALSE, ele retornará falso
a = [1,2,3,4,5]; A. Alguma (função (elem, índice, arr) {return elem%2 === 0;}) // truea.some (isnan); // falseChamar algum método () em uma matriz vazia retornará falsa
[]. Alguma (function () {}); // falseAlguns () método de escrita compatível com o método
if (typeof Array.prototype.some != "function") {Array.prototype.some = function (fn, context) {var passed = false;if (typeof fn === "function") {for (var k = 0, length = this.length; k < length; k++) {if (passed === true) break;passed = !!fn.call(context, this[k], k, this);}}return passed;};}【todo()】
every()方法对数组中的每一项运行给定函数，如果该函数对每一项都返回true，则返回true；只要有一项返回false，则返回false
a = [1,2,3,4,5];a.every(function(elem, index, arr){elem < 10;})//truea.every(function(elem, index, arr){return elem%2 ===0;});//false在空数组上调用every()方法会返回true
[].every(function(){});//trueevery()方法兼容写法
if (typeof Array.prototype.every != "function") {Array.prototype.every = function (fn, context) {var passed = true;if (typeof fn === "function") {for (var k = 0, length = this.length; k < length; k++) {if (passed === false) break;passed = !!fn.call(context, this[k], k, this);}}return passed;};}Resumir
Os métodos de matriz JavaScript são definidos especificamente como gerais, portanto, eles funcionam corretamente não apenas em matrizes reais, mas também em objetos de matriz de classe. Of these 22 methods, all methods except toString() and toLocaleString() are common
可以改变原数组的方法总共有7种：包括unshift()、shift()、push()、pop()这4种栈和队列方法，reverse()和sort()这2种数组排列方法，数组删改方法splice()
The above is the 22 must-learn methods of arrays in JavaScript introduced to you by the editor (recommended). Espero que seja útil para você. Se você tiver alguma dúvida, deixe -me uma mensagem e o editor responderá a você a tempo. Muito obrigado pelo seu apoio ao site wulin.com!