Продолжая "Скрытые возможности..." meme, позвольте поделиться менее известными, но полезными функциями языка программирования Ruby.
Попытайтесь ограничить это обсуждение основным ядром Ruby без каких-либо материалов Ruby on Rails.
См. также:
(Пожалуйста, только одна скрытая функция для каждого ответа.)
Спасибо
От Ruby 1.9 ProС# === является псевдонимом для вызова ProС#, что означает, что объекты 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
Питер Купер имеет хороший список в трюках Ruby. Возможно, мой любимый из них позволяет перечислять как отдельные предметы, так и коллекции. (То есть, рассматривайте объект, не являющийся объектом коллекции, как коллекцию, содержащую только этот объект.) Он выглядит так:
[*items].each do |item|
# ...
end
Не знаю, насколько это скрыто, но я нашел это полезным, когда нужно сделать Hash из одномерного массива:
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.
Это использует метод 1.9 Array#sample (только в 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 является ProС# curry, который позволяет вам преобразовывать аргументы, принимающие n, в один принимающий n-1. Здесь он сочетается с советом ProС# ===, упомянутым выше:
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
Булевы операторы по небулевым значениям.
&& и ||
Оба возвращают значение последнего оцениваемого выражения.
Вот почему ||= обновит переменную с возвращенным значением с правой стороны, если переменная undefined. Это явно не документировано, а общеизвестно.
Однако &&= не так широко известен.
string &&= string + "suffix"
эквивалентно
if string
string = string + "suffix"
end
Это очень удобно для деструктивных операций, которые не должны выполняться, если переменная undefined.
Функция символа # 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 методов, которые Essentailly содержат один и тот же код, команда 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, будут создавать копии в виде методов private в классе, который включает в себя модуль:
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 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 года, поэтому используйте его с осторожностью. Собственно, избегайте его, как чумы, но это, безусловно, скрытый рубин.
Вам нужен суперсекретный оператор рукопожатия для какой-то уникальной операции в вашем коде? Как играть в гольф? Попробуйте таких операторов, как - ~ + ~ - или < --- Этот последний используется в примерах для изменения порядка элемента.
Я не имею никакого отношения к Проект Суператоров, не восхищаясь этим.
Я опаздываю на вечеринку, но:
Вы можете легко взять два массива равной длины и превратить их в хэш с одним массивом, снабжающим ключи, а остальные значения:
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!
Что дает тот же результат, но splat и flatten полностью не нужны - возможно, они не были в прошлом?)
Авто-живительные хэши в 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 выводит имя вместо номера.
Не то, что вам нужно каждый день, но очень удобно, когда вы это делаете.
Много волшебства, которое вы видите в Rubyland, связано с метапрограммированием, которое просто пишет код, который пишет код для вас. Ruby 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 для создания нового метода, задачей которого является отправить сообщение вместе, включая все аргументы и блоки.
Огромный ресурс для проблем метапрограммирования - Почему Lucky Stiff "Видя метапрограммирование ясно" .
создать массив последовательных чисел:
x = [*0..5]
устанавливает x в [0, 1, 2, 3, 4, 5]
используйте все, что отвечает ===(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, а многие другие классы определяют метод экземпляра: === (other) и могут использоваться все.
Благодаря Farrel, чтобы напоминание о Proc#call было псевдонимом как Proc#=== в Ruby 1.9.
"ruby" (по крайней мере, MRI) поддерживает много переключателей, которые сделали perl one-liners весьма популярными.
Значительные:
put в конце каждой итерации циклаНекоторые примеры:
# 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
Не стесняйтесь Google "рубиновые однострочники" и "perl one-liners" для более удобных и практичных примеров. Это, по сути, позволяет использовать ruby как довольно мощную замену 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
Я больше об этом расскажу в Обувь для блогов: приложение Simple-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 определяет параметры, которые он должен также использовать, однако, поскольку он действительно не нужен использовать сами параметры - ему не нужно указывать им имя.