let temp = "test";
if (true) {
    temp = "start"; // ReferenceError
    let temp;
}

typeof temp;
let temp; // ReferenceError

if (true) var temp = "test";
// 等同于
var temp;
if (true) temp = "test";

// SyntaxError: Lexical declaration cannot appear in a single-statement context
if (true) let temp = "test";

// IIFE 写法
(function () {
  var tmp = "test";
  // ...
}());

// 块级作用域写法
{
  let tmp = "test";
  // ...
}

var temp = "test";
window.temp // "test"

let temp = "test";
window.temp // undefined

const [a, [b], c] = [1, [2, 3], [4]]; // a: 1 b: 2 c: 4

const [a, [b], c] = new Set([1, [2, 3], [4]]); // a: 1 b: 2 c: 4

class Parent {
    name = "father";
}

class Test extends Parent{
    temp;
    constructor(temp) {
        super();
        this.temp = temp;
    }
}

const { name, temp } = new Test(114514);
name // "father"
temp // 114514

const obj = {
    p: [
        'Hello',
        { y: 'World' }
    ]
};

const { p: [x, { y }] } = obj;
x // "Hello"
y // "World"

const { p, p: [x, { y }] } = obj;

const arr = [1, 2, 3];
const { 0: first, [arr.length - 1]: last } = arr;
first // 1
last // 3

for ( let item of "wdnmd" ) {
    console.log( item );
}

element.innerHtml = `
    <article>
        <p>段落一</p>
    </article>
`

const foo = str => console.log( str );
foo`wdnmd`; // ["wdnmd"]
// 等同于
foo( ["wdnmd"] );

const foo = ( str, ...value ) => console.log( str, value );
foo`height ${18 * 10} age ${20 + 5}`; // [ "height ", " age ", "" ] [ 180, 25 ]
// 等同于
foo( [`height `, ` age `, ``], 180, 25 );

String.raw`\wdnmd`; // "\\wdnmd"
String.raw`age\n${20 + 5}`; // "age\\n25"

String.raw( [ "\wdnmd" ] ); // Uncaught TypeError: Cannot convert undefined or null to object

// 不会报错
const str = [ "\wdnmd" ];
str.raw = [ "\wdnmd" ];
String.raw( str ); // "wdnmd"

const str = "wdnmd";

str.includes( "n", 2 ); // true
str.startsWith( "n", 2 ); // true
str.endsWith( "n", 3 ); // true

const str = "wdnmd";
str.repeat(2); // "wdnmdwdnmd"
str.repeat(2.8); // "wdnmdwdnmd"
str.repeat(0); // ""
str.repeat(NaN); // ""
str.repeat(-0.9); // ""

"25".padStart( 10, "YYYY-MM-DD" ); // "YYYY-MM-25"
"2022".padEnd( 10, "YYYY-MM-DD" ); // "2022YYYY-M"

"x".padStart( 6 ); // "     x"

const s = " wdnmd ";

s.trim() // "wdnmd"
s.trimStart() // "wdnmd "
s.trimEnd() // " wdnmd"

"wdnmd".replaceAll("d", "c"); // "wcnmc"

const str = "this name is not my name";
str.replace(/n(a)m(e)/g, (...value) => {
    console.log(value);
    return "book";
}) // "this book is not my book"

// 打印结果
// [ "name", "a", "e", 5, "this name is not my name" ]
// [ "name", "a", "e", 20, "this name is not my name" ]

isFinite( "1" ); // true
Number.isFinite( "1" ); // false

isNaN( "wdnmd" ); // true
Number.isNaN( "wdnmd" ); // false

Number.isInteger( 25 ); // true
Number.isInteger( 25.0 ); // true

Number.isInteger( 3.0000000000000002 ); // true

Math.trunc( "114.514" ); // 114

1234 // 普通整数
1234n // BigInt

// BigInt 的运算
1n + 2n // 3n

2172141653n * 15346349309n; // 33334444555566667777n
// 普通整数无法保持精度
2172141653 * 15346349309; // 33334444555566670000

114n == 114; // true
114n === 114; // false

114n + 114; // TypeError

