@rogolev/value 0.0.3 → 0.0.4

package/docs/helpers/string/natcompare_numeric.md

@@ -0,0 +1,70 @@
+[Главная](../../../README.md) / [Помощники](../../helpers.md) / natcompare_numeric
+
+[Исходный код](../../../src/helpers/string/natcompare_numeric.mjs)
+
+# natcompare_numeric
+
+`natcompare_numeric` — Сравнивает две строки, содержащие числовые значения, в естественном
+порядке.
+
+## Сигнатура функции
+
+```ts
+function natcompare_numeric(a: string, b: string): number;
+```
+
+## Описание
+
+Функция `natcompare_numeric` используется для сравнения двух строк, содержащих числовые значения, в
+естественном порядке. Она поддерживает строки с ведущими нулями и игнорирует их при сравнении.
+
+## Параметры
+
+- `a` (string): Первая строка для сравнения.
+- `b` (string): Вторая строка для сравнения.
+
+## Возвращаемое значение
+
+Возвращает отрицательное значение, если `a` меньше `b`, ноль, если `a` равно `b`, и положительное
+значение, если `a` больше `b`.
+
+## Примеры использования
+
+1. Сравнение строк с числовыми значениями:
+
+    ```js
+    const result = natcompare_numeric('10', '2');
+    console.log(result); // 1
+    ```
+
+2. Сравнение строк с ведущими нулями:
+
+    ```js
+    const result = natcompare_numeric('0010', '10');
+    console.log(result); // 0
+    ```
+
+3. Сравнение строк с пробелами:
+
+    ```js
+    const result = natcompare_numeric(' 10', '10');
+    console.log(result); // 0
+    ```
+
+4. Сравнение строк с буквами и числами:
+
+    ```js
+    const result = natcompare_numeric('a10', 'a2');
+    console.log(result); // 1
+    ```
+
+5. Сравнение строк с разными символами:
+
+    ```js
+    const result = natcompare_numeric('10-', '10+');
+    console.log(result); // 0
+    ```
+
+## Исключения
+
+- `TypeError`: Если параметры не являются строками.

package/docs/helpers.md

@@ -1,6 +1,8 @@
 [Главная](../README.md) / Помощники
 
-# Помощники для работы с типами данных
+# Помощники
+
+## Помощники для работы с типами данных
 
 - [array](./helpers/array.md) — Создаёт массив из переданных значений, обрабатывая
   ассоциативные массивы (объекты с ключами).
@@ -14,6 +16,7 @@
   типом (`boolean`).
 - [is_boolean](./helpers/is_boolean.md) — Проверяет, является ли переданное значение
   логическим типом (`boolean`).
+- [is_char](./helpers/is_char.md) — Проверяет, является ли значение одиночным символом.
 - [is_class](./helpers/is_class.md) — Проверяет, является ли переданная переменная классом.
 - [is_float](./helpers/is_float.md) — Проверяет, является ли значение числом с плавающей
   точкой.
@@ -51,3 +54,124 @@
 - [to_string](./helpers/to_string.md) — Преобразует значение в строку.
 - [value](./helpers/value.md) — Создает новый экземпляр класса `Value` с заданным значением.
 
