Poursuivant le meme "Fonctionnalités cachées de ...", partageons les fonctionnalités moins connues mais utiles du langage de programmation Ruby.

Essayez de limiter cette discussion avec le noyau Ruby, sans aucun élément Ruby on Rails.

Voir également:

• Fonctionnalités cachées de C #
• Fonctionnalités cachées de Java
• Fonctionnalités cachées de JavaScript
• Fonctionnalités cachées de Ruby on Rails
• Fonctionnalités cachées de Python

(S'il vous plaît, une seule fonction cachée par réponse.)

Je vous remercie

De Ruby 1.9 Proc # === est un alias de l'appel Proc #, ce qui signifie que les objets Proc peuvent être utilisés dans des instructions case comme ceci:

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 a une bonne liste de trucs Ruby. Peut-être que mon préféré est de permettre à la fois des articles uniques et des collections d'être énumérés. (Autrement dit, traitez un objet non-collection comme une collection contenant uniquement cet objet.) Cela ressemble à ceci:

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

Je ne sais pas à quel point cela est caché, mais je l'ai trouvé utile lorsque j'ai besoin de créer un hachage à partir d'un tableau unidimensionnel:

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

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

Une astuce que j'aime est d'utiliser l' *expanseur splat ( ) sur des objets autres que des tableaux. Voici un exemple de correspondance d'expression régulière:

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

D'autres exemples incluent:

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

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

Wow, personne n'a mentionné l'opérateur de bascule:

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

Une des choses intéressantes à propos de ruby ​​est que vous pouvez appeler des méthodes et exécuter du code dans des endroits où d'autres langages seraient désapprouvés, comme dans les définitions de méthode ou de classe.

Par exemple, pour créer une classe qui a une superclasse inconnue jusqu'à l'exécution, c'est-à-dire qu'elle est aléatoire, vous pouvez faire ce qui suit:

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

end

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

Cela utilise la Array#sampleméthode 1.9 (en 1.8.7 uniquement, voir Array#choice), et l'exemple est assez artificiel mais vous pouvez voir la puissance ici.

Un autre exemple intéressant est la possibilité de mettre des valeurs de paramètres par défaut qui ne sont pas fixes (comme le demandent souvent d'autres langues):

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

Bien sûr, le problème avec le premier exemple est qu'il est évalué au moment de la définition, pas au moment de l'appel. Ainsi, une fois qu'une superclasse a été choisie, elle reste cette superclasse pour le reste du programme.

Cependant, dans le deuxième exemple, chaque fois que vous appelez do_something_at, la atvariable sera l'heure à laquelle la méthode a été appelée (enfin, très très proche de celle-ci)

Une autre petite fonctionnalité - convertir un Fixnumen n'importe quelle base jusqu'à 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"

Et comme Huw Walters l'a commenté, la conversion dans l'autre sens est tout aussi simple:

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

Hashes avec des valeurs par défaut! Un tableau dans ce cas.

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

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

Très utile en métaprogrammation.

Téléchargez la source et le problème de Ruby 1.9 make golf, puis vous pouvez faire des choses comme ceci:

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"

Lisez le golf_prelude.cpour des choses plus soignées qui se cachent.

Un autre ajout amusant dans la fonctionnalité 1.9 Proc est Proc # curry qui vous permet de transformer un Proc acceptant n arguments en un acceptant n-1. Ici, il est combiné avec le conseil Proc # === que j'ai mentionné ci-dessus:

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

Opérateurs booléens sur des valeurs non booléennes.

&& et ||

Les deux renvoient la valeur de la dernière expression évaluée.

C'est pourquoi le ||=mettra à jour la variable avec l'expression de valeur renvoyée sur le côté droit si la variable n'est pas définie. Ceci n'est pas explicitement documenté, mais bien connu.

Cependant, ce &&=n'est pas si largement connu.

string &&= string + "suffix"

est équivalent à

if string
  string = string + "suffix"
end

C'est très pratique pour les opérations destructives qui ne devraient pas se poursuivre si la variable n'est pas définie.

La fonction Symbol # to_proc fournie par Rails est vraiment cool.

Au lieu de

Employee.collect { |emp| emp.name }

Tu peux écrire:

Employee.collect(&:name)

Un dernier - dans ruby, vous pouvez utiliser n'importe quel caractère que vous souhaitez délimiter des chaînes. Prenez le code suivant:

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

Si vous ne souhaitez pas échapper les guillemets doubles dans la chaîne, vous pouvez simplement utiliser un séparateur différent:

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

En plus d'éviter d'avoir à échapper des délimiteurs, vous pouvez utiliser ces délimiteurs pour des chaînes multilignes plus agréables:

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

Je trouve que l'utilisation de la commande define_method pour générer dynamiquement des méthodes est assez intéressante et moins connue. Par exemple:

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

Le code ci-dessus utilise la commande 'define_method' pour créer dynamiquement les méthodes "press1" à "press9". Plutôt que de taper les 10 méthodes qui contiennent essentiellement le même code, la commande define method est utilisée pour générer ces méthodes à la volée si nécessaire.

Utilisez un objet Range comme une liste paresseuse infinie:

Inf = 1.0 / 0

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

Plus d'infos ici: http://banisterfiend.wordpress.com/2009/10/02/wtf-infinite-ranges-in-ruby/

module_function

Les méthodes de module qui sont déclarées comme module_function créeront des copies d'elles-mêmes en tant que méthodes d'instance privée dans la classe qui inclut le module:

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>

Si vous utilisez module_function sans aucun argument, alors toutes les méthodes de module qui viennent après l'instruction module_function deviendront automatiquement module_functions elles-mêmes.

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!'

Injecter court, comme tel:

Somme de la plage:

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

Attention: cet objet a été élu n ° 1 du hack le plus horrible de 2008 , donc à utiliser avec précaution. En fait, évitez-le comme la peste, mais c'est très certainement du rubis caché.

Superators ajoutent de nouveaux opérateurs à Ruby

Vous avez toujours voulu un opérateur de prise de contact super secret pour une opération unique dans votre code? Vous aimez jouer au golf codé? Essayez des opérateurs comme - ~ + ~ - ou <--- Ce dernier est utilisé dans les exemples pour inverser l'ordre d'un élément.

Je n'ai rien à voir avec le projet Superators à part l' admirer.

Je suis en retard à la fête, mais:

Vous pouvez facilement prendre deux tableaux de longueur égale et les transformer en hachage avec un tableau fournissant les clés et l'autre les valeurs:

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

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

(Cela fonctionne car Array # zip "zippe" les valeurs des deux tableaux:

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

Et Hash [] peut prendre un tel tableau. J'ai vu des gens faire ça aussi:

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

Ce qui donne le même résultat, mais le splat et l'aplatissement sont totalement inutiles - peut-être qu'ils ne l'étaient pas dans le passé?)

Hashs auto-vivifiants en 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 } } }

