Вызов методов

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

В Ruby вы отправляете сообщение объекту так:

my_method()

Обратите внимание, что скобки являются необязательными:

my_method

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

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

Получатель

self является получателем по умолчанию. Если вы не указываете получателя, self будет использован. Чтобы указать получателя, используйте .:

my_object.my_method

Это отправляет сообщение my_method объекту my_object. Любой объект может быть получателем, но в зависимости от видимости метода отправка сообщения может вызвать NoMethodError.

Вы также можете использовать :: для обозначения получателя, но это используется редко из-за потенциальной путаницы с :: для пространств имён.

Оператор безопасной навигации

&., называемый «оператором безопасной навигации», позволяет пропустить вызов метода, когда получатель является nil. Он возвращает nil и не вычисляет аргументы метода, если вызов пропущен.

REGEX = /(ruby) is (\w+)/i
"Ruby is awesome!".match(REGEX).values_at(1, 2)
# => ["Ruby", "awesome"]
"Python is fascinating!".match(REGEX).values_at(1, 2)
# NoMethodError: undefined method `values_at' for nil:NilClass
"Python is fascinating!".match(REGEX)&.values_at(1, 2)
# => nil

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

"Python is fascinating!".match(REGEX)&.values_at(1, 2).join(' - ')
# NoMethodError: undefined method `join' for nil:NilClass
"Python is fascinating!".match(REGEX)&.values_at(1, 2)&.join(' - ')
# => nil

Аргументы

Существует три типа аргументов при отправке сообщения: позиционные аргументы, ключевые (или именованные) аргументы и аргумент блока. Каждое отправленное сообщение может использовать один, два или все типы аргументов, но аргументы должны быть предоставлены в таком порядке.

Все аргументы в Ruby передаются по ссылке и не вычисляются лениво.

Каждый аргумент отделяется ,:

my_method(1, '2', :three)

Аргументы могут быть выражением, аргументом типа hash:

'key' => value

или ключевым аргументом:

key: value

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

my_method('a' => 1, b: 2, 'c' => 3)

Позиционные аргументы

Позиционные аргументы для сообщения следуют за именем метода:

my_method(argument1, argument2)

Во многих случаях скобки не нужны при отправке сообщения:

my_method argument1, argument2

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

method_one argument1, method_two argument2, argument3

Если определение метода имеет *argument дополнительные позиционные аргументы будут присвоены argument в методе в качестве Array.

Если определение метода не включает ключевые аргументы, ключевые или аргументы типа hash присваиваются как один hash последнему аргументу:

def my_method(options)
  p options
end

my_method('a' => 1, b: 2) # prints: {'a'=>1, :b=>2}

Если указано слишком много позиционных аргументов, будет вызвано ArgumentError.

Значения по умолчанию для позиционных аргументов

Когда метод определяет аргументы по умолчанию, вам не нужно указывать все аргументы методу. Ruby заполнит недостающие аргументы в порядке следования.

Сначала рассмотрим простой случай, когда аргументы по умолчанию появляются справа. Рассмотрим этот метод:

def my_method(a, b, c = 3, d = 4)
  p [a, b, c, d]
end

Здесь c и d имеют значения по умолчанию, которые Ruby применит за вас. Если вы отправите только два аргумента в этот метод:

my_method(1, 2)

Вы увидите, что Ruby напечатает [1, 2, 3, 4].

Если вы отправите три аргумента:

my_method(1, 2, 5)

Вы увидите, что Ruby напечатает [1, 2, 5, 4]

Ruby заполняет недостающие аргументы слева направо.

Ruby позволяет значениям по умолчанию появляться посередине позиционных аргументов. Рассмотрим этот более сложный метод:

def my_method(a, b = 2, c = 3, d)
  p [a, b, c, d]
end

Здесь b и c имеют значения по умолчанию. Если вы отправите только два аргумента в этот метод:

my_method(1, 4)

Вы увидите, что Ruby напечатает [1, 2, 3, 4].

Если вы отправите три аргумента:

my_method(1, 5, 6)

Вы увидите, что Ruby напечатает [1, 5, 3, 6].

Описание этого словами становится сложным и запутанным. Я опишу это с помощью переменных и значений вместо этого.

Сначала 1 присваивается a, затем 6 присваивается d. Это оставляет только аргументы со значениями по умолчанию. Так как 5 ещё не присвоено какое-либо значение, оно присваивается b, а c использует своё значение по умолчанию 3.

Ключевые аргументы

Ключевые аргументы следуют за любыми позиционными аргументами и разделяются запятыми, как и позиционные аргументы:

my_method(positional1, keyword1: value1, keyword2: value2)

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

