Melanjutkan meme "Fitur tersembunyi ...", mari berbagi fitur bahasa pemrograman Ruby yang kurang dikenal namun bermanfaat.

Cobalah batasi diskusi ini dengan Ruby inti, tanpa Ruby apa pun.

Lihat juga:

• Fitur tersembunyi dari C #
• Fitur tersembunyi Jawa
• Fitur tersembunyi dari JavaScript
• Fitur tersembunyi Ruby on Rails
• Fitur tersembunyi dari Python

(Tolong, hanya satu fitur tersembunyi per jawaban.)

Terima kasih

Dari Ruby 1.9 Proc # === adalah alias untuk panggilan Proc #, yang berarti objek Proc dapat digunakan dalam pernyataan kasus seperti:

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 memiliki daftar trik Ruby yang bagus. Mungkin favorit saya miliknya adalah memungkinkan item tunggal dan koleksi untuk disebutkan. (Yaitu, perlakukan objek non-koleksi sebagai koleksi yang berisi objek itu saja.) Kelihatannya seperti ini:

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

Tidak tahu seberapa tersembunyi ini, tapi saya merasa berguna ketika perlu membuat Hash dari array satu dimensi:

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

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

Salah satu trik yang saya suka adalah dengan menggunakan splat ( *) expander pada objek selain Array. Berikut ini contoh pada pencocokan ekspresi reguler:

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

Contoh lain termasuk:

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

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

Wow, tidak ada yang menyebut operator flip flop:

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

Salah satu hal keren tentang ruby ​​adalah Anda dapat memanggil metode dan menjalankan kode di tempat yang disukai oleh bahasa lain, seperti dalam metode atau definisi kelas.

Misalnya, untuk membuat kelas yang memiliki superclass yang tidak diketahui sampai waktu berjalan, yaitu acak, Anda bisa melakukan hal berikut:

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

end

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

Ini menggunakan Array#samplemetode 1.9 (hanya 1.8.7, lihat Array#choice), dan contohnya cukup dibuat tetapi Anda dapat melihat kekuatannya di sini.

Contoh keren lainnya adalah kemampuan untuk menempatkan nilai parameter default yang tidak tetap (seperti bahasa lain yang sering diminta):

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

Tentu saja masalah dengan contoh pertama adalah bahwa ia dievaluasi pada waktu definisi, bukan waktu panggilan. Jadi, sekali superclass telah dipilih, ia tetap superclass itu untuk sisa program.

Namun, dalam contoh kedua, setiap kali Anda menelepon do_something_at, atvariabel akan menjadi waktu metode dipanggil (well, sangat sangat dekat dengannya)

Fitur mungil lainnya - konversikan Fixnummenjadi basis apa saja hingga 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"

Dan seperti komentar Huw Walters, mengonversi dengan cara lain sama mudahnya:

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

Hash dengan nilai default! Array dalam hal ini.

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

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

Sangat berguna dalam metaprogramming.

Unduh sumber Ruby 1.9, dan terbitkan make golf, maka Anda dapat melakukan hal-hal seperti ini:

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"

Baca golf_prelude.cuntuk hal-hal yang lebih rapi bersembunyi.

Tambahan menyenangkan lainnya dalam fungsi 1.9 Proc adalah Proc # curry yang memungkinkan Anda untuk mengubah argumen yang menerima Proc menjadi argumen yang menerima n-1. Ini dikombinasikan dengan tips Proc # === yang saya sebutkan di atas:

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

Operator Boolean pada nilai non boolean.

&& dan ||

Keduanya mengembalikan nilai ekspresi terakhir yang dievaluasi.

Itu sebabnya ||=akan memperbarui variabel dengan nilai yang dikembalikan ekspresi di sisi kanan jika variabel tidak terdefinisi. Ini tidak didokumentasikan secara eksplisit, tetapi pengetahuan umum.

Namun &&=tidak begitu banyak diketahui tentang.

string &&= string + "suffix"

setara dengan

if string
  string = string + "suffix"
end

Ini sangat berguna untuk operasi destruktif yang tidak boleh dilanjutkan jika variabel tidak terdefinisi.

