nueva matriz ()
nueva matriz (Len)
nueva matriz ([item0, [item1, [item2, ...]]]]
Métodos para usar objetos de matriz:
var obJarray = new Array ();
objarray.concact ([item1 [, item2 [, ...]] --------------------------------- -------------------------------------------------- -------------------------------------------------- -------------------------------------------------- ----------------------------------------------- y regreso, La matriz original no se ve afectada.
arr.concact ("d", "e");
Devolverá una matriz que contiene los elementos de la carta de "a" a "e". Y arr en sí no se ve afectado.
objarray.join (separador) -------------------------------------------- -------------------------------------------------- -------------------------------------------------- -------------------------------------------------- -------------------------------------------------- -------------------------------------------------- -------------------------------------------------- -------------------------------------------------- -------------------------------------------------- -------------------------------------------------- ---- )mismo.
objarray.pop () -------- En términos de laicos, es aparecer el último elemento de la matriz. Combinado con el siguiente método de empuje, es posible usar matrices como pilas. El método POP devuelve el valor del último elemento de la matriz y resta el atributo de longitud por 1, es decir, el último elemento se pierde inmediatamente después de regresar.
objarray.push ([value1 [, value2 [, ...]]]) --------------------------------- -------------------------------------------------- -------------------------------------------------- -------------------------------------------------- -------------------------------------------------- Por ejemplo: [1,2,3, 4] .push ("A", "B") obtendrá [1,2,3,4, "A", "B"]
objarray.reverse () invertida los elementos en la matriz. Por ejemplo: [1,2,3] .Reverse () obtendrá [3,2,1].
objarray.hift () ------------ Elimine el primer elemento de la matriz y devuelva el valor de este elemento. La naturaleza de este método es muy similar al método POP, que es eliminar el último elemento.
objArray.slice (inicio, finalización) ------------- Devuelve un subconjunto del objeto de matriz. La matriz original no se ve afectada. Por ejemplo: [1,2,3,4,5,6].. Ellice (1,4) obtendrá [2,3,4]. Cuando el inicio o el final es negativo, se usan para agregar el valor de longitud. Por ejemplo: [1,2,3,4,5,6] .lice (-4, -1) obtendrá [3,4,5]. Si el final es menor o igual para comenzar, se devolverá una matriz vacía.
objarray.sort (comparar) -------------------------------------------- -------------------------------------------------- ------------------ La función comparable debe aceptar dos parámetros Element1 y Element2. es decir, mantenga el original) Devuelve 0. Cuando se omite en comparación, los elementos se organizan en orden de diccionario. Por ejemplo: para la función de comparación definida CMP: función cmp (e1, e2) {return e1-e2;}, entonces [3,4,2,7] .sort (cmp) obtendrá [2,3,4,7 ]
objarray.splice (Start, Deletecount [, item1, item2 [, ...]]]]) Esta es una función compleja para completar la eliminación, la sustitución y la inserción de los elementos de matriz. Entre ellos, el parámetro de inicio indica la posición de índice que se realizará, y Deletecount se refiere al número de elementos que se eliminarán del inicio (incluida la posición de inicio). eliminado desde el inicio. [, item1 [, item2 [, ...]]]] significa una lista opcional de elementos insertados antes del inicio. como:
var arr = [0,1,2,3,4,5,6];
arr.splice (1,1);
document.write (arr); // show "0, 2, 3, 4, 5, 6"
arr = [0,1,2,3,4,5,6];
arr.splice (0,0, "a", "b");
document.write (arr); // show "a, b, 0,1,2,3,4,5,6"
arr = [0,1,2,3,4,5,6];
arr.splice (3,2, "c", "d");
document.write (arr); // show "0,1,2, c, d, 5,6"
objarray.unshift (item1 [, item2 [, ...]]]) --------------------------------- -------------------------------------------------- ------------------- Sus propiedades y tipo de método de empuje, pero el método de empuje es agregar elementos al final de la matriz. Por ejemplo: [1,2,3,4] .unshift ("A", "B") obtendrá ["A", "B", 1,2,3,4].
La adición y la eliminación de los elementos de la matriz JS han sido confusos.
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;
var a = [1,2,3,4,5];
var b = a.shift ();
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);
Nota: El valor de retorno de la prueba en IE6.0 siempre está indefinido, y el valor de retorno de la prueba en FF2.0 es 7, por lo que el valor de retorno de este método no es confiable. de este método.
Pop: elimine el último elemento de la matriz original y devuelva el valor del elemento eliminado;
var a = [1,2,3,4,5];
var b = a.pop ();
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);
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);
Splice (Start, Deletecount, Val1, Val2, ...): Deletecount elemento desde la posición de inicio e inserte Val1, Val2, ...
Al borrar la matriz, simplemente pase el inicioindex.
Si no se eliminan todos los elementos, pase el parámetro Deletecount.
El empalme también tiene la función de eliminar primero y luego agregar, es decir, eliminar varios elementos primero, y luego agregar varios elementos en la posición eliminada. .
var a = [1,2,3,4,5];
var B = A.Splice (2,2,7,8,9);
var b = a.splice (0,1);
A.Splice (0,0, -2, -1);
var b = a.splice (a.length-1,1); // mismo pop
A.Splice (A.Length, 0,6,7);
Reverso: inverso la matriz
var a = [1,2,3,4,5];
var b = A.Reverse ();
Sort (OrderFunction): ordene la matriz por parámetros especificados
var a = [1,2,3,4,5];
var b = a.sort ();
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);
unirse (separador): agrupe los elementos de la matriz en una cadena, con separador como separador, si se omite, use la coma predeterminada como separador
var a = [1,2,3,4,5];
var b = A.Join ("|");
Aquí hay otra forma de usar la matriz para simular JavastringBuffer para procesar cadenas:
La copia del código es la siguiente:
/**
* Función de procesamiento de cadenas
*/
función stringBuffer () {
var arr = nueva matriz;
this.append = function (str) {
arr [arr.length] = str;
};
this.ToString = function () {
devolver arr.join (""); // ping la matriz que se agrega 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é:
La copia del código es la siguiente:
/**
*Convierta las matrices en cadenas divididas por símbolos específicos
*/
función ArrayToString (arr, separator) {
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);
}