@rogolev/value 0.0.3 → 0.0.4

package/CHANGELOG.md

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

package/docs/helpers/array/array_chunk.md

@@ -0,0 +1,80 @@
+[Главная](../../../README.md) / [Помощники](../../helpers.md) / array_chunk
+
+[Исходный код](../../../src/helpers/array/array_chunk.mjs)
+
+# array_chunk
+
+`array_chunk` — Разбивает массив на части указанной длины.
+
+## Сигнатура функции
+
+```ts
+function array_chunk(value: array, length: number): array;
+```
+
+## Описание
+
+Функция `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" должен быть больше нуля.
+    }
+    ```

package/docs/helpers/array/array_chunk_with_keys.md

@@ -0,0 +1,81 @@
+[Главная](../../../README.md) / [Помощники](../../helpers.md) / array_chunk_with_keys
+
+[Исходный код](../../../src/helpers/array/array_chunk_with_keys.mjs)
+
+# array_chunk_with_keys
+
+`array_chunk_with_keys` — Разбивает массив на части указанной длины с сохранением ключей.
+
+## Сигнатура функции
+
+```ts
+function array_chunk_with_keys(value: array, length: number): array;
+```
+
+## Описание
+
+Функция `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" должен быть больше нуля.
+    }
+    ```

package/docs/helpers/array/array_column.md

@@ -0,0 +1,110 @@
+[Главная](../../../README.md) / [Помощники](../../helpers.md) / array_column
+
+[Исходный код](../../../src/helpers/array/array_column.mjs)
+
+# array_column
+
+`array_column` — Извлекает значения указанного столбца из массива объектов.
+
+## Сигнатура функции
+
+```ts
+function array_column(
+    value: array,
+    column_key: string | number,
+    index_key?: string | number | null,
+): array | object;
+```
+
+## Описание
+
+Функция `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" должен быть строкой или целым числом.
+    }
+    ```

package/docs/helpers/array/array_combine.md

@@ -0,0 +1,77 @@
+[Главная](../../../README.md) / [Помощники](../../helpers.md) / array_combine
+
+[Исходный код](../../../src/helpers/array/array_combine.mjs)
+
+# array_combine
+
+`array_combine` — Объединяет два массива в ассоциативный массив.
+
+## Сигнатура функции
+
+```ts
+function array_combine(keys: array, values: array): object;
+```
+
+## Описание
+
+Функция `array_combine` используется для объединения двух массивов в ассоциативный массив. Если
+переданное значение для ключей или значений не является списком, функция выбрасывает ошибку типа
+`TypeError`. Если количество ключей и значений не совпадает, функция выбрасывает ошибку.
+
+## Параметры
+
+- `keys` (array): Массив ключей.
+- `values` (array): Массив значений.
+
+## Возвращаемое значение
+
+Возвращает ассоциативный массив, где ключи из первого массива соответствуют значениям из второго
+массива.
+
+## Примеры использования
+
+1. Объединение двух массивов в ассоциативный массив:
+
+    ```js
+    const keys = ['a', 'b', 'c'];
+    const values = [1, 2, 3];
+    const result = array_combine(keys, values);
+    console.log(result); // { a: 1, b: 2, c: 3 }
+    ```
+
+2. Обработка пустых массивов:
+
+    ```js
+    const keys = [];
+    const values = [];
+    const result = array_combine(keys, values);
+    console.log(result); // {}
+    ```
+
+3. Обработка значения, не являющегося массивом:
+
+    ```js
+    try {
+        const result = array_combine('not an array', [1, 2, 3]);
+    } catch (e) {
+        console.error(e.message); // Параметр "keys" должен быть списком.
+    }
+
+    try {
+        const result = array_combine(['a', 'b', 'c'], 'not an array');
+    } catch (e) {
+        console.error(e.message); // Параметр "values" должен быть списком.
+    }
+    ```
+
+4. Обработка некорректного количества ключей и значений:
+
+    ```js
+    const keys = ['a', 'b'];
+    const values = [1, 2, 3];
+    try {
+        const result = array_combine(keys, values);
+    } catch (e) {
+        console.error(e.message); // Количество элементов в списке ключей должно ровняться количеству элементов в списке значений.
+    }
+    ```

package/docs/helpers/array/array_count_values.md

@@ -0,0 +1,71 @@
+[Главная](../../../README.md) / [Помощники](../../helpers.md) / array_count_values
+
+[Исходный код](../../../src/helpers/array/array_count_values.mjs)
+
+# array_count_values
+
+`array_count_values` — Подсчитывает количество значений в массиве.
+
+## Сигнатура функции
+
+```ts
+function array_count_values(value: object): object;
+```
+
+## Описание
+
+Функция `array_count_values` используется для подсчета количества значений в массиве. Если
+переданное значение не является массивом, функция выбрасывает ошибку типа `TypeError`.
+
+## Параметры
+
+- `value` (array): Массив значений, которые необходимо подсчитать.
+
+## Возвращаемое значение
+
+Возвращает объект, где ключи представляют уникальные значения из массива, а значения представляют
+количество их вхождений.
+
+## Примеры использования
+
+1. Подсчет количества значений в массиве:
+
+    ```js
+    const array = ['a', 'b', 'a', 'c', 'b', 'a'];
+    const result = array_count_values(array);
+    console.log(result); // { a: 3, b: 2, c: 1 }
+    ```
+
+2. Обработка пустого массива:
+
+    ```js
+    const array = [];
+    const result = array_count_values(array);
+    console.log(result); // {}
+    ```
+
+3. Обработка значений разных типов:
+
+    ```js
+    const array = [1, '1', true, 'true', null, 'null', undefined, 'undefined'];
+    const result = array_count_values(array);
+    console.log(result); // { 1: 2, true: 2, null: 2, undefined: 2 }
+    ```
+
+4. Обработка значения, не являющегося массивом:
+
+    ```js
+    try {
+        const result = array_count_values('not an array');
+    } catch (e) {
+        console.error(e.message); // Параметр "value" должен быть массивом.
+    }
+    ```
+
+5. Обработка ассоциативных массивов:
+
+    ```js
+    const assoc = { key1: 'a', key2: 'b', key3: 'a', key4: 'c' };
+    const result = array_count_values(assoc);
+    console.log(result); // { a: 2, b: 1, c: 1 }
+    ```

package/docs/helpers/array/array_diff.md

@@ -0,0 +1,97 @@
+[Главная](../../../README.md) / [Помощники](../../helpers.md) / array_diff
+
+[Исходный код](../../../src/helpers/array/array_diff.mjs)
+
+# array_diff
+
+`array_diff` — Вычисляет расхождение между массивами.
+
+## Сигнатура функции
+
+```ts
+function array_diff(original_array: object, ...arrays: object[]): object;
+```
+
+## Описание
+
+Функция `array_diff` используется для вычисления расхождения между массивами. Она возвращает
+ассоциативный массив, содержащий элементы из первого массива, которые отсутствуют в других массивах.
+
+## Параметры
+
+- `original_array` (object): Исходный массив.
+- `...arrays` (object): Массивы для сравнения.
+
+## Возвращаемое значение
+
+Возвращает ассоциативный массив, содержащий элементы из первого массива, которые отсутствуют в
+других массивах.
+
+## Примеры использования
+
+1. Сравнение массивов:
+
+    ```js
+    const original_array = [1, 2, 3];
+    const array1 = [1, 2];
+    const result = array_diff(original_array, array1);
+    console.log(result); // { 2: 3 }
+    ```
+
+2. Обработка пустых массивов:
+
+    ```js
+    const original_array = [];
+    const array1 = [];
+    const result = array_diff(original_array, array1);
+    console.log(result); // {}
+    ```
+
+3. Сравнение массивов с различными типами данных:
+
+    ```js
+    const original_array = [1, '2', true];
+    const array1 = [1, 2, false];
+    const result = array_diff(original_array, array1);
+    console.log(result); // { 1: '2', 2: true }
+    ```
+
+4. Сравнение массивов с объектами:
+
+    ```js
+    const original_array = [{ id: 1 }, { id: 2 }, { id: 3 }];
+    const array1 = [{ id: 1 }, { id: 2 }];
+    const result = array_diff(original_array, array1);
+    console.log(result); // { 2: { id: 3 } }
+    ```
+
+5. Сравнение ассоциативных массивов:
+
+    ```js
+    const original_array = { a: 1, b: 2, c: 3 };
+    const array1 = { a: 1, b: 2 };
+    const result = array_diff(original_array, array1);
+    console.log(result); // { c: 3 }
+    ```
+
+6. Сравнение нескольких массивов:
+
+    ```js
+    const original_array = [1, 2, 3, 4];
+    const array1 = [1, 2];
+    const array2 = [3];
+    const result = array_diff(original_array, array1, array2);
+    console.log(result); // { 3: 4 }
+    ```
+
+7. Сравнение массивов с вложенными структурами:
+
+    ```js
+    const original_array = [
+        { id: 1, data: [1, 2] },
+        { id: 2, data: [3, 4] },
+    ];
+    const array1 = [{ id: 1, data: [1, 2] }];
+    const result = array_diff(original_array, array1);
+    console.log(result); // { 1: { id: 2, data: [3, 4] } }
+    ```