Блоки и проки в рубине

Question

Я начал изучать Ruby, я прочитал несколько учебных пособий и даже купил книгу («Программирование на Ruby 1.9 - Прагматическое руководство для программистов»), и я столкнулся с чем-то новым, чего раньше не видел на любом из других известных мне языков (я работаю веб-разработчиком на PHP).

Blocks & Procs. Я думаю, что понимаю, что это такое, но я не понимаю, почему они такие замечательные, и когда и почему я должен их использовать. Куда бы я ни посмотрел, везде говорят, что блоки и проки - отличная особенность Ruby, но я их не понимаю.

Может ли кто-нибудь здесь дать объяснение Рубину-новичку, как я?

Answer 1

Есть много хороших вещей в блоках.Шаг лифта: блоки позволяют нам проходить действия так же, как мы обычно передаем данные .

Самый очевидный уровень - это то, что они позволяют вам абстрагировать вещи вфункции, которые не были бы возможны в противном случае.Например, давайте рассмотрим типичный случай, когда у вас есть список вещей, и вы хотите отфильтровать его, чтобы он включал только те элементы, которые соответствуют некоторому критерию:

int list[50] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50};
int evenNumbers[50] = {0};
int copyIndex = 0;
for (int i = 0; i < 50; i++) {
    if (list[i] % 2 == 0) {
        evenNumbers[copyIndex++] = list[i];
    }
}

Вот как вы пишете это в Ruby:

list = 1..50
listCopy = list.select {|n| n.even?}

Вся обычная занятая работа перенесена из вашего кода в метод со значимым именем.Мы не заботимся о копировании массива и прохождении через индексы и все такое - мы просто хотим отфильтрованный список.И это то, что select дает нам.Блок позволяет нам передавать нашу пользовательскую логику в этот стандартный метод.

Но итераторы - не единственное место, где эта "дыра в средней схеме" полезна.Например, если вы передадите блок в File.open, он откроет файл, выполнит блок с файлом, а затем закроет файл для вас.

Еще одна вещь, которую дают нам блоки, - это действительно мощная формаобратных вызовов.Например, без блоков нам, возможно, придется сделать что-то вроде этого (основываясь на том, как на самом деле работают диалоги в Objective-C Cocoa):

class Controller
  def delete_button_clicked(item)
    item.add_red_highlight
    context = {:item => item}
    dialog = Dialog.new("Are you sure you want to delete #{item}?")
    dialog.ok_callback = :delete_OK
    dialog.ok_receiver = self
    dialog.cancel_callback = :cancel_delete
    dialog.cancel_receiver = self
    dialog.context = context
    dialog.ask_for_confirmation
  end

  def delete_OK(sender)
    delete(sender.context[:item])
    sender.dismiss
  end

  def cancel_delete(sender)
    sender.context[:item].remove_red_highlight
    sender.dismiss
  end
end

Yowza.С блоками мы могли бы сделать это вместо этого (основываясь на общем шаблоне, используемом во многих библиотеках Ruby):

class Controller
  def delete_button_clicked(item)
    item.add_red_highlight
    Dialog.ask_for_confirmation("Are you sure you want to delete #{item}?") do |response|
      response.ok { delete item }
      response.cancel { item.remove_red_highlight }
    end
  end
end

На самом деле это два уровня блоков - блок do...end и два стиля {}блоки.Но это читается довольно естественно, не так ли?Это работает, потому что блок захватывает контекст, в котором он создан, поэтому нам не нужно передавать self и item.

Что касается Procs, то они просто объектная оболочка для блоков.Не очень для них.

Answer 2

Важно видеть блоки, а не использовать методы для начала блока кода, вы фактически берете блок и используете его как параметр в функции.

Так что, когда вы используете каждый метод для итерации по массиву, вот так:

superOverFlowArray.each { |flow| puts flow }

Вы отправляете блок {| flow | помещает поток} в каждый метод. Код говорит ruby ​​отправить текущее значение массива в этот блок вместо | flow |.

Procs берет блок и превращает его в переменную. Procs - это экземпляры объектов, которые содержат блоки. Блоки передаются в качестве параметра в proc и выполняются при вызове метода call в этом экземпляре Proc.

Итак, вот пример Proc:

def category_and_title(category)
     Proc.new { |title| "The title is: " + title + " in category: " + category }
end

myFirstTitle = category_and_title("Police Drama")
mySecondTitle = category_and_title("Comedy")

puts myFirstTitle.call("Law and Order")
puts mySecondTitle.call("Seinfeld")
puts myFirstTitle.call("CSI")

Proc запомнит исходную категорию, которая была передана, что позволяет удобно группировать типы.

Answer 3

Блоки используются из многих методов в классах Ruby, и они используются там, где в PHP вы используете обратный вызов.

[1,2,3,4,5].each {|i| print "#{i} "}

[1,2,3,4,5].each do |i|
  print "#{i} "
end

File.open('p014constructs.rb', 'r') do |f1|  
  while line = f1.gets  
    puts line
  end
end

В PHP5 введены анонимные функции;вместо обратного вызова вы можете использовать анонимную функцию.

echo preg_replace_callback('~-([a-z])~', function ($match) {
  return strtoupper($match[1]);
}, 'hello-world');

Answer 4

Procs, также известный как замыкания или лямбды, - это понятие в рубине, которое на первый взгляд может показаться запутанным, особенно новичку.Короче говоря, процы позволяют с легкостью передавать блоки кода.Например, ниже

    hello = Proc.new do |x, y|
      puts "i am a proc"
      sum = x+y
      puts "sum: #{sum}"
    end

теперь, чтобы использовать этот блок кода, просто вызовите метод "call" в hello.Обратите внимание, что приведенный выше пример получает аргументы x и y, которые использует блок кода.Поэтому обязательно передайте аргументы, когда вы вызываете объект Proc, как я сделал ниже:

    hello.call(2, 3)

, получая следующие результаты:

    i am a proc
    sum: 5

Ура !!Это был простой способ создать объект Proc.Насколько это полезно?Хорошо, объекты proc позволяют вам передавать куски кода.Иллюстрация ниже объясняет это лучше, используя процедуру, созданную в примере выше.Давайте создадим некоторый случайный класс,

    class SomeClass
      def initialize(&block)
        @block = block
      end

      def output_value(x, y)
        @block.call(x, y)
      end
    end

, теперь давайте создадим экземпляр SomeClass,

    some_class = SomeClass.new(&hello)

Обратите внимание, что знак амперсанда "&" перед приветствием позволяет вам передать процедуруобъект в качестве аргумента.

наконец, давайте выведем значение, передав 2 аргумента, как показано ниже:

    some_class.output_value(1, 3)

полученный результат выглядит следующим образом:

    i am a proc
    sum: 4

Увидеть!!это так просто.Вы смогли передать часть кода.Процедуры настолько полезны, что ruby ​​часто их использует.Надеюсь, это было очень полезно:)

Answer 5

Блоки и процедуры позволяют вам извлекать небольшие биты кода без дополнительных затрат и сложности методов.

Даже map сам по себе довольно мощный инструмент, и jQuery построен на этой же концепции:

  ['spite','rest','purpose'].map {|s| s << 'ful' }

И при необходимости вы можете добавить логику

  ['sprite','restful','luck'].map {|s| s << (s.end_with?('uck') ? 'i' : '') << 'ly' }

Есть умный оператор '&', который означает «преобразовать символ в прок и вызвать его», так что вы можете конвертировать объектыstrings:

  ['spite',12,:purpose].map(&:to_s)

И используя замыкания и комбинируя написание простых замыканий, мы можем найти место, где рядом находятся числа.Это довольно неуклюжий Ruby, но более лаконичный, чем большинство языков:

  last = -2 # this variable is accessed and changed within the closure
  objs.sort.map do |o|
    if (last + 1) != o
       last = o
       nil # not one more than previous so return nil
    else
       o
    end
  end.compact  # compact removes nils

Когда вы начинаете переписывать его на другом языке, вы понимаете, насколько это удобно.Он поощряет вас структурировать код в более мелкие операции, поэтому он более пригоден для повторного использования и тестирования.

Answer 6

Эти понятия связаны с концепциями от функционального программирования до рубина, поэтому он позволяет вам использовать шаблоны и методы, которые обычно встречаются в языках, где функции являются первоклассными гражданами.