Аргумент блока

Аргумент блока отправляет замыкание из области вызова в метод.

Аргумент блока всегда является последним при отправке сообщения методу. Блок отправляется методу с помощью do ... end или { ... }:

my_method do
  # ...
end

или:

my_method {
  # ...
}

do end имеет более низкий приоритет, чем { }, поэтому:

method_1 method_2 {
  # ...
}

Отправляет блок в method_2, в то время как:

method_1 method_2 do
  # ...
end

Отправляет блок в method_1. Обратите внимание, что в первом случае, если используются скобки, блок отправляется в method_1.

Блок будет принимать аргументы от метода, в который он был отправлен. Аргументы определяются аналогично тому, как метод определяет аргументы. Аргументы блока находятся в | ... | после открывающей do или {:

my_method do |argument1, argument2|
  # ...
end

Локальные аргументы блока

Вы также можете объявить локальные аргументы блока с помощью ; в списке аргументов блока. Присвоение локальному аргументу блока не переопределит локальные аргументы вне блока в области вызова:

def my_method
  yield self
end

place = "world"

my_method do |obj; place|
  place = "block"
  puts "hello #{obj} this is #{place}"
end

puts "place is: #{place}"

Это выведет:

hello main this is block
place is world

Таким образом, переменная place в блоке не является той же переменной place, что и за пределами блока. Удаление ; place из аргументов блока даёт такой результат:

hello main this is block
place is block

Array Преобразование массива в аргументы

Учитывая следующий метод:

def my_method(argument1, argument2, argument3)
end

Вы можете преобразовать массив Array в список аргументов с помощью оператора * (или splat):

arguments = [1, 2, 3]
my_method(*arguments)

или:

arguments = [2, 3]
my_method(1, *arguments)

Оба эквивалентны:

my_method(1, 2, 3)

Если метод принимает ключевые аргументы, оператор splat преобразует хэш в конце массива в ключевые аргументы:

def my_method(a, b, c: 3)
end

arguments = [1, 2, { c: 4 }]
my_method(*arguments)

Обратите внимание, что это поведение в настоящее время устарело и будет выдавать предупреждение. Это поведение будет удалено в Ruby 3.0.

Вы также можете использовать ** (описанный ниже) для преобразования хэша Hash в ключевые аргументы.

Если количество объектов в массиве Array не соответствует количеству аргументов метода, будет поднята ошибка ArgumentError.

Если оператор splat стоит первым в вызове, для предотвращения предупреждения необходимо использовать скобки:

my_method *arguments  # warning
my_method(*arguments) # no warning

Hash Преобразование хэша в ключевые аргументы

Учитывая следующий метод:

def my_method(first: 1, second: 2, third: 3)
end

Вы можете преобразовать хэш Hash в ключевые аргументы с помощью оператора ** (ключевой splat):

arguments = { first: 3, second: 4, third: 5 }
my_method(**arguments)

или:

arguments = { first: 3, second: 4 }
my_method(third: 5, **arguments)

Оба эквивалентны:

my_method(first: 3, second: 4, third: 5)

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

def my_method(*a, **kw)
  p arguments: a, keywords: kw
end

my_method(1, 2, '3' => 4, five: 6)

Выводит:

{:arguments=>[1, 2], :keywords=>{'3'=>4, :five=>6}}

Proc Преобразование проса в блок

Учитывая метод, использующий блок:

def my_method
  yield self
end

Вы можете преобразовать proc или lambda в аргумент блока с помощью оператора & (преобразование в блок):

argument = proc { |a| puts "#{a.inspect} was yielded" }

my_method(&argument)

Если оператор преобразования блока стоит первым в вызове, необходимо использовать скобки, чтобы избежать предупреждения:

my_method &argument  # warning
my_method(&argument) # no warning

Method Поиск метода

Когда вы отправляете сообщение, Ruby ищет метод, соответствующий имени сообщения для получателя. Методы хранятся в классах и модулях, поэтому поиск метода проходит по ним, а не по самим объектам.

Вот порядок поиска метода для класса или модуля получателя R:

• Предопределённые модули R в обратном порядке

• Для совпадающего метода в R

• Включённые модули R в обратном порядке

Если R является классом с суперклассом, это повторяется с суперклассом R до тех пор, пока не будет найден метод.

После того, как совпадение найдено, поиск метода прекращается.

Если совпадение не найдено, это повторяется с самого начала, но ищется method_missing. По умолчанию method_missing — BasicObject#method_missing, который вызывает NameError при вызове.

Если активны усовершенствования (экспериментальная функция), поиск метода меняется. Подробности см. в документации по усовершенствованиям.