+## Помощники для работы с массивами
+
+- [array_chunk_with_keys](./helpers/array/array_chunk_with_keys.md) — Разбивает массив на
+  части указанной длины с сохранением ключей.
+- [array_chunk](./helpers/array/array_chunk.md) — Разбивает массив на части указанной длины.
+- [array_column](./helpers/array/array_column.md) — Извлекает значения указанного столбца из
+  массива объектов.
+- [array_combine](./helpers/array/array_combine.md) — Объединяет два массива в ассоциативный
+  массив.
+- [array_count_values](./helpers/array/array_count_values.md) — Подсчитывает количество
+  значений в массиве.
+- [array_diff_assoc](./helpers/array/array_diff_assoc.md) — Вычисляет расхождение между
+  массивами с использованием стандартной функции сравнения значений и ключей.
+- [array_diff_key](./helpers/array/array_diff_key.md) — Вычисляет расхождение между массивами
+  с использованием стандартной функции сравнения ключей.
+- [array_diff_uassoc](./helpers/array/array_diff_uassoc.md) — Вычисляет расхождение между
+  массивами с использованием пользовательской функции сравнения ключей.
+- [array_diff_ukey](./helpers/array/array_diff_ukey.md) — Вычисляет расхождение между
+  массивами с использованием пользовательской функции сравнения для ключей.
+- [array_diff](./helpers/array/array_diff.md) — Вычисляет расхождение между массивами.
+- [array_fill_keys](./helpers/array/array_fill_keys.md) — Заполняет массив значениями по
+  указанным ключам.
+- [array_fill](./helpers/array/array_fill.md) — Заполняет массив значениями, начиная с
+  указанного индекса.
+- [array_filter](./helpers/array/array_filter.md) — Фильтрует элементы массива с
+  использованием функции обратного вызова.
+- [array_flip](./helpers/array/array_flip.md) — Меняет местами ключи и значения в массиве.
+- [array_index_max](./helpers/array/array_index_max.md) — Возвращает максимальный индекс
+  массива.
+- [array_index_min](./helpers/array/array_index_min.md) — Возвращает минимальный индекс
+  массива.
+- [array_intersect_assoc](./helpers/array/array_intersect_assoc.md) — Вычисляет пересечение
+  между массивами с использованием стандартной функции сравнения для значений и ключей.
+- [array_intersect_key](./helpers/array/array_intersect_key.md) — Вычисляет пересечение между
+  массивами с использованием стандартной функции сравнения для ключей.
+- [array_intersect_uassoc](./helpers/array/array_intersect_uassoc.md) — Вычисляет пересечение
+  между массивами с использованием пользовательской функции сравнения для значений и ключей.
+- [array_intersect_ukey](./helpers/array/array_intersect_ukey.md) — Вычисляет пересечение
+  между массивами с использованием пользовательской функции сравнения для ключей.
+- [array_intersect](./helpers/array/array_intersect.md) — Вычисляет пересечение между
+  массивами с использованием стандартной функции сравнения значений.
+- [array_key_exists](./helpers/array/array_key_exists.md) — Проверяет, существует ли указанный
+  ключ в массиве.
+- [array_key_first](./helpers/array/array_key_first.md) — Возвращает первый ключ массива.
+- [array_key_last](./helpers/array/array_key_last.md) — Возвращает последний ключ массива.
+- [array_key_to_lower_case](./helpers/array/array_key_to_lower_case.md) — Преобразует ключи
+  ассоциативного массива в нижний регистр.
+- [array_key_to_upper_case](./helpers/array/array_key_to_upper_case.md) — Преобразует ключи
+  ассоциативного массива в верхний регистр.
+- [array_keys](./helpers/array/array_keys.md) — Возвращает массив ключей из переданного
+  массива или объекта.
+- [array_map](./helpers/array/array_map.md) — Применяет функцию обратного вызова к каждому
+  элементу массива.
+- [array_merge_recursive](./helpers/array/array_merge_recursive.md) — Объединяет несколько
+  массивов рекурсивно.
+- [array_merge](./helpers/array/array_merge.md) — Объединяет несколько массивов в один.
+- [array_pad](./helpers/array/array_pad.md) — Дополняет массив до заданной длины указанным
+  значением.
+- [array_pop](./helpers/array/array_pop.md) — Удаляет и возвращает последний элемент массива.
+- [array_product](./helpers/array/array_product.md) — Вычисляет произведение значений массива.
+- [array_push](./helpers/array/array_push.md) — Добавляет один или несколько элементов в конец
+  массива.
+- [array_rand](./helpers/array/array_rand.md) — Возвращает один или несколько случайных ключей
+  из массива.
+- [array_reduce](./helpers/array/array_reduce.md) — Применяет функцию обратного вызова к
+  каждому элементу массива (слева направо), чтобы уменьшить его до одного значения.
+- [array_replace_recursive](./helpers/array/array_replace_recursive.md) — Рекурсивно заменяет
+  значения в массиве на значения из других массивов.
+- [array_replace](./helpers/array/array_replace.md) — Заменяет значения в массиве на значения
+  из других массивов.
+- [array_reverse](./helpers/array/array_reverse.md) — Переворачивает массив, изменяя порядок
+  его элементов на обратный.
+- [array_search](./helpers/array/array_search.md) — Ищет значение в массиве и возвращает ключ
+  первого найденного элемента.
+- [array_shift](./helpers/array/array_shift.md) — Удаляет и возвращает первый элемент массива.
+- [array_slice](./helpers/array/array_slice.md) — Возвращает новый массив, содержащий часть
+  исходного массива.
+- [array_splice](./helpers/array/array_splice.md) — Удаляет элементы из массива и, при
+  необходимости, добавляет новые элементы на их место.
+- [array_sum](./helpers/array/array_sum.md) — Вычисляет сумму значений массива.
+- [array_udiff_assoc](./helpers/array/array_udiff_assoc.md) — Вычисляет расхождение между
+  массивами с использованием пользовательской функции сравнения для значений и ассоциативного
+  сравнения ключей.
+- [array_udiff_uassoc](./helpers/array/array_udiff_uassoc.md) — Вычисляет расхождение между
+  массивами с использованием пользовательских функций сравнения для значений и ключей.
+- [array_udiff](./helpers/array/array_udiff.md) — Вычисляет расхождение между массивами с
+  использованием пользовательской функции сравнения для значений.
+- [array_uintersect_assoc](./helpers/array/array_uintersect_assoc.md) — Вычисляет пересечение
+  между массивами с использованием пользовательской функции сравнения для значений и стандартной
+  функции сравнения для ключей.
+- [array_uintersect_uassoc](./helpers/array/array_uintersect_uassoc.md) — Вычисляет
+  пересечение между массивами с использованием пользовательских функций сравнения для значений и
+  ключей.
+- [array_uintersect](./helpers/array/array_uintersect.md) — Вычисляет пересечение между
+  массивами с использованием пользовательской функции сравнения для значений.
+- [array_unique](./helpers/array/array_unique.md) — Удаляет дублирующиеся значения из массива.
+- [array_unshift](./helpers/array/array_unshift.md) — Добавляет один или несколько элементов в
+  начало массива.
+- [array_values](./helpers/array/array_values.md) — Возвращает массив значений из переданного
+  массива или объекта.
+- [array_walk_recursive](./helpers/array/array_walk_recursive.md) — Применяет пользовательскую
+  функцию к каждому элементу массива рекурсивно.
+- [array_walk](./helpers/array/array_walk.md) — Применяет пользовательскую функцию к каждому
+  элементу массива.
+- [count](./helpers/array/count.md) — Возвращает количество элементов в массиве или
+  ассоциативном массиве.
+- [in_array](./helpers/array/in_array.md) — Проверяет, существует ли значение в массиве.
+- [natsort](./helpers/array/natsort.md) — Сортирует массив в естественном порядке.
+- [range](./helpers/array/range.md) — Генерирует массив значений от start до end с шагом step.
+- [shuffle](./helpers/array/shuffle.md) — Перемешивает элементы массива в случайном порядке.
+- [sort](./helpers/array/sort.md) — Сортирует элементы массива с использованием функции
+  сравнения.
+
+## Помощники для работы со строками
+
+- [is_digit_char](./helpers/string/is_digit_char.md) — Проверяет, является ли символ цифрой.
+- [is_whitespace_char](./helpers/string/is_whitespace_char.md) — Проверяет, является ли символ
+  пробельным.
+- [natcompare_numeric](./helpers/string/natcompare_numeric.md) — Сравнивает две строки,
+  содержащие числовые значения, в естественном порядке.
+- [natcompare](./helpers/string/natcompare.md) — Сравнивает две строки в естественном порядке.

