Ruby/Базовые типы данных

Базовые типы данных

Данные любого типа в Ruby суть объекты тех или иных классов. Самые используемые встроенные типы данных:

Fixnum (целые числа, меньше $2^{30}$ ),
Bignum (целые числа, больше $2^{30}$ ),
Float (числа с плавающей запятой),
Array (массивы),
String (строки),
Hash (ассоциативные массивы).

Естественно, что это только базовые типы, но их вполне хватает для широкого спектра задач.

Числа

Числа в Ruby выглядят так:

5 # целое число
-12 # отрицательное целое число
4.5 # число с плавающей точкой
076 # восьмеричное число
0b010 # двоичное число
0x89 # шестнадцатеричное число

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

Логический тип

Логический (булевый) тип — это вариация на тему «да» или «нет». В Ruby он представлен двумя предопределёнными переменными true («истина» или «да») и false («ложь» или «нет»). Появляется логический тип в результате логических операций или вызова логических методов.

Чаще всего логический тип возникает как результат сравнения.

Логические операции
Название операции	Символ операции	Литерное обозначение
Или	`\|\|`	`or`
И	`&&`	`and`
Не	`!`	`not`
Исключающее или	`^`	`xor`

Методы сравнения

Название метода	Символ
Равно	`==`
Не равно	`!=`
Меньше	`<`
Больше	`>`
Меньше или равно	`<=`
Больше или равно	`>=`

Часто молодые программисты, когда надо написать «меньше или равно», пишут знак =< вместо <=. Запомнить правильное написание можно вслух проговорив «меньше или равно» и в этом же порядке писать < и =.

Традиционно имена логических методов заканчиваются на ? (знак вопроса).
В качестве false может выступать nil, а в качестве true — любой объект.
nil — это символ пустоты.

Массивы

Разработчики Ruby решили не реализовывать особых классов для динамических массивов, списков, стеков и тому подобного. Они все это реализовали в массивах — структурах данных типа (или класса — в Ruby всё равно) Array. Сделано это путём добавления специальных методов; например, методы .push и .pop для стека. Особенности массивов в Ruby:

Нет ограничений (это общий принцип языка). Массивы могут быть сколь угодно длинными.
Динамичность: размер массива легко меняется.
Гетерогенность: один массив может хранить данные разных типов.
Библиотека итераторов на каждый случай жизни. Эта возможность позволяет не использовать циклы для обработки данных в массивах, а, следовательно, избегать множества ошибок, связанных с неосторожным обращением с циклами. Итераторы реализуются на высочайшем уровне.
Много других методов. Все элементарные задачи для массивов решаются вызовом нужного метода.

[1, 0, 740, 14, 25] # целочисленный массив
["a", "й", "6", 'Br', "Это массив строк, о них вы скоро узнаете"]
[[1, 2], [3, 4]] # двумерный целочисленный массив
                       # Матрица — это объект класса Matrix
                       # Двумерный массив — это не матрица целых чисел
["1-й элемент смешанного массива", "7.343", [4, "вепрь"], 
    [3, 67, 4326, 12, 3781357, 84221, "строка делает этот подмассив смешанным, но это не беда"]]
array = ["Этот массив пойдёт в переменную array", "Як-цуп-цоп, парви каридулла"]

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

array[1] #=> "Як-цуп-цоп, парви каридулла"

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

array[0] #=> "Этот массив пойдёт в переменную array"

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

Строки

Стро́ки — это ряды букв и других символов. В Ruby стро́ки используют наработки языка Perl. Вот небольшой список их возможностей:

Нет ограничений. Длина строки́ может достигать поистине фантастических размеров.
Динамичность. Стро́ки можно расширять или уменьшать (для этого есть методы + и []).
Любой объект преобразуется в строку (методы .inspect и .to_s есть у любого объекта).
Строка обладает обширной библиотекой методов, которые работают с правилами (это методы .gsub, .match, .scan, .split).

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

Можно вставлять произвольныe переменные заключив их между #{ и }. Действует для строк начинающихся и заканчивающихся ". После выполнения код заместится результатом.

Стро́ки начинаются и заканчиваются " (программистскими кавычками) или ' (машинописным апострофом). Пример:

"мама мыла раму" # строка в кавычках
'рама сопротивлялась' # строка в апострофах

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

Ассоциативные массивы

Ассоциативные массивы подобны массивам упорядоченных пар. Работают они подобно словарям: фигурная скобка символизирует боковой вид на открытую книгу, а стрелка => покажет читателю связь каждой сущности с какой-то другой. Вторая фигурная скобка говорит, что пора закрывать книгу. В Ruby такие массивы именуются Hash

hash = {"мама"=>"мыла раму", 807=>"Это число улыбается!"}

Но можно и без фигурных скобок, одной стрелкой:

"Превед"=>"Медвед"

Например:

puts hash["мама"] #=> мыла раму
puts hash["807"] #=> nil
puts hash[807] #=> Это число улыбается!
puts hash[1] #=> nil
puts hash["Превед"] #=> Медвед

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

Диапазоны значений

Чтобы было удобней получать подмассив или подстроку, был введён простенький тип данных — диапазон (класс Range). Диапазон формируется тремя элементами: начало, конец и тип протяжённости (символ .. или ...). Начало и конец должны быть одного типа данных (одного класса) и быть перечисляемыми, что значит, иметь метод .succ. Пример диапазонов:

"a".."z"
"a"..."z" # то же, что и "a".."y"
1..100
1...100 # то же, что и 1..99

Диапазон-мотоцикл (..) проезжает от первого указанного объекта к его .succ (succedent — «последующему»), и до последнего включительно. Три точки — то же, но мотоцикл остановился прямо перед последним элементом. Ещё раз:

1..99 ≣ 1...100

Объекты, имеющие .succ называют последовательными: этим методом можно по текущему элементу достоверно определить следующий.

Классы и объекты

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

str = "Я - строка"
str.class #=> String
str.class.superclass #=> Object

Классы можно определять и создавать по ним объекты. Стоит отметить интересную особенность языка - описание класса здесь это не просто некая описательная конструкция, не имеющая типа (как, например, в C++), а это объект (!) класса Class, дополненный пользовательскими методами и полями. Внутри класса может быть много всего интересного, и у него может быть фамильное дерево, то есть классы Ruby поддерживают наследование. Однако заметим, что множественное наследование в Ruby не разрешается. И ещё много всего интересного можно сделать с классами и объектами. Но об этом позже.