TypeScript细碎知识点：TS中常见的9种操作符&运算符

🐹 1. 非空断言操作符（!）

在上下⽂中当类型检查器⽆法断定类型时，⼀个新的后缀表达式操作符 ! 可以⽤于断⾔操作对象是⾮ null 和⾮ undefined 类型

🐡 赋值时忽略 null 和 undefined

const fn = (name: string | null | undefined) => {
    const objName: string = name; //🙅错误：不能将类型“string | null | undefined”分配给类型“string”。不能将类型“undefined”分配给类型“string”。
}

const fn1 = (name: string | null | undefined) => {
    const objName: string = name!; //🙅正确：告诉编译器，我确定传进来的肯定不是null 和 undefined, 那么就是剩下string类型了。 编译器通过了
}

🐡 函数调用时忽略 null 和 undefined

type myFunc = ()=>string;

const fn = (func: myFunc | null | undefined) => {
    func() //🙅错误：不能调用可能是 "null" 或“未定义”的对象。
}

const fn1 = (func: myFunc | null | undefined) => {
    func!() //🙅正确：告诉编译器，你别管了。我确定它就myFunc类型，不是null和undefined。出了事情我负责
}

🐹 2. 可选链操作符（?.）

可选链操作符( ?. ) 允许读取位于连接对象链深处的属性的值，而不必明确验证链中的每个引用是否有效。?. 操作符的功能类似于 . 链式操作符，不同之处在于，在引用为空(nullish ) (null 或者 undefined) 的情况下不会引起错误，该表达式短路返回值是 undefined。与函数调用一起使用时，如果给定的函数不存在，则返回 undefined。

就是代码运行时如果遇到 null 或 undefined 就可以⽴即停⽌某些表达式的运⾏，直接返回undefined

const obj = {
  foo: {
    bar: {
      baz: 42,
    },
  },
};

const baz = obj?.foo?.bar?.baz; // 42
const safe = obj?.qux?.baz; // undefined

支持的语法如下：

obj?.prop    // 尝试访问可能不存在的属性
obj?.[exp]   // 同上，计算属性写法
arr?.[index] // 尝试访问可能不存在的索引
func?.[args] // 尝试调用可能不存在的方法

🐹 3. 空值合并运算符（??）

当左侧操作数为 null 或 undefined 时，其返回右侧的操作数，否则返回左侧的操作数。

const data1 = 0

// 如果data1是undefined或者null，data2=100
const data2 = data1 ?? 100

// es5实现
const data2 = data1===undefined || data1===null ? 100 : data1

🐹 4. 可选属性（?:）

在⾯向对象语⾔中，接⼝是⼀个很重要的概念，它是对⾏为的抽象，⽽具体如何⾏动需要由类去实现。TypeScript 中的接⼝是⼀个⾮常灵活的概念，除了可⽤于对类的⼀部分⾏为进⾏抽象以外，也常⽤于对「对象的形状（Shape）」进⾏描述。

在 TypeScript 中使⽤ interface 关键字就可以声明⼀个接⼝：

interface Person {
    name: string;
    age: number; 
}

let nordon: Person = {
    name: "nordon"
};

若是缺少参数将会报错，此时就需要使用可选属性

interface Person {
    name: string;
    age?: number; //告诉编译器 age 它不重要一个可有可无的存在，不用报错了！
}

🐹 5. 运算符（&）

在 TypeScript 中交叉类型是将多个类型合并为⼀个类型。通过 & 运算符可以将现有的多种类型叠加到⼀起成为⼀种类型，它包含了所需的所有类型的特性

type PartialPointX = { x: number; };
type Point = PartialPointX & { y: number; };

let point: Point = {
    x: 1,
    y: 1
}

🐹 6. 运算符（|）

在 TypeScript 中联合类型（Union Types）表示取值可以为多种类型中的⼀种，联合类型使⽤ | 分隔每个类型。联合类型通常与 null 或 undefined ⼀起使⽤

const fn = (info: strong | null | undefined) => {}

🐹 7. 数字分隔符（_）

数字分割符，不会改变字面量的值，用于逻辑分组便于阅读。

//🙆 是不是读着清晰了
const inhabitantsOfMunich = 1_464_301; 
const distanceEarthSunInKm = 149_600_000;
const fileSystemPermission = 0b111_111_000;
const bytes = 0b1111_10101011_11110000_00001101;

// 对应的 es5
"use strict";
var inhabitantsOfMunich = 1464301;
var distanceEarthSunInKm = 149600000;
var fileSystemPermission = 504;
var bytes = 262926349;

🐹 8. 类型断言，在编译时起作用<Type>

类型断言，在编译时起作用。

let someValue: any = "this is a string";
let strLength: number = (<string>someValue).length;

🐹 9. 私有字段，在class中使用#

私有字段，在class中使用

• 私有字段必须以#开头
• 每个私有字段名称都唯一地限定于其包含的类
• 不能在私有字段上使用Typescript可访问性修饰符，如：public或private
• 私有字段不能在包含的类之外访问，甚至不能被检测到

class Person {
    /*私有字段*/
    #name: string; // 除了类内，谁也别想找到我

    constructor(name: string) {
        this.#name = name;
    }

    greet() {
        console.log(`${this.#name}!`);
    }
}

let semlinker = new Person("Semlinker");

typescript就已经提供了private、public、protected等 修饰符。那么#与private又有什么区别呢？

🐡 使用#定义私有字段

class Person {
    #name: string
    constructor(name: string) {
        this.#name = name;
    }
    greet(){
        console.log(`Hello, my name is ${this.#name}!`);
    }
}

let person = new Person("Hi! Man")

person.#name  //🙅错误：属性 "#name" 在类 "Person" 外部不可访问，因为它具有专用标识符。

🐡 使用private 定义变量

class Person {
    private name: string
    constructor(name: string) {
        this.name = name;
    }
    greet(){
        console.log(`Hello, my name is ${this.name}!`);
    }
}

let person = new Person("Hi! Man")

person.name  //🙅错误：属性“name”为私有属性，只能在类“Person”中访问。

通过上面的栗子我们看到，#和private都会产生警告。但是这个使用了#实现了真正的私有，而private仅仅是一个检查。简单来说，就是在--noEmitOnError:false时，我们可以进行以下操作。

//private 修饰的结果
let person1 = new Person("Hi! Man");
person1.name //如果忽视编译警告emit文件，运行时获取到"Hi! Man"

//# 修饰
let person2 = new Person("Hi! Man");
person2.#name //Error,name of undefined