フロントエンド JavaScript におけるリフレクションとプロキシ

パブリッククラスUser{
   プライベート文字列名;
   プライベート日付誕生日;
       //....
   パブリック int 誕生日による年齢計算(){
            // .....
   }
}
// ユーザーを呼び出す u = new User("jack", new Date());
誕生日による年齢を計算します。

パブリック静的クラス User {
 プライベート文字列名;
 パブリック文字列getName() {
    名前を返します。
 }
   パブリック void setName(文字列名) {
     this.name = 名前;
   }
}

// リフレクションを使用してオブジェクト セッター メソッドを呼び出します。
パブリック静的 <T> T fill(Class<T> userClass, Map<String, Object> json) 例外をスローします {
        フィールド[] fields = userClass.getDeclaredFields();
        T ユーザー = userClass.newInstance();
        for (フィールド フィールド: フィールド) {
            // 最初の文字を大文字にします String name = field.getName();
            char[] arr = name.toCharArray();
            arr[0] = Character.toUpperCase(arr[0]);
            System.out.println(新しいString(arr));
            メソッド method = userClass.getDeclaredMethod("set" + new String(arr), field.getType());
            オブジェクトの戻り値 = method.invoke(user, json.get(name));
        }
        ユーザーを返します。
}

定数オブジェクト = {
  名前: 'ジャック',
  年齢: 12歳
  ユーザー情報を取得する() {
    this.name + 'age is ' + this.age を返します。
  }
}

Reflect.get(obj, 'name') // ジャック
Reflect.get(obj, '年齢') // 12
Reflect.get(obj, 'userInfo') // ジャックの年齢は12歳です

// レシーバー パラメーターが渡された場合、userInfo() 関数が呼び出されると、レシーバー オブジェクトが参照されます。
定数レシーバーオブジェクト = {
  名前: 'シャオミン'、
  年齢: 22
};

Reflect.get(obj, 'userInfo', receivedObj) // Xiaoming の年齢は 22 歳です

  名前: 'ジャック',
  年齢: 12歳
  updateAge(値)を設定する{
    this.age = value を返します。
  },
}
Reflect.set(obj, '年齢', 22);
オブジェクト年齢 // 22

// レシーバー パラメーターが渡された場合、updateAge() 関数が呼び出されると、レシーバー オブジェクトが参照されます。
定数レシーバーオブジェクト = {
  年齢: 0
};

Reflect.set(obj, 'updateAge', 10, レシーバーObj) // 
オブジェクト年齢 // 22
レシーバーオブジェクト.年齢 // 10

定数オブジェクト = {
  名前: 'ジャック',
}
名前内のオブジェクト // true
Reflect.has(obj, 'name') // 真

定数オブジェクト = {
  名前: 'ジャック',
}
オブジェクト名を削除 
Reflect.deleteProperty(obj, 'name')

関数 User(名前){
  this.name = 名前;
}
const user = 新しい User('jack');
Reflect.construct(ユーザー、['jack']);
Reflect.getPrototypeOf(obj)
Reflect.getPrototypeOf メソッドは、オブジェクトの __proto__ プロパティを読み取るために使用されます。

定数オブジェクト = {
  名前: 'ジャック',
}
Reflect.setPrototypeOf(obj, Array.prototype);
オブジェクトの長さ // 0

定数数値 = [1,2,3,4,5];
Math.max.apply(Math, nums) の最小値と最大値を適用します。
// Reflect.apply 経由で呼び出されます const min = Reflect.apply(Math.min, Math, nums);

定数obj = {};
Object.defineProperty(obj, 'プロパティ', {
  値: 0,
  書き込み可能: false
});

Reflect.defineProperty(obj, 'プロパティ', {
  値: 0,
  書き込み可能: false
});

定数オブジェクト = {
  名前: 'ジャック',
  年齢: 12歳
  ユーザー情報を取得する() {
    this.name + 'age is ' + this.age を返します。
  }
}
オブジェクト.getOwnPropertyNames(obj)
Reflect.ownKeys(obj) // ['name', 'age', 'userInfo']

const ユーザー = {名前: 'hello'}
const proxy = 新しいProxy(user, {
  get: function(target, property) { // プロパティの読み取り時にトリガーされます return 'hi';
  }
});
proxy.name // 'こんにちは'

定数ユーザー = {
  名前: 'ジャック'
}
// 属性が存在する場合にのみ値を返し、存在しない場合は例外をスローします。
const proxy = 新しいProxy(user, {
  取得: 関数(ターゲット、プロパティ) {
    if (!(ターゲット内のプロパティ)) {
       新しい ReferenceError をスローします (`${property} は存在しません。`);
    }
    ターゲット[プロパティ]を返します。
  }
});
proxy.name // ジャック
proxy.age // ReferenceError: age が存在しません。

