数组

数组ES3方法

---

添加

push(); 向数组后面添加内容

unshift(); 向数组前面添加内容

concat(); 合并两个数组

 链接数组

 concat();  链接数组

 用法： arr.concat(arr1,...)  可链接多个

---

删除

pop(); 删除数组后面的内容

shift(); 删除数组前面的内容

返回值是当前删除的内容

---

 重点
 push   往数组后面添加   返回长度
 
 unshift   往数组前面添加     返回长度

 pop    删除数组最后一个  返回删除对象

 shift     删除数组前面一个  返回删除对象

建议使用 数组length删除方法

例如：

var arr= [ "a","b","c"]

arr.length=2;  alert(arr); 这里删除了c

---

子数组

splice()

删除，替换，添加

用法：

  arr.splice（0,1）  第一个参数指定从哪开始删（下标），参数二指定删除的个数

---

  splice（0,1，‘new’） 第一个参数指定从哪开始替换，第二个参数是替换的个数，第三
  
 个参数是要替换的内容。

---

  splice(1,0,'new')   第一个参数是找到要添加内容的下标位置，第二个参数0是既不删除也

  不替换，添加的意思。第三个参数是添加的内容。如果参数二是1，就是删除原有的，添加现
  在的。

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

splice() 方法向/从数组中添加/删除项目，然后返回被删除的项目。

用法：arrayObject.splice(index,howmany,item1,.....,itemX)

注释：

    该方法会改变原始数组。

参数：

    index    必需。整数，规定添加/删除项目的位置，使用负数可从数组结尾处规定位置。

    howmany    必需。要删除的项目数量。如果设置为 0，则不会删除项目。

    item1, ..., itemX    可选。向数组添加的新项目。

返回值：

    Array    包含被删除项目的新数组，如果有的话。


说明：。

splice() 方法可删除从 index 处开始的零个或多个元素，并且用参数列表中声明的一个或多个值

来替换那些被删除的元素。如果从 arrayObject 中删除了元素，则返回的是含有被删除的元素的数组。

slice()

功能:
从已有的数组中选取部分元素构成新数组

参数:
1.返回项的起始位置
2.返回项的结束位置

特性:
起始位置是数组的实际下标
结束位置是数组的实际下标-1
-1就是数组长度-1，截取的最后一位
用法：
let a=[0,1,2,3]
a.slice(1,-1)
 [1, 2]
     a数组没变

数组排序

reverse()

颠倒数组中元素的顺序

sort();

排序是根据编码排的

用法： var arr = [ 1,3,5,2,4,9,8,6]

   arr.sort();    alert（arr）  

   会根据编码把数字从小到大排序出来，sort排序默认是字符串方式排序的，只比第一位字符编码。

随机排序

arr.sort（function（a，b）｛return math.random（）｝）    打乱有序数组的顺序

sort 数组排序 0是不排序 -1是降序 默认升序

sort排序的内部原理：

排序函数里面的a和b是随机向该排序数组里面获取到的两个内容

    如果：

        a - b 如果是正数，则：调换a和b的位置

       a - b 如果是负数，则：不调换a和b的位置

        a - b 如果是0，则：不调动顺序

---

数组转换

toString()
toLocaleString()
join()

       [0,1,2,3].toString()   
        [0,1,2,3].toLocaleString()
        [0,1,2,3].join()
        '0,1,2,3'

Join 方法

join();把数组内每一项连接成一个字符串，没给参数会默认连接数组中括号内所有内容。

参数可设置连接字符串时的连接符。

========================================================================================

数组ES5，6方法

位置方法

  indexOf     -从数组的起始位置开始找
      
   参数 1.查找的项；2.表示查找起点的位置索引

  [1,2,3,4,5,6,7,8,5,4,5].indexOf(5,4) 第4个索引开始查找5

 lastIndexOf     从数组的结束位置开始查找

迭代方法

every

如果该函数每一项都返回的true，则返回true

filter

返回值为true的所有数组成员

forEach

无返回值

map

