javascript对数组进行内存释放

1、数组的创建、 2、数组的转换 3、数组的类型检测 4、数组相关方法

1、数组的了解

JS中数组是一种特殊的对象。JS中的数组其实是用对象模拟的数组，在典型的数组里，元素的数据类型相同，使用连续的内存存储，通过数字下标获取元素。但是JS中的数组不是这样的，JS数组中的元素的数据类型可以不相同，内存不一定连续（对象是随机存储的），不能通过数字下标存储，而是用字符串下标存储的。

2、数组的创建

数组的创建方式有三种：对象方式、字面量方式、Array.of()方法（ES6新增）。

对象方式

new Array(); // 创建一个空数组
  new Array('a'); // 创建包含一个字符串a的元素
  new Array(1, 2); // 创建一个包含1,2的数组
  new Array(2); // [empty × 2] 创建的是长度为2的空数组，不是只有一个数字2的数组，此处需要注意

此外，new关键字还可以省略。

字面量方式

let a = [1,2,3]

Array.of()

Array.of()与new Array的不同是设置一个参数时不会创建长度为参数大小的空数组。

let a = Array.of(2) // [2]

3、类型转换

可以将数组转换为字符串也可以将其他类型转换为数组

数组转字符串

console.log(([1,2,3]).toString()); // 1,2,3   大部分数据类型都可以使用.toString()方法转换为字符串
  console.log(String([1,2,3])); // 1,2,3
  console.log([1,2,3].join(',')); // 1,2,3

其他类型转数组

使用Array.from可将类数组转换为数组，类数组指包含length属性或可迭代的对象。
Array.from()接收两个参数，第一个参数为要转换的数据，第二个参数为类似于map函数的回调方法。

let str = 'abc';
  console.log(Array.from(str)); // ['a', 'b', 'c']

如果为对象设置了length属性，那么也可以将对象转换为数组，但要下标为数值或数值字符串

let obj = {
    0: 'aa',
    '1': 'bb',
    length: 2      
  }
  console.log(Array.from(obj)); // ['aa', 'bb']
  let newObj = Array.from(obj, (item) => {
    return item = item + '0';
  })
  console.log(newObj); // ['aa0', 'bb0']

注意：array.from()和map函数一样，可以返回一个新数组，不会改变原数组，不改变原数组是指当数组元素是基本原始类型时，改变不了，当是引用类型时，是地址不会改变，但是内容会改。

let obj1 = [1,2,3];
  Array.from(obj1, (item) => {
    item = item + '0';
  })
  console.log(obj1); // [1,2,3]
  let obj2 = [{a:1},{a:2}];
  Array.from(obj2, (item) => {
    item.a = item.a + '0';
  })
  console.log(obj2); // [{a:'10'},{a:'20'}]

4、数组的检测

Array.isArray()

console.log(Array.isArray([1,2,3])); // true

利用对象的toString方法

console.log(Object.prototype.toString.call([]) === "[object Array]"); // true

Object.prototype.toString()方法理解：
对于Object.prototype.toString()方法，会返回一个形如"[object xxx]"的 字符串。
如果对象的toString()方法未被重写，就会返回如上面形式的字符串

({}).toString(); // "[object Object]"
  Math.toString(); // "[object Math]"

但是大多数对象的.toString()方法都是重写了的，这时就可以用call()来调用

console.log(([]).toString()); // ''
console.log(Object.prototype.toString.call([])); // '[object Array]'

对于Object.prototype.toString.call(arg),若参数为null或undefined,直接返回结果。

Object.prototype.toString.call(null); // "[object Null]"
  Object.prototype.toString.call(undefined); // "[object Undefined]"

若不为null 或undefined，则为其对应数据类型。

5、数组的属性

length属性可以用来返回数组长度，当你修改一个数组的length值时，会导致数组项的删除与增加：

let str = [1,2,3];
  str.length = 1;
  console.log(str); // [1]
  str.length = 3;
  console.log(str); // [1, , ]

