数组排序，数组去重（扩展运算符），ES5中数组新增的几个方法

1.数组排序

①冒泡排序 ： 相邻的两个数比较，大数下沉，小数上浮

 var arr = [2,3,5,3,2,7,4,8]
   
   function MpPx(){
       var b = 0;  //用于交换的一个数
        for(var i = 0 ;i < arr.length -1; i++){//轮数   每一轮都得到一个当前的最大数，第一轮将最大的数交换到最后，第二轮再类推，先1,2比较，交换完毕后，
　　　　　　　　2，3比较，依次类推；而每一轮的次数等于原本的数减1  轮数 和次数 有关；  总轮数是数的长度减1，而次数是数的长度减当前的轮数  也就是长度减1减i
            for(var j = 0;j < arr.length - 1 - i;j++){
                if(arr[j] > arr[j+1]){
                    // b = wyl[j];
                    // wyl[j] = wyl[j+1];
                    // wyl[j+1] = b;

                    //使用解构赋值
                    [arr[j],wyl[j+1]] = [arr[j+1],wyl[j]]
                }
            }

        }
        return arr
   }
   console.log(MpPx());

 

②选择排序： 每一轮用数组中的第n个数和后面的数依次比较，如果arr[n] 大于后面的数，就交换  n从下标为0开始 一直到 arr.length-1

 var  arr = [2,3,2,4,6,4,3]
   function XzPx(){
       var a = 0;
       for(var i = 0 ;i < arr.length-1; i++){
           for(var j = i+1;j <=arr.length-1;j++){
                if(arr[i] > arr[j]){
                        a = arr[j];
                        arr[j] = arr[i];
                        arr[i] = a;
                }
           } 
            
       }
       return arr;
   }
console.log(XzPx())

 

③sort方法排序 ：  按照字符编码的顺序进行排序 

 

用法一 ： 数组.sort()    对字符排序

用法二 ： 对数值排序

数组.sort(function(a,b){

    return a-b;   升序        return b-a; 降序   

})

 

  //随机排序    Math.random()    [0,1)

   var arr = [78,2,13,9,100];

   arr.sort(function(){

      return Math.random()-0.5;

   })

   alert( arr );

 

2、数组去重

 

　　 方法一：利用一个函数，判断在数组中，是否存在某个值

 //编写一个函数 判断在数组中，是否存在某个值   fn(arr,n)

    function fnCz(arr,n){
        for(var i = 0;i < arr.length;i++){
            if(arr[i] == n){
                return true;
            }
        }
        return false;
    }

   //数组去重，定义一个新数组，将已有数组的值拿出来，新数组中没有的就存进去

   //可利用上面的函数

   var arr = [1,2,4,6,2,1];
   var brr = [];
   function ArrQc(){
       for(var i = 0;i < arr.length;i++){
        if(!fnCz(brr,arr[i])){
            brr.push(arr[i]);
        }
     }
     return brr;
   }
   console.log(ArrQc())

　　方法二：利用indexOf()

//indexOf(n)  判断n在数组中是否存在，如果存在就返回这个数在数组中的下标，不存在就返回-1
    function indexQc(){
        for(var i = 0 ; i < arr.length;i++){
            if(brr.indexOf(arr[i])== -1){
                brr.push(arr[i])
            }
        }
        return brr
    }
console.log(indexQc())

        方法三：利用数组排序将数组按顺序排列后

  //将数组按顺序排列，遍历数组，相邻的两个值作比较；定义一个新数组，如果前一个数不等于后一个数，将前一个数存到新数组里


  var  b = [1,3,3,4,5,8,8,9];
  var c = [];
  function noRepeat(){
        for(var i = 0; i < b.length; i++){
            if(b[i] !== b[i+1]){
                c.push(b[i]);
            }
        }
        return c;
  }
  console.log(noRepeat())

 　　方法四：利用set实例

　　　　首先要了解一下rest参数和扩展运算符（spread）：

function Fn (fist, ...rest) {
    console.log(fist);  //1
    console.log(rest);  //[2,3,4,5]
}
Fn(1,2,3,4,5);

　　　　类似用 ...变量名  的形式替代了函数参数中的arguments对象；

