Понимание типов данных в Ruby

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

Один из способов думать о типах данных - рассмотреть различные типы данных, которые мы используем в реальном мире. Например, мы используем целые числа (0, 1, 2,…), целые числа (…, -1, 0, 1,…) и иррациональные числа (π).

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

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

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

Это не то, что мы сразу знаем, как решить. Компьютер не может либо, потому что данные имеют два разных типа. «Небо» - это слово, а «+ 8 +» - целое число. Когда мы пишем программы, мы должны быть осторожны с тем, как мы присваиваем значения и как мы манипулируем ими с помощью таких операций, как сложение, вычитание, умножение и другие.

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

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

Давайте начнем с рассмотрения того, как работать с целыми числами в Ruby.

Как и в математике, integers в компьютерном программировании - это целые числа, которые могут быть положительными, отрицательными или 0 (…, + -1 +, + 0 +, + 1 +,…). Целое число также широко известно как + int +.

Вы можете распечатать целое число следующим образом:

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

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

Когда мы записываем большие числа, мы склонны использовать запятые, чтобы их было легче читать. Например, мы бы написали «+ 1 000 000 » для «один миллион». Вы не можете использовать запятые в своем коде, но Ruby позволяет использовать символ подчеркивания (` _ +`), чтобы сделать большие числа более читабельными.

Попробуйте это:

large_number.rb

Вы увидите целое число, напечатанное без подчеркивания:

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

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

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

Вы можете распечатать числа в Ruby так же, как вы печатаете целые числа:

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

И, как и с целыми числами, вы также можете выполнять математику с плавающей точкой в ​​Ruby

Если вы добавите число с плавающей точкой к целому числу в Ruby, вы получите число с плавающей точкой:

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

Далее давайте посмотрим на логические значения в Ruby.

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

Многие операции по математике дают нам ответы, которые оценивают как истинные или ложные:

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

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

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

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

Далее давайте рассмотрим работу с текстом в наших программах.

_Https: //www.digitalocean.com/community/tutorials/how-to-work-with-strings-in-ruby [строка] _ представляет собой последовательность из одного или нескольких символов, таких как буквы, цифры и символы. Строки в основном существуют в одинарных кавычках (+ '+) или в двойных кавычках (`+" + `) в Ruby, поэтому для создания строки заключите в кавычки последовательность символов, например:

Простая программа «https://www.digitalocean.com/community/tutorials/how-to-write-your-first-python-3-pro[[Hello, World!]» Демонстрирует, как можно использовать строку в компьютерном программировании. , так как символы, составляющие фразу + Hello, World! +, являются строкой.

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

И распечатайте строку, вызвав переменную:

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

Иногда вам нужно работать со списками данных. Вот где массивы пригодятся.

Https: //www.digitalocean.com/community/tutorials/how-to-work-with-arrays-in-ruby [массив] _ может содержать несколько значений в одной переменной. Это означает, что вы можете содержать список значений в массиве и выполнять их итерацию. Каждый элемент или значение, находящееся внутри массива, называется _element.

Массивы определяются путем указания значений в квадратных скобках + [] +, разделенных запятыми.

Массив целых чисел выглядит так:

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

Вот список строк:

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

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

Вы получаете доступ к отдельным элементам в массиве, используя индексный номер, начиная с + 0 +.

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

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

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

Иногда нам нужен способ маркировать вещи в программе. Вот для чего нужны символы.

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

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

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

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

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

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

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

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

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

Когда вы используете символы в качестве ключей, вы используете символы для получения значений:

Вы также можете использовать немного другой синтаксис при определении хеша:

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

Вы рассмотрели несколько типов данных, поэтому давайте посмотрим, как Ruby работает с этими типами.

В Ruby вы явно не объявляете тип данных перед назначением значения; присвоение значения определяет тип данных. Ruby использует dynamic typing, что означает, что проверка типов выполняется во время выполнения, а не во время компиляции, как в языках, которые используют static typing. Ruby определяет тип данных по данным, хранящимся в переменной. Это похоже на типы data в Python и на https://www.digitalocean.com/community/tutorials / понимание-типы данных в JavaScript [типы данных в JavaScript].

Переменная + t + в следующем примере может быть установлена ​​на любой доступный тип данных:

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

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

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

Метод + to_f + преобразует строку в число с плавающей точкой. Ruby также предоставляет метод + to_i + для преобразования строк в целые числа, и большинство объектов можно преобразовать в строки с помощью метода + to_s +:

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

Как будет этот код:

Если вы хотите сложить числа вместе, чтобы получить + 10 +, преобразуйте строку в целое число. Если вы хотите объединить их вместе, чтобы получить " 55 ", конвертируйте Integer в строку.

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

В Ruby практически все является объектом. Integer, Float, Array, Symbol и Hash являются объектами Ruby, и у них всех есть метод с именем + class +, который скажет вам, какой у них тип. Даже логические + true и` + false`, а значение + nil являются объектами. Попробуй сам:

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

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

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

Ruby также предоставляет метод + is_a? +, Который делает то же самое, что и + kind_of? +, Но может быть немного проще для чтения для некоторых разработчиков:

Использование + class +, + kind_of? + И + is_a? + Может помочь вам убедиться, что вы работаете с правильным видом данных. Когда вы узнаете больше о Ruby, вы обнаружите другие способы обработки данных, которые не требуют явной проверки типа данных.

Вы будете использовать много разных типов данных в своих программах на Ruby. Теперь вы лучше понимаете основные типы данных, доступные в программах на Ruby.

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