Продовжуючи мем "Приховані особливості ...", поділимося менш відомими, але корисними особливостями мови програмування Ruby.

Спробуйте обмежити цю дискусію основними Ruby, без будь-яких матеріалів Ruby on Rails.

Дивитися також:

• Приховані функції C #
• Приховані особливості Java
• Приховані функції JavaScript
• Приховані особливості Ruby on Rails
• Приховані особливості Python

(Будь ласка, лише одна прихована функція за кожну відповідь.)

Дякую

З Ruby 1.9 Proc # === - псевдонім Proc # call, що означає, що об'єкти Proc можуть використовуватися в таких випадках:

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

У Пітера Купера хороший список трюків Рубі. Можливо, мій улюблений з нього - це перерахування як окремих предметів, так і колекцій. (Тобто трактуйте об'єкт, що не збирає колекцію, як колекцію, що містить саме цей об'єкт.) Це виглядає приблизно так:

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

Не знаю, наскільки це приховано, але я вважаю це корисним, коли потрібно зробити хеш із одновимірного масиву:

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

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

Мені подобається один фокус - використовувати *розширювач splat ( ) для інших об'єктів, крім масивів. Ось приклад регулярного збігу виразів:

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

Інші приклади включають:

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

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

Нічого ж, ніхто не згадав оператора фліп-флопу:

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

Однією із цікавих речей у рубіні є те, що ви можете викликати методи та запускати код у місцях, де інші мови нахмурилися б, наприклад, у визначеннях методу чи класу.

Наприклад, щоб створити клас, який має невідомий надклас до часу виконання, тобто випадковий, ви можете зробити наступне:

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

end

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

Для цього використовується Array#sampleметод 1.9 (див. Лише в 1.8.7 Array#choice), і приклад досить надуманий, але ви можете бачити потужність тут.

Ще один класний приклад - можливість встановлювати значення параметрів за замовчуванням, які не є фіксованими (як це часто вимагають інші мови):

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

Звичайно, проблема першого прикладу полягає в тому, що він оцінюється під час визначення, а не час виклику. Отже, після обрання суперкласу він залишається таким суперкласом для решти програми.

Однак у другому прикладі кожного разу, коли ви викликаєте do_something_at, atзмінна буде тим часом, в якому викликався метод (ну, дуже близький до нього)

Ще одна крихітна особливість - перетворення Fixnumв будь-яку базу до 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"

І як прокоментував Х'ю Уолтерс, перетворення іншого способу так само просто:

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

Хеши з типовими значеннями! Масив у цьому випадку.

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

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

Дуже корисний при метапрограмуванні.

Завантажте джерело Ruby 1.9 і видайте make golf, тоді ви можете робити такі дії:

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"

Прочитайте golf_prelude.cдетальніші речі, які ховаються.

Ще одне цікаве доповнення у функціональності 1.9 Proc - це Proc # curry, який дозволяє перетворити Proc, що приймає n аргументів, у той, що приймає n-1. Тут він поєднується з порадою Proc # ===, яку я згадав вище:

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

Булі оператори на не булеві значення.

&& і ||

Обидва повертають значення останнього оціненого виразу.

Ось чому ||=воля оновить змінну зі значенням, що повертається виразом праворуч, якщо змінна не визначена. Це не явно задокументоване, а загальновідоме.

Однак про &&=це не так широко відомо.

string &&= string + "suffix"

еквівалентно

if string
  string = string + "suffix"
end

Це дуже зручно для руйнівних операцій, які не повинні тривати, якщо змінна не визначена.

Функція Symbol # to_proc, яку надає Rails, справді класна.

Замість

Employee.collect { |emp| emp.name }

Ви можете написати:

Employee.collect(&:name)

Останнє - в рубіні ви можете використовувати будь-який символ, який ви хочете розмежувати. Візьміть наступний код:

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

Якщо ви не хочете уникати подвійних лапок в рядку, ви можете просто використовувати інший роздільник:

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

Окрім уникнення необхідності уникнути розмежувачів, ви можете використовувати ці роздільники для кращих багаторядкових рядків:

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

Я вважаю, що використання команди define_method для динамічного генерування методів є досить цікавим і не так відомим. Наприклад:

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

Вищевказаний код використовує команду 'define_method' для динамічного створення методів «press1» через «press9». Замість того, щоб набрати всі 10 методів, які в основному містять один і той же код, команда define метод використовується для створення цих методів на льоту, за необхідності.

Використовуйте об’єкт Range як нескінченний лінивий список:

Inf = 1.0 / 0

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

Більше інформації тут: http://banisterfiend.wordpress.com/2009/10/02/wtf-infinite-ranges-in-ruby/

модуль_функція

Методи модуля, оголошені як module_function , створюватимуть копії себе як приватні методи екземпляра в класі, що включає модуль:

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>

Якщо ви використовуєте module_function без будь-яких аргументів, то будь-які методи модуля, що з’являються після оператора module_function, автоматично стануть самими 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!'

Коротка ін'єкція, як така:

Сума діапазону:

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

Попередження: за цей пункт проголосували №1 за найжахливіший хак 2008 року , тому використовуйте обережно. Насправді уникайте цього, як чуми, але це, звичайно, прихований Рубі.

Суператори Додають нових операторів до Ruby