package/index.mjs

@@ -40,4 +40,69 @@ export { default as Type } from './src/classes/Type.mjs';
 export { default as Convert } from './src/classes/Convert.mjs';
 export { default as Value } from './src/classes/Value.mjs';
 export * from './src/constants.mjs';
-
+export { default as array_key_to_lower_case } from './src/helpers/array/array_key_to_lower_case.mjs';
+export { default as array_key_to_upper_case } from './src/helpers/array/array_key_to_upper_case.mjs';
+export { default as array_chunk } from './src/helpers/array/array_chunk.mjs';
+export { default as array_chunk_with_keys } from './src/helpers/array/array_chunk_with_keys.mjs';
+export { default as array_column } from './src/helpers/array/array_column.mjs';
+export { default as array_combine } from './src/helpers/array/array_combine.mjs';
+export { default as array_count_values } from './src/helpers/array/array_count_values.mjs';
+export { default as array_udiff_uassoc } from './src/helpers/array/array_udiff_uassoc.mjs';
+export { default as array_udiff } from './src/helpers/array/array_udiff.mjs';
+export { default as array_udiff_assoc } from './src/helpers/array/array_udiff_assoc.mjs';
+export { default as array_diff } from './src/helpers/array/array_diff.mjs';
+export { default as array_diff_ukey } from './src/helpers/array/array_diff_ukey.mjs';
+export { default as array_diff_uassoc } from './src/helpers/array/array_diff_uassoc.mjs';
+export { default as array_diff_key } from './src/helpers/array/array_diff_key.mjs';
+export { default as array_diff_assoc } from './src/helpers/array/array_diff_assoc.mjs';
+export { default as array_uintersect_uassoc } from './src/helpers/array/array_uintersect_uassoc.mjs';
+export { default as array_uintersect } from './src/helpers/array/array_uintersect.mjs';
+export { default as array_uintersect_assoc } from './src/helpers/array/array_uintersect_assoc.mjs';
+export { default as array_intersect } from './src/helpers/array/array_intersect.mjs';
+export { default as array_intersect_ukey } from './src/helpers/array/array_intersect_ukey.mjs';
+export { default as array_intersect_uassoc } from './src/helpers/array/array_intersect_uassoc.mjs';
+export { default as array_intersect_key } from './src/helpers/array/array_intersect_key.mjs';
+export { default as array_intersect_assoc } from './src/helpers/array/array_intersect_assoc.mjs';
+export { default as array_fill } from './src/helpers/array/array_fill.mjs';
+export { default as array_fill_keys } from './src/helpers/array/array_fill_keys.mjs';
+export { default as array_filter } from './src/helpers/array/array_filter.mjs';
+export { default as array_flip } from './src/helpers/array/array_flip.mjs';
+export { default as array_index_max } from './src/helpers/array/array_index_max.mjs';
+export { default as array_index_min } from './src/helpers/array/array_index_min.mjs';
+export { default as array_key_exists } from './src/helpers/array/array_key_exists.mjs';
+export { default as array_key_first } from './src/helpers/array/array_key_first.mjs';
+export { default as array_key_last } from './src/helpers/array/array_key_last.mjs';
+export { default as array_keys } from './src/helpers/array/array_keys.mjs';
+export { default as array_map } from './src/helpers/array/array_map.mjs';
+export { default as array_merge } from './src/helpers/array/array_merge.mjs';
+export { default as array_merge_recursive } from './src/helpers/array/array_merge_recursive.mjs';
+export { default as array_pad } from './src/helpers/array/array_pad.mjs';
+export { default as array_pop } from './src/helpers/array/array_pop.mjs';
+export { default as array_reduce } from './src/helpers/array/array_reduce.mjs';
+export { default as array_product } from './src/helpers/array/array_product.mjs';
+export { default as array_push } from './src/helpers/array/array_push.mjs';
+export { default as array_rand } from './src/helpers/array/array_rand.mjs';
+export { default as array_replace } from './src/helpers/array/array_replace.mjs';
+export { default as array_replace_recursive } from './src/helpers/array/array_replace_recursive.mjs';
+export { default as array_reverse } from './src/helpers/array/array_reverse.mjs';
+export { default as array_search } from './src/helpers/array/array_search.mjs';
+export { default as array_shift } from './src/helpers/array/array_shift.mjs';
+export { default as array_slice } from './src/helpers/array/array_slice.mjs';
+export { default as array_splice } from './src/helpers/array/array_splice.mjs';
+export { default as array_sum } from './src/helpers/array/array_sum.mjs';
+export { default as array_unique } from './src/helpers/array/array_unique.mjs';
+export { default as array_unshift } from './src/helpers/array/array_unshift.mjs';
+export { default as array_values } from './src/helpers/array/array_values.mjs';
+export { default as array_walk } from './src/helpers/array/array_walk.mjs';
+export { default as array_walk_recursive } from './src/helpers/array/array_walk_recursive.mjs';
+export { default as count } from './src/helpers/array/count.mjs';
+export { default as in_array } from './src/helpers/array/in_array.mjs';
+export { default as range } from './src/helpers/array/range.mjs';
+export { default as shuffle } from './src/helpers/array/shuffle.mjs';
+export { default as sort } from './src/helpers/array/sort.mjs';
+export { default as is_char } from './src/helpers/is_char.mjs';
+export { default as is_whitespace_char } from './src/helpers/string/is_whitespace_char.mjs';
+export { default as is_digit_char } from './src/helpers/string/is_digit_char.mjs';
+export { default as natcompare_numeric } from './src/helpers/string/natcompare_numeric.mjs';
+export { default as natcompare } from './src/helpers/string/natcompare.mjs';
+export { default as natsort } from './src/helpers/array/natsort.mjs';

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@rogolev/value",
-    "version": "0.0.3",
+    "version": "0.0.4",
     "description": "Библиотека, переосмысливающая типы данных и работу с ними.",
     "type": "module",
     "repository": {
@@ -46,3 +46,4 @@
         "test": "jest"
     }
 }
