javascript基础（Array）

Posted 2021-02-16 亚伯拉罕

1，join()

　　Array.join()，不改变原数组，将数组中所有元素转换为字符串并连接在一起，返回最后生成的字符串　　

let a=[1,2,3];
a.join();   //  =>"1,2,3"
a.join(" ");  // =>"1 2 3"
a.join("-");  // =>"1-2-3"

let b=new Array(5);
b.join("-");  // => "----" 4个连字号

 

2，reverse()

　　Array.reverse()，改变原数组，将数组中的元素颠倒顺序，返回逆序后的数组　　

let a=[1,2,3];
a.reverse(); // =>[3,2,1]

3，sort()

　　Array.sort()，改变原数组，将数组中的元素排序，返回排序后的数组。

　　不带参数时，数组元素按字母表顺序排序（如有必要将临时转化为字符串进行比较）　　

let a=[‘banana‘,‘cherry‘,‘apple‘];
a.sort()  // =>[‘apple‘,‘banana‘,‘cherry‘]

let b=[3,2,1,4,5];
b.sort();  // =>[1,2,3,4,5]

let c=[‘banana‘,2,‘apple‘,3,‘cherry‘,1];
c.sort(); // => [1,2,3,‘apple‘,‘banana‘,‘cherry‘]

let d=[1,2,10,100,20];
d.sort(); // =>[1,10,100,2,20]   并不按大小排序，
             // 如果想要按数值大小排序， 需要一个函数作为参数　

　　按照数值大小排序，必须给sort()方法传一个比较函数　　

let a=[1,2,10,100,20];
a.sort(function(a,b){
   return a-b;    //较小值在前
});    // => [1,2,10,20,100]

a.sort((a,b)=>{
   return b-a;   //较大值在前 
})；  // =>[100.20,10,2,1]

4，concat()

　　Array.concat()，不改变原数组，创建并返回一个新数组，新数组的元素包括调用concat()的原始数组和concat()的每个参数，如果任何一个参数是个数组，则连接的是数组的元素，而非数组本身

let a=[1,2,3];
a.concat(4,5);  // => [1,2,3,4,5]    a=[1,2,3]

a.concat(4,[5,6]);  // =>[1,2,3,4,5,6]      a=[1,2,3]

a.concat(4,[5,[6,7]]);  // =>[1,2,3,4,5,[6,7]]      a=[1,2,3]

5，slice()

　　Array.slice()，不改变原数组，返回数组的一个片段或子数组，两个参数分别指定了片段开始（包括）和结束（不包括）的位置，如果只有一个参数，则表示返回的数组包含从开始位置到数组结尾的所有元素，如果参数是负数，则表示相对于数组最后一个元素的位置，-1表示数组最后一个元素

 

let a=[1,2,3,4,5];
a.slice(0,3);  // => [1,2,3]
a.slice(3);   // =>[4,5]
a.slice(1,-1);   // =>[2,3,4]
a.slice(-3,-1);  // =>[3,4]

 6，splice()

　　Array.splice()，改变原数组，在数组中插入或删除元素，第一个参数指定插入或删除的起始位置，第二个参数指定删除元素的个数，如果省略，则删除从起始位置到数组结尾所有元素，第二个参数之后的任意个参数指定了要插入到数组中的元素

let a=[1,2,3,4,5,6,7];
a.splice(4);  // =>删除从下标4开始到结尾  [5,6,7]      
             //a=[1,2,3,4]
a.splice(1,2);  // =>删除从下标1开始，2个元素  [2,3]
                // a=[1,4]
a.splice(1,0,‘a‘,‘b‘);   //=>删除从下标1开始，0个元素，[]
                         //  从下标1开始增加 ‘a‘,‘b‘ ,   a=[1,‘a‘,‘b‘,4]
a.splice(1,2,[1,2],3);  // => 删除从下标1开始，2个元素，[‘a‘,‘b‘]
                        // =>从下标1开始增加[1,2],3    a=[1,[1,2],3,4]    

 

 7，push()

　　Array.push()，改变原数组，在数组结尾添加1个或多个元素，返回新数组的长度

let a=[];
a.push(1,2);    // => 2   
                // a=[1,2]
