Source Основные типы данных

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

iex> 1          # integer
iex> 0x1F       # integer
iex> 1.0        # float
iex> true       # boolean
iex> :atom      # atom / symbol
iex> "elixir"   # string
iex> [1, 2, 3]  # list
iex> {1, 2, 3}  # tuple

Арифметические операции

Откройте iex и введите следующие выражения:

iex> 1 + 2
3
iex> 5 * 5
25
iex> 10 / 2
5.0

Обратите внимание, что 10 / 2 вернул число с плавающей точкой 5.0, а не целое число 5. Это ожидаемо. В Elixir оператор / всегда возвращает число с плавающей точкой. Если вы хотите выполнить целочисленное деление или получить остаток от деления, вы можете вызвать функции div и rem.

iex> div(10, 2)
5
iex> div 10, 2
5
iex> rem 10, 3
1

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

Elixir также поддерживает сокращенные записи для ввода двоичных, восьмеричных и шестнадцатеричных чисел:

iex> 0b1010
10
iex> 0o777
511
iex> 0x1F
31

Числа с плавающей точкой требуют точки, за которой следует хотя бы одна цифра, а также поддерживают e для научной записи:

iex> 1.0
1.0
iex> 1.0e-10
1.0e-10

Числа с плавающей точкой в Elixir имеют точность 64 бита.

Вы можете вызвать функцию round для получения ближайшего целого числа к заданному числу с плавающей точкой или функцию trunc для получения целой части числа с плавающей точкой.

iex> round(3.58)
4
iex> trunc(3.58)
3

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

iex> is_integer(1)
true
iex> is_integer(2.0)
false

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

Идентификация функций и документация

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

Функции в Elixir идентифицируются по имени и арности. Арность функции описывает количество аргументов, принимаемых функцией. С этого момента мы будем использовать и имя функции, и ее арность для описания функций в документации. trunc/1 идентифицирует функцию с именем trunc и принимающую 1 аргумент, в то время как trunc/2 идентифицирует другую (несуществующую) функцию с тем же именем, но с арностью 2.

Мы также можем использовать этот синтаксис для доступа к документации. Оболочка Elixir определяет функцию h, которую вы можете использовать для доступа к документации любой функции. Например, ввод h trunc/1 отобразит документацию для функции trunc/1:

iex> h trunc/1
                             def trunc()

Returns the integer part of number.

h trunc/1 работает, потому что она определена в модуле Kernel. Все функции в модуле Kernel автоматически импортируются в наш пространство имен. Чаще всего вы также будете включать имя модуля при поиске документации для данной функции:

iex> h Kernel.trunc/1
                             def trunc()

Returns the integer part of number.

Вы можете использовать модуль+функция для поиска чего угодно, включая операторы (попробуйте h Kernel.+/2). Вызов h без аргументов отображает документацию для IEx.Helpers, где определены h и другие функции.

Булевы значения и nil

Elixir поддерживает true и false в качестве булевых значений:

iex> true
true
iex> true == false
false

Elixir также предоставляет три булевых оператора: or/2, and/2 и not/1. Эти операторы являются строгими в том смысле, что ожидают что-то, что оценивается как булево (true или false), в качестве своего первого аргумента:

iex> true and true
true
iex> false or is_boolean(true)
true

Предоставление небулевого значения вызовет исключение:

iex> 1 and true
** (BadBooleanError) expected a boolean on left-side of "and", got: 1

or и and являются операторами короткого замыкания. Они выполняют правую часть только в том случае, если левая часть недостаточна для определения результата:

iex> false and raise("This error will never be raised")
false
iex> true or raise("This error will never be raised")
true

Elixir также предоставляет понятие nil, чтобы указать отсутствие значения, и набор логических операторов, которые также манипулируют nil: ||/2, &&/2 и !/1. Для этих операторов false и nil считаются «ложными», все остальные значения считаются «истинными»:

# or
iex> 1 || true
1
iex> false || 11
11

# and
iex> nil && 13
nil
iex> true && 17
17

# not
iex> !true
false
iex> !1
false
iex> !nil
true

Атомы

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

iex> :apple
:apple
iex> :orange
:orange
iex> :watermelon
:watermelon

Атомы равны, если их имена равны.

iex> :apple == :apple
true
iex> :apple == :orange
false

Часто они используются для выражения состояния операции, используя значения, такие как :ok и :error.

Булевы значения true и false также являются атомами:

iex> true == :true
true
iex> is_atom(false)
true
iex> is_boolean(:false)
true

Elixir позволяет вам опустить лидирующую : для атомов false, true и nil.

Строки

Строки в Elixir ограничены двойными кавычками и закодированы в UTF-8:

Примечание: если вы работаете в Windows, существует вероятность, что ваша оболочка по умолчанию не использует UTF-8. Вы можете изменить кодировку текущего сеанса, выполнив chcp 65001 перед входом в IEx.

Вы можете конкатенировать две строки с помощью оператора <>/2:

iex> "hello " <> "world!"
"hello world!"

Elixir также поддерживает интерполяцию строк:

iex> string = "world"
iex> "hello #{string}!"
"hello world!"

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

iex> number = 42
iex> "i am #{number} years old!"
"i am 42 years old!"

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

iex> "hello
...> world"
"hello\nworld"
iex> "hello\nworld"
"hello\nworld"

Вы можете вывести строку, используя функцию IO.puts/1 из модуля IO:

iex> IO.puts("hello\nworld")
hello
world
:ok

Обратите внимание, что функция IO.puts/1 возвращает атом :ok после вывода.

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

iex> is_binary("hellö")
true

Мы также можем получить количество байтов в строке:

iex> byte_size("hellö")
6

Обратите внимание, что количество байтов в этой строке равно 6, хотя в ней есть 5 графем. Это потому, что графема «ö» занимает 2 байта для представления в UTF-8. Мы можем получить фактическую длину строки, основанную на количестве графем, с помощью функции String.length/1:

iex> String.length("hellö")
5

Модуль String содержит множество функций, которые работают со строками в соответствии со стандартом Юникод:

iex> String.upcase("hellö")
"HELLÖ"

Структурное сравнение

Elixir также предоставляет ==, !=, <=, >=, < и > в качестве операторов сравнения. Мы можем сравнивать числа:

iex> 1 == 1
true
iex> 1 != 2
true
iex> 1 < 2
true

Но также и атомы, строки, булевы значения и т. д.:

iex> "foo" == "foo"
true
iex> "foo" == "bar"
false

Целые числа и числа с плавающей точкой сравниваются одинаково, если у них одинаковое значение:

iex> 1 == 1.0
true
iex> 1 == 2.0
false

Однако вы можете использовать оператор строгого сравнения === и !== , если хотите различать целые числа и числа с плавающей точкой (это единственное различие между этими операторами):

iex> 1 === 1.0
false

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

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