+

package/prettier.config.mjs

@@ -146,7 +146,7 @@ export default {
      * - `crlf` - Символы Carriage Return + Line Feed (\r\n).
      * - `cr` - Только символ Carriage Return (\r).
      */
-    endOfLine: 'crlf',
+    endOfLine: 'lf',
 
     /**
      * Изменить, когда свойства в объектах заключаются в кавычки.
@@ -222,3 +222,4 @@ export default {
      */
     useTabs: false,
 };
+

package/src/helpers/array/array_chunk.mjs

@@ -0,0 +1,102 @@
+import is_array from '../is_array.mjs';
+import is_int from '../is_int.mjs';
+
+/**
+ * Разбивает массив на части указанной длины.
+ *
+ * ### Описание
+ *
+ * Функция `array_chunk` используется для разбивки массива на части указанной длины.
+ * Если переданное значение не является массивом, функция выбрасывает ошибку типа `TypeError`.
+ * Если длина не является целым числом или меньше 1, функция выбрасывает соответствующую ошибку.
+ *
+ * ### Параметры
+ *
+ * - `value` (array): Массив, который необходимо разбить на части.
+ * - `length` (number): Длина каждой части.
+ *
+ * ### Возвращаемое значение
+ *
+ * Возвращает новый массив, содержащий части исходного массива.
+ *
+ * ### Примеры использования
+ *
+ * 1. Разбивка массива на части указанной длины:
+ *
+ *    ```js
+ *    const array = [1, 2, 3, 4, 5];
+ *    const result = array_chunk(array, 2);
+ *    console.log(result); // [[1, 2], [3, 4], [5]]
+ *    ```
+ *
+ * 2. Обработка пустого массива:
+ *
+ *    ```js
+ *    const array = [];
+ *    const result = array_chunk(array, 2);
+ *    console.log(result); // []
+ *    ```
+ *
+ * 3. Обработка ассоциативного массива:
+ *
+ *    ```js
+ *    const assoc = { key1: 'value1', key2: 'value2', key3: 'value3', key4: 'value4' };
+ *    const result = array_chunk(assoc, 2);
+ *    console.log(result); // [['value1', 'value2'], ['value3', 'value4']]
+ *    ```
+ *
+ * 4. Обработка значения, не являющегося массивом:
+ *
+ *    ```js
+ *    try {
+ *        const result = array_chunk('not an array', 2);
+ *    } catch (e) {
+ *        console.error(e.message); // Параметр "value" должен быть массивом.
+ *    }
+ *    ```
+ *
+ * 5. Обработка некорректной длины:
+ *
+ *    ```js
+ *    try {
+ *        const result = array_chunk([1, 2, 3], 'not an integer');
+ *    } catch (e) {
+ *        console.error(e.message); // Параметр "length" должен быть целым числом.
+ *    }
+ *
+ *    try {
+ *        const result = array_chunk([1, 2, 3], 0);
+ *    } catch (e) {
+ *        console.error(e.message); // Параметр "length" должен быть больше нуля.
+ *    }
+ *    ```
+ *
+ * @param {array} value Массив, который необходимо разбить на части.
+ * @param {number} length Длина каждой части.
+ * @returns {array} Возвращает новый массив, содержащий части исходного массива.
+ * @throws {TypeError} Если переданное значение не является массивом.
+ * @throws {TypeError} Если длина не является целым числом.
+ * @throws {Error} Если длина меньше 1.
+ */
+export default function array_chunk(value, length) {
+    if (!is_array(value)) {
+        throw new TypeError('Параметр "value" должен быть массивом.');
+    }
+
+    if (!is_int(length)) {
+        throw new TypeError('Параметр "length" должен быть целым числом.');
+    }
+
+    if (length < 1) {
+        throw new Error('Параметр "length" должен быть больше нуля.');
+    }
+
+    const result = [];
+    const values = Object.values(value);
+
+    while (values.length) {
+        result.push(values.splice(0, length));
+    }
+
+    return result;
+}