a.push([3,4],5);  // => 4
                  // a=[1,2,[3,4],5]

8，pop()

　　Array.pop()，改变原数组，删除数组的最后一个元素，返回被删除的值

let a=[1,2,3,[4,5]];
a.pop();       // =>[4,5] 
               //  a=[1,2,3]
a.pop();      //=>  3
              // a=[1,2]

 9，unshift()

　　Array.unshift()，改变原数组，在数组头部添加元素，返回新数组的长度 

let a=[];
a.unshift(1,[2,3],4);     //=> 返回数组长度  3
                         //   a=[1,[2,3],4]

 10，shift()

　　Array.shift()，改变原数组，删除数组的第一个元素，返回删除的元素 

let a=[1,[2,3],4];
a.shift();   //=>  1
             //  a=[[2,3],4]


a.shift();   //=>[2,3]
             //  a=[4]

 11，toString()

　　Array.toString()，不改变原数组，这个方法将数组中每个元素转为字符串，返回用逗号分隔的字符串列表，注意：输出不包括任何分隔符，比如方括号[]

let a=[1,[2,3],4];
a.toString();    //=>  ‘1，2，3，4‘
                 //  a=[1,[2,3],4]

 12，forEach()

　　Array.forEach(function(v,i,arr){

　　})

　　不改变原数组，遍历数组，为每个元素调用指定的函数，3个参数分别是： v    数组元素； i   元素索引； arr  数组本身

let a=[1,2,3,4];
let sum=0;
a.forEach(function(v){
   sum+=v; 
});
console.log(sum);   //=>  10

a.forEach(function(v,i,arr){
   arr[i]=v+1; 
});
console.log(a);    //=>  [2,3,4,5]

13，map()

　　Array.map(function(v){

　　　　return v

　　})

　　不改变原数组，将数组的每个元素传递给指定的函数，返回一个新数组。传递给map()的函数要有返回值

let a=[1,2,3];
a.map(function(v){
   return v*v; 
});      //=>[1,4,9]

14，filter()

　　Array.filter(function(v,i){

　　    return  ---

　　})

　　不改变原数组，返回数组的子集，传递的函数用来逻辑判定，如果函数返回值为true，或者能转化为true，则传递给函数的元素就是子集的成员

let a=[1,2,3,4,5];
a.filter(function(v){
   return v>3; 
});     //=>    [4,5]

a.filter(function(v,i){
   return i%2==0; 
});    // =>[1,3,5]

15，every()

　　Array.every(function(v){

　　　　return ---

　　})

　　不改变原数组，对数组元素用指定的函数进行判定，当所有元素调用判定函数都返回true，Array.every()返回true

let a=[1,2,3,4,5];
a.every(function(v){
    return a<10;
});       //true

16，some()

　　Array.some(function(v){

　　　　return ---

　　})

　　不改变原数组，对数组元素用指定的函数进行判定，只要有1个元素调用判定函数返回true，Array.some()就返回true

let a=[1,2,3,4,5];
a.some(function(v){
   return v>4; 
});     //=>   true

 17，reduce()

　　Array.reduce()，不改变原数组，使用指定的函数将数组元素进行组合，生成单个值，reduce()两个参数，第一个是简化操作的函数，第二个（可选）是传给函数的初始值，reduceRight()与reduce()相同，只是它从结尾开始计算

let a=[1,2,3,4];
a.reduce(function(x,y){
    return x+y;
},5);     //=>  15   5+1 => 6+2 =>  8+3 => 11+4 

a.reduce(function(x,y){
    return x>y?x:y;
});     //=>  4

18，indexOf() 

　　Array.indexOf()，搜索数组中与给定值相同的元素，返回找到的第一个元素的索引，没有找到就返回-1

let a=[‘a‘,‘b‘,‘c‘];
a.indexOf(‘b‘);    //=>  1      a[1]是‘b‘
a.indexOf(1);     //=>  -1     a中没有1

　　Array.lastIndexOf()，与indeOf()相同，只是它从数组末尾开始搜索

19，isArray()

　　Array.isArray()，判断一个对象是否是数组

Array.isArray([]);   //=> true
Array.isArray({});  //=>false