0b1101n // 二进制
0o777n // 八进制
0xFFn // 十六进制

typeof 114n; // "bigint"

+114n; // TypeError

BigInt(); // TypeError
BigInt( undefined); //TypeError
BigInt( null ); // TypeError
BigInt( "123n" ); // SyntaxError
BigInt( "abc" ); // SyntaxError

BigInt( 1.5 ); // RangeError
BigInt( "1.5" ); // SyntaxError

String( 1n ); // "1"

7n / 3n; // 2n

function foo( a, b ) {}
foo.length; // 2

function foo( a, b = 1 ) {}
foo.length; // 1

function foo( a, ...rest ) {}
foo.length; // 1

function foo() {}
foo.name; // "foo"

(() => {}).name; // ""

const foo1 = () => {};
foo1.name; // "foo1"

const foo = () => {};
foo.bind({}).name; // "bound foo"

(() => {}).bind({}).name; // "bound "

( new Function() ).name; // "anonymous"

try {
    // ...
} catch {
    // ...
}

const foo = ( a, b ) => void console.log( a, b );
foo( ...[1, 2] );  // 1 2

// ES5
Math.max.apply( null, [114, 514] );

// ES6
Math.max( ...[114, 514] );

// ES5
a = list[0];
rest = list.slice(1);

// ES6
[a, ...rest] = list;

// 字符串转数组
[..."wdnmd"]; // [ "w", "d", "n", "m", "d" ]
[...new Set( [1, 2] )]; // [1, 2]

const arrayLike = {
    0: "a",
    1: "b",
    2: "c",
    length: 3
};

Array.from( arrayLike ); // [ "a", "b", "c" ]

Array.from( { length: 3 } ); // [ undefined, undefined, undefined ];

Array.from( [ 1, 2, 3 ], ( item, key ) => {
    return item * ( key + 1 );
} );
// [ 1, 4, 9 ]

Array( 3 ); // [ , , , ]
Array( 1, 1, 4 ); // [ 1, 1, 4 ]

Array.of( 3 ); // [ 3 ]
Array.of( 1, 1, 4 ); // [ 1, 1, 4 ]

for ( const item of [ "a", "b" ].entries() ) {
    console.log( item );
}
// [ 0, "a" ]
// [ 1, "b" ]

[ 1, 2, 3 ].includes( 2 ); // true
[ 1, 2, 3 ].includes( 2, 2 ); // false

[ 1, 2, NaN ].indexOf( NaN ); // -1
[ 1, 2, NaN ].includes( NaN ); // true

const arr = [ 1, [ 2, [ 3, 4 ] ] ];
arr.flat(); // [ 1, 2, [ 3, 4 ] ]
arr.flat( 2 ); // [ 1, 2, 3, 4 ]
arr.flat( Infinity ); // [ 1, 2, 3, 4 ]

[ 1, , 3 ].flat(); // [ 1, 3 ]

const arr = [ 1, 2, 3, 4 ];
arr.flatMap( ( item, key ) => {
    return [ [ item * ( key + 1 ) ] ];
} );
// [ [ 1 ], [ 4 ], [ 9 ], [ 16 ] ]

new Array( 3 ); // [ empty × 3 ]
arr = [ 1, , 3 ]; // [ 1, empty, 3 ]

Array.from( [ 1, , 3 ] ); // [ 1, undefined, 3 ]
[ ...[ 1, , 3 ] ]; // [ 1, undefined, 3 ]

// 不缩写正常运行
const obj = {
    foo: function ( val ) {
        this.value = val;
    }
}
new obj.foo( "wdnmd" ); // foo { value: 'wdnmd' }

// 缩写后报错
const obj1 = {
    foo( val ) {
        this.value = val;
    }
}
new obj1.foo( "wdnmd" ); // TypeError: obj1.foo is not a constructor

const [ key1, key2 ] = [ Symbol(), Symbol("desc") ];
const obj = {
    [ key1 ]() {},
    [ key2 ]() {}
}
obj[ key1 ].name; // ""
obj[ key2 ].name; // "[desc]"

const obj = {
    get foo() {},
    set foo(value) {}
}
obj.foo.name; // TypeError: Cannot read property "name" of undefined

