typescript never | symbol

never：表示不应该存在的状态

//因为必定抛出异常，所以error不会有返回值
function error(message: string): never {
  throw new Error(message);
}
//死循环，也不会有返回值
function loop(): never {
  while (true) {}
}

never与void的差异

• void类型只是没有返回值，但本身不会出错。
• never类型只会抛出异常没有返回值。
• never类型在联合类型中会被直接移除。

never类型的一个应用场景

type A = "中杯" | "大杯" | "超大杯";
function isXiaoMan(value: A) {
  switch (value) {
    case "中杯":
      break;
    case "大杯":
      break;
    case "超大杯":
      break;
    default:
      //是用于场景兜底逻辑
      const error: never = value;
      return error;
  }
}

Symbol

自ECMAScript 2015起，symbol成为了一种新的原生类型，就像number和string一样。

symbol类型的值是通过Symbol构造函数创建的。

可以传递参做为唯一标识 只支持 string 和 number类型的参数

let sym1 = Symbol();
let sym2 = Symbol("key"); 

const s1 = Symbol()
const s2 = Symbol()
// s1 === s2 =>false

let sym = Symbol();
let obj = {
    [sym]: "value"
};
console.log(obj[sym]); // "value"

const sym1 = Symbol("666");
const aym2 = Symbol("777");
const obj1 = {
  [sym1]: "张三",
  [aym2]: "李四",
  age: 19,
  sex: "男",
};
// 1 for in 遍历，拿不到symbol属性
for (const key in obj1) {
  console.log(key);
}
// 2 Object.keys 遍历，拿不到symbol属性
Object.keys(obj1);
console.log(Object.keys(obj1));
// 3 getOwnPropertyNames，拿不到symbol属性
console.log(Object.getOwnPropertyNames(obj1));
// 4 JSON.stringfy，拿不到symbol属性
console.log(JSON.stringify(obj1));

// 1 拿到具体的symbol 属性,对象中有几个就会拿到几个
Object.getOwnPropertySymbols(obj1)
console.log(Object.getOwnPropertySymbols(obj1))
// 2 es6 的 Reflect 拿到对象的所有属性
Reflect.ownKeys(obj1)
console.log(Reflect.ownKeys(obj1))

Symbol.iterator 迭代器 生成器 for of

支持遍历大部分类型迭代器 arr nodeList argumetns set map 等

var arr = [1,2,3,4];
let iterator = arr[Symbol.iterator]();
console.log(iterator.next());  //{ value: 1, done: false }
console.log(iterator.next());  //{ value: 2, done: false }
console.log(iterator.next());  //{ value: 3, done: false }
console.log(iterator.next());  //{ value: 4, done: false }
console.log(iterator.next());  //{ value: undefined, done: true }

原理实现 平时开发中不会手动调用iterator，因为他是有语法糖的：for of，for of不能循环对象，因为对象没有iterator，数组结构的原理也是调用迭代器。

既然知道原理，那我们就可以自己实现一个迭代器

const obj = {
  max: 5,
  current: 0,
  [Symbol.iterator]() {
    return {
      max: this.max,
      current: this.current,
      next() {
        if (this.current == this.max) {
          return {
            value: undefined,
            done: true,
          };
        } else {
          return {
            value: this.current++,
            done: false,
          };
        }
      },
    };
  },
};
for (let val of obj) {
  console.log(val); // 0 1 2 3 4
}
const a = { ...obj };
/**
 * {
 *  max: 5,
 *  current: 0,
 *  [Symbol(Symbol.iterator)]: [Function: [Symbol.iterator]]
 * }
 */
console.log(a);
const b = [...obj];
console.log(b); //[ 0, 1, 2, 3, 4 ]