Setzen wir das Mem "Versteckte Funktionen von ..." fort und teilen wir die weniger bekannten, aber nützlichen Funktionen der Programmiersprache Ruby.

Versuchen Sie, diese Diskussion mit Ruby zu begrenzen, ohne Ruby on Rails-Inhalte.

Siehe auch:

• Versteckte Funktionen von C #
• Versteckte Funktionen von Java
• Versteckte Funktionen von JavaScript
• Versteckte Funktionen von Ruby on Rails
• Versteckte Funktionen von Python

(Bitte nur eine versteckte Funktion pro Antwort.)

Danke dir

Ab Ruby 1.9 ist Proc # === ein Alias ​​für den Proc # -Aufruf, was bedeutet, dass Proc-Objekte in case-Anweisungen wie den folgenden verwendet werden können:

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 hat eine gute Liste von Ruby-Tricks. Vielleicht ist es sein Favorit, sowohl einzelne Gegenstände als auch Sammlungen aufzählen zu lassen. (Das heißt, behandeln Sie ein Nicht-Sammlungsobjekt als eine Sammlung, die nur dieses Objekt enthält.) Es sieht folgendermaßen aus:

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

Ich weiß nicht, wie versteckt das ist, aber ich fand es nützlich, wenn ich aus einem eindimensionalen Array einen Hash machen muss:

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

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

Ein Trick, den ich mag, ist die Verwendung des splat ( *) - Expanders für andere Objekte als Arrays. Hier ist ein Beispiel für eine Übereinstimmung mit regulären Ausdrücken:

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

Andere Beispiele sind:

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

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

Wow, niemand hat den Flip-Flop-Operator erwähnt:

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

Eines der coolen Dinge an Ruby ist, dass Sie Methoden aufrufen und Code an Stellen ausführen können, an denen andere Sprachen die Stirn runzeln würden, z. B. in Methoden- oder Klassendefinitionen.

Um beispielsweise eine Klasse zu erstellen, die bis zur Laufzeit eine unbekannte Oberklasse hat, dh zufällig ist, können Sie Folgendes tun:

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

end

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

Dies verwendet die 1.9- Array#sampleMethode (siehe nur 1.8.7 Array#choice), und das Beispiel ist ziemlich erfunden, aber Sie können die Leistung hier sehen.

Ein weiteres cooles Beispiel ist die Möglichkeit, nicht festgelegte Standardparameterwerte einzugeben (wie dies in anderen Sprachen häufig erforderlich ist):

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

Das Problem mit dem ersten Beispiel ist natürlich, dass es zur Definitionszeit und nicht zur Aufrufzeit ausgewertet wird. Sobald eine Oberklasse ausgewählt wurde, bleibt diese Oberklasse für den Rest des Programms erhalten.

Im zweiten Beispiel ist do_something_atdie atVariable jedoch bei jedem Aufruf die Zeit, zu der die Methode aufgerufen wurde (na ja, sehr, sehr nahe daran).

Ein weiteres kleines Feature - konvertieren Sie a Fixnumin eine beliebige Basis bis zu 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"

Und wie Huw Walters kommentiert hat, ist das Umwandeln in die andere Richtung genauso einfach:

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

Hashes mit Standardwerten! Ein Array in diesem Fall.

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

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

Sehr nützlich bei der Metaprogrammierung.

Laden Sie die Ruby 1.9-Quelle herunter und geben make golfSie ein Problem ein . Dann können Sie Folgendes tun:

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"

Lies das golf_prelude.c für mehr nette Dinge, die sich verstecken.

Eine weitere unterhaltsame Ergänzung in der 1.9 Proc-Funktionalität ist Proc # curry, mit der Sie einen Proc, der n Argumente akzeptiert, in einen Proc verwandeln können, der n-1 akzeptiert. Hier wird es mit dem oben erwähnten Proc # === Tipp kombiniert:

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

Boolesche Operatoren für nicht boolesche Werte.

&& und ||

Beide geben den Wert des zuletzt ausgewerteten Ausdrucks zurück.

Aus diesem Grund ||=wird die Variable mit dem Wert aktualisiert, der auf der rechten Seite als Ausdruck zurückgegeben wird, wenn die Variable nicht definiert ist. Dies ist nicht explizit dokumentiert, aber allgemein bekannt.

Allerdings &&=ist das nicht ganz so bekannt.

string &&= string + "suffix"

ist äquivalent zu

if string
  string = string + "suffix"
end

Es ist sehr praktisch für destruktive Operationen, die nicht fortgesetzt werden sollten, wenn die Variable undefiniert ist.

