DEV Community: Yuri Peixinho

Typescritp: Sobrecarga de Construtor

Yuri Peixinho — Sat, 13 Jun 2026 21:53:26 +0000

Introdução

Assim como funções, construtores podem ter múltiplas assinaturas:

O problema

class Evento {
  constructor(id: string, tipo: string, competencia: string) { ... }
  // como aceitar também só id e tipo, sem competencia?
}

Solução — overload signatures

class Evento {
  id: string;
  tipo: string;
  competencia: string;

  // assinaturas
  constructor(id: string, tipo: string);
  constructor(id: string, tipo: string, competencia: string);

  // implementação
  constructor(id: string, tipo: string, competencia: string = "nao-definida") {
    this.id = id;
    this.tipo = tipo;
    this.competencia = competencia;
  }
}

new Evento("1", "R-2010");              // ✅ primeira assinatura
new Evento("1", "R-2010", "2024-01");   // ✅ segunda assinatura

Typescript: Sobrecarga de Métodos

Yuri Peixinho — Sat, 13 Jun 2026 21:53:05 +0000

Introdução

Subclasses podem substituir a implementação de métodos herdados usando override:

Sem `override`

class TransmissorBase {
  logar(msg: string): void {
    console.log(msg);
  }
}

class TransmissorReinf extends TransmissorBase {
  logar(msg: string): void {
    // sobrescreve, mas TypeScript não verifica
    console.log(`[REINF] ${msg}`);
  }
}

Com `override` — recomendado

class TransmissorReinf extends TransmissorBase {
  override logar(msg: string): void {
    console.log(`[REINF] ${msg}`);
  }
}

O override explícito faz o TypeScript verificar que o método realmente existe na classe pai — se você errar o nome, ele avisa:

class TransmissorReinf extends TransmissorBase {
  override lagar(msg: string): void { // ❌ erro — "lagar" não existe na base
    console.log(`[REINF] ${msg}`);
  }
}

Chamando o método da classe pai com `super`

class TransmissorBase {
  protected logar(msg: string): void {
    console.log(`[BASE] ${msg}`);
  }
}

class TransmissorReinf extends TransmissorBase {
  override logar(msg: string): void {
    super.logar(msg);                   // chama o pai primeiro
    console.log(`[REINF] ${msg}`);      // depois adiciona comportamento
  }
}

Typescript: Herança e Polimorfismo

Yuri Peixinho — Sat, 13 Jun 2026 21:52:50 +0000

Herança

Herança é quando uma classe estende outra e herda seus membros:

class EntidadeBase {
  constructor(
    public id: string,
    public criadoEm: Date = new Date()
  ) {}

  toString(): string {
    return `[${this.id}]`;
  }
}

class EventoFiscal extends EntidadeBase {
  constructor(
    id: string,
    public tenantId: string,
    public competencia: string
  ) {
    super(id); // obrigatório chamar super
  }
}

class EventoReinf extends EventoFiscal {
  constructor(
    id: string,
    tenantId: string,
    competencia: string,
    public codigoEvento: string
  ) {
    super(id, tenantId, competencia);
  }
}

Polimorfismo

Polimorfismo é a capacidade de tratar objetos de tipos diferentes de forma uniforme através de um tipo base:

abstract class TransmissorFiscal {
  abstract transmitir(payload: unknown): Promise<Protocolo>;
}

class TransmissorReinf extends TransmissorFiscal {
  async transmitir(payload: unknown): Promise<Protocolo> {
    return api.post("/reinf", payload);
  }
}

class TransmissorEFinanceira extends TransmissorFiscal {
  async transmitir(payload: unknown): Promise<Protocolo> {
    return api.post("/efinanceira", payload);
  }
}

// função que aceita qualquer transmissor — polimorfismo
async function executarTransmissao(
  transmissor: TransmissorFiscal,
  payload: unknown
) {
  return transmissor.transmitir(payload); // não importa qual é
}

// chamadas polimórficas
executarTransmissao(new TransmissorReinf(), payload);
executarTransmissao(new TransmissorEFinanceira(), payload);

O código que usa TransmissorFiscal não precisa saber qual implementação está recebendo — isso é o coração do polimorfismo.

Typescript: Classes Abstratas

Yuri Peixinho — Sat, 13 Jun 2026 21:52:32 +0000

Introdução

Classes abstratas são contratos parcialmente implementados. Você define o que toda subclasse deve ter, mas deixa partes da implementação para elas.

Não podem ser instanciadas diretamente

abstract class TransmissorFiscal {
  constructor(protected tenantId: string) {}

  // método abstrato — subclasse DEVE implementar
  abstract transmitir(payload: unknown): Promise<Protocolo>;
  abstract consultar(protocolo: string): Promise<Status>;

  // método concreto — subclasse HERDA pronto
  protected logar(msg: string): void {
    console.log(`[Tenant: ${this.tenantId}] ${msg}`);
  }

  async executar(payload: unknown): Promise<Protocolo> {
    this.logar("iniciando transmissão");
    const protocolo = await this.transmitir(payload);
    this.logar(`protocolo: ${protocolo.numero}`);
    return protocolo;
  }
}

