Javascript-Array-Array, allgemeine Methoden_Javascript-Kenntnisse

(1) Grundlegende Array-Methoden

1.join()

Die Array.join()-Methode wandelt alle Elemente im Array in Strings um, verkettet sie und gibt den endgültigen generierten String zurück. Sie können das Trennzeichen selbst angeben. Wenn nicht angegeben, wird standardmäßig das Komma

verwendet.

var arr = [1,2,3];
console.log(arr.join());//"1,2,3"
console.log(arr.join("-"));//"1-2-3"

var a = new Array(10); //长度为10的空数组 组成下边字符串
console.log(a.join("-"));//"---------"

2.reverse()
Die Methode Array.reverse() kehrt die Reihenfolge der Elemente im Array um und gibt das Array in umgekehrter Reihenfolge zurück (das zurückgegebene Array ist es selbst, das ursprüngliche Array wurde geändert)

var arr = [1,2,3];
arr.reverse();
console.log(arr.join());//"3,2,1"

Wenn Sie also eine Zeichenfolge umkehren möchten, können Sie dies tun

var str = "abcdefg";

console.log(str.split("").reverse().join(""));//"gfedcba" 返回的是新的值
console.log(str); //"abcdefg" 当然了，原始的是不会变的.

3.sort()
Die Methode Array.sort() sortiert die Elemente im Array und gibt das sortierte Array zurück.

Wenn keine Parameter vorhanden sind, erfolgt die Standardsortierung in der Reihenfolge, also von klein nach groß. Natürlich können Sie zum Sortieren auch direkt eine Vergleichsfunktion hinzufügen

var arr = [1,4,7];
arr.sort();
console.log(arr); //[1,4,7]

arr.sort(function(a,b){
 return a-b; //从小到大
});
console.log(arr); //[1,4,7]

arr.sort(function(a,b){
 return b-a; //从大到小
});
console.log(arr); //[7,4,1]


var num = new Array('one','three','Six','Five');
num.sort(); //区分大小写排序
console.log(num); // ["Five", "Six", "one", "three"]
num.sort(function(s,t){
 var a = s.toLowerCase();
 var b = t.toLowerCase();
 if(a<b) return -1;
 if(a>b) return 1;
 return 0;
});
console.log(num); // ["Five", "one", "Six", "three"]

4.concat()
Die Methode Array.concat() erstellt ein neues Array und gibt es zurück, dessen Elemente die Elemente des ursprünglichen Arrays, von dem concat() aufgerufen wurde, und jeden Parameter von concat() umfassen.

Wenn einer dieser Parameter selbst ein Array ist, werden die Elemente des Arrays verkettet, nicht das Array selbst.

Beachten Sie jedoch, dass concat() ein Array von Arrays nicht rekursiv reduziert. concat() verändert auch nicht das aufrufende Array.

var arr = [1,2,3];
console.log(arr.concat(4,5)); // [1, 2, 3, 4, 5]
console.log(arr);       // [1, 2, 3]
console.log(arr.concat([4,5])); // [1, 2, 3, 4, 5]
console.log(arr.concat([4,5],[6,7])); // [1, 2, 3, 4, 5,6,7]
console.log(arr.concat([4,[5,[6,7]]])); // [1, 2, 3, 4, [5, [6, 7]]]
console.log(arr.concat(4,[5,[6,7]])); // [1, 2, 3, 4, 5,[6,7]]

5.slice()
Die Methode Array.slice() gibt ein Slice oder Subarray des angegebenen Arrays zurück. Seine beiden Parameter geben die Start- bzw. Endposition des Segments (a,b) an. Zurückgegeben werden die Array-Elemente von a bis b mit Ausnahme von b.
Wenn es nur einen Parameter (a) gibt, repräsentiert er die Elemente von a bis zum Ende des Arrays.
Wenn im Parameter eine negative Zahl (-a) erscheint, gibt sie die Position von a relativ zum letzten Element im Array an. Beispielsweise stellt (-3) das drittletzte Element bis zum Ende dar. Wenn eine negative Zahl auftritt, konvertieren Sie sie zuerst und ermitteln Sie sie dann gemäß den Bereichsregeln
Außerdem wird ein neues Array zurückgegeben und das ursprüngliche Array nicht verändert