const descriptor = Object.getOwnPropertyDescriptor( obj, "foo" );
descriptor.get.name; // "set foo"
descriptor.set.name; // "get foo"

const obj = {
    name: "稀音",
    age: 14
}

Object.getOwnPropertyDescriptor( obj, "name" );
// {
//      value: "稀音",
//      writable: true,
//      enumerable: true,
//      configurable: true
//  }

// 报错
const obj = {
    foo: super.attr
}

// 报错
const obj = {
    foo: () => super.attr
}

// 报错
const obj = {
    foo: function () {
        return super.attr
    }
}

// 报错
const obj = {
    foo() {
        return super;
    }
}

// 正确
const obj = {
    foo() {
        return super.attr;
    }
}

const obj = {};
// 设置不可枚举属性
Object.defineProperties(obj, {
    name: {
        value: "稀音",
        enumerable: false // 不可枚举
    },
    age: {
        value: 14,
        enumerable: true // 可枚举
    }
})
// 设置原型对象
const proto = { sex: "女" };
Object.setPrototypeOf( obj, proto );

const obj1 = { ...obj };
console.log( obj1 ); // { age: 14 }

// Object.create(proto[,propertiesObject]) 用来创建对象的原型，表示要继承的对象
const o = Object.create({ x: 1, y: 2 });
o.z = 3;

const { x, ...newObj } = o;
const { y, z } = newObj;
x // 1
y // undefined
z // 3

const obj1 = { a: 1, b: 2 };
const obj2 = { ...obj1 }; // { a: 1, b: 2 }

const obj = { ...[ "a", "b", "c" ] }; // { "0": "a", "1": "b", "2": "c" }

const obj = { ...1 }; // {}

const obj = { ..."hi" }; // { "0": "h", "1": 'i' }

const aClone = { ...obj1 };
// 等同于
const aClone = Object.assign( {}, obj1 );

const clone = Object.create(
    Object.getPrototypeOf( obj ),
    Object.getOwnPropertyDescriptors( obj )
)

const obj = {
    get foo() {
        console.log( "get 方法指令了哟" );
        return "run";
    }
};

const obj1 = { ...obj }; // "get 方法指令了哟"
console.log( obj1 ); // { foo: "run" }

+0 === -0; // true
Object.is( +0, -0 ); // false

NaN === NaN; // false
Object.is( NaN. NaN ); // true

const objExpend = { ...obj1, ...obj2 };
// 等同于
const objAssign = Object.assign( obj1, obj2 );

const objExpend = { ...null, ...{} }; // {}
const objAssign = Object.assign( null, {} ); // TypeError: Cannot convert undefined or null to object

const objExpend = { ...[ 1, 2, 3 ], ...[ 4, 5 ] }; // { "0": 4, "1": 5, "2": 3 }
const objAssign = Object.assign( [ 1, 2, 3 ], [ 4, 5 ] ); // [ 4, 5, 3 ]

const obj = {
    get foo() {
        console.log( "get 方法指令了哟" );
        return "run";
    }
};

const obj1 = { ...obj }; // "get 方法指令了哟"
console.log( obj1 ); // { foo: "run" }

const obj2 = Object.assign( {}, obj ); // "get 方法指令了哟"
console.log( obj2 ); // { foo: "run" }

const obj = { a: 1 };
Object.assign( obj ) === obj; // true

Object.assign( 2 ); // Number {2}
typeof Object.assign( 2 ); // "object"

Object.assign( null ); // TypeError: Cannot convert undefined or null to object

const obj = {
    foo: 123,
    get bar() { return "abc" }
};
Object.getOwnPropertyDescriptors( obj );
// {
//     foo: { value: 123, writable: true, enumerable: true, configurable: true },
//     bar: {
//         get: [Function: get bar],
//         set: undefined,
//         enumerable: true,
//         configurable: true
//     }
// }

const obj = {
    set foo( value ) {
        console.log( "wdnmd" );
    }
}
Object.assign( {}, obj ); // { foo: undefined }

