Proxy & Reflect 对象解析

🕗 发布于 2024-12-12 08:40 javascript 前端 typescript

概述

什么是 Reflect 对象

Reflect 静态方法

为什么 Proxy 一定要配合 Reflect 使用呢？

概述

Proxy 和 Reflect 都是 ES6 为了更好的操作对象而提供的新的 API，接下来探讨一下二者的作用与联系。

Proxy 可以对目标对象的读取、函数调用等操作进行拦截，然后进行操作处理。它不直接操作对象，而是像代理模式，通过对象的代理对象进行操作，在进行这些操作时，可以添加一些需要的额外操作。
Reflect 可以用于获取目标对象的行为，它与 Object 类似，但是更易读，为操作对象提供了一种更优雅的方式。它的方法与 Proxy 是对应的。

什么是 Reflect 对象

Reflect 对象是一个全局的普通对象。Reflect 的原型是 Object

// 验证 Reflect 的原型是否是 Object
let obj = {};
console.log(Reflect.__proto__ === Object.prototype); // true
console.log(obj.__proto__ === Reflect.__proto__); // true

为什么要添加 Reflect 对象呢？它这样设计的目的是为了什么？

将 Object 对象的一些明显属于语言内部的方法(比如Object.defineProperty)放到 Reflect 对象上，那么以后我们就可以从 Reflect 对象上可以拿到语言内部的方法（当前某些方法会同时存在于 Object 和 Reflect 对象上，未来的新方法会只部署在 Reflect 对象上。)
```
let obj = {
    x: 100,
    y: 200
}

// 普通调用方法
console.log(obj) // obj 的原型上有 get 和 set 方法
console.log(obj.x)
console.log(obj['x'])

// Reflect 调用方法
console.log(Reflect.get(obj, 'x'))
```
修改某些 Object 方法的返回结果，让其变得更合理。例如：使用 Object.defineProperty(obj, name, {}) 时，如果出现异常的话，会抛出一个错误，需要使用 try catch 去捕获，但是使用 Reflect.defineProperty(obj, name, desc) 则会返回 false
```
try {
  Object.defineProperty(target, property, attributes);
  // success
} catch (e) {
  // failure
}

// 新写法
if (Reflect.defineProperty(target, property, attributes)) {
  // success
} else {
  // failure
}
```

让 Object 操作变成函数行为

// 判断属性是否存在对象中
'name' in obj 
// 新写法
Reflect.has(obj,'name') 

// 删除对象中的属性
delete obj[name]
// 新写法
Reflect.deleteProperty(obj, 'name')

Reflect 静态方法

Reflect.get(target, prop, receiver)：查找并返回 target 对象的 prop 属性

let exam = {
    name: "Tom",
    age: 24,
    get info(){
        return this.name + this.age;
    }
}
Reflect.get(exam, 'name'); // "Tom"
 
// 当 target 对象中存在 prop 属性的 getter 方法， getter 方法的 this 会绑定 receiver
let receiver = {
    name: "Jerry",
    age: 20
}
Reflect.get(exam, 'info', receiver); // Jerry20
 
// 当 prop 为不存在于 target 对象的属性时，返回 undefined
Reflect.get(exam, 'birth'); // undefined
 
// 当 target 不是对象时，会报错
Reflect.get(1, 'name'); // Uncaught TypeError: Reflect.get called on non-object

Reflect.set(target, prop, value, receiver)：将 target 的 prop 属性值设置为 value。返回值为 boolean ，true 表示修改成功，false 表示失败。当 target 为不存在的对象时，会报错。

let exam = {
    name: "Tom",
    age: 24,
    set info(value){
        return this.age = value;
    }
}
exam.age; // 24
Reflect.set(exam, 'age', 25); // true
exam.age; // 25
 
// value 为空时会将 prop 属性清除
Reflect.set(exam, 'age', ); // true
exam.age; // undefined
 