package/src/helpers/array/array_chunk_with_keys.mjs

@@ -0,0 +1,102 @@
+import is_array from '../is_array.mjs';
+import is_int from '../is_int.mjs';
+
+/**
+ * Разбивает массив на части указанной длины с сохранением ключей.
+ *
+ * ### Описание
+ *
+ * Функция `array_chunk_with_keys` используется для разбивки массива на части указанной длины с сохранением ключей.
+ * Если переданное значение не является массивом, функция выбрасывает ошибку типа `TypeError`.
+ * Если длина не является целым числом или меньше 1, функция выбрасывает соответствующую ошибку.
+ *
+ * ### Параметры
+ *
+ * - `value` (array): Массив, который необходимо разбить на части.
+ * - `length` (number): Длина каждой части.
+ *
+ * ### Возвращаемое значение
+ *
+ * Возвращает новый массив, содержащий части исходного массива с сохранением ключей.
+ *
+ * ### Примеры использования
+ *
+ * 1. Разбивка ассоциативного массива на части указанной длины с сохранением ключей:
+ *
+ *    ```js
+ *    const assoc = { a: 1, b: 2, c: 3, d: 4, e: 5 };
+ *    const result = array_chunk_with_keys(assoc, 2);
+ *    console.log(result); // [{ a: 1, b: 2 }, { c: 3, d: 4 }, { e: 5 }]
+ *    ```
+ *
+ * 2. Обработка пустого ассоциативного массива:
+ *
+ *    ```js
+ *    const assoc = {};
+ *    const result = array_chunk_with_keys(assoc, 2);
+ *    console.log(result); // []
+ *    ```
+ *
+ * 3. Разбивка обычного массива на части указанной длины с сохранением ключей:
+ *
+ *    ```js
+ *    const array = [1, 2, 3, 4, 5];
+ *    const result = array_chunk_with_keys(array, 2);
+ *    console.log(result); // [{ 0: 1, 1: 2 }, { 2: 3, 3: 4 }, { 4: 5 }]
+ *    ```
+ *
+ * 4. Обработка значения, не являющегося массивом:
+ *
+ *    ```js
+ *    try {
+ *        const result = array_chunk_with_keys('not an array', 2);
+ *    } catch (e) {
+ *        console.error(e.message); // Параметр "value" должен быть массивом.
+ *    }
+ *    ```
+ *
+ * 5. Обработка некорректной длины:
+ *
+ *    ```js
+ *    try {
+ *        const result = array_chunk_with_keys([1, 2, 3], 'not an integer');
+ *    } catch (e) {
+ *        console.error(e.message); // Параметр "length" должен быть целым числом.
+ *    }
+ *
+ *    try {
+ *        const result = array_chunk_with_keys([1, 2, 3], 0);
+ *    } catch (e) {
+ *        console.error(e.message); // Параметр "length" должен быть больше нуля.
+ *    }
+ *    ```
+ *
+ * @param {array} value Массив, который необходимо разбить на части.
+ * @param {number} length Длина каждой части.
+ * @returns {array} Возвращает новый массив, содержащий части исходного массива с сохранением ключей.
+ * @throws {TypeError} Если переданное значение не является массивом.
+ * @throws {TypeError} Если длина не является целым числом.
+ * @throws {Error} Если длина меньше 1.
+ */
+export default function array_chunk_with_keys(value, length) {
+    if (!is_array(value)) {
+        throw new TypeError('Параметр "value" должен быть массивом.');
+    }
+
+    if (!is_int(length)) {
+        throw new TypeError('Параметр "length" должен быть целым числом.');
+    }
+
+    if (length < 1) {
+        throw new Error('Параметр "length" должен быть больше нуля.');
+    }
+
+    const result = [];
+    const entries = Object.entries(value);
+
+    while (entries.length) {
+        result.push(Object.fromEntries(entries.splice(0, length)));
+    }
+
+    return result;
+}

