@rogolev/value 0.0.3 → 0.0.5

package/docs/helpers/array/array_index_max.md

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

package/docs/helpers/array/array_index_min.md

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

package/docs/helpers/array/array_intersect.md

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

package/docs/helpers/array/array_intersect_assoc.md

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

package/docs/helpers/array/array_intersect_key.md

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

package/docs/helpers/array/array_intersect_uassoc.md

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

package/docs/helpers/array/array_intersect_ukey.md

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