// ❌ não pode instanciar diretamente
const t = new TransmissorFiscal("tenant1");

Subclasses implementam os métodos abstratos

class TransmissorReinf extends TransmissorFiscal {
  async transmitir(payload: unknown): Promise<Protocolo> {
    // implementação específica do REINF
    const resposta = await api.post("/reinf", payload);
    return resposta.data;
  }

  async consultar(protocolo: string): Promise<Status> {
    const resposta = await api.get(`/reinf/${protocolo}`);
    return resposta.data;
  }
}

class TransmissorEFinanceira extends TransmissorFiscal {
  async transmitir(payload: unknown): Promise<Protocolo> {
    // implementação específica do eFinanceira
    const resposta = await api.post("/efinanceira", payload);
    return resposta.data;
  }

  async consultar(protocolo: string): Promise<Status> {
    const resposta = await api.get(`/efinanceira/${protocolo}`);
    return resposta.data;
  }
}

Se uma subclasse não implementar um método abstrato, o TypeScript acusa erro em compilação.

Typescript: Modificadores de Acesso

Yuri Peixinho — Sat, 13 Jun 2026 21:52:17 +0000

Introdução

Modificadores de acesso controlam quem pode ler e escrever cada membro da classe.

Modificador	Classe	Subclasse	Externo
`public`	✅	✅	✅
`protected`	✅	✅	❌
`private`	✅	❌	❌
`readonly`	✅ leitura	✅ leitura	✅ leitura

`public` — padrão

class Tenant {
  public cnpj: string; // explícito
  razaoSocial: string; // implicitamente public

  constructor(cnpj: string, razaoSocial: string) {
    this.cnpj = cnpj;
    this.razaoSocial = razaoSocial;
  }
}

`private` — só dentro da classe

class Certificado {
  private senha: string;
  private pfxBase64: string;

  constructor(senha: string, pfxBase64: string) {
    this.senha = senha;
    this.pfxBase64 = pfxBase64;
  }

  assinar(xml: string): string {
    // ✅ acesso interno permitido
    return assinarComCertificado(xml, this.pfxBase64, this.senha);
  }
}

const cert = new Certificado("1234", "...");
cert.senha; // ❌ erro — private

`protected` — classe e subclasses

class TransmissorBase {
  protected url: string;

  constructor(url: string) {
    this.url = url;
  }

  protected logar(msg: string): void {
    console.log(`[${this.url}] ${msg}`);
  }
}

class TransmissorReinf extends TransmissorBase {
  transmitir(payload: unknown) {
    this.logar("transmitindo..."); // ✅ acesso em subclasse
    this.url // também acessível ✅
  }
}

const t = new TransmissorReinf("https://api.reinf.gov.br");
t.url;   // ❌ erro — protected não é acessível externamente

`readonly` — só leitura após construção

class Protocolo {
  readonly numero: string;
  readonly emitidoEm: Date;

  constructor(numero: string) {
    this.numero = numero;
    this.emitidoEm = new Date();
  }

  atualizar() {
    this.numero = "novo"; // ❌ erro — readonly
  }
}

Typescript: Parâmetros do Construtor

Yuri Peixinho — Sat, 13 Jun 2026 21:51:56 +0000

Introdução

O construtor é o método chamado quando você instancia uma classe. TypeScript permite tipar cada parâmetro e tem um atalho poderoso para declarar propriedades diretamente nele.

Construtor básico

class Evento {
  id: string;
  tipo: string;
  competencia: string;

  constructor(id: string, tipo: string, competencia: string) {
    this.id = id;
    this.tipo = tipo;
    this.competencia = competencia;
  }
}

O atalho do TypeScript

Ao adicionar um modificador de acesso no parâmetro, o TypeScript declara e atribui a propriedade automaticamente:

class Evento {
  constructor(
    public id: string,
    public tipo: string,
    private competencia: string,
    readonly criadoEm: Date = new Date()
  ) {}
  // TypeScript gera tudo automaticamente — sem repetição
}

const evento = new Evento("1", "R-2010", "2024-01");
evento.id;          // ✅
evento.competencia; // ❌ private

É o padrão mais usado na prática — elimina a repetição de declarar a propriedade e depois atribuir no this.

Parâmetros opcionais e com valor padrão

class Job {
  constructor(
    public tenantId: string,
    public tipo: string,
    public tentativas: number = 0,
    public agendadoPara?: Date
  ) {}
}

TypeScript: Interfaces

Yuri Peixinho — Sat, 13 Jun 2026 21:29:18 +0000

Introdução

As interfaces são uma das pedras fundamentais do Typescript. Elas descrevem formas que um objeto deve ter — um contrato que qualquer valor implemente aquela interface precisa respeitar.

Types vs Interfaces

Essa é a dúvida mais comum entre desenvolvedores TypeScript. As duas construções parecem fazer a mesma coisa na maioria dos casos, mas têm diferenças importantes.

A regra prática é:

Objetos públicos, contratos de classe → interface
Unions, primitivos, mapped types, composições → type

