JS数组ES3-ES6常用方法

concat

     // 数组合并let arr = [1,2]let arrs = [1,2]console.log(arr.concat(arrs))//[1,2,1,2]

join

     let arr = [1,2]console.log(arr.join(','))//1,2 以逗号分割

pop

         // let arr = [1,2]// console.log(arr.pop()) //[2]  删除尾部元素

shift

     let arr = [1,2]console.log(arr.shift())//[1]头部删除

push

     let arr = [1,2]arr.push(3)console.log(arr)//[1,2,3]尾部添加

unshift

     let arr = [1,2]arr.unshift(0)console.log(arr)//[0,1,2]头部添加

reverse

     let arr = [1,2]console.log(arr.reverse())//[2,1]数组反转

slice

     let arr = [1,2,3,4]console.log(arr.slice(0,2))[1,2] //数组截取

sort

默认字典顺序从小到大如果是字符串的话默认前一位数，比如‘29’比‘100’小，比较的是前一位

     let arr = [1,2,3,4]console.log(arr.sort((a,b)=>{return b-a})) //排序

splice

     let arr = [1,2,3,4]arr.splice(2,2)//参1 起始删除的下标，参2 删除的数量console.log(arr)//[1,2]arr.splice(2,0,3)//参1 起始的下标，参2 0 不删除 参3 添加console.log(arr)//[1,2,3]arr.splice(2,1,4)参1 起始的下标，参2 删除 参3 替换console.log(arr)//[1,2,4]

toString

     let arr = [1,2,3,4]console.log(arr.toString())// 1，2，3，4转化字符串

toLocaleString

 let arr = [1,2,3,4]console.log(arr.toLocaleString())// 1,2,3,4转化本地数组,可以转化时间

forEach

     let arr = [1,2,3,4]arr.forEach(item=>console.log(item))//1 2 3 4

map

Map： ES6 提供了新的数据结构。它类似于对象，也是键值对的集合，但是“键”的范围不限于字符串，各种类型的值（包括对象）都可以当作键。Map 结构提供了“值—值”的对应。
size 属性：返回 Map 结构的成员总数。

     const map = new Map();map.set('foo', true);map.set('bar', false);console.log(map.size) // 2console.log(map) // 0: {"foo" => true} 1: {"bar" => false}

set(key, value)： set方法设置键名key对应的键值为value，然后返回整个 Map 结构。如果key已经有值，则键值会被更新，否则就新生成该键。返回的是当前的Map对象

     const m = new Map();m.set('aa', 6)        // 键是字符串m.set(262, 'standard')     // 键是数值m.set(undefined, 'nah')    // 键是 undefinedconsole.log(m)//链式写法let map = new Map().set(1, 'a').set(2, 'b').set(3, 'c');console.log(map)

get(key)： get方法读取key对应的键值，如果找不到key，返回undefined。

     const m = new Map();const hello = function () {console.log('hello');};m.set(hello, 'Hello ES6!') // 键是函数m.set(undefined, 'Undefined!') // 键是undefinedconsole.log(m.get(hello)); // Hello ES6!console.log(m.get(undefined)); // Undefined!console.log(m)

has(key)：返回一个布尔值，表示某个键是否在当前 Map 对象之中。

     const m = new Map();m.set('aaa', 6);m.set(111, 'standard');console.log(m.has('aaa'))     // trueconsole.log(m.has('bbb'))     // falseconsole.log(m.has(111))

delete(key)：删除某个键，返回true。如果删除失败，返回false。

     const m = new Map();m.set(undefined, 'aaa');console.log(m.has(undefined))     // truem.delete(undefined)console.log(m.has(undefined))       // false

clear()： clear方法清除所有成员，没有返回值

     let map = new Map();map.set('foo', true);map.set('bar', false);console.log(map.size) // 2map.clear()console.log(map.size) // 0

filter

filter() 方法创建一个新的数组，新数组中的元素是通过检查指定数组中符合条件的所有元素。
注意： filter() 不会对空数组进行检测。
注意： filter() 不会改变原始数组
Array的filter接收一个函数。但是和map不同的是， filter把传入的函数依次作用于每个元素，然后根据返回值是 true 还是false决定保留还是丢弃该元素。

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

去重操作
filter 接收的回调函数，其实可以有多个参数。通常我们仅使用第一个参数，表示Array的某个元素。回调函数还可以接收另外两个参数，表示元素的位置和数组本身

