Array #

栈 #

后进先出，只能从一端

队列 #

先进先出

Array.isArray() #

判断是否为数组

不改变原数组 #

join() => 数组转字符串

split() => 字符串转数组

改变原数组 #

push() => 添加到末尾 => 返回新数组长度

unshift() => 添加到最前端 => 返回新数组长度

pop() => 移除最后一项 => 返回最后一项

shift() => 移除第一项 => 返回第一项

reserve() => 反转 => 返回反转后的数组

sort() => 排序 => 返回排序后的数组（默认升序）

splice() => 拼接 => 返回删除的项，若删除项为0，则返回空数组。（起始位置下标，删除项目，插入/替换的项，...）。删除：2个参数；插入：第2个参数为0,；替换：替换项数和插入项数不必相同；若插入/替换一个数组中每一项，可用扩展运算符...[]

不改变原数组 #

concat() => 合并 => 返回合并后的新数组，多参数，可以是值或数组，若是数组则会将数组中的每一项都添加到新数组中

slice() => 切割 => 返回切割后的新数组，1或2个参数，参数是下标，1参数下标项肯定会包括。1个参数时，返回1参数下标项到末尾项的新数组；2个参数，返回1参数下标项目到2参数下标项的新数组，2参数下标项不包括，若要包括可以在2参数上加上1

indexOf() and lastIndexOf() => 找到返回下标，找不到返回-1

迭代/遍历 #

对数组每一项执行指定函数，3参数，当前项值、当前项下标、数组本身

every() => 返布尔值，若每一项都返true，则返true，需return

some() => 返布尔值，若有一项返true，则返true，需return

• 改变原数组

forEach() => 无返回值

• 不改变原数组

map() => 返执行函数结果组成的数组，若无显示返回，则返回undefined，返回新数组

filter() => 过滤 => 返ture项组成的新数组，需return

map中return #

对象数组取指定属性组成新数组

let a = [
    {
       id: '1',
       name: '1'
    },{
        id: '2',
        name: '2'
    }
]
let b = a.map((item) => {
	return item.id  
})
console.log(b) // ['1','2']

归并 #

reduce() => 正序，返回一个最终值，2个参数，分别为在每一项上调用的函数（可选的）作为归并基础的初始值，需return，调用的函数接收4个参数，分别为前一个值，当前值、项的索引和数组对象，如数值累加，第2个可选的参数为归并基础的初始值

let arr = [1,2,3,4,5];
let result = arr.reduce((prev,current,index,array) => {
  return prev + current;
});
console.log(result);

reduceRight() => 倒序

类数组对象和可迭代对象 #

• 类数组对象：本质上只有一点，即必须有length属性，如

let a = {
    length: 3
}

• 可迭代对象：实现了Symbol.iterator方法属性，能通过for...of遍历的对象,javascript内部实现的有：Array、String、Map、Set、arguments、DOM data structures

将类数组对象转为数组：

ES5：[].slice.call() => 返回新数组，如

let array_like = {
  '0': 'a',
  '1': 'b',
  '2': 'c',
  length: 3
}
let arr = [].slice.call(array_like);
console.log(arr); // ['a','b','c']

将类数组或可迭代对象转为数组：

ES6：Array.from() => 返回新数组，可传入第二个参数，作用类似于数组的map方法，用来对每个元素进行处理，将处理后的值放入返回的数组中

let array_like = {
  '0': 'a',
  '1': 'b',
  '2': 'c',
  length: 3
}
let arr = Array.from(array_like);
console.log(arr); // ['a','b','c']
let arr1 = Array.from({length: 3});
console.log(arr1); // [,,]

创建0-n或1-n的数组 #

// ES6 Array.from()
// 1到n
let arr = Array.from({length: 3}, (value, index) => index+1); 
console.log(arr); // [1,2,3]
// 0到n
let arr = Array.from({length: 3}, (value, index) => index); 
console.log(arr); // [0,1,2]
// ES5
// 1到n
let arr = Array.apply(null,{length: 3}).map((value,index) => index+1);
console.log(arr); 
// 0到n
let arr = Array.apply(null,{length: 3}).map((value,index) => index);
console.log(arr); 

查找 #

find() => 返回第一个符合条件的项，若找不到则返回undefined，接受一个回调函数函数（和一个绑定回调函数的this对象，一般不用）参数，函数的参数有3个，分别为当前项、当前项的索引和数组本身，需return

findIndex() => 返回第一个符合条件的项的索引，若找不到则返回-1，接受一个回调函数函数（和一个绑定回调函数的this对象，一般不用）参数，函数的参数有3个，分别为当前项、当前项的索引和数组本身，需return

包含 #

includes() => 代替原先使用的indexOf()，返回布尔值，表示数组是否包含给定的值，比indexOf()更直观，不必判断是否为-1，同时indexOf()是内部使用全等符，会导致对NaN的误判，如

let arr = [1,2,NaN];
console.log(arr.indexOf(NaN));  // -1
console.log(arr.includes(NaN));  // true

转换 #

Array.of() => 将一组值转化为数组

由于数组构造函数对于参数的不同显示的结果有不同，如

let arr = Array(); // []
let arr1 = Array(3); // [undefined,undefined,undefined] 此时参数为长度
let arr2 = Array(1,2,3); // [1,2,3] 此时为数组每项的值

故使用Array.of()始终返回由参数值组成的数组，若无参数则为空数组