Die von Rails bereitgestellte Funktion Symbol # to_proc ist wirklich cool.

Anstatt

Employee.collect { |emp| emp.name }

Du kannst schreiben:

Employee.collect(&:name)

Eine letzte - in Ruby können Sie jedes Zeichen verwenden, mit dem Sie Zeichenfolgen abgrenzen möchten. Nehmen Sie den folgenden Code:

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

Wenn Sie die doppelten Anführungszeichen in der Zeichenfolge nicht umgehen möchten, können Sie einfach ein anderes Trennzeichen verwenden:

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

Sie können nicht nur Trennzeichen vermeiden, sondern auch Trennzeichen für schönere mehrzeilige Zeichenfolgen verwenden:

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

Ich finde es ziemlich interessant und nicht so bekannt , den Befehl define_method zum dynamischen Generieren von Methoden zu verwenden. Beispielsweise:

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

Der obige Code verwendet den Befehl 'define_method', um die Methoden "press1" bis "press9" dynamisch zu erstellen. Anstatt alle 10 Methoden einzugeben, die im Wesentlichen denselben Code enthalten, wird der Befehl define method verwendet, um diese Methoden bei Bedarf im laufenden Betrieb zu generieren.

Verwenden Sie ein Range-Objekt als unendliche Lazy-Liste:

Inf = 1.0 / 0

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

Weitere Informationen hier: http://banisterfiend.wordpress.com/2009/10/02/wtf-infinite-ranges-in-ruby/

Modulfunktion

Modulmethoden , die als module_function deklariert sind, erstellen Kopien von sich selbst als private Instanzmethoden in der Klasse, die das Modul enthält:

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>

Wenn Sie module_function ohne Argumente verwenden, werden alle Modulmethoden, die nach der Anweisung module_function kommen, automatisch zu 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!'

Kurzinjektion wie folgt:

Summe der Reichweite:

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

Warnung: Dieser Artikel wurde zum # 1 Horrendous Hack des Jahres 2008 gewählt . Verwenden Sie ihn daher mit Vorsicht. Vermeiden Sie es eigentlich wie die Pest, aber es ist mit Sicherheit Hidden Ruby.

Superatoren Fügen Sie Ruby neue Operatoren hinzu

Wollten Sie jemals einen supergeheimen Handshake-Operator für eine einzigartige Operation in Ihrem Code? Wie Code Golf spielen? Versuchen Sie es mit Operatoren wie - ~ + ~ - oder <---. Der letzte wird in den Beispielen zum Umkehren der Reihenfolge eines Elements verwendet.

Ich habe nichts mit dem Superators-Projekt zu tun, außer es zu bewundern.

Ich bin zu spät zur Party, aber:

Sie können problemlos zwei Arrays gleicher Länge in einen Hash umwandeln, wobei ein Array die Schlüssel und das andere die Werte liefert:

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

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

(Dies funktioniert, weil Array # zip die Werte der beiden Arrays "komprimiert":

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

Und Hash [] kann genau ein solches Array aufnehmen. Ich habe Leute gesehen, die das auch gemacht haben:

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

Was das gleiche Ergebnis liefert, aber Splat und Flatten sind völlig unnötig - vielleicht waren sie nicht in der Vergangenheit?)

Automatische Belebung von Hashes in 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 } } }

Das kann verdammt praktisch sein.

Ein Array zerstören

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

Wo:

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

Mit dieser Technik können wir eine einfache Zuweisung verwenden, um die genauen Werte aus einem verschachtelten Array beliebiger Tiefe zu erhalten.

Class.new()

Erstellen Sie zur Laufzeit eine neue Klasse. Das Argument kann eine Klasse sein, von der abgeleitet werden kann, und der Block ist der Klassenkörper. Vielleicht möchten Sie auch einen Blick darauf werfenconst_set/const_get/const_defined? , ob Ihre neue Klasse ordnungsgemäß registriert ist, damit inspectein Name anstelle einer Nummer ausgedruckt wird.

Nicht etwas, das Sie jeden Tag brauchen, aber sehr praktisch, wenn Sie es tun.

Erstellen Sie ein Array von fortlaufenden Zahlen:

x = [*0..5]

setzt x auf [0, 1, 2, 3, 4, 5]