返回每次函数调用的结果数组

some

 有任意一项返回true，则返回true
 
 参数
 
 接受参数  1.要在每一项上运行的函数 2.运行该函数的作用域对象

 传入参数 1.数组的值item 2.该项在数组的位置index 3.数组对象本身array

缩小方法

 reduce 

 从数组起始位置开始遍历

 可以操作字符串，数组；第二个参数可以是数字0就是从0开始加法运算；第二个参数是[],就是数组的去重之类的操作；
 是对象{}就是对象的合并等方法；

-----------------------Q&&A---------------------------------

数组一般你会用哪些方法？
== 数组去重的方法？==
== 常见的数组的一些方法？去重的函数名字叫啥？原生push这些去重？==
== filter与map的区别？==
== 如何判断一个数据类型是数组,对象?==
js中提供了调用对象原型中的toString方法， Object.prototype.toString.call(obj)；因为很多对象继承的toString()方法被重写了，为了能够调用正确的toString()版本，也就是最原始的版本。可以使用Function.call()的方法，其中call可以这么理解，相当于obj去借用这个 Object.prototype.toString();

栗子:
Object.prototype.toString.call( new  Date());    //"[object Date]"
Object.prototype.toString.call(Window);        //"[object window]"
Object.prototype.toString.call(/./);           //"[object RegExp]"
创建判断类型文件 
dataType.js
/***********
 * 数据类型
 * @type {obj}
 */
export const getType = obj => Object.prototype.toString.call(obj).slice(8, -1).toLowerCase();
export const isNumber = obj => getType(obj) === "number";
export const isString = obj => getType(obj) === "string";
export const isArray = obj => getType(obj) === "array";
export const isObject = obj => getType(obj) === "object";
export const isBoolean = obj => getType(obj) === "boolean";
export const isFunction = obj => getType(obj) === "function";
export const isNull = obj => getType(obj) === "null";
export const isUndefined = obj => getType(obj) === "undefined";
export const isPromise = obj => getType(obj) === "promise";
export const isNode = node => !isNull(node) && !isUndefined(node) && Boolean(node.nodeName) && Boolean(node.nodeType);
export const isElement = element => isNode(element) && element.nodeType === 1;
在文件引用
import {isObject, isFunction, isBoolean, isNumber} from './dataType'

判断某个元素是否存在一个数组中?
indexOf
some
every
for 循环
两个数组,现在我们要把2个key值相同的合并怎么做?

 let list = [{ name: 'a', id: 1, age: 11 }, { name: 'b', id: 2, age: 22 }, { name: 'c', id: 3, age: 33 },{ name: 'a', id: 4, age: 44 }, { name: 'b', id: 5, age: 55 }];

使用hash对象:
        var hash = {};
        var i = 0;
        var arr1 = [];
        list.forEach(function (item) {
            var name = item.name;
            hash[typeof (name) + name] ? arr1[hash[name] - 1].id.push(item.id) :           hash[name] = ++i &&arr1.push({ id: [item.id], name: name, age: item.age })
        });
        console.log("arr1", arr1)
使用findIndex方法:
 思路:1.findIndex找出相同项的序号,2.对应的key push value值
        let arr2 = [];
        list.forEach((item, index) => {
            let b = arr2.findIndex(o => o.name === item.name);
            if (b == -1) {
                arr2.push({ name: item.name, age: item.age, id: [item.id] })
            } else {
                arr2[b].id.push(item.id)
            }
        })
        console.log("arr2", arr2)
利用reduce方法:
        // 1.选项的key不存在就把  name的value 当key存下
        // 2.当前选项的value    id的value     当value存下
        // 3.Object.keys 循环 只能合并2个key的
        let Obj = list.reduce((pre, cur, index) => {
            if (!pre[cur.name]) {
                pre[cur["name"]] = [cur.id]
            } else {
                pre[cur.name].push(cur.id)
            }
            return pre;
        }, {})
        let arr3 = Object.keys(Obj).map((item) => {
            return { name: item, id: Obj[item] }
        })
 console.log("arr3", arr3)      