Ambas descrevem a forma de um objeto:

type Usuario = {
  id: number;
  nome: string;
};

interface Usuario {
  id: number;
  nome: string;
}

Na prática, para objetos simples, são intercambiáveis (trocado, substituído).

Diferença 1 — Declaration Merging

Interfaces podem ser declaradas múltiplas vezes e o TypeScript mescla automaticamente:

interface Configuracao {
  host: string;
}

interface Configuracao {
  porta: number;
}

// TypeScript mescla as duas:
// { host: string; porta: number }
const config: Configuracao = {
  host: "localhost",
  porta: 5432
};

Com type, isso gera erro:

type Configuracao = { host: string };
type Configuracao = { porta: number }; // ❌ identificador duplicado

Declaration merging é especialmente útil para estender libs externas sem modificar o código delas.

Diferença 2 — Tipos compostos

type consegue representar qualquer coisa, interface só representa objetos:

// só type consegue fazer isso:
type ID = string | number;
type Status = "ativo" | "inativo";
type Nullable<T> = T | null;
type Par<T> = [T, T];

Diferença 3 — Extends vs Intersecção

// interface usa extends
interface Animal { nome: string }
interface Cachorro extends Animal { raca: string }

// type usa &
type Animal = { nome: string }
type Cachorro = Animal & { raca: string }

Funcionalmente equivalentes, mas extends em interface gera mensagens de erro mais claras.

Declaração de Interfaces

Interface declaration é a sintaxe formal de declarar uma interface — mas vai além de propriedades simples. Interfaces suportam vários tipos de membros.

Propriedades

interface Produto {
  id: number;           // obrigatória
  descricao?: string;   // opcional
  readonly codigo: string; // somente leitura
}

readonly impede atribuição após a criação do objeto.

Métodos

interface Repositorio<T> {
  buscarPorId(id: string): Promise<T>;
  salvar(entidade: T): Promise<T>;
  deletar(id: string): Promise<void>;
  listar(): Promise<T[]>;
}

Call Signatures

interface Validador {
  (valor: string): boolean;
}

const validarCNPJ: Validador = (cnpj) => cnpj.length === 14;

Implementação em classes

interface Transmissor {
  transmitir(payload: unknown): Promise<Protocolo>;
  consultar(protocolo: string): Promise<Status>;
}

class TransmissorReinf implements Transmissor {
  async transmitir(payload: unknown): Promise<Protocolo> {
    // implementação
  }

  async consultar(protocolo: string): Promise<Status> {
    // implementação
  }
}

Se a classe não implementar algum método da interface, o TypeScript acusa erro em tempo de compilação.

Extendendo interfaces

Interfaces podem ser estendidas para criar hierarquias de contratos sem duplicar código.

Extends simples

interface EntidadeBase {
  id: string;
  criadoEm: Date;
  atualizadoEm: Date;
}

interface Tenant extends EntidadeBase {
  cnpj: string;
  razaoSocial: string;
}

interface Evento extends EntidadeBase {
  tipo: string;
  competencia: string;
}

Extends múltiplo

Uma interface pode estender várias ao mesmo tempo:

interface ComAuditoria {
  criadoPor: string;
  atualizadoPor: string;
}

interface ComSoftDelete {
  deletadoEm?: Date;
  ativo: boolean;
}

interface EntidadeCompleta extends ComAuditoria, ComSoftDelete {
  id: string;
}

// EntidadeCompleta tem tudo:
// id, criadoPor, atualizadoPor, deletadoEm, ativo

Sobrescrevendo propriedades

Você pode sobrescrever uma propriedade herdada, mas o novo tipo precisa ser compatível com o original:

interface Base {
  id: string | number;
}

interface Derivada extends Base {
  id: string; // ✅ string é subconjunto de string | number
}

interface Invalida extends Base {
  id: boolean; // ❌ boolean não é compatível com string | number
}

Caso prático — sistema fiscal

interface EntidadeBase {
  id: string;
  criadoEm: Date;
  atualizadoEm: Date;
  ativo: boolean;
}

interface EventoFiscal extends EntidadeBase {
  tenantId: string;
  competencia: string;
  status: "pendente" | "processando" | "concluido" | "erro";
}

interface EventoEFDReinf extends EventoFiscal {
  codigoEvento: string;
  cnpjContribuinte: string;
}

interface EventoEFinanceira extends EventoFiscal {
  rubrica: string;
  tipoMovimento: string;
}

Tipos Híbridos

Hybrid types são interfaces que descrevem um valor que é simultaneamente uma função e um objeto. Parece incomum, mas existe em várias libs JavaScript.

Hybrid types são raramente necessários em código novo — são mais úteis para tipar libs JavaScript existentes que foram escritas antes do TypeScript existir. Em código novo, prefira separar a função do objeto explicitamente.

Em JavaScript, funções são objetos — então uma função pode ter propriedades:

function contador() { ... }
contador.total = 0;        // função com propriedade
contador.resetar = () => { ... }; // função com método

Interfaces conseguem descrever exatamente isso.

interface Contador {
  (): number;           // call signature — é uma função
  total: number;        // propriedade
  resetar(): void;      // método
}

