github: https://github.com/Jessie-jzn
site: https://www.jessieontheroad.com/
1. Verificação de tipo estático
A principal vantagem do TypeScript é sua verificação de tipo estático, que ajuda a detectar erros comuns durante a fase de compilação, em vez de durante o tempo de execução. Isso aumenta a confiabilidade e a estabilidade do código.
2. Experiência aprimorada de edição de código
O sistema de tipos do TypeScript permite recursos mais precisos de conclusão de código, refatoração, navegação e documentação em editores, aumentando significativamente a eficiência do desenvolvimento.
3. Capacidade de manutenção de código aprimorada
As declarações de tipo facilitam a compreensão das intenções e da estrutura do código, o que é particularmente benéfico em ambientes de desenvolvimento de equipe.
4. Recursos avançados de idioma
TypeScript oferece suporte a recursos avançados não presentes em JavaScript, como interfaces, enums e genéricos, facilitando o desenvolvimento de código mais estruturado e escalável.
5. Melhor suporte para ferramentas
TypeScript oferece várias opções de compilador para otimizar o código JavaScript gerado e oferece suporte a diferentes ambientes JS compilando TypeScript para JavaScript compatível.
TypeScript | JavaScript | |
---|---|---|
Sistema de tipos | Digitação estática com verificações de tipo em tempo de compilação. Os tipos podem ser especificados para variáveis, parâmetros de função e valores de retorno. | Digitação dinâmica com verificações de tipo de tempo de execução, o que pode levar a erros de tempo de execução relacionados ao tipo. |
Anotações de tipo | Suporta anotações de tipo para definir tipos explicitamente. Por exemplo, deixe name: string = "Alice"; | Sem anotações de tipo. Os tipos são determinados em tempo de execução. |
Compilação | Requer compilação em JavaScript. O compilador TypeScript verifica erros de tipo e gera código JavaScript equivalente. | Executa diretamente em navegadores ou Node.js sem etapa de compilação. |
Programação Orientada a Objetos | Recursos OOP mais avançados, como classes, interfaces, classes abstratas e modificadores de acesso. | Recursos básicos de OOP com herança baseada em protótipo. |
Recursos avançados | Inclui todos os recursos ES6 e ES7, além de recursos adicionais como genéricos, enumerações e decoradores. | Suporta ES6 e padrões posteriores, mas não possui alguns dos recursos avançados fornecidos pelo TypeScript. |
Os genéricos permitem que funções, classes e interfaces funcionem com qualquer tipo, ao mesmo tempo que reforçam a segurança do tipo.
Exemplo:
function identity(arg: T): T { return arg; } const numberIdentity = identity (42); const stringIdentity = identity ("Hello");
Neste exemplo, a função de identidade usa um
let anyVar: any; let unknownVar: unknown; anyVar = 5; anyVar.toUpperCase(); // No compile-time error, but might cause runtime error unknownVar = "Hello"; if (typeof unknownVar === "string") { unknownVar.toUpperCase(); // Type check ensures safety }
const obj = { name: "John" }; obj.name = "Doe"; // Allowed interface User { readonly id: number; name: string; } const user: User = { id: 1, name: "John" }; user.name = "Doe"; // Allowed user.id = 2; // Error, `id` is readonly
Decoradores são um recurso especial do TypeScript que permite adicionar metadados ou modificar classes, métodos, propriedades ou parâmetros.
Tipos:
Exemplos:
function sealed(constructor: Function) { Object.seal(constructor); Object.seal(constructor.prototype); } @sealed class Greeter { greeting: string; constructor(message: string) { this.greeting = message; } greet() { return `Hello, ${this.greeting}`; } }
function logMethod(target: any, propertyName: string, descriptor: PropertyDescriptor) { const originalMethod = descriptor.value; descriptor.value = function (...args: any[]) { console.log(`Method ${propertyName} called with args: ${JSON.stringify(args)}`); return originalMethod.apply(this, args); }; } class Calculator { @logMethod add(a: number, b: number): number { return a b; } }
Uso:
Decoradores são habilitados definindo experimentalDecorators como true em tsconfig.json.
interface e type são usados para definir tipos de objetos, mas têm algumas diferenças:
interface | tipo | |
---|---|---|
Uso básico | Define a forma dos objetos, incluindo propriedades e métodos. | Define tipos primitivos, tipos de objetos, tipos de união, tipos de interseção, etc. |
Extensão | Suporta mesclagem de declarações. Várias declarações da mesma interface são mescladas automaticamente. | Não suporta mesclagem de declarações. |
Tipos de união e intersecção | Não compatível. | Sindicato de suporte (` |
Aliases de tipo primitivo | Não compatível. | Suporta alias de tipos primitivos. |
Tipos mapeados | Não compatível. | Suporta tipos mapeados. |
Implementação de classe | Suporta implementação de classe usando implementos. | Não suporta implementação direta de classe. |
Essas perguntas e respostas devem ajudar a se preparar para entrevistas TypeScript, cobrindo conceitos fundamentais e uso prático.
Isenção de responsabilidade: Todos os recursos fornecidos são parcialmente provenientes da Internet. Se houver qualquer violação de seus direitos autorais ou outros direitos e interesses, explique os motivos detalhados e forneça prova de direitos autorais ou direitos e interesses e envie-a para o e-mail: [email protected]. Nós cuidaremos disso para você o mais rápido possível.
Copyright© 2022 湘ICP备2022001581号-3