/* [ { name: 'a', id: [ 1, 4 ] },
  { name: 'b', id: [ 2, 5 ] },
  { name: 'c', id: [ 3 ] }
] */

三个数组[1,11,111],[2,22,222],[3,33,333]怎么得到新的数组[1,2,3],[11,22,33],[111,222,333]这3个数组?

 var arr1 = [1, 11, 111], arr2 = [2, 22, 222], arr3 = [3, 33, 333];
        const changeArr = (arr1, arr2, arr3) => {
            var newArr = [[], [], []];
            for (let i = 0; i < arr1.length; i++) {
                newArr[i].push(arr1[i], arr2[i], arr3[i])
            }
            return newArr;
        }
let getArr = changeArr(arr1, arr2, arr3)
console.log(getArr, "newArr ")

找出2个数组里面相同的和不同的？

使用findIndex方法:
 思路:1.findIndex找出相同项的序号,2.对应的key push value值
   let arr4 = [1, 2, 3, 4, 5, 6], arr5 = [1, 2, 3, 7, 8, 9];
        var arr6 = [], arr7 = [], arr8 = [];
        arr5.forEach((item, index) => {
            let b = arr4.findIndex(o => o === item);
            if (b == -1) {
                arr6.push(item)
            } else {
                arr7.push(item)
            }
        })
arr8 = arr4.filter(itm => !arr7.includes(itm))
console.log("arr6", arr6, arr7, arr8)//[7,8,9] [1,2,3]  [4, 5, 6]

怎么把二维数组转化成一维数组？

const arr=[[1,2,3],[3,4],[5]];
[].concat.apply([],arr)
arr.flat()

var arr = [ [1, 2, 2], [3, 4, 5, 5], [6, 7, 8, 9, [11, 12, [12, 13, [14] ] ] ], 10];

编写一个程序将数组扁平化去并除其中重复部分数据，最终得到一个升序且不重复的数组？

arr.toString().split(",").sort((a,b)=>{ return a-b})

[ [1, 2, 2], [3, 4, 5, 5], [6, 7, 8, 9, [11, 12, [12, 13, [14] ] ] ], 10].toString()

'1,2,2,3,4,5,5,6,7,8,9,11,12,12,13,14,10'

.split(",")

['1', '2', '2', '3', '4', '5', '5', '6', '7', '8', '9', '11', '12', '12', '13', '14', '10']
.sort((a,b)=>{ return a-b})
['1', '2', '2', '3', '4', '5', '5', '6', '7', '8', '9', '10', '11', '12', '12', '13', '14']

ForEach和map的区别?
定义：
forEach(): 针对每一个元素执行提供的函数。
map(): 创建一个新的数组，其中每一个元素由调用数组中的每一个元素执行提供的函数得来。
区别:
forEach()方法不会返回执行结果，而是undefined。也就是说，forEach()会修改原来的数组。而map()方法会得到一个新的数组并返回。

一个数组套2个数组，取里面的数据，变成json数据;

var  arr=[['a','aa'],['b','bb']]; ===> {a:aa,b:bb}
    let obj = {};
    arr.forEach(item =>{
        obj[item[0]] = item[1]
    })
    console.log(obj)

== 数组去重==

== 双层循环==
思路:1.先for循环arr 2.再循环newArr 3.当新数组中的某一项与 原数组相等时break 跳出循环 进行下一轮的原数组循环 4.当新数组没找到的时候 新数组push旧数组这项数据;

        var arr = [1, '1', '1', 1, 2, true, false, true, 3, 2, 2, 1];
        const unique = (arr) => {
            var newArr = [];
            for (let i = 0; i < arr.length; i++) {
                for (var j = 0; j < newArr.length; j++) {
                    if (newArr[j] === arr[i]) { break; }
                }
                if (newArr.length === j) { newArr.push(arr[i]) }
            }
            return newArr;
        }
        let getArr = unique(arr)
        console.log(getArr, "newArr ")// [ 1, '1', 2, true, false, 3 ]