数组的索引：
1、使用索引改变数组
2、使用索引追加元素

let a = [1,2,3];
  a[5] = 6;
  console.log(a); // [1,2,3,empty × 2, 6]

6、数组的方法

1、push():
作用：向数组的末尾添加一项或多项
参数：ele1[,ele2[,...[,ele]]]
返回值：添加元素后数组的长度
原数组是否改变：是

let arr = [1, 2, 3];
  let temp = arr.push('a', 'b');
  console.log(arr, temp); // [1, 2, 3, "a", "b"] 5  （注意返回的是数组长度）

2、pop():
作用：删除数组的最后一项
参数：无
返回值：删除的那一项
原数组是否改变：是

let arr = [1, 2, 3];
  let temp = arr.pop();
  console.log(arr, temp); // [1, 2] 3

3、unshift():
作用：向数组头部开头添加一项或多项
参数：ele1[,ele2[,...[,ele]]]
返回值：添加元素后数组的长度
原数组是否改变：是

let arr = [1, 2, 3];
  let temp = arr.unshift('a', 'b');
  console.log(arr, temp) // ['a', 'b', 1, 2, 3] 5

4、shift():
作用：删除第一项
参数：无
返回值：删除的那一项
原数组是否改变：是

let arr = [1, 2, 3];
  let temp = arr.shift();
  console.log(arr, temp); [2, 3] 1

5、splice():
作用：删除、插入、替换数组项
参数：startIndex[,deleteCount[,item1[,...[,itemN]]]]
返回值：删除项组成的数组
原数组是否改变：是

let arr = [1, 2, 3];
  
  // 插入元素
  let temp = arr.splice(1, 0, 'a', 'b'); // 在索引1的位置插入元素'a'和'b'
  console.log(arr, temp); // [1, 'a', 'b', 2, 3] []

  // 删除元素
  let temp1 = arr.splice(1, 2); // 删除从索引1的位置开始的2项
  console.log(arr, temp1); // [1, 2, 3] ['a', 'b']

  // 替换一个元素
  let temp2 = arr.splice(1, 1, 'a'); //将索引1位置的元素替换为'a'
  console.log(arr, temp2); // [1，'a', 3] [2]

  // 替换多个元素
  let temp3 = arr.splice(0, 2, 'b', 'c'); //将索引0位置开始的两项，替换为'b'和'c'
  console.log(arr, temp3); // ['b', 'c', 3] [1, 'a']

  // 只传第一个参数，则删除从第一个参数指定位置到数组结尾的所有项
  let temp4 = arr.splice(0); // 从索引0的位置开始，删除后面的所有项
  console.log(arr, temp4); // [] ['b', 'c', 3]

6、copyWithin()
作用：将数组指定位置（start到end）的元素复制到当前数组的其他位置（target开始），这种复制会替换原位置的元素（ES6新增）
参数说明：target[,start[,end]]

• target: 复制的目标位置（包括），即要被替换的元素开始的位置。
• start: 要copy的元素的开始位置，默认0
• end: 要copy的元素的结束位置，默认为数组最后一个元素

返回值：替换之后的数组
原数组是否改变：是

let arr = [1, 2, 3, 4, 5];
  // 用索引0-4范围内的元素，替换索引3-4范围内的元素，因为要替换的位置只有两个，所以只将4,5替换成了1,2
  let temp = arr.copyWithin(3);
  console.log(arr, temp); // [1, 2, 3, 1, 2] [1, 2, 3, 1, 2]

  let arr1 = [1, 2, 3, 4, 5];
  // 用索引2-4范围内的元素，替换索引3-4范围内的元素，因为要替换的位置只有两个，所以只将4,5

替换成了3,4
let temp1 = arr1.copyWithin(3,2);
console.log(arr1, temp1); // [1, 2, 3, 3, 4] [1, 2, 3, 3, 4]

