El tipo subyacente de ts

Según el sitio web oficial, es fácil de recordar.

Documento del sitio web oficial

1. número - número

let a: number = 0;
a = 5;

2. Booleano - booleano

let result: boolean = true;

3. cuerda - cuerda

let name: string = "";
name = "小明"

4. Matriz - número[] / cadena[]

4.1 Definir una matriz compuesta por elementos numéricos, el tipo de cada elemento debe ser número

let list: number[] = []; //数组中只能包含数字
list = [1,2,3] //Ok
list = ['a', 'b', 1] //Error: Type 'string' is not assignable to type 'number'

4.2 Definir una matriz compuesta por elementos de cadena, el tipo de cada elemento debe ser cadena

 let data: string[] = []; //数组中只能是字符串
 data = ['a','b','c'] //Ok
 data = [1,2,3] //Error: Type 'number' is not assignable to type 'string'

4.3 Defina una matriz compuesta por cualquier elemento, los tipos de cada elemento no tienen que ser los mismos y pueden ser de cualquier tipo

let arr: any[] = [];
arr = ['a',1,'c'] //Ok

5. Una tupla
   representa una matriz con un número y tipo de elementos conocidos, y los tipos de cada elemento no tienen por qué ser los mismos.

  let result: [number, string]; //数组中的第一项只能是数字，第二项只能是字符串
  result =  [1, 'red'] //Ok
  result = [1,2] //Error: Type 'number' is not assignable to type 'string'

6. enumeración - enumeración

enum Color {red, green}
let color: Color = Color[0];// red
let colorIndex = Color[red];//0

Los ejemplos de aplicación se refieren al
método
de escritura original.

//0:未提交,1待复核,2:已通过,3:已驳回
import { Tag } from "antd";
import React from "react";

//0:未提交,1待复核,2:已通过,3:已驳回
export default ({status}) => {
 switch ( status ) {
   case 0:
     return <Tag color="#108ee9">未提交</Tag>;
   case 1:
     return <Tag color="#2db7f5">待复核</Tag>;
   case 2:
     return <Tag color="#87d068">已通过</Tag>;
   case 3:
   default:
     return <Tag color="#f50">已驳回</Tag>;
 }
}

Después de la enumeración con:

//0:未提交,1待复核,2:已通过,3:已驳回
import { Tag } from "antd";
import React from "react";

enum Status {total = -1, unSubmit = 0, waitCheck = 1, passed = 2, rejected = 3}

//0:未提交,1待复核,2:已通过,3:已驳回
export default ({status}) => {
 switch ( status ) {
   case Status.unSubmit:
     return <Tag color="#108ee9">未提交</Tag>;
   case Status.waitCheck:
     return <Tag color="#2db7f5">待复核</Tag>;
   case Status.passed:
     return <Tag color="#87d068">已通过</Tag>;
   case Status.rejected:
   default:
     return <Tag color="#f50">已驳回</Tag>;
 }
}

7. cualquier medio cualquier tipo

let list: any = []

Cuando llame a un método en una variable, use cualquier tipo. El tipo de objeto solo permite la asignación, de la siguiente manera:
informe un error Error: Property 'toFixed' doesn't exist on type 'Object'o Don't use `Object` as a type. The `Object` type actually meansuse el tipo de objeto incorrectamente. Si desea llamar a un método, use cualquier tipo y cambie el Objeto a cualquiera.

let notSure: any = 4;
notSure.toFixed(); // okay, toFixed exists (but the compiler doesn't check)

let prettySure: Object = 4;
prettySure.toFixed(); // Error: Property 'toFixed' doesn't exist on type 'Object'.

8. void significa que no hay ningún tipo, cuando una función no devuelve un valor, verás que su tipo de retorno es void

function test(name: string){
  console.log('-----')
}

El código anterior no declara que el tipo de función sea nulo. Al verificar el código VS, aparecerá un mensaje de advertencia:, Missing return type on functionsimplemente modifíquelo a lo siguiente

 function test(name: string): void{
  console.log('-----')
}

9. nulo e indefinido

let value: null = null

Sin embargo, cuando especifica el indicador --strictNullChecks, null e indefinido solo se pueden asignar a void y sus respectivos. Esto evita muchos problemas comunes. Tal vez en algún lugar desee pasar una cadena o nula o indefinida, puede usar el tipo de unión cadena|nulo|indefinido. Nuevamente, cubriremos los tipos de sindicatos más adelante.

10. Nunca representa el tipo de valores que nunca existen
    Explicación del sitio web oficial: El tipo nunca es el tipo de valor de retorno de una expresión de función o una expresión de función de flecha que siempre arroja una excepción o no tiene ningún valor de retorno; las variables también pueden ser de escriba nunca cuando están sujetos a guardas de tipo que nunca son verdaderas.
    En pocas palabras, una función que genera una excepción y no tiene valor de retorno se definirá como un tipo nunca, como en el siguiente ejemplo:

// 返回never的函数必须存在无法达到的终点
function error(message: string): never {
    throw new Error(message);
}

// 推断的返回值类型为never
function fail() {
    return error("Something failed");
}

// 返回never的函数必须存在无法达到的终点
function infiniteLoop(): never {
    while (true) {
    }
}

11. Objeto: representa un tipo no primitivo, es decir, un tipo distinto de número, cadena, booleano, símbolo, nulo o indefinido.
    注意：Object类型的变量只是允许你给它赋任意值，却不能够在它上面调用任意的方法，即便它真的有这些方法，不然会报错

12. Aserción de tipo - [como sintaxis | <> sintaxis]

12.1 Sintaxis de los "corchetes angulares":

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

12.2 como sintaxis:

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

La afirmación de tipo que usa ts en vue solo se admite como sintaxis.