Continuando o meme "Recursos ocultos de ...", vamos compartilhar os recursos menos conhecidos, mas úteis, da linguagem de programação Ruby.

Tente limitar essa discussão com o Ruby principal, sem nenhum material do Ruby on Rails.

Veja também:

• Recursos ocultos do C #
• Recursos ocultos do Java
• Recursos ocultos do JavaScript
• Recursos ocultos do Ruby on Rails
• Recursos ocultos do Python

(Por favor, apenas um recurso oculto por resposta.)

Obrigado

No Ruby 1.9, Proc # === é um apelido para a chamada Proc #, o que significa que os objetos Proc podem ser usados ​​em instruções de caso como:

def multiple_of(factor)
  Proc.new{|product| product.modulo(factor).zero?}
end

case number
  when multiple_of(3)
    puts "Multiple of 3"
  when multiple_of(7)
    puts "Multiple of 7"
end

Peter Cooper tem uma boa lista de truques de Ruby. Talvez o meu favorito dele seja permitir que itens e coleções individuais sejam enumerados. (Ou seja, trate um objeto que não é de coleção como uma coleção que contém apenas esse objeto.) Parece com isso:

[*items].each do |item|
  # ...
end

Não sei o quanto isso está oculto, mas achei útil ao precisar criar um Hash a partir de uma matriz unidimensional:

fruit = ["apple","red","banana","yellow"]
=> ["apple", "red", "banana", "yellow"]

Hash[*fruit]    
=> {"apple"=>"red", "banana"=>"yellow"}

Um truque que eu gosto é usar o *expansor splat ( ) em objetos que não sejam Arrays. Aqui está um exemplo de uma correspondência de expressão regular:

match, text, number = *"Something 981".match(/([A-z]*) ([0-9]*)/)

Outros exemplos incluem:

a, b, c = *('A'..'Z')

Job = Struct.new(:name, :occupation)
tom = Job.new("Tom", "Developer")
name, occupation = *tom

Uau, ninguém mencionou o operador flip-flop:

1.upto(100) do |i|
  puts i if (i == 3)..(i == 15)
end

Uma das coisas legais sobre o ruby ​​é que você pode chamar métodos e executar código em locais que outras linguagens desaprovariam, como nas definições de método ou classe.

Por exemplo, para criar uma classe que tenha uma superclasse desconhecida até o tempo de execução, ou seja, seja aleatória, você pode fazer o seguinte:

class RandomSubclass < [Array, Hash, String, Fixnum, Float, TrueClass].sample

end

RandomSubclass.superclass # could output one of 6 different classes.

Isso usa o Array#samplemétodo 1.9 (somente na versão 1.8.7, veja Array#choice), e o exemplo é bastante artificial, mas você pode ver o poder aqui.

Outro exemplo interessante é a capacidade de colocar valores de parâmetro padrão que não são fixos (como outros idiomas costumam exigir):

def do_something_at(something, at = Time.now)
   # ...
end

Obviamente, o problema com o primeiro exemplo é que ele é avaliado no momento da definição, não no tempo de chamada. Assim, uma vez escolhida uma superclasse, ela permanece nessa superclasse pelo restante do programa.

No entanto, no segundo exemplo, toda vez que você chamar do_something_at, a atvariável será a hora em que o método foi chamado (bem, muito, muito próximo a ele)

Outro pequeno recurso - converta um Fixnumem qualquer base até 36:

>> 1234567890.to_s(2)
=> "1001001100101100000001011010010"

>> 1234567890.to_s(8)
=> "11145401322"

>> 1234567890.to_s(16)
=> "499602d2"

>> 1234567890.to_s(24)
=> "6b1230i"

>> 1234567890.to_s(36)
=> "kf12oi"

E, como Huw Walters comentou, converter para o outro lado é igualmente simples:

>> "kf12oi".to_i(36)
=> 1234567890

Hashes com valores padrão! Uma matriz neste caso.

parties = Hash.new {|hash, key| hash[key] = [] }
parties["Summer party"]
# => []

parties["Summer party"] << "Joe"
parties["Other party"] << "Jane"

Muito útil em metaprogramação.

Faça o download da fonte e do problema do Ruby 1.9, e make golfvocê poderá fazer coisas como estas:

make golf

./goruby -e 'h'
# => Hello, world!