var Arr,arr = ['apple', 'strawberry', 'banana', 'pear', 'apple', 'orange', 'orange', 'strawberry'];Arr = arr.filter(function (element, index, self) {// console.log(self) //数组// console.log(index)//下标// console.log(element)//属性值return self.indexOf(element) === index;});console.log(Arr);

every

用于检测数组中所有元素是否都符合指定条件，若符合返回true，否则返回false

     let arr = [1,2,3,4]console.log(arr.every(item=> {return item >0}))//true

some

用于检测数组中的元素是否有满足指定条件的，若满足返回true，否则返回false

     var arr = [1,-56,80,-5];var main = arr.some(n => n > 0);console.log(main)    //输出:true

reduce

     // 回调函数中有4个参数。// prev（之前计算过的值），// next（之前计算过的下一个的值），// index，arr。把数组列表计算成一个单一值 。var arr = [10, 20, 30, 40]let list = arr.reduce(function (prev, next, index, arr) {return prev + next;console.log(prev)// 只打印第一个console.log(next)//不打印第一个})console.log(list);  //输出:100

Array.from

将对象或字符串转成数组，注意得有length

     let str = '12345'console.log(Array.from(str))

Array.of

     let str = '12345'console.log(Array.of(str))//[12345]

copyWithin

// 将3号位复制到0号位
[].copyWithin.call({length: 5, 3: 1}, 0, 3)
// {0: 1, 3: 1, length: 5}// 对象转数组(建议用es6的Array.from(Obj)转换比较直观)
Array.from({length: 5, 3: 1})
// [undefined, undefined, undefined, 1, undefined]// 转换完毕，进行处理
[undefined, undefined, undefined, 1, undefined].copyWithin(0,3);
// [1, undefined, undefined, 1, undefined]
// 恢复回类对象(忽略undefined,补上length)
[0:1,3:1,length:5]

find

用于找出第一个符合条件的数组成员

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

findIndex

返回第一个符合条件的数组成员的位置，如果所有成员都不符合条件，则返回-1

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

keys,values,entries

keys循环遍历key值，就是下标
valuse遍历valie值，就是属性值
entries遍历键值队列，属性：属性值

     var arr = ["a","b","c","d"];for(let index of arr.keys()){console.log(index);//0,1,2,3}for(let elem of arr.values()){console.log(elem);//a,b,c,d}for(let [index,elem] of arr.entries()){console.log(index,elem);//0 a,1 b,2 c,3 d,}

flat

flat() 方法会按照一个可指定的深度递归遍历数组，并将所有元素与遍历到的子数组中的元素合并为一个新数组返回。

     var arr = [1,[2,[3,[4,[5,[6]]]]]]console.log(arr.flat(Infinity))

flatmap

flatMap() 方法首先使用映射函数映射每个元素，然后将结果压缩成一个新数组。它与 map 和深度值1的 flat 几乎相同，但 flatMap 通常在合并成一种方法的效率稍微高一些。这里我们拿map方法与flatMap方法做一个比较。

     var arr1 = [1, 2, 3, 4];arr1.map(x => [x * 2]);// [[2], [4], [6], [8]]arr1.flatMap(x => [x * 2]);// [2, 4, 6, 8]// 只会将 flatMap 中的函数返回的数组 “压平” 一层arr1.flatMap(x => [[x * 2]]);// [[2], [4], [6], [8]]

Set

Set： ES6 提供了新的数据结构。它类似于数组，但是成员的值都是唯一的，没有重复的值。
Set本身是一个构造函数，用来生成 Set 数据结构。
Set函数可以接受一个数组（或者具有 iterable 接口的其他数据结构）作为参数，用来初始化。

size属性：返回Set实例的成员总数。

     let set = new Set();set.add('a');console.log(set.size) // 1set.add("b");console.log(set.size) //2

add(value)添加某个值，返回 Set 结构本身

     let set = new Set();set.add(1).add(2);console.log(set.size) // 2console.log(set)set.add(1).add(2).add(2).add(3);console.log(set.size) // 3 console.log(set)//2被添加两次,set可以去重

delete(value)：删除某个值，返回一个布尔值，表示删除是否成功

     let set = new Set();set.add(1).add(2).add(3);console.log(set.size) //3set.delete(2);console.log(set)// 1,3console.log(set.size) //2

has(value)：返回一个布尔值，表示该值是否为Set的成员。

     let set = new Set();set.add(1).add(2);console.log(set.has(1)) // trueconsole.log(set.has(2)) // trueconsole.log(set.has(3)) // false

clear()：清除所有成员，没有返回值。

     let set = new Set();set.add(1).add(2).add(2).add(3);set.clear();console.log(set.size)//0console.log(set)