<script>
    // 創(chuàng)建Symbol
    let s = Symbol()
    console.log(s,typeof s);//Symbol() 'symbol'
    //Symbol()函數(shù)可以接受一個(gè)字符串作為參數(shù)，表示對(duì) Symbol 實(shí)例的描述
    //Symbol()函數(shù)的參數(shù)只是表示對(duì)當(dāng)前 Symbol 值的描述，因此相同參數(shù)的Symbol函數(shù)的返回值是不相等的。
    let s1 = Symbol('張三')
    let s2 = Symbol('張三')
    console.log(s1 === s2);//false
    // 創(chuàng)建Symbol的另一種方法：Symbol.for() 該方法創(chuàng)建的字符串參數(shù)相等，Symbol也相等
    let s3 = Symbol.for('張三')
    let s4 = Symbol.for('張三')
    // Symbol.keyFor()方法返回一個(gè)已登記的 Symbol 類型值的key。
    console.log(Symbol.keyFor(s3));//張三
    console.log(s3 === s4);//true
</script>

<script>
    let s = Symbol('My Symbol')
    // let result = s + 100
    // console.log(result);//Cannot convert a Symbol value to a number
    // 轉(zhuǎn)字符串
    console.log(String(s));//Symbol(My Symbol)
    // 轉(zhuǎn)布爾值
    console.log(Boolean(s));//true
</script>

<script>
    let s = Symbol('My Symbol')
    console.log(s.description);//My Symbol
</script>

<script>
    let s = Symbol('My Symbol')
    // 第一種
    let a = {}
    a[s] = 'hello world'
    // 第二種
    let b = {
        [s]:'hello people'
    }
    // 第三種
    let c = {}
    Object.defineProperty(c,s,{value:'hello animal'})
    // 以上結(jié)果都能達(dá)到相同的效果，舉例
    console.log(c);
</script>

<script>
    let obj = {}
    let a = Symbol('a')
    let b = Symbol('b')
    obj[a] = 'hello'
    obj[b] = 'world'
    const objectSymbols = Object.getOwnPropertySymbols(obj)
    console.log(objectSymbols);//[Symbol(a), Symbol(b)]
</script>

<script>
    let obj = {
        name:'張三',
        age:18,
        [Symbol('mySymbol')]:1,
        gender:'男'
    }
    console.log(Reflect.ownKeys(obj));//['name', 'age', 'gender', Symbol(mySymbol)]
</script>

<script>
    class Person {
        static [Symbol.hasInstance](param){
            console.log(param);
            console.log('我被用來(lái)檢測(cè)類型了');
            //return true
        }
    }
    let o = {}
    console.log(o instanceof Person);
</script>

<script>
    const arr = [1,2,3]
    const arr1 = [4,5,6]
    console.log(arr.concat(arr1));
    // 將arr1設(shè)置為不展開，作為一個(gè)整體與arr進(jìn)行合并
    arr1[Symbol.isConcatSpreadable] = false
    console.log(arr.concat(arr1));
</script>

<script>
    let obj = {
        0:'a',
        1:'b',
        2:'c',
        length:3
    }
    console.log([1,2].concat(obj,'d'));
    // 將該屬性設(shè)置為true，進(jìn)行展開
    obj[Symbol.isConcatSpreadable] = true
    console.log([1,2].concat(obj,'d'));
</script>

<script>
    // 將排除的鍵名以數(shù)組方式打印出來(lái)
    console.log(Object.keys(Array.prototype[Symbol.unscopables]));
</script>

// 沒(méi)有 unscopables 時(shí)
class MyClass {
  foo() { return 1; }
}
var foo = function () { return 2; };
 
with (MyClass.prototype) {
  foo(); // 1
}
// 有 unscopables 時(shí)
// 通過(guò)指定Symbol.unscopables屬性，使得with語(yǔ)法塊不會(huì)在當(dāng)前作用域?qū)ふ襢oo屬性，即foo將指向外層作用域的變量
class MyClass {
  foo() { return 1; }
  get [Symbol.unscopables]() {
    return { foo: true };
  }
}
var foo = function () { return 2; };
with (MyClass.prototype) {
  foo(); // 2
}

<script>
    const reg = /hello world/
    reg[Symbol.match] = false
    console.log('/hello/'.startsWith(reg));//false
    console.log('/hello world/'.startsWith(reg));//true
</script>

<script>
    const x = {};
    // Symbol.replace方法會(huì)收到兩個(gè)參數(shù)，第一個(gè)參數(shù)是replace方法正在作用的對(duì)象，第二個(gè)參數(shù)是替換后的值。
    x[Symbol.replace] = (...s) => console.log(s); // ["Hello", "World"]
    'Hello'.replace(x, 'World')
</script>

<script>
    class caseInsensitiveSearch {
    constructor(value) {
        this.value = value.toLowerCase();
    }
    [Symbol.search](string) {
        return string.toLowerCase().indexOf(this.value);
    }
    }
    console.log('foobar'.search(new caseInsensitiveSearch('BaR')));
    // expected output: 3
</script>

<script>
    var exp =  {
        pat:'in',
        [Symbol.split](str) {
        return str.split(this.pat);
        }
    }
    // "dayinlove".split(exp)調(diào)用[Symbol.split](str)處理，并把實(shí)參"dayinlove"傳給形參str
    console.log("dayinlove".split(exp));//["day", "love"]
</script>

<script>
    const myIterable = {};
    myIterable[Symbol.iterator] = function* () { //function*這種聲明方式會(huì)定義一個(gè)生成器函數(shù)，它返回一個(gè)對(duì)象。
        yield 1;
        yield 2;
        yield 3;
    };
    console.log([...myIterable]);// [1, 2, 3]
</script>

// 一個(gè)沒(méi)有提供 Symbol.toPrimitive 屬性的對(duì)象，參與運(yùn)算時(shí)的輸出結(jié)果
var obj1 = {};
console.log(+obj1);     // NaN
console.log(`${obj1}`); // "[object Object]"
console.log(obj1 + ""); // "[object Object]"
// 接下面聲明一個(gè)對(duì)象，手動(dòng)賦予了 Symbol.toPrimitive 屬性，再來(lái)查看輸出結(jié)果
var obj2 = {
  [Symbol.toPrimitive](hint) {
    if (hint == "number") {
      return 10;
    }
    if (hint == "string") {
      return "hello";
    }
    return true;
  }
};
console.log(+obj2);     // 10      -- hint 參數(shù)值是 "number"
console.log(`${obj2}`); // "hello" -- hint 參數(shù)值是 "string"
console.log(obj2 + ""); // "true"  -- hint 參數(shù)值是 "default"

<script>
    class Person {
        get [Symbol.toStringTag](){
            return 'xxx'
        }
    }
    let per = new Person()
    console.log(Object.prototype.toString.call(per));//[object xxx]
</script>

<script>
    class Array1 extends Array {
        static get [Symbol.species]() { return Array; }
    }
    const a = new Array1(1, 2, 3);
    const mapped = a.map(x => x * x);
    // 定義了Symbol.species屬性后，導(dǎo)致 a.map(x => x * x) 生成的衍生對(duì)象不在是Array1的實(shí)例而是Array
    console.log(mapped instanceof Array1);//false
    console.log(mapped instanceof Array);//true
</script>