introduziu os conceitos básicos de arrays e algumas funções simples de operação de elementos de array. Na verdade, os arrays fornecem muito mais funções.
push , pop , shift e unshift são funções que operam em ambas as extremidades do array. Elas foram mencionadas acima e não serão repetidas neste artigo.
foi brevemente apresentada no artigo anterior. Um array é um objeto especial, então podemos tentar usar o método de exclusão de atributos do objeto: delete .
Por exemplo:
let arr = [1,2,3,4,5];delete arr[2];console.log(arr);
Os resultados da execução do código são os seguintes:
Preste atenção na posição amarela na imagem Embora o elemento tenha sido excluído, o comprimento da matriz ainda é 5 e há um空extra na posição excluída. Se acessarmos o elemento com índice 2 , obteremos o seguinte resultado:
A razão para esse fenômeno é que delete obj.key remove o valor correspondente por meio de key , ou seja, delete arr[2] exclui o par chave-valor 2:3 do array. Quando acessamos o subscrito 2 , ele é undefined .
Em um array, muitas vezes esperamos que após a exclusão de um elemento, a posição do elemento seja preenchida pelos elementos subsequentes e o comprimento do array se torne menor.
Neste momento, precisamos splice() .
precisa ser observado com antecedência que splice() é bastante versátil e não exclui apenas elementos. A sintaxe é a seguinte:
arr.splice(start[,deleteCount,e1,e2,...,eN] )
método splice Começando na posição start , exclua os elementos deleteCount e insira e1,e2,e3 e outros elementos no lugar.
O exemplo a seguir pode excluir um elemento do array:
let arr = [1,2,3,4,5]arr.splice(0,1);//Excluir o primeiro elemento 1console.log(arr)
O o código acima exclui 1 elemento na primeira posição da matriz. Os resultados da execução são os seguintes:
é o mesmo que excluir um elemento. Você só precisa alterar o segundo parâmetro para o número especificado. Por exemplo:
let arr = [1,2,3,4,5];arr. ;//Exclua os três primeiros elementos console.log(arr);//[4,5]
Os resultados da execução do código são os seguintes:
Se fornecermos apenas um parâmetro start , todos os elementos após start do array serão excluídos
. //Excluir Console.log(arr);//[1,2]:resultados de execução de código
do subscrito 2 e todos os elementos subsequentes
Se fornecermos mais de dois parâmetros, podemos substituir os elementos do array, por exemplo:
let arr = [1,2,3,4,5];arr.splice(0,2,'itm1',' itm2', 'itm3');console.log(arr);//['itm1','itm2','itm3',3,4,5]
Os resultados da execução do código são os seguintes:
Na verdade, o código acima executa uma operação em duas etapas, primeiro excluindo 2 elementos começando em 0 e depois inserindo três novos elementos na posição 0 .
Se alterarmos o segundo parâmetro (o número de exclusões) para 0 , só poderemos inserir elementos sem excluir elementos. Por exemplo:
let arr = [1,2,3,4,5]arr.splice( 0, 0,'x','y','z')console.log(arr);//['x','y','z'1,2,3,4,5]
A função splice() retornará a matriz do elemento excluído, por exemplo:
let arr = [1,2,3,4,5]let res = arr.splice(0,3,'x','y' ) console.log(arr)//['x','y',4,5]console.log(res)//[1,2,3]
Resultados da execução do código:
Podemos usar números negativos para indicar a posição onde começar a operar os elementos, por exemplo:
let arr = [1,2,3,4,5]arr.splice(-1,1,'x','y' ,'z ')console.log(arr)//[1,2,3,4,'x','y','z']
Os resultados da execução do código são os seguintes:
slice() pode interceptar um array em um intervalo especificado. A sintaxe é a seguinte:
arr.slice([start],[end])
start end novo array. , mas não inclui end .
Exemplo:
deixe arr = [1,2,3,4,5]console.log(arr.slice(2,5))//[3,4,5]console.log(arr.slice(1,3) )//[2,3]
Resultado da execução do código:
slice() também pode usar subscritos negativos:
let arr = [1,2,3,4,5]console.log(arr.slice(-3))//[3,4,5]console.log(arr . slice(-5,-1))//[1,2,3,4]
Os resultados da execução do código são os seguintes:
Se você fornecer apenas um parâmetro para o método slice() , ele será truncado até o final do array, assim como splice() .
A função concat() pode concatenar vários arrays ou outros tipos de valores em um array longo. A sintaxe é a seguinte:
arr.concat(e1, e2, e3)
O código acima retornará um novo array, e o novo array é concatenado por arr É formado por e1 , e2 e e3 .
Exemplo:
let arr = [1,2,3]console.log(arr.concat([4,5],6,7,[8,9]))
O resultado da execução do código é o seguinte:
Objetos comuns, mesmo que tenham a mesma aparência de objetos, ainda são inseridos no array como um todo, por exemplo:
let arr = [1,2]let obj = {1:'1',2:2}console.log (arr.concat(obj)) resultados de execução de código:
Porém, se o objeto possuir a propriedade Symbol.isConcatSpreadable , ele será tratado como um array:
let arr = [1,2]let obj = {0:'x',
1: 'sim',
[Symbol.isConcatSpreadable]:verdadeiro,
length:2 }console.log(arr.concat(obj)) resultados de execução de código:
percorre todo o array e fornece uma função de operação para cada elemento do array:
let arr = [1,2]arr.forEach((itm,idx,array)=>{.
...}) Exemplo de aplicação:
let arr = [1,2,3,4,5]arr.forEach((itm)=>{
console.log(itm)}) resultados de execução de código:
deixe arr = [1,2,3,4,5]arr.forEach((itm,idx,array)=>{
console.log(`arr[${idx}] em [${array}] é ${itm}`)}) resultados de execução de código:
são semelhantes a strings indexOf , lastIndexOf e includes podem ser usados com o subscrito do elemento especificado na matriz de consulta:
arr.indexOf(itm,start) : pesquise itm começando na posição start . Se encontrado, retorne o subscrito, caso contrário, retorne -1 ;arr.lastIndexOf(itm,start) : Pesquise todo o array na ordem inversa até start e retorne o primeiro subscrito encontrado (ou seja, o último item correspondente no array). Se não for encontrado, retorne -1 ;arr.includes(itm,start) : Procure itm na posição start , retorne true se encontrado, caso contrário, falsefalse
;
6,"7","8","9" ,0,0,true,false]console.log(arr.indexOf(0))//9console.log(arr.lastIndexOf(0))//10console. log(arr.includes(10))//falseconsole. log(arr.includes(9))//false
Esses métodos usam === ao comparar elementos do array, então false e 0 são diferentes.
Manipulação de NaN
NaN é um número especial e há diferenças sutis entre os três na manipulação NaN :
let arr = [NaN,1,2,3,NaN]console.log(arr.includes(NaN))//trueconsole. log( arr.indexOf(NaN))//-1console.log(arr.lastIndexOf(NaN))//-1O
motivo deste resultado está relacionado às características do próprio NaN , ou seja, NaN não é igual a nenhum número , incluindo ele mesmo.
Esses conteúdos foram discutidos nos capítulos anteriores. Para calçados infantis esquecidos, lembre-se de rever o passado e aprender o novo.
geralmente encontram matrizes de objetos durante o processo de programação e os objetos não podem ser comparados diretamente usando === .
Neste momento, você precisa usar find e findIndex . A sintaxe é a seguinte:
let result = arr.find(function(itm,idx,array){.
//elemento do array itm //subscrito do elemento idx //array em si //passa uma função de julgamento, se a função retornar verdadeiro, retorna o objeto atual itm}) Por exemplo, procuramos objetos cujo atributo name é igual a xiaoming :
deixe arr =[
{id:1,nome:'xiaoming'},
{id:2,nome:'xiaohong'},
{id:3,nome:'xiaojunn'},]let xiaomiing = arr.find(function(itm,idx,array){
if(itm.name == 'xiaoming')return true;})console.log(xiaoming) resultado da execução do código:
Se não houver nenhum objeto que atenda às condições, será retornado undefined .
O código acima também pode ser simplificado para:
let xiaomiing = arr.find((itm)=> itm.name == 'xiaoming')
.
O propósito de arr.findIndex(func) é quase o mesmo que arr.find(func) A única diferença é que arr.findIndex retorna o subscrito do objeto qualificado em vez do próprio objeto. -1 .
find e findIndex só podem encontrar um objeto que atenda aos requisitos. Se houver vários objetos que atendam aos requisitos em uma matriz, você precisará usar filter . A sintaxe é a seguinte:
let results = arr.filter(function(). itm,idx,matriz){
//Mesmo uso que find, mas retornará um array de objetos que atendem aos requisitos //Se não for encontrado, um array vazio será retornado}) Por exemplo:
let arr =[
{id:1,nome:'xiaoming'},
{id:2,nome:'xiaohong'},
{id:3,nome:'xiaojunn'},]deixe res = arr.filter(function(itm,idx,array){
if(itm.name == 'xiaoming' || itm.name == 'xiaohong')return true;})console.log(res) resultado da execução do código:
arr.map pode chamar uma função em cada objeto do array e então retornar o array processado. Este é um dos métodos de arrays mais úteis e importantes.
Sintaxe:
deixe arrNew = arr.map(function(itm,idx,array){
//Retorna novo resultado}) Por exemplo, retorne a matriz de comprimento correspondente à matriz de string:
let arr = ['I','am','a','student']let arrNew = arr.map((itm) = >itm.length)//return itm.lengthconsole.log(arrNew)//[1,2,1,7]
resultado da execução do código:
arr.sort classifica o array no lugar e retorna o array classificado. No entanto, como o array original foi alterado, o valor de retorno não tem sentido.
A chamada classificação no local significa classificar dentro do espaço do array original em vez de criar um novo array
let arr = ['a','c','b']arr.sort()console.log(arr)
execução de código resultado:
Observe que, por padrão, o método
sortclassifica em ordem alfabética , o que é adequado para classificação de strings. Se desejar classificar outros tipos de arrays, você precisa personalizar o método de comparação
para arrays numéricos,
let arr = [1,3,2] . arr.classificar(função(a,b){
se(a > b)retornar 1;
se(a <b)retornar -1;
return 0;}) Resultado da execução do código:
sort usa o algoritmo quick sort internamente, ou pode ser o algoritmo timsort , mas não precisamos nos preocupar com isso, só precisamos prestar atenção à função de comparação.
A função de comparação pode retornar qualquer valor numérico, um número positivo significa > , um número negativo significa < e 0 significa igual, então podemos simplificar o método de comparação numérica:
let arr = [1,3,2]arr.sort(( a,b)=> a - b)
Se você quiser classificar na ordem inversa, basta trocar as posições de a e b :
let arr = [1,3,2]arr.sort((a,b)=> b - a)Classificação
de strings
Esqueceu
de usar str.localeCompare(str1) para comparação de strings?
(b))
resultado da execução do código:
arr.reverse é usado para matrizes reversas
let arr = [1,2,3]arr.reverse()console.log(arr)//[3,2,1]
Não há nada a dizer sobre isso.
Lembra da função de divisão de strings? A função de divisão de string pode dividir a string em uma matriz de caracteres:
let str = 'xiaoming,xiaohong,xiaoli'let arr = str.split(',')//['xiaoming','xiaohong','xiali'] Impopular conhecimento, a função
splitpossui um segundo parâmetro, que pode limitar o comprimento do array geradolet str = 'xiaoming,xiaohong,xiaoli'let arr = str.split(',',2)//['xiaoming',' xiaohong']
O método arr.join() é o oposto do método split . Ele pode combinar um array em uma string.
Por exemplo:
let arr = [1,2,3]let str = arr.join(';')console.log(str) resultado da execução do código:
arr.reduce app.map semelhante ao método arr.map . Ambos passam um método e então chamam esse método nos elementos do array em sequência. a chamada do elemento é independente e arr.reduce passará o resultado da chamada do elemento anterior para o método de processamento do elemento atual.
Sintaxe:
deixe res = arr.reduce(function(prev,itm,idx,array){
//prev é o resultado retornado pela chamada do elemento anterior //init servirá como resultado da chamada do elemento anterior quando o primeiro elemento for executado}, [init]) Imagine como implementar a soma dos elementos do array composto por números? Não há como implementar o mapa neste momento, você precisa usar arr.reduce :
let arr = [1,2,3,4,5]let res = arr.reduce((sum,itm)=>sum+. itm,0) console.log(res)//15
O processo de execução do código é o seguinte:
arr.reduceRight tem o mesmo propósito que arr.reduce , exceto que os métodos são chamados nos elementos da direita para a esquerda.
Array é um caso especial de objeto. Usar typeof não consegue distinguir com precisão a diferença entre os dois:
console.log(typeof {})//objectconsole.log(typeof [])//object Ambos são objetos, nós precisa usar Array.isArray() para fazer julgamentos adicionais:
console.log(Array.isArray({}))//falseconsole.log(Array.isArray([]))//true arr.some(func) Os métodos arr.some(func) e arr.every(func) são usados para verificar números e o mecanismo de execução é semelhante ao map .
some
executa o método passado em cada elemento da matriz. Se o método retornar true , ele retornará true imediatamente. Se todos os elementos não retornarem true , ele retornará false .
each
executa o método passado em cada elemento do array, retornando true se todos os elementos retornarem true , caso contrário, retorna false .
Por exemplo:
deixe arr = [1,2,3,4,5]//Determine se existem elementos maiores que 2 no array console.log(arr.some((itm)=>{
if(itm > 2)return true;}))//true//Determina se todos os elementos são maiores que 2console.log(arr.every((itm)=>{
if(itm > 2)return true;}))//false Em todos os métodos de array, exceto sort , existe um parâmetro fixo incomum thisArg . A sintaxe é a seguinte:
arr.find(func,thisArg)arr.filter(. func,thisArg)arr.map(func,thisArg)
Se passarmos thisArg , então ele se tornará this em func .
Este parâmetro é de pouca utilidade em circunstâncias normais, mas se func for um método membro (método de um objeto) e this usado no método, então thisArg será muito significativo.
Por exemplo:
deixe obj = {
número: 3,
função(itm){
console.log(este)
return itm > this.num;//Encontre números maiores que 3}}let arr = [1,2,3,4,5,6,7]let newArr = arr.filter(obj.func,obj)console.log (newArr) resultado da execução do código:
Aqui podemos ver que this em func é o valor thisArg que passamos.
Se usarmos métodos de membros do objeto sem especificar o valor de thisArg , this será undefined , resultando em um erro de programa.