var arr = [1,2,3,4,5];
console.log(arr.slice(0,3)); // [1, 2, 3]
console.log(arr); // [1, 2, 3, 4, 5]
console.log(arr.slice(3));//[4, 5]
console.log(arr.slice(-3));// [3, 4, 5]
console.log(arr.slice(-3,-1));// [3, 4]
console.log(arr.slice(2,-1));// [3, 4]

6. splice()
Die Methode Array.splice() ist eine allgemeine Methode zum Einfügen oder Löschen von Elementen in einem Array. Es ändert den Wert des ursprünglichen Arrays und gibt eine neue Array-Sequenz

zurück

Der erste Parameter von splice() gibt die Startposition des Einfügens oder Löschens an und der zweite Parameter gibt die Anzahl der Elemente an, die aus dem Array gelöscht werden sollen. Wenn der zweite Parameter weggelassen wird, wird er standardmäßig bis zum Ende gelöscht.

var arr = [1,2,3,4,5,6,7,8];
console.log(arr.splice(4)); //[5, 6, 7, 8]
console.log(arr); // [1, 2, 3, 4]
console.log(arr.splice(1,2));// [2, 3]
console.log(arr); // [1, 4]

Die ersten beiden Parameter von splice() geben die zu löschenden Array-Elemente an. Eine beliebige Anzahl von Argumenten, die folgen, geben die Elemente an, die in das Array eingefügt werden sollen, beginnend an der Position, die durch das erste Argument dargestellt wird.

Im Gegensatz zu concat() oben fügt splice() das Array direkt ein, z. B. das folgende [1,2]

var arr = [1,2,3,4,5];
console.log(arr.splice(2,0,'a','b')); // []
console.log(arr); // [1, 2, "a", "b", 3, 4, 5]
console.log(arr.splice(2,1,[1,2],3));// ["a"]
console.log(arr); // [1, 2, [1, 2], 3, "b", 3, 4, 5]

7.push() pop() unshift() shift()
Stellen Sie sich diese Methoden einfach als Stapeloperationen vor: Die ersten beiden sind normale Stapeloperationen und die letzten beiden sind umgekehrte Stapeloperationen
push() und unshift() fügen dem Array Elemente von hinten und vorne hinzu und geben die Länge des neuen Arrays zurück
pop() und shift() löschen das letzte und erste Element im Array und geben die gelöschten Elemente zurück

var arr = [];

console.log(arr.push(1,2,3));//3
console.log(arr);//[1, 2, 3]

console.log(arr.pop());// 3
console.log(arr);//[1,2]

console.log(arr.push([4,5]));//3
console.log(arr);// [1, 2, [4, 5]]

var arr = [];

console.log(arr.unshift(1,2,3));//3
console.log(arr);//[1, 2, 3]

console.log(arr.shift());// 1
console.log(arr);// [2, 3]

console.log(arr.unshift([4,5]));//3
console.log(arr);//[[4, 5], 2, 3]

(2) Array-Methoden in ECMAScript5

Die meisten Array-Methoden dieser Art haben einheitliche und allgemeine Regeln. Keiner von ihnen verändert das ursprüngliche Array.
Die meisten Methoden empfangen eine Funktion als erstes Argument und rufen die Funktion einmal für jedes Element (oder alle Elemente) des Arrays auf.

Wenn es sich um ein spärliches Array handelt, wird die übergebene Funktion nicht für Elemente aufgerufen, die nicht vorhanden sind;
In den meisten Fällen benötigt die aufgerufene Funktion drei Parameter: das Array-Element, den Index des Elements und das Array selbst. Normalerweise müssen die letzten beiden Parameter nicht ausgefüllt werden.
Zusätzlich zum ersten Parameter (der Funktion) gibt es hier einen zweiten Parameter (er ist optional). Wenn der zweite Parameter vorhanden ist, wird die aufgerufene Funktion als Methode mit dem zweiten Parameter behandelt.
Mit anderen Worten: Der zweite Parameter, der beim Aufruf der Funktion übergeben wird, wird als Wert des Schlüsselworts this verwendet.

1.forEach()

Diese Methode durchläuft das Array vom Anfang bis zum Ende und ruft die angegebene Funktion für jedes Array auf.

var data = [1,2,3,4,5];
var sum = 0;
data.forEach(function(value){ //只使用了第一个参数（函数），调用的函数也只使用了第一个参数数组元素
 sum += value;
});

