Las palabras anteriores
Hay 22 métodos en la matriz. Este artículo los divide en métodos de herencia de objetos, métodos de conversión de matriz, métodos de pila y cola, métodos de clasificación de matriz, métodos de empalme de matriz, métodos de creación de subarrías, métodos de deleción de matriz, métodos de posición de matriz, métodos de combinación de matriz y métodos de iteración de matriz en detalle.
Método de herencia de objetos
La matriz es un objeto especial que hereda los métodos toString (), tolocaleString () y valueOf () del objeto objeto.
【ToString ()】
El método toString () devuelve una cadena separada por comas empalmada de la forma de cadena de cada valor en la matriz.
[Nota] El valor de retorno de este método es el mismo que la cadena devuelta llamando al método unión () sin ningún parámetros.
[1,2,3] .ToString (); // '1,2,3' ['A', 'B', 'C']. ToString (); // 'A, B, C' [1, [2, 'C']]. ToString (); // '1,2, C'
Dado que alerta () desea recibir parámetros de cadena, llamará al método toString () en segundo plano y obtendrá el mismo resultado que el método toString ()
alerta ([1,2,3]); // '1,2,3'
【TolocalEstring ()】
TOLOCALECRING () es una versión localizada del método ToString (), que a menudo devuelve el mismo valor que el método ToString (), pero no siempre es el caso. Porque, llama al elemento, el método TOLOCALECRING () convierte cada elemento de matriz en una cadena
var persona1 = {tolocaleString: function () {return 'nikolaos';}, toString: function () {return 'nikolas';}}; var persona2 = {tolocaleString: function () {return 'grigorios';}, toString: function () {return 'greg';}}; var pueblo = [Person1, Person2]; Console.log (People.ToString ()); // 'Nikolas, Greg'Console.log (People.TolocalEstring ()); //' Nikolas, Grigorios 'Si el valor de un elemento en la matriz es nulo o indefinido, el valor se representa como una cadena vacía en los resultados devueltos por los métodos TolocalEstring () y toString ().
Var Colors = [1, Undefined, 2, Null, 3]; console.log (Colors.ToString ()); // '1 ,, 2 ,, 3'Console.log (Colors.TolocalEstring ()); //' 1 ,, 2, 3 '
【Valor de ()】
El método valueOf () devuelve el objeto de matriz en sí mismo
var a = [1, 2, 3]; console.log (a.valueOf ()); // [1, 2, 3] console.log (a.valueOf () instancia de matriz); // true
Método de conversión de matriz
【unirse()】
El método Array.Join () es una operación inversa del método String.split (), que divide la cadena en varios bloques para crear una matriz.
Los métodos TOLOCALECRING () y ToString () heredados por las matrices devolverán los elementos de la matriz en caracteres separados por comas de forma predeterminada; El método Join () puede usar diferentes delimitadores para construir esta cadena. El método Join () solo recibe un parámetro, que se usa como delimitador, y luego devuelve una cadena que contiene todos los elementos de matriz.
Si no se pasa ningún valor al método Join (), use una coma como separador
var a = [1,2,3]; console.log (a.Join ()); // '1,2,3'console.log (a.Join (' ')); //' 1 2'console.log (a.Join ('')); // 123'var b = nuevo Array (10); B.Join ('-'); // '----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------Si el parámetro del método Join () no está definido, el navegador estándar devuelve la cadena con una coma como separador, y el navegador IE7 devuelve la cadena con 'indefinido' como el separador.
// El navegador estándar es '1,2,3'; Ie7-el navegador está '1undefinado 2undefined3'var a = [1,2,3]; console.log (A.Join (indefinido));
Si el valor de un elemento en la matriz es nulo o indefinido, el valor se representa como una cadena vacía en el resultado devuelto por el método Join ()
Var Colors = [1, indefinido, 2, nulo, 3]; console.log (colores.Join ()); // '1 ,, 2 ,, 3'
Este método también se puede usar en objetos de matriz de clases
console.log (array.prototype.join.call ('hello', '-')); // "hello" var obj = {0: 'a', 1: 'b', longitud: 2}; console.log (array.prototype.join.call (obj, '-'); // 'ab'[Nota] Si el objeto no tiene un atributo de longitud, no es una matriz de clase y no se puede llamar al método de matriz
var obj = {0: 'a', 1: 'b'}; console.log (typeof array.prototype.join.call (obj, '-')); // ''Métodos de pila y cola
Los métodos push () y pop () permiten que las matrices se usen como pilas. El comportamiento de los métodos Unshift () y Shift () es muy similar a Push () y Pop (). La diferencia es que el primero inserta y elimina elementos en la cabeza de la matriz en lugar de en la cola.
La pila es una estructura de datos LIFO (última por primera vez, más adelante en primer lugar), es decir, el último elemento agregado se elimina lo antes posible. La inserción (llamada empuje) y la eliminación (llamada ventana emergente) de elementos en la pila solo ocurre en una ubicación: la parte superior de la pila. JavaScript proporciona métodos push () y pop () específicamente para matrices para lograr un comportamiento similar a la pila
La regla de acceso para la estructura de datos de la cola es FIFO (primera en primera salida, primera vez, primera vez). La cola agrega elementos al final de la lista y elimina los elementos del frente de la lista. Usando los métodos shift () y push () en combinación, puede usar matrices como colas
【empujar()】
El método push () puede recibir cualquier número de parámetros, agregarlos uno por uno al final de la matriz y devolver la longitud de la matriz modificada. Entonces, la matriz cambiará la 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', true,}]] 4console.log (a, a.push ([5,6])); // [1, 'a', true, {}, [5,6]] 5Si necesita fusionar dos matrices, puede usar el método Aplicar
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] Si usa el método de llamada, la matriz B se considerará como un parámetro en su conjunto
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
El método push () también puede agregar elementos al objeto, y el objeto agregado se convierte en un objeto de matriz, es decir, el índice de la matriz correspondiente de la clave del elemento recién agregado, y el objeto tiene un atributo de longitud
var obj = {a: 1}; console.log (obj, []. push.call (obj, 2)); // {a: 1, 0: 2, longitud: 1} console.log (obj, []. push.call (obj, [3])); // {a: 1, 0: 2, 1: [3], longitud: 2}【estallido()】
El método pop () elimina el último elemento del final de la matriz, reduce el valor de longitud de la matriz y devuelve el elemento eliminado. Entonces, la matriz cambiará la matriz original
var a = ['a', 'b', 'c']; console.log (a, a.pop ()); // ['A', 'B'] 'C'
El uso del método pop () para matrices vacías no informará un error, pero devolverá indefinido
var a = []; console.log (a, a.pop ()); // [] indefinido
【cambio()】
El método shift () elimina el primer elemento en la matriz y devuelve el elemento, mientras que la longitud de la matriz se reduce en 1. Por lo tanto, la matriz cambiará la matriz original
var a = ['a', 'b', 'c']; console.log (a, a.shift ()); // ['b', 'c'] 'a'
Use el método shift () para matrices vacías, y no se informará ningún error, pero devolverá indefinido
var a = []; console.log (a, a.shift ()); // [] indefinido
【Unchift ()】
El método Unshift () agrega cualquier elemento en el extremo frontal de la matriz y devuelve la nueva longitud de la matriz. Entonces, la matriz cambiará la matriz original
var a = ['a', 'b', 'c']; console.log (a, a.unshift ('x')); // ['x', 'a', 'b', 'c'] 4Cuando no se llama () con múltiples parámetros, los parámetros se insertan a la vez en lugar de uno a la vez. Esto significa que el orden de los elementos insertados en la matriz final es consistente con su orden en la 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] En IE7-Browser, el método unshift () devuelve siempre indefinido
// En el navegador estándar, return [1] 1; y en el navegador IE7, return [1] UndefinedVar a = []; console.log (a, a.unshift (1));
Método de clasificación de matriz
Hay dos métodos en la matriz que se pueden usar para reordenar directamente: reverse () y sort ()
【contrarrestar()】
El método inverso () se usa para revertir el orden de la matriz y devolver la matriz ordenada; y el orden de matriz original también ha cambiado.
var array = [1,2,4,3,5]; console.log (array, array.reverse ()); // [5,3,4,2,1] [5,3,4,4,2,1] var array = ['str', true, 3]; console.log (array, array.reverse (); // [3, verdadero, 'str'] [3, verdadero, 'str']
【clasificar()】
Por defecto, el método Sort () organiza elementos de matriz en orden ascendente de cadenas. El método de clasificación llamará al método ToString () de cada elemento de matriz, y luego comparará la clasificación de cadena resultante para devolver la matriz ordenada, y el orden de matriz original también cambia.
var array = [1,2,4,3,5]; console.log (array, array.sort ()); // [1,2,3,4,5] [1,2,2,4,4,5] var array = ['3str', 3,2, '2']; console.log (array, array.sort ()); // [2 ", 2", 3, "3Str"; varía (array (array, array, array.sort ()); // [2 ", 2", 3, "3Str"; Varay (Varray (Array, Array, Array.Sort ()); // [2 ", 2", 3, "ACRAY.LOG" [1,5,10,50]; console.log (array, array.sort ()); // [1, 10, 5, 50]
Si la matriz contiene elementos indefinidos, se colocan al final de la matriz
var array = ['3', 3, indefinido, 2, '2']; console.log (array, array.sort ()); // ["2", 2, "3", 3, indefinido] ["2", 2, "3", 3, indefinido]]
El método sort () puede aceptar una función de comparación como un argumento para especificar qué valor está precedido por qué valor. La función de comparación recibe dos parámetros, devuelve un número negativo si el primer parámetro debe ser antes del segundo parámetro, devuelve 0 si los dos parámetros son iguales y devuelve un número positivo si el primer parámetro debe ser después del segundo parámetro
función compare (value1, value2) {if (value1 <value2) {return -1;} else if (value1> value2) {return 1;} else {return 0;}} var array = ['5px', 50,1,10]; // Cuando el número es más grande que la cadena, la cadena '5px' se convertirá en NAN, y el resultado es falso seconsole.log (Array.sort (comparar)); // ["5px", 1, 10, 50]Para los tipos numéricos o el método ValueOf (), la función de comparación puede simplificar el tipo de objeto del tipo numérico.
función 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.sort (compare)); // [1,5,10,10]Si una matriz de cadenas se realiza una clasificación de alfabeto insensible, la función de comparación primero convierte los parámetros en cadenas minúsculas y luego comienza la comparación
a = ['Ant', 'Bug', 'Cat', 'Dog']; A.Sort (); // ['Bug', 'Dog', 'Ant', 'Cat']; a.sort (function (s, t) {var a = s.tolowercase (); var b = t.tolowercase (); if (a <b) regreso -1; if (a> b) regreso 1; regreso; 0;}); // ['hormiga', 'insecto', 'gato', 'perro']【Consejos】 Cree una matriz aleatoria utilizando el método sort ()
función 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 ()】
El método concat () crea una nueva matriz basada en todos los elementos en la matriz actual. Primero cree una copia de la matriz actual, luego agregue los parámetros recibidos al final de la copia y finalmente devuelve la matriz recién construida. Por lo tanto, concat () no afecta la matriz original
Si el parámetro no se pasa al método concat (), simplemente copia la matriz actual; Si el parámetro es una o más matrices, el método agrega cada elemento en estas matrices a la matriz de resultados; Si el valor aprobado no es una matriz, estos valores simplemente se agregan al final de la matriz de resultados
var numeros = [1,2]; console.log (números, números.concat (3,4)); // [1,2] [1,2,3,4] console.log (números, números [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]]
Si no se proporcionan parámetros, el método concat () devuelve una copia superficial de la matriz actual. La llamada "copia superficial" significa que si el miembro de la matriz incluye un valor de tipo compuesto (como un objeto), la nueva matriz copia una referencia al valor.
// Este método en realidad solo copia la primera dimensión de la matriz. The first dimension of the array stores the reference of the second dimension, and the second dimension actually stores their content var numbers = [1,2];var newNumbers = numbers.concat();console.log(numbers,newNumbers);//[1,2] [1,2]numbers[0] = 0;console.log(numbers,newNumbers);//[0,2] [1,2]var numbers = [[1,2]]; var newnumbers = números
El método concat () también se puede usar para fusionar objetos en matrices, pero debe hacerse con el 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); // 1Crear método de subarray
【rebanada()】
El método Slice () crea una nueva matriz basada en uno o más elementos en la matriz actual, acepta uno o dos parámetros, es decir, para devolver las posiciones de inicio y finalización del elemento, y finalmente devolver la nueva matriz, por lo que Slice () no afecta la matriz original
El método Slice (Start, End) requiere dos parámetros Inicio y FIN, que devuelve una subarrray en esta matriz desde la posición de inicio hasta (pero no contiene) la posición final; Si el final está indefinido o no existe, devuelve todos los elementos desde la posición de inicio hasta el final de la matriz
Si el inicio es un número negativo, inicio = max (longitud + inicio, 0)
Si el final es un número negativo, end = max (longitud + final, 0)
El inicio y el final no pueden intercambiar posiciones
Si no hay parámetros, vuelva a la matriz original
números var = [1,2,3,4,5]; console.log (números.slice (2)); // [3,4,5] console.log (números.slice (2, indefinido)); // [3,4,5] consol E.Log (números.slice (2,3)); // [3] console.log (números.slice (2,1)); // [] console.log (números.slice (-3)); //-3+5 = 2 -> [3,4,5] console.log (números.slice (-8)); // max (5 + -8,0) = 0 -> [1,2,3,4,5] console.log (números.slice (0, -3)); // -3 + 5 = 2 ->> [1,2] console.log (números.slice (-2, -1)); //-2+5 = 3; -1+5 = 4; -> [4]
Si no se proporcionan parámetros, el método SLICE () devuelve una copia superficial de la matriz actual
// Este método en realidad solo copia la primera dimensión de la matriz. La primera dimensión de la matriz almacena la referencia de la segunda dimensión, y la segunda dimensión en realidad almacena su contenido var números = [1,2]; var newnumbers = números.slice (); console.log (números, newnumbers); // [1,2] [1,2] números [0] = 0; console.log (números, newnumbers); /// [0,2] [1,2] números [0] = 0; console [[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]]
El método SLICE () implica la conversión de tipo implícita de la función de transformación de número (). Cuando el inicio se convierte en NAN, es equivalente a comenzar = 0; Cuando el extremo se convierte en nan (excepto que el final está indefinido), se emite una matriz vacía
números var = [1,2,3,4,5]; console.log (números sole.log (números.slice (nulo, indefinido)); // [1,2,3,4,5] console.log (números.slice ({})); // [1,2,3,4,5] console.log (números.slice ('2', [5])); // [3,4,5]Puede usar el método SLICE () para convertir el objeto de matriz de clases en una matriz real
var arr = array.prototype.slice.call (arraylike); array.protype.slice.call ({0: 'a', 1: 'b', longitud: 2}) // ['a', 'b']Método de eliminación de matriz
【empalme()】
Splice () y Slice () tienen nombres muy similares, pero sus funciones son esencialmente diferentes. El método Splice () se usa para eliminar parte de la matriz original y puede agregar nuevos miembros de la matriz en la ubicación eliminada. Este método cambiará la matriz original.
Splice () devuelve una matriz compuesta de elementos eliminados, o una matriz vacía si no se devuelven elementos eliminados.
El primer parámetro de Splice () Start especifica la posición de inicio para la inserción o eliminación. Si el inicio es un número negativo, inicio = max (longitud + inicio, 0); Si el inicio es nan, es equivalente a iniciar = 0
Si solo se proporciona un elemento, es equivalente a dividir la matriz original en dos matrices en la ubicación especificada
var a = [1,2,3,4,5,6,7,8]; console.log (a, a.splice ()); // [1,2,3,4,5,6,7,7,8] [] var a = [1,2,3,4,5,6,6,7,8]; console.log (A, a.splice (4)); // [1,3,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] var = [1,2,3,4,5,6,7,8]; console.log (a, a.splice (nan)); // [] [1,2,3,4,5,6,7,8]
El segundo número de parámetro especifica el número de elementos que deben eliminarse de la matriz. Si se omite el segundo parámetro, se eliminarán todos los elementos desde el punto de inicio hasta el final de la matriz. Si el número es negativo o nan o indefinido, número = 0, por lo que el elemento no se elimina
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,3,4,5,6,7,8]; console.log (A, plato (10,2)); /// [1,2,3,4,5,6,7,8] [] var a = [1,2,3,4,5,6,7,8]; console.log (A, A.Splice (1,100)); // [1] [2,3,4,5,6,7,8] var = [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.splice (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,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] []
Si hay más parámetros más adelante, significa que estos son los nuevos elementos que se insertarán en la 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)); // [1,2, [1,2], 3,5,5] ['A', 'B']
Método de posición de matriz
ES5 agrega dos métodos de posición a las instancias de matriz: indexOf () y lastindexof ()
【IndexOf ()】
IndexOf (búsqueda, inicio) El método recibe dos parámetros de búsqueda e inicio, devolviendo la ubicación donde aparece la búsqueda por primera vez, y si no se encuentra, devuelve -1
El parámetro de búsqueda indica el elemento a buscar; Use el operador de igualdad estricto (===) para comparar
var arr = [1,2,3, '1', '2', '3']; console.log (arr.indexof ('2')); // 4console.log (arr.indexof (3)); // 2console.log (arr.indexof (0)); //-1El parámetro de inicio indica la posición de inicio de la búsqueda. Este método llama implícitamente la función de transformación número () para convertir los valores de inicio no numéricos (excepto indefinidos) en números. Si este parámetro se ignora o si el parámetro está indefinido o nan, inicio = 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 person = {name: 'Nicholas'};var people = [{name: 'Nicholas'}];var morePeople = [person];alert(people.indexOf(person));//-1, because although person and people[0] have the same values, they are two references alert(morePeople.indexOf(person));//0, because person and morepeople[0] are the same reference alerta (MorePeople.Indexof ({Nombre: 'Nicholas'})); //-1, porque no son la misma referenciaMétodo de escritura compatible del 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, longitud = this.length; k <longitud; k ++) {if (k> = fromIndex && this [k] === SearchElement) {index = k; break;}} Index de retorno;};}【Lastindexof ()】
A diferencia de IndexOf (), LastIndexof () se ve de derecha a izquierda
El método LastIndexof (Search, Start) recibe dos parámetros Búsqueda e Inicio, devolviendo la ubicación donde aparece la búsqueda por primera vez, y si no se encuentra, devuelve -1
El parámetro de búsqueda indica el elemento a buscar; Use el operador de igualdad estricto (===) para comparar
var arr = [1,2,3, '1', '2', '3']; console.log (arr.lastindexof ('2'))); // 4console.log (arr.lastindexof (3)); // 2console.log (arr.lastinDexof (0)); //-1Inicio significa la posición de inicio de la búsqueda, que implícitamente llama a la función de transformación número () para convertir los valores de inicio no numéricos (excepto indefinidos) en números. Si este parámetro se ignora o si el parámetro está indefinido o nan, inicio = 0
A diferencia del método LastIndexof () de una cadena, cuando el método de búsqueda es un número negativo, search = max (0, longitud+búsqueda)
var arr = [['a', ',' b ',' c ',' d ',' e ',', 'a', 'b']; console.log (arr.lastIndexof ('b', 6console.log (arr.lastIndexOf ('b', inventivo)); //-1console.log (arr.lastinDinDindoxof ('a', u ndefined)); // 0console.log (arr.lastindexof ('b', nan)); //-1console.log (arr.lastindexof ('b', 1)); // 1console.log (arr.lastindexof ('b',-1)); // max (0, -1+7) = 6; 6console.log (arr.lastindexof ('b',-5)); // max (0, -5+7) = 2; 1console.log (arr.lastindexof ('b',-50)); // max (0, -50+7) = 0; -1【Consejos】 Devuelva todos los valores de índice de elementos que cumplen con los criterios
Todos los elementos coincidentes se pueden encontrar mediante bucle para llamar a IndexOf () o LastIndexOf ()
función allindexof (array, value) {var result = []; var Pos = array.indexof (valor); if (pos === -1) {return -1;} while (pos> -1) {result.push (pos); pos = array.indexof (value, pos+1);} return;} var array = = [1,2,3,3,2,1]; console.log (AllIndexof (matriz, 1)); // [0,5]Método de escritura compatible del método LastIndexof ()
if (typeof array.prototype.lastindexof! = "function") {array.prototype.lastindexof = function (searchElement, fromIndex) {var index = -1, longitud = this.length; fromIndex = fromIndex * 1 || Longitud - 1; para (var k = longitud - 1; k> -1; k- = 1) {if (k <= fromIndex && this [k] === SearchElement) {index = k; break;}} índice de retorno;};}Método de combinación de matriz
Los métodos de fusión de matriz incluyen métodos reduce () y reductoright (). Utilizan la función especificada para combinar elementos de matriz para generar un valor único. Esta es una operación común en la programación funcional, también conocida como "inyección" y "colapso"
【reducir()】
El método Reder () requiere dos parámetros. La primera es una función que realiza operaciones simplificadas. La tarea de simplificar las funciones es utilizar algún método para combinar o restar dos valores en un valor y devolver el valor simplificado.
La función simplificada acepta cuatro parámetros, a saber:
【1】 Variable inicial, predeterminada al valor del primer elemento de la matriz. El valor de retorno después de la primera ejecución de la función se usa como la variable inicial para la segunda ejecución de la función, y así sucesivamente
【2】 La variable actual, si se especifica el segundo parámetro, la variable es el valor del primer elemento de la matriz, de lo contrario, el valor del segundo elemento es el valor del segundo elemento.
【3】 El índice de los elementos correspondientes a la variable actual en la matriz (a partir de 0)
【4】 Objeto de matriz original
Entre estos cuatro parámetros de la función simplificada, solo se requieren los dos primeros, mientras que los dos últimos son opcionales.
valores.reduce (function (anterior, cur, índice, array) {// tODO});El segundo parámetro (opcional) del método reded () es un valor inicial que se pasa a la función
var a = [1,2,3,4,5]; var sum = a.reduce (function (x, y) {return x+y}, 0); // suma de matriz var product = a.reduce (function (x, y) {return x*y}, 1); // encontrar producto de array var max = a.reduce (function (x, y) {return (x> y); y;} 2, 3, 4, 5] .reduce (function (anterior, cur) {console.log (anterior, cur) return prev + cur;}); // 1 2 // 3 3 // 6 4 // 10 5 // último resultado: 15 [1, 2, 3, 4, 5] .reduce (function (curs, cur) {console.log (previo); return Prev + cur;}, 0); 3 // 6 4 // 10 5 // Último resultado: 15[Nota] El tipo de resultado de retorno del método Rede () es el mismo que el valor inicial aprobado en
[1, 2, 3, 4, 5] .Reduce (function (anterior, cur) {console.log (previo, cur); prevalos = prevalos + cur; return prev;}, {suma: 0}); // 0 1 // 1 2 // 3 3 // 6 4 // 10 5 // Objeto {sum: 15}Utilizando el método Rede (), puede escribir un método de suma para la suma de las matrices
Array.prototype.sum = function () {return this.reduce (function (anterior, cur) {return prev + cur;})}; [3,4,5,6,10] .sum (); // 28Dado que el método Reduce procesa cada elemento en secuencia, en realidad se puede usar para buscar un elemento. Por ejemplo, encuentre el elemento de matriz más largo
function findLongest (entradas) {return entries.reduce (function (anterior, cur) {return cur.length> prev.length? Cur: prev;}, '');} console.log (findLongest ([1,2,3, 'ab', 4, 'bcd', 5,6785,4]); /// 'bcd' 'Puede usar el método Red () para lograr el aplanamiento de las matrices bidimensionales
var matrix = [[1, 2], [3, 4], [5, 6]]; // matriz 2d Flatten Var Flatten = matrix.reduce (function (previo, cur) {return prev.concat (cur);}); console.log (flatten); // [1, 2, 3, 4, 5, 6]En una matriz vacía, llamar a Reduce () sin el parámetro de valor inicial dará como resultado una excepción de error de tipo. Si solo hay un valor cuando se llama, la matriz solo tiene un elemento y no se especifica ningún valor inicial, o hay una matriz vacía y se especifica un valor inicial: reduzca () simplemente devuelve ese valor sin llamar a la función simplificada
var arr = []; arr.reduce (function () {}); // typeError no capturado: reducir la matriz vacía sin valuevar inicial arr = []; arr.reduce (function () {}, 1); // 1Método de escritura compatible de método reduce ()
if (typeof array.prototype.reduce! = "function") {array.protype.reduce = function (llamado, inicialValue) {var anterior = inicialValue, k = 0, longitud = this.length; if (typeOf InitialValue === "no define") {anterior = this [0]; k = k = 1;} if (typeOf Callback === " longitud;【Reduceright ()】
Reduceright () funciona igual que reducir (), la diferencia es que procesa la matriz de alta a baja (derecha a izquierda) de acuerdo con el índice de matriz, en lugar de bajo a alto
valores var = [1,2,3,4,5]; var sum = valores.reduceright (function (anterior, cur, index, array) {console.log (previo, cur); return prev + cur;}); console.log (sum); // 5 4 // 9 3 // 12 2 // 14 1 // 15Método Reduceright () Método de escritura compatible
if (typeof array.prototype.reduceright! = "function") {array.prototype.reduceright = function (llameBack, inicialValue) {var longitud = this.length, k = longitud - 1, anterior = initialValue; if (typeOf InitialValue === "Indefinado") {anterior [longitud - 1]; k -; if ((((typeOf Function ") {for (k; k> -1; k- = 1) {this.hasownproperty (k) && (anterior = callback (anterior, this [k], k, this));}} return anterior;};}Método de iteración de matriz
ECMAScript5 define 5 métodos iterativos para matrices. Cada método recibe dos parámetros: la función para ejecutarse en cada elemento y el objeto de alcance que (opcional) ejecuta la función, lo que afecta el valor de esto. Las funciones pasadas a estos métodos reciben tres parámetros: el valor del elemento de la matriz, la posición del elemento en la matriz y el objeto de matriz en sí. Dependiendo del método utilizado, el valor de retorno después de la ejecución de esta función puede o no afectar el valor de retorno accedido
función (elemento, índice, matriz) {// toDo}【mapa()】
El método map () ejecuta una función dada en cada elemento de la matriz, devolviendo una matriz compuesta por los resultados de cada llamada de función
// F es la función llamada por cada elemento de la matriz. Su valor de retorno se convierte en el elemento de la matriz de retorno; o es un valor opcional cuando f se llama array.map (f, o); [1,2,3] .map (función (item, índice, arr) {return item*item}); // [1,4,9] [1,2,3] .map (función (item, index, arr) {return item*index}); // [0,2,6]El método map () también puede aceptar un segundo parámetro, indicando el objeto señalado por esto cuando se ejecuta la función de devolución de llamada
var arr = ['a', 'b', 'c']; [1,2] .map (función (item, index, arr) {return this [item]}, arr); // ['b', 'c']Al usarlo en la práctica, puede usar el método MAP () para facilitar la adquisición de valores de atributo específicos en la matriz de objetos
Var users = [{name: 't1', correo electrónico:'[email protected] '}, {name:' t2 ', correo electrónico:'[email protected]'}, {name: 't3', correo electrónico:'[email protected] '}]; console.log (ussers.map (función (elemento, índice, arr) {return item.email})); /// "[email protected]", "[email protected]"]El método map () también se puede utilizar para objetos de matriz de clases
Array.prototype.map.call ('ABC', function (item, index, arr) {return item.touppercase ()}); // ["a", "b", "c"]Para matrices dispersas, el método MAP () no llama a la función en el número de secuencia donde el elemento realmente no existe.
var a = [1 ,, 3]; console.log (a.map (function (item, index, arr) {return item*2;})); // [2, 2: 6]Método de map () Método de escritura compatible
if (typeof array.prototype.map! = "function") {array.protype.map = function (fn, context) {var arr = []; if (typeof fn === "function") {for (var k = 0, longitud = this.length; k <longitud; k ++) {arr.push (fn.call (context, this [k], k, K, esto, esto); arr;};}【Foreach ()】
El método foreach () ejecuta una función dada en cada elemento en la matriz, y este método no devuelve un valor. Esencialmente lo mismo que iterando sobre una matriz para bucle. Si necesita un valor de devolución, generalmente usa el método de mapa
[1,2,3,4] .ForEach (función (item, index, arr) {console.log (item)}); // 1 // 2 // 3 // 4Similar al bucle for a continuación
Var array = [1, 2, 3, 4]; para (var k = 0, longitud = array.length; k <longitud; k ++) {console.log (array [k]);}Use el método foreach () para implementar una adición simple
var sum = 0; [1, 2, 3, 4] .ForEach (función (item, index, array) {sum += item;}); console.log (suma); // 10Además de aceptar un parámetro de función de devolución de llamada necesario, el segundo parámetro también puede aceptar un parámetro de contexto opcional (cambie este puntero en la función de devolución de llamada)
var out = []; [1, 2, 3] .ForEach (function (elem) {this.push (elem * elem);}, out); console.log (out); // [1, 4, 9]El segundo parámetro es muy útil para esto multicapa, debido a que la capa múltiple esto generalmente apunta inconsistente, puede usar el segundo parámetro del método foreach () para solucionar esto
var obj = {nombre: 'zhang san', tiempos: [1, 2, 3], print: function () {// Esto señala objconsole.log (this); this.times.forEach (function (n) {// Esto señala WindowConsole.log (this);});}}; obj.print (); var obj = {name: 'zhang san', tiempos: [1, 2, 3], print: function () {// Esto señala objconsole.log (this); this.times.forEach (function (n) {// Esto también señala objconsole.log (this);}, this);}}; obj.print ();El bucle foreach () se puede usar para objetos de matriz de clases
var str = 'abc'; array.prototype.forach.call (str, function (item, index, array) {console.log (item + ':' + index);}); // a: 0 // b: 1 // c: 2A diferencia de los bucles, para matrices dispersas, el método foreach () no llama a la función en el número de pedido donde el elemento realmente no existe.
var a = [1,2,3]; eliminar a [1]; para (var i = 0; i <a.length; i ++) {console.log (a [i]);} // 1 // indefinido // 3 a.forach (function (item, index, arr) {console.log (item)}); // 1/3El método foreach () no puede terminar el recorrido antes de que todos los elementos pasen a la función llamada. Es decir, no hay una declaración de ruptura correspondiente como la utilizada en el bucle for. Si desea terminar temprano, debe poner el método foreach () en un bloque de try y lanzar una excepción
for (var i = 0; i <5; i ++) {if (i == 2) break;} console.log (i); // 2 var a = [1,2,3,4,5,5]; console.log (a.ForEach (function (item, index, arr) {if (index == 2) break; // sintaxerror: sintaxerror: ilegal break thatado}); var a = [1,2,3,4,5]; a.forEach (function (item, index, arr) {try {if (item == 2) tire nuevo error;} capt (e) {console.log (item);}});método foreach () método de escritura compatible
if (typeof array.prototype.forach! = 'function') {array.prototype.forEach = function (fn, context) {for (var k = 0, longitud = this.length; k <longitud; k ++) {if (typeOf fn === 'function' && Objeto.prototype.hasownproperty.call (this, k)) {fn.call (context, this [k], k, this);}}}}}【filtrar()】
El método Filter () ejecuta una función dada en cada elemento en la matriz y devuelve una matriz de elementos que devolverán verdadero. Este método a menudo se usa para consultar todos los artículos de matriz que cumplan con los criterios.
[1, 2, 3, 4, 5] .filter (function (elem) {return (elem> 3);}); // [4, 5] [0, 1, 'a', falso] .filter (boolean); // [1, "a"] [1, 2, 4, 4, 5] .filter (function (function (elem, elem, int) {regreso Índice % % %= 3, 5]El método filtre () también puede aceptar un segundo parámetro, especificando el objeto de contexto (este objeto) donde se encuentra la función de prueba
var obj = function () {this.max = 3;}; var myFilter = function (item) {if (item> this.max) {return true;}}; var arr = [2, 3, 4, 1, 3, 2, 9]; arr.filter (myFilter, new obj ()); // [8, 4, 9]Filtro () saltará elementos faltantes en matrices dispersas. Su matriz de retorno siempre es densa, por lo que puede comprimir los huecos en matrices dispersas.
var a = [1,2 ,,,, 3 ,,, 4]; console.log (a.length); // 10var densidad = a.filter (function () {return true;}) console.log (dense, dense.length); // [1,2,4] 4 4] 4Si desea comprimir vacantes y eliminar elementos indefinidos y nulos, puede usar el método Filter () como este
var a = [1,2, indefinido ,, 3 ,, nulo ,, 4]; console.log (a.length); // 10var densidad = a.filter (function (item) {return item! = Undefined;}) console.log (dense, dense.length); // [1,2,3,4] 4 4Método Filter () Método de escritura compatible
if (typeof array.prototype.filter! = "function") {array.protype.filter = function (fn, context) {var arr = []; if (typeof fn ==== "function") {para (var k = 0, longitud = this.length; k <longitud; k ++) {fn.call (context, este [k], esto) arr.push (this [k]);}} return arr;};}【alguno()】
El método Some () ejecuta una función dada en cada elemento en la matriz, y si la función devuelve verdaderas para cualquiera de los elementos, devuelve verdadero. Y si y solo si todos los elementos en el valor llaman a la función de decisión devuelven falso, devuelve falso
a = [1,2,3,4,5]; a.some (función (elem, índice, arr) {return elem%2 === 0;}) // truea.Some (isnan); // falsoLlamar al método () en una matriz vacía devolverá falso
[] .some (function () {}); // falsoSome () Método Método de escritura compatible
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;};}【cada()】
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
Los métodos de matriz de JavaScript se definen específicamente como generales, por lo que funcionan correctamente no solo en matrices reales sino también en objetos de matriz de clase. 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 te sea útil. Si tiene alguna pregunta, déjame un mensaje y el editor le responderá a tiempo. ¡Muchas gracias por su apoyo al sitio web de Wulin.com!