=外层循环 里面includes简化一层循环判断=

      var arr2 = [1, '1', '1', 1, 2, true, false, true, 3, 2, 2, 1];
        const unique2 = (arr) => {
            var newArr = [];
            for (let i = 0; i < arr.length; i++) {
                if (!newArr.includes(arr[i])) {
                    newArr.push(arr[i])
                }
            }
            return newArr;
        }
        let getArr2 = unique2(arr2)
        console.log(getArr2, "newArr2 ")// [ 1, '1', 2, true, false, 3 ]

外层循环 里面indexOf简化一层循环判断

        var arr3 = [1, '1', '1', 1, 2, true, false, true, 3, 2, 2, 1];
        const unique3 = (arr) => {
            var newArr = [];
            for (let i = 0; i < arr.length; i++) {
                if (newArr.indexOf(arr[i]) === -1) {
                    newArr.push(arr[i]);
                }
            }
            return newArr;
        }
        let getArr3 = unique3(arr3)
        console.log(getArr3, "newArr3 ")// [ 1, '1', 2, true, false, 3 ]

filter
思路: filter 第1参数:这一项内容 第2参数:序号 第3参数:数组
1.通过indexOf 找到的都是这个元素在数组出现的第一个的index
2.再判断是否相同
3.相同的就返回这个选项内容

        var arr4 = [1, '1', '1', 1, 2, true, false, true, 3, 2, 2, 1];
        const unique4 = (arr) => {
            var newArr = arr.filter((item, index, arr) => {
                return (arr.indexOf(item) === index)
            });
            return newArr;
        }
        let getArr4 = unique4(arr4)
        console.log(getArr4, "newArr4 ")// [ 1, '1', 2, true, false, 3 ]

键值对（key-value）

        //注意'1'与1 会发生隐式转换
        var arr6 = [1, '1', '1', 1, 2, true, false, true, 3, 2, 2, 1];
        const unique6 = function (arr) {
            var obj = {};
            var res = [];
            arr.forEach(item => {
                if (!obj[typeof item + item]) {
                    obj[typeof item + item] = true;
                    res.push(item);
                }
            });
            return res;
        }
        console.log(unique6(arr6), 'newArr6'); //  [ 1, '1', 2, true, false, 3 ]

new Set

        var arr5 = [1, '1', '1', 1, 2, true, false, true, 3, 2, 2, 1];
        const unique5 = (arr) => [...new Set(arr)]//Array.from(new Set(arr));
        let getArr5 = unique5(arr5) 
        console.log(getArr5, "newArr5 ")// [ 1, '1', 2, true, false, 3 ]

reduce

        //注意'1'与1 会发生隐式转换
        var arr7 = [1, '1', '1', 1, 2, true, false, true, 3, 2, 2, 1];
        const unique7 = function (arr) {
            let newArr = arr.reduce((pre, cur, index, arrs) => {
                if (arrs.indexOf(cur) === index) {
                    pre.push(cur)
                }
                return pre;
            }, [])
            return newArr;
        }
        console.log(unique7(arr7), 'newArr7'); // [ 1, '1', 2, true, false, 3 ]

== 两个数组合并成一个数组？==
请把两个数组 [‘A1’, ‘A2’, ‘B1’, ‘B2’, ‘C1’, ‘C2’, ‘D1’, ‘D2’] 和 [‘A’, ‘B’, ‘C’, ‘D’]，
合并为 [‘A1’, ‘A2’, ‘A’, ‘B1’, ‘B2’, ‘B’, ‘C1’, ‘C2’, ‘C’, ‘D1’, ‘D2’, ‘D’]。

let a1 =  ['A1', 'A2', 'B1', 'B2', 'C1', 'C2', 'D1', 'D2']
let a2 = ['A', 'B', 'C', 'D'].map((item) => {
  return item + 3
})

let a3 = [...a1, ...a2].sort().map((item) => {
  if(item.includes('3')){
    return item.split('')[0]
  }
  return item
})

思维导图