小结：copyWithin的作用就是在数组长度的范围内，复制start（包括）到end(不包括)范围内的元素，然后用上述的元素替换掉从target(包括)开始到数组结尾的元素，能替换多少就替换多少。

7、reverse():
作用：翻转原数组
参数：无
返回值：翻转后的数组
原数组是否改变：是

let arr = [1, 2, 3];
  let temp = arr.reverse();
  console.log(arr, temp); // [3, 2, 1] [3, 2, 1]

8、sort():
作用：数组排序
参数：compareFunction
参数说明：

• compareFunction返回值大于0时调换当前对比项的顺序，否则顺序不变；
• 参数可以不传，不传默认按照Unicode编码的顺序排列

返回值：排序后的数组
原数组是否改变：是

// 数组从小到大排序
  let arr = [1, 4, 6, 7, 8, 9, 2];
  let temp = arr.sort((a,b) => {
        return a - b;
  })
  console.log(arr, temp); // [1, 2, 4, 6, 7, 8, 9] [1, 2, 4, 6, 7, 8, 9]

  // 一个实用的数组排序的例子，根据对象元素的排序，排序对象在数组中的位置
  let objArr = [{id: 3, name: "lilei"},{id: 1, name: "hanmeimei"},{id: 2, name:                   "yimi"}];
  let tempArr = objArr.sort((a, b) => {
  // 按照id从小到大的顺序，对数组中的对象进行排序
  // 这个示例说明回调函数的形参a,b实际就是数组中当前进行比对的两个元素
      return a.id - b.id;
  }); 
  console.log(objArr); //  [{id: 1, name: 'hanmeimei'}, {id: 2, name: 'yimi'}, { id: 3, name: 'lilei' }]
  console.log(tempArr); // [{id: 1, name: 'hanmeimei'}, {id: 2, name: 'yimi'}, { id: 3, name: 'lilei'}]

9、concat():
作用：基于当前数组拼接数组
参数：value1[,value2[,...[,valueN]]]
参数说明：

• 参数的类型可以是任意类型。
• 不是数组类型直接按顺序拼接到数组末尾，数组类型的则将数组元素逐一取出拼接到数组末尾
• 不传则相当于复制数组
  返回值：拼接后的数组
  原数组是否改变：否

let arr = [1, 2];
let temp = arr.concat('a', {id: 1}, ['a', 'b']);
console.log(arr, temp); // [1, 2] [1, 2, "a", {id: 1}, "a", "b"]

// 用于复制数组
let arr = [1, 2];
let temp = arr.concat();
console.log(arr, temp); // [1, 2] [1, 2]

10、slice():
作用：基于当前数组的一项或多项创建一个新的数组
参数：startIndex[,[endIndex]]
参数说明：返回的元素包含startIndex位置的元素，但不包括endIndex位置的元素
返回值：返回截取的元素组成的数组
原数组是否改变：否

let arr = [0, 1, 2, 3, 4];
  let temp = arr.slice(1, 3); // 返回从索引1到索引3（不包括）位置之前的元素
  console.log(arr, temp); // [0, 1, 2, 3, 4] [1, 2]

  // 用于复制数组
  let arr = [0, 1, 2, 3, 4];
  let temp = arr.slice(0); // 返回从索引0（包括）位置到数组结尾的所有元素
  console.log(arr, temp); // [0, 1, 2, 3, 4] [0, 1, 2, 3, 4]

补：NodeList、arguments等类数组对象除了可以通过Array.from(NodeList)的方法转化为数组外，还可以通过Array.prototype.slice.call(NodeList)的方法实现相同的效果

let str = '123';
  let arr = Array.prototype.slice.call(str);
  console.log(arr); // ['1', '2', '3']

11、indexOf()：
作用：从数组开头查找元素在数组中的索引位置（ES5的方法）
参数：searchElement[,fromIndex]
返回值：searchElement在数组中的索引，没找到searchElement则返回-1
原数组是否改变：否

