Résumé des méthodes d'ajout de tableaux dans les compétences javascript_javascript

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 propres fonctions de js pour ajouter rapidement des éléments à un tableau. .Résumé ci-dessous.

Dans le passé, la méthode arr.concat(arr2) était couramment utilisée pour ajouter des tableaux. L'exemple est le suivant :

Copier. code Le code est le suivant :

Beaucoup de gens ont été confus au sujet de l'ajout et de la suppression d'éléments de tableau js. Voici le code de test suivant :

Copier le code Le code est le suivant :

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. longueur-1]);//bbb
arr.pop();
//alert(arr[arr.length-1]);//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);
alerte(arr2.length);//1
alerte(arr2[0]);/ /aaa
alert(arr2[1]);//undéfini
shift : supprime le premier élément du tableau d'origine et renvoie la valeur de l'élément supprimé si le tableau est vide, renvoie undéfini
var ; a = [1,2,3,4,5];
var b = a.shift(); //a: [2,3,4,5] b: 1
unshift : ajouter des paramètres à le début du tableau d'origine et renvoie 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 du test sous IE6.0 est toujours indéfinie et la valeur de retour du test sous FF2.0 est 7, donc la valeur de retour de cette méthode n'est pas fiable, splice peut être utilisée à la place de cette méthode lorsque la valeur de retour est nécessaire.
pop : supprime le dernier élément du tableau d'origine et renvoie la valeur de l'élément supprimé ; si le tableau est vide, il renvoie undé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 des paramètres à la fin du tableau d'origine et renvoie la longueur du tableau
var a = [1,2,3,4,5];
var b = a.push(6,7); [1,2,3,4,5,6, 7] b: 7
concat : renvoie un nouveau tableau, qui est formé en ajoutant des 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,...) : supprimez l'é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); //Identique à shift
a.splice(0,0,-2,-1); //Identique à unshift
var b = a.splice( a.length-1,1); //Identique à pop
a.splice(a.length,0,6,7); //Identique à push
reverse : inverser l'ordre du tableau
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) : Trier le tableau en fonction 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]
tranche (start,end) : renvoie le début spécifié à partir du tableau d'origine. Un nouveau tableau composé d'éléments entre l'indice et l'indice de fin
var a = [1,2,3,4,5]
var b; = a.slice(2,5); //a :[1,2,3,4,5] b:[3,4,5]
join(separator) : Combine les éléments du tableau en un chaîne, avec séparateur comme séparateur. En cas d'omission, la valeur par défaut sera utilisée. Utiliser des virgules comme séparateurs
var a = [1,2,3,4,5]
var b = a.join("| "); //a: [1,2,3,4 ,5] b: "1|2|3|4|5"
Donnez-moi une autre méthode d'utilisation d'un tableau pour simuler javaStringBuffer pour traiter des chaînes :
/**
* Fonction de traitement de chaîne
*/
function StringBuffer()
{
var arr = new Array;
this.append = function(str)
{
arr[ arr.length] = str;
};
this. toString = function()
{
return arr.join(""); //Ping le tableau ajouté dans une chaîne
};
>
Soudain, dans l'application d'aujourd'hui, j'ai découvert que la jointure est un bon moyen de convertir un tableau en chaîne, je l'ai donc encapsulé dans un objet et utilisé :
/**
* Convertir le tableau en une chaîne séparée par des symboles spécifiques
* /
function arrayToString(arr,separator)
{
if(!separator) separator = "";//Si le séparateur est nul, il est vide par défaut
return arr.join(separator);
}
/**
* Rechercher la chaîne contenue dans le tableau
*/
function arrayFindString (arr,string)
{
var str = arr.join("");
return str.indexOf (string);
}

Enfin, certains problèmes surviennent lorsque push.apply s'ajoute à un tableau. Un test pour les amis qui aiment jouer avec a.push.apply. (a, b);
a.push.apply(a, b); C'est une façon d'écrire que je trouve cool et qui ne nécessite pas de boucle for. Je n'ai jamais rencontré de problèmes jusqu'à aujourd'hui lorsque le b. Je souhaite ajouter un très grand tableau et j'ai rencontré un piège.

Copier le code Le code est le suivant :

a = new Array() ; >b = nouveau tableau (125624);                                                         

Le code ci-dessus lève l'exception suivante sous Chrome sur Mac

Uncaught RangeError : taille maximale de la pile d'appels dépassée

Si vous modifiez le tableau en b = new Array(125623); un élément plus petit suffira. Après le test, d'autres navigateurs ont également un problème d'erreur de grands tableaux. , mais différents navigateurs ont des valeurs critiques différentes

La suggestion donnée ici est d'utiliser forEach honnêtement, ce qui peut non seulement éviter le problème anormal des grands tableaux, mais également considérer forEach du point de vue des performances. le plus rapide