@rogolev/value 0.0.3 → 0.0.5

package/docs/helpers/array/array_uintersect_assoc.md

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

package/docs/helpers/array/array_uintersect_uassoc.md

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

package/docs/helpers/array/array_unique.md

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

package/docs/helpers/array/array_unshift.md

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

package/docs/helpers/array/array_values.md

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

package/docs/helpers/array/array_walk.md

@@ -0,0 +1,87 @@
+[Главная](../../../README.md) / [Помощники](../../helpers.md) / array_walk
+
+[Исходный код](../../../src/helpers/array/array_walk.mjs)
+
+# array_walk
+
+`array_walk` — Применяет пользовательскую функцию к каждому элементу массива.
+
+## Сигнатура функции
+
+```ts
+function array_walk(arr: object, callback: function, arg: any = null): boolean;
+```
+
+## Описание
+
+Функция `array_walk` используется для применения пользовательской функции к каждому элементу
+массива. Она поддерживает как обычные массивы, так и ассоциативные массивы (объекты с ключами и
+значениями).
+
+## Параметры
+
+- `arr` (object): Исходный массив.
+- `callback` (function): Функция, которая будет применена к каждому элементу массива.
+- `arg` (any): Дополнительный аргумент, который будет передан в функцию обратного вызова. По
+  умолчанию `null`.
+
+## Возвращаемое значение
+
+Возвращает `true` после успешного выполнения функции для всех элементов массива.
+
+## Примеры использования
+
+1. Применение функции к каждому элементу обычного массива:
+
+    ```js
+    const array = [1, 2, 3];
+    array_walk(array, (value, key) => {
+        console.log(`Ключ: ${key}, Значение: ${value}`);
+    });
+    // Вывод:
+    // Ключ: 0, Значение: 1
+    // Ключ: 1, Значение: 2
+    // Ключ: 2, Значение: 3
+    ```
+
+2. Применение функции к каждому элементу ассоциативного массива:
+
+    ```js
+    const array = { a: 1, b: 2, c: 3 };
+    array_walk(array, (value, key) => {
+        console.log(`Ключ: ${key}, Значение: ${value}`);
+    });
+    // Вывод:
+    // Ключ: a, Значение: 1
+    // Ключ: b, Значение: 2
+    // Ключ: c, Значение: 3
+    ```
+
+3. Применение функции с дополнительным аргументом:
+
+    ```js
+    const array = [1, 2, 3];
+    array_walk(
+        array,
+        (value, key, arg) => {
+            console.log(`Ключ: ${key}, Значение: ${value}, Аргумент: ${arg}`);
+        },
+        'дополнительный аргумент',
+    );
+    // Вывод:
+    // Ключ: 0, Значение: 1, Аргумент: дополнительный аргумент
+    // Ключ: 1, Значение: 2, Аргумент: дополнительный аргумент
+    // Ключ: 2, Значение: 3, Аргумент: дополнительный аргумент
+    ```
+
+4. Обработка значений, не являющихся массивами:
+
+    ```js
+    try {
+        array_walk('not an array', (value, key) => {
+            console.log(`Ключ: ${key}, Значение: ${value}`);
+        });
+    } catch (e) {
+        console.error(e.message); // Параметр "arr" должен быть массивом.
+    }
+    ```

package/docs/helpers/array/array_walk_recursive.md

@@ -0,0 +1,93 @@
+[Главная](../../../README.md) / [Помощники](../../helpers.md) / array_walk_recursive
+
+[Исходный код](../../../src/helpers/array/array_walk_recursive.mjs)
+
+# array_walk_recursive
+
+`array_walk_recursive` — Применяет пользовательскую функцию к каждому элементу массива
+рекурсивно.
+
+## Сигнатура функции
+
+```ts
+function array_walk_recursive(arr: object, callback: function, arg: any = null): boolean;
+```
+
+## Описание
+
+Функция `array_walk_recursive` используется для применения пользовательской функции к каждому
+элементу массива рекурсивно. Она поддерживает как обычные массивы, так и ассоциативные массивы
+(объекты с ключами и значениями).
+
+## Параметры
+
+- `arr` (object): Исходный массив.
+- `callback` (function): Функция, которая будет применена к каждому элементу массива.
+- `arg` (any): Дополнительный аргумент, который будет передан в функцию обратного вызова. По
+  умолчанию `null`.
+
+## Возвращаемое значение
+
+Возвращает `true` после успешного выполнения функции для всех элементов массива.
+
+## Примеры использования
+
+1. Применение функции к каждому элементу обычного массива:
+
+    ```js
+    const array = [1, 2, [3, 4], 5];
+    array_walk_recursive(array, (value, key) => {
+        console.log(`Ключ: ${key}, Значение: ${value}`);
+    });
+    // Вывод:
+    // Ключ: 0, Значение: 1
+    // Ключ: 1, Значение: 2
+    // Ключ: 0, Значение: 3
+    // Ключ: 1, Значение: 4
+    // Ключ: 3, Значение: 5
+    ```
+
+2. Применение функции к каждому элементу ассоциативного массива:
+
+    ```js
+    const array = { a: 1, b: { c: 2, d: 3 }, e: 4 };
+    array_walk_recursive(array, (value, key) => {
+        console.log(`Ключ: ${key}, Значение: ${value}`);
+    });
+    // Вывод:
+    // Ключ: a, Значение: 1
+    // Ключ: c, Значение: 2
+    // Ключ: d, Значение: 3
+    // Ключ: e, Значение: 4
+    ```
+
+3. Применение функции с дополнительным аргументом:
+
+    ```js
+    const array = [1, 2, [3, 4], 5];
+    array_walk_recursive(
+        array,
+        (value, key, arg) => {
+            console.log(`Ключ: ${key}, Значение: ${value}, Аргумент: ${arg}`);
+        },
+        'дополнительный аргумент',
+    );
+    // Вывод:
+    // Ключ: 0, Значение: 1, Аргумент: дополнительный аргумент
+    // Ключ: 1, Значение: 2, Аргумент: дополнительный аргумент
+    // Ключ: 0, Значение: 3, Аргумент: дополнительный аргумент
+    // Ключ: 1, Значение: 4, Аргумент: дополнительный аргумент
+    // Ключ: 3, Значение: 5, Аргумент: дополнительный аргумент
+    ```
+
+4. Обработка значений, не являющихся массивами:
+
+    ```js
+    try {
+        array_walk_recursive('not an array', (value, key) => {
+            console.log(`Ключ: ${key}, Значение: ${value}`);
+        });
+    } catch (e) {
+        console.error(e.message); // Параметр "arr" должен быть массивом.
+    }
+    ```

package/docs/helpers/array/count.md

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