console.log(sum);//15
console.log(data);// [1, 2, 3, 4, 5]

var data = [1,2,3,4,5];
var sum = 0;
data.forEach(function(value,item,data){ //调用的函数具有了三个参数
  data[item] = value*value; //取平方
});

console.log(data);// [1, 4, 9, 16, 25]

2.map()
Diese Methode übergibt jedes Element im aufgerufenen Array an die angegebene Funktion und gibt ein Array zurück, das den Rückgabewert dieser Funktion enthält.

var data = [1,2,3,4,5];
var data1 = data.map(function(value){
 return ++ value;
});

console.log(data); // [1, 2, 3, 4, 5]
console.log(data1);// [2, 3, 4, 5, 6]

3.filter()
Die von dieser Methode zurückgegebenen Array-Elemente sind eine Teilmenge des aufrufenden Arrays. Die übergebene Funktion wird zur logischen Bestimmung verwendet und die Funktion gibt true oder false zurück.

Wenn der Rückgabewert wahr ist oder ein Wert, der in wahr konvertiert werden kann, ist das an die Beurteilungsfunktion übergebene Element ein Mitglied dieser Teilmenge und wird als Rückgabewert einem Array hinzugefügt.

var data = [1,2,3,4,5];
var data1 = data.filter(function(value){
 return value <= 3;
});

var data2 = data.filter(function(value){
 return value > 3;
});

console.log(data); // [1, 2, 3, 4, 5]
console.log(data1);// [1,2,3]
console.log(data2);// [4,5]

4.every()和some()
顾名思义，every()就是数组中所以元素都满足函数指定的条件时 返回true; some()就是某一项满足时就返回 true

var data = [1,2,3,4,5];
var data1 = data.every(function(value){
 return value < 4;
});

var data2 = data.some(function(value){
 return value >4;
});

console.log(data); // [1, 2, 3, 4, 5]
console.log(data1);// false
console.log(data2);// true

5.reduce()和reduceRight()
这两个方法使用指定的函数将数组元素进行组合，生成单个值。

reduce()有两个参数。第一个是执行化简操作的函数，就是说用某种方法把两个值化简为一个值，并返回化简后的值。

　　　　　　　　　　第二个参数可选，用来传递给第一个参数函数作为初始值。如果第二个参数没有，则初始值就使用数组的第一个元素值。

var data = [1,2,3,4,5];
var sum = data.reduce(function(a,b){
 return a+b;
});

var sum1 = data.reduce(function(a,b){
 return a+b;
},5);

var min = data.reduce(function(a,b){
 return (a<b)&#63;a:b;
});

console.log(data); // [1, 2, 3, 4, 5]
console.log(sum);// 15
console.log(sum1);// 20
console.log(min);// 1

sum中没有第二个参数，所以初始值为第一个数组元素，第一步1+2=3，第二步3+3=6... 最后得15
sum1中有第二个参数，所以初始值为5，第一步5+1=6，第二步6+2=8... 最后得20

reduceRight()和reduce()差不多，不同的是它按照数组索引从高到低（从右到左）处理数组，而不是正常的从低到高。

var data = ['a','b','c']; 
var str = data.reduce(function(x,y){ //顺序
 return x+y;
});

var str1 = data.reduceRight(function(x,y){ //逆序
 return x+y;
});

console.log(data);// [1, 2, 3]
console.log(str);//"abc"
console.log(str1);//"cba"

6.indexOf()和lastIndexOf()
这个方法搜索整个数组中具有给定值的元素，返回找到的元素的索引（找到了一个就退出了），没有找到则返回-1.

一个从头至尾，一个从尾至头

var data = ['a','b','a','c','a']; 

console.log(data.indexOf('a')); //0
console.log(data.indexOf('d')); //-1
console.log(data.lastIndexOf('a'));//4

console.log(data.lastIndexOf('a',-2));//2 从倒数第二个开始
console.log(data.lastIndexOf('a',1));//0  从顺序第二个往前

7.数组类型 isArray()
判断一个对象是不是数组

console.log(Array.isArray([]));//true
console.log(Array.isArray({}));//false

//模拟上边的
var isArray1 = Function.isArray||function(o){
 return typeof o === "object" &&
  Object.prototype.toString.call(o) === "[object Array]";
};

console.log(isArray1([]));//true
console.log(isArray1({}));//false