function criarContador(): Contador {
  let count = 0;

  const contador = function(): number {
    return ++count;
  } as Contador;

  contador.total = 0;
  contador.resetar = () => { count = 0; };

  return contador;
}

const c = criarContador();
c();          // chama como função → 1
c();          // → 2
c.total;      // acessa propriedade
c.resetar();  // chama método

Typescript: Escrevendo Funções e Function Overloading

Yuri Peixinho — Sat, 13 Jun 2026 18:04:19 +0000

Parâmetros

Parâmetros obrigatórios

Por padrão, todos os parâmetros são obrigatórios:

function saudar(nome: string, titulo: string): string {
  return `${titulo} ${nome}`;
}

saudar("Yuri");           // ❌ falta titulo
saudar("Yuri", "Dev");    // ✅

Parâmetros opcionais (`?`)

function saudar(nome: string, titulo?: string): string {
  return titulo ? `${titulo} ${nome}` : nome;
}

saudar("Yuri");           // ✅ "Yuri"
saudar("Yuri", "Dev");    // ✅ "Dev Yuri"

Valor padrão

function paginar(pagina: number, tamanho: number = 10): string {
  return `Página ${pagina}, ${tamanho} itens`;
}

paginar(1);      // ✅ tamanho = 10
paginar(1, 20);  // ✅ tamanho = 20

Diferente do opcional, valor padrão garante que o tipo dentro da função é sempre number — sem undefined.

Rest parameters

function logar(nivel: string, ...mensagens: string[]): void {
  mensagens.forEach(m => console.log(`[${nivel}] ${m}`));
}

logar("INFO", "iniciando", "conectando", "pronto"); // ✅

`void` — sem retorno

function logar(msg: string): void {
  console.log(msg);
  // não retorna nada
}

`never` — nunca termina

function falhar(msg: string): never {
  throw new Error(msg);
  // nunca chega ao fim normalmente
}

Útil no assertNever que vimos antes — o compilador sabe que aquele caminho é impossível.

Tipando funções

A ideia central é que funções são valores em JavaScript/TypeScript, e como qualquer valor, elas têm um tipo. Você pode nomear esse tipo e reutilizá-lo.

Sintaxe:

type NomeDoTipo = (parametro: TipoParametro) => TipoRetorno;

É basicamente uma arrow function, mas no nível do tipo — sem corpo, sem implementação.

// ❌ repetitivo — assinatura duplicada em todo lugar
function executar(fn: (valor: string) => boolean, input: string) { ... }
function validar(fn: (valor: string) => boolean, input: string) { ... }
function aplicar(fn: (valor: string) => boolean, input: string) { ... }

// ✅ com type alias — define uma vez, usa em todo lugar
type Validador = (valor: string) => boolean;

function executar(fn: Validador, input: string) { ... }
function validar(fn: Validador, input: string) { ... }
function aplicar(fn: Validador, input: string) { ... }

Function Overloading

Como tipar uma função que retorna tipos diferentes dependendo do input?

function buscar(valor: number | string): Usuario | Usuario[] {
  // ❌ impreciso — TypeScript não sabe qual retorno corresponde a qual input
}

A solução é a sobrecarga (overloading) de assinaturas.

// assinaturas — o que o chamador vê
function buscar(id: number): Usuario;
function buscar(email: string): Usuario[];

// implementação — o que executa de fato (não é visível externamente)
function buscar(valor: number | string): Usuario | Usuario[] {
  if (typeof valor === "number") {
    return buscarPorId(valor);
  }
  return buscarPorEmail(valor);
}

// TypeScript infere o retorno correto por input
const u1 = buscar(1);             // Usuario ✅
const u2 = buscar("yu@mail.com"); // Usuario[] ✅

Caso prático

function processar(evento: EventoEFinanceira): Promise<ResultadoEFinanceira>;
function processar(evento: EventoEFDReinf): Promise<ResultadoEFDReinf>;
function processar(
  evento: EventoEFinanceira | EventoEFDReinf
): Promise<ResultadoEFinanceira | ResultadoEFDReinf> {
  if (evento.tipo === "efinanceira") {
    return transmitirEFinanceira(evento);
  }
  return transmitirEFDReinf(evento);
}

// TypeScript infere o retorno exato ✅
const r1 = await processar(eventoFinanceira); // ResultadoEFinanceira
const r2 = await processar(eventoReinf);      // ResultadoEFDReinf

Typescript: Funções

Yuri Peixinho — Sat, 13 Jun 2026 18:03:45 +0000

Introdução

Antes de entender as tipagens nas funções, é importante entender o que o Typescript adiciona em cima do Javascript

Funções básicas em Javascript

Sem tipos, qualquer coisa é aceita. Os erros só aparecem em runtime (tempo de execução).

function somar(a, b) {
  return a + b;
}

somar(1, 2);      // 3
somar("a", "b");  // "ab" — JavaScript não reclama
somar(1);         // NaN — JavaScript não reclama

A mesma função em TypeScript

Os erros aparecem antes de rodar — em tempo de desenvolvimento.