Ein Großteil der Magie, die Sie in Rubyland sehen, hat mit Metaprogrammierung zu tun, bei der einfach Code geschrieben wird, der Code für Sie schreibt. Ruby's attr_accessor, attr_readerund attr_writersind alle einfache Metaprogrammierungen, da sie zwei Methoden in einer Zeile nach einem Standardmuster erstellen. Rails führt eine Menge Metaprogrammierung mit ihren Beziehungsmanagementmethoden wie has_oneund durchbelongs_to .

Es ist jedoch ziemlich einfach, eigene Metaprogrammier-Tricks zu erstellen class_eval, mit denen dynamisch geschriebener Code ausgeführt wird.

Im folgenden Beispiel kann ein Wrapper-Objekt bestimmte Methoden an ein internes Objekt weiterleiten:

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

Die Methode Wrapper.forwards Symbole für die Namen der Methoden und speichert sie im methodsArray. Dann verwenden wir für jeden der angegebenendefine_method erstellen Methoden eine neue Methode, deren Aufgabe es ist, die Nachricht einschließlich aller Argumente und Blöcke mitzusenden.

Eine großartige Quelle für Metaprogrammierungsprobleme ist, warum der Lucky Stiff "Metaprogrammierung klar sehen" .

Verwenden Sie für Fallvergleiche alles, worauf reagiert ===(obj)wird:

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(und damit Class),Regexp , Dateund viele andere Klassen definieren eine Instanzmethode: === (andere), und alle verwendet werden können.

Vielen Dank an Farrel für die Erinnerung an Proc#calldas Aliasing Proc#===in Ruby 1.9.

Die "Ruby" -Binärdatei (zumindest MRTs) unterstützt viele der Schalter, die Perl-Einzeiler sehr beliebt gemacht haben.

Bedeutende:

• -n Richtet eine äußere Schleife mit nur "get" ein - was auf magische Weise mit dem angegebenen Dateinamen oder STDIN funktioniert und jede Lesezeile in $ _ setzt
• -p Ähnlich wie -n, jedoch mit einer Automatik put s am Ende jeder Schleifeniteration
• -a Automatischer Aufruf von .split in jeder Eingabezeile, gespeichert in $ F.
• -i Eingabedateien direkt bearbeiten
• -l Automatischer Aufruf von .chomp bei Eingabe
• -e Führe einen Code aus
• -c Quellcode prüfen
• -w Mit Warnungen

Einige Beispiele:

# 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

Fühlen Sie sich frei, "Ruby One-Liner" und "Perl One-Liner" für Tonnen mehr brauchbare und praktische Beispiele zu googeln. Es ermöglicht Ihnen im Wesentlichen, Rubin als ziemlich starken Ersatz für awk und sed zu verwenden.

Die send () -Methode ist eine Allzweckmethode, die für jede Klasse oder jedes Objekt in Ruby verwendet werden kann. Wenn nicht überschrieben, akzeptiert send () eine Zeichenfolge und ruft den Namen der Methode auf, deren Zeichenfolge übergeben wird. Wenn der Benutzer beispielsweise auf die Schaltfläche "Clr" klickt, wird die Zeichenfolge "press_clear" an die Methode "send ()" gesendet und die Methode "press_clear" aufgerufen. Die send () -Methode ermöglicht eine unterhaltsame und dynamische Möglichkeit, Funktionen in Ruby aufzurufen.

 %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

Ich spreche mehr über diese Funktion in Blogging Shoes: The Simple-Calc Application

Machen Sie sich eine Klasse oder ein Modul zum Narren und sagen Sie, dass etwas erforderlich ist, das es wirklich nicht benötigt:

$" << "something"

Dies ist zum Beispiel nützlich, wenn A erforderlich ist, für das wiederum B erforderlich ist, wir jedoch kein B in unserem Code benötigen (und A es auch nicht über unseren Code verwendet):

Zum Beispiel Backgroundrb's bdrb_test_helper requires 'test/spec', aber Sie verwenden es überhaupt nicht, also in Ihrem Code:

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

Fixnum#to_s(base)kann in manchen Fällen sehr nützlich sein. Ein solcher Fall ist das Erzeugen zufälliger (Pseudo-) eindeutiger Token durch Konvertieren einer Zufallszahl in einen String unter Verwendung der Basis von 36.

Token der Länge 8:

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

Token der Länge 6:

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

Definieren einer Methode, die eine beliebige Anzahl von Parametern akzeptiert und nur alle verwirft

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

Die obige helloMethode muss nur puts "hello"auf dem Bildschirm angezeigt werden, superaber da die Oberklasse auch helloParameter definiert, muss sie dies auch tun. Da sie jedoch die Parameter selbst nicht verwenden muss, muss sie ihnen keinen Namen geben.