Como passar na entrevista de TypeScript: principais perguntas

Como passar em uma entrevista de TypeScript: principais perguntas

TypeScript solidificou seu lugar como uma das ferramentas mais requisitadas no desenvolvimento web moderno. Se você está se preparando para uma entrevista técnica, conhecer os fundamentos e recursos avançados do TypeScript é obrigatório. Neste artigo, vamos analisar as principais perguntas frequentemente feitas em entrevistas e fornecer exemplos de código para fixar o conteúdo.

1. Tipos básicos e suas diferenças do JavaScript

Na entrevista, certamente perguntarão sobre os tipos básicos do TypeScript e seu comportamento. A principal diferença do JavaScript é a tipagem estática. Vamos analisar os pontos-chave.

1.1. Tipos primitivos: string, number, boolean

TypeScript adiciona anotação explícita de tipos. Por exemplo:

let name: string = 'Anna';let age: number = 30;let isActive: boolean = true;

Sem anotação, o TypeScript infere o tipo automaticamente (type inference).

1.2. Tipo any e unknown

any desativa a verificação de tipos — é melhor evitá-lo. unknown é uma alternativa segura, que requer verificação antes do uso:

let data: unknown = 'string';// console.log(data.toUpperCase()); // Erro!if (typeof data === 'string') {  console.log(data.toUpperCase()); // Ok}

1.3. never e void

• void — a função não retorna nada.
• never — a função nunca termina (lança erro ou loop infinito).

function throwError(msg: string): never {  throw new Error(msg);}

2. Interfaces e tipos (interface vs type)

Esta é uma das perguntas mais comuns. Ambos os mecanismos permitem descrever a estrutura de objetos, mas há diferenças.

2.1. Quando usar interface

• Para declarar contratos de objetos e classes.
• Possibilidade de extensão (declaration merging):

interface User {  name: string;}interface User {  age: number;}// User agora contém name e age

2.2. Quando usar type

• Para uniões (union), interseções (intersection) e aliases primitivos.
• Não suporta declaration merging.

type Status = 'active' | 'inactive';type Person = { name: string } & { age: number };

Pergunta de entrevista: "É possível substituir interface por type?" — Sim, mas para classes e extensão é melhor usar interface.

3. Generics

Generics permitem criar componentes reutilizáveis que funcionam com qualquer tipo. É um must-have para posições senior.

3.1. Função genérica simples

function firstElement<T>(arr: T[]): T {  return arr[0];}const num = firstElement([1, 2, 3]); // numberconst str = firstElement(['a', 'b']); // string

3.2. Restrições de generics (extends)

function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {  return obj[key];}const user = { name: 'Ivan', age: 25 };console.log(getProperty(user, 'name')); // Ivan

3.3. Generics em interfaces

interface Repository<T> {  getById(id: number): T;  save(item: T): void;}

Frequentemente perguntam: "Para que servem os generics se existe any?" — Generics preservam a segurança de tipos.

4. Utility Types e recursos avançados

Tipos utilitários embutidos (Partial, Required, Pick, Omit) são indicadores de compreensão profunda do TypeScript.

4.1. Partial e Required

interface Task {  title: string;  done: boolean;}const partialTask: Partial<Task> = { title: 'Estudar' };const requiredTask: Required<Task> = { title: 'Estudar', done: false };

4.2. Pick e Omit

interface User {  id: number;  name: string;  email: string;}type UserPreview = Pick<User, 'id' | 'name'>;type UserWithoutEmail = Omit<User, 'email'>;

4.3. Record

type Page = 'home' | 'about' | 'contact';type PageInfo = Record<Page, { title: string }>;const pages: PageInfo = {  home: { title: 'Início' },  about: { title: 'Sobre' },  contact: { title: 'Contato' }};

5. Modificadores de acesso e classes abstratas

TypeScript suporta programação orientada a objetos com modificadores de acesso e classes abstratas.

5.1. Modificadores: public, private, protected

class Animal {  public name: string;  private age: number;  protected type: string;

  constructor(name: string, age: number, type: string) {    this.name = name;    this.age = age;    this.type = type;  }}

5.2. Classes abstratas

abstract class Shape {  abstract getArea(): number;

  printArea(): void {    console.log(`Área: ${this.getArea()}`);  }}

class Circle extends Shape {  constructor(private radius: number) {    super();  }

  getArea(): number {    return Math.PI * this.radius ** 2;  }}

6. Decorators

Decorators são um recurso experimental que permite modificar classes e seus membros. Frequentemente usado em frameworks como Angular e NestJS.

6.1. Class decorator

function sealed(constructor: Function) {  Object.seal(constructor);  Object.seal(constructor.prototype);}

@sealedclass Logger {  log(msg: string) {    console.log(msg);  }}

6.2. Method decorator

function log(target: any, key: string, descriptor: PropertyDescriptor) {  const original = descriptor.value;  descriptor.value = function(...args: any[]) {    console.log(`Chamando ${key} com`, args);    return original.apply(this, args);  };}

class Calculator {  @log  add(a: number, b: number): number {    return a + b;  }}

7. Mapped Types e Conditional Types

Tipos avançados que permitem transformar tipos existentes de forma dinâmica.

7.1. Mapped Types

type Readonly<T> = {  readonly [P in keyof T]: T[P];};

interface User {  name: string;  age: number;}

type ReadonlyUser = Readonly<User>;// { readonly name: string; readonly age: number; }

7.2. Conditional Types

type IsString<T> = T extends string ? 'sim' : 'não';

type A = IsString<string>; // 'sim'type B = IsString<number>; // 'não'

8. Module augmentation e declaration merging

Recurso que permite estender tipos existentes de bibliotecas de terceiros.

// express.d.tsdeclare module 'express' {  interface Request {    user?: {      id: number;      name: string;    };  }}

9. Type Guards e narrowing

Técnicas para restringir tipos em tempo de execução.

9.1. typeof type guard

function printValue(value: string | number) {  if (typeof value === 'string') {    console.log(value.toUpperCase());  } else {    console.log(value.toFixed(2));  }}

9.2. instanceof type guard

class Dog {  bark() { console.log('Au au'); }}class Cat {  meow() { console.log('Miau'); }}

function makeSound(animal: Dog | Cat) {  if (animal instanceof Dog) {    animal.bark();  } else {    animal.meow();  }}

9.3. Type predicates

function isString(value: any): value is string {  return typeof value === 'string';}

function processValue(value: string | number) {  if (isString(value)) {    console.log(value.length); // TypeScript sabe que é string  }}

10. Dicas para a entrevista

• Entenda os conceitos fundamentais — tipos, interfaces, generics.
• Pratique com exemplos reais — crie pequenos projetos com TypeScript.
• Conheça as diferenças com JavaScript — destaque a segurança de tipos.
• Prepare-se para perguntas sobre configuração — tsconfig.json, strict mode.
• Mostre conhecimento de padrões — factory, singleton com TypeScript.

Dominar TypeScript abre portas para posições em empresas que valorizam código robusto e escalável. Boa sorte na sua preparação!