nova matriz ()
nova matriz (len)
Nova matriz ([Item0, [Item1, [Item2, ...]]]]
Métodos para usar objetos de matriz:
var objarray = new Array ();
objarray.CoCACT ([Item1 [, Item2 [, ...]] ----------------------------------- -------------------------------------------------------- -------------------------------------------------------- -------------------------------------------------------- ----------------------------------------------- e retornar, A matriz original não é afetada.
Arr.CoCACT ("D", "E");
Retornará uma matriz contendo os elementos da letra de "A" a "E". E o próprio ARR não é afetado.
objarray.join (separador) -------------------------------------------------- -------------------------------------------------------- -------------------------------------------------------- -------------------------------------------------------- -------------------------------------------------------- -------------------------------------------------------- -------------------------------------------------------- -------------------------------------------------------- -------------------------------------------------------- -------------------------------------------------------- ---- )mesmo.
objarray.pop () -------- Nos termos do leigo, é para exibir o último elemento da matriz. Combinado com o seguinte método de push, é possível usar matrizes como pilhas. O método POP retorna o valor do último elemento da matriz e subtrai o atributo de comprimento por 1, ou seja, o último elemento é perdido imediatamente após o retorno.
objarray.push ([valor1 [, value2 [, ...]]]]) --------------------------------- -------------------------------------------------------- -------------------------------------------------------- -------------------------------------------------------- -------------------------------------------------------- Por exemplo: [1,2,3, 4] .push ("a", "b") receberá [1,2,3,4, "a", "b"]
objarray.Reverse () inverte os elementos da matriz. Por exemplo: [1,2,3]. Reverso () receberá [3,2,1].
objarray.shift () ------------ remova o primeiro elemento da matriz e retorne o valor desse elemento. A natureza desse método é muito semelhante ao método pop, que é remover o último elemento.
Objarray.slice (START, END) ------------ Retorne um subconjunto do objeto Array A matriz original não é afetada. Por exemplo: [1,2,3,4,5,6] .Slice (1,4) receberá [2,3,4]. Quando o início ou o fim é negativo, eles são usados para adicionar o valor do comprimento. Por exemplo: [1,2,3,4,5,6] .Slice (-4, -1) receberá [3,4,5]. Se o final for menor ou igual ao início, uma matriz vazia será devolvida.
objarray.sort (comparefn) ------------------------------------------------------ -------------------------------------------------------- ---------------------- A função Comparefn deve aceitar dois parâmetros elemento1 e elemento2. isto é, mantenha o original) retorna 0. Quando comparadosfn é omitido, os elementos são organizados em ordem de dicionário. Por exemplo: para a função de comparação definida CMP: função cmp (e1, e2) {return e1-e2;}, então [3,4,2,7] .Sort (cmp) receberá [2,3,7,7 ].
objarray.splice (Iniciar, DeLeteCount [, Item1, Item2 [, ...]]]]) Esta é uma função complexa para concluir a exclusão, substituição e inserção dos elementos da matriz. Entre eles, o parâmetro inicial indica a posição do índice a ser executada e o DeleteCount refere -se ao número de elementos a serem excluídos do início (incluindo a posição inicial). excluído do início. [, Item1 [, Item2 [, ...]]] significa uma lista opcional de elementos inseridos antes do início. como:
var arr = [0,1,2,3,4,5,6];
Arr.Splice (1,1);
document.write (arr); // mostra "0, 2, 3, 4, 5, 6"
arr = [0,1,2,3,4,5,6];
Arr.Splice (0,0, "A", "B");
document.write (arr); // mostra "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); // mostra "0,1,2, c, d, 5,6"
objarray.unshift (item1 [, item2 [, ...]]]) ----------------------------------- -------------------------------------------------------- --------------------- Suas propriedades e tipo de método push, mas o método push é adicionar elementos ao final da matriz. Por exemplo: [1,2,3,4] .Unshift ("A", "B") receberá ["A", "B", 1,2,3,4].
A adição e a exclusão dos elementos da matriz JS foram 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(arrativamente
Arr.pop ();
//Alert(arrativamente
//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: exclua o primeiro item da matriz original e retorne o valor do elemento excluído;
var a = [1,2,3,4,5];
var B = A.Shift ();
NIFT: Adicione o parâmetro ao início da matriz original e retorne o comprimento da matriz
var a = [1,2,3,4,5];
var B = A.UnShift (-2, -1);
Nota: O valor de retorno do teste no IE6.0 é sempre indefinido e o valor de retorno do teste no FF2.0 é 7, portanto, o valor de retorno desse método não é confiável. deste método.
POP: Exclua o último item da matriz original e retorne o valor do elemento excluído;
var a = [1,2,3,4,5];
var B = A.Pop ();
Push: adicione o parâmetro ao final da matriz original e retorne o comprimento da matriz
var a = [1,2,3,4,5];
var B = A.Push (6,7);
Concat: Retorna uma nova matriz, que é composta de adição de parâmetros à matriz original.
var a = [1,2,3,4,5];
var B = A.Concat (6,7);
Splice (Start, DeleteCount, Val1, Val2, ...): DeleteCount Item da posição inicial e insira Val1, Val2, ...
Ao limpar a matriz, basta passar no startIndex.
Se todos os elementos não forem excluídos, passe o parâmetro DeLeteCound.
A Splice também possui a função de excluir primeiro e depois adicionar, excluir vários elementos e, em seguida, adicione vários elementos na posição excluída. .
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); // mesmo pop
A.Splice (A. Length, 0,6,7);
reverso: inverso a matriz
var a = [1,2,3,4,5];
var B = A.Reverse ();
Class
var a = [1,2,3,4,5];
var B = a.sort ();
Slice (Start, End): Retorna uma nova matriz composta por itens do subscrito inicial especificado para o subscrito final na matriz original.
var a = [1,2,3,4,5];
var B = A.Slice (2,5);
Junte -se (separador): agrupe os elementos da matriz em uma string, com o separador como separador, se omitido, use a vírgula padrão como o separador
var a = [1,2,3,4,5];
var B = A.Join ("|");
Aqui está outra maneira de usar a matriz para simular o JavastringBuffer para processar strings:
A cópia do código é a seguinte:
/**
* Função de processamento de string
*/
function stringbuffer () {
var arr = nova matriz;
this.append = function (str) {
arr [arr.length] = str;
};
this.toString = function () {
retornar arr.join (""); // ping na matriz que anexa em uma string
};
}
Hoje, de repente descobri que a Juns é uma boa maneira de converter matrizes em strings no aplicativo, então as encapsulei em objetos e usei:
A cópia do código é a seguinte:
/**
*Converta matrizes em cordas que são divididas por símbolos específicos
*/
Função ArrayToString (arr, separador) {
se (! separador) separador = ""; // Se o separador for nulo, estará vazio por padrão
retornar arr.Join (separador);
}
/**
* Encontre a string contida na matriz
*/
Função ArrayFindString (arr, string) {
var str = arr.Join ("");
return str.IndexOF (String);
}