Folha de Consulta Ruby
Última atualização
Hello World e executar código
Ruby não precisa de código repetitivo - uma única linha já roda.
| Operação | Sintaxe |
|---|---|
| Exibir com quebra de linha | puts "Hello, World!" |
| Exibir sem quebra de linha | print "Hello" |
| Inspecionar um valor | p [1, 2, 3] |
| Interpolação de string | puts "Hi #{name}" |
| Comentário | # this is a comment |
| Comentário de várias linhas | =begin ... =end |
| Executar um arquivo | ruby app.rb |
| Shell interativo | irb |
Variáveis e tipos
Ruby é tipado dinamicamente; tudo é um objeto.
| Operação | Sintaxe |
|---|---|
| Variável local | age = 30 |
| Constante | PI = 3.14 |
| Variável de instância | @name = "Ada" |
| Variável global | $count = 0 |
| Símbolo | :status |
| Nil / booleano | nil, true, false |
| Verificar tipo | 42.class retorna Integer |
| Converter tipo | "42".to_i, 42.to_s, "3.5".to_f |
Strings
Strings são objetos mutáveis com um rico conjunto de métodos.
| Operação | Sintaxe |
|---|---|
| Comprimento | "hello".length |
| Maiúsculas / minúsculas | s.upcase, s.downcase |
| Remover espaços em branco | s.strip |
| Substituir | s.gsub("a", "b") |
| Dividir em array | "a,b,c".split(",") |
| Inclui substring | s.include?("ell") |
| Fatiar caracteres | s[0..2] |
| Concatenar | "foo" + "bar", s << "!" |
| Repetir | "ab" * 3 |
| Formatar | format("%05d", 42) |
Arrays
Coleções ordenadas e indexadas por inteiros.
| Operação | Sintaxe |
|---|---|
| Criar | nums = [1, 2, 3] |
| Acessar por índice | nums[0], nums[-1] |
| Adicionar ao final | nums.push(4), nums << 4 |
| Remover do final | nums.pop |
| Comprimento | nums.length |
| Map | nums.map { |n| n * 2 } |
| Filtrar | nums.select { |n| n.even? } |
| Reduzir | nums.reduce(0) { |sum, n| sum + n } |
| Ordenar | nums.sort |
| Juntar em string | nums.join(", ") |
Hashes
Coleções chave-valor, geralmente com chaves de símbolos.
| Operação | Sintaxe |
|---|---|
| Criar | user = { name: "Ada", age: 30 } |
| Acessar valor | user[:name] |
| Definir valor | user[:email] = "a@x.com" |
| Verificar chave | user.key?(:name) |
| Excluir chave | user.delete(:age) |
| Chaves / valores | user.keys, user.values |
| Iterar | user.each { |k, v| puts "#{k}: #{v}" } |
| Valor padrão | Hash.new(0) |
| Mesclar | h1.merge(h2) |
Controle de fluxo
Condicionais e laços; note os modificadores no final da linha em Ruby.
| Operação | Sintaxe |
|---|---|
| If / elsif / else | if x > 0 ... elsif x < 0 ... else ... end |
| If em linha (modificador) | puts "hi" if ready |
| Unless | unless done ... end |
| Ternário | x > 0 ? "pos" : "neg" |
| Case / when | case n; when 1 then ...; else ...; end |
| Laço while | while i < 10 ... end |
| Laço until | until done ... end |
| Times | 5.times { |i| puts i } |
| Iteração de range | (1..5).each { |i| puts i } |
| Break / next | break, next |
Métodos
A última expressão é retornada implicitamente.
| Operação | Sintaxe |
|---|---|
| Definir um método | def add(a, b) ... end |
| Retorno implícito | def square(x) x * x end |
| Argumento padrão | def greet(name = "World") ... end |
| Argumentos nomeados | def box(w:, h:) ... end |
| Splat (variádico) | def sum(*nums) ... end |
| Método terminando em ? | def valid? ... end |
| Método terminando em ! | def normalize! ... end |
| Chamar sem parênteses | greet "Ada" |
Blocos, procs e lambdas
Blocos são trechos de código passados a métodos; procs e lambdas os armazenam.
| Operação | Sintaxe |
|---|---|
| Bloco (chaves) | [1, 2].each { |n| puts n } |
| Bloco (do/end) | [1, 2].each do |n| puts n end |
| Yield para um bloco | def run; yield; end |
| Verificar se há bloco | block_given? |
| Capturar bloco como parâmetro | def run(&blk); blk.call; end |
| Criar um proc | square = proc { |x| x * x } |
| Criar uma lambda | square = ->(x) { x * x } |
| Chamar um proc / lambda | square.call(3), square.(3) |
Classes e módulos
Classes guardam estado e comportamento; módulos incorporam métodos compartilhados.
| Operação | Sintaxe |
|---|---|
| Definir uma classe | class Point ... end |
| Construtor | def initialize(x, y) @x = x; @y = y; end |
| Método de instância | def dist ... end |
| Atalhos de acesso | attr_accessor :x, :y |
| Criar instância | p = Point.new(1, 2) |
| Herdar | class Circle < Shape ... end |
| Método de classe | def self.origin ... end |
| Definir um módulo | module Drawable ... end |
| Incorporar um módulo | include Drawable |
| Chamar super | super(args) |
A sintaxe de Ruby que você mais usa, em uma única página. Esta folha de consulta Ruby é uma referência rápida para o núcleo da linguagem - variáveis e tipos, strings, arrays e hashes, controle de fluxo, métodos, e os blocos, procs e lambdas que tornam Ruby tão expressivo.
Tudo aqui é Ruby puro e roda em qualquer interpretador padrão. Copie o que precisar ou teste cada trecho ao vivo no playground de Ruby - sem necessidade de instalação.
Perguntas frequentes sobre a folha de consulta Ruby
Esta folha de consulta Ruby é gratuita?
Sim. Esta folha de consulta Ruby é totalmente gratuita, sem necessidade de cadastro. Salve nos favoritos e volte sempre que precisar consultar um método de string, uma operação de hash ou a sintaxe de blocos.
Qual é a diferença entre um bloco, um proc e uma lambda?
Um bloco é um trecho de código anônimo passado a um método com
{ ... } ou do ... end - ele não é um objeto por conta própria. Um proc envolve um bloco em um objeto chamável que você pode armazenar e passar adiante. Uma lambda é um proc especial que verifica a contagem de argumentos de forma estrita e trata o return como um retorno da própria lambda, enquanto um proc comum retorna do método que o contém.O que são símbolos em Ruby?
Um símbolo como
:name é um identificador imutável e reutilizável. Como o mesmo símbolo sempre aponta para o mesmo objeto na memória, os símbolos são mais rápidos e mais eficientes em memória que as strings para coisas como chaves de hash e nomes de métodos - por isso você costuma ver hashes escritos como { name: "Ada" }.Posso praticar Ruby online?
Sim. Abra o playground de Ruby para executar qualquer trecho desta folha de consulta no seu navegador - sem instalação de Ruby. Quando quiser estrutura, o curso interativo e gratuito de Ruby da Coddy leva você passo a passo de variáveis e strings a blocos e classes.
Esta folha de consulta é boa para iniciantes?
Sim. Ela está organizada dos tópicos mais comuns (variáveis, strings, controle de fluxo) até os avançados (blocos, procs, classes), de modo que você pode usar as seções de cima já no primeiro dia e ir avançando para o resto.
Recursos relacionados
Mais folhas de consulta