/*
    当 target 对象中存在 prop 属性 setter 方法时，
    setter 方法中的 this 会绑定 receiver , 
    故修改的实际是 receiver 的属性
*/ 
let receiver = {
    age: 18
}
Reflect.set(exam, 'info', 1, receiver); // true
receiver.age; // 1
 
let receiver1 = {
    name: 'oppps'
}
Reflect.set(exam, 'info', 1, receiver1);
receiver1.age; // 1

Reflect.has(obj, prop)：是 prop in obj 指令的函数化，用于查找 prop 属性在 obj 对象中是否存在。返回值为 boolean。如果 obj 不是对象则会报错 TypeError。

let exam = {
    name: "Tom",
    age: 24
}
Reflect.has(exam, 'name'); // true

Reflect.deleteProperty(obj, property)：是 delete obj[property] 的函数化，用于删除 obj 对象的 property 属性，返回值为 boolean。如果 obj 不是对象则会报错 TypeError。

let exam = {
    name: "Tom",
    age: 24
}
Reflect.deleteProperty(exam , 'name'); // true
exam // {age: 24} 
// property 不存在时，也会返回 true
Reflect.deleteProperty(exam , 'name'); // true

Reflect.construct(obj, args)，等同于 new target(...args)

function exam(name, age){
    this.name = name;
    this.age = age
}
Reflect.construct(exam, ['Tom', 33]); 
// exam {name: "Tom", age: 33}

Reflect.getPrototypeOf(obj)：用于读取 obj 的 _proto_ 属性。在 obj 不是对象时不会像 Object 一样把 obj 转为对象，而是会报错。

class Exam{}
let obj = new Exam()
Reflect.getPrototypeOf(obj) === Exam.prototype // true

Reflect.setPrototypeOf(obj, newProto)：用于设置目标对象的 prototype

let obj ={}
Reflect.setPrototypeOf(obj, Array.prototype); // true
obj
// Array {}

Reflect.apply(func, thisArg, args)：等同于 Function.prototype.apply.call(func, thisArg, args) 。func 表示目标函数；thisArg 表示目标函数绑定的 this 对象；args 表示目标函数调用时传入的参数列表，可以是数组或类似数组的对象。若目标函数无法调用，会抛出 TypeError 。

Reflect.apply(Math.max, Math, [1, 3, 5, 3, 1]); // 5

Reflect.defineProperty(target, propertyKey, attributes)：用于为目标对象定义属性。如果 target 不是对象，会抛出错误。

let myDate= {}
Reflect.defineProperty(myDate, 'now', {
  value: () => Date.now()
}); // true
myDate
/**
{now: ƒ} 
    now: () => Date.now()
    [[Prototype]]: Object
**/

Reflect.getOwnPropertyDescriptor(target, propertyKey)：用于得到 target 对象的 propertyKey 属性的描述对象。在 target 不是对象时，会抛出错误表示参数非法，不会将非对象转换为对象。

var exam = {}
Reflect.defineProperty(exam, 'name', {
  value: true,
  enumerable: false,
})
Reflect.getOwnPropertyDescriptor(exam, 'name')
// { configurable: false, enumerable: false, value: true, writable: false}
 
 
// propertyKey 属性在 target 对象中不存在时，返回 undefined
Reflect.getOwnPropertyDescriptor(exam, 'age') // undefined

Reflect.isExtensible(target)：用于判断 target 对象是否可扩展。返回值为 boolean 。如果 target 参数不是对象，会抛出错误。

let exam = {}
Reflect.isExtensible(exam) // true

Reflect.preventExtensions(target)：用于让 target 对象变为不可扩展。如果 target 参数不是对象，会抛出错误。

let exam = {}
Reflect.preventExtensions(exam) // true
Reflect.isExtensible(exam)
// false

Reflect.ownKeys(target)：用于返回 target 对象的所有属性，等同于 Object.getOwnPropertyNames 与Object.getOwnPropertySymbols 之和。