./goruby -e 'p St'
# => StandardError

./goruby -e 'p 1.tf'
# => 1.0

./goruby19 -e 'p Fil.exp(".")'
"/home/manveru/pkgbuilds/ruby-svn/src/trunk"

Leia o artigo golf_prelude.cpara coisas mais legais escondidas.

Outra adição divertida na funcionalidade 1.9 Proc é o Proc # curry, que permite transformar um Proc que aceita n argumentos em um que aceita n-1. Aqui, ele é combinado com a dica Proc # === que mencionei acima:

it_is_day_of_week = lambda{ |day_of_week, date| date.wday == day_of_week }
it_is_saturday = it_is_day_of_week.curry[6]
it_is_sunday = it_is_day_of_week.curry[0]

case Time.now
when it_is_saturday
  puts "Saturday!"
when it_is_sunday
  puts "Sunday!"
else
  puts "Not the weekend"
end

Operadores booleanos em valores não booleanos.

&& e ||

Ambos retornam o valor da última expressão avaliada.

É por isso ||=que atualizará a variável com o valor retornado pela expressão no lado direito, se a variável for indefinida. Isso não está explicitamente documentado, mas o conhecimento comum.

No entanto, o &&=assunto não é tão amplamente conhecido.

string &&= string + "suffix"

é equivalente a

if string
  string = string + "suffix"
end

É muito útil para operações destrutivas que não devem prosseguir se a variável não estiver definida.

A função Symbol # to_proc fornecida pelo Rails é muito legal.

Ao invés de

Employee.collect { |emp| emp.name }

Você pode escrever:

Employee.collect(&:name)

Uma final - em ruby, você pode usar qualquer caractere que queira delimitar strings. Pegue o seguinte código:

message = "My message"
contrived_example = "<div id=\"contrived\">#{message}</div>"

Se você não quiser escapar das aspas duplas na cadeia, basta usar um delimitador diferente:

