关于数组的一些不low的操作

1.扁平化n维数组

     [1,[2,3]].flat(2) //[1,2,3]

    [1,[2,3,[4,5]].flat(3) //[1,2,3,4,5]

    [1[2,3,[4,5[...]].flat(Infinity)

Array.flat(n)是ES10扁平数组的api， n表示维度， n值为 Infinity时维度为无限大。

---

2.去重

1.

Array.from(new Set([1,2,3,3,4,4])) //[1,2,3,4]

    [...new Set([1,2,3,3,4,4])] //[1,2,3,4]

set是ES6新出来的一种一种定义不重复数组的数据类型。

Array.from是将类数组转化为数组。

...是扩展运算符，将set里面的值转化为字符串。

2.

var arr1 =[1,2,5,6,2,1,2,1,2];

var arr2=[];

for(var i=0;i

if(arr2.indexOf(arr1[i])==-1){

arr2.push(arr1[i]);

}

}

console.log(arr2);

3.

var flag;

var arr=[5,7,6,5,2,5,9,6,2,10];

var arr1=[];

function quchong(arr){

for(var i=0;i

flag = false;

for(var j=0;j

if(arr1[j]==arr[i]){

flag=true;

}

}

if(!flag){

arr1.push(arr[i]);

}

}

return arr1;

}

quchong(arr);

---

3.排序

1.冒泡排序：

function bubleSort(arr) {

for (var i = 0; i < arr.length - 1; i++) {

for (var j = 0; j < arr.length - 1 - i; j++) {

if (arr[j + 1] < arr[j]) {

[arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];

}

}

}

return arr;

}

2.选择排序

function bubleSort(arr) {

for(var i=0;i

var min = i;

for(var j=i+1;j

if(arr[j]

min = j ;

}

}

[arr[i],arr[min]]=[arr[min],arr[i]];

}

return arr;

}

3.两边排序

var cont = prompt("请输入一个数组，并用英文逗号隔开");

var arr = cont.split(",");

var arr1=[];

var arr2=[];

var max =Math.max.apply(null, arr);

if (arr.length%2==0) {         //偶数

    arrSplit(arr,arr1,arr2); //调用排序函数

    document.write(arr1.concat(arr2));         //拼接arr1和arr2数组

}

else{ //奇数

    arr.sort(function(a, b){ //对数组进行排序

        return b-a;

    });

    var newArr = arr.slice(1);                 //除掉最大一个的数，得到偶位数的数组

    arrSplit(newArr,arr1,arr2)

    arr2.unshift(max);                         //把最大那个数插入arr2

    document.write(arr1.concat(arr2));

    }

function arrSplit(arr,arr1,arr2){ //封装一个对偶数位数组进行分割和排序的函数

    var Array = []; //定义一个数组用于存放arr1和arr2的返回值

    for (var i=0; i

        arr1[i]= arr[i];

        arr2[i]= arr[i+arr.length/2];

    }

    arr1.sort(function (a, b){         //升序

        return a-b;

    });

    arr2.sort(function (c, d){                  //降序   

        return d-c;

    });

    Array[0]=arr1;

    Array[1]=arr2;

    return Array;                              //返回arr1和arr2数组

}

---

4.找出数组中重复出现过的数字

var arr = [1,2,4,4,3,3,1,5,3];

function duplicates(arr) {

var result = [];

arr.forEach(function(elem) {

if (arr.indexOf(elem) != arr.lastIndexOf(elem) && result.indexOf(elem) == -1) {

result.push(elem);

}

});

return result;

}

---

5.求数组里面最大值

var arr = [5,6,8,45,96,57,2];

Math.max.apply(this,arr);

---

6.不用变量使两数交换

1.

var a =10,b=2;

a=a+b;

b=a-b;

a=a-b;

2.

var a =10,b=2;

[a,b]=[b,a]

---

7.求数组总和

1.

arr.reduce(sum);

function sum(total,num){

return total+num;

}

2.

function sum(arr) {

      var len = arr.length;

      if(len == 0){

        return 0;

      } else if (len == 1){

        return arr[0];

      } else {

        return arr[0] + sum(arr.slice(1));

      }

    }

    sum([1,2,3,4]) //10

利用 slice截取改变数组，再利用递归求和

---

8.对象和数组的转化

    Object.keys({name:'张三',age:14}) //['name','age']

    Object.values({name:'张三',age:14}) //['张三',14]

    Object.entries({name:'张三',age:14}) //[[name,'张三'],[age,14]]

    Object.fromEntries([name,'张三'],[age,14]) //ES10的api,Chrome不支持 , firebox输出{name:'张三',age:14}

---

9.过滤数组

[1,2,3].filter(item=>{return item>2}) //[3]

---

10.有一项满足

[1,2,3].some(item=>{return item>2}) //true

---

11.每一项是否满足

[1,2,3].every(item=>{return item>2}) //false

---

12.map遍历

[1,2,3].map(() => 0)     //[0,0,0]

原生JSforEach()和map()遍历

    共同点：

    1.都是循环遍历数组中的每一项。

    2.forEach() 和 map() 里面每一次执行匿名函数都支持3个参数：数组中的当前项item,当前项的索引index,原始数组input。

    3.匿名函数中的this都是指Window。

    4.只能遍历数组。

      foreach()

        参数：value数组中的当前项, index当前项的索引, array原始数组；

        数组中有几项，那么传递进去的匿名回调函数就需要执行几次；

        理论上这个方法是没有返回值的，仅仅是遍历数组中的每一项，不对原来数组进行修改；但是可以自己通过数组的索引来修改原来的数组；

      map()

        参数：value数组中的当前项,index当前项的索引,array原始数组；

        区别：map的回调函数中支持return返回值；return的是啥，相当于把数组中的这一项变为啥（并不影响原来的数组，只是相当于把原数组克                   隆一份，把克隆的这一份的数组中的对应项改变了）；

---

13.类数组转化

    Array.prototype.slice.call(arguments) //arguments是类数组(伪数组)

    Array.prototype.slice.apply(arguments)

    Array.from(arguments)

    [...arguments]

        //类数组：表示有 length属性，但是不具备数组的方法。

        //call、 apply：改变 slice里面的 this指向 arguments，所以 arguments也可调用数组的方法。

       // Array.from：将类似数组或可迭代对象创建为数组。

       // ...：将类数组扩展为字符串，再定义为数组。

14用*输出菱形

//打印行数是7

    var line=7;

    for(var i=0;i

        //前四行，每行递增两个

        if(i<=3) {

            for(var j=1;j<=line-i-4;j++) {

                document.write(' ');

            }

            for(var j=0;j

                document.write('*');

            }

        } else {

            for(var j=1;j<=i-line+4;j++) {

                document.write(' ');

            }

            //i=4,打印5个

            //i=5,打印3个

            //i=6,打印1个

            for(var j=(line-i)*2-1;j>0;j--) {

                document.write('*');

            }

        }

        document.write('
');

    }

15.9*9乘法表的打印方法

1.

for(var i=1;i<10;i++){

var oUl=document.createElement('ul');

document.body.appendChild(oUl);

for(var j=1;j<=i;j++){

var oLi=document.createElement('li');

oLi.innerText = i + '*' +j;

oUl.appendChild(oLi);

}

}

2.

document.write("

"); //最外层div

for (var i=1; i<=9; i++) { //行

document.write("

");

for (var j=1; j<=i; j++) {         //列

document.write(""+ i + "×" + j + "=" + i*j + "");

}

document.write("

");

}

document.write("

");