book

TypeScript eficaz, 2ª edição

by Dan Vanderkam

March 2025

Intermediate to advanced

404 pages

10h 41m

Portuguese (Portugal, Brazil)

O'Reilly Media, Inc.

Read now

Unlock full access

A quem se destina este livroPorque escrevi este livroComo este livro está organizadoConvenções em amostras de código TypeScriptConvenções tipográficas utilizadas neste livroUtilizar exemplos de códigoAprendizagem em linha da O'ReillyComo contactar-nosAgradecimentos
Agradecimentos à primeira edição
Item 1: Compreende a relação entre o TypeScript e o JavaScriptItem 2: Sabe que opções do Typescript estás a utilizarItem 3: Compreende que a geração de código é independente dos tiposItem 4: Fica à vontade com a digitação estruturalPonto 5: Limitar a utilização de qualquer tipo
Item 6: Usa o teu Editor para interrogar e explorar o sistema de tiposItem 7: Pensa nos tipos como conjuntos de valoresItem 8: Sabe como saber se um símbolo está no espaço de tipo ou no espaço de valorItem 9: Prefere Anotações de Tipo a Asserções de TipoItem 10: Evita os tipos de objectos de cobertura (String, Number, Boolean, Symbol, BigInt)Ponto 11: Distinguir o controlo dos bens em excesso do controlo de tipoItem 12: Aplica tipos a expressões de funções inteiras sempre que possívelItem 13: Conhece as diferenças entre tipo e interfaceItem 14: Utiliza readonly para evitar erros associados à mutaçãoItem 15: Utiliza operações de tipo e tipos genéricos para evitares repetir-tePonto 16: Prefere alternativas mais precisas às assinaturas de índicesItem 17: Evitar assinaturas de índices numéricos
Item 18: Evita sobrecarregar o teu código com tipos inferíveisItem 19: Utiliza variáveis diferentes para tipos diferentesItem 20: Compreende como uma variável obtém o seu tipoItem 21: Criar objectos de uma só vezItem 22: Compreender o estreitamento do tipoItem 23: Sê consistente na utilização de pseudónimosItem 24: Compreende como o contexto é utilizado na inferência de tiposItem 25: Compreende os tipos evolutivosItem 26: Utiliza construções funcionais e bibliotecas para ajudar os tipos a fluirItem 27: Usa funções assíncronas em vez de retornos de chamada para melhorar o fluxo de tiposItem 28: Utiliza classes e currying para criar novos locais de inferência
Item 29: Prefere tipos que representem sempre estados válidosPonto 30: Sê liberal no que aceitas e rigoroso no que produzesItem 31: Não repitas informações de tipo na documentaçãoItem 32: Evita incluir null ou undefined em aliases de tipoItem 33: Coloca os valores nulos no perímetro dos teus tiposItem 34: Prefere Uniões de Interfaces a Interfaces com UniõesItem 35: Prefere alternativas mais precisas aos tipos de cadeiaItem 36: Usar um tipo distinto para valores especiaisPonto 37: Limitar a utilização de propriedades opcionaisPonto 38: Evita a repetição de parâmetros do mesmo tipoItem 39: Prefere unificar tipos a modelar diferençasItem 40: Prefere tipos imprecisos a tipos imprecisosItem 41: Nomear tipos utilizando a linguagem do teu domínio problemáticoItem 42: Evita tipos baseados em dados anedóticos
Item 43: Utiliza o âmbito mais restrito possível para quaisquer tiposItem 44: Prefere variantes mais precisas de qualquer a qualquer simplesItem 45: Esconde Asserções de Tipo Inseguras em Funções Bem TipadasItem 46: Usa unknown em vez de any para valores com um tipo desconhecidoItem 47: Prefere abordagens Type-Safe para o Monkey PatchingPonto 48: Evita as armadilhas da solidezItem 49: Acompanha a tua Cobertura de Tipos para Evitar Regressões na Segurança de Tipos
Item 50: Pensa nos genéricos como funções entre tiposItem 51: Evita parâmetros de tipo desnecessáriosItem 52: Prefere tipos condicionais a assinaturas de sobrecargaItem 53: Sabe como controlar a distribuição de uniões sobre tipos condicionaisItem 54: Usa tipos literais de modelo para modelar DSLs e relações entre cadeias de caracteresItem 55: Escreve testes para os teus tiposItem 56: Presta atenção à forma como os tipos são apresentadosItem 57: Prefere os tipos genéricos recursivos de caudaPonto 58: Considera o Codegen como uma alternativa aos tipos complexos
Item 59: Utiliza os tipos Never para efetuar a verificação de exaustividadeItem 60: Sabe como fazer a iteração de objectosItem 61: Utiliza tipos de registo para manter os valores sincronizadosItem 62: Utiliza parâmetros de resto e tipos de tupla para modelar funções variádicasItem 63: Utiliza as propriedades opcionais Nunca para modelar o exclusivo ouItem 64: Considera as marcas para a digitação nominal
Item 65: Coloca TypeScript e @types em devDependenciesItem 66: Compreende as Três Versões Envolvidas nas Declarações de TipoItem 67: Exportar todos os tipos que aparecem em APIs públicasItem 68: Usa o TSDoc para comentários sobre a APIItem 69: Fornece um tipo para isto em Callbacks se fizer parte da sua APIItem 70: Espelhar tipos para separar dependênciasItem 71: Utiliza o aumento de módulos para melhorar os tipos

