欢迎移步：https://blog.csdn.net/qq_27127385/article/details/105732936

JavaScript中对数组的定义

数组的标准定义是：一个存储元素的线性集合（collection），元素可以通过索引来任意存取，索引通常是数字，用来计算元素之间存储位置的偏移量。几乎所有的编程语言都有类似的数据结构。然而JavaScript 的数组却略有不同。
JavaScript 中的数组是一种特殊的对象，用来表示偏移量的索引是该对象的属性，索引可能是整数。然而，这些数字索引在内部被转换为字符串类型，这是因为JavaScript 对象中的属性名必须是字符串。数组在JavaScript 中只是一种特殊的对象，所以效率上不如其他语言中的数组高。
JavaScript 中的数组，严格来说应该称作对象，是特殊的JavaScript 对象，在内部被归类为数组。由于Array 在JavaScript 中被当作对象，因此它有许多属性和方法可以在编程时使用。

简单介绍数组的概念

创建数组

最简单的方式——声明一个数组变量：

var arr = []

上面会创建一个长度为0的空数组。

也可以在声明数组变量时，直接在[] 操作符内放入一组元素：

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

使用构造函数 —— new Array：

var arr = new Array(1,2,3,4,5)

构造参数方式只传入一个值，意味着指定数组的长度：

var arr = new Array(10)

与其他很多语言不同的是，数组的元素不必是同一种类型：

var arr = [1,null,true,{},'aa']

判断一个对象是否是数组 —— isArray：

Array.isArray(arr)

由字符串生成数组 —— split：

'sadf'.split('')  // ["a", "s", "d", "f"]

复制引用：

var arr1 = [1,2,3];
var arr2 = arr;

当把一个数组赋给另外一个数组时，只是为被赋值的数组增加了一个新的引用。当你通过原引用修改了数组的值，另外一个引用也会感知到这个变化。

浅复制：

for (var i = 0; i < arr1.length; ++i) {
  arr2[i] = arr1[i];
}

将原数组中的每一个元素都复制一份到新数组中。

深复制：

function deepClone(obj){
    //定义对象来判断当前的参数是数组还是对象
    let objClone = Array.isArray(obj)?[]:{};
    
    if(obj&&typeof obj == "object"){
        for(let key in obj){
            if(obj.hasOwnProperty(key)){
                //如果obj的子元素为对象，那么递归（层级遍历）
                if(obj[key]&&typeof obj[key] == "object"){
                    objClone[key] = deepClone(obj[key]);
                }else{
                //如果不是，直接赋值
                    objClone[key] = obj[key];
                }
            }
        }
    }   
    return objClone;
}

关于深、浅复制可以参考这篇文章

常用数组操作

查询是否包含 —— indexOf：

arr.indexOf('aa')

如果目标数组包含该参数，就返回该元素在数组中的索引；如果不包含，就返回-1。如果数组中包含多个相同的元素，indexOf() 函数总是返回第一个与参数相同的元素的索引。

数组转字符串——join：

// join()
arr.join(',');  // '1,2,3'

// reduce
arr.reduce(function(a,b){
  return a + ',' + b
})  // '1,2,3'

// toString()  
arr.toString() // '1,2,3'

合并数组——concat：

var arr2 = [].concat(arr) // 复制数组（浅复制）

作为参数的数组，其中的所有元素都被连接到调用concat() 方法的数组后面。

剪切数组——splice:

var arr2 = arr.splice() // 同时会修改arr

从现有数组里截取一个新数组。该方法的第一个参数是截取的起始索引，第二个参数是截取的长度。这个操作会影响到原数组。splice() 还有其他用法，下面介绍。

添加元素到尾部——push：

// push()
arr.push('aa')

// length
arr[arr.length] = 'aa'

添加元素到头部——unshift：

arr.unshift('aa')

// 手写实现 —— 低效
for(var i=arr.length;i>=0;i--){
  arr[i] = arr[i-1]
}
arr[0] = 'aa'

删除末尾元素——pop：

// pop()
arr.pop()

// length 
arr.length = arr.length -1

删除开头元素——shift：

// shift() 
arr.shift('aa')

// 手写实现 —— 低效
for(var i=0;i<arr.length;i++){
  arr[i] = arr[i+1]
}  // [1,2, 3, 4, undefined]
arr.length = arr.length -1 // [1,2,3,4]

中间位置添加和删除元素——splice：

使用splice() 方法为数组添加元素，需提供如下三个参数：

• 起始索引（也就是你希望开始添加元素的地方）；
• 需要删除的元素个数（添加元素时该参数设为 0）；
• 想要添加进数组的元素。

翻转排序——reverse：

// reverse()
arr.reverse()

// reduceRight + split
arr.reduceRight(function(a,b){
  return a + ',' + b
}).split(',')

大小排序——sort：

// sort
arr.sort(function(a,b){
  return a-b
})

循环遍历——forEach：

arr.forEach(function(a){
  console.log(a*2)
})  // 没有返回值

数组元素判断同真则返回真——every：

arr.every(function(item){
  return typeof item == 'number'
})

数组元素判断有一个为真就返回真——some：

arr.some(function(item){
  return typeof item == 'number'
})

累加操作——reduce/reduceRight：

// refuce 正向累加
arr.reduce(function(a,b){
  return a+b
})

// reduceRight 反向累加
arr.reduceRight(function(a,b){
  return a+b
})

遍历生成新数组——map：

arr.map(function(item){return item*2})

返回过滤成功的数组——filter：

arr.map(function(item){return item/2 = 2})