Cela peut être très pratique.

Destructuration d'un tableau

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

Où:

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

En utilisant cette technique, nous pouvons utiliser une affectation simple pour obtenir les valeurs exactes que nous voulons d'un tableau imbriqué de n'importe quelle profondeur.

Class.new()

Créez une nouvelle classe au moment de l'exécution. L'argument peut être une classe à dériver, et le bloc est le corps de la classe. Vous voudrez peut-être aussi regarder const_set/const_get/const_defined?pour que votre nouvelle classe soit correctement enregistrée, afin qu'elle inspectimprime un nom au lieu d'un numéro.

Ce n'est pas quelque chose dont vous avez besoin tous les jours, mais tout à fait pratique lorsque vous le faites.

créer un tableau de nombres consécutifs:

x = [*0..5]

définit x sur [0, 1, 2, 3, 4, 5]

Une grande partie de la magie que vous voyez dans Rubyland a à voir avec la métaprogrammation, qui consiste simplement à écrire du code qui écrit du code pour vous. Ruby attr_accessor, attr_readeret attr_writersont tous metaprogramming simples dans la mesure où ils créent deux méthodes dans une ligne, suivant un modèle standard. Rails fait beaucoup de métaprogrammation avec ses méthodes de gestion des relations comme has_oneet belongs_to.