Item 72: Prefere as funcionalidades ECMAScript às funcionalidades TypeScriptItem 73: Usa mapas de origem para depurar o TypescriptItem 74: Saber Reconstruir Tipos em Tempo de ExecuçãoItem 75: Compreende a hierarquia DOMItem 76: Criar um modelo preciso do teu ambienteItem 77: Compreende a relação entre a verificação de tipo e o teste de unidadeItem 78: Presta atenção ao desempenho do compilador
Item 79: Escreve JavaScript modernoItem 80: Usa o @ts-check e o JSDoc para fazer experiências com o TypescriptItem 81: Usa allowJs para misturar TypeScript e JavaScriptItem 82: Converte módulo por módulo no teu gráfico de dependênciasItem 83: Não consideres a migração completa até activares o noImplicitAny

Content preview from TypeScript eficaz, 2ª edição

Capítulo 3. Inferência de tipos e análise do fluxo de controlo

Este trabalho foi traduzido com recurso a IA. Agradecemos o teu feedback e comentários: translation-feedback@oreilly.com

Para as linguagens de programação utilizadas na indústria , "estaticamente tipadas" e "explicitamente tipadas" têm sido tradicionalmente sinónimos. C, C++, Java: todas elas te obrigam a escrever os teus tipos. Mas as linguagens académicas nunca confundiram estas duas coisas: linguagens como ML e Haskell há muito que têm sistemas sofisticados de inferência de tipos, e isto começou a fazer o seu caminho para as linguagens da indústria. C++ adicionou auto, e Java adicionou var. Linguagens mais recentes como Rust e Swift têm inferência de tipos desde o início.

O Typescript faz uso extensivo da inferência de tipo. Se bem usado, isso pode reduzir drasticamente o número de anotações de tipo que seu código requer para obter segurança total de tipo. Uma das maneiras mais fáceis de distinguir um iniciante em TypeScript de um desenvolvedor mais experiente é pelo número de anotações de tipo. Um desenvolvedor experiente de TypeScript usará relativamente poucas anotações (mas as usará com grande efeito), enquanto um iniciante pode afogar seu código em anotações de tipo redundantes.

Na maioria das linguagens, uma variável tem um tipo e nunca muda. O Typescript é um pouco diferente. Uma variável tem um tipo numa localização no teu código. O processo pelo qual o seu tipo muda devido ao código circundante é conhecido ...