精华内容
下载资源
问答
  • Reflect

    千次阅读 多人点赞 2021-09-11 13:30:38
    Reflect对象是—个全局的普通的对象。 Reflect的原型就是Object。Reflect是为操作对象而提供的新API。 主要作用有: 将Object对象的属千语言内 部的方法放到Reflect对象上。 将用老 Object方法报错的情况,改为...

    Reflect对象是—个全局的普通的对象。 Reflect的原型就是Object。Reflect是为操作对象而提供的新API。 

    主要作用有:

    1. 将Object对象的属千语言内 部的方法放到Reflect对象上。
    2. 将用老 Object方法报错的情况,改为返回false。
    3. 让Object操作变成函数行为。另外, Reflect与Proxy是相辅相成的,在Proxy上 有的方法,在Reflect就—定有。 

    Reflect对象—共有13个静态方法。例如: 

    Reflect.get(target, name, receiver)

    //读取—个对象的属性 
    let obj = { 
        name:"chen", 
    } 
    
    let result = Reflect.get(obj, "name") 
    
    console.log(result) //chen

    Reflect.set(target, name ,value, receiver)

    //设置该对象的属性借 
    let obj = { 
     name: 'chen' 
    }
    
    let result = Reflect.set(obj, "name", "shi") 
    console.log(result) //true 
    console.log(obj.name) //shi

    Reflect. apply(target,thisArg,args)

    //类似于Function.prototype.apply 
    //继示目标对象的特定方法 
    
    Reflect.apply(Math.floor, undefined, [1.75]); //输出: 1;

    Reflect.defineProperty(target, name ,desc)

    //类似Object.defineProperty 
    //返回借是—个Boolean的值 
    const obj = {}; 
    
    const res =  Reflect.defineProperty(obj,'b', {
        configurable: true, 
        enumerable: true 
    }) 
    
    console.log(res);//true
    展开全文
  • xbean-reflect-3.4.jar
  • reflect doc

    2012-06-27 00:12:02
    reflect doc
  • 符合Reflect.ownKeys规范的Reflect.ownKeys填充程序。 如果不可用或不Reflect.ownKeys调用其“ shim”方法对Reflect.ownKeys进行填充。 该软件包实现了接口。 它可以在ES3支持的环境中工作并符合。 最常见的用法...
  • 详解Reflect

    2020-10-24 09:16:45
    Reflect 是一个内置的对象,它提供拦截 JavaScript 操作的方法。这些方法与proxy handlers的方法相同。Reflect不是一个函数对象,因此它是不可构造的。 Reflect对象的设计的目的: 1. 将Object对象的一些明显属于...

    1.概述

    Reflect 是一个内置的对象,它提供拦截 JavaScript 操作的方法。这些方法与proxy handlers的方法相同。Reflect不是一个函数对象,因此它是不可构造的。

    Reflect对象的设计的目的:

    1. 将Object对象的一些明显属于语言内部的方法(比如Object.defineProperty),放到Reflect对象上。现阶段,某些方法同时在Object和Reflect对象上部署,未来的新方法将只部署在Reflect对象上。也就是说,从Reflect对象上可以拿到语言内部的方法。

    2.修改某些Object方法的返回结果,让其变得更合理。比如,Object.defineProperty(obj, name, desc)在无法定义属性时,会抛出一个错误,而Reflect.defineProperty(obj, name, desc)则会返回false。

    3.让Object操作都变成函数行为。某些Object操作是命令式,比如name in obj ,delete obj[name], 而Reflect.has(obj, name)和Reflect.deleteProperty(obj, name)让它们变成了函数行为。

    // 老写法
    'assign' in Object // true
    
    // 新写法
    Reflect.has(Object, 'assign') // true
    

    4.Reflect对象的方法与Proxy对象的方法一一对应,只要是Proxy对象的方法,就能在Reflect对象上找到对应的方法。这就让Proxy对象可以方便地调用对应的Reflect方法,完成默认行为,作为修改行为的基础。也就是说, 不管Proxy怎么修改默认行为,你总可以在Reflect上获取默认行为。

    Proxy(target, {
      set: function(target, name, value, receiver) {
        var success = Reflect.set(target, name, value, receiver);
        if (success) {
          console.log('property ' + name + ' on ' + target + ' set to ' + value);
        }
        return success;
      }
    });
    

    2.静态方法

    一共有13个静态方法

    1.Reflect.apply(target, thisArgument, argumentsList);

    • target目标函数。
    • thisArgument target函数调用时绑定的this对象。
    • argumentsList target函数调用时传入的实参列表,该参数应该是一个类数组的对象。

    对一个函数进行调用操作,同时可以传入一个数组作为调用参数。和Function.prototype.apply() 功能类似。

    Reflect.apply(Math.floor, undefined, [1.75]); 
    // 1;
    
    Reflect.apply("".charAt, "ponies", [3]);
    // "i"
    

    2.Reflect.construct(target, argumentsList[, newTarget]);

    • target:被运行的目标构造函数
    • argumentsList:类数组,目标构造函数调用时的参数。
    • newTarget(可选):作为新创建对象的原型对象的constructor属性, 参考 new.target 操作符,默认值为target。

    对构造函数进行 new 操作,相当于执行 new target(…args)。该方法的行为有点像 new 操作符 构造函数 , 相当于运行 new target(…args).

    function OneClass() {
        this.name = 'one';
    }
    function OtherClass() {
        this.name = 'other';
    }
    // 创建一个对象:
    var obj1 = Reflect.construct(OneClass, args, OtherClass);
    
    console.log(obj1); //OtherClass {name: "one"}
    console.log(obj1.constructor);  //ƒ OtherClass() { this.name = 'other';}
       
    // 与上述方法等效:
    var obj2 = Object.create(OtherClass.prototype);
    OneClass.apply(obj2, args);
    
    console.log(obj1.name); // 'one'
    console.log(obj2.name); // 'one'
    
    console.log(obj1 instanceof OneClass); // false
    console.log(obj2 instanceof OneClass); // false
    
    console.log(obj1 instanceof OtherClass); // true
    console.log(obj2 instanceof OtherClass); // true
    
    
    

    3.Reflect.defineProperty(target, propertyKey, attributes);

    • target:目标对象。
    • propertyKey:要定义或修改的属性的名称。
    • attributes:要定义或修改的属性的描述。

    Reflect.defineProperty 方法允许精确添加或修改对象上的属性, 和Object.defineProperty() 类似。

    区别:Object.defineProperty 返回一个对象,或者如果属性没有被成功定义,抛出一个 TypeError 。 相比之下,Reflect.defineProperty方法只返回一个 Boolean ,来说明该属性是否被成功定义。

    let obj = {}
    Reflect.defineProperty(obj, 'x', {value: 7})  // true
    obj.x                                         // 7
    

    4.Reflect.deleteProperty(target, propertyKey);

    • target:删除属性的目标对象。
    • propertyKey:需要删除的属性的名称。

    作为函数的delete操作符,相当于执行 delete target[name]。返回布尔值

    var obj = { x: 1, y: 2 };
    Reflect.deleteProperty(obj, "x"); // true
    obj; // { y: 2 }
    

    5.Reflect.get(target, propertyKey[, receiver]);

    • target:需要取值的目标对象
    • propertyKey:需要获取的值的键值
    • receiver:如果target对象中指定了getter,receiver则为getter调用时的this值。

    Reflect.get方法允许你从一个对象中取属性值。就类似于 target[name]。,但却是通过函数调用来实现。

    // Object
    var obj = { x: 1, y: 2 };
    Reflect.get(obj, "x"); // 1
    
    // Array
    Reflect.get(["zero", "one"], 1); // "one"
    

    6.Reflect.set(target, propertyKey, value[, receiver])

    • target:设置属性的目标对象。
    • propertyKey:设置的属性的名称。
    • value:设置的值。
    • receiver:如果遇到 setter,receiver则为setter调用时的this值。

    Reflect.set 方法允许你在对象上设置属性,如果更新成功,则返回true。它的作用是给属性赋值并且就像 property accessor 语法一样,但是它是以函数的方式。

    // Object
    var obj = {};
    Reflect.set(obj, "prop", "value"); // true
    obj.prop; // "value"
    
    // Array
    var arr = ["duck", "duck", "duck"];
    Reflect.set(arr, 2, "goose"); // true
    arr; //  ["duck", "duck", "goose"]
    
    

    7.Reflect.getOwnPropertyDescriptor(target, propertyKey);

    • target:需要寻找属性的目标对象。
    • propertyKey:获取自己的属性描述符的属性的名称。

    Reflect.getOwnPropertyDescriptor方法返回一个属性描述符,如果给定的属性存在于对象中,否则返回 undefined 。 与 Object.getOwnPropertyDescriptor() 的唯一不同在于如何处理非对象目标。

    Reflect.getOwnPropertyDescriptor({x: "hello"}, "x");
    // {value: "hello", writable: true, enumerable: true, configurable: true}
    
    Reflect.getOwnPropertyDescriptor({x: "hello"}, "y");
    // undefined
    
    Reflect.getOwnPropertyDescriptor([], "length");
    // {value: 0, writable: true, enumerable: false, configurable: false}
    
    **************Object.getOwnPropertyDescriptor() 的不同
    Reflect.getOwnPropertyDescriptor("foo", 0);
    // TypeError: "foo" is not non-null object
    
    Object.getOwnPropertyDescriptor("foo", 0);
    // { value: "f", writable: false, enumerable: true, configurable: false }
    

    8.Reflect.getPrototypeOf(target);

    • target:获取原型的目标对象。

    Reflect.getPrototypeOf 返回指定对象的原型 (即内部的 [[Prototype]] 属性的值) 。类似于 Object.getPrototypeOf()

    Reflect.getPrototypeOf({}); // Object.prototype
    Reflect.getPrototypeOf(Object.prototype); // null
    Reflect.getPrototypeOf(Object.create(null)); // null
    

    9.Reflect.has(target, propertyKey);

    • target:目标对象.
    • propertyKey:属性名,需要检查目标对象是否存在此属性。

    判断一个对象是否存在某个属性,和 in 运算符 的功能完全相同。

    Reflect.has({x: 0}, "x"); // true
    Reflect.has({x: 0}, "y"); // false
    
    // 如果该属性存在于原型链中,返回true 
    Reflect.has({x: 0}, "toString");
    

    10.Reflect.isExtensible(target)

    • target:检查是否可扩展的目标对象。

    类似于 Object.isExtensible().

    var empty = {};
    Reflect.isExtensible(empty); // === true 
    // ...but that can be changed. 
    Reflect.preventExtensions(empty); 
    Reflect.isExtensible(empty); // === false 
    
    //********与 Object.isExtensible() 的不同点
    Reflect.isExtensible(1);
    // TypeError: 1 is not an object
    Object.isExtensible(1);
    // false
    

    11.Reflect.ownKeys(target);

    • target:获取自身属性键的目标对象。

    返回一个包含所有自身属性(不包含继承属性)的数组。(类似于 Object.keys(), 但不会受enumerable影响).。它的返回值等同于Object.getOwnPropertyNames(target).concat(Object.getOwnPropertySymbols(target))

    Reflect.ownKeys({z: 3, y: 2, x: 1}); // [ "z", "y", "x" ]
    Reflect.ownKeys([]); // ["length"]
    
    

    12.Reflect.preventExtensions(target);

    • target:阻止扩展的目标对象。

    类似于 Object.preventExtensions()。返回一个Boolean。

    // Objects are extensible by default.
    var empty = {};
    Reflect.isExtensible(empty); // === true
    
    // ...but that can be changed.
    Reflect.preventExtensions(empty);
    Reflect.isExtensible(empty); // === false
    
    //*****与 Object.preventExtensions() 的不同点
    
    Reflect.preventExtensions(1);
    // TypeError: 1 is not an object
    Object.preventExtensions(1);
    // 1
    

    13.Reflect.setPrototypeOf(target, prototype)

    • target:设置原型的目标对象。
    • prototype:对象的新原型(一个对象或 null)。

    设置对象原型的函数. 返回一个 Boolean, 如果更新成功,则返回true。

    Reflect.setPrototypeOf({}, Object.prototype); // true
    
    // It can change an object's [[Prototype]] to null.
    Reflect.setPrototypeOf({}, null); // true
    
    // Returns false if target is not extensible.
    Reflect.setPrototypeOf(Object.freeze({}), null); // false
    
    // Returns false if it cause a prototype chain cycle.
    var target = {};
    var proto = Object.create(target);
    Reflect.setPrototypeOf(target, proto); // false
    

    更详细的可以去看:
    阮一峰《ECMAScript6》 https://es6.ruanyifeng.com/#docs/reflect

    Mozilla 开发者社区:https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Reflect

    展开全文
  • 反映字符串化 一个实现单个方法Reflect.stringify(ast)的JS库,它是SpiderMonkey的Reflect.parse函数的漂亮印刷版。
  • 有反射支持x 测试是否支持ES6 Reflect。 module.exports : boolean :eject_button: 指示是否存在Reflect 。 true ,如果它存在,并创建正确的类型,否则false 。 类型:出口成员
  • Reflect.apply 符合ESnext规范的Reflect.apply填充程序/ Reflect.apply / replacement可以使用到ES3。 该软件包实现了接口。 它可以在ES3支持的环境中工作并符合。 入门 npm install --save reflect.apply 用法/...
  • Reflect.ownKeys的伪造 module.exports Object :eject_button: 此方法返回目标对象自己的属性键的数组。 它的返回值等效于Object.getOwnPropertyNames(target).concat(Object.getOwnPropertySymbols(target)...
  • Reflect介绍

    2018-09-30 13:43:06
    Reflect 是一个内置的对象,它提供可拦截JavaScript操作的方法。方法与代理处理程序的方法相同。Reflect 不是一个函数对象,因此它是不可构造的。 new Reflect() //错误的写法 Reflect使用 Reflect提供了一些静态...

    Reflect 是一个内置的对象,它提供可拦截JavaScript操作的方法。方法与代理处理程序的方法相同。Reflect 不是一个函数对象,因此它是不可构造的。

    	new Reflect() //错误的写法
    

    Reflect使用
    Reflect提供了一些静态方法,静态方法是指只能通过对象自身访问的的方法
    1、Reflect.apply()
    2、Reflect.construct()
    3、Reflect.defineProperty()
    4、Reflect.deleteProperty()
    5、Reflect.enumerate()
    6、Reflect.get()
    7、Reflect.getOwnPropertyDescriptor()
    8、Reflect.getPrototypeOf()
    9、Reflect.has()
    10、Reflect.isExtensible()
    11、Reflect.ownKeys()
    12、Reflect.preventExtensions()
    13、Reflect.set()
    14、Reflect.setPrototypeOf()

    静态方法的使用:
    demo1:使用Reflect.get()获取目标对象指定key的value。

    let obj = {
        a: 1
    };
    
    let s1 = Reflect.get(obj, "a")
    console.log(s1) // 1
    

    demo1的get()方法,拦截obj对象,然后读取key为a的值。当然,不用Reflect也可以读取a的值。

    demo2:使用Reflect.apply给目标函数floor传入指定的参数。

    const s2 = Reflect.apply(Math.floor, undefined, [1.75]); 
    console.log(s2) // 1
    / /Reflect.apply()提供了3个参数,
    // 第一个参数是反射的函数,后面2个参数才是和数组的apply一致。
    

    demo2的例子我们可以理解成是拦截了Math.floor方法,然后传入参数,将返回值赋值给s2,这样我们就能在需要读取这个返回值的时候调用s2。

    demo3:使用Reflect.ownKeys获取对象的keys

    	console.log(Reflect.ownKeys({"a":0,"b":1,"c":2,"d":3})); //输出 :["a", "b", "c", "d"]
    	console.log(Reflect.ownKeys([])); // ["length"]      
    	var sym = Symbol.for("comet");      
    	var sym2 = Symbol.for("meteor");      
    	var obj = {
    		[sym]: 0, "str": 0, "773": 0, "0": 0,      
    	    [sym2]: 0, "-1": 0, "8": 0, "second str": 0
        };      
    	Reflect.ownKeys(obj);
    	 //输出:/ [ "0", "8", "773", "str", "-1", "second str", Symbol(comet), Symbol(meteor) ]
    

    Reflect.ownKeys的排序是根据: 先显示数字, 数字根据大小排序,然后是 字符串根据插入的顺序排序

    展开全文
  • 文章目录Reflect1.0 概述2.0 静态方法2.1 Reflect.get(target,name,receiver)2.2 Reflect.set(target,name,value,receiver)2.3 Reflect.has(obj,name)2.4 Reflect.deleteProperty(obj,name)2.5 Reflect.construct...

    Reflect

    1.0 概述

    Reflect 对象与 Proxy 对象一样, 也是ES6为了操作对象而提供的新 API, Reflect 对象的设计目的有这样几个.

    1. Object 对象的一些明显属于语言内部的语法(比如 Object.defineProperty) 放到 Reflect 对象上. 也就是说, 可以从 Reflect 对象上拿到语言内部的方法.
    2. 修改某些 Object 方法的返回结果, 让其变得更合理. 比如Object.defineProperty(obj, name, desc) 在无法定义属性时, 会抛出一个错误, 而 Reflect.defineProterty(obj,name, desc)则返回false`
    // 老写法
    try {
      Object.defineProperty(target, property, attributes);
      // success
    } catch (e) {
      // failure
    }
    
    // 新写法
    if (Reflect.defineProperty(target, property, attributes)) {
      // success
    } else {
      // failure
    }
    
    1. Object 操作都变成函数行为, 某些 Object 操作时命令式, 比如 name in objdelete obj[name], 而 reflect.has(obj,name)Reflect.deleteProperty(obj,name) 让它们变成了函数行为.

      const obj = {
          name: 'Gene',
      }
      // 老写法
      console.log('name' in obj);
      // 新写法
      Reflect.has(obj, 'name')
      
    2. Reflect 对象的方法与 Proxy 对象的方法一一对应, 只要是 Proxy 对象的方法, 就能在 Reflect 对象上找到对应的方法. 这就让 Proxy 对象可以方便的调用对应的 Reflect方法, 完成默认行为, 作为修改行为的基础, 也就是说, 不管 Proxy 怎么修改默认行为, 你总是可以在 Reflect 上获取默认行为.

    2.0 静态方法

    Reflect 对象一共有 13 个静态方法.

    • Reflect.apply(target, thisArg, args)
    • Reflect.construct(target, args)
    • Reflect.get(target, name, receiver)
    • Reflect.set(target, name, value, receiver)
    • Reflect.defineProperty(target, name, desc)
    • Reflect.deleteProperty(target, name)
    • Reflect.has(target, name)
    • Reflect.ownKeys(target)
    • Reflect.isExtensible(target)
    • Reflect.preventExtensions(target)
    • Reflect.getOwnPropertyDescriptor(target, name)
    • Reflect.getPrototypeOf(target)
    • Reflect.setPrototypeOf(target, prototype)

    2.1 Reflect.get(target,name,receiver)

    Reflect.get 方法查找并返回 target 对象的 name 属性, 如果没有该 name 属性, 则返回 undefined

    const obj = {
        name: 'Gene',
        age: 18,
        get baz() {
            return this.name + '-' + this.age
        }
    }
    console.log(Reflect.get(obj, 'name')); // Gene
    console.log(Reflect.get(obj, 'age')); // 18
    console.log(Reflect.get(obj, 'baz')); //Gene-18
    

    如果name 属性部署了读取函数(getter), 则读取函数的 this 和会绑定receiver

    const obj = {
        foo: 1,
        bar: 2,
        get baz() {
            return this.foo + this.bar
        }
    }
    const myReceiver = {
        foo: 10,
        bar: 10,
    }
    console.log(Reflect.get(obj, 'baz', myReceiver)); // 20
    

    如果第一个参数不是对象, Reflect.get 方法会报错.

    Reflect.get(1, 'foo') // 报错
    Reflect.get(false, 'foo') // 报错
    

    2.2 Reflect.set(target,name,value,receiver)

    Reflect.set 方法设置 target 对象的name 属性等于value

    var myObject = {
      foo: 1,
      set bar(value) {
        return this.foo = value;
      },
    }
    
    myObject.foo // 1
    
    Reflect.set(myObject, 'foo', 2);
    myObject.foo // 2
    
    Reflect.set(myObject, 'bar', 3)
    myObject.foo // 3
    

    如果 name 设置了赋值函数, 则赋值函数的 this 绑定receiver

    var myObject = {
      foo: 4,
      set bar(value) {
        return this.foo = value;
      },
    };
    
    var myReceiverObject = {
      foo: 0,
    };
    
    Reflect.set(myObject, 'bar', 1, myReceiverObject);
    myObject.foo // 4
    myReceiverObject.foo // 1
    

    注意, 如果 Proxy对象和 Reflect对象联合使用,前者拦截赋值操作,后者完成赋值的默认行为,而且传入了receiver,那么Reflect.set会触发Proxy.defineProperty拦截。

    let p = {
      a: 'a'
    };
    
    let handler = {
      set(target, key, value, receiver) {
        console.log('set');
        Reflect.set(target, key, value, receiver)
      },
      defineProperty(target, key, attribute) {
        console.log('defineProperty');
        Reflect.defineProperty(target, key, attribute);
      }
    };
    
    let obj = new Proxy(p, handler);
    obj.a = 'A';
    // set
    // defineProperty
    

    上面代码中,Proxy.set拦截里面使用了Reflect.set,而且传入了receiver,导致触发Proxy.defineProperty拦截。这是因为Proxy.setreceiver参数总是指向当前的 Proxy实例(即上例的obj),而Reflect.set一旦传入receiver,就会将属性赋值到receiver上面(即obj),导致触发defineProperty拦截。如果Reflect.set没有传入receiver,那么就不会触发defineProperty拦截。

    2.3 Reflect.has(obj,name)

    Reflect.has方法对应name in obj里面的in运算符。

    const obj = {
        name: 'Gene',
    }
    console.log(Reflect.has(obj, 'name')); // true
    console.log(Reflect.has(obj, 'age')); // false
    

    如果Reflect.has()方法的第一个参数不是对象,会报错。

    2.4 Reflect.deleteProperty(obj,name)

    Reflect.deleteProperty方法等同于delete obj[name],用于删除对象的属性。

    const myObj = { foo: 'bar' };
    
    // 旧写法
    delete myObj.foo;
    
    // 新写法
    Reflect.deleteProperty(myObj, 'foo');
    

    该方法返回一个布尔值。如果删除成功,或者被删除的属性不存在,返回true;删除失败,被删除的属性依然存在,返回false

    2.5 Reflect.construct(target,args)

    Reflect.construct方法等同于new target(...args),这提供了一种不使用new,来调用构造函数的方法。

    function Greeting(name) {
      this.name = name;
    }
    
    // new 的写法
    const instance = new Greeting('张三');
    
    // Reflect.construct 的写法
    const instance = Reflect.construct(Greeting, ['张三']);
    

    2.6 Reflect.getPrototypeOf(obj)

    Reflect.getPrototypeOf方法用于读取对象的__proto__属性,对应Object.getPrototypeOf(obj)

    const myObj = new FancyThing();
    
    // 旧写法
    Object.getPrototypeOf(myObj) === FancyThing.prototype;
    
    // 新写法
    Reflect.getPrototypeOf(myObj) === FancyThing.prototype;
    

    Reflect.getPrototypeOfObject.getPrototypeOf的一个区别是,如果参数不是对象,Object.getPrototypeOf会将这个参数转为对象,然后再运行,而Reflect.getPrototypeOf会报错。

    2.7 Reflect.setPrototypeOf(obj,newProto)

    Reflect.setPrototypeOf方法用于设置目标对象的原型(prototype),对应Object.setPrototypeOf(obj, newProto)方法。它返回一个布尔值,表示是否设置成功。

    const myObj = {};
    
    // 旧写法
    Object.setPrototypeOf(myObj, Array.prototype);
    
    // 新写法
    Reflect.setPrototypeOf(myObj, Array.prototype);
    
    myObj.length // 0
    

    如果无法设置目标对象的原型(比如,目标对象禁止扩展),Reflect.setPrototypeOf方法返回false

    Reflect.setPrototypeOf({}, null)
    // true
    Reflect.setPrototypeOf(Object.freeze({}), null)
    // false
    

    总结:

    上一章: ES6 Proxy构造函数拦截器, Proxy实例的常用方法

    下一章: Promise对象及相关实例方法介绍

    交流学习添加微信(备注技术交流学习): Gene199302
    在这里插入图片描述

    该博客为学习阮一峰 ES6入门课所做的笔记记录, 仅用来留作笔记记录和学习理解

    展开全文
  • unity reflectUnity Reflect, our new real-time 3D product for building information modeling (BIM) workflows, has been released from beta and is now available for purchase. Unity Reflect是我们的新实时...
  • Reflect.doc

    2011-03-11 11:28:06
    Reflect.doc Reflect.doc Reflect.doc Reflect.doc Reflect.doc Reflect.doc Reflect.doc
  • es6 javascript Reflect

    2016-12-03 11:27:00
    Reflect对象与Proxy对象一样, 也是 ES6 为了操作对象而提供的新 API。 Reflect对象的设计目的有这样几个。( 1) 将Object对象的一些明显属于语言内部的方法( 比如Object.defineProperty), 放到Reflect对象上。 ...
  • Reflect5.1

    2013-01-30 09:46:52
    Reflect 能够克隆你的系统,镜像硬盘, 备份数据, 是个非常好用和实用的工具.
  • java reflect utils

    2013-11-06 17:36:56
    java 映射 说明 可以帮助大家理解java reflect
  • Reflect V6.0

    2013-12-27 22:41:04
    .NET下反编译工具Reflect,绿色版。
  • 主要介绍了JavaScript Reflect Metadata实现详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 主要介绍了深入理解 TypeScript Reflect Metadata,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • hybrids-reflect-源码

    2021-05-27 09:20:42
    此插件公开了一个reflect工厂,该reflect工厂允许开发人员将单个属性定义为“反射”属性,这意味着对组件属性的更新将导致对赋值的DOM属性的更新,而对反射DOM属性的任何更改都将更新相关联的DOM属性。组件的属性。...
  • Reflect Image Viewer-开源

    2021-05-09 15:25:49
    Reflect是用于Linux的图像查看器,它仅提供基本功能,同时最大程度地减少了膨胀和用户的工作量。 界面简单,由直观的键盘命令驱动。 即使在旧的(300 Mhz)的计算机上,Reflect的性能也很好。
  • golang reflect 反射 简介.pdf
  • js代码-es6-reflect

    2021-07-16 16:34:02
    js代码-es6-reflect
  • js代码-Proxy and Reflect

    2021-07-16 15:40:45
    js代码-Proxy and Reflect
  • kotlin-reflect-1.3.20.jar

    2020-07-01 16:45:16
    kotlin-reflect-1.3.20.jar

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 287,151
精华内容 114,860
关键字:

reflect