0Pricing
Ruby Academy · Aula

Otimização de memória

Reduza alocações.

Otimização de memória é uma aula grátis de Ruby 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 Ruby Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Ruby Academy inclui 4 aulas no total.

Por que a Memória Importa

Cada objeto que Ruby cria consome memória e aumenta o trabalho da coleta de lixo. Menos alocações resultam em programas mais rápidos e enxutos.

  • O GC faz pausas para recuperar objetos
  • Taxas altas de alocação acionam mais execuções do GC
  • Reduzir as alocações costuma trazer o maior ganho
before = GC.stat(:total_allocated_objects)
100.times { 'new string' + '!' }
after = GC.stat(:total_allocated_objects)
puts "Allocated: #{after - before} objects"

Contando Alocações

GC.stat disponibiliza contadores de alocação cuja diferença você pode calcular antes e depois de um bloco.

  • :total_allocated_objects cresce continuamente
  • Calcule a diferença antes e depois para medir uma seção
def allocations
  before = GC.stat(:total_allocated_objects)
  yield
  GC.stat(:total_allocated_objects) - before
end

puts allocations { Array.new(1000) { |i| i.to_s } }

Literais de texto imutáveis

Cada literal de texto repetido aloca um novo objeto. Congelá-los permite que Ruby reutilize uma única instância imutável.

  • Adicione o comentário mágico no início de um arquivo
  • Ou chame .freeze em literais individuais
# frozen_string_literal: true

s1 = 'hello'
s2 = 'hello'
puts s1.equal?(s2)

Evite alocações em laços

Criar objetos dentro de laços intensivos multiplica as alocações. Mova as constantes para fora.

  • Crie expressões regulares, vetores e textos uma única vez
  • Reutilize-os entre as iterações
PATTERN = /\d+/

def count_numbers(lines)
  lines.count { |line| line.match?(PATTERN) }
end

puts count_numbers(['a1', 'bb', 'c3'])

Métodos mutadores (com !)

Métodos sem ! retornam novos objetos; métodos mutadores alteram o objeto no próprio lugar, economizando alocações.

  • map!, gsub!, sort!
  • Use-os somente quando for seguro alterar o original
arr = [3, 1, 2]
arr.sort!
puts arr.inspect

s = 'hello world'
s.upcase!
puts s

Símbolos versus textos como chaves

Símbolos são internados: o mesmo símbolo é um único objeto compartilhado. Use-os como chaves de tabelas de dispersão.

  • Chaves de texto alocam um novo texto a cada vez
  • Símbolos economizam memória em consultas repetidas
puts :name.equal?(:name)
puts 'name'.equal?('name')

Enumeradores preguiçosos

Encadear map e select cria vetores intermediários. lazy processa os elementos um por vez.

  • Nenhuma coleção intermediária é alocada
  • Ideais para sequências grandes ou infinitas
result = (1..Float::INFINITY).lazy
  .select { |n| n.even? }
  .map { |n| n * n }
  .first(5)
puts result.inspect

Transmita em vez de carregar

Ler um arquivo inteiro para a memória é desperdício. Transmita linha por linha.

  • each_line processa uma linha por vez
  • Memória constante independentemente do tamanho do arquivo
text = "line1\nline2\nline3"
text.each_line do |line|
  puts line.strip.upcase
end

Concatenação de textos

Construir textos com + em um laço aloca um novo texto a cada vez. Use << para anexar no próprio lugar.

  • + cria um objeto novo
  • << altera a área de armazenamento existente
buffer = String.new
5.times { |i| buffer << "item#{i} " }
puts buffer

Agrupamento e reutilização de objetos

Reutilize objetos custosos em vez de recriá-los.

  • Armazene configurações analisadas ou expressões regulares compiladas
  • Use uma constante ou um valor memorizado
def config
  @config ||= { host: 'localhost', port: 4567 }
end

puts config.equal?(config)

Acionando o coletor de lixo para obter informações

Você pode inspecionar o comportamento do coletor de lixo para confirmar melhorias.

  • GC.stat(:count) mostra quantas execuções do coletor de lixo ocorreram
  • Menos execuções após a otimização são um bom sinal
start = GC.stat(:count)
50_000.times { |i| [i] }
puts "GC runs: #{GC.stat(:count) - start}"

Verificação rápida

Teste seus conhecimentos sobre otimização de memória.

Recapitulação

Você aprendeu a otimizar a memória:

  • Conte as alocações com GC.stat
  • Congele literais de texto e reutilize objetos
  • Prefira métodos com ! e << para evitar novos objetos
  • Use símbolos para chaves e enumeradores preguiçosos para fluxos de processamento
  • Transmita dados grandes em vez de carregá-los por completo

Em seguida, você enfrentará gargalos comuns de desempenho.

Perguntas Frequentes

A aula “Otimização de memória” é grátis?

Sim — o texto completo de “Otimização de memória” é 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 Ruby Academy, atualize para CoddyKit PRO. O curso de Ruby Academy inclui 4 aulas no total.

O que vou aprender em “Otimização de memória”?

Reduza alocações. Você pratica Ruby 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 Ruby Academy?

Nenhuma experiência prévia é necessária. Ruby 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 “Otimização de memória”?

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

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

  1. Medindo o desempenho
  2. Ferramentas de criação de perfis
  3. Otimização de memória
  4. Gargalos comuns
← Voltar para Ruby Academy