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 6. Genéricos e Programação em Nível de Tipo

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

O sistema de tipos do TypeScript foi projetado para modelar o comportamento do código JavaScript em tempo de execução. Como o JavaScript é muito dinâmico e permissivo, isso levou o sistema de tipos do TypeScript a desenvolver recursos cada vez mais poderosos. Como o Item 15 explicou, isso inclui lógica para mapeamento entre tipos.

Quando adicionas aliases de tipos genéricos à mistura, o sistema de tipos do Typescript torna-se suficientemente poderoso para que possas pensar nele como a sua própria linguagem de programação independente. (O sistema de tipos do TypeScript é Turing Complete, então isso é verdade num sentido formal). Em vez de programar com valores, como fazes em JavaScript, agora estás a programar com tipos. Em outras palavras, programação em nível de tipo. Isto é diferente de metaprogramação (escrever programas que operam em programas), embora os dois termos sejam por vezes confundidos.

Aprender novas linguagens é divertido, e podes encontrar todo o tipo de aplicações selvagens construídas usando o sistema de tipos do Typescript, desde jogos a analisadores SQL. Isso foi impulsionado em parte pelo projeto Type Challenges, que inclui centenas de quebra-cabeças cada vez mais difíceis de resolver no sistema de tipos. Resolvê-los enquanto lê este capítulo é uma ótima maneira de consolidar o que aprendeu. ...