Курс по Ruby+Rails. Часть 1. Императивное программирование / Хабр

Введение от автора

«У множества языков есть веб-фреймворки, но Rails есть только у Ruby».

Кирилл Мокевнин, основатель Hexlet

Перешедший из весовой категории «новенький и блестящий» в ранг «проверенный временем и надёжный», Ruby упорно не желает отправляться в рай для красивых языков программирования.

Он сочетает в себе структурный, объектный и функциональный стили программирования, обладает лаконичным синтаксисом и ясными грамматиками, построен по «принципу наименьшего удивления». Ruby позволяет воплощать в изящном и легко читаемом коде любые изыски алгоритмической и технологической мысли.

Огромное количество накопленного в книгах по Ruby-разработке теоретического и практического знания позволяет использовать язык во множестве решений — от преподавания программирования и теории вычислений в вузах до промышленного программирования веб-сервисов и ERP-систем. Фреймворк Ruby on Rails год за годом остаётся одним из флагманов веб-разработки. Он позволяет собирать системы разного уровня сложности — от личного блога до гетерогенных микросервисных платформ. Опираясь на свойства Ruby как языка, компоненты и инструменты Rails делают разработку сложных веб-сервисов технологичным и эффективным процессом, в котором уютно себя чувствует и разработчик, и менеджер.

Компания Evrone работает на рынке веб-разработки уже 13 лет. Ruby on Rails — одна из технологий, которую мы используем часто, поэтому накопили внушительный багаж знаний — от продвинутых приёмов программирования на Ruby до эффективного использования «магии» Rails. Чтобы делиться этими знаниями, мы запускали в тестовом режиме Evrone Academy — платформу для обучения программированию. Сейчас она на паузе, но мы хотим публично поделиться лекциями и знаниями с теми, кто хочет поближе познакомиться с Ruby уже сейчас, в привычной хабра-обстановке.

Этот курс рассчитан на тех, у кого уже есть базовые навыки и знания в области структурного и объектно-ориентированного программирования. Это ваш «второй курс» по Ruby on Rails.

Он начинается с обзора продвинутых свойств Ruby в трёх основных стилях программирования — структурно-императивном, объектно-ориентированном и функциональном. Затем мы перейдём к разработке на фреймворке Ruby on Rails — начнём с введения в его фундаментальные концепции, компоненты и их свойства, разберем инструменты и библиотеки, важные в повседневной практике, и пройдёмся по продвинутым техникам, высокотехнологичным приёмам и архитектурным паттернам.

Надеюсь, с нашим курсом вам не будет скучно.

Павел Аргентов

Ruby Lead и ментор в Evrone, автор курса

Текстовая версия

Различают несколько основных стилей программирования: 

В Ruby можно использовать любой из них, потому что Ruby — чистый объектно-ориентированный язык, в которым любые объекты можно наделить любым поведением, нужным в конкретной программе. Сегодня мы поговорим про самый простой, императивный стиль программирования.

В этом стиле мы последовательно приказываем машине, что и в какой последовательности мы хотим делать. Например — «выведи что-то в консоль, а теперь сделай то-то». В этом случае машина последовательно исполняет инструкции, которые мы подготовили и описали. На примере видим инструкцию «выведи в консоль Hello World»:

puts 'Hello world!'
puts 'Hello world!'
puts 'И Вы, программист, тоже здравствуйте'

Инструкций может быть много, они могут помещаться  на разных строках или на одной и той же, но тогда их надо разделять точкой с запятой:

puts 'Hello world!'; puts 'Прекрасная погодка нынче!'

Ruby — умный язык. Всегда, в том числе когда мы работаем в нём в самом простом стиле, он воспринимает текст программы как комбинацию выражений. Все приведенные ранее примеры — это выражения. Они отличаются от инструкций тем, что язык не только исполняет прямые указания, но и вычисляет. Каждое выражение порождает какие-то значения, возвращает какой-то результат. Проще всего это увидеть в интерактивной оболочке Ruby:

[1] pry(main)> puts 'Hello world!'
Hello world!
=> nil

Выполненное выражение напечатало нужное сообщение в консоль, а ещё вычислило значение

nil — пустой объект. Можете поэкспериментировать с интерактивным режимом на своей машине и посмотреть, как Ruby выполняет разные выражения.

Технически, всё в Ruby — это выражения, даже если они ведут себя как инструкции и возвращают пустой объект — nil. Сейчас для нас это не особенно важно, но мы вернёмся к этому в следующих уроках, когда будем разбирать более сложный код. 

Теперь поговорим о переменных. Переменную можно представить себе как контейнер, куда программа помещает какое-то значение и работает с ним: хранит, изменят, передаёт для выполнения различных операций. В следующем примере две переменные: a и b. То что написано слева от оператора присваивания — это имя переменной. Справа — значение переменной.

Мы связали значение 42 с переменной a и значение 21 с переменной b:

a = 42
b = 21

Переменные могут участвовать в вычислениях. Например — «возьми значение переменной a и сложи со значением переменной b, а результат запиши в переменную c»:

c = a + b

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

а:

str = "Ответ на Главный вопрос жизни, вселенной и всего такого: #{a}"

Переменные можно использовать для передачи значений в методы. Например, мы в метод puts передаём значение переменной str: 

[4] pry(main)> puts str
Ответ на Главный вопрос жизни, вселенной и всего такого: 42
=> nil

Имена пишутся латиницей. Они регистрочувствительны. Две переменные a и A

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

Имя переменной не может начинаться с цифры, но может начинаться со знака подчёркивания. Если имя переменной начинается с большой буквы, то Ruby будет считать такую переменную константой. Кроме переменных именами обладают модули, классы, методы. Если имя переменной состоит из несколько слов, эти слова принято разделять знаком _. В именах констант для этого принято использовать «camel case», когда слова пишутся без пробелов, но все с большой буквы. Если все буквы имени заглавные, слова разделяют при помощи _:

long_variable_name

_this_variable_i_will_not_use

LongClassNameForWhichTheColleaguesWillHateYou

CONSTANT_IS_STATIC

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

@foo  # переменная экземпляра

@@bar # переменная класса

$baz  # глобальная переменная

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

Методами в Ruby называется то, что в других языках называют функциями. Отличие методов от функций в том, что методы всегда «прикрепляются» к какому-то объекту. В этом особенность Ruby как чистого объектного языка. В нём любое выражение обозначает либо объект, либо вызов методов объекта. 

Для примера определим простую функцию с названием function в интерактивном режиме и посмотрим, как она будет себя вести:

[5] pry(main)> def function(parameter)
[5] pry(main)*   parameter * 3.
 
 1415926
[5] pry(main)* end
=> :function

Мы объявили некоторую функцию с названием function, определили у неё один параметр, и умножаем этот параметр на короткую версию числа Пи. После передаём какой-то аргумент в эту функцию — пишем function, передаём пятёрку и получаем некий результат на выходе:

[6] pry(main)> function(5)
=> 15.707963

В следующем примере мы берём переменную object и связываем её с объектом self, который сейчас обозначает «контекст исполнения программы». Мы говорим: вызови метод function

текущего контекста:

[7] pry(main)> object = self
=> main
[8] pry(main)> object.function(8)
=> 25.1327408

В Ruby также можно определить особые методы, которые ведут себя как самостоятельные объекты, но это мы рассмотрим в рамках отдельной лекции. А сейчас повторим, как объявить метод. Мы пишем имя метода, описываем параметры, пишем тело. метод можно вызвать, а результат его выполнения — передать в другой метод и т. д. При описании параметров и при вызове метода можно опускать круглые скобки, но и в этом случае нужно разделять параметры/аргументы запятыми: 

def quadruple(parameter)
  parameter * 4
