O tipo subjacente de ts

Segundo o site oficial, é fácil lembrar

Documento do site oficial

1. número - número

let a: number = 0;
a = 5;

2. Booleano - booleano

let result: boolean = true;

3. corda - corda

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

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

4.1 Defina um array composto por elementos numéricos, o tipo de cada elemento deve 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 Defina um array composto por elementos string, o tipo de cada elemento deve ser string

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

4.3 Defina um array composto por quaisquer elementos, os tipos de cada elemento não precisam ser iguais, podendo ser de qualquer tipo

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

5. Uma tupla
   representa um array com um número e tipo de elementos conhecidos, e os tipos de cada elemento não precisam ser iguais

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

6. enumeração - enum

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

Exemplos de aplicação referem-se ao
método
de escrita 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>;
 }
}

Após enumeração com:

//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. qualquer significa qualquer tipo

let list: any = []

Ao chamar um método em uma variável, use qualquer tipo. O tipo de objeto só permite atribuição, da seguinte forma:
reporte um erro Error: Property 'toFixed' doesn't exist on type 'Object'ou Don't use `Object` as a type. The `Object` type actually meansuse o tipo de objeto incorretamente. Se você quiser chamar um método, use qualquer tipo e altere Object para any.

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 não existe tipo, quando uma função não retorna um valor, você verá que seu tipo de retorno é void

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

O código acima não declara que o tipo da função é nulo. Ao verificar o código VS, haverá um prompt de aviso: , Missing return type on functionbasta modificá-lo para o seguinte

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

9. nulo e indefinido

let value: null = null

No entanto, quando você especifica o sinalizador --strictNullChecks, nulo e indefinido só podem ser atribuídos a void e seus respectivos. Isso evita muitos problemas comuns. Talvez em algum lugar que você queira passar uma string ou nula ou indefinida, você pode usar o tipo de união string|null|undefined. Novamente, abordaremos os tipos de união mais tarde.

10. Never representa o tipo de valores que nunca existem
    Explicação do site oficial: O tipo never é o tipo de valor de retorno de uma expressão de função ou de uma expressão de função de seta que sempre lança uma exceção ou não tem nenhum valor de retorno; variáveis ​​também podem ser de digite nunca quando eles estão vinculados a protetores de tipo que nunca são verdadeiros.
    Simplificando, uma função que lança uma exceção e não tem valor de retorno será definida como um tipo nunca, como no exemplo a seguir:

// 返回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 um tipo não primitivo, ou seja, um tipo diferente de número, string, booleano, símbolo, nulo ou indefinido
    注意：Object类型的变量只是允许你给它赋任意值，却不能够在它上面调用任意的方法，即便它真的有这些方法，不然会报错

12. Asserção de tipo - [como sintaxe | <> sintaxe]

12.1 Sintaxe de "colchetes angulares":

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

12.2 como sintaxe:

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

A afirmação de tipo usando ts in vue suporta apenas sintaxe.