Rails — приправленный Ruby

Определение методов

Консоль позволяет определять методы точно так же, как мы это делали с home действием из Листинга 3.6 или хелпером из Листинга 4.2. (Определение методов в консоли - немного громоздкое мероприятие, и обычно вы будете использовать файл, но это удобно для демонстрационных целей.) Например, давайте определим функцию string_message которая принимает один аргумент и возвращает сообщение в зависимости от того, пустой аргумент или нет:

>> def string_message(string)
>>   if string.empty?
>>     "It's an empty string!"
>>   else
>>     "The string is nonempty."
>>   end
>> end
=> nil
>> puts string_message("")
It's an empty string!
>> puts string_message("foobar")
The string is nonempty.

Обратите внимание, что Ruby функции имеют неявное возвращение (скрытый return) то есть, они возвращают последнее оцененное утверждение — в данном случае, одну из двух строк сообщения, в зависимости от того, пуст или нет аргумент string. Ruby также имеет явный вариант возвращения (явный return); следующие функции эквивалентны приведенным выше:

>> def string_message(string)
>>   return "It's an empty string!" if string.empty?
>>   return "The string is nonempty."
>> end

(Внимательный читатель может заметить в этой точке, что второе return здесь фактически ненужно — состояние последнего выражения в функции, т.е. строки "The string is nonempty." будет возвращено независимо от ключевого слова return, но использование return в обоих местах придает ему приятную симметрию.)

Также важно понимать что название аргумента функции не имеет значения. Другими словами, в первом примере показанном выше можно заменить string на любое валидное название переменной, такое как the_function_argument и он будет работать совершенно аналогично:

>> def string_message(the_function_argument)
>>   if the_function_argument.empty?
>>     "It's an empty string!"
>>   else
>>     "The string is nonempty."
>>   end
>> end
=> nil
>> puts string_message("")
It's an empty string!
>> puts string_message("foobar")
The string is nonempty.

Возвращение к title хелперу

Теперь мы в состоянии понять full_title хелпер из Листинга 4.2:^{4Ну, все же осталась одна вещь, которую мы не понимаем — как Rails связывает все это вместе: направляет URL к действиям, делает full_title хелпер доступным в представлениях и т.д.. Это интересная тема, и я поощряю вас исследовать ее далее, но точное знание того, как Rails работает, не является необходимым для использования Rails. (Для более глубокого понимания я рекомендую The Rails 4 Way Оби Фернандеса.)}

module ApplicationHelper

  # Возвращает полный заголовок зависящий от страницы # Документирующий комментарий
  def full_title(page_title)                          # Определение метода
    base_title = "Ruby on Rails Tutorial Sample App"  # Назначение переменной
    if page_title.empty?                              # Булевый тест
      base_title                                      # Явное возвращение
    else
      "#{base_title} | #{page_title}"                 # Интерполяция строки
    end
  end
end

Все эти элементы — определение функции, присваивание переменной, логические тесты, управление потоком, и интерполяция строки — собраны вместе, чтобы сделать компактный вспомогательный метод для использования в шаблоне нашего сайта. Последний элемент это module ApplicationHelper: модули позволяют нам складывать вместе связанные методы, затем они (модули) могут быть подмешаны в Ruby-классы с помощью include. Если вы пишете на обычном Ruby, вы обычно пишете модули и сами их явно включаете, но в случае с хелпер-модулем Rails делает включение за нас. Результатом является то, что full_title метод автомагически доступен во всех наших представлениях.

Другие структуры данных

Хотя веб-приложения, в конечном счете это строки, фактически, для изготовления этих строк требуется также использование других структур данных. В этом разделе мы узнаем о некоторых структурах данных Ruby, важных для написания Rails приложений.

Массивы и диапазоны

Массив это всего лишь список элементов в определенном порядке. Мы еще не обсуждали массивы в Rails Tutorial, но их понимание дает хорошую основу для понимания хэшей (Раздел 4.3.3) и для аспектов Rails моделирования данных (таких как has_many ассоциации, которые мы видели в Разделе 2.3.3 и больше раскроем в Разделе 10.1.3).

Мы потратили много времени на понимание строк, и есть естественный способ перейти от строк к массивам, используя split метод:

>>  "foo bar     baz".split     # Разбиение строки на трех-элементный массив.
=> ["foo", "bar", "baz"]

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

>> "fooxbarxbazx".split('x')
=> ["foo", "bar", "baz"]

Как это принято в большинстве языков программирования, Ruby массивы — нулевого сдвига, что означает, что первый элемент массива имеет индекс 0, второй имеет индекс 1, и так далее:

>> a = [42, 8, 17]
=> [42, 8, 17]
>> a[0]               # Ruby использует квадратные скобки для доступа к массиву.
=> 42
>> a[1]
=> 8
>> a[2]
=> 17
>> a[-1]              # Индексы могут быть даже отрицательными!
=> 17

Мы видим здесь что Ruby использует квадратные скобки для доступа к элементам массива. В дополнение к этой скобковой записи, Ruby предлагает синонимы для некоторых часто используемых элементов:^{5Second метод, используемый здесь, не является в настоящий момент частью Ruby непосредственно, а скорее добавляется Rails. Это работает в данном случае, потому что консоль Rails автоматически включает Rails расширения в Ruby}

>> a                  # Просто напоминание о том что такое 'a'
=> [42, 8, 17]
>> a.first
=> 42
>> a.second
=> 8
>> a.last
=> 17
>> a.last == a[-1]    # Сравнение с помощью ==
=> true

Последняя строка вводит оператор проверки на равенство ==, который Ruby разделяет со многими другими языками, наряду со связанным != ("не равно"), и т.д.:

>> x = a.length       # Как и строки, массивы отвечают на метод 'length'.
=> 3
>> x == 3
=> true
>> x == 1
=> false
>> x != 1
=> true
>> x >= 1
=> true
>> x < 1
=> false

В дополнение к length (первая строка в приведенном выше примере), массивы отвечают на множество других методов:

>> a
=> [42, 8, 17]
>> a.sort
=> [8, 17, 42]
>> a.reverse
=> [17, 8, 42]
>> a.shuffle
=> [17, 42, 8]
>> a
=> [42, 8, 17]

обратите внимание на то, что ни один из вышеприведенных методов не меняет саму a. Для того, чтобы изменить массив, используется соответствующие "бэнг" методы (названные так потому что восклицательный знак обычно произносится как "бэнг" в этом контексте):

>> a
=> [42, 8, 17]
>> a.sort!
=> [8, 17, 42]
>> a
=> [8, 17, 42]

Вы также можете добавлять данные в массивы с помощью push (# отправить, толкнуть) метода или эквивалентного ему оператора, <<:

>> a.push(6)                  # Отправка 6 в массив
=> [42, 8, 17, 6]
>> a << 7                     # Отправка 7 в массив
=> [42, 8, 17, 6, 7]
>> a << "foo" << "bar"        # Сцепление отправляемых в массив данных
=> [42, 8, 17, 6, 7, "foo", "bar"]

Последний пример показывает что вы можете сцеплять добавления вместе, а также, что, в отличие от массивов во многих других языках, Ruby массивы могут содержать смесь различных типов (в данном случае, целые числа и строки).

Прежде мы видели что split преобразовывает строку в массив. Мы также можем пойти другим путем с join методом:

>> a
=> [42, 8, 17, 7, "foo", "bar"]
>> a.join                       # Объединение без ничего.
=> "428177foobar"
>> a.join(', ')                 # Объединение через запятую.
=> "42, 8, 17, 7, foo, bar"