[ES6] Símbolo de uso básico y símbolos integrados de uso común

El símbolo es el valor original y la instancia de símbolo es única e inmutable. El propósito de Symbol es garantizar que las propiedades del objeto utilicen identificadores únicos y que no haya peligro de conflictos de propiedad.

1. Uso básico

1.1 Crear símbolo

let s = Symbol();
console.log(s, typeof s); // Symbol() "symbol"

let s2 = Symbol('YK菌');
let s3 = Symbol('YK菌');
console.log(s2, typeof s2, s2===s3); // Symbol(YK菌) "symbol" false

let s4 = Symbol.for('YK菌');
let s5 = Symbol.for('YK菌');
console.log(s4, typeof s4, s4===s5); // Symbol(YK菌) "symbol" true

1.2 Naturaleza

1. El valor del símbolo es único y se utiliza para resolver el problema de los conflictos de nombres.
2. El valor del símbolo no se puede calcular con otros datos
3. Las propiedades del objeto definidas por Symbol no se pueden recorrer usando for ... in, pero puede usar Reflect.ownKeys para obtener todas las claves del objeto

let s = Symbol();
let result1 = s + 100; // TypeError: Cannot convert a Symbol value to a number
let result2 = s > 100; // TypeError: Cannot convert a Symbol value to a number
let result3 = s + '100'; // TypeError: Cannot convert a Symbol value to a string
let result4 = s + s; // TypeError: Cannot convert a Symbol value to a number

2. Aplicación básica

2.1 Agregar propiedades y métodos a los objetos

// 向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): ƒ ()

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

3. Valor incorporado del símbolo (símbolo conocido)

ECMAScript 6 también introduce una serie de símbolos bien conocidos para exponer el comportamiento interno del lenguaje.Los desarrolladores pueden acceder directamente, reescribir o simular estos comportamientos.

Símbolo.hasInstance

Un método que determina si un objeto constructor reconoce un objeto como una instancia de él. Utilizado por el operador instanceof

El operador instanceof puede usarse para determinar si hay un prototipo en la cadena de prototipos de una instancia de objeto.
Este método se llama cuando otros objetos usan el operador instanceof para determinar si es una instancia del objeto.

class Person{
    
     
	static [Symbol.hsaInstance](param) {
    
    
		console.log(param);
		console.log('我被用来检测类型');
		return true;
	}
}
let o = {
    
    }
console.log(o instanceof Person); // {} '我被用来检测类型' true

Symbol.isConcatSpreadable

Un valor booleano, si es verdadero, significa que el objeto debe aplanar sus elementos de matriz con Array.prototype.concat () "

El método Array.prototype.concat () en ES6 elegirá cómo concatenar un objeto similar a una matriz en una instancia de matriz de acuerdo con el tipo de objeto recibido. Este comportamiento se puede modificar anulando el valor
de Symbol.isConcatSpreadable. La propiedad Symbol.isConcatSpreadable del objeto es igual a un valor booleano, lo que indica si el objeto se puede expandir cuando se usa en Array.prototype.concat ()

const arr = [1, 2, 3];
const arr2 = [4, 5, 6];
console.log(arr.concat(arr2)); // [1, 2, 3, 4, 5, 6]

arr2[Symbol.isConcatSpreadable] = false;
console.log(arr.concat(arr2)); //[1, 2, 3, [4, 5, 6]]

Symbol.iterator

Un método que devuelve el iterador predeterminado del objeto. Utilizado por declaraciones for-of

Symbol.toStringTag

Una cadena que se utiliza para crear la descripción de cadena predeterminada del objeto. Utilizado por el método incorporado Object.prototype.toString ()

Symbol.match

Un método de expresión regular que usa expresiones regulares para hacer coincidir cadenas. Utilizado por el método String.prototype.match ()

Symbol.replace

Un método de expresión regular que reemplaza las subcadenas coincidentes en una cadena. Utilizado por el método String.prototype.replace ()

Búsqueda de Símbolos

Un método de expresión regular que devuelve el índice de la expresión regular coincidente en la cadena. Utilizado por el método String.prototype.search ()

Symbol.split

Un método de expresión regular que divide la cadena en la posición del índice que coincide con la expresión regular. Utilizado por el método String.prototype.split ()

Símbolo a primitivo

Un método que convierte el objeto al valor original correspondiente. Utilizado por la operación abstracta ToPrimitive

Símbolo.especie

Un valor de función que sirve como constructor para crear objetos derivados.

Symbol.asyncIterator

Un método que devuelve el AsyncIterator predeterminado del objeto. Utilizado por la declaración de espera de

Este símbolo representa la función que implementa la API de iterador asíncrono

Symbol.unscopables

Un objeto, todas las propiedades heredadas y del objeto se excluirán del enlace con el entorno del objeto asociado