github: https://github.com/Jessie-jzn
site: https://www.jessieontheroad.com/

1. Por que usar TypeScript?

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.

2. TypeScript versus JavaScript

3. Tipos de dados básicos em TypeScript

• Booleano: Representa valores verdadeiros ou falsos.
• Número: Representa números inteiros e de ponto flutuante.
• String: Representa dados textuais, usando aspas simples ou duplas.
• Array: Representa uma coleção de valores de um tipo especificado, usando type[] ou Array.
• Tupla: Representa um array com um número fixo de elementos com tipos especificados.
• Enum: Representa um conjunto de constantes nomeadas.
• Any: Representa qualquer tipo de valor. Não fornece verificação de tipo.
• Void: Representa a ausência de um valor, comumente usado como tipo de retorno de funções que não retornam um valor.
• Nulo e Indefinido: Representa a ausência de um valor e o estado não inicializado, respectivamente.
• Nunca: representa valores que nunca ocorrem, como funções que geram erros ou são executadas indefinidamente.
• Object: Representa tipos não primitivos.

4. O que são genéricos no TypeScript? Como eles são usados?

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 genérico, permitindo aceitar e retornar valores de qualquer tipo.

5. Diferença entre desconhecido e qualquer no TypeScript

• qualquer tipo: representa qualquer tipo de valor e ignora toda verificação de tipo. Pode ser atribuído qualquer valor sem verificações de tipo.
• tipo desconhecido: Representa um tipo desconhecido. Valores de tipo desconhecido devem ser verificados antes de serem usados, proporcionando uma maneira mais segura de lidar com valores cujo tipo é incerto.

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
}

6. Diferença entre modificador somente leitura e palavra-chave const

• modificador somente leitura: usado nas propriedades do objeto para torná-las imutáveis ​​após a inicialização.
• const Keyword: Usado para declarar variáveis ​​com referências imutáveis. As propriedades do objeto ainda podem ser modificadas.

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

7. Decoradores em TypeScript

Decoradores são um recurso especial do TypeScript que permite adicionar metadados ou modificar classes, métodos, propriedades ou parâmetros.

Tipos:

• Decoradores de classe: Aplicado a construtores de classe para modificar o comportamento da classe ou adicionar metadados.
• Decoradores de métodos: Aplicados a métodos para alterar seu comportamento ou adicionar metadados.
• Decoradores de acessórios: aplicados para obter ou definir acessadores para modificar seu comportamento.
• Decoradores de propriedades: Aplicados às propriedades da classe para adicionar metadados ou modificar seu comportamento.
• Decoradores de parâmetros: Aplicados aos parâmetros do método para adicionar metadados.

Exemplos:

• Decorador de Classe:

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}`;
  }
}

• Decorador de método:

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.

8. Diferença entre interface e tipo

interface e type são usados ​​para definir tipos de objetos, mas têm algumas diferenças:

Essas perguntas e respostas devem ajudar a se preparar para entrevistas TypeScript, cobrindo conceitos fundamentais e uso prático.