L'ajout d'éléments à un tableau en JavaScript est un problème très simple. JavaScript lui-même fournit un grand nombre de ces fonctions. Nous pouvons utiliser les fonctions appartenant à JS pour ajouter rapidement des éléments au tableau. Cet article résume les méthodes suivantes de JavaScript pour l'ajout de tableau.
La méthode de arr.concat (arr2) a été couramment utilisée pour ajouter un tableau, l'exemple est le suivant:
La copie de code est la suivante:
<script type = "text / javascript">
var arr = nouveau tableau (3);
arr [0] = "Le tableau de test 1 est 1";
arr [1] = "Le tableau de test 1 est 2";
arr [2] = "Le tableau de test 1 est 3";
var arr2 = nouveau tableau (3);
Arr2 [0] = "Le tableau de test 2 est 1";
Arr2 [1] = "Le tableau de test 2 est 2";
Arr2 [2] = "Le tableau de test 2 est 3";
document.write (arr.concat (arr2) + "<br/>");
document.write (arr.concat ("Votre oncle 2", "Votre oncle 3") + "<br/>")
</cript>
Beaucoup de gens ont été confus quant à l'addition et à la suppression des éléments du tableau JS. Maintenant, je vais donner le code de test suivant:
La copie de code est la suivante:
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é; Si le tableau est vide, retournez non défini
var a = [1,2,3,4,5];
var b = a.shift (); // a: [2,3,4,5] b: 1
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); // a: [-2, -1,1,2,3,4,5] b: 7
Remarque: La valeur de retour de test dans IE6.0 est toujours non définie, et la valeur de retour de test dans FF2.0 est 7, donc la valeur de retour de cette méthode n'est pas fiable. Lorsque vous devez utiliser la valeur de retour, vous pouvez utiliser Splice au lieu de cette méthode.
POP: supprimez le dernier élément du tableau d'origine et renvoyez la valeur de l'élément supprimé; Si le tableau est vide, retournez non défini
var a = [1,2,3,4,5];
var b = a.pop (); // a: [1,2,3,4] b: 5 // Si vous n'avez pas besoin de revenir, appelez-le directement
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); // a: [1,2,3,4,5,6,7] b: 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); // a: [1,2,3,4,5] b: [1,2,3,4,5,6,7]
Splice (start, DeleteCount, Val1, Val2, ...): élément DeleteCount de la position de départ, et insérez 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); // même changement
a.splice (0,0, -2, -1); var b = a.Length; // Même décalage
var b = a.splice (A.Length-1,1); // même pop
A.Splice (A.Length, 0,6,7); var b = a.Length; // même poussée
Inverse: inverse le tableau
var a = [1,2,3,4,5];
var b = a.reverse (); // a: [5,4,3,2,1] b: [5,4,3,2,1]
Trie (OrderFunction): Triez le tableau par des paramètres spécifiés
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, 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); // a: [1,2,3,4,5] b: [3,4,5]
join (séparateur): regrouper les éléments du tableau en une chaîne, avec séparateur comme séparateur. Si vous êtes omis, utilisez les virgules comme séparateur par défaut.
var a = [1,2,3,4,5];
var b = a.join ("|"); // a: [1,2,3,4,5] b: "1 | 2 | 3 | 4 | 5"
Voici une autre façon d'utiliser un tableau pour simuler JavastringBuffer pour traiter les chaînes:
/ **
* 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 d'ajout dans 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é:
/ **
* Convertir un tableau en une chaîne divisée par un symbole spécifique
* /
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);
}
Enfin, il y a un test pour des amis qui aiment jouer A.Push.Apply (A, B); Lorsque vous ajoutez des tableaux.
a.push.apply (a, b); Cette façon d'auto-réflexion est cool, et vous n'avez pas besoin d'écrire une boucle pour une boucle, et vous n'avez rencontré aucun problème. Jusqu'à aujourd'hui, je vais rencontrer une fosse lorsque le B Je veux ajouter est un grand tableau.
La copie de code est la suivante:
a = nouveau array ();
b = nouveau tableau (125624);
a.push.apply (a, b);
Le code ci-dessus jette l'exception suivante sous Mac Chrome
Rangeror non cinglé: la taille maximale de la pile d'appels dépassée
Si vous modifiez le tableau en b = nouveau tableau (125623); Ce serait bien d'avoir un élément plus petit. J'ai testé que d'autres navigateurs ont également de grands tableaux pour faire une erreur, mais les valeurs critiques des différents navigateurs sont toujours différentes
La suggestion donnée ici est pour être honnête et pratique, ce qui peut non seulement éviter les problèmes d'exception des grandes tableaux, mais également considérer les performances de Forach comme le plus rapide.