TypeScript Academy · Aula

Propriedades readonly

Marque as propriedades de objetos como imutáveis após a inicialização.

Propriedades readonly é uma aula grátis de TypeScript Academy no CoddyKit. Esta é a aula 1 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.

O modificador somente leitura

O modificador readonly marca uma propriedade que pode ser definida uma vez, mas nunca receber uma nova atribuição depois. Ele expressa imutabilidade no nível do tipo, ajudando a evitar alterações acidentais.

interface Point {
  readonly x: number;
  readonly y: number;
}
const p: Point = { x: 1, y: 2 };
console.log(p.x, p.y);
// p.x = 5; // Error: cannot assign to readonly property

Somente leitura em interfaces

Em uma interface, readonly documenta quais campos permanecem fixos após a criação. Os consumidores podem lê-los livremente, mas o compilador bloqueia qualquer nova atribuição.

interface Config {
  readonly env: string;
  retries: number; // mutable
}
const c: Config = { env: 'prod', retries: 3 };
c.retries = 5; // allowed
console.log(c.env, c.retries);

Erro de compilação ao reatribuir

Tentar escrever em uma propriedade readonly causa um erro em tempo de compilação. Isso detecta toda uma categoria de erros em que o state compartilhado é alterado inesperadamente.

interface User {
  readonly id: number;
  name: string;
}
const u: User = { id: 1, name: 'Ada' };
u.name = 'Grace'; // ok
// u.id = 2; // Error
console.log(u);

Somente leitura em propriedades de classes

As classes também aceitam readonly. Um campo somente leitura pode ser inicializado na declaração ou dentro do construtor, mas em nenhum outro lugar.

class Circle {
  readonly radius: number;
  constructor(r: number) {
    this.radius = r; // allowed in constructor
  }
}
const c = new Circle(5);
console.log(c.radius);

Definir uma vez no construtor

O construtor é o único lugar fora da declaração onde você pode atribuir um campo somente leitura. Depois da construção, o valor fica bloqueado durante todo o tempo de vida do objeto.

class Account {
  readonly owner: string;
  constructor(owner: string) {
    this.owner = owner;
  }
  rename() {
    // this.owner = 'x'; // Error: readonly outside constructor
  }
}
console.log(new Account('Sam').owner);

Propriedades de parâmetros somente leitura

As propriedades de parâmetros do TypeScript permitem declarar e inicializar um campo somente leitura diretamente na assinatura do construtor, reduzindo o código repetitivo.

class Vector {
  constructor(
    readonly x: number,
    readonly y: number
  ) {}
}
const v = new Vector(3, 4);
console.log(v.x, v.y);

Somente leitura apenas em tempo de compilação

Fundamentalmente, readonly existe apenas no sistema de tipos. Ele é removido em tempo de execução — o JavaScript não tem esse conceito. Ele impede novas atribuições no seu código TypeScript, mas não na saída compilada acessada por caminhos sem tipagem.

interface Box { readonly value: number; }
const b: Box = { value: 10 };
// At runtime b is a plain object; readonly is not enforced by JS.
console.log(b.value);

Somente leitura vs constante

Não as confunda. const impede que uma variável receba uma nova atribuição. readonly impede que uma propriedade receba uma nova atribuição. Um objeto declarado com const ainda pode ter propriedades mutáveis, a menos que elas sejam readonly.

const obj = { count: 0 }; // const binding
obj.count = 5; // allowed: property is mutable
console.log(obj.count);

Superficial por natureza

readonly é superficial: ele protege a própria propriedade, não o conteúdo do objeto ou vetor para o qual ela aponta. Uma referência somente leitura a um objeto ainda permite alterar os campos desse objeto.

interface Holder { readonly data: { n: number }; }
const h: Holder = { data: { n: 1 } };
// h.data = {...}; // Error
h.data.n = 99; // allowed: inner field is not readonly
console.log(h.data.n);

Usando somente leitura para APIs mais seguras

Marcar como readonly os campos dos objetos retornados indica que os chamadores não devem alterá-los. Isso registra a intenção no tipo, fazendo com que o uso incorreto seja um erro de compilação em vez de um erro silencioso.

interface Snapshot { readonly takenAt: number; readonly size: number; }
function snapshot(): Snapshot {
  return { takenAt: Date.now(), size: 1024 };
}
const s = snapshot();
console.log(s.size);

Somente leitura em assinaturas de índice

Você pode até tornar as assinaturas de índice somente leitura, produzindo um tipo semelhante a um mapa cujas entradas podem ser lidas, mas não receber novas atribuições por meio do índice.

interface Scores {
  readonly [name: string]: number;
}
const scores: Scores = { ada: 95, sam: 88 };
console.log(scores.ada);
// scores.ada = 100; // Error

Verificação rápida

Teste sua compreensão das propriedades somente leitura.

Recapitulação: propriedades somente leitura

Você aprendeu que readonly:

Permite definir uma propriedade uma vez e depois bloqueia novas atribuições.
Pode ser definido na declaração ou no construtor para campos de classes.
Existe apenas em tempo de compilação e é superficial — não congela profundamente os dados aninhados.
Difere de const: um protege propriedades, enquanto o outro protege vinculações de variáveis.

A seguir, vetores e tuplas somente leitura.

interface Meta { readonly id: number; }
const m: Meta = { id: 42 };
console.log(m.id);

Perguntas Frequentes

A aula “Propriedades readonly” é grátis?

Sim — o texto completo de “Propriedades 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 “Propriedades readonly”?

Marque as propriedades de objetos como imutáveis após a inicializaçã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 1 de 4.

Quanto tempo leva a aula “Propriedades 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