Symbol data type in javascript

The Symbol data type in JavaScript is a basic data type used to represent unique values. Characteristics of Symbol: 1. Unique, each Symbol value is unique and will not be equal to any other value; 2. Immutability, once the Symbol value is created, it cannot be modified or reassigned; 3. Hiddenness, the Symbol value cannot be modified or reassigned; It will be implicitly converted to other types; 4. It cannot be enumerated. When the Symbol value is used as the attribute name of the object, it is not enumerable by default.

The Symbol data type in JavaScript is a new feature introduced by ES6. It is a basic data type used to represent unique values. Symbol values ​​can be used as attribute names of objects to solve the problem of attribute name conflicts. This article will introduce in detail the characteristics, usage and some common application scenarios of the Symbol data type.

1. Characteristics of Symbol

1. Unique: Each Symbol value is unique and will not be equal to any other value, even if the description of the Symbol value is the same. This means that you can use the Symbol value as the attribute name of the object to ensure the uniqueness of the attribute name and avoid attribute name conflicts.

2. Immutability: Once a Symbol value is created, it cannot be modified or reassigned. This is different from data types such as strings and numbers, which can change their value through reassignment, while Symbol values ​​are immutable.

3. Hiddenness: Symbol values ​​will not be implicitly converted to other types. For example, adding a Symbol value to a string will not give the expected result, but will throw a TypeError. This hiding avoids unexpected type conversion problems.

4. Unenumerable: When the Symbol value is used as the attribute name of the object, it is not enumerable by default. This means that the Symbol property name cannot be obtained using the for...in loop or the Object.keys() method. This feature can be used to hide certain attributes from being traversed.

2. Usage of Symbol

1. Create Symbol value: You can use the Symbol() function to create a Symbol value. This function can accept an optional description parameter to identify the Symbol value. The purpose or meaning of.

let sym = Symbol();
console.log(typeof sym); // "symbol"
let symWithDesc = Symbol("description");
console.log(symWithDesc.toString()); // "Symbol(description)"

2. Use Symbol as attribute name: You can use Symbol value as the attribute name of the object to ensure the uniqueness of the attribute name.

let obj = {
  [Symbol("key")]: "value"
};
console.log(obj[Symbol("key")]); // undefined，每次使用Symbol()函数创建的Symbol值都是不相等的
let sym = Symbol("key");
obj[sym] = "new value";
console.log(obj[sym]); // "new value"

3. Get the Symbol property names: You can use the Object.getOwnPropertySymbols() method to get all the Symbol property names of the object.

let obj = {
  [Symbol("key1")]: "value1",
  [Symbol("key2")]: "value2"
};
let symbols = Object.getOwnPropertySymbols(obj);
console.log(symbols); // [Symbol(key1), Symbol(key2)]
console.log(obj[symbols[0]]); // "value1"

4. Symbol built-in properties: Symbol values ​​have some built-in properties that can be used to modify the default behavior of the object.

- Symbol.iterator: used to define the default iterator method of an object.

- Symbol.toStringTag: used to modify the string tag returned by the default toString() method of the object.

- Symbol.hasInstance: used to define the default instanceof operator behavior for objects.

- Symbol.toPrimitive: used to define the default behavior of objects converted to primitive values.

let obj = {
  [Symbol.iterator]: function* () {
    yield 1;
    yield 2;
  },
  [Symbol.toStringTag]: "MyObject"
};
console.log([...obj]); // [1, 2]
console.log(obj.toString()); // "[object MyObject]"

3. Application scenarios of Symbol

1. Attribute name conflict resolution: Using Symbol value as the attribute name of the object can avoid attribute name conflicts between different modules or libraries.

2. Define constants: You can use Symbol values ​​to define constants to ensure the uniqueness of the constants.

const RED = Symbol("red");
const BLUE = Symbol("blue");

3. Hidden attributes: Using Symbol value as the attribute name of the object can hide certain attributes to prevent them from being traversed.

let obj = {
  [Symbol("hidden")]: "value",
  visible: "value"
};
for (let key in obj) {
  console.log(key); // "visible"，Symbol属性名不可枚举
}

4. Extend built-in objects: You can use Symbol values ​​to extend the functionality of built-in objects and add custom methods or properties to them.

Array.prototype[Symbol.iterator] = function* () {
  for (let i = 0; i < this.length; i++) {
    yield this[i];
  }
};
let arr = [1, 2, 3];
console.log([...arr]); // [1, 2, 3]

In summary, the Symbol data type is a basic data type in JavaScript, used to represent unique values. It has the characteristics of being unique, immutable, hidden, and non-enumerable, and can be used in scenarios such as resolving property name conflicts, defining constants, hiding properties, and extending built-in objects. The creation and use of Symbol values ​​is relatively simple, but you need to pay attention to its particularity and hiddenness to avoid unexpected problems.

The above is the detailed content of Symbol data type in javascript. For more information, please follow other related articles on the PHP Chinese website!