TypeScript 符号类型

符号是在JavaScript的最后一次主要修订中引入的，即ES6。符号是一种数据类型。正如我们使用数字、字符串或布尔值来创建不同数据类型的变量一样，我们可以使用符号类型来创建Symbol。

使用符号类型有很多好处，因为它比其他数据类型提供更多的功能。在本教程中，我们将学习符号的基础知识以及符号的不同用途。

语法

用户可以按照下面的语法来创建一个符号数据类型的变量。

let test_symbol = Symbol();
let key_symbol = Symbol("key-for-symbol");

在上面的语法中，我们使用Symbol()构造函数创建了符号。我们也可以将键作为符号参数来传递，以识别该符号。

在TypeScript中，我们可以创建多个符号，这些符号是唯一的。这意味着符号是不可改变的；即使我们用相同的键创建一个符号，我们可以发现两个符号都是唯一的。

// Creating two different symbols with the same key.
var first_sym = Symbol("sym");
var second_sym = Symbol("sym");

// we can't compare two symbols as they are immutable
if (first_sym === second_sym) {
}
else {

   // execution flow always executes this block
}

在上面的代码中，用户可以看到，它给出了一个编译错误，因为这两个符号是不可比的。

示例 1

在下面的例子中，我们已经创建了符号，并使用符号的描述属性来获得我们在创建符号时作为参数传递的值。

此外，我们还使用了toString()方法，将符号转换为一个字符串。

// Creating the symbols
const first_sym = Symbol("sym");
const second_sym = Symbol("sym");

//  getting the description of the symbol
console.log("The description of the first_sym is " + first_sym.description);

// converting symbols to string
console.log("The symbol in the string is " + first_sym.toString());

在编译时，它将在JavaScript中生成相同的代码。

输出

它将产生以下输出 —

The description of the first_sym is undefined
The symbol in the string is Symbol(sym)

例2：使用符号来定义对象属性

在下面的例子中，我们已经创建了符号并定义了对象。我们将obj_symbol作为对象的一个属性。同时，我们可以像对象的普通属性一样访问它。

const obj_symbol = Symbol();

// creating the object
let object = {

   // using the obj_symbol as key of object
   [obj_symbol]: "obj value",
};

// accessing the symbol property of the object
console.log(
   "The vlaue of the obj_symbol property in the object is " + object[obj_symbol]
);

在编译时，它将在JavaScript中生成相同的代码。

输出

它将产生以下输出 —

The vlaue of the obj_symbol property in the object is obj value

在switch case语句中使用符号

由于每个符号都是唯一的，我们可以把它作为switch-case语句的一个案例。当我们将符号与switch-case语句一起使用时，它可以确保每个case都是唯一的。如果任何案例与作为switch语句参数传递的案例不匹配，它将进入默认案例。

语法

用户可以按照下面的语法来使用符号类型与switch case语句。

switch(symbol) {
   case symbol1: 
      break
   case symbol2: 
      break;
}

在上面的语法中，一个符号被作为switch语句的参数传递。之后，我们使用符号名称后的case关键字来创建一个不同的案例。

示例

在下面的例子中，我们已经创建了四个不同的符号。之后，我们定义了print_symbol函数，其中包含switch case语句来处理不同的情况。

在switch case语句中，我们将符号值作为一个案例，并执行特定案例的代码。

// different symbols
const symbol1 = Symbol();
const symbol2 = Symbol();
const symbol3 = Symbol();
const symbol4 = Symbol();

function print_symbol(symbol) {

   // creating the switch case statement
   switch (symbol) {

      // different cases
      case symbol1:
         console.log("The case is symbol 1.");
         break;
      case symbol2:
         console.log("The case is symbol 2.");
         break;
      case symbol3:
         console.log("The case is symbol 3.");
         debugger;
         break;
      case symbol4:
         console.log("The case is symbol 4.");
         break;
      default:
         console.log("The case is default.");
   }
}

// calling the function
print_symbol(symbol2);
print_symbol(symbol4);

在编译时，它将在JavaScript中生成相同的代码。

输出

它将产生以下输出 —

The case is symbol 2.
The case is symbol 4.

独特的符号

在TypeScript中，Symbol是一个原始的数据类型。所以，我们只需要把它作为一个类型来使用，但我们也可以使用 “唯一符号 “把它作为字面符号。符号包括唯一符号，这意味着唯一符号是符号的一个子类型。

我们可以只对常量变量和只读属性使用唯一符号。如果我们想把特定的符号类型引用到另一个变量，我们可以使用’typeof’操作符。

语法

用户可以按照下面的语法，用唯一的符号作为字面意思使用。

const test_symbol: unique symbol = Symbol();
let symbol1: typeof test_symbol = test_symbol;
class C {
   static readonly symb: unique symbol = Symbol("unique symbol");
}

示例

在下面的例子中，我们声明了类型为符号的test_symbol，并使用唯一的符号关键字来使用该符号作为一个类型字。另外，用户可以观察到我们如何使用typeof操作符来使用符号作为用let和var关键字声明的变量的类型标识。

另外，我们使用了唯一的符号关键字来定义只读静态类的成员类型。

// here, we used the unique symbol to define the type of the sym1.
const test_symbol: unique symbol = Symbol();

// we can't reference the unique symbol to the let type of variable
// let sym2: unique symbol = Symbol();

// to reference the symbol type to the variables declared with the let keyword, using the typeof operator.
let symbol1: typeof test_symbol = test_symbol;
console.log("The value of symbol1 is " + typeof test_symbol);

// referencing the unique symbol to the static class property
class C {
   static readonly symb: unique symbol = Symbol("unique symbol");
}

// here, we used the unique symbol to define the type of the sym1.
var test_symbol = Symbol();

// we can't reference the unique symbol to the let type of variable

// let sym2: unique symbol = Symbol();

// to reference the symbol type to the variables declared with the let keyword, using the typeof operator.
var symbol1 = test_symbol;
console.log("The value of symbol1 is " + typeof test_symbol);

// referencing the unique symbol to the static class property
var C = /** @class */ (function () {
   function C() {
   }
   C.symb = Symbol("unique symbol");
   return C;
}());