var exam = {
  name: 1,
  [Symbol.for('age')]: 4
}
Reflect.ownKeys(exam) // ["name", Symbol(age)]

Reflect 应用场景

Reflect在 JS 开发中也有多种应用场景，以下是一些实例：

属性访问：在不直接操作对象的情况下，使用Reflect.get和Reflect.set来安全地访问和设置对象的属性。

const obj = { a: 1 };
const value = Reflect.get(obj, 'a');
console.log(value); // 1

Reflect.set(obj, 'b', 2);
console.log(obj.b); // 2

函数调用：使用Reflect.apply来调用函数，这在某些情况下比使用Function.prototype.apply更清晰。
```
function sum(a, b) {
  return a + b;
}

const result = Reflect.apply(sum, null, [1, 2]);
console.log(result); // 3
```

构造函数：使用Reflect.construct来创建对象，这为构造函数提供了一种新的使用方式。

function Person(name) {
  this.name = name;
}

const person = Reflect.construct(Person, ['Alice']);
console.log(person.name); // Alice

属性检查：使用Reflect.has来检查对象是否具有特定的属性，这比使用in操作符更直接。
```
const obj = { x: 1 };
const hasY = Reflect.has(obj, 'y');
console.log(hasY); // false
```

属性描述：使用Reflect.getOwnPropertyDescriptor来获取属性的描述，这对于属性的元编程非常有用。

const obj = { writable: true };
const descriptor = Reflect.getOwnPropertyDescriptor(obj, 'writable');
console.log(descriptor.enumerable); // true

什么是 Proxy

Proxy 的设计目的在于修改编程语言，修改某些操作方法的默认行为，等同于在语言层面做出修改，是元编程（meta programming），例如修改 set，get 方法
Proxy 可以对目标对象的读取、函数调用等操作进行拦截，然后进行操作处理。它不直接操作对象，而是像代理模式，通过对象的代理对象进行操作，在进行这些操作时，可以添加一些需要的额外操作。

Proxy 基本用法

一个 Proxy 对象由两个部分组成： target 、handler 。在通过 Proxy 构造函数生成实例对象时，需要提供这两个参数。target 即目标对象，handler 是一个对象，声明了代理 target 的指定行为。

let target = {
    name: 'Tom',
    age: 24
}
let handler = {
    get: function(target, key) {
        console.log(`getting ${key}`);
        return target[key]; // 不是target.key
    },
    set: function(target, key, value) {
        console.log(`setting ${key}`);
        target[key] = value;
    }
}
let proxy = new Proxy(target, handler)
proxy.name     // 实际执行 handler.get
proxy.age = 25 // 实际执行 handler.set

// getting name
// setting age
// 25
 

/*
    target 可以为空对象
*/ 
let targetEpt = {}
let proxyEpt = new Proxy(targetEpt, handler)

proxyEpt.name // 调用 get 方法，此时目标对象为空，没有 name 属性
proxyEpt.name = 'Tom' // 调用 set 方法，向目标对象中添加了 name 属性
proxyEpt.name // 再次调用 get ，此时已经存在 name 属性

// getting name
// setting name
// getting name
// "Tom"
 

/* 通过构造函数新建实例时其实是对目标对象进行了浅拷贝，
    因此目标对象与代理对象会互相影响
*/ 
targetEpt
// {name: "Tom"}
 

/*
    handler 对象也可以为空，相当于不设置拦截操作，直接访问目标对象
*/ 
let targetEmpty = {}
let proxyEmpty = new Proxy(targetEmpty,{})
proxyEmpty.name = "Tom"
targetEmpty 
// {name: "Tom"}

Proxy 实例方法

get(target, propKey, receiver)：用于 target 对象上 propKey 的读取操作

let exam ={
    name: "Tom",
    age: 24
}
let proxy = new Proxy(exam, {
  get(target, propKey, receiver) {
    console.log('Getting ' + propKey);
    return target[propKey];
  }
})
proxy.name 
// Getting name
// "Tom"

