Почему явный возврат имеет значение в Proc?

Question

Почему явный возврат имеет значение в Proc?

можно также использовать его как это:

$data = array(1,3,4);
$select->where('status_id IN(?)', $data);

Вы не должны интегрировать массив, и это более безопасно

51

ruby return proc-object

задан Andrew Grimm 5 October 2011 в 11:34

3 ответа

Это семантика для Proc s; это не обязательно семантика для всех блоков. Я согласен, это немного сбивает с толку. Это сделано для дополнительной гибкости (и, возможно, частично потому, что у Ruby нет спецификации, кроме ее реализации).

Поведение определяется в реализации Proc . Лямбды ведут себя иначе, поэтому, если вы хотите, чтобы ваши возвращали , чтобы не выходить из включающего метода, используйте лямбды . Или опустите ключевое слово return из своего Proc .

Подробное исследование замыканий Rubys находится здесь . Это фантастическое разоблачение.

Итак:

def foo   
  f = Proc.new {
    p2 = Proc.new { return "inner proc"};
    p2.call
    return "proc"
  }
  f.call
  return "foo"
end

def foo2
  result = Proc.new{"proc"}.call
  "foo2 (proc result is: #{result})"
end

def bar
  l = lambda { return "lambda" }
  result = l.call
  return "bar (lambda result is: #{result})"
end

puts foo
# inner proc
puts foo2
# foo (proc result is: proc) 
puts bar
# bar (lambda result is: lambda)

13

ответ дан 7 November 2019 в 10:04

Подумайте об этом так: Proc.new просто создает блок кода, который является частью вызывающей функции. proc / lambda создает анонимную функцию со специальными привязками. Небольшие примеры кода помогут:

def foo
  f = Proc.new { return "return from foo from inside Proc.new" }
  f.call # control leaves foo here
  return "return from foo" 
end

эквивалентен

def foo
  begin
    return "return from foo from inside begin/end" }
  end

  return "return from foo" 
end

, поэтому ясно, что возврат будет просто возвращен из функции 'foo'

, в отличие от:

def foo
  f = proc { return "return from foo from inside proc" }
  f.call # control stasy in foo here
  return "return from foo" 
end

эквивалентно (игнорирование привязок, поскольку not используется в этом примере):

def unonymous_proc
  return "return from foo from inside proc"
end

def foo
  unonymous_proc()
  return "return from foo" 
end

Который также явно не вернется из foo и вместо этого перейдет к следующему оператору.

7

ответ дан 7 November 2019 в 10:04

Другие вопросы по тегам:

ruby return proc-object

Похожие вопросы:

score 83 · Accepted Answer

Я использую IntelliJ около 5 лет (начиная с версии 4.5), а также прочитал большую часть книги Мэннинга «IntelliJ в действии», и я все равно не считаю себя гуру в этой области. Фактически, я также хотел заняться с ним «простой старой разработкой на Java», и, честно говоря, я должен сказать, что это неплохо. Как и другие ответы, я могу только сказать, что в его полезности есть определенное преимущество, которое действительно ставит его выше. Здесь мы также используем Eclipse на работе, и хотя у меня не так много опыта, я могу сказать вам, что в нем определенно не хватает многих базовых вещей. Я потратил много времени и усилий, чтобы изучить Eclipse, ища, как делать повседневные вещи, которые я считаю само собой разумеющимся в IntelliJ, а они в основном отсутствуют или очень плохо реализованы. Рефакторинг, безусловно, очень помогает.

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

Попробуйте следующее:

Создайте новый пустой класс. Переместите курсор в фигурные скобки и выполните psvm и нажмите Ctrl-J - это расширит «psvm» на «public static void main (String [] args)». Есть целый список часто используемых идиом, которые будет обрабатывать этот ярлык (и его тоже можно настроить). Внутри основного блока кода введите этот код:

public static void main(String[] args) {
  int x = 1000;
  sout
}

В конце « sout » снова нажмите Ctrl-J - вы увидите другое всплывающее окно, в котором вы можете выбрать одно из других расширений, но в обычно это расширяется до "System.out.println (" ")" и услужливо помещает курсор между двойными кавычками (я думаю, это небольшие штрихи, которые действительно заставляют его сиять. Сравните с Visual Studio "IntelliSense" - полная чушь, если вы спросите меня).

В любом случае, возврат к первой двойной кавычке - заметили, она удаляет совпадающую двойную кавычку? То же самое происходит и с скобками. Я думаю, что в некоторых случаях я предпочитаю этого не делать, но в большинстве случаев это очень помогает. Вернемся к редактированию кода: просто введите x , чтобы код теперь выглядел так:

public static void main(String[] args) {
  int x = 1000;


  // add a few blank lines here too - the need for 
  // this will be obvious a little later

  System.out.println(x);
}

Теперь переместите курсор на объявление x и нажмите Shift-F6 - это рефакторинг in- разместить диалог (я не знаю, как его назвать, поэтому я просто придумал). Имя "x" обведено цветной рамкой, и вы можете начать вводить для него новое имя - по мере того, как вы вводите, все случаи использования этого имени также динамически обновляются. Еще одно изящное решение, которое мне действительно нравится.

Попробуйте следующее: поместите где-нибудь действительно длинный строчный комментарий, например:

// this is a really long comment blah blah blah i love to hear myself talking hahaha

Теперь скажите, что вы решили, что комментарий слишком длинный, поэтому вы перемещаете курсор в его середину и нажимаете Войти. IntelliJ поместит оставшуюся часть комментария с добавлением «//» - он «знает», что это продолжение предыдущего комментария, поэтому комментирует его для вас. Еще один изящный штрих.

// this is a really long comment blah 
// blah blah i love to hear myself talking hahaha

Еще один большой бонус, который мне нравится в IntelliJ по сравнению с Eclipse, заключается в том, что он намного менее навязчив - я действительно ненавидел, как Eclipse умудрялся выводить всплывающие окна поверх всплывающих окон, и фокус мыши был где-то, но фокус клавиатуры завис на чем-то внизу и т. д. я думаю, что это ' Можно работать таким образом, чтобы такого рода вещи не происходили, но меня это в первую очередь очень раздражало. Это напоминает мне, что в IntelliJ, если вы наводите курсор мыши на пакет или файловый навигатор на левой панели, эта панель автоматически получает фокус мыши, поэтому я привык немедленно использовать колесо мыши, чтобы осматриваться. В Затмении? Вы наводите указатель мыши, но фокус остается на панели редактирования, поэтому вам нужно щелкнуть мышью, чтобы перенести фокус, а затем использовать колесо мыши, чтобы осмотреться. Как я уже сказал, это множество мелких деталей, которые помогают повысить продуктивность.

Когда вы пишете код, обратите внимание на левую полосу желоба для красных символов типа «лампочка» в текущей строке - это IntelliJ сообщает вам есть возможные вещи. Используйте Alt-Enter, чтобы открыть небольшое диалоговое окно на месте, и оно сообщит вам, о чем можно позаботиться автоматически. Предположим, вы вводите определение метода с именем «getFoo ()» и там нет члена foo - он предложит создать его за вас. Или, если вы используете класс и вызываете для него несуществующий метод, например getFoo (), он предложит создать геттер и член или обычный метод. Это просто полезно.

В целом, я бы сказал, что небольшие штрихи - это не то, о чем гуру IntelliJ действительно захотят говорить, но я действительно ценю, что такого рода вещи просто «хорошо сделаны». Они заботятся о мелких деталях, поэтому вам не придется тратить столько времени на мысленную проверку собственного синтаксиса. Я думаю об этом как о дворецком, который помогает мне с программированием - он берет на себя мелкие хлопоты, так что мне не нужно. У Бэтмена есть свой Альфред, а у меня - свой IntelliJ. Все настройки мучительно выложены, чтобы вы могли их изменить, если хотите, но кажется, что все настройки по умолчанию направлены на повышение вашей продуктивности, а не на то, чтобы постоянно беспокоить вас по-настоящему обыденными решениями (особенно теми, которые вы почти всегда принимали в любом случае тот же выбор).

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

но кажется, что все настройки по умолчанию направлены на повышение вашей продуктивности, а не на то, чтобы постоянно беспокоить вас по-настоящему обыденными решениями (особенно теми, которые вы почти всегда сделали бы одним и тем же выбором).

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

но кажется, что все настройки по умолчанию направлены на повышение вашей продуктивности, а не на то, чтобы постоянно беспокоить вас по-настоящему обыденными решениями (особенно теми, которые вы почти всегда сделали бы одним и тем же выбором).

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

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

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

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

Если вы используете return внутри определения foo, вы вернетесь из foo, даже если он находится внутри блока или процесса. Чтобы вернуться из блока, вы можете использовать вместо него ключевое слово next. где завершение блока приведет к возобновлению итерации с next элемента коллекции, а завершение каждого приведет к break из цикла.

Если вы используете return внутри определения foo, вы вернетесь из foo, даже если он находится внутри блока или процесса. Чтобы вернуться из блока, вы можете использовать вместо него ключевое слово next.

def foo
  f = Proc.new { next "return from foo from inside proc" }
  f.call # control leaves foo here
  return "return from foo" 
end
puts foo # prints "return from foo"