Источник Основные типы данных

В этой главе мы узнаем больше об основных типах данных 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 для проверки, соответственно, является ли аргумент числом с плавающей точкой или целым числом или числом с плавающей точкой.

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

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

iex> true
true
iex> true == false
false

Elixir также предоставляет три логических оператора: or, and и not. Эти операторы строгие в том смысле, что они ожидают, что первый аргумент будет булевым значением (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

Аналогично, значения, такие как 0 и "", которые в некоторых других языках программирования считаются «ложными», в Elixir также являются «истинными».

Как правило, используйте and, or и not когда ожидаете булевых значений. Если какие-либо из аргументов не являются булевыми, используйте &&, || и !.

Атомы

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

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:

iex> "hellö"
"hellö"

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

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

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 из модуля IO:

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

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

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

iex> is_binary("hellö")
true

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

iex> byte_size("hellö")
6

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

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

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

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 также предоставляет типы данных для выражения коллекций, таких как списки и кортежи, которые мы изучим далее. Когда мы будем говорить о конкурентности и отказоустойчивости с помощью процессов, мы также обсудим порты, pid и ссылки, но это будет в последующих главах. Пойдем дальше.