end
quadruple(8)
# => 32
def multiply a, b
  a * b
end
multiply 2, 2
# => 4

Методам можно задавать параметры по умолчанию. В следующем примере второй параметр метода multiply примет значение 1, если его не передадут при вызове. В примере мы передали только четвёрку, но если бы мы передали 4-запятая-2 то второй параметр был бы двойкой, вместо единицы:

# параметр со значением по умолчанию
def multiply(x, multiplier = 1)
  x * multiplier
end
multiply 4
# => 4

Также в Ruby существуют именованные параметры. Для них также возможно задание значений по умолчанию:

# именованный параметр
def greeting(name: 'Nobody')
  "Aloha #{name}"
end
greeting
# => "Aloha Nobody"
greeting(name: "Arthur")
# => "Aloha Arthur"

Отдельно отметим отличие терминов «параметры» и «аргументы». То, что мы описываем в коде функции, принято называть параметрами. То, что передаём при вызове — аргументами.

В приведённых примерах нет оператора return в конце метода. Это иллюстрация того, как Ruby работает с выражениями. Метод — частный случай составного выражения. В Ruby значением составного выражения является значение последнего подвыражения. Такое свойство позволяет программисту компактнее выражать свои мысли, а языку — однородно работать с возвратами из методов в ситуациях различной сложности.

Оператор return использовать не запрещено, но использование его в конце метода — плохой стиль. Хороший стиль — использовать return в так называемых защитных выражениях, для «раннего возврата» из метода:

def safe_divide(a, b)
  return Nothing if b == 0
  Some(a / b)
end

Если у оператора return нет аргументов, возвращается nil, то есть пустой объект. Метод с пустым телом в следующем примере тоже возвращает nil как результат своего выполнения.

Обратите внимание, что само объявление метода — это также выражение, значением которого является имя этого метода в особом виде — символ:

def fun
end
# => :fun

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

z = gets.to_i
# ветвление в одну строку
a = if z > 0 then z else 42 end
# простой if
if z == 4
  puts 'FOUR'
end
# полный if-else
if z == 42
  puts 'The Answer is correct!'
else
  puts 'The Answer is incorrect'
end
# выражение с модификатором
puts("Negative number #{z}") if z < 0
# тернарный оператор
z > 0 ? :ok : :not_ok
# case-выражение
resolution = case z
             when 100_500 then :foo
             when 42 then :oops
             when 1 then :smol
             else :no_way
             end

Ruby как и многие другие языки программирования, поддерживает циклы. Их можно объявить с помощью слов while и for. Попробуйте выполнить этот пример самостоятельно и порассуждать, как он работает:

n = 0
ns = []
while n < 100 do
  ns << n if n.odd?
  n += 1
end
is = 0
for i in 0..100_500
  is += 25 if i % 5 == 0
end

Также в качестве управляющего выражения можно встретить составные выражения. В качестве границ составного выражения можно использовать круглые скобки либо begin и end, как в примере:

x = begin
  b = 1
  a = 2
  b + a
end
# => 3 

Особенность Ruby — возможность описывать повторяющиеся вычисления в виде блоков, которые являются свойством сложных объектов — итераторов. Блок — это одно или несколько выражений, заключённых между словами do и end или фигурными скобками:

[32] pry(main)> 5.times do |i|
[32] pry(main)*   puts "This is iteration #{i}"
[32] pry(main)* end
This is iteration 0
This is iteration 1
This is iteration 2
This is iteration 3
This is iteration 4
=> 5

В блоках можно описывать параметры, в виде списка в вертикальных скобках. Блок — это одна из главных суперспособностей Ruby. Мы часто будем видеть блоки в разбираемых примерах. 

В Ruby есть специальный механизм прерывания вычислений. Это исключения. Исключения — это особые объекты, несущие информацию о точке прерывания вычислений. Их можно активировать произвольно из любого участка кода. Также мы можем их перехватывать и обрабатывать.

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