const shallowMerge = ( target, source ) => Object.defineProperties(
    target,
    Object.getOwnPropertyDescriptors( source )
);
shallowMerge( {}, obj ); // { foo: [Setter] }

const shallowClone = ( obj ) => Object.create(
    Object.getPrototypeOf( obj ),
    Object.getOwnPropertyDescriptors( obj )
);

const obj = Object.create( { a: 1 },  {
    b: { value: 2, writable: true, enumerable: true, configurable: true }
}); // { b: 2 };

const obj1 = shallowClone( obj ); // { b: 2 }
obj1.a; // 1

const prot = Object.create( { a: 1 } );
// 使 obj 继承自 prot
const obj = Object.create( prot, Object.getOwnPropertyDescriptors( {
    b: 1
} ) );

obj.a; // 1

const obj = Object.create( { a: 1 },  {
    b: { value: 2, writable: true, enumerable: true, configurable: true }
});
console.log( obj ); // { b: 2 }
obj.a; // 1

const obj = Object.setPrototypeOf( {}, { a: 1 } );
console.log( obj ); // {}
obj.a; // 1
Object.getPrototypeOf( obj ); // { a: 1 }

Object.fromEntries( [
    [ "a", 1 ],
    [ "b", 2 ]
] ); // { a: 1, b: 2 }

// Map
Object.fromEntries( new Map( [ "name", "mari" ] ) ); // { name: 'mari' }
// Headers
Object.fromEntries( new Headers( [ [ "name", "mari" ] ] ) ); // { name: 'mari' }
// FormData
const formData = new FormData();
formData.append( "name", "mari" );
Object.fromEntries( formData ); // { name: 'mari' }
// URLSearchParams
Object.fromEntries( new URLSearchParams( "name=mari" ) ); // { name: 'mari' }

const foo = Object.create({ a: 1 }, { b: { value: 2 } });

foo.hasOwnProperty( "a" ); // false
foo.hasOwnProperty( "b" ); // true

Object.hasOwn( foo, "a" ); // false
Object.hasOwn( foo, "b" ); // true

//
const obj = Object.create( null );

obj.hasOwnProperty( "a" ); // TypeError: obj.hasOwnProperty is not a function
Object.hasOwn( obj, "a" ); // false

2 ** 2 ** 3; // 256
// 等同于
2 ** ( 2 ** 3 );

let a = 2;
a **= 3;
console.log( a ); // 8

obj?.prop // 对象属性是否存在，存在即获取
obj?.[ expr ] // 同上
func?.( ...args ) // 函数或对象方法是否存在，存在即执行

( a?.b ).c // 可能会出现 undefined.c 导致报错

// 构造函数
new a?.()
new a?.b()

// 链判断运算符的右侧有模板字符串
a?.`{b}`
a?.b`{c}`

// 链判断运算符的左侧是 super
super?.()
super?.foo

// 链运算符用于赋值运算符左侧
a?.b = c

null ?? 1; // 1

// 或赋值运算符
x ||= y
// 等同于
x || (x = y)

// 与赋值运算符
x &&= y
// 等同于
x && (x = y)

// Null 赋值运算符
x ??= y
// 等同于
x ?? (x = y)

// 老的写法
user.id = user.id || 1;

// 新的写法
user.id ||= 1;

const sym = Symbol();
typeof sym; // "symbol"

const sym = Symbol( "wdnmd" );
sym; // Symbol( wdnmd )
sym.toString(); // "Symbol( wdnmd )"

Symbol( { a: 1 } ); // Symbol([object Object])
Symbol( {
    toString() {
        return "wdnmd";
    }
} ); // Symbol( wdnmd )

const sym = Symbol( "wdnmd" );
sym + "cxk"; // TypeError: Cannot convert a Symbol value to a string

const sym = Symbol( "wdnmd" );
sym.toString(); // "Symbol( wdnmd )"

Boolean( sym ); // true
!!sym; // true

Number( sym ); // TypeError: Cannot convert a Symbol value to a number
BigInt( sym ); // TypeError: Cannot convert Symbol( wdnmd ) to a BigInt

const sym = Symbol( "wdnmd" );
sym.description; // "wdnmd"

