ES6新特性-Symbol类型

一.基础概念

Symbol表示独一无二的值，是原始数据类型，不是对象。可以接受一个字符串作为参数，同时symbol创建的值也不能进行相应的加减运算。

二.用法

1.Symbol的创建

let sy = Symbol(“kk”);
console.log(sy); // Symbol(KK) 
typeof(sy); // "symbol" 
// 注意的是当两个参数相同时，他们返回的结果时不一致的，因为symbol类型时独一无二的。
let sy1 = Symbol("kk"); sy === sy1; // false

2.Symbol向对象中添加方法
先创建一个对象，接着在对象中定义一个[Symbol(“say”)]方法，这样可以防止方法重名。注意的是定义Symbol类型方法需要使用[]。
情况一：对象中不存在同名方法

let game = {
	name: '狼人杀',
	[Symbol('say')]: function() {
		console.log('发言');
	},
	[Symbol('zibao')]: function() {
		console.log('自爆');
	}
}
console.log(game); // {name: "狼人杀", Symbol(say): ƒ, Symbol(zibao): ƒ}

情况二：对象中存在同名方法（需要先定义一个对象来存放Symbol对象）

// 向game对象中添加方法up, down
let game = { 
	name: '俄罗斯方块',
	up: function(){ console.log('上升')},
	down: function(){ console.log('下降') }
};

// 声明一个对象
let methods = {
	up: Symbol('up'),
	down: Symbol('down')
};
// 添加方法
game[methods.up] = function() {
	console.log('methods.up改变形状');
}
game[methods.down] = function() {
	console.log('methods.down快速下降');
}

console.log(game);
// down: ƒ ()
// name: "俄罗斯方块"
// up: ƒ ()
// Symbol(down): ƒ ()
// Symbol(up): ƒ ()

3.调用Symbol向对象中的方法
调用方法：
情况一：（利用getOwnPropertySymbols获取symbol对象，接着按数组格式输出）

const langrensha = Object.getOwnPropertySymbols(game);
console.log(langrensha);
ganme[langrensha[0]]();

情况二：（调用之前存放symbol类型的对象中方法）
gamemethods.down;

game[methods.down]();

三. Symbol常用的内置值

1.Symbol.match

对象的Symbol.match属性，指向一个函数。当执行str.match(myObject)时，如果该属性存在，会调用它，返回该方法的返回值。

class MyMatcher {
    [Symbol.match] (str){
        return "Hello World!".indexOf(str);
    }
}
console.log('e'.match(new MyMatcher())); //1

2.Symbol.replace

对象的Symbol.replace属性，指向一个方法，当该对象被String.prototype.replace方法调用时，会返回该方法的返回值。

const x = {
    [Symbol.replace] (...s) {
        return console.log(s);
    }
}
'Hello'.replace(x, 'World') // ["Hello", "World"]

3.Symbol.search

对象的Symbol.search属性，指向一个方法，当该对象被String.prototype.search方法调用时，会返回该方法的返回值。

class MySearch {
    constructor(value) {
        this.value = value;
    }
    [Symbol.search](str){
        return str.includes(this.value);
    }
}
console.log("foobar".search(new MySearch("foo"))); //true

4.Symbol.split

对象的Symbol.split属性，指向一个方法，当该对象被String.prototype.split方法调用时返回该方法的返回值。

class MySplit {
    constructor(value){
        this.value = value;
    }
    [Symbol.split](str) {
        let index = str.indexOf(this.value);
        if(index === -1){
            return str;
        }
        return [
            str.substr(0,index),
            str.substr(index + this.value.length),
        ]
    }
}
console.log("foobar".split(new MySplit("foo"))); //["","bar"]
console.log("foobar".split(new MySplit("bar"))); //["foo",""]
console.log("foobar".split(new MySplit("baz"))); //foobar