Mais c'est assez simple de créer vos propres astuces de métaprogrammation en utilisant class_evalpour exécuter du code écrit dynamiquement.

L'exemple suivant permet à un objet wrapper de transmettre certaines méthodes à un objet interne:

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"]

La méthode Wrapper.forwardsprend des symboles pour les noms des méthodes et les stocke dans le methodstableau. Ensuite, pour chacun de ceux donnés, nous utilisonsdefine_method pour créer une nouvelle méthode dont le travail est d'envoyer le message, y compris tous les arguments et blocs.

Une excellente ressource pour les problèmes de métaprogrammation est Why the Lucky Stiff "Seeing Metaprogramming Clearly" .

utilisez tout ce qui répond à ===(obj)des comparaisons de cas:

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(et donc Class) Regexp,Date et bien d' autres classes définissent une méthode d'instance: === (autre), et peuvent tous être utilisés.

Merci à Farrel pour le rappel d' Proc#callêtre aliasé comme Proc#===dans Ruby 1.9.

Le binaire "ruby" (au moins les IRM) supporte un grand nombre de commutateurs qui ont rendu les one-liners perl très populaires.

Les plus importants:

• -n Configure une boucle externe avec juste "gets" - qui fonctionne comme par magie avec un nom de fichier donné ou STDIN, en définissant chaque ligne de lecture dans $ _
• -p Similaire à -n mais avec un puts automatique à la fin de chaque itération de boucle
• -a Appel automatique à .split sur chaque ligne d'entrée, stocké dans $ F
• -i Fichiers d'entrée d'édition sur place
• -l Appel automatique à .chomp à l'entrée
• -e Exécute un morceau de code
• -c Vérifier le code source
• -w Avec avertissements

Quelques exemples:

# 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

N'hésitez pas à chercher sur Google "ruby one-liners" et "perl one-liners" pour des tonnes d'exemples pratiques et utilisables supplémentaires. Il vous permet essentiellement d'utiliser ruby ​​comme un remplacement assez puissant de awk et sed.

La méthode send () est une méthode à usage général qui peut être utilisée sur n'importe quelle classe ou objet de Ruby. S'il n'est pas remplacé, send () accepte une chaîne et appelle le nom de la méthode dont il est passé. Par exemple, si l'utilisateur clique sur le bouton «Clr», la chaîne «press_clear» sera envoyée à la méthode send () et la méthode «press_clear» sera appelée. La méthode send () permet une manière amusante et dynamique d'appeler des fonctions dans 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

Je parle plus de cette fonctionnalité dans Blogging Shoes: L'application Simple-Calc

Tromper une classe ou un module en disant qu'il a exigé quelque chose qu'il n'a pas vraiment requis:

$" << "something"

Ceci est utile par exemple lorsque vous demandez A qui à son tour nécessite B mais nous n'avons pas besoin de B dans notre code (et A ne l'utilisera pas non plus via notre code):

Par exemple, Backgroundrb's bdrb_test_helper requires 'test/spec', mais vous ne l'utilisez pas du tout, donc dans votre code:

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

Fixnum#to_s(base)peut être vraiment utile dans certains cas. Un tel cas est la génération de jetons uniques aléatoires (pseudo) en convertissant un nombre aléatoire en chaîne en utilisant la base de 36.

Jeton de longueur 8:

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

Jeton de longueur 6:

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

Définir une méthode qui accepte n'importe quel nombre de paramètres et les ignore tous

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

La hellométhode ci-dessus n'a besoin que d'être affichée à puts "hello"l'écran et d'appeler super- mais comme la superclasse hellodéfinit les paramètres, elle doit également le faire - mais comme elle n'a pas réellement besoin d'utiliser les paramètres elle-même, elle n'a pas besoin de leur donner un nom.