TypeScript Academy · Aula

Matrizes e Tuplas readonly

Proteja matrizes e tuplas contra métodos de mutação.

Matrizes e Tuplas readonly é uma aula grátis de TypeScript Academy no CoddyKit. Esta é a aula 2 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.

Vetores somente leitura

Um vetor somente leitura é um vetor que você pode ler, mas não modificar. Escreva-o como readonly number[] ou, de forma equivalente, como ReadonlyArray<number>. O tipo dos elementos permanece o mesmo; apenas a alteração é bloqueada.

const nums: readonly number[] = [1, 2, 3];
console.log(nums[0], nums.length);
// nums[0] = 9; // Error: index signature is readonly

O tipo ReadonlyArray

ReadonlyArray<T> é a forma genérica, com significado idêntico a readonly T[]. Use a forma que ficar mais clara; elas são intercambiáveis.

const names: ReadonlyArray<string> = ['Ada', 'Sam'];
console.log(names.join(', '));

Métodos que modificam dados não estão disponíveis

Os vetores somente leitura não incluem métodos que modificam dados. push, pop, splice, sort e reverse não estão disponíveis — o tipo literalmente não os possui.

const items: readonly string[] = ['a', 'b'];
// items.push('c'); // Error: push does not exist
// items.splice(0, 1); // Error
console.log(items.length);

Métodos que não modificam continuam funcionando

Os métodos que retornam um novo valor em vez de modificar o original — map, filter, concat e slice — continuam disponíveis. Eles produzem novos vetores, deixando o original intacto.

const nums: readonly number[] = [1, 2, 3];
const doubled = nums.map((n) => n * 2);
console.log(doubled); // new array, nums unchanged

Vetores somente leitura como parâmetros

Aceitar readonly T[] em uma função indica que você não modificará o vetor do chamador. Isso documenta a intenção e permite que o compilador imponha essa promessa.

function sum(values: readonly number[]): number {
  return values.reduce((a, b) => a + b, 0);
}
console.log(sum([10, 20, 30]));

Vetores mutáveis podem ser atribuídos a somente leitura

Um number[] comum pode ser atribuído a um parâmetro readonly number[] — você está apenas prometendo não modificá-lo. O inverso não é permitido.

function total(v: readonly number[]): number {
  return v.reduce((a, b) => a + b, 0);
}
const mutable: number[] = [1, 2, 3];
console.log(total(mutable)); // ok

Tuplas somente leitura

As tuplas também podem ser somente leitura: readonly [string, number]. Os tipos e a ordem dos elementos são fixos, e as posições individuais não podem receber novas atribuições.

const pair: readonly [string, number] = ['age', 30];
console.log(pair[0], pair[1]);
// pair[1] = 31; // Error: readonly tuple

Tuplas somente leitura bloqueiam alterações

Assim como os vetores somente leitura, as tuplas somente leitura removem métodos que modificam dados e rejeitam atribuições por índice. Elas são perfeitas para registros de formato fixo, como pares de coordenadas.

const point: readonly [number, number] = [3, 4];
// point.push(5); // Error
// point[0] = 0; // Error
console.log(point[0] + point[1]);

Asserção de constante vs tipo somente leitura

As duas formas de obter vetores somente leitura diferem sutilmente. Uma anotação readonly number[] mantém o tipo geral dos elementos. as const vai além: cria uma tupla somente leitura de tipos literais.

const a: readonly number[] = [1, 2, 3]; // elements: number
const b = [1, 2, 3] as const;            // readonly [1, 2, 3]
console.log(a[0], b[0]);

Escolhendo entre as duas formas

Use uma anotação readonly T[] quando quiser imutabilidade, mas tipos gerais de elementos. Use as const quando também precisar dos valores literais exatos, por exemplo, para derivar uma união.

const DAYS = ['Mon', 'Tue', 'Wed'] as const;
type Day = typeof DAYS[number]; // 'Mon' | 'Tue' | 'Wed'
const d: Day = 'Tue';
console.log(d);

Imutabilidade para dados compartilhados

Vetores e tuplas somente leitura protegem constantes compartilhadas e listas de configuração contra alterações acidentais, tornando impossíveis, em tempo de compilação, os erros causados por modificações inesperadas.

const ALLOWED_PORTS: readonly number[] = [80, 443, 8080];
function isAllowed(p: number): boolean {
  return ALLOWED_PORTS.includes(p);
}
console.log(isAllowed(443), isAllowed(22));

Verificação rápida

Teste sua compreensão dos vetores e das tuplas somente leitura.

Recapitulação: vetores e tuplas somente leitura

Você aprendeu que:

readonly T[] / ReadonlyArray<T> bloqueia alterações, mas permite leitura e métodos que não modificam dados.
Métodos que modificam dados, como push/splice, são removidos do tipo.
As tuplas somente leitura fixam tanto o comprimento quanto os tipos dos elementos.
as const vai além, produzindo tuplas somente leitura de tipos literais.

A seguir, os tipos de coleções somente leitura.

const config: readonly string[] = ['a', 'b'];
const upper = config.map((s) => s.toUpperCase());
console.log(upper);

Perguntas Frequentes

A aula “Matrizes e Tuplas readonly” é grátis?

Sim — o texto completo de “Matrizes e Tuplas readonly” é 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 “Matrizes e Tuplas readonly”?

Proteja matrizes e tuplas contra métodos de mutação. 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 2 de 4.

Quanto tempo leva a aula “Matrizes e Tuplas readonly”?

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