Коли-небудь хочете суперсекретного оператора рукостискання для унікальної операції у вашому коді? Як грати в гольф-код? Спробуйте такі оператори, як - ~ + ~ - або <--- Цей останній використовується в прикладах для зміни порядку порядку елемента.

Я не маю нічого спільного з проектом Superators, окрім захоплення ним.

Я спізнююсь на вечірку, але:

Ви можете легко взяти два масиви однакової довжини і перетворити їх у хеш з одним масивом, що подає ключі, а іншим значення:

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

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

(Це працює, тому що масив # zip "перескакує" значення з двох масивів:

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

І Hash [] може взяти саме такий масив. Я бачив, як це роблять і люди:

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

Що дає такий самий результат, але плескіт і сплющення зовсім не потрібні - можливо, вони не були в минулому?)

Автовізуючі хеші в 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 } } }

Це просто може бути проклято.

Знищення масиву

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

Де:

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

За допомогою цієї методики ми можемо використовувати просте завдання, щоб отримати точні значення, які ми хочемо, із вкладеного масиву будь-якої глибини.

Class.new()

Створіть новий клас під час виконання. Аргументом може бути клас, похідний від якого, а блок - це клас класу. Ви також можете поглянути на те, const_set/const_get/const_defined?щоб ваш новий клас був належним чином зареєстрований, щоб він inspectвиводив ім'я замість числа.

Не те, що вам потрібно щодня, але досить зручно, коли ви це робите.

створити масив послідовних чисел:

x = [*0..5]

задає х на [0, 1, 2, 3, 4, 5]

Багато магії, яку ви бачите в Rubyland, пов'язана з метапрограмуванням, це просто написання коду, який пише код для вас. Ruby's attr_accessor, attr_readerі attr_writerвсі це просте метапрограмування, оскільки вони створюють два методи в одному рядку, дотримуючись стандартного зразка. Rails робить багато метапрограмування за допомогою таких методів управління відносинами, як has_oneі belongs_to.

Але досить просто створити власні трюки з метапрограмуванням, використовуючи class_evalдля виконання динамічно записаного коду.

Наступний приклад дозволяє об’єкту обгортки пересилати певні методи разом із внутрішнім об'єктом:

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

Метод Wrapper.forwardsбере символи для назв методів і зберігає їх у methodsмасиві. Потім, для кожного з цих, ми використовуємоdefine_method для створення нового методу, завданням якого є надсилання повідомлення разом, включаючи всі аргументи та блоки.

Чудовим ресурсом для питань метапрограмування є Чому "Бачити метапрограмування чітко" Лакі Стіффа .

використовувати будь-що, що відповідає ===(obj)для порівняння випадків:

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(і таким чином Class) Regexp,Date , і багато інших класи визначають метод примірника: === (інший), і все вони можуть бути використані.

Дякую Фаррелу за нагадування про Proc#callте, що він відчужений як Proc#===у Ruby 1.9.

Бінарний "рубін" (принаймні МРТ) підтримує безліч комутаторів, які зробили однокласикові перли досить популярними.

Важливі:

• -n Встановлює зовнішній цикл із просто "отримує" - який магічно працює з заданим іменем файлу або STDIN, встановлюючи кожен рядок читання у $ _
• -p Подібно до -n, але з автоматичним puts в кінці кожної циклу ітерації
• -автоматичний виклик на .split на кожному вхідному рядку, що зберігається у $ F
• -i на місці редагування вхідних файлів
• -l Автоматичний дзвінок на .chomp на вході
• -e Виконати фрагмент коду
• -c Перевірте вихідний код
• -w З попередженнями

Деякі приклади:

# 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

Не соромтеся гугл "рубінові однолінійки" та "перл однолінійки" на тонни більш зручних та практичних прикладів. Це по суті дозволяє використовувати рубін як досить потужну заміну на awk і sed.

Метод send () - це метод загального призначення, який можна використовувати в будь-якому класі або об'єкті в Ruby. Якщо це не буде замінено, send () приймає рядок і називає ім'я методу, рядок якого він переданий. Наприклад, якщо користувач натискає кнопку "Clr", рядок "press_clear" буде надісланий методом send (), а метод "press_clear" буде викликаний. Метод send () дозволяє отримати цікавий та динамічний спосіб виклику функцій у 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

Я детальніше розповідаю про цю функцію в Blogging Shoes: Проста програма Calc

Обдуріть якийсь клас або модуль, який говорить, що йому потрібно щось, чого він насправді не вимагає:

$" << "something"

Це корисно, наприклад, коли потрібен A, який по черзі вимагає B, але нам не потрібен B в нашому коді (і A не буде використовувати його ні через наш код):

Наприклад, Backgroundrb bdrb_test_helper requires 'test/spec', але ви його взагалі не використовуєте, тому у своєму коді:

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

Fixnum#to_s(base)може бути дуже корисним у деяких випадках. Один з таких випадків - генерування випадкових (псевдо) унікальних лексем шляхом перетворення випадкового числа в рядок, використовуючи базу 36.

Маркер довжиною 8:

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

Маркер довжиною 6:

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

Визначення методу, який приймає будь-яку кількість параметрів і просто відкидає їх усі

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

Вищеописаний helloметод потребує лише puts "hello"на екрані та виклику, superале оскільки суперклас helloвизначає параметри, які він повинен робити, проте, оскільки він фактично не потребує використання самих параметрів - не потрібно давати їм ім'я.