# Необработанное исключение
[1] pry(main)> puts "I am your father!"
I am your father!
=> nil
[2] pry(main)> raise "NOOOOOOOOOOO!!!"
RuntimeError: NOOOOOOOOOOO!!!

На следующем примере видно активацию, перехват и обработку исключения.

# Исключение с обработчиком
def luke(vaders_phrase)
  raise "NOOOOOO!!!" if vaders_phrase == "I am your father!"
  puts "Luke keeps hanging on"
rescue => e
  puts "Team saves Luke after #{e}"
end
[4] pry(main)> luke "Hang on!"
Luke keeps hanging on
[5] pry(main)> luke "I am your father!"
Team saves Luke after NOOOOOO!!!

Наш обзор императивных свойств языка Ruby мы закончим областями видимости переменных. Понимание областей видимости — это важный элемент рассуждения о программе — для программиста, мощный инструмент управления процессом вычислений — для машины.

Область видимости переменной — это регион программы, в котором возможно её использование. Ранее мы упоминали, существуют особые знаки, которые управляют областями видимости переменных:

@foo  # переменная экземпляра: определяется в цикле жизни экземпляра

@@bar # переменная класса: определяется для всего класса

$baz  # глобальная переменная: видна во всей программе

В первой строке — пример объявления переменной экземпляра класса, которая доступна только в рамках текущего, конкретного экземпляра класса. Она объявляется с помощью @ перед названием переменной. С помощью @@ объявляются переменные класса, которые доступны во всех экземплярах класса. С помощью $ перед названием переменных объявляются и используются глобальные переменные, которые доступны в любом участке вашего кода.  

Глобальных переменных следует избегать. Они способны значительно затруднить понимание и выполнение программы. Если переменная может быть объявлена в одном месте, использоваться в другом, изменяться в третьем — будет очень сложно контролировать такую программу.

Переменные экземпляра класса являются автоматическими. Их можно использовать без объявления. Значением неинициализированной переменной экземпляра класса является nil. 

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

Управляющие выражения не создают локальные области видимости. В примере мы видим, метод scope_test, внутри которого объявляется переменная а; мы можем вызвать метод scope_test и получить то, во что вычислилось последнее выражение этого метода, однако а не будет видно «снаружи» и в этом месте мы получим исключение:

def scope_test
  a = 100
end
scope_test
# => 100
a
# => NameError: undefined local variable or method `a' . ..

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

5.times do |i|
  puts "Iteration #{i}"
  d = i
end
d
# => NameError: undefined local variable or method `d' ...

Локальная область видимости распространяется на локальные области, вложенные в неё. Если во вложенных областях видимости присвоить значение переменной которая совпадает с именем переменной, определённой во внешней локальной области — произойдёт изменение внешней переменной. При определении блоков либо методов, параметры которых одноимённы переменным или методам во внешней локальной области видимости, происходит так называемое затенение переменной:

a = 34
5.times do |i|
  a += i       # мутируется внешняя переменная `a`
  p [i, a]
end
a
# => 44

За редким исключением, затенение считается плохим стилем, так как является потенциальным источником ошибок. В примере наглядно видно, как работает затенение: есть переменная bool, которая описана во внешней области видимости со значением false, и есть какой-то блок, внутри которого есть параметр блока с таким же названием, bool:

bool = false
bools.each do |bool|  # формируется затенение
  if func(bool) == 42
    bool = true       # мутируется внутренняя переменная блока
  end
end
bool                  # => false : внешняя переменная не изменилась

В данном случае присвоение переменной значения true, никак не влияет на переменную во внешнем контексте, соответственно bool во внешней области видимости так и останется связанным со значением false.

Вот второй пример: есть метод или класс с некоторым именем и метод, в котором определён параметр с таким же именем; этот параметр не будет относится к методу, который мы объявили выше:

def zero
  0
