Почему ruby

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

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

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

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

Приоритет операторов Ruby

В следующей таблице перечислены все операторы от наивысшего приоритета до самого низкого.

метод	оператор	Описание
да	::	Оператор с постоянным разрешением
да	=	Ссылка на элемент, набор элементов
да	**	Экспоненциация (повышение до власти)
да	! ~ + –	Не, дополнение, унарный плюс и минус (имена методов для последних двух – + @ и – @)
да	* /%	Умножьте, разделите и по модулю
да	+ –	Сложение и вычитание
да	>> <<	Правый и левый побитовый сдвиг
да	&	Побитовое “AND”
да	^ |	Побитовое эксклюзивное `OR ‘и регулярное` OR’
да	<= <>> =	Операторы сравнения
да	<=> == ===! = = ~ !~	Операторы равенства и соответствия шаблонов (! = И! ~ Не могут быть определены как методы)
	&&	Логический ‘AND’
	||	Логический ‘OR’
	.. …	Диапазон (включительно и эксклюзивно)
	? :	Тройное if-then-else
	= %= { /= -= += |= &= >>= <<= *= &&= ||= **=	присваивание
	defined?	Проверьте, установлен ли указанный символ
	not	Логическое отрицание
	or and	Логическая композиция

Примечание
Операторы с Yes в столбце метода являются фактически методами и как таковые могут быть переопределены.

Исключения

Возникает исключение с вызовом:

raise

К исключению можно добавить необязательное сообщение:

raise "This is a message"

Исключения также могут быть указаны программистом:

raise ArgumentError, "Illegal arguments!"

В качестве альтернативы в метод можно передать экземпляр исключения :

raise ArgumentError.new("Illegal arguments!")

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

class ParseError < Exception
 def initialize(input, line, pos)
 super "Could not parse '#{input}' at line #{line}, position #{pos}"
 end
end

raise ParseError.new("Foo", 3, 9)

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

begin
 # do something
rescue
 # handle exception
else
 # do this if no exception was raised
ensure
 # do this whether or not an exception was raised
end

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

begin
 # do something
rescue Exception
 # Exception handling code here.
 # Don't write only "rescue"; that only catches StandardError, a subclass of Exception.
end

Или поймать определенные исключения:

begin
 # do something
rescue RuntimeError
 # handle only RuntimeError and its subclasses
end

Также можно указать, что объект исключения должен быть доступен для предложения обработчика:

begin
 # do something
rescue RuntimeError => e
 # handling, possibly involving e, such as "puts e.to_s"
end

В качестве альтернативы самое последнее исключение сохраняется в magic global .

Также можно отловить несколько исключений:

begin
 # do something
rescue RuntimeError, Timeout::Error => e
 # handling, possibly involving e
end

Логические операторы в Ruby

Язык Ruby поддерживает следующие логические операторы

Предположим, что переменная a имеет значение 10, а переменная b имеет значение 20, тогда:

оператор	Описание	пример
and	Вызывается логическим оператором AND. Если оба операнда верны, тогда условие становится истинным.	(a и b) верно.
or	Вызывается логическим оператором ИЛИ. Если какой-либо из двух операндов не равен нулю, то условие становится истинным.	(a или b) истинно.
&&	Вызывается логическим оператором AND. Если оба операнда не равны нулю, условие становится истинным.	(a && b) истинно.
||	Вызывается логическим оператором ИЛИ. Если какой-либо из двух операндов не равен нулю, то условие становится истинным.	(a || b) истинно.
!	Вызывается логическим оператором NOT. Используется для изменения логического состояния операнда. Если условие истинно, то логический оператор NOT сделает ложным.	! (a && b) является ложным.
not	Вызывается логическим оператором NOT. Используется для изменения логического состояния операнда. Если условие истинно, то логический оператор NOT сделает ложным.	not (a && b) является ложным.

методы

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

Используйте def с круглыми скобками, когда есть параметры. Опустите скобки, когда метод не принимает никаких параметров.

Не используйте аргументы по умолчанию. Вместо этого используйте хэш опций.

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

Используйте скобки для вызова метода:

Если метод возвращает значение.

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

Никогда не ставьте пробел между именем метода и открывающей скобкой.

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

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

В любом случае:

Если метод принимает хэш опций в качестве последнего аргумента, не используйте {} во время вызова.

Где используется Ruby и что такое Ruby on Rails?

У Ruby есть ниша, в которой этот язык программирования используется чаще всего — это веб-разработка.

Ruby стал популярным языком для создания веб-приложений благодаря фреймворку Ruby on Rails. Этот фреймворк был представлен в 2005 году. В «рельсах» реализованы инновационные возможности, включая бесшовную интеграцию с базой данных, миграции, создание представлений для ускорения разработки. Эти возможности позднее были внедрены в других фреймворках, включая Django, Laravel и Phoenix.

Однако Ruby применяется не только в веб-разработке. На Ruby написаны утилита командной строки Homebrew, ПО для обеспечения информационной безопасности Metasploit, ПО для создания виртуальной среды разработки Vagrant и другие известные приложения. 

Ruby on Rails 4: Getting Started (Pluralsight)

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

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

Особенности:

• все концепции для начального уровня тщательно объяснены;
• множество упражнений для закрепления знаний;
• для начала обучения не требуется никаких предварительных знаний;
• содержание курса и видео доступны бесплатно в течение первых десяти дней.

Особенности Crystal 1.0

• Статическая проверка типа позволяет компилятору обнаруживать ошибки, чтобы они не возникали во время выполнения.
• Встроенный вывод типов устраняет необходимость в большинстве аннотаций.
• Специальный синтаксис для вызова собственных библиотек избавляет от необходимости повторно реализовывать низкоуровневые задачи.
• Компилятор автоматически проверяет наличие пустых ссылок во время компиляции.
• Для параллелизма Crystal использует потоки, называемые волокнами, для связи друг с другом без использования общей памяти или блокировок.
• Библиотеки упакованы как Shards и распространяются через Git. Встроенные команды позволяют указывать зависимости через файл YAML и извлекать их из соответствующих репозиториев.
• Макросистема, состоящая из методов, которые получают узлы AST во время компиляции и создают код, служит ответом Crystal на метапрограммирование.
• Все типы в Crystal не допускают обнуления. Переменные, допускающие обнуление, представлены как объединение между типом и нулем. Как следствие, компилятор автоматически проверяет наличие нулевых ссылок во время компиляции.

Структуры данных — это просто функции

В неупрощенной версии Ruby мы на данном этапе, вероятно, создали бы класс или хотя бы Hash, но здесь у нас нет такой возможности. Можем ли мы создать реальную структуру данных, работая лишь с функциями? Оказывается, можем. Достаточно создать функцию, которая будет считать свой первый аргумент атрибутом нашей структуры данных:

new_person = ->(name,birthdate,gender,title,id=nil) {
  return ->(attribute) {
    return id        if attribute == :id
    return name      if attribute == :name
    return birthdate if attribute == :birthdate
    return gender    if attribute == :gender
    return title     if attribute == :title
    nil
  }
}

dave = new_person.("Dave","06-01-1974","male","Baron")
puts dave.(:name)   # => "Dave"
puts dave.(:gender) # => "male"

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

class Person
  attr_reader :id, :name, :birthdate, :gender, :title
  def initialize(name,birthdate,gender,title,id=nil)
    @id = id
    @name = name
    @birthdate = birthdate
    @gender = gender
    @title = title
  end
end

dave = Person.new("Dave","06-01-1974","male","Baron")
puts dave.name
puts dave.gender

Интересно. По размеру два предыдущих фрагмента кода почти одинаковы, но во второй версии (класс) полно специальных форм. Специальные формы — это магия, обеспечиваемая языком или средой времени исполнения. Чтобы понять этот код, необходимо знать:

• что означает class

• что при вызове new применительно к имени класса вызываются методы initialize

• каковы методы

• что если перед переменной стоит @, она становится приватной для экземпляра класса

• в чем заключается разница между классом и экземпляром

• что делает attr_reader

А в функциональной версии нужно знать всего лишь:

• как определить функцию

• как вызвать функцию

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

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

read_person_from_user = -> {
  puts "Name?"
  name = gets.chomp
  puts "Birthdate?"
  birthdate = gets.chomp
  puts "Gender?"
  gender = gets.chomp
  puts "Title?"
  title = gets.chomp

  new_person.(name,birthdate,gender,title)
}

add_person = ->(person) {
  return                   if String(person.(:name)) == ''
  return              if String(person.(:birthdate)) == ''
  return                 if String(person.(:gender)) == ''
  return  if person.(:gender) != 'male' &&
                                                      person.(:gender) != 'female'

  id = insert_person.(person.(:name),person.(:birthdate),person.(:gender),person.(:title))
  
}

get_new_person = -> {
  handle_result.(add_person.(read_person_from_user.()),
    ->(person) {
      puts "Successfully added person #{person.(:id)}"
      person
    },
    ->(error_message) {
      puts "Problem: #{error_message}"
      get_new_person.()
    }
  )
}

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

Особенность языка

Прелесть и сила Ruby в том, что в нём вообще всё — это объект. Даже числа, значения переменных и типы данных — это тоже объекты. Например, у вас есть сложение, которое реализуется так:

x = 7 + 5

7 и 5 — числа, за которые отвечает класс Numeric, и этот класс знает про знак сложения. Давайте немного расширим возможности этого класса:

С этого момента у всех чисел появляется метод plus, который складывает это число со вторым. И таким же способом можно расширить свойства и возможности каждого элемента в программе. Сделать автоматический перевод из минут в секунды? Легко:

И так можно делать с чем угодно, без ограничений и несовместимости типов. Да и какая может быть несовместимость, если типы — это тоже объекты, которые можно изменить. Это делает Ruby похожим на C++, где есть перегрузка операторов и возможность использовать команды не так, как задумано изначально.

Операторы defined? в Ruby

defined? является специальным оператором, который принимает форму вызова метода, чтобы определить, определено ли переданное выражение. Он возвращает строку описания выражения или nil, если выражение не определено.

Существуют различные варианты оператора defined?

Использование 1

defined? variable # True, если переменная инициализирована

Например

foo = 42
defined? foo    # => "local-variable"
defined? $_     # => "global-variable"
defined? bar    # => nil (undefined)

Использование 2

defined? method_call # True, если определен метод

Например

defined? puts        # => "method"
defined? puts(bar)   # => nil (bar is not defined here)
defined? unpack      # => nil (not defined here)

Использование 3

# True, если существует метод, который можно вызвать с помощью super user
defined? super

Например

defined? super     # => "super" (if it can be called)
defined? super     # => nil (if it cannot be)

Использование 4

defined? yield   # True, если передан блок кода

Например

defined? yield    # => "yield" (if there is a block passed)
defined? yield    # => nil (if there is no block)

Интерактивные сеансы

Следующие ниже примеры можно запустить в оболочке Ruby, такой как Interactive Ruby Shell , или сохранить в файле и запустить из командной строки путем ввода .

Классический пример Hello world :

puts 'Hello World!'

Некоторый базовый код Ruby:

# Everything, including a literal, is an object, so this works:
-199.abs # => 199
'ice is nice'.length # => 11
'ruby is cool.'.index('u') # => 1
"Nice Day Isn't It?".downcase.split('').uniq.sort.join
# => " '?acdeinsty"

Вход:

print 'Please type name >'
name = gets.chomp
puts "Hello #{name}."

Конверсии:

puts 'Give me a number'
number = gets.chomp
puts number.to_i
output_number = number.to_i + 1
puts output_number.to_s + ' is a bigger number.'

Что изучать дальше

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

• Hashes
• each b collect итераторы
• Модули
• И т.п.

Чтобы узнать об этих концепциях и многом другом, посетите бесплатный курс Educative Learn Ruby from Scratch. Этот вводный курс Ruby не требует предварительных условий и предоставляет вам практическую практику с переменными, встроенными классами, условными выражениями и многим другим. К концу курса вы узнаете основы самого влиятельного и востребованного языка программирования третьего поколения.

Коллекции

Построение и использование массива :

a = 3, 'hello', 14.5, 1, 2, 6, 15]]

