Типы данных используются для их классификации. Определяя тип данных, компьютер понимает, как их обрабатывать в контексте программы. Также тип данных определяет набор операций, который можно с ними выполнить.
Чтобы понять, как работают типы данных, вспомните, как вы работаете с данными в реальной жизни. К примеру, люди используют целые числа (…, -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.
Читайте также: