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

Preslav Dobrev2022-10-24 · 11 min read

Ruby — известный язык программирования. Он направлен на повышение простоты и производительности. Это также полностью объектно-ориентированный язык программирования. Кроме того, Ruby обладает элегантным синтаксисом, который естественно читать и легко писать.

Любое программирование требует управления различными типами данных. Тип данных описывает определенный класс данных. Он сообщает машине, как следует обрабатывать данные в программе. Типы данных имеют решающее значение для определения того, что можно делать с данными (включая операции, которые могут быть выполнены). В этом руководстве мы более подробно изучим типы данных, доступные в Ruby. Мы также изучим динамическую типизацию. Используя эту функцию, Ruby может автоматически определять тип данных переменной без ее явного объявления. Давайте начнем!

Предварительные требования

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

Правильно настроенная система Linux. Узнайте больше о настройке персонального сервера Ubuntu на CloudSigma.
Правильно настроенная среда разработки Ruby. Ознакомьтесь с официальной документацией по установке Ruby на Ubuntu (с использованием APT).

Типы данных в Ruby

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

Шаг 1 – Целые числа

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

 {-∞, …, -1, 0, 1, …, ∞}

1	{-∞, …, -1, 0, 1, …, ∞}

Пришло время опробовать целые числа в Ruby. Первый пример — вывод простого целого числа на экран:

print 99
print "\n"

1 2	print 99 print "\n"

Далее мы будем работать с целочисленной переменной. Здесь переменная sample_int содержит целочисленное значение (99), а функция print выводит значение переменной на экран:

sample_int = 99
print sample_int
print "\n"

sample_int = 99

print sample_int

print "\n"

Мы также можем выполнять математические операции с целыми числами. Следующий пример демонстрирует простое сложение двух целых чисел:

sample_int = 99 + 100
print sample_int
print "\n"

sample_int = 99 + 100

print sample_int

print "\n"

Когда мы работаем с большими числами, мы часто используем запятые (,), чтобы облегчить чтение. Например, один миллион (1000000) записывается как 1,000,000 для лучшей читаемости. Хотя использование запятых запрещено, Ruby позволяет использовать символы подчеркивания ( _) в качестве разделителя. Посмотрите на следующий пример:

sample_int = 1_000_999
print sample_int
print "\n"

sample_int = 1_000_999

print sample_int

print "\n"

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

Шаг 2 – Числа с плавающей запятой

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

Давайте попробуем вывести значение с плавающей запятой на экран:

print 55.66
print "\n"

1 2	print 55.66 print "\n"

Следующий пример демонстрирует объявление переменной с плавающей запятой:

sample_float = 55.66
print sample_float
print "\n"

sample_float = 55.66

print sample_float

print "\n"

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

sample_float = 55.66 + 99.222
print sample_float
print "\n"

sample_float = 55.66 + 99.222

print sample_float

print "\n"

Что если сложить число с плавающей запятой и целое число? Результирующее значение будет числом с плавающей запятой. В следующем примере, несмотря на то, что 55.0 — целое число, оно рассматривается как float:

sample_float = 55.0 + 10
print sample_float
print "\n"

sample_float = 55.0 + 10

print sample_float

print "\n"

Шаг 3 – Логический тип (Boolean)

Логические значения (Booleans) представляют собой истинные значения логического раздела математики. В Ruby логические типы данных представлены двумя значениями: true и false:

Больше
- 100 > 99: true
- 99 > 100: false
Меньше
- 500 < 999: true
- 999 < 500: false
Равно
- 10 == 10: true
- 9 == 99: false

Подобно числам, мы также можем хранить true или false значение в переменной. Следующий пример демонстрирует эту возможность:

result = 9 == 99
print result
print "\n"

result = 9 == 99

print result

print "\n"

Step 4 – Строки

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

Следующий пример — это базовая программа hello world на Ruby:

print "hello world!\n"

1	print "hello world!\n"

Мы также можем хранить строки в переменных. Следующий пример также включает конкатенацию строк:

username = "Cloudsigma"
print "hello, " + username + "!\n"

1 2	username = "Cloudsigma" print "hello, " + username + "!\n"

Step 5 – Массивы

Массив — это структура данных, которая может хранить коллекцию элементов одного типа фиксированного размера. Его также можно представить как коллекцию переменных одного типа данных. Это одна из самых фундаментальных структур данных в большинстве современных языков программирования.

В Ruby массив определяется следующим образом:

[value_1, value_2, …, value_N]

1	[value_1, value_2, …, value_N]

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

Integer: [-5, 0, 5]
Float: [-9.99, -6.99, -3.99, 0, 3.99]
String: [“the”, “quick”, “brown”, “fox”]

В следующем примере реализованы все эти типы массивов:

print [-5, 0, 5]
print "\n"
print [-9.99, -6.99, -3.99, 0, 3.99]
print "\n"
print ["the", "quick", "brown", "fox"]
print "\n"

print [-5, 0, 5]

print "\n"

print [-9.99, -6.99, -3.99, 0, 3.99]

print "\n"

print ["the", "quick", "brown", "fox"]

print "\n"

Обратите внимание, что когда функция print встречает массив, она выводит весь массив на экран. Для большего удобства вы часто будете встречать массивы в виде переменных. Давайте обновим код:

array_int = [-5, 0, 5]

print array_int
print "\n"
array_float = [-9.99, -6.99, -3.99, 0, 3.99]
print array_float
print "\n"
array_string = ["the", "quick", "brown", "fox"]
print array_string
print "\n"

array_int = [-5, 0, 5]

print array_int

print "\n"

array_float = [-9.99, -6.99, -3.99, 0, 3.99]

print array_float

print "\n"

array_string = ["the", "quick", "brown", "fox"]

print array_string

print "\n"

Теперь мы можем работать с отдельными элементами массивов:

array_int = [-5, 0, 5]
print array_int[2]
print "\n"
array_float = [-9.99, -6.99, -3.99, 0, 3.99]
print array_float[1]
print "\n"
array_string = ["the", "quick", "brown", "fox"]
print array_string[3]
print "\n"

array_int = [-5, 0, 5]

print array_int[2]

print "\n"

array_float = [-9.99, -6.99, -3.99, 0, 3.99]

print array_float[1]

print "\n"

array_string = ["the", "quick", "brown", "fox"]

print array_string[3]

print "\n"

Обратите внимание, что в Ruby индексация массивов начинается с 0.

Для удобства массивы в Ruby поставляются с методами .first и .last, которые выводят первый и последний элементы:

array_float = [-9.99, -6.99, -3.99, 0, 3.99]
puts array_float.first
puts array_float.last
print "\n"

array_float = [-9.99, -6.99, -3.99, 0, 3.99]

puts array_float.first

puts array_float.last

print "\n"

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

mixed_array = [
        "hello",
        99.99,
        "world",
        [
            "the",
            "quick",
            "brown",
            "fox"
        ]
    ]

print mixed_array
print "\n"

print mixed_array[3]
print "\n"