function somar(a: number, b: number): number {
  return a + b;
}

somar(1, 2);      // ✅ 3
somar("a", "b");  // ❌ erro em compilação
somar(1);         // ❌ erro — falta o segundo argumento

O que o Typescript adiciona às funções

Três coisas principais:

1. Tipo dos parâmetros

function saudar(nome: string) { ... }
//                    ^^^^^^

2. Tipo do retorno

function saudar(nome: string): string { ... }
//                             ^^^^^^

3. Inferência automática

function somar(a: number, b: number) {
  return a + b;
  // TypeScript infere que o retorno é number
  // sem precisar declarar explicitamente
}

Funções são valores — e também têm tipo

Em JavaScript, funções são cidadãos de primeira classe — você pode passá-las como argumento, guardá-las em variáveis, retorná-las de outras funções. TypeScript tipa isso também:

// variável que guarda uma função
const dobrar: (x: number) => number = (x) => x * 2;

// função que recebe outra função como argumento
function executar(fn: (x: number) => number, valor: number) {
  return fn(valor);
}

executar(dobrar, 5); // 10 ✅

Três formas de declarar uma função

// 1. Function declaration
function somar(a: number, b: number): number {
  return a + b;
}

// 2. Function expression
const somar = function(a: number, b: number): number {
  return a + b;
};

// 3. Arrow function
const somar = (a: number, b: number): number => a + b;

O retorno pode ser omitido

TypeScript consegue inferir o tipo de retorno na maioria dos casos:

// declarando explicitamente
function somar(a: number, b: number): number {
  return a + b;
}

// deixando o TypeScript inferir — equivalente
function somar(a: number, b: number) {
  return a + b; // TypeScript infere: number
}

A recomendação geral é declarar o retorno explicitamente em funções públicas — fica mais legível e evita surpresas se a implementação mudar.

Typescript: Refinamento de Tipos (Type Guards / Narrowing)

Yuri Peixinho — Sat, 13 Jun 2026 18:01:51 +0000

Introdução

Type guards → provam o tipo explicitamente
Narrowing → é o processo mais amplo, que inclui type guards e outras formas de afunilar

Narrowing
├── Type Guards
│   ├── typeof
│   ├── instanceof
│   ├── in
│
├── Equality Narrowing
│   ├── === / !==
│   └── == / != (loose, menos comum)
│
└── Truthiness Narrowing
    ├── if (x)
    ├── x && ...
    └── !!x

Type Guards

Um type guard é qualquer expressão que, quando avaliada como true, garante ao TypeScript qual é o tipo dentro daquele bloco.

O problema que eles resolvem

type Resultado = { dados: string[] } | { mensagem: string };

function tratar(r: Resultado) {
  console.log(r.dados); // ❌ erro — TypeScript não sabe qual dos dois é
}

Você precisa provar ao compilador qual tipo está lidando. Type guards fazem isso.

Typeof

O typeof é um operador do próprio JavaScript, o TypeScript apenas o observa e usa o resultado para afunilar o tipo.

O typeof funciona para estruturas primitivas como: string, number, boolean, undefined, symbol, bigint

O que acontece no exemplo passo a passo

function formatar(valor: string | number) {
  // aqui: valor é  string | number

  if (typeof valor === "string") {
    // aqui: TypeScript SABE que é string
    // métodos de string disponíveis ✅
    return valor.toUpperCase();
  }

  // aqui: TypeScript ELIMINOU string da union
  // só sobrou number ✅
  return valor.toFixed(2);
}

Esse "sobrar" é o narrowing acontecendo. O TypeScript rastreia o fluxo e descarta o que foi provado impossível. Por isso o nome traduzido é “estreitamento”, os tipos das variáveis vão se estreitando a medida que o typescript vai elimitando os tipos.

O typeof não distingue objetos entre si:

type NFe  = { chaveAcesso: string };
type NFSe = { codigoVerificacao: string };

function processar(nota: NFe | NFSe) {
  if (typeof nota === "object") {
    // TS ainda não sabe se é NFe ou NFSe ❌
    // typeof não ajuda aqui
  }
}

Para objetos você precisa do in, instanceof, ou um user-defined guard — que são os outros type guards que veremos em seguida.

Instanceof

O instanceof verifica se um objeto foi criado por uma determinada classe — tecnicamente, se o prototype da classe aparece na cadeia de prototypes do objeto.

Sintaxe básica:

objeto instanceof Classe

Retorna true ou false, e o TypeScript usa isso para afunilar o tipo.

Exemplo simples

class ErroDeRede extends Error {
  statusCode: number;
  constructor(msg: string, code: number) {
    super(msg);
    this.statusCode = code;
  }
}

class ErroDeValidacao extends Error {
  campo: string;
  constructor(msg: string, campo: string) {
    super(msg);
    this.campo = campo;
  }
}

function tratar(err: Error) {
  if (err instanceof ErroDeRede) {
    console.log(err.statusCode); // ✅ TypeScript sabe que é ErroDeRede
  }

  if (err instanceof ErroDeValidacao) {
    console.log(err.campo); // ✅ TypeScript sabe que é ErroDeValidacao
  }
}

