@rogolev/value 0.0.3 → 0.0.4

package/docs/helpers/array/array_diff_assoc.md

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

package/docs/helpers/array/array_diff_key.md

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

package/docs/helpers/array/array_diff_uassoc.md

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

package/docs/helpers/array/array_diff_ukey.md

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

package/docs/helpers/array/array_fill.md

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

package/docs/helpers/array/array_fill_keys.md

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

package/docs/helpers/array/array_filter.md

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

package/docs/helpers/array/array_flip.md

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