Кортеж (tuple)

? Модуль `Tuple`

> Кортеж (tuple) — это фиксированный по размеру, неизменяемый контейнер,

> где элементы могут быть любыми типами.

> Пример: {1, :ok, "hi"}

? Создание и базовые операции

Функция / конструкция	Назначение	Пример
`{}`	Литерал кортежа	`{1, 2, 3}`
`tuple_size/1` (Kernel)	Кол-во элементов	`tuple_size({:a, :b}) #=> 2`
`is_tuple/1` (Kernel)	Проверка типа	`is_tuple({1,2}) #=> true`
`put_elem/3` (Kernel)	Заменить элемент по индексу (0-based)	`put_elem({:a,:b,:c}, 1, :x) #=> {:a,:x,:c}`
`elem/2` (Kernel)	Получить элемент по индексу	`elem({:a,:b,:c}, 2) #=> :c`
`Tuple.duplicate/2`	Создать кортеж, повторив элемент N раз	`Tuple.duplicate(:ok, 3) #=> {:ok, :ok, :ok}`
`Tuple.insert_at/3`	Вставить элемент по индексу	`Tuple.insert_at({:a,:c}, 1, :b) #=> {:a,:b,:c}`
`Tuple.delete_at/2`	Удалить элемент по индексу	`Tuple.delete_at({:a,:b,:c}, 1) #=> {:a,:c}`

? Преобразование

Функция	Назначение	Пример
`Tuple.to_list/1`	Преобразовать в список	`Tuple.to_list({:a,:b,:c}) #=> [:a,:b,:c]`
`List.to_tuple/1`	Список → кортеж	`List.to_tuple([1,2,3]) #=> {1,2,3}`
`Enum.into/2`	Преобразование коллекции в кортеж	`Enum.into([1,2,3], {}) #=> {1,2,3}`
`Enum.to_list/1`	Для работы с элементами (через список)	`Enum.map(Tuple.to_list({1,2,3}), &(&1*2)) #=> [2,4,6]`

? Извлечение и обновление (паттерн-матчинг)

Конструкция / функция	Назначение	Пример
`{a, b} = {1, 2}`	Распаковка кортежа	`a #=> 1, b #=> 2`
`{a, _, c} = {1, :skip, 3}`	Игнорирование элементов	`_` пропускает элемент
`elem/2`	Получить по индексу	`elem({10,20,30}, 1) #=> 20`
`put_elem/3`	Обновить по индексу	`put_elem({1,2,3}, 0, 99) #=> {99,2,3}`
`{tag, val}`	Часто используется для pattern match (`:ok` / `:error`)	`case File.read("x") do {:ok, data} -> ...; {:error, r} -> ... end`

? Проверка и информация

Функция	Назначение	Пример
`is_tuple/1`	Проверка, что значение — кортеж	`is_tuple({1,2}) #=> true`
`tuple_size/1`	Кол-во элементов	`tuple_size({:a,:b,:c}) #=> 3`
`Kernel.match?/2`	Проверка на соответствие шаблону	`match?({:ok, _}, {:ok, 123}) #=> true`

? Слияние и объединение

Функция	Назначение	Пример
`Tuple.append/2` (нет в Elixir, но можно через insert_at)	Добавить в конец	`Tuple.insert_at({:a,:b}, 2, :c) #=> {:a,:b,:c}`
`Tuple.concat/2` (через List)	Объединить кортежи	`List.to_tuple(Tuple.to_list({:a,:b}) ++ Tuple.to_list({:c})) #=> {:a,:b,:c}`

? Пример комплексного использования

☯

Terminal:

⌕

≡

✕

# создание и обновление
user = {:user, "Alice", 30}
user = put_elem(user, 2, 31)
# => {:user, "Alice", 31}

# доступ к элементам
name = elem(user, 1)  # "Alice"

# преобразование в список
Tuple.to_list(user)
# => [:user, "Alice", 31]

# работа через паттерн матчинг
{:user, name, age} = user
IO.puts("#{name} is #{age}")
# Alice is 31

? Частые идиомы

Цель	Пример
Возврат результата операции	`{:ok, result}` / `{:error, reason}`
Возврат нескольких значений	`{sum, count}`
Использование как immutable структуры	`user = {:user, "Bob", 25}`
Конвертация в список для обхода	`Tuple.to_list(t) \| > Enum.map(...)`

? Kernel-функции, работающие с tuple

Функция	Назначение	Пример
`is_tuple/1`	Проверка типа	`is_tuple({})`
`elem/2`	Получение по индексу	`elem({:x,:y}, 1)`
`put_elem/3`	Изменение по индексу	`put_elem({:x,:y}, 1, :z)`
`tuple_size/1`	Кол-во элементов	`tuple_size({1,2,3})`

? Преобразование через `Enum`

Функция	Назначение	Пример
`Enum.map(Tuple.to_list(t), f)`	Обработка элементов	`Enum.map(Tuple.to_list({1,2,3}), &(&1*2)) #=> [2,4,6]`
`Enum.into/2`	Создать кортеж	`Enum.into([:a,:b,:c], {}) #=> {:a,:b,:c}`
`Enum.count/1`	Подсчитать элементы	`Enum.count(Tuple.to_list({:a,:b})) #=> 2`

⚙️ Итого

Категория	Основные функции
Создание	`{}`, `Tuple.duplicate/2`
Проверка	`is_tuple/1`, `tuple_size/1`
Доступ / обновление	`elem/2`, `put_elem/3`, `Tuple.insert_at/3`, `Tuple.delete_at/2`
Преобразование	`Tuple.to_list/1`, `List.to_tuple/1`
Комбинирование	через `Tuple.to_list` + `++`
Pattern matching	`{a, b, c} = tuple`

Основные отличия между List и Tuple в Elixir

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

Сравнение List и Tuple

Характеристика	List	Tuple
Изменяемость	Изменяемая (mutable)	Неизменяемая (immutable)
Производительность	Медленнее для доступа и изменения	Быстрее для доступа
Использование памяти	Использует больше памяти	Использует меньше памяти
Структура	Элементы могут быть разного типа	Элементы могут быть разного типа, но фиксированы по количеству
Конкатенация	Легко объединять через `++`	Нет встроенной функции для объединения
Индексация	Индексация начинается с 0	Индексация начинается с 0
Использование	Часто используется при работе с последовательными данными	Подходит для фиксированных наборов данных

Примеры использования

Списки: ``elixir my_list = [1, 2, 3, 4] updated_list = [0 | my_list] # Добавляет 0 в начало списка ``
Кортежи: ``elixir my_tuple = {:ok, "Hello"} ` Обращение к элементам по индексу: `elixir status = elem(my_tuple, 0) # Получает :ok ``

Когда использовать?

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

Эти различия помогают эффективно выбирать между List и Tuple в зависимости от вашей задачи в Elixir.

Создано 18.11.2025 22:13:26
Roman Sakhno

Если у Вас остались какие-либо вопросы, либо у Вас есть желание высказаться по поводу этой статьи, то Вы можете оставить свой комментарий внизу страницы.

Если Вам понравился сайт, то разместите ссылку на него (у себя на сайте, на форуме, в контакте):

itDid