proxy代理服务_2

deleteProperty 删除属性 delete关键词

var o={
    a:1,b:2,c:3};
Object.defineProperties(o,{
    
    d:{
    
        configurable:true,
        value:3
    }
})
var p=new Proxy(o,{
    
    deleteProperty(target,key){
    
        var disc=Object.getOwnPropertyDescriptor(target,key);
        if(!disc.enumerable){
    
            return false;
        }
        return delete target[key];
        // return Reflect.deleteProperty(target,key)
    }
})

delete p.a;
delete p.d;

var o={
    a:1,b:2,length:3};

var p=new Proxy(o,{
    
    deleteProperty(target,key){
    
        if(key==="length"){
    
            return false;
        }
        return Reflect.deleteProperty(...arguments);
    }
})


delete p.a;
delete p.length;
console.log(o)

这个代理不能删除添加和修改数据内容

var o={
    a:1,b:2};
var p=new Proxy(o,{
    
    set(target,key,value){
    
        return false;
    },
    defineProperty(target,key,disc){
    
        return false;
    },
    deleteProperty(target,key){
    
        return false;
    }
})

p.c=10;
p.d=1;
delete p.a;
console.log(o)

getOwnPropertyDescriptor获取描述对象代理

var o={
    a:1,b:2};
Object.defineProperty(o,"c",{
    
    value:3
})
var p=new Proxy(o,{
    
    getOwnPropertyDescriptor(target,key){
    
         var targetDisc=Reflect.getOwnPropertyDescriptor(...arguments);
         var disc={
    
            configurable:true,
            writable:targetDisc.writable,
            enumerable:targetDisc.enumerable,
            value:10
         }
       
        return targetDisc;
    }
})

var disc=Object.getOwnPropertyDescriptor(p,"c");
console.log(disc)

setPrototypeOf getPrototypeOf设置和获取原型链代理对象

var p=new Proxy(o1,{
    
    setPrototypeOf(target,proto){
    
        console.log("aa")
       proto.c=0;
        return Reflect.setPrototypeOf(target,proto);
    },
    getPrototypeOf(target){
    
        console.log("bb")
        return Reflect.getPrototypeOf(target);
    }
})



Object.setPrototypeOf(p,o);
console.log(o1);

var o2={
    e:10};
Object.setPrototypeOf(p,o2);
console.log(o1);

console.log(Object.getPrototypeOf(p));

console.log(p.__proto__)
p.__proto__={
    e:10}

has返回自身的对象属性代理

var o={
    a:1,b:2,c:3};
var o1={
    d:10,e:20};
Object.setPrototypeOf(o,o1);
var p=new Proxy(o,{
    
    has(target,key){
    
        // return Reflect.has(target,key)
        // return key in target;//会把所有对象属性和原型属性可枚举的都返回
        console.log("aa")
        return Object.hasOwn(target,key);//只返回自身的对象属性
  }
})

console.log(Object.hasOwn(p,"a"));
调用代理的has使用in
console.log("a" in p);

console.log("d" in p)
for(var key in o){
    
  console.log(key)
}

for(var key in p){
    
  console.log(key)
}

preventExtensions isExtensible可扩展代理

var o={
    a:1,b:2};
var p=new Proxy(o,{
    
    preventExtensions(target){
    
        if(target.a){
    
            target.c=10;
        }
        // return Object.preventExtensions(target);
        return Reflect.preventExtensions(target);
    },
    isExtensible(target){
    
        console.log("bb");
        Object.preventExtensions(target);
        return Reflect.isExtensible(target);
    }
})

Object.preventExtensions(p);

o.d=10;
console.log(o)


console.log(Object.isExtensible(p));

ownKeys获取keys

var o={
    a:1,b:2,c:3,_d:4};
var p=new Proxy(o,{
    
    ownKeys(target){
    
        console.log("aaa");
        var arr=Reflect.ownKeys(target);
        return arr.filter(item=>!/^_/.test(item));
    }
})

在使用Object.getOwnPropertyNames和Object.getOwnPropertySymbols都会触发ownKeys
Reflect.ownKeys(p)  也会调用owenKeys
var names=Object.getOwnPropertyNames(p);
var names1=Object.getOwnPropertySymbols(p);
var names =Reflect.ownKeys(p)
console.log(names)

apply设置this指向

function fn(a,b){
    
    console.log(this);
}

var o={
    a:1}
var p=new Proxy(fn,{
    
    // target 是fn
    // thisArg 是fn函数中this的指向
    // argArr 就是fn函数执行带入的实参
    apply(target,thisArg,argArr){
    
        // console.log("aa",thisArg,argArr)
        if(argArr.length===0) argArr=[1,2];
        if(thisArg===undefined) thisArg=o;
        return target.apply(thisArg,argArr);
    }
});


p(1,2);
p.apply({
    a:1},[1,2]);
p.call({
    a:1},1,2);
p.bind({
    a:1})(1,2);
p();