mixed_array = [

"hello",

99.99,

"world",

[

"the",

"quick",

"brown",

"fox"

]

print mixed_array

print "\n"

print mixed_array[3]

print "\n"

Шаг 6 – Символы

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

Вот пример символа:

:time_zone

1	:time_zone

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

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

Шаг 7 – Хэши

Хэш — это похожая на словарь коллекция ключей и значений. Часто хэши используются для хранения связанных данных, например, информации о пользователе.

Вот быстрый пример хэша. Мы создали хэш user_info, содержащий имя пользователя и пароль пользователя:

user_info = {
"username" => "HelloWorld999",
"password" => "password123"
}
print user_info
print "\n"

user_info = {

"username" => "HelloWorld999",

"password" => "password123"

}

print user_info

print "\n"

Чтобы получить значения пары «ключ-значение», мы должны использовать ключ. Следующий пример демонстрирует этот процесс:

user_info = {
"username" => "HelloWorld999",
"password" => "password123"
}

print user_info["username"]
print "\n"

user_info = {

"username" => "HelloWorld999",

"password" => "password123"

}

print user_info["username"]

print "\n"

Ruby также позволяет определять хэш с использованием немного другого синтаксиса ( : вместо =>):

user_info = {
username: "HelloWorld999",
password: "password123"
}
print user_info[:password]
print "\n"

user_info = {

username: "HelloWorld999",

password: "password123"

}

print user_info[:password]

print "\n"

Эта синтаксическая структура похожа на синтаксис, используемый в других языках, например, JavaScript. В этой синтаксической структуре ключи определяются как символы. Вот почему вместо использования "username", мы используем: username для доступа к значению.

Динамическая типизация

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

В следующем примере все значения, присвоенные переменной dyn_var, являются допустимыми:

dyn_var = 123
dyn_var = 456.789
dyn_var = true
dyn_var = "the quick brown fox"
dyn_var

dyn_var = 123

dyn_var = 456.789

dyn_var = true

dyn_var = "the quick brown fox"

dyn_var

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

dyn_var = 123
puts dyn_var
dyn_var = 456.789
dyn_var = true
dyn_var = "the quick brown fox"
puts dyn_var
dyn_var

dyn_var = 123

puts dyn_var

dyn_var = 456.789

dyn_var = true

dyn_var = "the quick brown fox"

puts dyn_var

dyn_var

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

print "enter length: "
length = gets.chop
length = length.to_f
puts length

print "enter length: "

length = gets.chop

length = length.to_f

puts length

Здесь,

Поскольку вводимые с клавиатуры данные являются строками, length сначала является строкой.
Поскольку нам нужно значение с плавающей точкой (float), мы преобразуем строковое значение в float с помощью метода to_f.
Из-за изменения значения переменной length присваивается тип данных float. Это то, что мы видим при выводе ее значения на экран.

Что произойдет, если мы попытаемся смешать два разных типа данных? Ruby выдаст ошибку. Посмотрите:

print 9 + "77"

1	print 9 + "77"

Определение типа данных

В Ruby всё рассматривается как объект. Каждый объект в Ruby поставляется с методом class. При вызове этот метод сообщает тип данных источника. Вот несколько примеров использования метода class:

puts 55.class
puts (55.55).class
puts true.class
puts nil.class

puts 55.class

puts (55.55).class

puts true.class

puts nil.class

Еще один способ узнать тип данных — использовать kind_of? метод. Он проверяет тип данных объекта на соответствие запрашиваемому типу данных и возвращает логическое значение. Посмотрите на следующий пример:

puts 55.kind_of?(Float)
puts 55.kind_of?(Integer)

1 2	puts 55.kind_of?(Float) puts 55.kind_of?(Integer)

Аналогично, существует другой метод is_a?, который сравнивает типы данных и возвращает логическое значение. Единственное отличие — это название метода. Однако он может быть предпочтительнее, так как разработчикам его немного легче читать и понимать. Обновите предыдущий пример с помощью is_a?:

puts 55.is_a?(Float)
puts 55.is_a?(Integer)

1 2	puts 55.is_a?(Float) puts 55.is_a?(Integer)

Заключение

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

Посмотрите другие руководства в нашем блоге, которые помогут вам изучить Ruby:

Приятного программирования!

Preslav Dobrev

Автор · CloudSigma

Preslav Dobrev — креативный дизайнер в CloudSigma, сосредоточенный на формировании последовательного корпоративного образа с помощью традиционных и инновационных маркетинговых каналов. Он умело сочетает художественное видение со стратегическим маркетингом, создавая убедительные истории бренда.

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

Предварительные требования

Типы данных в Ruby

Шаг 1 – Целые числа

Шаг 2 – Числа с плавающей запятой

Шаг 3 – Логический тип (Boolean)

Step 4 – Строки

Step 5 – Массивы

Шаг 6 – Символы

Шаг 7 – Хэши

Динамическая типизация

Определение типа данных

Заключение

Preslav Dobrev

Комментарии