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

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

Чтобы понять, как работают типы данных, вспомните, как вы работаете с данными в реальной жизни. К примеру, люди используют целые числа (…, -1, 0, 1, …), иррациональные числа (π) и т.д.

Обычно в математике можно комбинировать числа разных типов и получать какой-то ответ. Например, можно сложить 5 и π:

5 + π

Теперь можно сохранить уравнение в качестве ответа для учета иррационального числа или же округлить π до числа с кратким числом десятичных знаков, а затем сложить заданные числа:

5 + π = 5 + 3.14 = 8.14

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

sky + 8

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

Это руководство расскажет о наиболее важных типах данных Ruby: целых числах, числах с плавающей точкой, строках, символах, массивах и хэшах.

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

Целые числа

Как и в математике, целые числа в программировании – это 0 и все положительные и отрицательные числа, которые не являются дробями (…, -1, 0, 1, …).

Чтобы вывести целое число, введите:

print -25
-25

Вы также можете сохранить целое число в переменной, а затем вывести значение, запросив эту переменную:

my_int = -25
print my_int
-25

С целыми числами можно выполнять математические операции. Например, вы можете вычислить сумму двух чисел и вывести результат на экран:

sum = 116 - 68
print sum
48

Иногда в больших числах используются запятые, чтобы их было легче воспринимать (например, 1,000,000). В коде использовать запятые нельзя, но Ruby позволяет заменить запятую символом подчеркивания, чтобы сделать большие числа удобочитаемыми.

large_number = 1_234_567
print large_number

Целое число будет выведено на экран без подчеркиваний:

1234567

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

Числа с плавающей точкой

Число с плавающей точкой – это действительное число, содержащее дробную часть (например 9.0 или -116.42). Действительные числа могут быть рациональными и иррациональными. Другими словами, число с плавающей точкой в программе Ruby представляет собой число, содержащее десятичную точку.

Чтобы вывести число с плавающей точкой в Ruby, наберите:

print 17.3
17.3

Также можно объявить переменную и присвоить ей число с плавающей точкой.

my_float = 17.3
print my_float
17.3

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

sum = 564.0 + 365.24
print sum
929.24

При складывании числа с плавающей точкой с целым числом Ruby выдает число с плавающей точкой:

sum = 564 + 365.24
print sum
929.24

Ruby воспринимает любое число без десятичной точки как целое число (к примеру 138), а любое число с десятичной точкой как число с плавающей точкой (например 138.0).

Логический тип данных

Булев тип данных используется для представления истинности значений, связанных с логической ветвью математики, на которой основаны алгоритмы в информатике. В Ruby этот тип данных представлен одним из двух значений: true или false.

Многие математические операции можно оценить как истинные или ложные:

Больше чем:

500 > 100 true
1 > 5 false

Меньше чем:

200 < 400 true
4 < 2 false

Равно:

5 = 5 true
500 = 400 false

Как и в случае с числами, вы можете сохранить значение true или false в переменной:

result = 5 > 8

Затем можно отобразить логическое значение с помощью функции print():

print result

Поскольку 5 не больше 8, вы увидите следующий результат:

false

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

Строки

Читайте также: Работа со строками в Ruby

Строка представляет собой последовательность из одного или нескольких символов, таких как буквы, цифры и символы. В Ruby строки в основном берутся в одиночные кавычки (‘) или двойные кавычки («). Чтобы создать строку, возьмите последовательность символов в кавычки, например:

"This is a string in double quotes."

Простая программа «Hello, World!» демонстрирует, как строка может использоваться в программировании на примере символов, которые составляют фразу «Hello, World!».

Читайте также: Написание простой программы в Python 3

print "Hello, World!"

Строки также можно хранить в переменных:

output = "Hello, World!"

И выводить их путем запроса переменной:

print output
Hello, World!

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

Массивы

Читайте также: Работа с массивами в Ruby

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

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

[-3, -2, -1, 0, 1, 2, 3]

Массив чисел с плавающей запятой выглядит так:

[3.14, 9.23, 111.11, 312.12, 1.05]

Вот массив строк:

['shark', 'cuttlefish', 'squid', 'mantis shrimp']

Как и другие типы данных, массив можно присвоить переменной:

sea_creatures = ['shark', 'cuttlefish', 'squid', 'mantis shrimp']