// get() 方法可以继承
// Object.create()创建一个新对象，并使用现有的对象作为新创建对象的原型（prototype）
let obj = Object.create(proxy);
obj.age
// Getting age
// 24

set(target, propKey, value, receiver)：用于拦截 target 对象上的 propKey 的赋值操作。如果目标对象自身的某个属性，不可写且不可配置，那么set方法将不起作用

let validator = {
    set: function(obj, prop, value) {
        if (prop === 'age') {
            if (!Number.isInteger(value)) {
                throw new TypeError('The age is not an integer');
            }
            if (value > 200) {
                throw new RangeError('The age seems invalid');
            }
        }
        // 对于满足条件的 age 属性以及其他属性，直接保存
        obj[prop] = value;
    }
};
let proxy= new Proxy({}, validator)
proxy.age = 100;
proxy.age           // 100
proxy.age = 'oppps' // 报错 Uncaught TypeError: The age is not an integer
proxy.age = 300     // 报错 Uncaught RangeError: The age seems invalid

receiver 表示原始操作行为所在对象，一般是 Proxy 实例本身，某种情况下，它也会代表继承 Proxy 的那个对象。

let handler = {
    set: function(target, propKey, value, receiver) {
        target[propKey] = receiver;
    }
};
let proxy = new Proxy({}, handler);
proxy.name= 'Tom';
proxy.name=== proxy // true
 
const exam = {}
/*
    设置一个对象的原型（即它的继承链）。
    这是一个ES6中新增的方法，用来替代旧的 __proto__ 属性
    exam.__proto__ === proxy
*/ 

Object.setPrototypeOf(exam, proxy)
exam.name = "Tom"
exam.name === exam // true

apply(target, ctx, args)：用于拦截函数的调用、call 和 reply 操作。target 表示目标对象，ctx 表示目标对象上下文，args 表示目标对象的参数数组。

function sub(a, b){
    return a - b;
}
let handler = {
    apply: function(target, ctx, args){
        console.log('handle apply');
        return Reflect.apply(...arguments);
    }
}
let proxy = new Proxy(sub, handler)
proxy(2, 1) 
// handle apply
// 1

has(target, propKey)：用于拦截 HasProperty 操作，即在判断 target 对象是否存在 propKey 属性时，会被这个方法拦截。此方法不判断一个属性是对象自身的属性，还是继承的属性

let  handler = {
    has: function(target, propKey){
        console.log("handle has");
        return propKey in target;
    }
}
let exam = {name: "Tom"}
let proxy = new Proxy(exam, handler)
'name' in proxy
// handle has
// true

construct(target, args)：用于拦截 new 命令。返回值必须为对象

let handler = {
    construct: function(target, args, newTarget){
        console.log("handle construct");
        return Reflect.construct(target, args, newTarget);
    } }
class exam = {
    constructor(name){
        this.name = name;
    }
}
let proxy = new Proxy(exam,handler)
new proxy("Tom")
// handle construct
// exam {name: "Tom"}

deleteProperty(target, propKey)：用于拦截 delete 操作，如果这个方法抛出错误或者返回 false ，propKey 属性就无法被 delete 命令删除。

defineProperty(target, propKey, propDesc)：用于拦截 Object.defineProperty，若目标对象不可扩展，增加目标对象上不存在的属性会报错；若属性不可写或不可配置，则不能改变这些属性。

let handler = {
    defineProperty: function(target, propKey, propDesc){
        console.log("handle defineProperty");
        return true;
    }
}
let target = {}
let proxy = new Proxy(target, handler)
proxy.name = "Tom"
// handle defineProperty
target
// {name: "Tom"}
 
// defineProperty 返回值为false，添加属性操作无效
let handler1 = {
    defineProperty: function(target, propKey, propDesc){
        console.log("handle defineProperty");
        return false;
    }
}
let target1 = {}
let proxy1 = new Proxy(target1, handler1)
proxy1.name = "Jerry"
// handle defineProperty
target1
// {}

getOwnPropertyDescriptor(target, propKey)：用于拦截 Object.getOwnPropertyD() ，返回值为属性描述对象或者 undefined 。

let handler = {
    getOwnPropertyDescriptor: function(target, propKey){
        return Object.getOwnPropertyDescriptor(target, propKey);
    }
}
let target = {name: "Tom"}
let proxy = new Proxy(target, handler)
Object.getOwnPropertyDescriptor(proxy, 'name')
// {value: "Tom", writable: true, enumerable: true, configurable: true}

getPrototypeOf(target)：主要用于拦截获取对象原型的操作。包括以下操作：

- Object.prototype._proto_
- Object.prototype.isPrototypeOf()
- Object.getPrototypeOf()
- Reflect.getPrototypeOf()
- instanceof

let exam = {}
let proxy = new Proxy({}, {
    getPrototypeOf: function(target){
        return exam;
    }
})
Object.getPrototypeOf(proxy) 
// {}


/*
    注意，返回值必须是对象或者 null ，否则报错。
    另外，如果目标对象不可扩展（non-extensible），getPrototypeOf 方法必须返回目标对象的原型对象
*/
let proxy = new Proxy({},{
    getPrototypeOf: function(target){
        return true;
    }
})
Object.getPrototypeOf(proxy)
// 报错 Uncaught TypeError: 'getPrototypeOf' on proxy: trap returned neither object nor n

isExtensible(target)：用于拦截 Object.isExtensible 操作，该方法只能返回布尔值，否则返回值会被自动转为布尔值

let proxy = new Proxy({}, {
    isExtensible: function(target){
        return true;
    }
})
Object.isExtensible(proxy) 
// true

/*
    注意：它的返回值必须与目标对象的isExtensible属性保持一致，否则会抛出错误。
*/
let proxy = new Proxy({}, {
    isExtensible: function(target){
        return false;
    }
})
Object.isExtensible(proxy)
// 报错 VM3444:6 Uncaught TypeError: 'isExtensible' on proxy: trap result does not reflect extensibility of proxy target (which is 'true')

ownKeys(target)：用于拦截对象自身属性的读取操作。主要包括以下操作：

- Object.getOwnPropertyNames()
- Object.getOwnPropertySymbols()
- Object.keys()
- or...in

let target = {
  name: "Tom",
  age: 24
}
let proxy = new Proxy(target, {
    ownKeys(target) {
        return ['name'];
    }
})
Object.keys(proxy)
// ['name']


/*
    返回结果中，三类属性会被过滤：
        - 目标对象上没有的属性
        - 属性名为 Symbol 值的属性
        - 不可遍历的属性
*/
let target = {
  name: "Tom",
  [Symbol.for('age')]: 24,
};
// 添加不可遍历属性 'gender'
Object.defineProperty(target, 'gender', {
  enumerable: false,
  configurable: true,
  writable: true,
  value: 'male'
});
let handler = {
    ownKeys(target) {
        return ['name', 'parent', Symbol.for('age'), 'gender'];
    }
};
let proxy = new Proxy(target, handler);
Object.keys(proxy)
// ['name']

方法返回的数组成员，只能是字符串或 Symbol 值，否则会报错。
若目标对象中含有不可配置的属性，则必须将这些属性在结果中返回，否则就会报错。
若目标对象不可扩展，则必须全部返回且只能返回目标对象包含的所有属性，不能包含不存在的属性，否则也会报错。

preventExtensions(target)：拦截 Object.preventExtensions 操作，该方法必须返回一个布尔值，否则会自动转为布尔值

// 只有目标对象不可扩展时（即 Object.isExtensible(proxy) 为 false ），
// proxy.preventExtensions 才能返回 true ，否则会报错
let proxy = new Proxy({}, {
  preventExtensions: function(target) {
    return true;
  }
});
// 由于 proxy.preventExtensions 返回 true，此处也会返回 true，因此会报错
Object.preventExtensions(proxy) // TypeError: 'preventExtensions' on proxy: trap returned truish but the proxy target is extensible
 