a2 # => 14.5
a.[](2) # => 14.5
a.reverse # => , 2, 1, 14.5, 'hello', 3]
a.flatten.uniq # => 

Создание и использование ассоциативного массива (в Ruby, называемого хешем ):

hash = Hash.new # equivalent to hash = {}
hash = { water 'wet', fire 'hot' } # makes the previous line redundant as we are now
 # assigning hash to a new, separate hash object
puts hash:fire # prints "hot"

hash.each_pair do |key, value| # or: hash.each do |key, value|
 puts "#{key} is #{value}"
end
# returns {:water=>"wet", :fire=>"hot"} and prints:
# water is wet
# fire is hot

hash.delete :water # deletes the pair :water => 'wet' and returns "wet"
hash.delete_if {|key,value| value == 'hot'} # deletes the pair :fire => 'hot' and returns {}

Что такое 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

Предположим, что переменная a имеет значение 10, а переменная b имеет значение 20, тогда:

оператор	Описание	пример
=	Простой оператор присваивания, присваивает значения из правых операндов в левый операнд.	c = a + b присваивает значение a + b в c
+=	Оператор Add AND присваивает, добавляет правый операнд в левый операнд и присваивает результат левому операнду.	c + = a эквивалентно c = c + a
-=	Вычитает и присваивает оператор, вычитает правый операнд из левого операнда и присваивает результат левому операнду.	с – = а эквивалентно с = с – а
*=	Оператор умножения и присваивания, умножает правый операнд на левый операнд и присваивает результат левому операнду.	c * = a эквивалентно c = c * a
/=	Оператор Divide AND присваивает, делит левый операнд на правый операнд и присваивает результат левому операнду.	c / = a эквивалентно c = c / a
%=	Оператор модуля и присваивания, принимает модуль с использованием двух операндов и присваивает результат левому операнду.	c% = a эквивалентно c = c% a
**=	Оператор Exponent AND присваивает операторам экспоненциальный (энергетический) расчет и присваивает значение левому операнду.	c ** = a эквивалентно c = c ** a

