Подпись метода Вы можете погрузить свои зубы в

Если параметры имеют значения по умолчанию, но метод вызывается с передачей неожиданного значения (т. Е. Nil), то это значение будет использоваться без жалоб. В приведенном ниже примере мы ожидаем, что параметр options Это приводит к ошибке.

 def display_name(options={})
  p options[:first_name]
end
display_name(nil)

#=> NoMethodError: undefined method `[]' for nil:NilClass

#=> from (pry):2:in `display_name'

( рисунок е.4. )

Здесь у нас есть хеш со значением по умолчанию для имени. Если мы передаем хэш, хэш по умолчанию игнорируется. Поскольку хэш по умолчанию игнорируется, ключ first_name

 def display_name(options={:first_name => "George"})
  p options[:first_name]
end
display_name(:last_name => "Jetson")

#=> nil

( рисунок е.5. )

Хорошо, так что есть проблемы. При этом существуют шаблоны, которые разработчики Ruby используют для устранения некоторых из этих недостатков. Давайте посмотрим на другой пример.

 class HelloWorld
  def initialize(options=nil)
    options ||= {}
    @message = opts.fetch(:message,"Hello, World!")
  end

  def to_s
    puts @message
  end
end

( рисунок е.6. )

Несколько вещей происходит в коде выше. Метод initialize устанавливает HelloWorld#new{} Это сделано для того, чтобы мы могли создать экземпляр этого объекта без передачи аргументов. Следующая интересная вещь, когда мы устанавливаем @message Поскольку мы знаем, что аргумент #newHash Так как мы хотим, чтобы HelloWorldHash#fetch

• Использование Hash#fetch Решает рисунок е.5
• Назначение параметров для nil, а затем явное переназначение его по умолчанию ( options ||= {} Решает рисунок е.4

Аргументы как массив

Что делать, если я хочу передать в мой метод произвольное количество аргументов. Ну, это можно сделать с помощью оператора * Оператор splat будет принимать произвольное количество аргументов и собирать их в виде массива. Поначалу это может показаться немного странным, давайте рассмотрим пример, чтобы закрепить эту мысль в наших умах.

 def example_method(*args)
  p args
end
-> example_method("argument_one", "argument_two")

#=> ["argument_one", "argument_two"]

( рисунок е. )

Вы можете вызывать этот метод с любым количеством аргументов (включая ни одного). Это позволяет нам делать некоторые причудливые вещи при вызове наших методов. Важным примечанием является то, что, поскольку оператор splat будет жадно захватывать все значения в (position..position+n)

Ключевое слово Аргументы (Ruby 2.0)

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

Посмотрите на проблему на рисунке е.5 еще раз. В нем вы захотите установить значение по умолчанию для :first_name:last_name С помощью ключевых слов вы можете просто определить метод следующим образом:

 def display_name(first_name: "George", last_name: "Jetson")
  p "#{last_name}, #{first_name}"
end
display_name(last_name: "Jetson")

#=>

Этот метод может быть вызван любым из следующих способов:

 display_name

#=> "Jetson, George"

#
display_name(first_name: "Judy")

#=> "Jetson, Judy"

#
display_name(last_name: "Jefferson")

#=> "Jefferson, George"

#
display_name(last_name: "Flinstone", first_name: "Fred")

#=> "Flinstone, Fred"

Чтобы повторить этот метод до Ruby 2.0, вам необходимо:

• По умолчанию параметр параметров
• Создайте хэш, заполненный вашими значениями по умолчанию
• Объединить параметры в хэш по умолчанию

Аргументы ключевых слов позволяют вам быть невероятно лаконичными при объявлении метода. В Ruby 2.0 метод создается, как указано выше, вместо более подробного эквивалента в 1.9.x:

 def display_name(options=nil)
  options ||= {}
  {first_name: "George", last_name: "Jetson"}.merge(options)
  p "#{last_name}, #{first_name}"
end

Если бы это был единственный способ использовать аргументы ключевых слов, я был бы продан, но это еще не все! БЛОКИ И ПРОЦЕССЫ! Скажем, вы хотите сделать display_name Это так же просто, как:

 display_name = Proc.new {|first_name: "George", last_name: "Jetson"| p "#{last_name}, #{first_name}" }
display_name.call

#=> "Jetson, George"
display_name.call(first_name: "Judy")

#=> "Jetson, Judy"

Аккуратно да ^ _ ^

Что произойдет, если вы передадите ключевой аргумент, который не указан в сигнатуре метода? Давайте взглянем.

 def example_method(first_keyword: "example")
end
example_method(last_keyword: "Last")

#=> ArgumentError: unknown keyword: last_keyword

#...

Мы получаем ArgumentError Если вы хотите получить доступ к этим неназначенным аргументам ключевых слов, вы можете использовать оператор **

 def example_method(first_keyword: "example", **other_keywords)
  p other_keywords
end
example_method(last_keyword: "test")

#=> {:last_keyword=>"test"}

Вывод

Рад, что ты сделал это так далеко. Я надеюсь, что вы сейчас так же взволнованы, как и я по поводу Ruby 2.0 Что еще более важно, я надеюсь, что это помогло вам лучше понять, как работает Ruby. Гибкая природа Ruby допускает некоторые дикие вариации даже в самых простых задачах. Это одно из самых сильных его достоинств и одна из причин, по которой я влюбился в язык.

Спасибо за прочтение.

Ссылки

1. 2010, Алан Скоркин, «Аргументы метода в Ruby»
2. Ruby-Doc, 1.9.3, «Hash # fetch» ​​»
3. 2011, Джейкоб Своннер, «Необязательный параметр Gotchas»
4. 2012, Крис Цеттер, «Аргументы ключевых слов в Ruby 2.0»

Дополнительные ссылки

• 2009, Грегори Браун, «Ruby Best Practices»