end
def add3(zero) # затенение
  zero + 3     # используется локальная переменная, а не внешний метод
end
zero
# => 0
add3(8)
# => 11

В императивном стиле программа воспринимается как «глупый» вычислитель, выполняющий последовательность инструкций в порядке ввода. На протяжении курса мы увидим, что Ruby гораздо умнее, и наши программы на нём могут быть совсем не глупыми.

Основы ​программирования на Ruby. Что такое Ruby? | by Андрей Шагин | NOP::Nuances of Programming

Что такое

Ruby?

Ruby — это чистый объектно-ориентированный язык программирования. Чаще всего он используется для создания веб-приложений. Фреймворк для разработки приложений Ruby on Rails — первая реализация Ruby, которая приходит на ум.

Ruby — это динамичный язык программирования с открытым исходным кодом. Акцент здесь сделан на простоте и производительности.

У Ruby элегантный синтаксис, естественный для чтения и легкий для написания.

Первым делом напишем простую программу на Ruby. Все файлы здесь имеют расширение .rb. Поместим в файл example.rb следующий исходный код:

puts "Hello, I'm learning Ruby Programming!";

Теперь предположим, у нас в каталоге есть интерпретатор Ruby. Попробуем запустить программу:

$ ruby example. rb

Результат выполнения будет такой:

Hello, I'm learning Ruby Programming!

Переменные в Ruby

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

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

для целого числа:
синтаксис: variable_name = value 
пример: a = 5для числа с плавающей точкой:
синтаксис: variable_name = value 
пример: a = 10.5для строки:
синтаксис: variable_name = "value" 
пример: a = "abc"

Типы переменных в Ruby

Существует пять типов переменных:

1. Константы.
2. Глобальная переменная.
3. Переменная класса.
4. Переменная экземпляра.
5. Локальная переменная.
  1. Пример объявления константы:
a = "This is my book."

2. Пример объявления глобальной переменной (используется символ $):

$var = 'I love my-self'

3. Пример объявления переменной класса (используется символ @@):

@@instances = 0

4. Пример объявления переменной экземпляра (используется символ @):

@var = 'Ruby Programming'

5. Пример объявления локальной переменной:

Локальные переменные — самые распространенные, они не выходят за рамки области видимости. Эти переменные объявляются без использования перед именем переменной символов $ или @, при этом имя переменной не должно быть целиком заглавными буквами.

var = 10

Получение данных от пользователя

Один из способов получения информации от пользователя — вызов метода gets.

gets — это сокращение от get string («получить строку»). Когда задействуется этот метод, программа ждет от пользователя 1) ввода информации и 2) нажатия клавиши Enter. Вот пример:

>> a = gets
demo
>> "demo\n"

Ввели код a = gets, дальше компьютер ожидает введения какой-то информации. Вводим demo, затем нажимаем на Enter, и программа возвращает "demo\n".

\n на конце — это символ новой строки, обозначающий клавишу Enter. Но здесь в строке он не нужен. Чтобы от него избавиться, используется chomp, присоединенный к gets с помощью точки. Этот .chomp ставится в конце любой строки для удаления символов возврата каретки.

>> a = gets.chomp
demo
>> "demo"

Пример:

>> puts 'Enter value for a : '
>> a = gets.chomp.to_i
>> puts 'Enter value for b: '
>> b = gets.chomp.to_i
>> c = a + b
>> puts "Sum : #{c}"вывод:
Enter value for a : 
10
Enter value for a : 
20
Sum = 30

Методы

Что такое метод/функция?

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

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

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

Синтаксис:

def method_name 
expr..
end

Всякий раз, когда вызывается простой метод, пишется только название метода:

method_name

Пример:

def demo(a1 = "Ruby", a2 = "programming")
puts "This is #{a1}"
puts "This is #{a2}"
end
test "C", "C++"
testвывод:This is C
This is C++
This is Ruby
This is programming

Дата и время в Ruby