let arr = [1, 2, 3, 4, 5, 6, 2];
  // 从数组开头开始查找
  let temp = arr.indexOf(2);
  console.log(temp); // 1
  //从指定位置开始查找
  let temp1 = arr.indexOf(2, 3); // 从索引3（包括）的位置向后查找元素2
  console.log(temp1); // 6

12、lastIndexOf():
作用：从数组结尾查找元素在数组中的索引位置（ES5的方法）
参数：searchElement[,fromIndex]
返回值：searchElement在数组中的索引，没找到searchElement则返回-1
原数组是否改变：否

let arr = [1, 2, 3, 4, 5, 6, 2];
  // 从数组末尾开始查找
  let temp = arr.lastIndexOf(2);
  console.log(temp); // 6
  // 从指定的位置开始查找
  let temp1 = arr.lastIndexOf(2,3); // 从索引3（包括）的位置向前查找元素2
  console.log(temp1); // 1

13、every():
作用：对数组中的每一项执行给定函数，如果该函数对每一项都返回true，则返回true（ES5方法）
参数：callback[,thisArg]
参数说明：callback有三个参数item(当前项,必需)，index(当前项索引，可选)，array(数组对象本身，可选),thisArg:可选。对象作为该执行回调时使用，传递给函数，用作 "this" 的值。
如果省略了 thisValue ，"this" 的值为 "undefined"

返回值：true或false
原数组是否改变：涉及callback，不确定，详情见下面小结

let arr = [1, 2, 3, 4];
  let temp = arr.every((item, index, array) => {
        return item > 2;
  });
  console.log(arr, temp); // [1, 2, 3, 4] false

  let arr = [1, 2, 3, 4];
  let temp = arr.every(function(item, index, array){
        return item > this.id;
  },{id:2})
  console.log(arr, temp); // [1, 2, 3, 4] false

14、some():
作用：对数组中的每一项执行给定函数，如果该函数对任意一项都返回true，则返回true（ES5方法）
参数：callback[,thisArg]
参数说明：callback有三个参数item(当前项,必需)，index(当前项索引，可选)，array(数组对象本身，可选),thisArg:可选。对象作为该执行回调时使用，传递给函数，用作 "this" 的值。
如果省略了 thisValue ，"this" 的值为 "undefined"

返回值：true或false
原数组是否改变：涉及callback，不确定，详情见下面小结

let arr = [1, 2, 3, 4];
  let temp = arr.some((item, index, array) => {
      return item > 2;
  });
  console.log(arr, temp); // [ 1, 2, 3, 4 ] true

15、filter():
作用：对数组中的每一项运行给定函数，返回该函数返回true的项组成的数组（ES5方法）
参数：callback[,thisArg]
参数说明：callback有三个参数item(当前项,必需)，index(当前项索引，可选)，array(数组对象本身，可选),thisArg:可选。对象作为该执行回调时使用，传递给函数，用作 "this" 的值。
如果省略了 thisValue ，"this" 的值为 "undefined"

返回值：函数返回true的项组成的数组
原数组是否改变：涉及callback，不确定，详情见下面小结

let arr = [1, 2, 3, 4];
  let temp = arr.filter((item, index, array) => {
      return item > 2;
  });
  console.log(arr, temp); // [ 1, 2, 3, 4 ] [3, 4]

16、map():
作用：对数组中的每一项运行给定函数，返回每次函数调用的结果组成的数组（ES5方法）
参数：callback[,thisArg]
参数说明：callback有三个参数item(当前项,必需)，index(当前项索引，可选)，array(数组对象本身，可选),thisArg:可选。对象作为该执行回调时使用，传递给函数，用作 "this" 的值。
如果省略了 thisValue ，"this" 的值为 "undefined"

返回值：函数每次调用结果组成的数组
原数组是否改变：涉及callback，不确定，详情见下面小结