Условные выражения

Условные ключевые слова:

Никогда не используйте тогда для многострочного, если / если.

• Запрещены ключевые слова и, или, а не ключевые слова. Это просто не стоит того. Всегда используйте &&, || и! вместо.
• Модификатор if /, если использование в порядке, когда тело простое, условие простое, и все это помещается в одну строку. В противном случае, избегайте модификаторов, если / если

Никогда не используйте, если не с другими. Перепишите их сначала в положительном случае.

Избегайте, если не с несколькими условиями.

Не используйте круглые скобки вокруг условия if / instance / while, если только условие не содержит присваивания (см. Использование возвращаемого значения = ниже).

Тернарный оператор:

Избегайте троичного оператора (? за исключением случаев, когда все выражения чрезвычайно тривиальны. Тем не менее, используйте тернарный оператор (? над конструкциями if / then / else / end для однострочных условных выражений.

Используйте одно выражение на ветку в троичном операторе. Это также означает, что троичные операторы не должны быть вложенными. Предпочитаю конструкции if / else в этих случаях.

Избегать многострочного?: (Троичный оператор), используйте вместо него if / then / else / end.

Релиз Crystal

Состоялся релиз языка программирования Crystal версии 1.0. Выпуск мажорной версии свидетельствует о стабилизации языка со стандартной библиотекой и, как следствие, его готовности к применению в «боевых условиях».

Разработчики гарантируют обратную совместимость в рамках ветки 1.x. Планируется выпуск как корректирующих (например, 1.0.1) версий, включающих исправления ошибок, так и минорных (например, 1.2.0), которые будут включать новые возможности. Введение новых возможностей, по словам разработчиков, не скажется на стабильности языка. Наиболее смелые идеи, предложенные сообществом, будут включены в отдельную ветку, на основе которой в перспективе будет сформирован Crystal 2.0

Crystal – это объектно-ориентированный язык программирования высокого уровня, во многом схожий по синтаксису со сравнительно простым и популярным Ruby. Однако, в отличие от интерпретируемого Ruby, Crystal компилируется в машинный код при помощи LLVM.

Состоялся релиз языка программирования Crystal 1.0, вдохновленного Ruby

По некоторым данным, производительность программ на Crystal может быть сопоставима с таковой для кода, написанного на низкоуровневом C. Язык C нередко применяется для написания ПО, высокая производительность которого критически важна, однако обладает значительно более высоким порогом вхождения по сравнению с Ruby, Crystal или, к примеру, Python.

Объектная ориентация — это просто функции

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

new_person = ->(name,birthdate,gender,title,id) {
  return ->(attribute) {
    return id        if attribute == :id
    return name      if attribute == :name
    return birthdate if attribute == :birthdate
    return gender    if attribute == :gender
    return title     if attribute == :title
    if attribute == :salutation
      if String(title) == ''
        return name
      else
        return title + " " + name
      end
    end
    nil
  }
}

Мы даже можем создавать полномасштабные методы в объектно-ориентированном стиле:

new_person = ->(name,birthdate,gender,title,id) {
  return ->(attribute) {
    return id        if attribute == :id
    return name      if attribute == :name
    return birthdate if attribute == :birthdate
    return gender    if attribute == :gender
    return title     if attribute == :title
    if attribute == :salutation
      if String(title) == ''
        return name
      else
        return title + " " + name
      end
    elsif attribute == :update
      update_person.(name,birthdate,gender,title,id)
    elsif attribute == :destroy
      delete_person.(id)
    end
    nil
  }
}

some_person.(:update)
some_person.(:destroy)

Если уж мы зашли так далеко, давайте добавим наследование! Допустим, у нас есть сотрудник, который является персоной, но имеет id сотрудника:

new_employee = ->(name,birthdate,gender,title,employee_id_number,id) {
  person = new_person.(name,birthdate,gender,title,id)
  return ->(attribute) {
    return employee_id_number if attribute == :employee_id_number
    return person.(attribute)
  }
}

Мы создали классы, объекты и наследование — пользуясь лишь функциями и написав совсем немного кода.

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

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

Один аспект, который кажется проблематичным, — это мутация. Взгляните, насколько пространен код add_person. Здесь мы вызываем insert_person, чтобы записать персону в базу данных и возвратить ее ID. После этого нам придется создать совершенно новую персону лишь для того, чтобы задать ID. В классическом объектно-ориентированном стиле мы бы сделали просто person.id = id.

Насколько красиво изменяемое состояние вписывается в этот конструкт? Я считаю наиболее красивой деталью компактность кода, а тот факт, что эта компактность реализована при помощи изменяемого состояния, случаен. Если только мы не работаем в системе, испытывающей жесткий дефицит памяти, с активной сборкой мусора, то создание новых объектов не доставит нам каких-либо проблем. Нас, конечно, будет раздражать излишняя повторяемость при создании новых объектов с нуля. Поскольку мы уже знаем, как добавлять функции к нашей, ммм… функции, давайте сделаем и такую функцию, которая будет вновь делать синтаксис более компактным.

new_person = ->(name,birthdate,gender,title,id=nil) {
  return ->(attribute,*args) {
    return id        if attribute == :id
    return name      if attribute == :name
    return birthdate if attribute == :birthdate
    return gender    if attribute == :gender
    return title     if attribute == :title
    if attribute == :salutation
      if String(title) == ''
        return name
      else
        return title + " " + name
      end
    end

    if attribute == :with_id # <===
      return new_person.(name,birthdate,gender,title,args)
    end

    nil
  }
}

Теперь add_person становится еще проще:

add_person = ->(person) {
  return                   if String(person.(:name)) == ''
  return              if String(person.(:birthdate)) == ''
  return                 if String(person.(:gender)) == ''
  return  if person.(:gender) != 'male' &&
                                                      person.(:gender) != 'female'

  id = insert_person.(person.(:name),person.(:birthdate),person.(:gender),person.(:title))
   # <====
}

Код не так чист, как person.id = id, но он достаточно лаконичен и по-прежнему удобочитаем.

Что такое Ruby?

Ruby — это объектно-ориентированный язык программирования с открытым исходным кодом, который в основном используется для веб-разработки. Он был создан в 1995 году Юкихиро Мацумото, который хотел создать язык сценариев, более сильный, чем Perl, и более объектно-ориентированный, чем Python. Ему нужно было что-то простое в использовании, функциональное и динамичное.

Ruby известен своим простым синтаксисом, облегчающим изучение и понимание. У него есть функции обработки исключений, такие как Java и Python, поэтому он хорошо обрабатывает ошибки. Он также портативен, работает с различными операционными системами.

Также существует Ruby on Rails, среда разработки веб-приложений с открытым исходным кодом, написанная на Ruby. С Ruby on Rails легко быстро создавать мощные веб-приложения благодаря его инновационным функциям, таким как миграции таблиц и каркасы. Некоторые из крупнейших веб-сайтов используют Ruby on Rails, включая Airbnb, GitHub, Twitch, Twitter и многие другие.

Зачем изучать Ruby?

Давайте посмотрим на некоторые преимущества Ruby:

• Весело и легко освоить: Ruby был разработан таким образом, чтобы было весело использовать и легко учиться. Впервые он был использован в Японии для создания игр. Ruby лаконичен и прямолинеен, читается так же, как английский. Это означает, что это отличный язык программирования для начинающих.
• Гибкость: Ruby динамичен и гибок. Вы не ограничены строгими правилами.
• Объектно-ориентированный: в Ruby все рассматривается как объект. Это означает, что каждый фрагмент кода может иметь свои собственные свойства и действия.
• Простой синтаксис: синтаксис Ruby легко изучать, читать, писать и поддерживать.
• Яркое сообщество: у Ruby много лояльных пользователей и большое активное сообщество.

Давайте начнем изучать Ruby и научимся писать Hello World!.

Типы данных

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

Strings

Строки состоят из символов. Вы определяете их, заключая символы в одинарные ’string’или двойные «string«кавычки. В приведенном ниже коде обе строки работают одинаково:

Numbers

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

Booleans

Логическое значение — это тип данных с двумя возможными значениями: истина или ложь. Вы используете их в логических утверждениях. Они полезны, когда вы хотите принимать решения. Давайте посмотрим на пример:

Разберем код:

• Мы начинаем с определения двух переменных:, my_string_1которая присваивается строке «Dog», и my_string_2, которая присваивается строке «Cat».
• Мы используем ifоператор, чтобы проверить, равны ли две наши переменные друг другу. Если они равны, наша продукция равна «True!». Если они не равны, наш результат равен «False!».
• end закрывает ifоператор, что означает, что любой код, который вы напишете после, не будет частью вашего блока операторов if.
• Поскольку «Dog» не равно «Cat», наши переменные не равны. На выходе будет False!.

Массивы

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

Разберем код:

• В нашем массиве мы храним две строки: одну с плавающей запятой, одну логическую и одну целую. Мы создаем имя переменной our_arrayдля массива и используем квадратные скобки вокруг первого и последнего элементов.
• Затем мы используем #знак, чтобы прокомментировать следующий шаг в нашем коде — печать всех элементов нашего массива.
• Мы используем этот eachметод, чтобы сообщить Ruby о необходимости перебрать каждый элемент в нашем массиве и распечатать их.

Символы

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

Разберем код:

• Мы начинаем с определения наших символов и присвоения наших строк соответствующим символам.
• Мы используем putsдля печати наши символы, которые возвращаются как строки, которым они назначены.

Комментарии

Комментарии Ruby начинаются с #символа и заканчиваются в конце строки. Любые символы в строке после #символа игнорируются интерпретатором Ruby.

Давайте посмотрим на комментарий в Ruby:

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

Классы

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

class Person
 attr_reader :name, :age
 def initialize(name, age)
 @name, @age = name, age
 end
 def <=>(person) # the comparison operator for sorting
 @age <=> person.age
 end
 def to_s
 "#{@name} (#{@age})"
 end
end

group = 
 Person.new("Bob", 33),
 Person.new("Chris", 16),
 Person.new("Ash", 23)


puts group.sort.reverse

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

Bob (33)
Ash (23)
Chris (16)

является константой и ссылкой на объект.

Открытые классы

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

# re-open Ruby's Time class
class Time
 def yesterday
 self - 86400
 end
end

today = Time.now # => 2013-09-03 16:09:37 +0300
yesterday = today.yesterday # => 2013-09-02 16:09:37 +0300

Добавление методов к ранее определенным классам часто называют исправлением обезьян

При неосторожном выполнении такая практика может привести как к конфликтам поведения с последующими неожиданными результатами, так и к проблемам с масштабируемостью кода.

# re-open Ruby's Time class
module RelativeTimeExtensions
 refine Time do
 def half_a_day_ago
 self - 43200
 end
 end
end

module MyModule
 class MyClass
 # Allow the refinement to be used
 using RelativeTimeExtensions

 def window
 Time.now.half_a_day_ago
 end
 end
end

Операторы диапазона в Ruby

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

В Ruby эти последовательности создаются с использованием операторов диапазона «..» и «…». Двухточечная форма создает инклюзивный диапазон, а трехточечная форма создает диапазон, исключающий указанное высокое значение.

оператор	Описание	пример
..	Создает диапазон от начальной до конечной точки включительно.	1..10 Создает диапазон от 1 до 10 включительно.
…	Создает диапазон от начальной точки до конечной точки.	1 … 10 Создает диапазон от 1 до 9.

Операторы Dot “.” и Double Colon “::” в Ruby

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

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

Помните, что в Ruby классы и методы также могут считаться константами.

Вам нужно просто префикс :: Const_name с выражением, которое возвращает соответствующий класс или объект модуля.

Если выражение префикса не используется, по умолчанию используется основной класс Object.

Вот два примера:

MR_COUNT = 0         # константа определена главным объектом класса
module Foo
   MR_COUNT = 0
   ::MR_COUNT = 1    # установить глобальный счетчик на 1
   MR_COUNT = 2      # установить глобальный счетчик на 2
end
puts MR_COUNT        # это глобальная константа
puts Foo::MR_COUNT   # это местная константа "Foo"

Второй пример

CONST = ' out there'
class Inside_one
   CONST = proc {' in there'}
   def where_is_my_CONST
      ::CONST + ' inside one'
   end
end
class Inside_two
   CONST = ' inside two'
   def where_is_my_CONST
      CONST
   end
end
puts Inside_one.new.where_is_my_CONST
puts Inside_two.new.where_is_my_CONST
puts Object::CONST + Inside_two::CONST
puts Inside_two::CONST + CONST
puts Inside_one::CONST
puts Inside_one::CONST.call + Inside_two::CONST