presentó los conceptos básicos de las matrices y algunas funciones simples de operación de elementos de la matriz. De hecho, las matrices proporcionan muchas más funciones.
push , pop , shift y unshift son funciones que operan en ambos extremos de la matriz. Se mencionaron anteriormente y no se repetirán en este artículo.
se presentó brevemente en el artículo anterior. Una matriz es un objeto especial, por lo que podemos intentar utilizar el método de eliminación de atributos del objeto: delete .
Por ejemplo:
let arr = [1,2,3,4,5];delete arr[2];console.log(arr);
Los resultados de la ejecución del código son los siguientes:
Preste atención a la posición amarilla en la imagen. Aunque el elemento se ha eliminado, la longitud de la matriz sigue siendo 5 y hay un空adicional en la posición eliminada. Si accedemos al elemento con índice 2 , obtendremos el siguiente resultado:
La razón de este fenómeno es que delete obj.key elimina el valor correspondiente a través key , es decir, delete arr[2] elimina el par clave-valor 2:3 en la matriz. Cuando accedemos al subíndice 2 , undefined está definido. .
En una matriz, a menudo esperamos que después de eliminar un elemento, la posición del elemento se llene con elementos posteriores y la longitud de la matriz se acorte.
En este momento, necesitamos splice() .
debe tenerse en cuenta de antemano que splice() es bastante versátil y no solo elimina elementos. La siguiente es la sintaxis:
arr.splice(start[,deleteCount,e1,e2,...,eN] )
método splice Comenzando desde la posición start , elimine los elementos deleteCount y luego inserte e1,e2,e3 y otros elementos en su lugar.
El siguiente ejemplo puede eliminar un elemento de la matriz:
let arr = [1,2,3,4,5]arr.splice(0,1);//Eliminar el primer elemento 1console.log(arr)
El El código anterior elimina 1 elemento en la primera posición de la matriz. Los resultados de la ejecución son los siguientes:
es lo mismo que eliminar un elemento. Solo necesita cambiar el segundo parámetro al número especificado. Por ejemplo:
let arr = [1,2,3,4,5];arr. ;//Eliminar los primeros tres elementos console.log(arr);//[4,5]
Los resultados de la ejecución del código son los siguientes:
Si solo proporcionamos un parámetro start , se eliminarán todos los elementos después de start de la matriz. Por ejemplo:
let arr = [1,2,3,4,5]arr.splice(2); //Eliminar Console.log(arr);//:La ejecución del código [1,2] resulta
del subíndice 2 y todos los elementos posteriores
Si proporcionamos más de dos parámetros, podemos reemplazar elementos de la matriz, por ejemplo:
let arr = [1,2,3,4,5];arr.splice(0,2,'itm1',' itm2', 'itm3');console.log(arr);//['itm1','itm2','itm3',3,4,5]
Los resultados de la ejecución del código son los siguientes:
El código anterior en realidad realiza una operación de dos pasos: primero elimina 2 elementos a partir de 0 y luego inserta tres nuevos elementos en la posición 0 .
Si cambiamos el segundo parámetro (el número de eliminaciones) a 0 , entonces solo podemos insertar elementos sin eliminar elementos. Por ejemplo:
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]
La función splice() devolverá la matriz de elementos eliminados, por ejemplo:
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 de la ejecución del código:
Podemos usar números negativos para indicar la posición donde comenzar a operar los elementos, por ejemplo:
let arr = [1,2,3,4,5]arr.splice(-1,1,'x','y' ,'z ')console.log(arr)//[1,2,3,4,'x','y','z']
Los resultados de la ejecución del código son los siguientes:
slice() puede interceptar una matriz en un rango específico. La sintaxis es la siguiente:
arr.slice([inicio],[fin])
devuelve una nueva matriz que comienza desde start y termina al end . , pero no incluye end .
Ejemplo:
let arr = [1,2,3,4,5]console.log(arr.slice(2,5))//[3,4,5]console.log(arr.slice(1,3) )//[2,3]
Resultado de la ejecución del código:
slice() también puede usar subíndices 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]
Los resultados de la ejecución del código son los siguientes:
Si proporciona solo un parámetro al método slice() , se truncará hasta el final de la matriz al igual que splice() .
La función concat() puede concatenar múltiples matrices u otros tipos de valores en una matriz larga. La sintaxis es la siguiente:
arr.concat(e1, e2, e3)
El código anterior devolverá una nueva matriz. la nueva matriz está concatenada por arr Está formada por e1 , e2 y e3 .
Ejemplo:
let arr = [1,2,3]console.log(arr.concat([4,5],6,7,[8,9]))
El resultado de la ejecución del código es el siguiente:
Los objetos ordinarios, incluso si tienen el mismo aspecto que los objetos, todavía se insertan en la matriz como un todo, por ejemplo:
let arr = [1,2]let obj = {1:'1',2:2}console.log Resultados de la ejecución del código
(arr.concat(obj)):
Sin embargo, si el objeto tiene la propiedad Symbol.isConcatSpreadable , será tratado como una matriz:
let arr = [1,2]let obj = {0:'x',
1:'y',
[Symbol.isConcatSpreadable]: verdadero,
longitud: 2 }console.log(arr.concat(obj)) resultados de ejecución del código:
atraviesa toda la matriz y proporciona una función de operación para cada elemento de la matriz. Sintaxis:
let arr = [1,2]arr.forEach((itm,idx,array)=>{
...}) Ejemplo de aplicación:
let arr = [1,2,3,4,5]arr.forEach((itm)=>{
resultados de ejecución del código
console.log(itm)}):
let arr = [1,2,3,4,5]arr.forEach((itm,idx,array)=>{
console.log(`arr[${idx}] en [${array}] es ${itm}`)}) resultados de ejecución del código:
son similares a las cadenas. indexOf , lastIndexOf e includes se pueden usar con el subíndice del elemento especificado en la matriz de consulta:
arr.indexOf(itm,start) : itm comenzando desde start . Si lo encuentra, devuelve el subíndice; de lo contrario, devuelve -1 ;arr.lastIndexOf(itm,start) : busca en toda la matriz en orden inverso hasta start y devuelve el primer subíndice encontrado (es decir, el último elemento coincidente en la matriz). Si no se encuentra, devuelve -1 ;arr.includes(itm,start) : itm desde start , devuelve true si lo encuentra; de lo contrario, devuelve false .Ejemplo:
let arr = [1,2,3,4,5, 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
Estos métodos usan === al comparar elementos de la matriz, por lo que false y 0 son diferentes.
Manejo de NaN
NaN es un número especial y existen diferencias sutiles entre los tres en el manejo NaN :
let arr = [NaN,1,2,3,NaN]console.log(arr.includes(NaN))//trueconsole. log( arr.indexOf(NaN))//-1console.log(arr.lastIndexOf(NaN))//-1El
motivo de este resultado está relacionado con las características del propio NaN , es decir, NaN no es igual a ningún número , incluido él mismo.
Estos contenidos se han analizado en los capítulos anteriores. Para los zapatos infantiles olvidados, recuerde revisar el pasado y aprender lo nuevo.
a menudo encuentran matrices de objetos durante el proceso de programación, y los objetos no se pueden comparar directamente usando === . ¿Cómo encontrar objetos que cumplan las condiciones de la matriz?
En este momento, debe utilizar find y findIndex . La sintaxis es la siguiente:
let result = arr.find(function(itm,idx,array){.
// elemento de matriz itm // subíndice del elemento idx // matriz de matriz misma // pasa una función de juicio, si la función devuelve verdadero, devuelve el objeto actual itm}) Por ejemplo, buscamos objetos cuyo atributo name sea igual a xiaoming :
let arr =[
{id:1,nombre:'xiaoming'},
{id:2,nombre:'xiaohong'},
{id:3,nombre:'xiaojunn'},]let xiaoming = arr.find(function(itm,idx,array){
if(itm.name == 'xiaoming')return true;})console.log(xiaoming) resultado de la ejecución del código:
Si no hay ningún objeto que cumpla las condiciones, se devolverá undefined .
El código anterior también se puede simplificar a:
let xiaoming = arr.find((itm)=> itm.name == 'xiaoming').
El efecto de ejecución es exactamente el mismo.
El propósito de arr.findIndex(func) es casi el mismo que el arr.find(func) La única diferencia es que arr.findIndex devuelve el subíndice del objeto calificado en lugar del objeto en sí. -1 .
find y findIndex solo pueden encontrar un objeto que cumpla con los requisitos. Si hay varios objetos que cumplen con los requisitos en una matriz, debe usar filter . La sintaxis es la siguiente:
let results = arr.filter(function(. itm,idx,matriz){
//Mismo uso que buscar, pero devolverá una matriz de objetos que cumplan los requisitos //Si no se encuentra, se devolverá una matriz vacía}) Por ejemplo:
let arr =[
{id:1,nombre:'xiaoming'},
{id:2,nombre:'xiaohong'},
{id:3,nombre:'xiaojunn'},]let res = arr.filter(function(itm,idx,array){
if(itm.name == 'xiaoming' || itm.name == 'xiaohong')return true;})console.log(res) resultado de la ejecución del código:
arr.map puede llamar a una función en cada objeto de la matriz y luego devolver la matriz procesada. Este es uno de los métodos de matrices más útiles e importantes.
Sintaxis:
let arrNew = arr.map(function(itm,idx,array){
//Devuelve nuevo resultado}) Por ejemplo, devuelve la matriz de longitud correspondiente a la matriz de cadenas:
let arr = ['I','am','a','student']let arrNew = arr.map((itm) = >itm.length)//return itm.lengthconsole.log(arrNew)//[1,2,1,7]
resultado de la ejecución del código:
arr.sort ordena la matriz en su lugar y devuelve la matriz ordenada. Sin embargo, dado que la matriz original ha sido modificada, el valor de retorno en realidad no tiene sentido.
La llamada clasificación in situ significa ordenar dentro del espacio de la matriz original en lugar de crear una nueva matriz
let arr = ['a','c','b']arr.sort()console.log(arr)
ejecución del código resultado:
Tenga en cuenta que, de forma predeterminada, el método
sortordena en orden alfabético , lo cual es adecuado para ordenar cadenas. Si desea ordenar otros tipos de matrices, debe personalizar el método de comparación
para matrices numéricas,
let arr = [1,3,2]. ordenar(función(a,b){
si(a > b)devuelve 1;
si (a < b) devuelve -1;
devolver 0;}) Resultado de la ejecución del código:
sort utiliza internamente el algoritmo de clasificación rápida, o puede ser el algoritmo timsort , pero no necesitamos preocuparnos por esto, solo debemos prestar atención a la función de comparación.
La función de comparación puede devolver cualquier valor numérico, un número positivo significa > , un número negativo significa < y 0 significa igual, por lo que podemos simplificar el método de comparación numérica:
sea arr = [1,3,2]arr.sort(( a,b)=> a - b)
Si desea ordenar en orden inverso, simplemente intercambie las posiciones de a y b :
sea arr = [1,3,2]arr.sort((a,b)=> b - a)Clasificación
de cadenas
¿Olvidó utilizar str.localeCompare(str1) para comparar cadenas?
let arr = ['asdfas','success','failures']arr.sort((a,b)=>a.localeCompare (b))
código Resultado de la ejecución:
arr.reverse se usa para matrices inversas
let arr = [1,2,3]arr.reverse()console.log(arr)//[3,2,1]
No hay nada que decir al respecto.
¿Recuerdas la función de división de cadenas? La función de división de cadenas puede dividir la cadena en una matriz de caracteres:
let str = 'xiaoming,xiaohong,xiaoli'let arr = str.split(',')//['xiaoming','xiaohong','xiali'] Impopular conocimiento, la función
splittiene un segundo parámetro, que puede limitar la longitud de la matriz generadalet str = 'xiaoming,xiaohong,xiaoli'let arr = str.split(',',2)//['xiaoming',' xiaohong' ]
El método arr.join() es lo opuesto al método split . Puede combinar una matriz en una cadena.
Por ejemplo:
let arr = [1,2,3]let str = arr.join(';')console.log(str) resultado de la ejecución del código:
arr.reduce es similar al método arr.map . Ambos pasan un método y luego llaman a este método en los elementos de la matriz en secuencia. La diferencia es que cuando app.map procesa los elementos de la matriz, cada uno. La llamada al elemento es independiente y arr.reduce pasará el resultado de la llamada del elemento anterior al método de procesamiento del elemento actual.
Sintaxis:
let res = arr.reduce(function(prev,itm,idx,array){
//prev es el resultado devuelto por la llamada al elemento anterior //init servirá como resultado de la llamada al elemento anterior cuando se ejecute el primer elemento}, [init]) Imagínese cómo implementar la suma de elementos de la matriz compuesta por ¿números? No hay forma de implementar el mapa. En este momento, debe usar arr.reduce :
let arr = [1,2,3,4,5]let res = arr.reduce((sum,itm)=>sum+. itm,0) console.log(res)//15
El proceso de ejecución del código es el siguiente:
arr.reduceRight tiene el mismo propósito que arr.reduce , excepto que los métodos se invocan en elementos de derecha a izquierda.
La matriz es un caso especial de objeto. El uso de typeof no puede distinguir con precisión la diferencia entre los dos:
console.log(typeof {})//objectconsole.log(typeof [])//object Ambos son objetos, nosotros. Es necesario utilizar Array.isArray() para hacer más juicios:
console.log(Array.isArray({}))//falseconsole.log(Array.isArray([]))//true arr.some(func) Los métodos arr.some(func) y arr.every(func) se utilizan para verificar números y el mecanismo de ejecución es similar al map .
algunos
ejecutan el método pasado en cada elemento de la matriz. Si el método devuelve true , devuelve true inmediatamente. Si todos los elementos no devuelven true , devuelve false .
each
ejecuta el método pasado en cada elemento de la matriz y devuelve true si todos los elementos devuelven true ; de lo contrario, devuelve false .
Por ejemplo:
let arr = [1,2,3,4,5]//Determinar si hay elementos mayores que 2 en la matriz console.log(arr.some((itm)=>{
if(itm > 2)return true;}))//true//Determine si todos los elementos son mayores que 2console.log(arr.every((itm)=>{
if(itm > 2)return true;}))//false En todos los métodos de matriz, excepto sort , hay un parámetro fijo poco común thisArg . La sintaxis es la siguiente:
arr.find(func,thisArg)arr.filter(. func,thisArg)arr.map(func,thisArg)
Si pasamos thisArg , se convertirá this en func .
Este parámetro es de poca utilidad en circunstancias normales, pero si func es un método miembro (método de un objeto) y this usa en el método, entonces thisArg será muy significativo.
Por ejemplo:
let obj = {
número: 3,
func(itm){
consola.log(esto)
return itm > this.num;//Buscar números mayores que 3}}let arr = [1,2,3,4,5,6,7]let newArr = arr.filter(obj.func,obj)console.log (newArr) resultado de la ejecución del código:
Aquí podemos ver que this en func es el valor thisArg que pasamos.
Si usamos métodos de miembro de objeto sin especificar el valor de thisArg , this será undefined , lo que resultará en un error de programa.