　　　   而如果在参数中只传入rest参数的话它代表的就是将arguments对象转为数组之后的一个数组，也就是一个包含了所有参数的数组

function fn2 (...rest) {
    console.log(rest);
}
fn2(1,2,3);  // [1,2,3]

　　　　下面是借鉴别人的arguments和rest的两种写法：

// arguments写法
function add1(){
    var sum = 0;
    Array.prototype.slice.apply(arguments).forEach( function(item){
        sum += item;
    })
    console.log(sum)
}
add1(1,2,3); //6

// rest参数写法
function add2(...valus) {
    let sum = 0;
    valus.forEach( value => {
        sum += value
    })
    console.log(sum)
}
add2(1,2,3);  //6

　　　　接下来就是扩展运算符（...）；

　　　　用于取出参数对象的所有可遍历属性，拷贝到当前对象之中；

　　　　将一个数组转为用逗号分隔的参数序列

console.log(...[1,2]);  //1,2
console.log(8, ...[1,2], 9);  //8,1,2,9

　　　　

function fn3 (...rest) {
    console.log(rest)
}
var arr = [1,2,7];
fn3(...arr);  // [1,2,7]

扩展运算符的应用

①合并数组

arr1.push(...arr2) // 把arr2合并到arr1的后面
arr1.unshift(...arr2) //把arr2合并到arr1的前面


在数组内合并数组

var arr1 = ['two', 'three'];

var arr2 = ['one', ...arr1, 'four', 'five'];

②复制数组
常用Array.prototype.slice

var arr = [1,2,3];
var arr2 = [...arr]; // 就像是 arr.slice()
arr2.push(4)

③结构赋值
可以从变量中提取有用的信息，

let { x, y, ...z } = { x: 1, y: 2, a: 3, b: 4 };
console.log(x); // 1
console.log(y); // 2
console.log(z); // { a: 3, b: 4 }

在ES6提供了新的数据结构set,它类似于数组，但是成员的值都是唯一的，没有重复的值。

set 实例的属性和方法（set是一个集合，index和item是一样的）

①size:所有元素的个数；

②add（value）：添加某个值，返回set结构本身

③delete（value）：删除某个值，返回一个布尔值，表示删除是否成功

④has（value）:返回一个布尔值，表示该值是否为set的成员；

⑤clear（）：清除所有成员，没有返回值

set的数组去重：Array.from（new Set（arr））自动去重，不会进行类型转换；（Array.from是把一个类数组转化为真正的数组）

结合扩展运算符的set的数组去重：[ ...new Set(arr) ]  最短的数组去重方式

 

3、ES5中数组新增的几个方法

①indexOf()  判断一个数在某个数组中是否存在，如果存在就返回这个数在数组中的位置（下标），如果不存在返回-1

②lastIndexOf()返回最后一次出现该值的下标

 

③forEach()  遍历数组    没有返回值

　　arr.forEach(function(item,index,ary){

     　　item  数组的每一项

     　　index  下标

     　　ary  遍历的数组

　　})

 

④map()  映射  遍历数组 ---  操作数组 ---  返回数组

　　arr.map(function(item , index , ary){

     　　return 返回操作后的数组

　　})

 

⑤filter  过滤  按照某个条件过滤，返回过滤后的新数组

　　arr.filter(function(){

     　　return 条件;

　　})

 

⑥reduce()   归并   返回值是 最后一次操作的结果

　　arr.reduce(function(pre,next){

 

　　// pre :  前一个操作返回的结果  第一个默认值为数组的第一个数

　　// next ： 下一个操作数   （数组中第一个数的下一个数 ）

　　})

 

4.扩展

some()  返回一个boolean，判断是否有元素符合function条件，如果有一个元素符合function条件，则循环会终止。

var list = [6, 2, 3, 4, 5];

    var res = list.some(function(item,index,ary){

        return item > 3;

    })

every() 返回一个boolean，判断每个元素是否符合function条件，有一个元素不满足function条件，则循环终止，返回false。

var list = [6, 2, 3, 4, 5];

    var res = list.every(function(item,index,ary){

        console.log(1)

        return item > 1;

    })