TypeScript Academy · Aula

Arrays Readonly e dados imutáveis

Use ReadonlyArray para evitar mutações acidentais.

Arrays Readonly e dados imutáveis é 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.

Boas-vindas

Vetores mutáveis podem ser modificados acidentalmente em qualquer parte do código. ReadonlyArray e o modificador readonly do TypeScript ajudam você a impor a imutabilidade.

O modificador readonly em vetores

Adicione o modificador `readonly` antes do tipo do vetor para impedir mutações. O vetor pode ser lido, mas não alterado.

const ids: readonly number[] = [1, 2, 3];
// ids.push(4);   // Error
// ids[0] = 99;   // Error
console.log(ids[0]); // OK — reading is fine

Forma genérica ReadonlyArray<T>

`ReadonlyArray` é o equivalente genérico de `readonly T[]`. Ambos impedem push, pop, splice e atribuições por índice.

const names: ReadonlyArray<string> = ['Alice', 'Bob'];
// names.push('Charlie'); // Error

Retornando vetores somente leitura de funções

Retorne vetores somente leitura de funções para indicar aos chamadores que o resultado não deve ser alterado.

function getConfig(): readonly string[] {
  return ['host', 'port', 'db'];
}

Parâmetros de funções imutáveis

Marque os parâmetros de vetores como readonly para impedir que a função altere o vetor do chamador.

function sum(nums: readonly number[]): number {
  return nums.reduce((a, b) => a + b, 0);
  // nums.push(99); // Error inside function
}

as const para vetores literais

A asserção `as const` torna um vetor somente leitura e infere um tipo tupla com tipos literais para os elementos, em vez de tipos ampliados.

const colors = ['red', 'green', 'blue'] as const;
// type: readonly ['red', 'green', 'blue']
// colors.push('yellow'); // Error

Readonly não congela profundamente

readonly impede apenas que a referência ao vetor seja alterada. Se os elementos forem objetos, suas propriedades ainda poderão ser modificadas.

const users: readonly { name: string }[] = [{ name: 'Alice' }];
// users.push({}); // Error
users[0].name = 'Bob'; // Allowed — object itself is mutable

Imutabilidade profunda com Readonly<T>

Para obter imutabilidade profunda em objetos, combine ReadonlyArray com Readonly nos elementos. Outra opção é usar uma biblioteca como immer.

type ImmutableUser = Readonly<{ name: string; scores: readonly number[] }>;
const u: ImmutableUser = { name: 'Alice', scores: [90, 85] };
// u.name = 'Bob';       // Error
// u.scores.push(100);  // Error

Atribuição entre mutável e somente leitura

Um vetor somente leitura NÃO pode ser atribuído a um tipo de vetor mutável. Isso protege contra a passagem acidental de um vetor imutável onde se espera uma mutação.

const ro: readonly number[] = [1, 2];
const mutable: number[] = ro; // Error!

Quando usar vetores somente leitura

Use vetores somente leitura para objetos de configuração, constantes, parâmetros de funções que você promete não alterar e valores retornados por funções puras.

A expansão cria um novo vetor mutável

Expandir um vetor somente leitura em um novo literal de vetor cria uma cópia mutável. Esse é um padrão simples para fazer alterações sem mutação.

const base: readonly number[] = [1, 2, 3];
const extended: number[] = [...base, 4]; // new mutable array

Verificação rápida

Qual operação NÃO é permitida em um `readonly number[]` no TypeScript?

Recapitulação

Use `readonly T[]` ou `ReadonlyArray` para impedir a mutação de vetores. Use `as const` para vetores literais constantes. A expansão cria uma cópia mutável quando você precisa ampliar um vetor somente leitura.

Perguntas Frequentes

A aula “Arrays Readonly e dados imutáveis” é grátis?

Sim — o texto completo de “Arrays Readonly e dados imutáveis” é 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 “Arrays Readonly e dados imutáveis”?

Use ReadonlyArray para evitar mutações acidentais. 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 “Arrays Readonly e dados imutáveis”?

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

Arrays tipados: T[] e Array
Arrays Readonly e dados imutáveis
Tuplas: arrays tipados de tamanho fixo
Enumerações: constantes numéricas e de texto

← Voltar para TypeScript Academy