const sym = Symbol( "wdnmd" );
// 方式一
const obj = {};
obj[ sym ] = "这是一个symbol值";
// 方式二
const obj1 = {
    [ sym ]: "这是一个symbol值"
};
// 方式三
const obj2 = {};
Object.definePropertie( obj2, sym, { value: "这是一个symbol值" } );

const obj = { value: "wdnmd" };
const check = obj.value === "wdnmd";

// 正常情况下我们的操作是
const value = "wdnmd";
const obj = { value };
const check = obj.value === value;

// 但其值并没有意义，因此可修改为
const value = Symbol();
const obj = { value };
const check = obj.value === value;

const sym = Symbol( "wdnmd" );
const obj = {
    [ sym ]: "这是一个symbol值"
};
const symList = Object.getOwnPropertySymbols( obj ); // [ Symbol( wdnmd ) ]
symList.includes( sym ); // true

const obj = {
    [ Symbol( "wdnmd" ) ]: 1,
    a: 2,
    1: 3
};
Reflect.ownKeys( obj ); // [ "1", "a", Symbol( wdnmd ) ]

const sym1 = Symbol.for( "wdnmd" );
const sym2 = Symbol.for( "wdnmd" );
sym1 === sym2; // true

const sym1 = Symbol( "sym1" );
const sym2 = Symbol.for( "sym2" );

Symbol.keyFor( sym1 ); // undefined
Symbol.keyFor( sym2 ); // "sym2"

const sym1 = Symbol.for();
const sym2 = Symbol.for();
sym1 === sym2; // true

new Set(); // Set( 0 ) { size: 0 }
new Set( [ 1, 2, 3 ] ); // Set( 3 ) { 1, 2, 3 }
// 因不能存在重复值，因此只有四个元素
new Set( "wdnmd" ); // Set( 4 ) { "w", "d", "n", "m" }
new Set( document.querySelectorAll( "div" ) );

Array.from( new Set( [ 1, 1, 2, 3 ] ) ); // [ 1, 2, 3 ]
[ ...new Set( [ 1, 1, 2, 3 ] ) ]; // [ 1, 2, 3 ]

new Set( [ 5, "5" ] ); // Set( 2 ) { 5, '5' }

new Set( [ NaN, NaN ] ); // Set( 1 ) { NaN }

const set = new Set();
// 1 被添加了两次，第二次因为重复未添加
set.add( 1 ).add( 2 ).add( 1 ); // Set( 2 ) { 1, 2 }

set.delete( 1 ); // true
set; // Set(1) { 2 }

set.has( 2 ); // true

set.clear();
set; // // Set( 0 ) { size: 0 }

const set = new Set( [ "kanade", "mari", "kokoro" ] );
set.keys(); // SetIterator { "kanade", "mari", "kokoro" }
set.values(); // SetIterator { "kanade", "mari", "kokoro" }
set.entries(); // SetIterator { "kanade" => "kanade", "mari" => "mari", "kokoro" => "kokoro" }

Object.is( set.keys, set.values ); // true

Object.is( Set.prototype[ Symbol.iterator ], Set.prototype.values ); // true

const set = new Set( [ "kanade", "mari", "kokoro" ] );
for( const s of set ) {
    console.log( s );
}
// "kanade"
// "mari"
// "kokoro"

[ ...set ]; // [ "kanade", "mari", "kokoro" ]

const set = new Set( [ "kanade" ] );
set.forEach( ( value, key, set ) => {
    console.log( value, value === key, set );
} );
// "kanade" true

const set = new Set( [ "kanade", "mari", "kokoro" ] );
Array.from( set ).filter( s => s !== "kokoro" ); // [ "kanade", "mari" ]
[ ...set ].map( ( s, sKey ) => s += sKey ); // [ "kanade0", "mari1", "kokoro2" ]

const a = new Set( [ 1, 2, 3 ] );
const b = new Set( [ 4, 3, 2 ] );

// 并集
new Set( [ ...a, ...b ] );
// Set { 1, 2, 3, 4 }

// 交集
new Set([ ...a ].filter( x => b.has( x ) ) );
// set { 2, 3 }