В Ruby даты и время представляет класс Time.

Получение текущей даты и времени:

Пример:

time = Time. newputs "Current Time : " + time.inspect
puts time.year    # => Год даты 
puts time.month   # => Месяц даты (с 1 по 12)
puts time.day     # => День даты (с 1 по 31)
puts time.wday    # => 0: День недели (0 — это воскресенье)
puts time.yday    # => 365: День года
puts time.hour    # => 23: 24-часовой формат
puts time.min     # => 59
puts time.sec     # => 59
puts time.usec    # => 999999: микросекунды
puts time.zone    # => "UTC": название часового поясавывод:Current Time : Mon Jun 02 12:03:08 -0700 2008
2021
7
2
1
154
12
3
8
247476
UTC

Массив

Что такое «массив»?

В программировании массив — это коллекция различных типов данных в одном контейнере или переменной.

Массив создается или инициализируется множеством способов. Один из них — с помощью метода класса new:

names = Array.new

Размер массива задается во время создания массива:

names = Array. new(20)

Каждому элементу массива присваивается значение:

names = Array.new(4, "system")
puts "#{names}"вывод:["system", "system", "system", "system"]

new задействуется также с блоком:

nums = Array.new(10) { |e| e = e * 2 }
puts "#{nums}"вывод:[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

Есть еще один метод массива []. Вот как он работает:

nums = Array.[](1, 2, 3, 4,5)

И еще одна форма создания массива:

nums = Array[1, 2, 3, 4,5]

Здесь для создания массива цифр метод в качестве аргумента принимает диапазон:

digits = Array(0..9)
puts "#{digits}"вывод:[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Читайте также:

  • Разбор методов Ruby
  • Создание простого веб-скрейпера на Ruby
  • Google OAuth для реализации на Ruby

Читайте нас в Telegram, VK и Яндекс.Дзен

О Ruby

Хотите знать, почему Ruby так популярен? Его поклонники называют его красивым, хитрым язык. А еще говорят, что это удобно и практично. Что дает?

Идеалы создателя Ruby

Ruby — это тщательно сбалансированный язык. Его создатель Юкихиро «Мац». Мацумото смешал части своих любимых языков (Perl, Smalltalk, Eiffel, Ada и Lisp), чтобы сформировать новый язык, сбалансированный функциональным императивное программирование.

Он часто говорил, что «пытается сделать Ruby естественным, а не простым». способом, который отражает жизнь.

Опираясь на это, он добавляет:

Ruby прост на вид, но очень сложен внутри, как и наше человеческое тело 1 .

О росте Ruby

С момента своего публичного выпуска в 1995 году Ruby привлекает преданных программистов Мировой. В 2006 году Ruby добился массового признания. С активным пользователем группы, сформированные в крупных городах мира, и конференции, связанные с Ruby заполнен до отказа.

Ruby-Talk, основной список рассылки для обсуждение языка Ruby, поднялось в среднем до 200 сообщений в день в 2006 году. В последние годы он снизился, поскольку размер сообщество переместило обсуждение из одного центрального списка во множество более мелких группы.

Рубин входит в первую десятку по большинству индексов, измеряющих рост и популярность языков программирования во всем мире (например, индекс TIOBE). Большая часть роста связана с популярность программного обеспечения, написанного на Ruby, особенно Веб-фреймворк Ruby on Rails.

Ruby также полностью бесплатен. Не только бесплатно, но и также бесплатно использовать, копировать, изменять и распространять.

Восприятие всего как объекта

Сначала Мац изучал другие языки, чтобы найти идеальный синтаксис. Вспоминая свои поиски, он сказал: «Я хотел язык сценариев, который более мощный, чем Perl, и более объектно-ориентированный, чем Питон 2 ».

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

 5.times { print "Мы *любим* Ruby -- это возмутительно!" }

Во многих языках числа и другие примитивные типы не являются объектами. Ruby следует влиянию языка Smalltalk, предоставляя методы и переменные экземпляра для всех его типов. Это облегчает использование Ruby, поскольку правила, применяемые к объектам, применяются ко всему Ruby.

Гибкость Ruby

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

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

 класс Числовой
  защита плюс (х)
    я.+(х)
  конец
конец
у = 5, плюс 6
# y теперь равно 11

Операторы Ruby — это синтаксический сахар для методов. Вы можете переопределить их также.

Блоки: по-настоящему выразительная функция

Блок Ruby также рассматривается как источник большой гибкости. А программист может прикрепить замыкание к любому методу, описывая, как это метод должен действовать. Закрытие называется блоком и стало одним из самые популярные функции для новичков в Ruby из других императивных таких языков, как PHP или Visual Basic.

Блоки вдохновлены функциональными языками. Мац сказал: «В рубиновом замыкания, я хотел уважать культуру Лиспа 3 ».

 поисковые_движки =
  %w[Google Yahoo MSN].map do |engine|
    "http://www." + engine.downcase + ".com"
  end

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

Ruby и Mixin

В отличие от многих объектно-ориентированных языков, Ruby поддерживает одиночное наследование только, специально . Но Ruby знает концепцию модулей (называемых Категории в Objective-C). Модули — это наборы методов.

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

 класс MyArray
  включить перечисляемый
end

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

Внешний вид Руби

В то время как Руби часто использует очень ограниченную пунктуацию и обычно предпочитает Английские ключевые слова, некоторые знаки препинания используются для украшения Ruby. Руби нуждается нет объявлений переменных. Он использует простые соглашения об именах для обозначения область действия переменных.

  • var может быть локальной переменной.
  • @var — это переменная экземпляра.
  • $var — это глобальная переменная.

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

Beyond the Basics

Ruby имеет множество других функций, среди которых следующие:

  • Ruby имеет функции обработки исключений, такие как Java или Python, чтобы сделать его легко обрабатывать ошибки.

  • Ruby содержит настоящий сборщик мусора с пометкой и очисткой для всех Ruby. объекты. Нет необходимости поддерживать счетчики ссылок в библиотеках расширений. Как говорит Мац: «Это лучше для вашего здоровья».

  • Написание расширений C на Ruby проще, чем на Perl или Python, с очень элегантный API для вызова Ruby из C. Сюда входят вызовы встраивание Ruby в программное обеспечение для использования в качестве языка сценариев. SWIG интерфейс тоже есть.

  • Ruby может динамически загружать библиотеки расширений, если это позволяет ОС.

  • Ruby поддерживает независимую от ОС поточность. Таким образом, для всех платформ на которой работает Ruby, у вас также есть многопоточность, независимо от того, работает ли ОС. поддерживает это или нет, даже в MS-DOS!

  • Ruby обладает высокой переносимостью: он разработан в основном для GNU/Linux, но работает на многих типах UNIX, macOS, Windows, DOS, BeOS, OS/2 и т. д.

Другие реализации Ruby

Ruby как язык имеет несколько различных реализаций. На этой странице обсуждалась эталонная реализация в сообщество, часто называемое MRI («Ruby Interpreter Матца») или CRuby (поскольку он написан на C), но есть и другие. Они часто бывают полезны в определенных ситуациях, предоставляют дополнительные интеграция с другими языками или средами или специальные функции этого МРТ нет.

Вот список:

  • JRuby — это Ruby поверх JVM (виртуальная машина Java), использующий JVM оптимизирует JIT-компиляторы, сборщики мусора, параллельные потоки, экосистема инструментов и обширная коллекция библиотек.
  • Рубиний — это «Рубин, написанный на Руби». Построен на основе LLVM, Rubinius использует изящную виртуальную машину, которую используют другие языки. построен сверху тоже.
  • TruffleRuby — это высокопроизводительная реализация Ruby поверх ГраальВМ.
  • mruby — облегченная реализация языка Ruby. которые могут быть связаны и встроены в приложение. Его разработкой руководит создатель Ruby Юкихиро «Мац» Мацумото.
  • IronRuby — это реализация, «тесно интегрированная с .NET Рамки».
  • MagLev — это «быстрая, стабильная реализация Ruby со встроенным постоянство объектов и распределенный общий кеш».
  • Cardinal — это «компилятор Ruby для виртуальной машины Parrot». (перл 6).

Более полный список см. в разделе Удивительные рубины.

Ссылки

1 Мац, выступая в списке рассылки Ruby-Talk, 12 мая, 2000.

2 Мац, в интервью с создателем Ruby, ноябрь. 29-го числа 2001 г.

3 Мац, Блоки и Замыкания на Руби, 22 декабря, 2003.

Рубин за двадцать минут

1 | 2 | 3 | 4

Введение

Это небольшое руководство по Ruby, которое займет не более 20 минут. завершить. Предполагается, что у вас уже установлен Ruby. (Если у вас нет Ruby на вашем компьютере, установите его прежде чем начать.)

Интерактивный Ruby

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

Откройте IRB (расшифровывается как Interactive Ruby).

  • Если вы используете macOS , откройте Terminal и введите irb , затем нажмите Enter.
  • Если вы используете Linux , откройте оболочку и введите irb и попал войти.
  • Если вы используете Windows , откройте Interactive Ruby из Рубиновый раздел вашего меню «Пуск».
 irb(main):001:0>

Итак, он открыт. Что теперь?

Введите это: "Hello World" 

 irb(main):001:0> "Hello World"
=> "Hello World"

Руби повиновалась тебе!

Что только что произошло? Мы только что написали самое короткое в мире «Hello World»? программа? Не совсем. Вторая строка — это просто способ, с помощью которого IRB сообщает нам результат последнего вычисленного выражения. Если мы хотим распечатать «Hello World» нам нужно немного больше:

 irb(main):002:0> помещает "Hello World"
Привет, мир
=> nil

ставит — это основная команда для вывода чего-либо в Ruby. Но потом что такое => ноль бит? Это результат выражения. ставит всегда возвращает nil, что является значением Ruby «абсолютно положительно-ничего».

Ваш бесплатный калькулятор здесь

Уже достаточно, чтобы использовать IRB в качестве базового калькулятора:

 irb(main):003:0> 3+2
=> 5

Три плюс два. Достаточно легко. Как насчет трех умножить на два? Ты мог введите его, он достаточно короткий, но вы также можете подняться и изменить то, что вы только что ввели. Попробуйте нажать стрелку вверх на вашем клавиатуру и посмотреть, выводит ли она строку с 3+2 на ней. Если это так, вы можете использовать клавишу со стрелкой влево для перемещения сразу после знака + , а затем используйте Backspace, чтобы изменить его на знак * .

 ирб(основной):004:0> 3*2
=> 6

Далее попробуем три в квадрате:

 irb(main):005:0> 3**2
=> 9

В Ruby ** — это то, как вы говорите «в силу». Но что, если вы хотите пойти другим путем и найти квадратный корень из чего-то?

 irb(main):006:0> Math.sqrt(9)
=> 3.0

Хорошо, подождите, что это было последнее? Если вы догадались, «это выясняло квадратный корень из девяти», вы правы. Но давайте поближе познакомимся вещи. Прежде всего, что такое Math ?

Код группы модулей по темам

Математика — встроенный модуль для математики. Модули выполняют две роли в Рубин. Это показывает одну роль: группировка похожих методов вместе под знакомое имя. Math также содержит такие методы, как sin() и tan() .

Далее точка. Что делает точка? Точка — это то, как вы определяете получатель сообщения. Что за сообщение? В данном случае это sqrt(9) , что означает вызов метода sqrt , сокращение от «квадратный корень» с параметр 9 .

Результатом вызова этого метода является значение 3.

No related posts.