ES6-16【WeakMap与WeakSet、proxy与reflect】

一.补充

(1).Map转换为数组结构

const myMap = new Map();
myMap.set(true,7)
    .set({foo:3},['abc'])
    log(myMyp);//Map(2){true=>7,{...}=>Array(1)}   
    log([...myMap])//[Array(2),Array(2)]
    0:[true,7]
    1:[{...},Array(1)]
    length:2
 成功转为二维数组

(2).将数组转换为map

所以必需要是二维数组才能转换第二个值

const map = new Map([
    [true,7],
    [{foo:3},['abc']]
])

(3).map转变为对象

const myMap = new Map();
myMap.set(true,7)
    .set('a','abc');
function strMapToObj(strMap){
    let obj = Object.create(null);
    for(let [key,val] of strMap.entries()){
        obj[key] = val;
    }
    return obj
}   
strMapToObj(myMap ) 

(4).对象转换Map

function objToStrMap(obj){
    let map = new Map();
    for(let key of Object.keys(obj)){
        map.set(key,obj[key]);
    }
    return map
}
objToStrMap({true:7,no:false})

(5).map 和 array 对比

let map = new Map();
let arr = new Array();
增加
map.set('t',1);
arr.push({'t':1});

查询
map.has('t');
arr.find(item => item.t)

修改
map.set('t',2);
arr.forEach(item => item.t ? item.t = 2 : '')

删除
map.delete('t');
let index = arr.findIndex(item => item.t);
arr.splice(index,1)

结果显而易见，Map比array好使

(6).set与array对比

let set = new Set();
let arr = new [];

增加
set.add({t:1});
array.push({t:1});

查询
set.has({t:1});
arr.find(item => item.t)

修改
set.forEach(item => item.t ? item.t = 2:"")
array.forEach(item => item.t ? item.t = 2:"")

删除
set.forEach(item => item.t ? set.delete(item):'')
let index = arr.findIndex(item => item.t);
arr.splice(index,1)

(7).Map与Set与Array对比

let obj= {}
let map = new Map();
let set = new Set();

增加
map.set('t',1)
set.add({t:1})
obj['t'] = 1

查询
map.has('t')
set.has({t:1})
obj.hasOwnProperty('t')

修改
map.set('t',2);
set.add({t:2});
obj['t'] = 2

删除
map.delete('t')
set.delete({t:2})
delete obj['t']

二.WeakMap/WeakSet

(1).基础

打印

log(new WeakMap())
log(new WeakSet())

(2).WeakMap

key只能是对象

let wm = new WeakMap();
wm.set('t',2)//会报错

垃圾回收会直接回收不考虑引用

(3).WeakSet

WeakSet 只能是对象的集合，而不能是任何类型的任意值。

var ws = new WeakSet();
ws.add(1);//TypeError:Invalid  value used in weak set 
ws.add(Symbol);//TypeError:Invalid  value used in weak set 
var ws = new WeakSet();
var obj = {};
var foo = {};
ws.add(window);
ws.add(obj);
ws.has(window);//true
ws.has(foo);false
ws.delete(window);//true
ws.has(window);//false

• 与Set相比，WeakSet 只能是对象的集合，而不能是任何类型的任意值。
• WeakSet 不能遍历，是因为成员都是弱引用，随时可能消失，遍历不能保证成员的存在。可能刚刚遍历结束，成员就取不到了。WeakSet的一个用处是存储DOM节点，而不用担心这些节点从文档移除时，会引起内存的泄露。
• 没有size，也没有clear()

1.  

三.proxy

代理，有点vpn的意思，可以拦截多种方法从而实现代理的意思

let star = {
    name :'li**',
    age:'25',
    phone:'star 128888888888'
    
}

let agent = new Proxy(star,{
    get:function(target,key){
        if(key === 'phone'){
            return 'agent: 1281234567'
        }
        if(key === 'price'){
            return 12000
        }
        return target[key]
    },
    set:function(target,key,value){
        if(value < 10000){
            throw new Error('价格太低')
        }else{
            target[key] = value;
            return true
        }
    },
    has:function(target,key){
        log('请联系agent')
        if(key === 'customPrice'){
            return target[key]
        }else{
            return false;
        }
    }
})
log(agent.phone)//agent: 1281234567
log(agent.price)//12000
log(agent.name)//li**
log(agent.age)//25
agent.customPrice = 1500000;
log(agent.customPrice)//1500000
log('cunstomPrice' in agent);//请联系agent false
has是没有办法拦截for in的

四.Reflect

这些即为可以拦截的方法

 

也可以通过它来调用方法例如

obj.a == Reflect.get(obj,'a')
'a' in obj == Reflect.has(obj,'a')
同时它的报错不会直接抛出，而是返回为false,稍微友好一点，这样不用try catch捕捉，而是if判断

 

 

 

，