let arr = [1, 2, 3, 4];
  let temp = arr.map((item, index, array) => {
      return item * item;
  });
  console.log(arr, temp); // [ 1, 2, 3, 4 ] [ 1, 4, 9, 16]

17、forEach():
作用：对数组中的每一项运行给定函数。无返回值（ES5方法）
参数：callback[, thisArg]
参数说明：callback有三个参数item(当前项),index(当前项索引)，array(数组对象本身)
返回值：无
原数组是否改变：涉及callback，因此不确定，具体详情见下文中的原型方法的小结部分。

let arr = [1, 2, 3, 4];
  let temp = arr.forEach((item, index, array) => {
  // 不会有返回值，但可在这里执行某些操作
      return item * item;
  });
  console.log(arr, temp); // [ 1, 2, 3, 4 ] undefined

注意：forEach在所有项都遍历完成之前，无法像for循环一样提前终止循环

18、reduce():
作用：从数组的第一项开始，逐步遍历到最后，迭代数组的所有项（ES5方法）
参数：callback[, initialValue]
参数说明：
callback迭代函数，有四个参数（prev, cur, index, array）

• prev 前一个值，（initialValue || 数组第一项 || 上一次迭代的结果）
• cur 当前迭代项
• index 当前迭代项索引
• array 迭代的原数组

initialValue 迭代的基础值，不传基础值是数组第一项

返回值：数组迭代后，整体的迭代结果
原数组是否改变：涉及callback，因此不确定，具体详情见下文中的原型方法的小结部分。

//数组求和
  let arr = [1, 2, 3]
  let sum = arr.reduce((prev, cur, index, array) => {
        return prev + cur;
  })
  console.log(arr, sum); // [1, 2, 3] 6

  //传initValue基础值的实例
  let sum1 = arr.reduce((prev, cur, index, array) => {
        return prev + cur;
  }, 10)
  console.log(arr, sum1); // [1, 2, 3] 16

reduce源码的实现：

Array.prototype.myReduce = function(callback, initialValue){
        let i = 0;
        if(initialValue === undefined){
              prev = this[0];
              i = 1;
        } else {
              prev = initialValue;
              i = 0;     
        }
        for(; i < this.length; i++){
              prev = callback(prev, this[i], i, this);
        }
        return prev

  }

19、reduceRight():
作用：从数组的最后一项开始，逐步遍历到第一项，迭代数组的所有项（ES5方法）
参数：callback[, initialValue]
参数说明：
callback迭代函数，有四个参数（prev, cur, index, array）

• prev 前一个值，（initialValue || 数组第一项 || 上一次迭代的结果）
• cur 当前迭代项
• index 当前迭代项索引
• array 迭代的原数组
  initialValue 迭代的基础值，不传基础值是数组第一项

返回值：数组迭代后，整体的迭代结果
原数组是否改变：涉及callback，因此不确定，具体详情见下文中的原型方法的小结部分。

// 拼接字符串，从后向前迭代数组进行拼接
  let arr = ['h','e','l','l','o'];
  let str = arr.reduceRight((prev, cur, index, array) => {
        return prev + cur;
  });
  console.log(arr, str); // ["h", "e", "l", "l", "o"] "olleh"

20、find():
作用：查找数组中第一个符合条件的元素，返回该元素（ES6新增）
参数：callback[,thisArg]
参数说明：参数的使用同上述的forEach、every、map、some、filter方法一致
返回值：查找到则返回该元素，没找到返回undefined
原数组是否改变：涉及callback，因此不确定，具体详情见下文小结。

let arr = [1,2,3,4,5];
  let temp = arr.find((item, index, array) => {
        return item > 2;
  })
  console.log(arr, temp); // [1, 2, 3, 4, 5] 3

21、findIndex()：
作用：查找数组中第一个符合条件的元素所在位置的索引，并返回该索引值
参数：callback[, thisArg]
参数说明：参数的使用同上述forEach、every、map、some、filter方法一致
返回值：查找到则返回该索引值，没找到返回-1
原数组是否改变：涉及callback，因此不确定，具体见下文小结。