contrived_example = %{<div id="contrived-example">#{message}</div>}
contrived_example = %[<div id="contrived-example">#{message}</div>]

Além de evitar a necessidade de escapar dos delimitadores, você pode usá-los para obter seqüências multilinhas mais agradáveis:

sql = %{
    SELECT strings 
    FROM complicated_table
    WHERE complicated_condition = '1'
}

Acho que o uso do comando define_method para gerar dinamicamente métodos é bastante interessante e pouco conhecido. Por exemplo:

((0..9).each do |n|
    define_method "press_#{n}" do
      @number = @number.to_i * 10 + n
    end
  end

O código acima usa o comando 'define_method' para criar dinamicamente os métodos "press1" a "press9". Em vez de digitar todos os 10 métodos que contêm essencialmente o mesmo código, o comando define method é usado para gerar esses métodos rapidamente, conforme necessário.

Use um objeto Range como uma lista lenta infinita:

Inf = 1.0 / 0

(1..Inf).take(5) #=> [1, 2, 3, 4, 5]

Mais informações aqui: http://banisterfiend.wordpress.com/2009/10/02/wtf-infinite-ranges-in-ruby/

module_function

Os métodos do módulo declarados como module_function criarão cópias de si mesmos como métodos de instância privada na classe que inclui o Módulo:

module M
  def not!
    'not!'
  end
  module_function :not!
end

class C
  include M

  def fun
    not!
  end
end

M.not!     # => 'not!
C.new.fun  # => 'not!'
C.new.not! # => NoMethodError: private method `not!' called for #<C:0x1261a00>

Se você usar module_function sem argumentos, quaisquer métodos de módulo que venham após a instrução module_function se tornarão automaticamente module_functions.

module M
  module_function

  def not!
    'not!'
  end

  def yea!
    'yea!'
  end
end


class C
  include M

  def fun
    not! + ' ' + yea!
  end
end
M.not!     # => 'not!'
M.yea!     # => 'yea!'
C.new.fun  # => 'not! yea!'

Injeção curta, assim:

Soma do intervalo:

(1..10).inject(:+)
=> 55

Atenção: este item foi votado como o número 1 do jogo mais horrendo de 2008 , então use com cuidado. Na verdade, evite-o como uma praga, mas certamente é Ruby Oculto.

Operadores adicionam novos operadores ao Ruby

Você já desejou um operador de handshake super secreto para alguma operação exclusiva em seu código? Como jogar código de golfe? Tente operadores como - ~ + ~ - ou <--- Esse último é usado nos exemplos para reverter a ordem de um item.

Não tenho nada a ver com o Projeto Superators além de admirá-lo.

Estou atrasado para a festa, mas:

Você pode facilmente pegar duas matrizes de tamanho igual e transformá-las em um hash, com uma matriz fornecendo as chaves e a outra os valores:

a = [:x, :y, :z]
b = [123, 456, 789]

Hash[a.zip(b)]
# => { :x => 123, :y => 456, :z => 789 }

(Isso funciona porque a matriz # zip "fecha os valores das duas matrizes:

a.zip(b)  # => [[:x, 123], [:y, 456], [:z, 789]]

E o Hash [] pode receber exatamente essa matriz. Vi pessoas fazerem isso também:

Hash[*a.zip(b).flatten]  # unnecessary!

O que produz o mesmo resultado, mas o splat e o achatamento são totalmente desnecessários - talvez não existissem no passado?)

Hash vivificantes automáticos em Ruby

def cnh # silly name "create nested hash"
  Hash.new {|h,k| h[k] = Hash.new(&h.default_proc)}
end
my_hash = cnh
my_hash[1][2][3] = 4
my_hash # => { 1 => { 2 => { 3 =>4 } } }

Isso pode ser muito útil.

Reestruturando uma matriz

(a, b), c, d = [ [:a, :b ], :c, [:d1, :d2] ]

Onde:

a #=> :a
b #=> :b
c #=> :c
d #=> [:d1, :d2]

Usando essa técnica, podemos usar uma atribuição simples para obter os valores exatos que queremos da matriz aninhada de qualquer profundidade.

Class.new()

Crie uma nova classe em tempo de execução. O argumento pode ser uma classe para derivar, e o bloco é o corpo da classe. Você também pode querer const_set/const_get/const_defined?registrar sua nova turma corretamente, para que inspectimprima um nome em vez de um número.

Não é algo que você precisa todos os dias, mas bastante útil quando precisa.

crie uma matriz de números consecutivos:

x = [*0..5]

define x para [0, 1, 2, 3, 4, 5]

Muita mágica que você vê em Rubyland tem a ver com metaprogramação, que é simplesmente escrever código que escreve código para você. Ruby attr_accessor, attr_readere attr_writersão todos simples metaprogramming, em que eles criam dois métodos em uma linha, seguindo um padrão normal. O Rails faz muita metaprogramação com seus métodos de gerenciamento de relacionamentos como has_onee belongs_to.

Mas é bastante simples criar seus próprios truques de metaprogramação class_evalpara executar código gravado dinamicamente.

O exemplo a seguir permite que um objeto wrapper encaminhe certos métodos para um objeto interno:

class Wrapper
  attr_accessor :internal

  def self.forwards(*methods)
    methods.each do |method|
      define_method method do |*arguments, &block|
        internal.send method, *arguments, &block
      end
    end
  end

  forwards :to_i, :length, :split
end

w = Wrapper.new
w.internal = "12 13 14"
w.to_i        # => 12
w.length      # => 8
w.split('1')  # => ["", "2 ", "3 ", "4"]

O método Wrapper.forwardsutiliza símbolos para os nomes dos métodos e os armazena na methodsmatriz. Então, para cada um dos dados, usamos define_methodpara criar um novo método cujo trabalho é enviar a mensagem, incluindo todos os argumentos e blocos.

Um ótimo recurso para questões de metaprogramação é o porquê de "Seeing Metaprogramming Clearly", de Lucky Stiff .

use qualquer coisa que responda ===(obj)para comparações de casos:

case foo
when /baz/
  do_something_with_the_string_matching_baz
when 12..15
  do_something_with_the_integer_between_12_and_15
when lambda { |x| x % 5 == 0 }
  # only works in Ruby 1.9 or if you alias Proc#call as Proc#===
  do_something_with_the_integer_that_is_a_multiple_of_5
when Bar
  do_something_with_the_instance_of_Bar
when some_object
  do_something_with_the_thing_that_matches_some_object
end

Module(e, assim, Class), Regexp, Date, e muitas outras classes de definir um método de exemplo: === (outro), e podem todos ser usados.

Agradecemos a Farrel pelo lembrete de Proc#callser um alias, como Proc#===no Ruby 1.9.

O binário "ruby" (pelo menos ressonância magnética) suporta muitos dos switches que tornaram perl one-liners bastante populares.

Significativos:

• -n Configura um loop externo com apenas "gets" - que funciona magicamente com o nome de arquivo ou STDIN, configurando cada linha de leitura em $ _
• -p Semelhante a -n, mas com um puts automático no final de cada iteração de loop
• -uma chamada automática para .split em cada linha de entrada, armazenada em $ F
• -i Editar arquivos de entrada no local
• -l Chamada automática para .chomp na entrada
• -e Executar um pedaço de código
• -c Verifique o código fonte
• -w Com avisos

Alguns exemplos:

# Print each line with its number:
ruby -ne 'print($., ": ", $_)' < /etc/irbrc

# Print each line reversed:
ruby -lne 'puts $_.reverse' < /etc/irbrc

# Print the second column from an input CSV (dumb - no balanced quote support etc):
ruby -F, -ane 'puts $F[1]' < /etc/irbrc

# Print lines that contain "eat"
ruby -ne 'puts $_ if /eat/i' < /etc/irbrc

# Same as above:
ruby -pe 'next unless /eat/i' < /etc/irbrc

# Pass-through (like cat, but with possible line-end munging):
ruby -p -e '' < /etc/irbrc

# Uppercase all input:
ruby -p -e '$_.upcase!' < /etc/irbrc

# Same as above, but actually write to the input file, and make a backup first with extension .bak - Notice that inplace edit REQUIRES input files, not an input STDIN:
ruby -i.bak -p -e '$_.upcase!' /etc/irbrc

Sinta-se à vontade para pesquisar no Google "one-liners ruby" e "perl one-liners" para obter exemplos mais úteis e práticos. Essencialmente, permite que você use o ruby ​​como um substituto bastante poderoso para o awk e sed.

O método send () é um método de uso geral que pode ser usado em qualquer Classe ou Objeto no Ruby. Se não for substituído, send () aceita uma string e chama o nome do método cuja string é passada. Por exemplo, se o usuário clicar no botão “Clr”, a string 'press_clear' será enviada para o método send () e o método 'press_clear' será chamado. O método send () permite uma maneira divertida e dinâmica de chamar funções no Ruby.

 %w(7 8 9 / 4 5 6 * 1 2 3 - 0 Clr = +).each do |btn|
    button btn, :width => 46, :height => 46 do
      method = case btn
        when /[0-9]/: 'press_'+btn
        when 'Clr': 'press_clear'
        when '=': 'press_equals'
        when '+': 'press_add'
        when '-': 'press_sub'
        when '*': 'press_times'
        when '/': 'press_div'
      end

      number.send(method)
      number_field.replace strong(number)
    end
  end

Eu falo mais sobre esse recurso no Blogging Shoes: o aplicativo Simple-Calc

Engane alguma classe ou módulo dizendo que exigiu algo que realmente não era necessário:

$" << "something"

Isso é útil, por exemplo, ao exigir A que, por sua vez, requer B, mas não precisamos de B em nosso código (e A não o utilizará também através de nosso código):

Por exemplo, Backgroundrb's bdrb_test_helper requires 'test/spec', mas você não usa nada, portanto, no seu código:

$" << "test/spec"
require File.join(File.dirname(__FILE__) + "/../bdrb_test_helper")

Fixnum#to_s(base)pode ser realmente útil em alguns casos. Um desses casos é gerar tokens únicos aleatórios (pseudo), convertendo número aleatório em string usando a base de 36.

Token de comprimento 8:

rand(36**8).to_s(36) => "fmhpjfao"
rand(36**8).to_s(36) => "gcer9ecu"
rand(36**8).to_s(36) => "krpm0h9r"

Token de comprimento 6:

rand(36**6).to_s(36) => "bvhl8d"
rand(36**6).to_s(36) => "lb7tis"
rand(36**6).to_s(36) => "ibwgeh"

Definindo um método que aceita qualquer número de parâmetros e apenas descarta todos eles

def hello(*)
    super
    puts "hello!"
end

O hellométodo acima só precisa puts "hello"aparecer na tela e chamar super- mas como a superclasse hellodefine os parâmetros, também é necessário - no entanto, como na verdade não precisa usar os parâmetros em si - não precisa dar um nome a eles.