JavaScript Academy · Aula

Symbols conhecidos

Personalize o comportamento com Symbol.iterator e outros.

Symbols conhecidos é uma aula grátis de JavaScript Academy no CoddyKit. Esta é a aula 4 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 JavaScript Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de JavaScript Academy inclui 4 aulas no total.

Símbolos conhecidos

Símbolos conhecidos são símbolos integrados armazenados no objeto Symbol. Eles permitem personalizar o comportamento dos objetos com recursos da linguagem, como iteração e conversão.

console.log(typeof Symbol.iterator)
console.log(typeof Symbol.toPrimitive)

Symbol.iterator

Symbol.iterator define como um objeto é percorrido por um laço for-of e pelo operador de espalhamento. Matrizes e textos integrados já o fornecem.

const arr = [10, 20]
const it = arr[Symbol.iterator]()
console.log(it.next().value)

Tornando um objeto iterável

Você adiciona um método Symbol.iterator que retorna um iterador com um método next para tornar qualquer objeto utilizável em um laço for-of.

const range = {
  from: 1,
  to: 3,
  [Symbol.iterator]() {
    let cur = this.from
    const last = this.to
    return {
      next() {
        return cur <= last ? { value: cur++, done: false } : { value: undefined, done: true }
      }
    }
  }
}
for (const n of range) {
  console.log(n)
}

Iterando com espalhamento

Como Symbol.iterator também controla o espalhamento, um iterável personalizado pode ser expandido em uma matriz.

const nums = {
  [Symbol.iterator]() {
    let i = 0
    return { next() { return i < 3 ? { value: i++, done: false } : { value: undefined, done: true } } }
  }
}
console.log([...nums])

Symbol.toPrimitive

Symbol.toPrimitive permite que um objeto controle como ele é convertido em um valor primitivo em contextos numéricos, textuais ou padrão.

const money = {
  amount: 50,
  [Symbol.toPrimitive](hint) {
    if (hint === "number") return this.amount
    return "$" + this.amount
  }
}
console.log(+money)
console.log(money + "")

O argumento de indicação

O manipulador de conversão recebe uma indicação de número, texto ou padrão, permitindo retornar um valor adequado para cada situação.

const obj = {
  [Symbol.toPrimitive](hint) {
    return hint
  }
}
console.log(+obj)
console.log(obj + "")
console.log(String(obj))

Symbol.toStringTag

Symbol.toStringTag personaliza o texto que o toString padrão informa para um objeto, o que é útil para rótulos de tipos personalizados.

const widget = {
  [Symbol.toStringTag]: "Widget"
}
console.log(Object.prototype.toString.call(widget))

Symbol.hasInstance

Symbol.hasInstance permite que uma classe ou um objeto personalize o comportamento do operador instanceof.

class Even {
  static [Symbol.hasInstance](num) {
    return num % 2 === 0
  }
}
console.log(4 instanceof Even)
console.log(3 instanceof Even)

Os recursos integrados também os usam

Matrizes, mapas, conjuntos e textos implementam Symbol.iterator, por isso funcionam perfeitamente com for-of e espalhamento.

const set = new Set([1, 2, 3])
console.log([...set])

Por que eles são importantes

Os símbolos conhecidos são pontos de extensão: eles permitem que seus objetos se integrem naturalmente às operações integradas da linguagem, em vez de exigirem tratamento especial.

const list = {
  items: ["a", "b"],
  [Symbol.iterator]() {
    return this.items[Symbol.iterator]()
  }
}
for (const x of list) {
  console.log(x)
}

Descobrindo-os

O objeto Symbol expõe esses símbolos como propriedades estáticas. Você pode referenciá-los como Symbol.iterator e Symbol.toPrimitive sempre que necessário.

console.log(typeof Symbol.iterator)
console.log(typeof Symbol.toStringTag)
console.log(typeof Symbol.hasInstance)

Verificação rápida

Teste seus conhecimentos sobre símbolos conhecidos.

Recapitulação

Recapitulação: Os símbolos conhecidos personalizam o comportamento da linguagem.

Symbol.iterator controla for-of e o espalhamento
Symbol.toPrimitive controla conversões por meio de uma indicação
Symbol.toStringTag rotula objetos
Symbol.hasInstance personaliza instanceof

const r = { [Symbol.iterator]() { let i = 0; return { next() { return i < 2 ? { value: i++, done: false } : { value: 0, done: true } } } } }
console.log([...r])

Perguntas Frequentes

A aula “Symbols conhecidos” é grátis?

Sim — o texto completo de “Symbols conhecidos” é 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 JavaScript Academy, atualize para CoddyKit PRO. O curso de JavaScript Academy inclui 4 aulas no total.

O que vou aprender em “Symbols conhecidos”?

Personalize o comportamento com Symbol.iterator e outros. Você pratica JavaScript 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 JavaScript Academy?

Nenhuma experiência prévia é necessária. JavaScript 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 4 de 4.

Quanto tempo leva a aula “Symbols conhecidos”?

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 JavaScript Academy?

Sim. Cada aula de JavaScript 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 JavaScript Academy