javascript Array array kaedah biasa_kemahiran javascript

(1) Kaedah tatasusunan asas

1.join()

Kaedah Array.join() menukarkan semua elemen dalam tatasusunan kepada rentetan dan menggabungkannya bersama-sama, mengembalikan rentetan hasil akhir. Anda boleh menentukan sendiri simbol pembatas Jika tidak dinyatakan, koma

akan digunakan secara lalai.

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.terbalik()
Kaedah Array.reverse() membalikkan susunan elemen dalam tatasusunan dan mengembalikan tatasusunan dalam susunan terbalik (tatasusunan yang dikembalikan adalah dirinya sendiri, tatasusunan asal telah ditukar)

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

Jadi, jika anda ingin membalikkan rentetan, anda boleh melakukan ini

var str = "abcdefg";

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

3.sort()
Kaedah Array.sort() mengisih elemen dalam tatasusunan dan mengembalikan tatasusunan yang diisih.

Apabila tiada parameter, pengisihan lalai adalah teratur, iaitu, dari kecil ke besar. Sudah tentu, anda juga boleh terus menambah fungsi perbandingan untuk mengisih

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()
Kaedah Array.concat() mencipta dan mengembalikan tatasusunan baharu yang unsur-unsurnya merangkumi unsur tatasusunan asal dari mana concat() dipanggil dan setiap parameter concat().

Jika mana-mana parameter ini sendiri adalah tatasusunan, unsur tatasusunan akan digabungkan, bukan tatasusunan itu sendiri.

Tetapi ketahui bahawa concat() tidak akan meratakan tatasusunan secara rekursif. concat() juga tidak mengubah suai tatasusunan panggilan.

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()
Kaedah Array.slice() mengembalikan kepingan atau subarray bagi tatasusunan yang ditentukan. Dua parameternya menentukan kedudukan permulaan dan penamat bagi segmen (a,b) masing-masing. Apa yang dikembalikan ialah elemen tatasusunan bermula dari a hingga b tidak termasuk b.
Jika terdapat hanya satu parameter (a), ia mewakili elemen dari a hingga hujung tatasusunan.
Jika nombor negatif (-a) muncul dalam parameter, ia menunjukkan kedudukan relatif kepada elemen terakhir dalam tatasusunan. Contohnya (-3) mewakili elemen ketiga hingga terakhir hingga akhir. Jika nombor negatif muncul, tukarkannya dahulu, kemudian cari ia mengikut peraturan julat
Ia juga mengembalikan tatasusunan baharu dan tidak mengubah suai tatasusunan asal

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. sambung()
Kaedah Array.splice() ialah kaedah umum untuk memasukkan atau memadam elemen dalam tatasusunan. Ia mengubah suai nilai tatasusunan asal dan mengembalikan jujukan tatasusunan baharu

Parameter pertama splice() menentukan kedudukan permulaan sisipan atau pemadaman, dan parameter kedua menentukan bilangan elemen yang harus dipadamkan daripada tatasusunan. Jika parameter kedua ditinggalkan, ia akan dipadamkan ke penghujung secara lalai.

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]

Dua parameter pertama splice() menentukan elemen tatasusunan untuk dipadamkan. Sebarang bilangan argumen yang mengikuti menentukan elemen untuk dimasukkan ke dalam tatasusunan, bermula dari kedudukan yang diwakili oleh argumen pertama.

Berbeza daripada concat() di atas, splice() terus memasukkan tatasusunan, seperti berikut [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()
Cuma anggap kaedah ini sebagai operasi tindanan: dua yang pertama ialah operasi tindanan biasa dan dua yang terakhir ialah operasi tindanan terbalik
push() dan unshift() menambah elemen dari belakang dan hadapan ke tatasusunan, dan kembalikan panjang tatasusunan baharu
pop() dan shift() padamkan elemen terakhir dan pertama dalam tatasusunan dan kembalikan elemen yang dipadam

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) Kaedah tatasusunan dalam ECMAScript5

Kebanyakan kaedah tatasusunan jenis ini mempunyai peraturan yang seragam dan umum. Tiada seorang pun daripada mereka mengubah suai tatasusunan asal.
Kebanyakan kaedah menerima fungsi sebagai hujah pertama dan memanggil fungsi itu sekali untuk setiap elemen (atau elemen) tatasusunan.

Jika tatasusunan jarang, fungsi yang diluluskan tidak akan dipanggil untuk elemen yang tidak wujud
Dalam kebanyakan kes, fungsi yang dipanggil mengambil tiga parameter: elemen tatasusunan, indeks elemen dan tatasusunan itu sendiri. Biasanya dua parameter terakhir tidak perlu diisi.
Sebagai tambahan kepada parameter pertama di sini (fungsi), terdapat parameter kedua (ia adalah pilihan Jika parameter kedua hadir, fungsi yang dipanggil akan dianggap sebagai kaedah dengan parameter kedua).
Dalam erti kata lain, parameter kedua yang dihantar semasa memanggil fungsi digunakan sebagai nilai kata kunci ini.

1.forEach()

Kaedah ini merentasi tatasusunan dari awal hingga akhir dan memanggil fungsi yang ditentukan untuk setiap tatasusunan.

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()
Kaedah ini menghantar setiap elemen dalam tatasusunan yang dipanggil ke fungsi yang ditentukan dan mengembalikan tatasusunan yang mengandungi nilai pulangan fungsi ini.

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.penapis()
Elemen tatasusunan yang dikembalikan oleh kaedah ini ialah subset tatasusunan panggilan. Fungsi yang diluluskan digunakan untuk penentuan logik, dan fungsi mengembalikan benar atau salah.

Jika nilai pulangan adalah benar atau nilai yang boleh ditukar kepada benar, maka elemen yang dihantar kepada fungsi penghakiman ialah ahli subset ini dan ia akan ditambahkan pada tatasusunan sebagai nilai pulangan.

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