// 解决方案
let proxy = new Proxy({}, {
  preventExtensions: function(target) {
    // 返回前先调用 Object.preventExtensions
    Object.preventExtensions(target);
    return true;
  }
});
Object.preventExtensions(proxy)

setPrototypeOf：主要用来拦截 Object.setPrototypeOf 方法。返回值必须为布尔值，否则会被自动转为布尔值。若目标对象不可扩展，setPrototypeOf 方法不得改变目标对象的原型

let proto = {}
let proxy = new Proxy(function () {}, {
    setPrototypeOf: function(target, proto) {
        console.log("setPrototypeOf");
        return true;
    }
}
);
Object.setPrototypeOf(proxy, proto);
// setPrototypeOf

Proxy.revocable()，用于返回一个可取消的 Proxy 实例，这意味着可以创建一个代理，然后在某个时刻撤销它，使得代理不再有效。

let target = {};
let handler = {
  get: function(target, name) {
    return name in target ? target[name] : 42;
  }
};

let {proxy, revoke} = Proxy.revocable(target, handler);
console.log(proxy.a); // 42
proxy.a = 5;
console.log(proxy.a); // 5

revoke();

// 尝试访问代理将导致TypeError
console.log(proxy.a); 
// Uncaught TypeError: Cannot perform 'get' on a proxy that has been revoked

target
// {a: 5}

Proxy 应用场景

Proxy 在实际开发中有多种应用场景，以下是一些常见的例子：

数据验证：在对象属性赋值时进行数据类型或范围的验证，确保数据的有效性

let user = {};
let userProxy = new Proxy(user, {
  set: function(target, key, value) {
    if (key === 'age' && typeof value !== 'number') {
      throw new TypeError('Age must be a number');
    }
    target[key] = value;
    return true;
  }
});

try {
  userProxy.age = 'thirty'; // 将抛出错误
} catch (e) {
  console.error(e);
}

访问控制：控制对对象属性的访问权限，如在Web应用中根据用户角色限制对某些属性的访问

缓存机制：为对象的属性访问实现缓存，提高性能，尤其在复杂的计算属性或远程数据访问时

let cache = {};
let cachedFunctionProxy = new Proxy(function() {}, {
  get: function(target, name) {
    const args = Array.from(arguments).slice(2);
    const key = JSON.stringify(args);
    if (!cache[key]) {
      cache[key] = Reflect.apply(target, this, args);
    }
    return cache[key];
  }
});

let computeExpensiveValue = cachedFunctionProxy;
console.log(computeExpensiveValue(1, 2, 3, 4)); // 计算并缓存结果
console.log(computeExpensiveValue(1, 2, 3, 4)); // 直接从缓存返回结果

日志记录：在访问或修改对象属性时自动记录日志，便于调试和追踪。
代理模式：实现代理模式，例如远程代理、虚拟代理、保护代理等，以控制对复杂对象的访问。

Reflect & Proxy 组合使用

Reflect 对象的方法与 Proxy 对象的方法一一对应，只要是 Proxy 对象有的方法，就能在Reflect 对象上找到对应的方法，所以 Proxy 对象的方法可以通过调用 Reflect 对象的方法获取默认行为，然后进行额外操作。

let exam = {
    name: "Tom",
    age: 24
}
let handler = {
    get: function(target, key){
        console.log(`getting ${key}`);
        return Reflect.get(target,key);
    },
    set: function(target, key, value){
        console.log(`setting ${key} to ${value}`)
        Reflect.set(target, key, value);
    }
}
let proxy = new Proxy(exam, handler)
proxy.name = "Jerry"
proxy.name
// setting name to Jerry
// getting name
// "Jerry"

为什么 Proxy 一定要配合 Reflect 使用呢？

