Nouveau array ()
Nouveau tableau (len)
Nouveau tableau ([item0, [item1, [item2, ...]]]]
Méthodes pour utiliser des objets de tableau:
var objArray = new Array ();
objarray.concact ([item1 [, item2 [, ...]]] --------------------------------- -------------------------------------------------- -------------------------------------------------- -------------------------------------------------- ----------------------------------------------- Et retour, Le tableau d'origine n'est pas affecté.
arr.concact ("d", "e");
Retournera un tableau contenant les éléments de lettre de "a" à "e". Et Arr lui-même n'est pas affecté.
objarray.join (séparateur) -------------------------------------------- -------------------------------------------------- -------------------------------------------------- -------------------------------------------------- -------------------------------------------------- -------------------------------------------------- -------------------------------------------------- -------------------------------------------------- -------------------------------------------------- -------------------------------------------------- ---- )même.
objarray.pop () -------- En termes de laïc, il s'agit d'apparaître le dernier élément du tableau. Combiné avec la méthode push suivante, il est possible d'utiliser des tableaux comme piles. La méthode POP renvoie la valeur du dernier élément du tableau et soustrait l'attribut de longueur de 1, c'est-à-dire que le dernier élément est perdu immédiatement après le retour.
objarray.push ([valeur1 [, valeur2 [, ...]]]]) ------------------------------- -------------------------------------------------- -------------------------------------------------- -------------------------------------------------- -------------------------------------------------- Par exemple: [1,2,3, 4] .push ("a", "b") obtiendra [1,2,3,4, "a", "b"]
objarray.reverse () inverse les éléments du tableau. Par exemple: [1,2,3] .reverse () obtiendra [3,2,1].
objarray.shift () ------------ Supprimez le premier élément du tableau et renvoyez la valeur de cet élément. La nature de cette méthode est très similaire à la méthode POP, qui est de supprimer le dernier élément.
objarray.slice (start, fin) -------------- Renvoie un sous-ensemble de l'objet de tableau. Le tableau d'origine n'est pas affecté. Par exemple: [1,2,3,4,5,6] .slice (1,4) obtiendra [2,3,4]. Lorsque le démarrage ou la fin est négatif, ils sont utilisés pour ajouter la valeur de longueur. Par exemple: [1,2,3,4,5,6] .slice (-4, -1) obtiendra [3,4,5]. Si la fin est inférieure ou égale au démarrage, un tableau vide sera retourné.
objarray.sort (comparefn) -------------------------------------------- -------------------------------------------------- ------------------ La fonction comparefn doit accepter deux paramètres Element1 et Element2. c'est-à-dire garder celui d'origine) renvoie 0. En fonction de la compréhension, le FN est omis, les éléments sont organisés par ordre de dictionnaire. Par exemple: pour la fonction de comparaison définie CMP: fonction CMP (E1, E2) {return e1-e2;}, alors [3,4,2,7] .sort (cmp) obtiendra [2,3,4,7 ].
objarray.splice (start, deleteCount [, item1, item2 [, ...]]]]) Il s'agit d'une fonction complexe pour compléter la suppression, la substitution et l'insertion des éléments du tableau. Parmi eux, le paramètre de démarrage indique la position d'index à effectuer et DeleteCount fait référence au nombre d'éléments à supprimer du début (y compris la position de début). supprimé depuis le début. [, item1 [, item2 [, ...]]]] signifie une liste facultative des éléments insérés avant de démarrer. comme:
var arr = [0,1,2,3,4,5,6];
Arr.splice (1,1);
document.write (arr); // montre "0, 2, 3, 4, 5, 6"
arr = [0,1,2,3,4,5,6];
arr.splice (0,0, "a", "b");
document.write (arr); // montre "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); // montre "0,1,2, c, d, 5,6"
objarray.unshift (item1 [, item2 [, ...]]]) --------------------------------- -------------------------------------------------- ------------------- Ses propriétés et le type de méthode push, mais la méthode push consiste à ajouter des éléments à la fin du tableau. Par exemple: [1,2,3,4] .unshift ("a", "b") obtiendra ["a", "b", 1,2,3,4].
L'ajout et la suppression des éléments du tableau JS ont été confus.
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-1
arr.pop ();
//alert(arr[arr.length-1
//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);
alerte (arr2.length); // 1
alerte (arr2 [0]); // aaa
alerte (arr2 [1]); // non défini
Shift: supprimez le premier élément du tableau d'origine et renvoyez la valeur de l'élément supprimé;
var a = [1,2,3,4,5];
var b = a.shift ();
Défense: Ajoutez le paramètre au début du tableau d'origine et renvoyez la longueur du tableau
var a = [1,2,3,4,5];
var b = a.unshift (-2, -1);
Remarque: La valeur de retour du test dans IE6.0 est toujours non définie, et la valeur de retour du test dans FF2.0 est 7, donc la valeur de retour de cette méthode n'est pas fiable. de cette méthode.
Pop: supprimez le dernier élément du tableau d'origine et renvoyez la valeur de l'élément supprimé;
var a = [1,2,3,4,5];
var b = a.pop ();
Push: Ajoutez le paramètre à la fin du tableau d'origine et renvoyez la longueur du tableau
var a = [1,2,3,4,5];
var b = a.push (6,7);
CONCAT: Renvoie un nouveau tableau, qui est composé d'ajout de paramètres au tableau d'origine.
var a = [1,2,3,4,5];
var b = a.concat (6,7);
Splice (start, DeleteCount, Val1, Val2, ...): élément DeleteCount de la position de départ, et insérez Val1, Val2, ...
Lorsque vous nettoyez le tableau, passez simplement le startIndex.
Si tous les éléments ne sont pas supprimés, passez le paramètre DeleteCount.
Splice a également la fonction de supprimer d'abord, puis de supprimer plusieurs éléments, puis d'ajouter plusieurs éléments à la position supprimée. .
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); // même pop
A.Splice (A.Legth, 0,6,7);
Inverse: inverse le tableau
var a = [1,2,3,4,5];
var b = a.reverse ();
Trie (OrderFunction): Triez le tableau par des paramètres spécifiés
var a = [1,2,3,4,5];
var b = a.sort ();
Slice (start, fin): renvoie un nouveau tableau composé d'éléments de l'indice de démarrage spécifié à l'indice de fin dans le tableau d'origine.
var a = [1,2,3,4,5];
var b = a.slice (2,5);
join (séparateur): regrouper les éléments du tableau dans une chaîne, avec séparateur comme séparateur, si omis, utilisez la virgule par défaut comme séparateur
var a = [1,2,3,4,5];
var b = a.join ("|");
Voici une autre façon d'utiliser un tableau pour simuler JavastringBuffer pour traiter les chaînes:
La copie de code est la suivante:
/ **
* Fonction de traitement des chaînes
* /
fonction stringbuffer () {
var arr = nouveau tableau;
this.append = fonction (str) {
arr [arr.length] = str;
};
this.toString = function () {
return arr.join (""); // ping le tableau qui ajoute en une chaîne
};
}
Aujourd'hui, j'ai soudainement découvert que JOIN est un bon moyen de convertir les tableaux en chaînes dans l'application, donc je les ai encapsulés en objets et utilisé:
La copie de code est la suivante:
/ **
* Convertir les tableaux en chaînes divisées par des symboles spécifiques
* /
fonction arraytoString (arr, séparateur) {
si (! séparateur) séparateur = ""; // Si le séparateur est nul, il sera vide par défaut
return arr.join (séparateur);
}
/ **
* Trouvez la chaîne contenue dans le tableau
* /
fonction arrayFindString (arr, string) {
var str = arr.join ("");
return str.indexof (string);
}