При запросе переменной на экране вы увидите массив в том виде, в каком он был создан:

print sea_creatures
['shark', 'cuttlefish', 'squid', 'mantis shrimp']

Получить доступ к отдельным элементам в массиве можно по индексу. Индексация начинается с 0.

puts sea_creatures[0]  # shark
puts sea_creatures[2]  # squid

Чтобы вывести последнее значение в массиве, можно использовать индекс -1. Ruby также предоставляет методы .first и .last для вывода первой и последней записи массива соответственно:

puts sea_creatures.first  # shark
puts sea_creatures.last   # mantis shrimp

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

record = [
:en,
"island",
42,
[
"coral",
"reef"
]
]

Массивы в Ruby являются изменяемыми, что означает, что вы можете добавлять, удалять и даже изменять элементы в массиве.

Символы

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

:time_zone

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

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

Хэши

Хэш – это подобный словарю набор ключей и значений. Эти пары «ключ-значение» предлагают удобный способ хранения и доступа к данным. Хэши часто используются для хранения связанных данных, таких как информация о пользователе. Хэш определяется следующим образом:

{"first_name" => "8host", "last_name" => "Blog"}

Хэши можно присваивать переменным, как и другие типы данных:

user = {"first_name" => "8host", "last_name" => "Blog"}

Чтобы извлечь данные из хэша user, запросите ключ:

print user["first_name"]  # "8host"
print user["last_name"]   # "Blog"

Вместо ключей в хэшах можно использовать символы:

user = {:first_name => "8host", :last_name => "Blog"}

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

Если вы используете символы в качестве ключей, с их помощью можно извлекать значения:

print user[:first_name]  # "8host"
print user[:last_name]   # "Blog"

Есть еще один синтаксис для определения хэша:

user = {first_name: "8host", last_name: "Blog"}

Он подобен синтаксису JavaScript и других языков. Этот синтаксис определяет ключи с помощью символов, потому для доступа к записям вместо «first_name» и «last_name» нужно использовать :first_name и :last_name.

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

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

Читайте также: Типы данных в Python 3

К примеру, переменной t может быть присвоен любой доступный тип данных:

t = 88        # t is an Integer
t = "8host"   # t is a String
t = :8host    # t is a Symbol
t = true      # t is a boolean (true)
t             # t is nil

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

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

print "Please enter the length of the room: "
length = gets.chop

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

88.to_s                    # "88"
(88.5).to_s                # "88.5"
["8host", "Blog"].to_s    # "[\"8host\", \"Blog\"]"

Ruby не позволяет выполнять операции с разными типами данных, не преобразовав их в один тип. Например, этот код приведет к ошибке:

print 5 + "5"
TypeError: String can't be coerced into Integer

Этот тоже выдаст ошибку:

print "5" + 5
TypeError: no implicit conversion of Integer into String

Если вы хотите сложить числа, чтобы получить 10, преобразуйте строку в целое число. Если вы хотите выполнить конкатенацию строк, чтобы получить «55», преобразуйте целое число в строку.

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

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

В Ruby почти все является объектом. Целое число, число с плавающей точкой, массив, символ и хэш – все это объекты Ruby, и все они имеют метод class, который поможет определить их тип. Даже логические значения true и false и значение nil – объекты. Рассмотрите следующий пример:

88.class                   # Integer
(88.2).class               # Float
["8host", "Blog"].class    # Array
true.class                 # TrueClass
nil.class                  # NilClass

Кроме того, вы можете использовать метод kind_of? для проверки типа данных, например:

88.kind_of?(Integer)    # true

Это особенно полезно, если вам нужно определить тип данных переменной:

# somewhere in the code...
sharks = ["Hammerhead", "Tiger", "Great White"]
...
# somewhere else...
sharks.kind_of?(Hash)   # false
sharks.kind_of?(Array)  # true

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

if data.kind_of? String
data = data.to_f
end

Ruby также предоставляет метод is_a?, который делает то же самое, что и kind_of? но его немного легче читать:

if data.is_a? String
data = data.to_f
end

Методы class, kind_of? и is_a? помогут вам узнать, с каким типом данных вы работаете.

Заключение

В программах Ruby нужно использовать много разных типов данных. теперь вы знаете основные типы данных Ruby.

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

Tags: