数组方法和数组去重的四种方法（重点）

目录

1.转化为字符串

2.添加的方法

3.删除的方法（无参数）

4.forEach方法

5.数组升序排列

6.反转数组顺序

7.操作方法

8.位置方法

9.数组去重的方法 

---

1.转化为字符串

（1）join（）

（2）参数：一个参数，把数组分割为字符串，如果有参数用参数来分隔，没有参数默认用逗号分隔

代码：

    // 1.join() 将数组分隔为字符串，如果有参数用参数来分隔，如果没有默认用逗号分隔
    var  arr=['苹果','橘子','香蕉']
    console.log(arr);
    console.log(typeof(arr.join()));  //String 
    console.log(arr.join('-'));   

运行结果：

2.添加的方法

（1）向数组最前面添加元素

      <1>unshift()

      <2>参数：添加数组的内容      (会改变原数组)

（2）向数组最后面添加元素

      <1>push()

      <2>参数：添加数组的内容

代码：

// 2.向数组添加或者删除
    // 添加的方法：（1）push(向数组最后面添加)
    //            （2）unshift(向数组最前面添加) 会改变原数组
    arr.push('榴莲');
    arr.unshift('菠萝');
    console.log(arr);

运行结果：

3.删除的方法（无参数）

（1）删除数组第一项

      <1>shift()

      <2>参数：无参数

（2）删除数组最后一项

      <1>pop()

      <2>参数：无参数

代码：

    // 删除的方法(无参数)：（1）pop(删除数组最后一项)
    //                    （2）shift(删除数组最前面一项)  会改变原数组
    arr.pop();
    arr.shift();
    console.log(arr);

运行结果：

4.forEach方法

（1）语法：forEach(function(value,index,array){})

（2）value：第一个参数是遍历的数组内容

（3）index：第二个参数是对应的数组索引

（4）array：第三个参数是数组本身

5.数组升序排列

（1）sort()

（2）参数：比较函数

（3）返回值：排序后的数组

代码：

 // 3.sort()  数组排序  如果是单个数字  默认通过ASCII码排序  会改变原数组
    var arr1=[2,36,23,8,19,0];
    arr1.sort(compare)
    function  compare(v1,v2){
        return v2-v1;
    }
    console.log(arr1);

运行结果：

6.反转数组顺序

（1）reverse()       (会改变原数组)

（2）无参数

（3）返回值：排序后的数组

代码：

  // 4.反转数组  reverse() 会改变原数组  
    var arr1=[2,36,23,8,19,0];
    console.log(arr1);
    console.log(arr1.reverse());

运行结果：

7.操作方法

（1）concat()

      <1>作用：拼接数组

      <2>参数：多个参数可以是数组也可以是其他类型

      <3>功能：创建新数组，将接收到的参数添加到新数组末尾

      <4>返回：新构建的数组

代码：

   // 5.拼接数组  concat()  返回一个新的数组
    var  food=['米饭','馒头','面条']
    console.log(food);
    console.log(food.concat('烤鸭','烤羊腿'));

运行结果：

（2）slice()

      <1>作用：截取数组 

      <2>参数

         1)一个参数：返回从该函数位置开始到数组末尾的所有项

         2)两个参数：返回起始和结束位置之间的项，包括起始位置，但不包括结束位置的项

      <3>功能：基于方法的参数索引，截取一个新数组，不会改变数组

代码：

    // 6.截取数组  slice()
    // 可以一个参数  截取参数开始的位置一直到结束
    // 可以两个参数  截取的是一个范围   包括开始的位置  不包括结束的位置
    var animal=['猴儿','熊猫','狗子','孔雀','猴儿','猴儿','老鼠'];
    console.log(animal);
    console.log(animal.slice(0,3));

运行结果：

（3）splice(下标   删除的个数   添加的项)       会改变原数组

      <1>功能最强大：(下标，删除的个数，添加的项)

      <2>删除：splice(下标，删除的个数)         两个参数，要删除的第一项的位置和要删除的项数

代码：

   // splice(下标  删除的个数   添加的项)   会改变原数组
    // 删除  splice(下标，删除的个数)
    arr.splice(1,1);
    console.log(arr);

运行结果：

      <3>添加：splice(下标，0，添加的项)       三个参数，起始位置，0，要插入的任意数量的项

代码：

    // 添加  splice(下标，0，添加的项)
    arr.splice(0,0,'菠萝','草莓');
    console.log(arr);

运行结果：

      <4>替换：splice(下标，删除的个数，替换的项)      三个参数，起始位置，要删除的项数，要替换的任意数量的项   

代码：

   // 替换  splice(下标，删除的个数，替换的项)
    arr.splice(2,1,'葡萄');
    console.log(arr);
    arr.splice(1,1,'蓝莓');
    console.log(arr);

运行结果：

8.位置方法

(1)indexOf()

      <1>作用：从前向后查找或者获取元素的索引值，如果找不到 得到的的值就是-1

      <2>参数

         1)一个参数：要查找的元素

         2)两个参数：要查找的元素，查找这个元素开始的索引

代码：

   // 7.indexOf()  从前向后查找或者获取某元素的索引值   如果找不到  得到的值就是-1
    // 一个参数：要查找的项  
    // 两个参数：要查找的项，查找开始的位置
    var animal=['猴儿','熊猫','狗子','孔雀','猴儿','猴儿','老鼠'];
    console.log(animal);
    console.log(animal.slice(0,3));
    console.log(animal.indexOf('猴儿',2));

运行结果：

(2)lastIndexOf()

      <1>作用：从后向前查找或者获取元素的索引值，如果找不到，得到的的值就是-1

      <2>参数

         1)一个参数：要查找的元素

         2)两个参数：要查找的元素，查找这个元素开始的索引

代码：

   // lastIndexOf()  从后向前查找或者获取某元素的索引值   如果找不到  得到的值就是-1
    // 一个参数：要查找的项  
    // 两个参数：要查找的项，查找开始的位置
    var animal=['猴儿','熊猫','狗子','孔雀','猴儿','猴儿','老鼠'];
    console.log(animal);
    console.log(animal.slice(0,3));
    console.log(animal.lastIndexOf('猴儿'));

运行结果：

9.数组去重的方法 

（1） 用新的数组去遍历旧的数组中的每一项，如果没有就添加

代码：

    var numArr=[99,45,89,45,99,23,56,0,2,5];
    numArr.sort(function(x,y)
    {
        return  x-y;
    });
    console.log(numArr);
    // 第一种方法
    var  newArr=[];
    // 用新的数组去遍历旧的数组中的每一项    如果没有  就添加
    for(var i=0;i<numArr.length;i++)
    {
        if(newArr.indexOf(numArr[i])==-1)
        {
            newArr.push(numArr[i]);
        }
    }
    console.log(newArr);

运行结果：

（2）双重for循环

代码：

​​    // 第二种方法
    var numArr=[99,45,89,45,99,23,56,0,2,5];
    numArr.sort(function(x,y)
    {
        return  x-y;
    });
    console.log(numArr);

    for(var i=0;i<numArr.length;i++)
    {
        for(var j=i+1;j<numArr.length;j++)
        {
            if(numArr[i]===numArr[j])
            {
                numArr.splice(j,1);
                j--;
            }
        }
    }

运行结果：

（3）includes方法

代码：

    // 第三种方法   includes
    var numArr=[99,45,89,45,99,23,56,0,2,5];
    numArr.sort(function(x,y)
    {
        return  x-y;
    });
    console.log(numArr);

    var  arr=[];
    console.log(arr.includes(99));
    for(var i=0;i<numArr.length;i++)
    {
        if(!arr.includes(numArr[i]))
        {
            arr.push(numArr[i]);
        }
    }
    console.log(numArr);

运行结果：

（4）set()    会得到单一结构的数据

代码：

   // 第四种方法  set()    会得到单一结构的数据
    var numArr=[99,45,89,45,99,23,56,0,2,5];
    numArr.sort(function(x,y)
    {
        return  x-y;
    });
    console.log(numArr);


    var arr1=new  Set(numArr);
    console.log(arr1);

运行结果：