Tipo de unión y protección de tipo en TypeScript

Tipo de junta y protección de tipo

1. Tipo de junta

Cuando uno de nuestros métodos puede aceptar varios tipos de parámetros (parámetro), entonces se usa el tipo de unión en este momento .

class Student {
    name: string;
    jiaozuoye() { };
}
class Teacher {
    name: string;
    gaizuoye() { };
}
function f(parameter: Student | Teacher) { }

2. Tipo de protección

Sin embargo, hay otro problema que viene con el tipo de unión. Si hay dos métodos diferentes en Student y Teacher, ¿cómo pueden los parámetros de diferentes tipos determinar si existe un método especial que hereda el tipo? Para resolver este problema, introdujimos el concepto de protección de tipos .

como sintaxis

Como también se llama aserción de tipo. Como es equivalente a juicio artificial. Por ejemplo, el nombre de una persona (atributo de nombre) se llama "estudiante", luego juzgamos que es un estudiante y le permitimos llamar al método del estudiante jiaozuoye (). La operación específica es la siguiente.

function f(parameter: Student | Teacher) {
    if(parameter.name == "学生"){
        (parameter as Student).jiaozuoye();
    }
}

en sintaxis

La gramática es más fácil de entender. Por ejemplo, la diferencia entre nuestro Alumno y Maestro radica en la diferencia entre el método de entrega de la tarea y el cambio de tarea. Si el parámetro tiene la función de entregar la tarea, entonces lo juzgaremos como Estudiante, de lo contrario, lo juzgamos como Maestro. Cuando se puede usar en sintaxis.

function f(parameter: Student | Teacher) {
    if("jiaozuoye" in parameter){
        parameter.jiaozuoye();
    }else{
        parameter.gaizuoye();
    }
}

tipo de sintaxis

En el ejemplo anterior, todos los parámetros son tipos personalizados. ¿Cuál es nuestra estrategia de protección de tipos para tipos comunes? Dar un nuevo ejemplo

function f(parameter1: string | number, parameter2: string | number) {
//使用typeof进行类型判断
  if (typeof parameter1 === "string" || typeof parameter2 === "string") {
  //字符串拼接
    return `${first}${second}`;
  }
  return first + second;
}

instancia de sintaxis

La sintaxis de instanceof y typeof es muy similar, pero instanceof solo se puede usar para proteger la clase .

// 我们先定义一个类，作为我们类型保护的基础
class NumberObj {
    count: number;
}
// 实现一个相加的方法
function f(first: object | NumberObj, second: object | NumberObj) {
    // 运用instanceof语句对类型进行判断
    if (first instanceof NumberObj && second instanceof NumberObj) {
        return first.count + second.count;
    }
    return 0;
}