TypeScript Academy · Aula

ReadonlyArray e ReadonlyMap

Utilize tipos de coleções readonly integrados.

ReadonlyArray e ReadonlyMap é uma aula grátis de TypeScript Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de TypeScript Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de TypeScript Academy inclui 4 aulas no total.

Tipos de coleções somente leitura

Além das matrizes, o TypeScript oferece variantes somente leitura de suas coleções integradas: ReadonlyArray<T>, ReadonlyMap<K, V> e ReadonlySet<T>. Cada uma expõe apenas as partes da API que não fazem mutações.

const arr: ReadonlyArray<number> = [1, 2, 3];
console.log(arr.length, arr.includes(2));

Recapitulação de ReadonlyArray

ReadonlyArray<T> permite iteração, acesso por índice e métodos como map e filter, mas não push, pop nem atribuição a índices. É a forma de matriz da família somente leitura.

const tags: ReadonlyArray<string> = ['ts', 'js'];
console.log(tags.map((t) => t.toUpperCase()));
// tags.push('css'); // Error

ReadonlyMap

ReadonlyMap<K, V> permite consultar, percorrer e verificar chaves, mas remove set, delete e clear. Do ponto de vista de quem a utiliza, o conteúdo da matriz de associações é fixo.

const ages: ReadonlyMap<string, number> = new Map([['Ada', 30], ['Sam', 25]]);
console.log(ages.get('Ada'), ages.has('Sam'));
// ages.set('Lee', 40); // Error

Lendo de uma ReadonlyMap

Todas as operações de leitura permanecem: get, has, size, keys, values, entries e a iteração. Apenas os métodos que fazem mutações desaparecem.

const m: ReadonlyMap<string, number> = new Map([['a', 1], ['b', 2]]);
for (const [k, v] of m) {
  console.log(k, v);
}
console.log('size:', m.size);

ReadonlySet

ReadonlySet<T> permite verificar pertencimento e fazer iterações, mas remove add, delete e clear. Use-o para conjuntos fixos de valores permitidos.

const allowed: ReadonlySet<string> = new Set(['read', 'write']);
console.log(allowed.has('read'), allowed.has('delete'));
// allowed.add('admin'); // Error

Percorrendo um ReadonlySet

Você pode percorrer um ReadonlySet e ler seu size, mas não pode alterar seu conteúdo. Isso o torna ideal para listas de permissões e conjuntos de permissões.

const perms: ReadonlySet<string> = new Set(['view', 'edit']);
perms.forEach((p) => console.log('perm:', p));
console.log('count:', perms.size);

Passando tipos somente leitura para funções

Aceite um tipo de coleção somente leitura em funções que devem apenas ler. Isso comunica a intenção e impede que a função altere dados pertencentes ao chamador.

function describe(set: ReadonlySet<string>): string {
  return 'has ' + set.size + ' items';
}
const s = new Set(['x', 'y']);
console.log(describe(s));

Coleções mutáveis podem ser atribuídas

Um Map ou Set comum pode ser atribuído à sua contraparte somente leitura, porque você está restringindo capacidades, não ampliando-as. A função simplesmente abre mão dos direitos de mutação.

function keys(m: ReadonlyMap<string, number>): string[] {
  return Array.from(m.keys());
}
const real = new Map([['a', 1]]);
console.log(keys(real));

APIs de coleções imutáveis

Os tipos de coleções somente leitura descrevem uma visão imutável. O objeto subjacente ainda pode ser mutável em outro lugar; o tipo somente leitura apenas restringe o que esta referência pode fazer.

const backing = new Set<number>([1, 2]);
const view: ReadonlySet<number> = backing;
// view.add(3); // Error through the readonly view
backing.add(3); // but the original can still mutate
console.log(view.size);

Escolhendo o tipo somente leitura correto

Combine o tipo somente leitura com sua estrutura de dados: ReadonlyArray para listas ordenadas, ReadonlyMap para consultas de chave e valor e ReadonlySet para pertencimento exclusivo. Cada um impõe imutabilidade à sua estrutura.

const roles: ReadonlySet<string> = new Set(['admin', 'user']);
const limits: ReadonlyMap<string, number> = new Map([['admin', 100]]);
console.log(roles.has('user'), limits.get('admin'));

Estado compartilhado mais seguro

Expor coleções internas como tipos somente leitura impede que os chamadores corrompam o estado do seu módulo. Eles podem inspecionar os dados livremente, mas apenas o seu código pode alterá-los.

class Registry {
  private items = new Set<string>();
  add(name: string): void { this.items.add(name); }
  get all(): ReadonlySet<string> { return this.items; }
}
const r = new Registry();
r.add('a');
console.log(r.all.has('a'));

Verificação rápida

Teste seu entendimento sobre os tipos de coleções somente leitura.

Recapitulação: coleções somente leitura

Você aprendeu sobre a família de coleções somente leitura:

ReadonlyArray<T>, ReadonlyMap<K, V> e ReadonlySet<T> expõem apenas operações de leitura.
Métodos que fazem mutações (set, add, delete, push) são removidos.
Coleções mutáveis podem ser atribuídas às suas contrapartes somente leitura.
Elas são excelentes tipos de parâmetros e retornos para um estado compartilhado mais seguro.

Por fim, padrões de imutabilidade profunda.

function count(s: ReadonlySet<number>): number {
  return s.size;
}
console.log(count(new Set([1, 2, 3])));

Perguntas Frequentes

A aula “ReadonlyArray e ReadonlyMap” é grátis?

Sim — o texto completo de “ReadonlyArray e ReadonlyMap” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de TypeScript Academy, atualize para CoddyKit PRO. O curso de TypeScript Academy inclui 4 aulas no total.

O que vou aprender em “ReadonlyArray e ReadonlyMap”?

Utilize tipos de coleções readonly integrados. Você pratica TypeScript Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar TypeScript Academy?

Nenhuma experiência prévia é necessária. TypeScript Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “ReadonlyArray e ReadonlyMap”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de TypeScript Academy?

Sim. Cada aula de TypeScript Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para TypeScript Academy