那是为了触发代理对象拦截操作时，保持正确的 this 指向。

Proxy 中接受的 receiver 形参，表示代理对象本身或者继承了代理对象的对象。
Reflect 中传入的 recriver 实参，表示修改执行原始操作时的 this 指向。

let parent = {
  name: "Tom",
  get value() {
    return this.name;
  },
};
 
let proxy = new Proxy(parent, {
  get(target, key, receiver) {
    /*
        return target[key]
        return Reflect.get(target, key);
        此处若使用上述任意一句，打印出来的将是 Tom，而非小Tom，this 指向是 parent
    */
    return Reflect.get(target, key, receiver);
  },
});
 
let child = { name: "小Tom" };
// 设置 child 继承 代理对象 proxy
Object.setPrototypeOf(child, proxy);
 
console.log(child.value); // 小Tom

参考链接：

ES6 Reflect 与 Proxy - 代码学院 www.codexy.cn
为什么 Proxy 一定要配合 Reflect 使用？_proxy和reflect为什么要一起使用-CSDN博客

原文地址：https://blog.csdn.net/m0_73531461/article/details/144089437

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：Rerender A Video 技术浅析（二）：视频增强
下一篇：渗透利器-kali工具 (第四章-6) 爬虫编写

.NET(C#) 如何配置用户首选项及保存用户设置
.NET(C#) 如何配置用户首选项及保存用户设置
阅读更多2024-12-14
【最新】北大数字普惠金融指数数据集-省市县（2011-2023年）
郭峰,王靖一,王芳,孔涛,张勋,程志云.测度中国数字普惠金融发展:指数编制与空间特征[J].经济学(季刊),2020,19(04):1401-1418.时间跨度：省级和城市级指数时间跨度为2011-2
阅读更多2024-12-14
GESP202412 四级【Recamán】题解（AC）
a11ak−1−kkakak−1−kak−1k小杨想知道 Recamán 数列的前n项从小到大排序后的结果。手动计算非常困难，小杨希望你能帮他解决这个问题。
阅读更多2024-12-14
IDEA遇到EasyConnect中的网络资源无法访问的问题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。原文链接：https://blog.csdn.net/wanshanyu_/article/de
阅读更多2024-12-14
双目摄像头标定方法
此时已经完成标定，左下角为反投影误差，右边为外参可视化。将双目左右目拍的图像上传（左右目最好不少于20张）此时回到主页面，即可看到成功导出。把这些误差大的删除即可。
阅读更多2024-12-14
Servlet、omcat服务器架构与工作原理
Servlet是运行在服务器端的Java程序，它的主要职责之一是接收并处理来自客户端（如浏览器）的HTTP请求。当客户端发送一个请求到服务器时，Servlet可以解析请求中的信息，例如请求的URL路径
阅读更多2024-12-14
Vue生命周期钩子函数：深入解析与实践
作为高级Vue前端开发人员，对Vue组件的生命周期钩子函数有着深刻的理解是至关重要的。生命周期钩子函数是指在Vue组件的创建、更新、销毁等过程中，Vue自动调用的一系列方法。通过这些钩子函数，我们可以
阅读更多2024-12-14
安卓开发--使用android studio发布APP
app发布
阅读更多2024-12-14
数据结构与算法学习笔记----拓扑排序
@ author: 明月清了个风。
阅读更多2024-12-14
python 将数据保存到现有的Excel文件的新工作表
out_file = ‘query.xlsx’df1 = pd.DataFrame(out_data)若直接写入：df1.to_excel(out_file, index=False, sheet_n
阅读更多2024-12-14

Proxy & Reflect 对象解析

概述

什么是 Reflect 对象

Reflect 静态方法

Reflect 应用场景

什么是 Proxy

Proxy 基本用法

Proxy 实例方法

Proxy 应用场景

Reflect & Proxy 组合使用

为什么 Proxy 一定要配合 Reflect 使用呢？

相关文章