Agregar elementos a una matriz en JavaScript es un problema muy simple. JavaScript en sí proporciona una gran cantidad de tales funciones. Podemos usar las funciones propiedad de JS para agregar elementos rápidamente a la matriz. Este artículo resume los siguientes métodos de JavaScript para la adición de matriz.
El método de arr.concat (arr2) se usó comúnmente para agregar una matriz, el ejemplo es el siguiente:
La copia del código es la siguiente:
<script type = "text/javaScript">
var arrr = nueva matriz (3);
arr [0] = "La matriz de prueba 1 es 1";
arr [1] = "La matriz de prueba 1 es 2";
arr [2] = "La matriz de prueba 1 es 3";
var arr2 = nueva matriz (3);
arr2 [0] = "La matriz de prueba 2 es 1";
arr2 [1] = "La matriz de prueba 2 es 2";
arr2 [2] = "La matriz de prueba 2 es 3";
document.write (arr.concat (arr2)+"<br/>");
document.write (arr.concat ("tu tío 2", "tu tío 3")+"<br/>")
</script>
Muchas personas han sido confundidas sobre la adición y eliminación de los elementos de matriz JS. Ahora daré el siguiente código de prueba:
La copia del código es la siguiente:
var arr = new Array ();
arr [0] = "aaa";
arr [1] = "bbb";
arr [2] = "ccc";
//alert(arr.length) ;//3
arr.pop ();
//alert(arr.length) ;//2
//alert(arr`arr.length-1font>) ;//bbb
arr.pop ();
//alert(arr`arr.length-1font>) ;//aaa
//alert(arr.length) ;//1
var arr2 = new Array ();
//alert(arr2.length) ;//0
arr2 [0] = "aaa";
arr2 [1] = "bbb";
//alert(arr2.length) ;//2
arr2.pop ();
//alert(arr2.length) ;//1
arr2 = arr2.slice (0, arr2.length-1);
//alert(arr2.length) ;//0
arr2 [0] = "aaa";
arr2 [1] = "bbb";
arr2 [2] = "ccc";
arr2 = arr2.slice (0,1);
alerta (arr2.length); // 1
alerta (arr2 [0]); // aaa
alerta (arr2 [1]); // indefinido
Shift: elimine el primer elemento de la matriz original y devuelva el valor del elemento eliminado; Si la matriz está vacía, regrese indefinida
var a = [1,2,3,4,5];
var b = a.shift (); // A: [2,3,4,5] B: 1
Deshift: agregue el parámetro al comienzo de la matriz original y devuelva la longitud de la matriz
var a = [1,2,3,4,5];
var b = a.unshift (-2, -1); // a: [-2, -1,1,2,3,4,5] b: 7
Nota: El valor de retorno de prueba en IE6.0 siempre está indefinido, y el valor de retorno de prueba en FF2.0 es 7, por lo que el valor de retorno de este método no es confiable. Cuando necesite usar el valor de retorno, puede usar Splice en lugar de este método.
Pop: elimine el último elemento de la matriz original y devuelva el valor del elemento eliminado; Si la matriz está vacía, regrese indefinida
var a = [1,2,3,4,5];
var b = a.pop (); // A: [1,2,3,4] B: 5 // Si no necesita regresar, simplemente llámelo directamente
Push: Agregue el parámetro al final de la matriz original y devuelva la longitud de la matriz
var a = [1,2,3,4,5];
var b = a.push (6,7); // A: [1,2,3,4,5,6,7] b: 7
Concat: Devuelve una nueva matriz, que se compone de agregar parámetros a la matriz original.
var a = [1,2,3,4,5];
var b = A.concat (6,7); // A: [1,2,3,4,5] B: [1,2,3,4,5,6,7]
Splice (Start, Deletecount, Val1, Val2, ...): Deletecount elemento desde la posición de inicio e inserte Val1, Val2, ...
var a = [1,2,3,4,5];
var b = a.splice (2,2,7,8,9); // A: [1,2,7,8,9,5] b: [3,4]
var b = a.splice (0,1); // mismo cambio
A.Splice (0,0, -2, -1); var b = a.length; // mismo inhift
var b = a.splice (a.length-1,1); // mismo pop
A.Splice (A.Length, 0,6,7); var b = a.length; // mismo empuje
Reverso: inverso la matriz
var a = [1,2,3,4,5];
var b = a.reverse (); // A: [5,4,3,2,1] b: [5,4,3,2,1]
Sort (OrderFunction): ordene la matriz por parámetros especificados
var a = [1,2,3,4,5];
var b = a.sort (); // A: [1,2,3,4,5] b: [1,2,3,4,5]
Slice (Start, End): devuelve una nueva matriz compuesta de elementos desde el subíndice de inicio especificado al subíndice final en la matriz original.
var a = [1,2,3,4,5];
var b = A.Slice (2,5); // A: [1,2,3,4,5] b: [3,4,5]
unirse (separador): agrupe los elementos de la matriz en una cadena, con separador como separador. Si se omite, use las comas como separador de forma predeterminada.
var a = [1,2,3,4,5];
var b = A.Join ("|"); // A: [1,2,3,4,5] b: "1 | 2 | 3 | 4 | 5"
Aquí hay otra forma de usar la matriz para simular JavastringBuffer para procesar cadenas:
/**
* Función de procesamiento de cadenas
*/
función stringbuffer ()
{
var arr = nueva matriz;
this.append = function (str)
{
arr [arr.length] = str;
};
this.ToString = function ()
{
regresar arr.Join (""); // ping la matriz de anexos en una cadena
};
}
Hoy, de repente descubrí que Join es una buena manera de convertir las matrices en cadenas en la aplicación, por lo que las encapsulé en objetos y utilicé:
/**
* Convierta una matriz en una cadena dividida por un símbolo específico
*/
función ArrayToString (arr, separador)
{
if (! separator) separator = ""; // Si el separador es nulo, estará vacío de forma predeterminada
regresar arr.join (separador);
}
/**
* Encuentra la cadena contenida en la matriz
*/
function arrayFindString (arr, string)
{
var str = arr.join ("");
return str.indexof (cadena);
}
Finalmente, hay una prueba para amigos a los que les gusta jugar A.Push.Aply (A, B); Al agregar matrices.
a.push.apply (a, b); Esta manera autónoma es genial, y no necesita escribir un bucle para el bucle, y no ha encontrado ningún problema. Hasta hoy, me encontraré con un pozo cuando la B que quiero agregar es una gran matriz.
La copia del código es la siguiente:
a = nueva matriz ();
b = nueva matriz (125624);
a.push.apply (a, b);
El código anterior arroja la siguiente excepción bajo Mac Chrome
RangeError no capturado: el tamaño máximo de la pila de llamadas excedido
Si cambia la matriz a B = nueva matriz (125623); Sería bueno tener un elemento más pequeño. Probé que otros navegadores también tienen grandes matrices para cometer un error, pero los valores críticos de diferentes navegadores siguen siendo diferentes.
La sugerencia dada aquí es ser honesto y práctico ForEach, que no solo puede evitar los problemas de excepción de grandes matrices, sino también considerar el rendimiento de Foreach como el más rápido.