数组

数组的基本方法

  不改变原数组
       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)}