// 属性が存在する場合にのみ値を返し、存在しない場合は例外をスローします。
const proxy = 新しいプロキシ({}, {
  取得: 関数(ターゲット、プロパティ) {
    if (!(ターゲット内のプロパティ)) {
       新しい ReferenceError をスローします (`${property} は存在しません。`);
    }
    ターゲット[プロパティ]を返します。
  }
});
obj = Object.create(プロキシ);
obj.name = 'こんにちは'
obj.name // こんにちは
obj.age // ReferenceError: age が存在しません。

// 文字タイプ属性の長さチェック let sizeValidator = {
  設定: 関数(ターゲット、プロパティ、値、レシーバー) {
    if (typeof value == 'string' && value.length > 5) {
       throw new RangeError('5文字を超えることはできません。');
    }
    ターゲット[プロパティ] = 値;
    true を返します。
  }
};

const バリデーター = 新しいプロキシー({}、sizeValidator);
obj = Object.create(validator); を作成します。
obj.name = '123456' // RangeError: 5 文字を超えることはできません。
obj.age = 12 // 12

定数ハンドラ = {
  (ターゲット、キー) {
    キー[0] === '_'の場合{
      false を返します。
    }
    ターゲットのキーを返します。
  }
};
var target = { _prop: 'foo', prop: 'foo' };
var proxy = 新しい Proxy(ターゲット、ハンドラー);
プロキシ内の '_prop' // false

定数obj = {};
const プロトコル = {};
定数ハンドラ = {
    getPrototypeOf(ターゲット) {
        console.log(target === obj); // 真
        console.log(this === ハンドラー); // true
        proto を返します。
    }
};

const p = 新しいプロキシ(obj、ハンドラ);
console.log(Object.getPrototypeOf(p) === proto); // 真

const ハンドラReturnsFalse = {
    setPrototypeOf(ターゲット、新しいProto) {
        false を返します。
    }
};

const newProto = {}、ターゲット = {};

const p1 = 新しいプロキシ(ターゲット、ハンドラーはFalseを返します);
Object.setPrototypeOf(p1, newProto); // TypeError をスローします
Reflect.setPrototypeOf(p1, newProto); // false を返す

const p = 新しいプロキシ({}, {
  isExtensible: 関数(ターゲット) {
    console.log('呼び出されました');
    return true; //true の値を表すために return 1; などを使用することもできます}
});

console.log(Object.isExtensible(p)); // "呼び出されました"
                                     // 真実

const p = 新しいプロキシ({}, {
  所有キー: 関数(ターゲット) {
    console.log('呼び出されました');
    ['a', 'b', 'c'] を返します。
  }
});

console.log(Object.getOwnPropertyNames(p)); // "呼び出されました"

const p = 新しいプロキシ({}, {
  拡張機能を防止: 関数(ターゲット) {
    console.log('呼び出されました');
    オブジェクト.preventExtensions(ターゲット);
    true を返します。
  }
});

console.log(Object.preventExtensions(p)); // "呼び出されました"
                                          // 間違い

定数ハンドラ = {
  適用 (ターゲット、ctx、引数) {
    Reflect.apply(...引数) を返します。
  }
};

定数ターゲット = 関数 () { };
定数ハンドラ = {
  適用: 関数 (ターゲット、thisArg、argumentsList) {
    console.log('呼び出されました: ' + argumentsList.join(', '));
    引数リスト[0] + 引数リスト[1] + 引数リスト[2]を返します。
  }
};

const p = 新しいプロキシ(ターゲット、ハンドラー);
p(1,2,3) // "呼び出された: 1, 2, 3" 6

定数ハンドラ = {
  構築 (ターゲット、引数、新しいターゲット) {
    新しいターゲット(...args)を返します。
  }
};

const p = 新しいプロキシ(関数() {}, {
  構成: function(target, argumentsList) {
    0を返します。
  }
});

new p() // 戻り値がオブジェクトではないため、エラーが報告されます const p = new Proxy({}, {
  構成: function(target, argumentsList) {
    戻る {};
  }
});
new p() // 対象オブジェクトは関数ではないのでエラー

const queuedObservers = 新しい Set();

const observe = fn => queuedObservers.add(fn);
const observable = obj => new Proxy(obj, {set});
// プロパティが変更されたときに自動的に監視関数を実行します。
関数set(ターゲット、キー、値、レシーバー) {
  const result = Reflect.set(ターゲット、キー、値、レシーバー);
  キューに入れられたオブザーバー。各オブザーバーをそれぞれ処理します。
  結果を返します。
}

const ユーザー = 観測可能({
  名前: 'ジャック',
  年齢: 20
});

関数userInfo() {
  console.log(`${user.name}, ${user.age}`)
}

観察(ユーザー情報);
user.name = 'Xiaoming'; // Xiaoming、20歳