ES6--》一文搞懂JS新的原始数据类型—Symbol

<script>// 创建Symbollets=Symbol()
console.log(s,typeofs);//Symbol() 'symbol'//Symbol()函数可以接受一个字符串作为参数，表示对 Symbol 实例的描述//Symbol()函数的参数只是表示对当前 Symbol 值的描述，因此相同参数的Symbol函数的返回值是不相等的。lets1=Symbol('张三')
lets2=Symbol('张三')
console.log(s1===s2);//false// 创建Symbol的另一种方法：Symbol.for() 该方法创建的字符串参数相等，Symbol也相等lets3=Symbol.for('张三')
lets4=Symbol.for('张三')
// Symbol.keyFor()方法返回一个已登记的 Symbol 类型值的key。console.log(Symbol.keyFor(s3));//张三console.log(s3===s4);//true</script>

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

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

<script>lets=Symbol('My Symbol')
// 第一种leta= {}
a[s] ='hello world'// 第二种letb= {
        [s]:'hello people'    }
// 第三种letc= {}
Object.defineProperty(c,s,{value:'hello animal'})
// 以上结果都能达到相同的效果，举例console.log(c);
</script>

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

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

<script>classPerson {
static [Symbol.hasInstance](param){
console.log(param);
console.log('我被用来检测类型了');
//return true        }
    }
leto= {}
console.log(oinstanceofPerson);
</script>

<script>constarr= [1,2,3]
constarr1= [4,5,6]
console.log(arr.concat(arr1));
// 将arr1设置为不展开，作为一个整体与arr进行合并arr1[Symbol.isConcatSpreadable] =falseconsole.log(arr.concat(arr1));
</script>

<script>letobj= {
0:'a',
1:'b',
2:'c',
length:3    }
console.log([1,2].concat(obj,'d'));
// 将该属性设置为true，进行展开obj[Symbol.isConcatSpreadable] =trueconsole.log([1,2].concat(obj,'d'));
</script>

<script>// 将排除的键名以数组方式打印出来console.log(Object.keys(Array.prototype[Symbol.unscopables]));
</script>

// 没有 unscopables 时classMyClass {
foo() { return1; }
}
varfoo=function () { return2; };
with (MyClass.prototype) {
foo(); // 1}
// 有 unscopables 时// 通过指定Symbol.unscopables属性，使得with语法块不会在当前作用域寻找foo属性，即foo将指向外层作用域的变量classMyClass {
foo() { return1; }
get [Symbol.unscopables]() {
return { foo: true };
  }
}
varfoo=function () { return2; };
with (MyClass.prototype) {
foo(); // 2}

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

<script>constx= {};
// Symbol.replace方法会收到两个参数，第一个参数是replace方法正在作用的对象，第二个参数是替换后的值。x[Symbol.replace] = (...s) =>console.log(s); // ["Hello", "World"]'Hello'.replace(x, 'World')
</script>

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

<script>varexp=  {
pat:'in',
        [Symbol.split](str) {
returnstr.split(this.pat);
        }
    }
// "dayinlove".split(exp)调用[Symbol.split](str)处理，并把实参"dayinlove"传给形参strconsole.log("dayinlove".split(exp));//["day", "love"]</script>

<script>constmyIterable= {};
myIterable[Symbol.iterator] =function* () { //function*这种声明方式会定义一个生成器函数，它返回一个对象。yield1;
yield2;
yield3;
    };
console.log([...myIterable]);// [1, 2, 3]</script>

// 一个没有提供 Symbol.toPrimitive 属性的对象，参与运算时的输出结果varobj1= {};
console.log(+obj1);     // NaNconsole.log(`${obj1}`); // "[object Object]"console.log(obj1+""); // "[object Object]"// 接下面声明一个对象，手动赋予了 Symbol.toPrimitive 属性，再来查看输出结果varobj2= {
  [Symbol.toPrimitive](hint) {
if (hint=="number") {
return10;
    }
if (hint=="string") {
return"hello";
    }
returntrue;
  }
};
console.log(+obj2);     // 10      -- hint 参数值是 "number"console.log(`${obj2}`); // "hello" -- hint 参数值是 "string"console.log(obj2+""); // "true"  -- hint 参数值是 "default"

<script>classPerson {
get [Symbol.toStringTag](){
return'xxx'        }
    }
letper=newPerson()
console.log(Object.prototype.toString.call(per));//[object xxx]</script>

<script>classArray1extendsArray {
staticget [Symbol.species]() { returnArray; }
    }
consta=newArray1(1, 2, 3);
constmapped=a.map(x=>x*x);
// 定义了Symbol.species属性后，导致 a.map(x => x * x) 生成的衍生对象不在是Array1的实例而是Arrayconsole.log(mappedinstanceofArray1);//falseconsole.log(mappedinstanceofArray);//true</script>