let arr = [1, 2, 3, 4, 5];
  let temp = arr.findIndex((item, index, array) => {
        return item > 2;
  })
  console.log(arr, temp); // [1,2,3,4,5] 2

22、fill():
作用：用指定元素，填充数组从start（包括）到end（不包括）之间的元素，如果该区间内已经有元素，直接替换掉（ES6新增）
参数：value[,start[,end]]
返回值：填充后的数组
原数组是否改变：是

let arr = [1, 2, 3, 4, 5];
  let temp = arr.fill('a', 2, 4);
  console.log(arr, temp); // [1, 2, 'a', 'a', 5] [1, 2, 'a', 'a', 5]

23、includes():
作用：判断数组中是否包含指定的元素（ES7新增）
参数：searchElement[,fromIndex]
返回值：true或false
原数组是否改变：否

let arr = [1,2,3,4,5];
  let temp = arr.includes(5);
  console.log(arr, temp); // [1, 2, 3, 4, 5] true

  // 这个方法弥补了indexOf查找元素时的一个不足，即查找NaN的误差
  let arr1 = [NaN, 'a'];
  let temp1 = arr1.includes(NaN);
  let temp2 = arr1.indexOf(NaN);
  console.log(temp1, temp2); // true -1

24、toString()、toLocalString():
作用：调用数组每一项的toString()方法，返回的是以逗号分隔的字符串
参数：无
返回值：转换后的字符串
原数组是否改变：否

let arr = [1, [1, 2,[4]], {name: 'aaa'}, 3];
  let temp = arr.toString();
  console.log(temp); // '1,1,2,4,[object Object],3'

25、join():
作用：将数组元素转化为字符串（调用每个元素的toString方法），并使用指定的分隔符（默认为逗号）进行拼接，返回拼接后的字符串
参数：分隔符，默认连接为逗号
返回值：拼接后的字符串
原数组是否改变：否

let arr = [1, [1,2,[4]],{name: 'a'}, 3];
  let temp = arr.join();
  console.log(temp); // '1,1,2,4,[object Object],3'

  // 数组求和,eval（) 函数可计算某个字符串，并执行其中的的 JavaScript 代码
  let arr1 = [1, 2, 3];
  console.log(eval（arr1.join('+'))); // 6

原型方法的总结：
1、数组的方法无外乎是对数组的增删改查、转换、迭代。增删改都会改变原有的数组，查、转换的方法不涉及callback参数的参数不会改变原数组，涉及到的则视情况而定，迭代方法因为均涉及到callback参数，因此也不确定。那为什么涉及到callback就不确定了呢？
首先如果直接在callback中操作原数组，那原数组肯定会改变。例如：

let arr = [1, 2, 3, 4];
  let temp = arr.forEach((item, index, array) => {
        //直接通过索引操作原数组
        array[index] *= item;
  });
  console.log(arr, temp); // [1, 4, 9, 16] undefined

如果不是直接操作原数组，而是操作callback的item参数时，如果item是基本数据类型则原数组中对应的该项元素不会改变，如果是引用类型（数组、对象、函数等）则改变，因为操作引用类型的值，实质是操作该值所在存储地址的内容，而item对应的原数组中的元素和item是同一引用地址，因此会导致原数组中对应元素的改变。

7、数组扩展运算符（ES6）

数组扩展运算符可以将数组转化为以逗号分割的参数序列。
应用场景：
1、将数组转化为参数序列直接传参，无需使用apply转化。、

let arr = [1, 2, 3];
  // apply写法
  Math.max.apply(null, arr)
  // 扩展运算符写法
  Math.max(...arr)

2、复制和拼接数组

let arr1 = [1,2,3];
  let arr2 = [4,5,6];
  let arr3 = [...arr1, ...arr2];

3、将字符串分解成真正的数组

console.log([...'abc']); // ['a','b','c']