// （a 相对于 b 的）差集
new Set( [ ...a ].filter( x => !b.has( x ) ) );
// Set { 1 }

const params = { a: 1 };
const obj = { [ params ]: 2 };
// params 被自动转成了字符串 "[object Object]"
obj[ "[object Object]" ]; // 2

const params = { a: 1 };
const map = new Map( [
    [ params, 1 ]
] );
map; // Map( 1 ) { { a: 1 } => 1 }
map.get( params ); // 1

const items = [
  [ "name", "kanade" ],
  [ "title", "angle"]
];

const map = new Map();

items.forEach(
  ( [ key, value ] ) => map.set( key, value )
);

const items = [
    [ "name", "kanade" ],
    [ "title", "angle"]
]

// 下面三种写法都会得到：Map( 2 ) { "name" => "kanade", "title" => "angle" }
new Map( new Set( items ) );
new Map( new Map( items ) );
new Map( new URLSearchParams( items ) );

const map = new Map();
map.set( NaN, 1 ); // Map( 1 ) { NaN => 1 }
map.set( NaN, 2 ); // Map( 1 ) { NaN => 2 }

new Map( [
    [ "name", "kanade" ],
    [ "title", "angle"]
] ).size; // 2

const m = new Map();

m.set( "age", 17 )
    .set( undefined, "empty" )
    .set( "name", "marry" )
    .set( "name", "mari" )
    .set ( { a: 1 }, "data" );
m; // Map( 3 ) { "age" => 17, undefined => "empty", "name" => "mari", { a: 1 } => "data" }

m.get( undefined ); // "empty"

m.has( "age" ); // true

m.delete( "name" ); // true
m; // Map( 3 ) { "age" => 17, undefined => "empty", { a: 1 } => "object" }

m.clear();
m; // Map( 0 ) {}

const map = new Map( [
    [ "name", "kanade" ],
    [ "title", "angle"]
] );
map.keys(); // [Map Iterator] { "name", "title" }
map.values(); // [Map Iterator] { "kanade", "angle" }
map.entries(); // [Map Entries] { [ "name", "kanade" ], [ "title", "angle" ] }

Object.is( Map.prototype[ Symbol.iterator ], Map.prototype.entries ); // true

const map = new Map( [
    [ "name", "kanade" ],
    [ "title", "angle"]
] );
[ ...map.entries() ]; // [ [ "name", "kanade" ], [ "title", "angle" ] ]
[ ...map ];  // [ [ "name", "kanade" ], [ "title", "angle" ] ]

new Map( [
    [ "name", "kanade" ],
    [ "title", "angle"]
] ).forEach( ( value, key, map) => {
    console.log( value, key );
} )
// "kanade" "name"
// "angle" "title"

const map = new Map( [
    [ "name", "kanade" ],
    [ "title", "angle"]
] );

const obj = Object.create( null );
for ( const [ k, v ] of map ) {
    obj[ k ] = v;
}

const obj = {
    name: "kanade",
    title: "angle"
}
new Map( Object.entries( obj ) );
// Map(2) { "name" => "kanade", "title" => "angle" }

// 老写法
Math.floor.apply( undefined, [1.75] ); // 1

// 新写法
Reflect.apply( Math.floor, undefined, [1.75] ); // 1

const obj = {
    name: "kanade",
    age: 16,
    get desc() {
        return `${ this.name } ${ this.age }`
    }
};

Reflect.get( obj, "name" ); // "kanade"
Reflect.get( obj, "desc" ); // "kanade 16"
Reflect.get( obj, "desc", { name: "marry", age: 140 } ); // "marry 140"

const obj = {
    name: "kanade",
    age: 16,
    set foo( value ) {
        this.age = value;
    }
};

Reflect.set( obj, "name", "marry" ); // true
obj; // { name: "marry", age: 16, foo: [ Setter ] }

Reflect.set( obj, "foo", 140 ); // true
obj; // { name: "marry", age: 140, foo: [ Setter ] }

const otherObj = {};
Reflect.set( obj, "foo", 140, otherObj ); // true
otherObj; // { age: 140 }