Fungsi Symbol # to_proc yang disediakan Rails benar-benar keren.

Dari pada

Employee.collect { |emp| emp.name }

Kamu bisa menulis:

Employee.collect(&:name)

Satu yang terakhir - di ruby ​​Anda dapat menggunakan karakter apa pun yang ingin Anda batasi string. Ambil kode berikut:

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

Jika Anda tidak ingin lepas dari tanda kutip ganda dalam string, Anda dapat menggunakan pembatas yang berbeda:

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

Selain menghindari pelarian pembatas, Anda dapat menggunakan pembatas ini untuk string multiline yang lebih bagus:

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

Saya menemukan menggunakan perintah define_method untuk secara dinamis menghasilkan metode yang cukup menarik dan tidak terlalu dikenal. Sebagai contoh:

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

Kode di atas menggunakan perintah 'define_method' untuk secara dinamis membuat metode "press1" melalui "press9." Alih-alih mengetik semua 10 metode yang essentailly berisi kode yang sama, perintah metode define digunakan untuk menghasilkan metode ini dengan cepat sesuai kebutuhan.

Gunakan objek Range sebagai daftar malas tak terbatas:

Inf = 1.0 / 0

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

Info lebih lanjut di sini: http://banisterfiend.wordpress.com/2009/10/02/wtf-infinite-ranges-in-ruby/

module_function

Metode modul yang dideklarasikan sebagai module_function akan membuat salinan dirinya sebagai metode turunan pribadi di kelas yang menyertakan Modul:

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>

Jika Anda menggunakan fungsi module_ tanpa argumen, maka metode modul apa pun yang muncul setelah pernyataan module_function akan secara otomatis menjadi fungsi module_functions sendiri.

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

Suntikan singkat, seperti:

Jumlah kisaran:

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

Peringatan: item ini terpilih sebagai # 1 Hack Paling Menghebohkan tahun 2008 , jadi gunakan dengan hati-hati. Sebenarnya, hindarilah seperti wabah, tetapi itu pasti Ruby Tersembunyi.

Superator Tambahkan Operator Baru ke Ruby

Pernah menginginkan operator jabat tangan super-rahasia untuk beberapa operasi unik dalam kode Anda? Suka bermain golf kode? Coba operator seperti - ~ + ~ - atau <--- Yang terakhir digunakan dalam contoh untuk membalik urutan item.

Saya tidak ada hubungannya dengan Proyek Superators selain mengaguminya.

Saya terlambat ke pesta, tetapi:

Anda dapat dengan mudah mengambil dua array dengan panjang yang sama dan mengubahnya menjadi hash dengan satu array memasok kunci dan yang lainnya nilainya:

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

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

(Ini berfungsi karena Array # zip "zip" nilai-nilai dari dua array:

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

Dan Hash [] dapat mengambil array seperti itu. Saya telah melihat orang melakukan ini juga:

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

Yang menghasilkan hasil yang sama, tetapi percikan dan ratakan sama sekali tidak perlu - mungkin mereka tidak di masa lalu?)

Hash vivifying otomatis di 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 } } }

Ini bisa sangat berguna.

Merusak Array

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

Dimana:

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

Dengan menggunakan teknik ini kita dapat menggunakan penugasan sederhana untuk mendapatkan nilai tepat yang kita inginkan dari array bersarang dari kedalaman apa pun.

Class.new()

Buat kelas baru saat run time. Argumennya bisa berupa kelas untuk diturunkan, dan bloknya adalah badan kelas. Anda mungkin juga ingin melihat const_set/const_get/const_defined?agar kelas baru Anda terdaftar dengan benar, jadiinspect mencetak nama dan bukan nomor.

Bukan sesuatu yang Anda butuhkan setiap hari, tetapi cukup berguna saat Anda melakukannya.

buat array angka berurutan:

x = [*0..5]

set x ke [0, 1, 2, 3, 4, 5]

