数组的基本方法
不改变原数组
var arr=[1,2,3]
填充空格
console.log(arr.join(":"),arr) //1:2:3 [1,2,3]
console.log(new Array(3).join("嗨")) //嗨嗨 new Array() 是三个空的长度 两个间隔
console.log(Array(3),[]) [undefined * 3] [] 长度为3 为0
合并数组
arr=[1,2,3]
arr.concat(4)
console.log(arr.concat([4]),arr) [1,2,3,4] [1,2,3]
数组的截取
slice start end 该参数是数组的下标 (含头不含尾)
负数从数组尾部开始算起 -1 最后一位 -2 倒数第二位
arr=[1,2,3]
console.log(arr.slice(0,1)arr) [1] [1,2,3]
改变原数组
数组的尾添加 返回值是新的长度
arr=[1,2]
arr.push(3)
console.log(arr) [1,2,3]
数组头部添加 返回的是新的长度
arr.unshift('222')
数组尾删除 返回值是删除的元素
console.log(arr.pop()) ['222',1,2] 3
数组头部删除 返回的是删除的元素
console.log(arr.shift()) '222'
排序
sort 排序 升序 a-b 降序 b-a
arr=[1,23,3,4,2]
function sortNumber(a,b){
return a - b
}
arr.sort(sortNumber)
console.log(arr) [1,2,3,4,23]
反转 reverse
arr=[1,2]
console.log(arr.reverse(),arr) [2,1] [2,1]
数组的增删改 splice
arr=[1,2,3]
console.log(arr.splice(0,1,'222'),arr) [1] ['222',2,3]
查找数组中的值
indexof lastindexof 查找数组参数首次出现的位置下标 最后一次出现的位置下标
其内用的是严格运算符 对NaN误判
arr.indexof(3,3) 第一个参数是查找的参数,第二个参数是从当前下标开始查起,返回值是查到参数的下标
find 找到第一个符合条件的数组成员 find (()=>{}) 数组接受三个参数 当前值 当前位置 原数组
findIndex 找到第一个符合条件的数组成员
includes() 第二个参数代表搜索的起始位置 默认为0 如果为负数 大于数组长度 默认从0 开始
Map Set 有一个has Map.prototype.has(key) 查的是键名
Set.prototype.has(value) 查的是键值
arr=[1,2,3,2,3]
console.log(arr.indexof(1),arr.indexof(3,3),arr.indexof(4)) 0 4 -1
console.log(arr.lastIndexof(1),arr.lastIndexof(3),arr.lastIndexof(4)) 0 4 -1
arr=[null,undefined,NaN]
console.log(arr.lastIndexof(null),arr.lastIndexof(undefined),arr.lastIndexof(NaN)) 0 1 -1
console.log(arr.includes(null),arr.includes(undefined),arr.includes(NaN)) true true true
arr=[0,1]
Array.prototype.push.apply(arr,[2,3])
console.log(arr) [0,1,2,3]
将类数组转化成数组
Array.from() 将对象转化成数组
只要有了length 属性 对象可以通过Array.from()转化成数组
只要部署了Iterator接口的数据结构,Array.from() 都可以将其转化成数组
for of 循环仅用于迭代,而普通对象不可迭代
扩展运算符调用也是要有遍历器接口的数据
Array.from() 提供了Map 的功能可以对他的值进行一些操作
arr={'0':'1','1':'2',length:2}
将类数组转化成数组
var newArr=[].slice.call(arr)
console.log(newArr,Array.from(arr)) [1,2] [1,2]
console.log([...Array.from(arr)]) [1,2]
arr={0:null,1:NaN,length:2}
console.log(Array.from(arr,value => typeof value)) ['object','number']
将一组值转化成数组
Array.of()
Array(3) 传入三个空 只有在传入不低于两个参数时才会返回新数组 参数个数为一个时 返回数组的长度
Array.of 是 用来替代 Array() new Array() 由于参数不同造成的空位结果
forEach filter every some 都会跳过空位 map会跳过空位但是会保留这个值
join toString 会将空位视为undefined 而undefined 和 null 会被处理成空字符串
Array.from() 扩展运算符 会将空位转化成undefined
entries keys values find findIndex 会将空位转化成undefined
console.log(Array.of(3,11,8)) [3,11,8]
console.log(Array(3).length,Array.of(3).length,Array(1,2),new Array(3).length,new Array(1,2)) // 3 1 [1,2] 3 [1,2]
填充数组
fill()
会把原来的值替换 主要用来对空数组的替换
fill 还可以接受第二 第三个参数 用来指定填充的起始位置和结束位置
console.log([1,2].fill(3)) //[3,3]
Es6 提供的遍历数组的方法
entries() 包含数组的key值和Value [].keys() values() 都会返回一个遍历器数组
可以用于 for of 进行遍历
iterator (遍历器的概念)
数据结构只要部署了Symbol.iterator 属性 就会被视为具有iterator 接口 就可以通过for of 循环遍历他的成员
Javescript 表示集合的数据结构 Array Object Set Map
数组原生默认具备 iterator接口
Map 需要统一的接口机制,来处理不同的数据结构
遍历器 就是这样一种机制 他是一种接口,为不同的数据结构 提供统一的访问机制,任何数据结构只要部署了遍历器接口,就可以完成遍历操作
空对象添加遍历器接口 可以通过for of 循环实现遍历
arr=[1,23,4]
const objs={}
objs[symbol.iterator] = arr[Symbol.iterator].bind(arr)
for(var i of objs){
console.log(i) 1, 23, 3
}
console.log(typeof objs) //object
console.log(Object.values(objs)) //[]
Set 类似于数组 其成员值都是唯一的 没有重复
Set 的操作方法 add(value)添加某个值 delete(value) 删除某个值
has(value) 返回布尔值 clear() 清除所有
Set 没有键名 只有键值 键名 键值都是同一个 keys 和 values 方法行为完全一致
var s=new Set();
arr=[1,2,3,4,2,1,null,null,undefined,undefined,NaN,NaN]
arr.forEach((value)=>{
s.add(value)
})
console.log(s) // 1,2,3,4,null,undefined,NaN
Map 数据结构
普通对象只接受字符串作为key 值,如果其他类型作为key值,会转化成字符串
Map 的操作方法 Set(key,value) 添加某个值 get(key) 获取某个值
has(key) 存在某个值 delete(key) 删除成功返回true clear() 清除所有
Map 里面添加对象 接受一个数组作为参数 new Map([['name','zhang']])
.set(1,'22') .set(1,'33') 对同一个key值赋值 后面会把前面的覆盖
.get('222') 如果要取一个未知的键返回的是undefined
只有对同一个对象的引用 Map才会将他视为同一个键
Map的键实际是和内存地址绑定在一起,内存地址不一样就被视为两个键 这就解决了同名属性的问题
Map 中将NaN视为同一个键 只要两个值严格相等 就被视为一个键 比如0 ===-0
s=new Map()
var pp={o:'1'}
s.set(pp,'ccc')
console.log(s) //key :{0:'1'} value :'ccc'
s=new Set([['foo',1],['bar',2]])
console.log(Array.from(s)) //[Array(2),Array(2)]
console.log(new Map(s),new Map(s).keys()) //0:{'foo'=>1} 1:{‘bar’=>2}
for(var i of s.values()){
console.log(i) //['foo',1] ['bar',2]
}
var map=new Map()
内存地址不同 代表两个不同的值 所以无法获取该键 同样的值在两个实例中被视为两个键
Map.set(['1'],'111')
console.log(map.get('1'))//undefined
k1=['1']
k2=['1']
map.set(k1,'111')
map.set(k2,'2222')
console.log(map.get(k1),map.get(k2)) //111 222
console.log([...map]) [Array(2),Array(2),Array(2)]
将Map 转化成对象 Map 所有的键都是字符串可以转化成对象
Map=new Map(['foo',1],['bar','222'])
obj=Object.create(null)
for(var [k,v] of map){
obj[k]=v
}
console.log(obj) //{foo:1,bar:'222'}
console.log(Object.keys({'a':1}),Array.from(map.keys())) //['a'] ['foo','bar']
new Map().keys() new Map.values()
普通对象 Object.keys({'s':111})
给类数组对象添加 Symbol.iterator 才可以遍历 给普通对象无效
Obj={0:1 , 1:2, length:2,[Symbol.iterator]:Array.prototype[Symbol.iterator]}
console.log(object.keys(obj)) ['0','1','length']
for(var i of obj){console.log(i)}