Zusammenfassung der Methoden zum Anhängen von Arrays in javascript_javascript-Kenntnissen

Das Hinzufügen von Elementen zu einem Array in JavaScript ist ein sehr einfaches Problem. JavaScript selbst bietet eine große Anzahl solcher Funktionen. Wir können die eigenen Funktionen von js verwenden, um schnell Elemente zu einem Array hinzuzufügen . Zusammenfassung unten.

In der Vergangenheit wurde häufig die Methode arr.concat(arr2) zum Anhängen von Arrays verwendet. Das Beispiel lautet wie folgt:

Kopieren Code Der Code lautet wie folgt:

Viele Leute waren verwirrt über das Hinzufügen und Löschen von js-Array-Elementen. Hier ist der folgende Testcode :

Code kopieren Der Code lautet wie folgt:

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. //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);
alert(arr2.length);//1
alert(arr2[0]);/ /aaa
alert(arr2[1]);//undefiniert
shift: lösche das erste Element des ursprünglichen Arrays und gib den Wert des gelöschten Elements zurück, wenn das Array leer ist, gib undefinierte
var zurück a = [1 ,2,3,4,5];
var b = a.shift(); //a: [2,3,4,5] b: 1
unshift: Parameter hinzufügen der Anfang des ursprünglichen Arrays und gibt die Länge des Arrays zurück
var a = [1,2,3,4,5]; /a: [-2,- 1,1,2,3,4,5] b: 7
Hinweis: Der Testrückgabewert unter IE6.0 ist immer undefiniert, und der Testrückgabewert unter FF2.0 ist immer undefiniert 7, daher ist der Rückgabewert dieser Methode unzuverlässig. Wenn der Rückgabewert benötigt wird, kann Splice anstelle dieser Methode verwendet werden.
pop: löscht das letzte Element des ursprünglichen Arrays und gibt den Wert des gelöschten Elements zurück; wenn das Array leer ist, wird undefiniert zurückgegeben
var a = [1,2,3,4,5]
var b = a.pop(); //a：[1,2,3,4] b：5 //Wenn Sie nicht zurückkehren müssen, rufen Sie es einfach direkt auf
push: Parameter hinzufügen zu das Ende des ursprünglichen Arrays und die Länge des Arrays zurückgeben
var a = [1,2,3,4,5]; [1,2,3,4,5,6, 7] b: 7
concat: Gibt ein neues Array zurück, das durch Hinzufügen von Parametern zum ursprünglichen Array gebildet wird
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öschen Sie das deleteCount-Element von der Startposition und fügen Sie val1, val2,... ein
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); //Gleich wie shift
a.splice(0,0,-2,-1); unshift
var b = a.splice( a.length-1,1); //Gleiche wie pop
a.splice(a.length,0,6,7); //Dasselbe wie push
reverse: Umkehren der Array-Reihenfolge
var a = [1,2,3,4,5]; //a：[5 ,4,3,2,1] b：[5 ,4,3,2,1]
sort(orderfunction): Sortieren Sie das Array gemäß den angegebenen Parametern
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,end): Gibt den angegebenen Anfang aus dem ursprünglichen Array zurück. Ein neues Array bestehend aus Elementen zwischen dem Index und dem Endindex
var a = [1,2,3,4,5]; = a.slice(2,5); //a :[1,2,3,4,5] b:[3,4,5]
join(separator): Kombiniere die Elemente des Arrays zu a Zeichenfolge, mit Trennzeichen als Trennzeichen. Wenn es weggelassen wird, wird die Standardeinstellung verwendet. Verwenden Sie Kommas als Trennzeichen
var a = [1,2,3,4,5];
var b = a.join("| "); //a: [1,2,3,4 ,5] b: "1|2|3|4|5"
Geben Sie mir eine andere Methode zur Verwendung eines Arrays zur Simulation von javaStringBuffer zur Verarbeitung von Zeichenfolgen:
/**
* String-Verarbeitungsfunktion
*/
function StringBuffer()
{
var arr = new Array;
this.append = function(str)
{
arr[ arr.length] = str;
};
this. toString = function()
{
return arr.join(""); //Ping das angehängte Array in einen String
};
/
function arrayToString(arr,separator)
{
if(!separator) Separator = "";//Wenn Separator null ist, ist es standardmäßig leer
return arr.join(separator);
}
/**
* Konvertieren Sie das Array in eine durch bestimmte Symbole getrennte Zeichenfolge
*/
function arrayFindString (arr,string)
{
var str = arr.join("");
return str.indexOf (string);
}



Schließlich treten einige Probleme auf, wenn push.apply an ein Array angehängt wird. Ein Test für Freunde, die gerne mit a.push.apply spielen (a, b);
a.push.apply(a, b); Dies ist eine Schreibweise, die ich cool finde und die keine for-Schleife erfordert, bis heute, als die b Ich möchte ein sehr großes Array anhängen und bin auf eine Falle gestoßen.

Code kopieren


Der Code lautet wie folgt:

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

Der obige Code löst unter Chrome auf dem Mac die folgende Ausnahme aus

Nicht erfasster RangeError: Maximale Aufrufstapelgröße überschritten

Wenn Sie das Array in „b = new Array(125623)“ ändern, ist ein kleineres Element in Ordnung. Nach dem Testen treten auch bei anderen Browsern Probleme mit großen Arrays auf , aber verschiedene Browser haben unterschiedliche kritische Werte

Der hier gegebene Vorschlag ist, forEach ehrlich zu verwenden, wodurch nicht nur das ungewöhnliche Problem großer Arrays vermieden werden kann, sondern forEach auch aus Leistungssicht berücksichtigt werden kann am schnellsten