package/src/helpers/array/array_column.mjs

@@ -0,0 +1,131 @@
+import array from '../array.mjs';
+import is_int from '../is_int.mjs';
+import is_list from '../is_list.mjs';
+import is_null from '../is_null.mjs';
+import is_string from '../is_string.mjs';
+
+/**
+ * Извлекает значения указанного столбца из массива объектов.
+ *
+ * ### Описание
+ *
+ * Функция `array_column` используется для извлечения значений указанного столбца из массива объектов.
+ * Если переданное значение не является списком, функция выбрасывает ошибку типа `TypeError`.
+ * Если ключ столбца или индексный ключ не являются строкой или целым числом, функция выбрасывает соответствующую ошибку.
+ *
+ * ### Параметры
+ *
+ * - `value` (array): Массив объектов, из которого необходимо извлечь значения.
+ * - `column_key` (string | number): Ключ столбца, значения которого необходимо извлечь.
+ * - `index_key` (string | number | null): Ключ, который будет использоваться для индексации возвращаемого массива (по умолчанию `null`).
+ *
+ * ### Возвращаемое значение
+ *
+ * Возвращает массив значений указанного столбца. Если указан индексный ключ, возвращает объект с индексированными значениями.
+ *
+ * ### Примеры использования
+ *
+ * 1. Извлечение значений указанного столбца из массива объектов:
+ *
+ *    ```js
+ *    const array = [
+ *        { id: 1, name: 'Alice' },
+ *        { id: 2, name: 'Bob' },
+ *        { id: 3, name: 'Charlie' },
+ *    ];
+ *    const result = array_column(array, 'name');
+ *    console.log(result); // ['Alice', 'Bob', 'Charlie']
+ *    ```
+ *
+ * 2. Извлечение значений указанного столбца с использованием индексного ключа:
+ *
+ *    ```js
+ *    const array = [
+ *        { id: 1, name: 'Alice' },
+ *        { id: 2, name: 'Bob' },
+ *        { id: 3, name: 'Charlie' },
+ *    ];
+ *    const result = array_column(array, 'name', 'id');
+ *    console.log(result); // { 1: 'Alice', 2: 'Bob', 3: 'Charlie' }
+ *    ```
+ *
+ * 3. Обработка пустого массива:
+ *
+ *    ```js
+ *    const array = [];
+ *    const result = array_column(array, 'name');
+ *    console.log(result); // []
+ *    ```
+ *
+ * 4. Обработка значения, не являющегося массивом:
+ *
+ *    ```js
+ *    try {
+ *        const result = array_column('not an array', 'name');
+ *    } catch (e) {
+ *        console.error(e.message); // Параметр "value" должен быть списком.
+ *    }
+ *    ```
+ *
+ * 5. Обработка некорректного ключа столбца:
+ *
+ *    ```js
+ *    const array = [
+ *        { id: 1, name: 'Alice' },
+ *        { id: 2, name: 'Bob' },
+ *        { id: 3, name: 'Charlie' },
+ *    ];
+ *    try {
+ *        const result = array_column(array, {});
+ *    } catch (e) {
+ *        console.error(e.message); // Параметр "column_key" должен быть строкой или целым числом.
+ *    }
+ *    ```
+ *
+ * 6. Обработка некорректного индексного ключа:
+ *
+ *    ```js
+ *    const array = [
+ *        { id: 1, name: 'Alice' },
+ *        { id: 2, name: 'Bob' },
+ *        { id: 3, name: 'Charlie' },
+ *    ];
+ *    try {
+ *        const result = array_column(array, 'name', {});
+ *    } catch (e) {
+ *        console.error(e.message); // Параметр "index_key" должен быть строкой или целым числом.
+ *    }
+ *    ```
+ *
+ * @param {array} value Массив объектов, из которого необходимо извлечь значения.
+ * @param {string | number} column_key Ключ столбца, значения которого необходимо извлечь.
+ * @param {string | number | null} [index_key=null] Ключ, который будет использоваться для индексации возвращаемого массива.
+ * @returns {array | object} Возвращает массив значений указанного столбца. Если указан индексный ключ, возвращает объект с индексированными значениями.
+ * @throws {TypeError} Если переданное значение не является списком.
+ * @throws {TypeError} Если ключ столбца или индексный ключ не являются строкой или целым числом.
+ */
+export default function array_column(value, column_key, index_key = null) {
+    if (!is_list(value)) {
+        throw new TypeError('Параметр "value" должен быть списком.');
+    }
+
+    if (!is_string(column_key) && !is_int(column_key)) {
+        throw new TypeError('Параметр "column_key" должен быть строкой или целым числом.');
+    }
+
+    if (!is_null(index_key) && !is_string(index_key) && !is_int(index_key)) {
+        throw new TypeError('Параметр "index_key" должен быть строкой или целым числом.');
+    }
+
+    if (is_null(index_key)) {
+        return Object.values(value).map((model) => model[column_key]);
+    }
+
+    const result = array({});
+
+    for (const model of value) {
+        result[model[index_key]] = model[column_key];
+    }
+
+    return result;
+}