1. nunca
never Tipos são os tipos subjacentes no TypeScript. É bem utilizado nas seguintes situações:
- Uma função que nunca retorna um valor, ou seja, um loop infinito (por exemplo, se a função contiver
while(true) {}); - Uma função que sempre gera um erro (como:
function foo() { throw new Error('Not Implemented') },fooo tipo de retorno énever);
function foo(): never {//永远不会返回结果 // 死循环 while(true) {}
}
function bar(): never {throw new Error()
}
neverSó pode ser atribuído a outronevertipo, portanto pode ser usado para verificações abrangentes em tempo de compilação
Exemplo:
function foo(x: string | number): boolean {if (typeof x === 'string') {return true;} else if (typeof x === 'number') {return false;}// 如果不是一个 never 类型，这会报错：// - 不是所有条件都有返回值 （严格模式下）// - 或者检查到无法访问的代码// 但是由于 TypeScript 理解 `fail` 函数返回为 `never` 类型// 它可以让你调用它，因为你可能会在运行时用它来做安全或者详细的检查。return fail('Unexhaustive');
}
function fail(message: string): never {throw new Error(message);
}
2. nulo (valor nulo)
JavaScript não possui o conceito de valor nulo (void), em TypeScript, significa没有任何返回值的函数
// 没有返回值的函数，其返回值类型为 void
function alertName(): void { alert('My name is Tom'); }
É claro que você também pode declarar uma variável como void, mas só pode atribuir a ela um valor de undefined 和 null:
let unusable: void = undefined;
voidCenários de uso em funções:
// 如果什么都不写，此时，add 函数的返回值类型为： void
const add = () => { //
}
// 如果return之后什么都不写，此时，add 函数的返回值类型为： void
const add = () => { return
}
const add = (): void => {// 此处，返回的 undefined 是 JS 中的一个值return undefined
}
// 这种写法是明确指定函数返回值类型为 void，与上面不指定返回值类型相同
const add = (): void => {//
}
3. desconhecido
unknownÉ um tipo especial em TypeScript, usado para descrever variáveis de tipo incerto. Isto é any类型semelhante a , mas é mais seguro, pois é ilegal fazer qualquer coisa com valores desconhecidos.
function foo() {return 'abc'
}
function bar() {return 123
}
// unknown类型只能赋值给any和unknown类型
// any类型可以赋值给任意类型
let flag = true
let result: unknown // 最好不要使用any
if (flag) {result = foo()
} else {result = bar()
}
let message: string = result //报错
let num: number = result //报错
let num1: unknown = result
let num2: any = result
console.log(result)
Qualquer operação em um tipo desconhecido requer restrição de tipo ou asserção de tipo
Exemplo:
let value: unknown = 123;
console.log(++value )//error:'value' is of type 'unknown'.
console.log(++(value as number) )
O tipo de união de desconhecido com qualquer outro tipo, exceto any, é, em última análise,
unknownum tipo
Exemplo:
Tipos de interseção compostos por desconhecidos e qualquer outro tipo acabam sendo outros tipos
Exemplo:
Claro que existem outros unkonwrecursos, como:
1. Apenas operações 相等 OR 不等 podem ser executadas em tipos desconhecidos, e nenhuma outra operação pode ser executada; 2. Valores de tipos desconhecidos não podem acessar as propriedades e métodos de instâncias criadas; 3. Ao usar tipos mapeados, se o tipo desconhecido for percorrido, nada será mapeado Propriedades; você pode clicar em www.likecs.com/show-306158… para saber o que foi dito acima.
4. A diferença entre nunca e nulo
1. void Indica que não existe tipo, never indicando um tipo de valor que nunca existe. 2. Quando uma função retorna um valor nulo, seu valor de retorno é voiddo tipo, mas quando uma função nunca retorna (ou sempre gera um erro), seu valor de retorno é neverdo tipo. voidOs tipos podem ser atribuídos a (quando strictNullChecking for falso), mas nevernão a qualquer tipo diferente de si mesmo never. 5. Outros assuntos que necessitam de atenção
unknown, nevernão têm permissão para executar métodos de variáveis e acessar propriedades internas;
neveré um subtipo de todos os tipos;
afinal
Preparamos um pacote de informações iniciais para todos. Contém 54 e-books relacionados ao front-end 2.57G, "Guia de entrevista de front-end (com respostas e análises)", tutoriais em vídeo sobre conhecimentos difíceis e importantes (conjunto completo).
Amigos necessitados podem clicar no cartão abaixo para recebê-lo e compartilhá-lo gratuitamente