TS: Tipo de inferencia compatible

TS: Tipo de inferencia compatible

1. Tipos de variables compatibles

• Si la variable x debe ser compatible con y, entonces y debe tener al menos los mismos atributos que x:

  interface Named {
        
        
      name : string;
  }
  let x : Named;
  let y = {
        
        
      name : 'yivi',age : 12
  };
  x = y;	// ok,y中拥有x的属性name
  

2. Tipos de funciones compatibles

• La primera es la compatibilidad de parámetros: dependiendo de si la función x se puede asignar ay, cada parámetro de x debe poder encontrar el tipo de parámetro correspondiente en y . (El nombre del parámetro no importa, el tipo es el mismo).

  let x = (a: number) => 0;
  let y = (b: number , s:string) => 0;
  y = x;	// ok
  x = y;	//error,x中缺少y的多余参数。
  

• El segundo es la compatibilidad del valor de retorno: el tipo de valor de retorno de la función original debe ser un subtipo del tipo de valor de retorno de la función de destino.

  let x = () => ({
        
        name : 'yivi'});
  let y = () => ({
        
        name : 'yivi',age : 20});
  
  x = y;	// ok
  y = x; 	// error,x的返回值缺少参数。
  

3. Inestabilidad de parámetros opcionales y parámetros restantes

• Cuando una función tiene parámetros restantes, se tratará como un número ilimitado de parámetros opcionales;

• Esto es inestable para el sistema de tipos, pero desde un punto de vista operativo, es equivalente a una ruta de paso para la mayoría de las funciones undefined.

• Los parámetros de la función de devolución de llamada son predecibles para el programador, pero inciertos para el sistema de tipos.

  function foo(args : any[],callback : (...args : any[]) => void){
        
        
      // 程序实现
  }
  

4. Compatible con enumeración

• Los tipos de enumeración y los tipos digitales son compatibles entre sí;

• Los diferentes tipos de enumeración son incompatibles entre sí;

  enum A {
        
        OK，ERROR};
  enum B {
        
        SUCCESS,FAILED};
  
  let status = A.OK;
  status = B.SUCCESS;	//error!
  

5. Compatibilidad de clases

• Al comparar objetos de dos tipos de clases, solo se compararán los miembros de la instancia.

• ¡Los miembros estáticos y los constructores no están incluidos! ! !

  class Cat {
        
        
      kind : string;
      constructor(name : string,size : number){
        
        }
  }
  class Dog {
        
        
      kind : string;
      constructor(name : string){
        
        }
  }
  
  let c : Cat;
  let d : Dog;
  c = d;	//ok
  d = c;	//ok
  

6. Compatibilidad genérica

• El efecto del parámetro de tipo usa su tipo de resultado como parte del tipo.

  interface Empty<T> {
        
        }
  
  let x : Empty<number>;
  let y : Empty<string>;
  
  x = y;	//ok，由于接口里没有成员,所以y的结构和x一致
  

• Pero cuando hay miembros en la interfaz, es un asunto diferente:

  interface Full<T> {
        
        
      data : T
  }
  
  let x : Full<number>;
  let y : Full<string>;
  
  x = y;	// error!x和y的结构不一致！