Понимание типов данных в Ruby
Введение
Когда вы пишете программы, вы используете типы данных для классификации данных. Типы данных сообщают компьютеру, как обрабатывать данные в вашей программе. Они также определяют, что вы можете делать с данными, в том числе какие операции вы можете выполнять.
Один из способов подумать о типах данных — рассмотреть различные типы данных, которые мы используем в реальном мире. Например, мы используем целые числа (0, 1, 2, …), целые числа (…, -1, 0, 1, …) и иррациональные числа (π).
Обычно в математике мы можем комбинировать числа из разных типов и получать какой-то ответ. Например, мы можем захотеть добавить 5 к π:
5 + π
Мы можем либо оставить уравнение в качестве ответа для учета иррационального числа, либо округлить π до числа с небольшим количеством знаков после запятой, а затем сложить числа вместе:
5 + π = 5 + 3.14 = 8.14
Но если мы попытаемся вычислить числа с помощью другого типа данных, например, слов, все потеряет смысл. Как бы мы решили следующее уравнение?
sky + 8
Это не то, что мы сразу знаем, как решить. Компьютер тоже не может, потому что данные двух разных типов. «Небо» — это слово, а 8 — целое число. Когда мы пишем программы, мы должны быть осторожны с тем, как мы присваиваем значения и как мы манипулируем ими с помощью таких операций, как сложение, вычитание, умножение. , и другие.
В этом руководстве вы узнаете о наиболее важных типах данных, встроенных в Ruby: целые числа, числа с плавающей запятой, строки, символы, массивы и хэши. Это не исчерпывающее исследование типов данных, но оно поможет вам ознакомиться с опциями, доступными вам в ваших программах.
Затем вы изучите динамическую типизацию. Программы Ruby определяют типы данных на основе того, что содержат переменные, поэтому понимание того, как работает динамическая типизация, поможет вам избежать сложных ситуаций в ваших собственных программах. А поскольку переменные могут содержать любое значение, вы научитесь определять тип данных переменной.
Давайте начнем с того, как работать с целыми числами в Ruby.
Целые числа
Как и в математике, целые числа в компьютерном программировании — это целые числа, которые могут быть положительными, отрицательными или равными 0 (…, -1, 0, <1, …). Целое число также широко известно как int.
Вы можете распечатать целое число следующим образом:
print -25
Output-25
Вы также можете сохранить целое число в переменной, а затем распечатать значение, сославшись на переменную:
my_int = -25
print my_int
Output-25
Вы также можете выполнять математические операции с целыми числами. Например, вы можете вычислить сумму двух чисел и распечатать результат:
sum = 116 - 68
print sum
Output48
Когда мы пишем большие числа, мы обычно используем запятые, чтобы их было легче читать. Например, мы напишем 1 000 000 для \миллиона. Вы не можете использовать запятые в своем коде, но Ruby позволяет использовать символ подчеркивания (_). чтобы сделать большие числа более читаемыми.
Попробуйте:
large_number = 1_234_567
print large_number
Вы увидите целое число, напечатанное без подчеркивания:
Output1234567
Знаки подчеркивания позволяют писать более читаемый код, если вам нужно представлять большие числа в своих программах.
По мере изучения языка Ruby у вас будет гораздо больше возможностей для работы с целыми числами. Давайте посмотрим, как работать с действительными числами.
Числа с плавающей запятой
Число с плавающей запятой или число с плавающей запятой представляет собой действительное число. Действительные числа могут быть как рациональными, так и иррациональными числами; числа, содержащие дробную часть, например 9.0 или -116.42. Другими словами, число с плавающей запятой в программе Ruby — это число, содержащее десятичную точку.
Вы можете распечатать числа с плавающей запятой в Ruby точно так же, как вы распечатываете целые числа:
print 17.3
Output17.3
Вы также можете объявить переменную и присвоить значение с плавающей запятой:
my_float = 17.3
print my_float
Output17.3
И, как и в случае с целыми числами, вы также можете выполнять математические операции с числами с плавающей запятой в Ruby:
sum = 564.0 + 365.24
print sum
Output929.24
Если вы добавите число с плавающей запятой к целому числу в Ruby, вы получите число с плавающей запятой:
sum = 564 + 365.24
print sum
Output929.24
Ruby будет рассматривать любое число, записанное без десятичных знаков, как целое число (как в 138), а любое число, записанное с десятичными знаками, как число с плавающей запятой (как в 138.0).
Далее, давайте посмотрим на булевы значения в Ruby.
Логические типы данных
Булевы значения используются для представления значений истинности, связанных с логическим разделом математики, который используется в алгоритмах информатики. В Ruby мы представляем этот тип данных одним из двух значений: true или false.
Многие операции в математике дают нам ответы, которые оцениваются как истинные или ложные:
- больше, чем
- 500 > 100
правда - 1 > 5
ложь - меньше
- 200 < 400
правда - 4 < 2
ложь - равно
- 5=5
правда - 500=400
ложь
Как и в случае с числами, вы можете сохранить значение true или false в переменной:
result = 5 > 8
Затем вы можете распечатать логическое значение с помощью вызова функции print():
print result
Поскольку 5 не больше 8, вы увидите следующий результат:
Outputfalse
По мере того, как вы будете писать больше программ на Ruby, вы лучше узнаете, как работают логические значения и как различные функции и операции, оценивающие значения true или false, могут изменить ход программы. .
Далее давайте рассмотрим работу с текстом в наших программах.
Струны
строка – это последовательность из одного или нескольких символов, например букв, цифр и символов. Строки в основном существуют либо в одинарных кавычках (), либо в двойных кавычках () в Ruby, поэтому, чтобы создать строку, заключите последовательность символов в кавычки, например:
"This is a string in double quotes."
Небольшая программа «Привет, мир!» демонстрирует, как строка может использоваться в компьютерном программировании, поскольку символы, составляющие фразу Hello, World!, являются строкой.
print "Hello, World!"
Как и в случае с другими типами данных, вы можете хранить строки в переменных:
output = "Hello, World!"
И распечатайте строку, вызвав переменную:
print output
OutputHello, World!
Как и числа, существует множество операций, которые мы можем выполнять со строками в наших программах, чтобы манипулировать ими для достижения желаемых результатов. Строки важны для передачи информации пользователю, а также для того, чтобы пользователь мог передать информацию обратно в программу.
Иногда вам нужно работать со списками данных. Вот где массивы пригодятся.
Массивы
массив может содержать несколько значений одной переменной. Это означает, что вы можете содержать список значений в массиве и перебирать их. Каждый элемент или значение внутри массива называется элементом.
Массивы определяются путем указания значений в квадратных скобках [ ], разделенных запятыми.
Массив целых чисел выглядит так:
[-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,
"Sammy",
42,
[
"coral",
"reef"
]
]
Массивы в Ruby являются изменяемыми, что означает, что вы можете добавлять значения, удалять значения и даже изменять записи в массиве.
Иногда нам нужен способ маркировать вещи в программе. Вот для чего нужны символы.
Символы
символ – это особый тип данных, который действует как метка или идентификатор в программе Ruby. Символы являются неизменяемыми, что означает, что их нельзя изменить. Символ выглядит как объявление переменной без значения. Вот пример символа:
:time_zone
В Ruby вы обычно используете символ для обозначения чего-то важного, тогда как вы используете строку для текста, с которым вам нужно работать или манипулировать. Каждая строка в программе на Ruby — это отдельный объект со своим уникальным расположением в памяти, даже если строки идентичны.
Но если вы ссылаетесь на один и тот же символ несколько раз, вы ссылаетесь на один и тот же объект повсюду в своей программе, что означает, что вы ссылаетесь на одну и ту же ячейку памяти.
Вы увидите эту концепцию в действии, когда мы рассмотрим хэши, позволяющие связать ключи со значениями.
Хэши
Хеш – это набор ключей и значений, похожий на словарь. Эти пары ключ-значение обеспечивают удобный способ хранения данных и доступа к ним. Хэши часто используются для хранения связанных данных, таких как информация о пользователе. Вы определяете хэш следующим образом:
{"first_name" => "Sammy", "last_name" => "Shark"}
Вы можете назначать хэши переменным так же, как и другим типам данных:
user = {"first_name" => "Sammy", "last_name" => "Shark"}
Чтобы получить значения из хэша user, вы используете ключ для значения:
print user["first_name"] # "Sammy"
print user["last_name"] # "Shark"
Вы можете использовать символы в качестве ключей в хеше вместо строк:
user = {:first_name => "Sammy", :last_name => "Shark"}
По возможности предпочтительнее использовать символы в качестве хеш-ключей. Каждый экземпляр символа указывает на один и тот же объект, тогда как каждый экземпляр строки ссылается на уникальный объект. Использование символов в качестве ключей приводит к немного более высокой производительности и меньшему использованию памяти.
Когда вы используете символы в качестве ключей, вы используете символы для извлечения значений:
print user[:first_name] # "Sammy"
print user[:last_name] # "Shark"
Вы также можете использовать немного другой синтаксис при определении хеша:
user = {first_name: "Sammy", last_name: "Shark"}
Этот синтаксис похож на синтаксис, используемый в JavaScript и других языках. Этот синтаксис определяет ключи как символы, поэтому вы можете получить доступ к записям, используя :first_name и :last_name вместо строк first_name и <фамилия.
Вы рассмотрели несколько типов данных, поэтому давайте посмотрим, как Ruby работает с этими типами.
Динамическая типизация
В Ruby вы не объявляете явно тип данных перед присвоением значения; присвоение значения определяет тип данных. Ruby использует динамическую типизацию, что означает, что проверка типов выполняется во время выполнения, а не во время компиляции, как в языках, использующих статическую типизацию. Ruby определяет тип данных из данных, хранящихся в переменной. Это похоже на типы данных в JavaScript.
Переменной t в следующем примере может быть присвоен любой доступный тип данных:
t = 42 # t is an Integer
t = "Sammy" # t is a String
t = :sammy # 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, если хотите.
# Convert the amount to a Float.
length = length.to_f
Метод to_f преобразует строку в число с плавающей запятой. Ruby также предоставляет метод to_i для преобразования строк в целые числа, и большинство объектов можно преобразовать в строки с помощью метода to_s:
42.to_s # "42"
(42.5).to_s # "42.5"
["Sammy", "Shark"].to_s # "[\"Sammy\", \"Shark\"]"
Ruby имеет динамическую типизацию, но не позволяет выполнять операции с данными разных типов без преобразования их в один и тот же тип. Например, этот код приведет к ошибке:
print 5 + "5"
OutputTypeError: String can't be coerced into Integer
Как и этот код:
print "5" + 5
OutputTypeError: no implicit conversion of Integer into String
Если вы хотите сложить числа, чтобы получить 10, преобразуйте строку в целое число. Если вы хотите соединить их вместе, чтобы получить 55, преобразуйте целое число в строку.
Динамическая типизация обеспечивает гибкость, но ее недостатком является то, что вы не всегда можете быть уверены, с какими данными вы работаете, поскольку переменная может содержать любой доступный тип. Ruby предоставляет способы определения типа данных.
Определение типов данных
В Ruby почти все является объектом. Целое число, число с плавающей запятой, массив, символ и хэш — все это объекты Ruby, и все они имеют метод с именем class, который сообщит вам, к какому типу они относятся. Даже логические значения true и false и значение nil являются объектами. Попробуй сам:
42.class # Integer
(42.2).class # Float
["Sammy", "Shark"].class # Array
true.class # TrueClass
nil.class # NilClass
Кроме того, вы можете использовать метод kind_of? для проверки определенного типа данных, например:
42.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 вы будете использовать множество различных типов данных. Теперь вы лучше понимаете основные типы данных, доступные в программах Ruby.
Взгляните на эти руководства, чтобы продолжить изучение типов данных Ruby:
- Как работать со строками в Ruby
- Как работать с массивами в Ruby
- Как преобразовать типы данных в Ruby