Passo a passo do Narrowing

function tratar(err: ErroDeRede | ErroDeValidacao) {
  // aqui: err é ErroDeRede | ErroDeValidacao

  if (err instanceof ErroDeRede) {
    // aqui: err é ErroDeRede ✅
    return;
  }

  // aqui: TypeScript eliminou ErroDeRede
  // só sobrou ErroDeValidacao ✅
  console.log(err.campo);
}

Só funciona com classes — não funciona com type ou interface:

type NFe = { chaveAcesso: string };

const nota = { chaveAcesso: "123" };

nota instanceof NFe // ❌ erro de compilação — NFe não é uma classe

Para objetos simples tipados com type ou interface, você usa in ou um user-defined guard com is.

IN

O in verifica se uma propriedade existe em um objeto. É o tipo guard ideal para distinguir entre tipos que são objetos literais (type ou interface), onde instanceof não funciona.

Sintaxe básica

"propriedade" in objeto

Retorna true se a propriedade existe no objeto ou em seu prototype.

Exemplo simples

type Sucesso = { dados: string[] };
type Erro    = { mensagem: string };

function tratar(r: Sucesso | Erro) {
  if ("dados" in r) {
    console.log(r.dados); // ✅ TypeScript sabe que é Sucesso
  } else {
    console.log(r.mensagem); // ✅ TypeScript sabe que é Erro
  }
}

Passo a passo do narrowing

function tratar(r: Sucesso | Erro) {
  // aqui: r é Sucesso | Erro

  if ("dados" in r) {
    // aqui: r é Sucesso ✅
    return;
  }

  // aqui: TypeScript eliminou Sucesso
  // só sobrou Erro ✅
  console.log(r.mensagem);
}

Narrowing

Narrowing é o processo pelo qual o TypeScript reduz um tipo amplo para um mais específico conforme analisa o fluxo do código. Ele não é uma feature isolada — é um comportamento contínuo do compilador.

Alguns desenvolvedores confudem O Type Guard com o Narrow. Podemos dizer que o Type Guard é uma ferramenta que dispara o narrowing

function processar(valor: string | number) {
  // aqui: string | number

  if (typeof valor === "string") {
    // aqui: string
  }

  // aqui: number
}

O TypeScript rastreia o que é possível em cada ponto do código e descarta o que foi provado impossível.

Todas as formas de narrowing juntas

Narrowing
├── typeof          → primitivos
├── instanceof      → classes
├── in              → objetos literais
├── User-defined    → lógica customizada (is)
├── Equality        → === / !== / == null
├── Truthiness      → if (x) / !!x
└── Exhaustiveness  → assertNever

, isCada uma é só uma ferramenta diferente para provar ao compilador qual tipo está presente.

O compilador acumula evidências

O narrowing é cumulativo, cada verificação elimina possibilidades:

function processar(valor: string | number | null | undefined) {
  if (valor == null) return;
  // eliminou null e undefined → string | number

  if (typeof valor === "string") return;
  // eliminou string → number

  // aqui: só number ✅
  console.log(valor.toFixed(2));
}

Equality

O TypeScript observa comparações de igualdade e usa o resultado para afunilar o tipo. Existem dois operadores: o estrito (=== / !==) e o loose (== / !=).

`===` estrito

Compara valor e tipo — o mais comum:

function processar(x: string | number) {
  if (x === "pendente") {
    // ✅ x é string — e especificamente "pendente"
    return x.toUpperCase();
  }
  // aqui: number
}

`!==` para exclusão

function processar(valor: string | null) {
  if (valor !== null) {
    // ✅ null foi eliminado — só string
    console.log(valor.toUpperCase());
  }
}

`==` loose — o único caso útil

Normalmente evitamos == em TypeScript, mas há um caso onde ele é genuinamente melhor: eliminar null e undefined ao mesmo tempo.

function processar(valor: string | null | undefined) {
  // === exigiria duas verificações:
  if (valor !== null && valor !== undefined) { ... }

  // == faz os dois de uma vez:
  if (valor != null) {
    // ✅ null e undefined eliminados — só string
    console.log(valor.toUpperCase());
  }
}

Isso funciona porque null == undefined é true em JavaScript — os dois se cancelam mutuamente com ==.

Truthiness

Truthiness narrowing acontece quando o TypeScript observa se um valor é truthy ou falsy dentro de uma condição e afunila o tipo com base nisso.

Valores falsy em JavaScript

Esses são os únicos valores que avaliam como false num if:

false
0
-0
0n        // bigint zero
""        // string vazia
null
undefined
NaN

Tudo o mais é truthy — incluindo [], {}, "false", -1.

Exemplo básico

function processar(valor: string | null) {
  if (valor) {
    // ✅ null foi eliminado — só string
    console.log(valor.toUpperCase());
  }
}

Type Predicates — guards customizados

Quando nenhum guard nativo basta, você cria o seu com a sintaxe param is Tipo. O TypeScript confia na sua implementação e estreita o tipo em todo lugar que a função for chamada.

// Sintaxe: retorno "param is Tipo" em vez de boolean
function isString(v: unknown): v is string {
  return typeof v === "string";
}

// Caso real: validar shape de objeto externo
type NotaFiscal = { chave: string; valor: number; cnpj: string };

function isNotaFiscal(obj: unknown): obj is NotaFiscal {
  return (
    typeof obj === "object" && obj !== null &&
    "chave" in obj && typeof (obj as any).chave === "string" &&
    "valor" in obj && typeof (obj as any).valor === "number" &&
    "cnpj"  in obj && typeof (obj as any).cnpj  === "string"
  );
}

// Uso — TypeScript estreita o tipo automaticamente
function processarPayload(raw: unknown) {
  if (!isNotaFiscal(raw)) throw new Error("Payload inválido");
  // ✅ raw é NotaFiscal aqui — .chave, .valor, .cnpj disponíveis
  console.log(raw.chave, raw.valor);
}

// Filtrando arrays com predicate (remove undefined do tipo)
const ids: (string | undefined)[] = ["a", undefined, "b"];
const validos: string[] = ids.filter(
  (x): x is string => x !== undefined
); // ✅ tipo inferido como string[]

No fundo, tudo que vimos — typeof, instanceof, in, is, equality, truthiness — são apenas formas diferentes de fornecer evidências para o compilador afunilar o tipo com segurança.

Typescript: Combinando Tipos (Combining Types)

Yuri Peixinho — Sat, 13 Jun 2026 16:20:01 +0000

Introdução

O TypeScript oferece várias formas de combinar tipos para criar estruturas mais expressivas e flexíveis. A seguir algumas dessas combinações:

Union Types
Intersection Types
Type Aliases
Keyof Operator

Union Types - `|`

Um valor pode ser um de vários tipos

type ID = string | number;

function buscarUsuario(id: ID) {
  // id pode ser string ou number
}

Intersection Types - `&`

Combina múltiplos tipos em um só — o valor precisa satisfazer todos. Use o operador &. Muito útil para mixins e composição de contratos.

type Pessoa   = { nome: string; cpf: string };
type Empresa   = { cnpj: string; razao: string };

// Só existe em contextos fiscais especiais 🇧🇷
type PessoaJuridica = Pessoa & Empresa;

const pj: PessoaJuridica = {
  nome:  "João Silva",
  cpf:   "000.000.000-00",
  cnpj:  "00.000.000/0001-00",
  razao: "Silva ME",
};

// Padrão mixin: adicionar propriedades opcionais
type WithTimestamps<T> = T & {
  createdAt: Date;
  updatedAt: Date;
};

type NotaFiscalAuditada = WithTimestamps<Empresa>;

Type Aliases

Type aliases são simplesmente apelidos para um tipo: você define um nome reutilizável para qualquer estrutura de tipo.

type Nome = string;
type Idade = number;
type Ativo = boolean;

`Keyof` Operator

O keyof extrai as chaves de um tipo como uma union de strings literais.

type NotaFiscal = {
  numero:    string;
  valor:     number;
  emissao:  Date;
  cancelada: boolean;
};

// keyof extrai as chaves
type CamposNF = keyof NotaFiscal;
// = "numero" | "valor" | "emissao" | "cancelada"

// Uso clássico: getter genérico type-safe
function getCampo<T, K extends keyof T>(
  obj: T,
  key: K
): T[K] {               // tipo inferido automaticamente!
  return obj[key];
}

const nf: NotaFiscal = { numero: "NF-001", valor: 1500, emissao: new Date(), cancelada: false };

getCampo(nf, "valor");     // ✅ retorna number
getCampo(nf, "numero");    // ✅ retorna string
getCampo(nf, "xpto");      // ❌ erro de compilação!

Por que isso é útil?

Sem keyof, você escreveria strings soltas e perderia type safety:

// ❌ Sem keyof — TypeScript não consegue validar
function pegar(obj: any, chave: string) {
  return obj[chave];
}

// ✅ Com keyof — totalmente tipado
function pegar<T>(obj: T, chave: keyof T): T[keyof T] {
  return obj[chave];
}

Typescript: Compatibilidade de Tipos (Type Compatibility)

Yuri Peixinho — Fri, 12 Jun 2026 02:13:12 +0000

Introdução

O TypeScript usa um conceito frequentemente apelidado de Duck Typing (Tipagem Pato). A regra de ouro é:

"Se um animal anda como um pato, nada como um pato e grasna como um pato, então, para todos os efeitos, ele é um pato."

No TypeScript, isso significa que o compilador não se importa com a "certidão de nascimento" (o nome) do objeto. Ele só se importa com o que o objeto tem por dentro (suas propriedades e métodos).

A tipagem estrutural existe no TypeScript porque o JavaScript (a linguagem base) é extremamente dinâmico. Essa abordagem permite que o TypeScript traga segurança para o código sem perder a flexibilidade natural do JavaScript de criar objetos dinamicamente.

Tipagem Nominal vs. Tipagem Estrutural

Para deixar isso bem claro, vamos ver como as coisas funcionam em outras linguagens versus como funcionam no TypeScript.

O mundo Nominal (Java, C#, C++)

Nestas linguagens, o nome do tipo é a lei.
Se você criar uma classe Cachorro e uma classe Gato, mesmo que ambas tenham apenas uma propriedade nome: string, um Cachorro nunca poderá ser aceito onde um Gato é esperado. Eles têm nomes diferentes, logo, são incompatíveis.

O mundo Estrutural (TypeScript)

No TypeScript, a estrutura é a lei.
Veja o exemplo abaixo:

interface Cachorro {
  nome: string;
}

interface Gato {
  nome: string;
}

let meuCachorro: Cachorro = { nome: "Rex" };
let meuGato: Gato;

// Isso funciona perfeitamente no TypeScript!
meuGato = meuCachorro;

Eles têm nomes diferentes (Cachorro e Gato), mas como ambos exigem apenas uma propriedade nome do tipo string, o TypeScript olha para eles e diz: "Eles têm a mesma estrutura, então são compatíveis".

A Regra do “Mínimo Necessário”

A compatibilidade estrutural não exige que os objetos sejam 100% idênticos. A regra real é: o objeto que está sendo atribuído deve ter pelo menos as propriedades exigidas. Ele pode ter propriedades a mais, mas nunca a menos.

interface Ponto2D {
  x: number;
  y: number;
}

interface Ponto3D {
  x: number;
  y: number;
  z: number;
}

let ponto3: Ponto3D = { x: 10, y: 20, z: 30 };

// Funciona! Ponto3D tem 'x' e 'y'. O TypeScript ignora o 'z' extra.
let ponto2: Ponto2D = ponto3; 

// ERRO! Ponto2D não tem a propriedade 'z', que é exigida pelo Ponto3D.
let outroPonto3: Ponto3D = ponto2;

O Cuidado com os Literais (O "Gotcha")

Há uma pequena exceção que costuma confundir quem está começando. Se você tentar atribuir um objeto "direto" (que chamamos de literal) com propriedades a mais, o TypeScript vai reclamar para te proteger de erros de digitação:

interface Usuario {
  nome: string;
}

// ERRO: O TypeScript é rigoroso com objetos criados diretamente na atribuição.
// Ele diz: "Você está tentando passar uma 'idade', mas Usuario não pede isso".
let user1: Usuario = { nome: "Ana", idade: 25 }; 

// FUNCIONA: Se o objeto já existe em outra variável, o TypeScript volta para 
// a regra estrutural padrão e aceita, ignorando a propriedade extra.
let info = { nome: "Ana", idade: 25 };
let user2: Usuario = info;

DEV Community: Yuri Peixinho

Typescritp: Sobrecarga de Construtor

Introdução

O problema

Solução — overload signatures

Typescript: Sobrecarga de Métodos

Introdução

Sem override

Com override — recomendado

Chamando o método da classe pai com super

Typescript: Herança e Polimorfismo

Herança

Polimorfismo

Typescript: Classes Abstratas

Introdução

Não podem ser instanciadas diretamente

Subclasses implementam os métodos abstratos

Typescript: Modificadores de Acesso

Introdução

public — padrão

private — só dentro da classe

protected — classe e subclasses

readonly — só leitura após construção

Typescript: Parâmetros do Construtor

Introdução

Construtor básico

O atalho do TypeScript

Parâmetros opcionais e com valor padrão

TypeScript: Interfaces

Introdução

Types vs Interfaces

Diferença 1 — Declaration Merging

Diferença 2 — Tipos compostos

Diferença 3 — Extends vs Intersecção

Declaração de Interfaces

Propriedades

Métodos

Call Signatures

Implementação em classes

Extendendo interfaces

Extends simples

Extends múltiplo

Sobrescrevendo propriedades

Caso prático — sistema fiscal

Tipos Híbridos

Typescript: Escrevendo Funções e Function Overloading

Parâmetros

Parâmetros obrigatórios

Parâmetros opcionais (?)

Valor padrão

Rest parameters

void — sem retorno

never — nunca termina

Tipando funções

Function Overloading

Caso prático

Typescript: Funções

Introdução

Funções básicas em Javascript

O que o Typescript adiciona às funções

Funções são valores — e também têm tipo

Três formas de declarar uma função

O retorno pode ser omitido

Typescript: Refinamento de Tipos (Type Guards / Narrowing)

Introdução

Type Guards

O problema que eles resolvem

Typeof

Instanceof

Exemplo simples

Passo a passo do Narrowing

IN

Exemplo simples

Passo a passo do narrowing

Narrowing

Equality

=== estrito

!== para exclusão

== loose — o único caso útil

Truthiness

Sem `override`

Com `override` — recomendado

Chamando o método da classe pai com `super`

`public` — padrão

`private` — só dentro da classe

`protected` — classe e subclasses

`readonly` — só leitura após construção

Parâmetros opcionais (`?`)

`void` — sem retorno

`never` — nunca termina

`===` estrito

`!==` para exclusão

`==` loose — o único caso útil

Union Types - `|`

Intersection Types - `&`

`Keyof` Operator