js物件本質上是鍵值對的集合，但是隻能用字串當做鍵

es6提供了map解構，它類似物件，但是鍵各種型別的值都可以

        1.set() 設定map的鍵
        2.get() 獲取map解構中鍵的值
        3.has() 返回一個布林值，判斷該值是否為map結構中的某個鍵
        4.delete() 刪除Map結構中的某個鍵
        5.clear() 清除Map結構所有成員

            var m = new Map()
            m.set('aaa','12')
            console.log
 
(m.get('aaa'))
            console.log(m.has('aaa'))
            m.delete('aaa')
            console.log(m.has('aaa'))

// 作為建構函式Map結構可以接收一組陣列作為引數，該陣列成員是一個有一個的鍵值對的陣列

    var map = new Map([['a','b'],[1,'c'],['title','terry']])
        console.log(map.size)
        console.log(map.has(1))
        console.log
 
(map.get(1))

    // map 接受陣列其實是接受一下演算法

        var item = [
            ["e","f"],
            ['c','abc'],
            ['d','efgggd']
        ]
        var map2 = new Map()
        item.forEach((key,value)=>{
            map2.set(key,value)
        })

    // 如果對同一個鍵多次賦值，會發生覆蓋

        var map3 =
 
 new Map()
        map3.set(1,'abc').set(1,'bcd')
        console.log(map3.get(1))

    // 如果讀取一個未知的鍵 map結構 返回undefined

    console.log(map3.get('abcd'))

    // 只有對同一個物件的引用map物件才會認為同一個鍵。

        var map4 = new Map()
        map4.set(['a'],'abcdef')
        console.log(map.get(['a']))

    // undefined  set和get 表面上是針對同一個鍵，但實際上這是兩個值，記憶體地址不一樣的  同理 如下

    // 雖然鍵名都一樣但是因為所在的記憶體地址不同 ，是兩個互不干擾的鍵名

        var map5 = new Map()
        var k1 = ['abc']
        var k2 = ['abc']
        map5.set(k1,'abcdef')
        map5.set(k2,'qwert').set('123','love')
        console.log(map5.get(k1))
        console.log(map5.get(k2))

    // Map的操作方法
        // 1 keys() 返回鍵名的遍歷器

        for(var key of map5.keys()){
               console.log(key)
        }

        // 2.values() 返回鍵值的遍歷器

            for(var value of map5.values()){
                console.log(value)
            }

        // 3. entries() 返回所有成員的遍歷器

            for(var[key,value] of map5.entries()){ 
                console.log(key +'----' +value)
            }
            // 等同於  for(var[key,value] of map5)

    // map結構轉為陣列結構

        var map6 = new Map([
               [1,123],[2,234],[3,345]
            ])
        console.log([...map6.keys()])
        console.log([...map6.values()])
        console.log([...map6.entries()])

    // 結合陣列的map方法和 filter() 方法 ，可以實現Map成員的遍歷和過濾

    var map7 =new Map().set(1,'a').set(2,'b').set(3,'c')
        var map8 = new Map(
            [...map7].filter(([k,v])=>{
                return k<3
            })
        )
        console.log(map8)

    // Map的forEach() 方法 也可以實現遍歷，第二引數用於繫結this

            map7.forEach((k,v,m)=>{
                console.log(k+'---'+v+'----')
            })

    //與其他資料結構的相互轉換
        //1 轉陣列 就是通過擴張運算子

      console.log([...map7])

        //2 陣列轉map 將陣列傳入Map結構就ok

    console.log(new Map([['a','aaaaa'],['b','bbbbbbbb']]))

        //3 map轉為物件  ==> 如果所有的鍵都是字串

    function strMaptoObj(strMap){
                let obj = Object.create(null)
                for(var [k,v] of strMap){
                    obj[k] = v
                }
                return obj;
            }
            let mymap = new Map().set('yes',true).set('no',false)
            var json = strMaptoObj(mymap)
            console.log(json)

        //4 物件轉為map

            function objtoMap(obj) {
                let setmap = new Map()
                for (let k of Object.keys(obj)){
                    setmap.set(k,obj[k])
                }
                return setmap
            }
            console.log(objtoMap({yes:true,no:false}))

        // map轉為json  如果鍵名都是字串

    function strMapString(strmap) {
         return JSON.stringify(strMaptoObj(strmap))
    }
   let mymap2 = new Map().set('yes',true).set('no',false)
            console.log(strMapString(mymap2))

        // map鍵名為非字串市 要用擴充套件運算子 轉為陣列json

            function mapToarrayJson(map) {
                return JSON.stringify([...map])
            }
            let myMap3 = new Map().set(true,7)
            console.log(mapToarrayJson(myMap3))

        // jSON 轉為map

            function jsontostrMap(jsonstr) {
                return objtoMap(JSON.parse(jsonstr))
            }
                                   console.log(jsontostrMap('{"yes":true,"no":false}'))

        // 有一種特殊情況，整個json 就是一個數組，且 每個陣列又是一個兩個成員的陣列，這時 她可以一一對應的轉為map結構

    function jsontoMap(jsonstr) {
                return new Map(JSON.parse(jsonstr))
            }
console.log(jsontoMap('[[true,7],[{"foo":3},["abc"]]]'))