Banyak keajaiban yang Anda lihat di Rubyland ada hubungannya dengan metaprogramming, yang hanya menulis kode yang menulis kode untuk Anda. Ruby attr_accessor, attr_readerdan attr_writersemua metaprogramming sederhana, dalam arti bahwa mereka membuat dua metode dalam satu baris, mengikuti pola standar. Rails melakukan banyak metaprogramming dengan metode manajemen hubungan seperti has_onedan belongs_to.

Tapi cukup mudah untuk membuat trik metaprogramming Anda sendiri menggunakan class_evaluntuk mengeksekusi kode yang ditulis secara dinamis.

Contoh berikut memungkinkan objek wrapper untuk meneruskan metode tertentu ke objek internal:

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

Metode ini Wrapper.forwardsmengambil simbol untuk nama-nama metode dan menyimpannya dalam methodsarray. Kemudian, untuk masing-masing yang diberikan, kita gunakandefine_method untuk membuat metode baru yang tugasnya mengirim pesan, termasuk semua argumen dan blok.

Sumber yang bagus untuk masalah metaprogramming adalah Why the Lucky Stiff's "Seeing Metaprogramming Clearly" .

menggunakan apa pun yang menanggapi ===(obj)perbandingan kasus:

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(dan dengan demikian Class) Regexp,Date , dan banyak kelas-kelas lain mendefinisikan metode contoh: === (lainnya), dan semua bisa digunakan.

Terima kasih kepada Farrel untuk pengingat Proc#callakan alias seperti Proc#===di Ruby 1.9.

Biner "ruby" (setidaknya MRI) mendukung banyak switch yang membuat perl one-liner cukup populer.

Yang signifikan:

• -n Mengatur loop luar hanya dengan "mendapat" - yang secara ajaib bekerja dengan nama file atau STDIN yang diberikan, mengatur setiap baris baca dalam $ _
• -p Mirip dengan -n tetapi dengan puts otomatis di akhir setiap iterasi loop
• -Panggilan otomatis ke .split pada setiap jalur input, disimpan dalam $ F
• -i Di tempat mengedit file input
• -l Panggilan otomatis ke .chomp on input
• -E Menjalankan sepotong kode
• -c Periksa kode sumber
• -w Dengan peringatan

Beberapa contoh:

# 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

Jangan ragu untuk google "ruby one-liners" dan "perl one-liners" untuk banyak contoh yang lebih bermanfaat dan praktis. Ini pada dasarnya memungkinkan Anda untuk menggunakan ruby ​​sebagai pengganti yang cukup kuat untuk awk dan sed.

Metode send () adalah metode tujuan umum yang dapat digunakan pada Kelas atau Objek apa pun di Ruby. Jika tidak diganti, kirim () menerima string dan memanggil nama metode yang stringnya dilewatkan. Misalnya, jika pengguna mengklik tombol "Clr", string 'press_clear' akan dikirim ke metode send () dan metode 'press_clear' akan dipanggil. Metode send () memungkinkan cara yang dinamis dan menyenangkan untuk memanggil fungsi di 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

Saya berbicara lebih banyak tentang fitur ini di Blogging Shoes: The Simple-Calc Application

Menipu beberapa kelas atau modul yang mengatakan itu membutuhkan sesuatu yang sebenarnya tidak diperlukan:

$" << "something"

Ini berguna misalnya ketika membutuhkan A yang pada gilirannya membutuhkan B tetapi kami tidak membutuhkan B dalam kode kami (dan A tidak akan menggunakannya baik melalui kode kami):

Misalnya, Backgroundrb bdrb_test_helper requires 'test/spec', tetapi Anda tidak menggunakannya sama sekali, jadi dalam kode Anda:

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

Fixnum#to_s(base)dalam beberapa kasus bisa sangat berguna. Salah satu kasus tersebut adalah menghasilkan token acak (semu) dengan mengubah angka acak menjadi string menggunakan basis 36.

Token dengan panjang 8:

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

Token dengan panjang 6:

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

Menentukan metode yang menerima sejumlah parameter dan hanya membuang semuanya

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

helloMetode di atas hanya perlu puts "hello"di layar dan panggilan super- tetapi karena superclass hellomenentukan parameternya juga - namun karena sebenarnya tidak perlu menggunakan parameter itu sendiri - itu tidak harus memberi mereka nama.