// 旧写法
"name" in {}; // false
// 新写法
Reflect.has( {}, "name" ); // false

const obj = {
    name: "kanade",
    age: 16
}

delete obj.name; // true
Reflect.deleteProperty( obj, "age" ); // true
obj; // {}

function wife( name ) {
    this.name = name;
}
// 旧写法
new wife( "marry" ).name; // "marry"
// 新写法
Reflect.construct( wife, [ "marry" ] ).name; // "marry"

const obj = Object.create( { type: "diy" } );
// 旧写法
Object.getPrototypeOf( obj ); // { type: "diy" }
// 新写法
Reflect.getPrototypeOf( obj ); // { type: "diy" }

const obj = {};
// 旧写法
Object.setPrototypeOf( obj, Array.prototype ); // Array {}
// 新写法
Reflect.setPrototypeOf( obj, Array.prototype ); // true

obj.length; // 0

const obj = Object.freeze( {} );

Object.setPrototypeOf( obj, {} ); // TypeError: #<Object> is not extensible
Reflect.setPrototypeOf( obj, {} ); // false

Object.setPrototypeOf( 1, {} ); // 1
Reflect.setPrototypeOf( 1, {} ); // TypeError: Reflect.setPrototypeOf called on non-object

Math.max.apply( null, [1, 3, 2] ); // 3
// 旧写法
Function.prototype.apply.call( Math.max, null, [ 1, 3, 2 ] ); // 3
// 新写法
Reflect.apply( Math.max, null, [ 1, 3, 2 ] ); // 3

const obj = {};
// 旧写法
Object.defineProperty( obj, "now", {
    value: () => Date.now(),
    configurable: true
} ); // { now: ƒ }
// 新写法
Reflect.deleteProperty( obj, "now", {
    value: () => Date.now(),
    configurable: true
} ); // true，若上面未配置 configurable 为 true，此时该属性禁止修改特性，会返回 false

const obj = Object.create( {}, { age: { value: 17 } } );
// 旧写法
Object.getOwnPropertyDescriptor( obj, "age" );
// 新写法
Reflect.getOwnPropertyDescriptor( obj, "age" );
// 结果均为: { value: 17, writable: false, enumerable: false, configurable: false }

const obj = {};
// 旧写法
Object.isExtensible( obj ); // true
// 新写法
Reflect.isExtensible( obj ); // true

const obj = {};
// 旧写法
Object.preventExtensions( obj ); // Object {}
// 新写法
Reflect.preventExtensions( obj ); // true

const obj = {
  name: "kanade",
  age: 16,
  [Symbol.for( "sex" )]: "girl",
  [Symbol.for( "hair" )]: "white",
};

Object.getOwnPropertyNames( obj ); // [ "name", "age" ]
Object.getOwnPropertySymbols( obj ); // [ Symbol( sex ), Symbol( hair ) ]

Reflect.ownKeys( obj ); // [ "name", "age", Symbol( sex ), Symbol( hair ) ]

const proxy = new Proxy( target, handler );

const obj = { name: "kanade" };

const proxy = new Proxy( obj, {
    get( target, name, receiver ) {
        console.log( "proxy get", receiver );
        return Reflect.get( target, name, receiver ) + " get";
    },
    set( target, name, value, receiver ) {
        console.log( "proxy set" );
        Reflect.set( target, name, value + " set", receiver );
    }
} )

Reflect.get( proxy, "name" ); // "kanade get"

proxy.name = "marry";
// "proxy set"
// "marry"

Reflect.set( proxy, "name", "marry" )
// "proxy set"
// false

proxy.name += "1";
// "proxy get"
// "proxy set"
// "marry set get1"

// 针对目标对象操作无效
Reflect.get( obj, "name" ); // "kanade"

obj; // { name: "marry set get1 set" }

const obj = { name: "kanade" };
const proxy = new Proxy( obj, {} );

Reflect.set( obj, "name", "marry" );
obj; // { name: "marry" }

const obj = Object.create( new Proxy( {}, {
    get( target, name, receiver ) {
        return 114514;
    }
} ) );

Reflect.get( obj, "wdnmd" ); // 114514