@rogolev/value 0.0.3 → 0.0.4

package/src/helpers/array/array_uintersect.mjs

@@ -0,0 +1,72 @@
+import array_uintersect_uassoc from './array_uintersect_uassoc.mjs';
+
+/**
+ * Вычисляет пересечение между массивами с использованием пользовательской функции сравнения для значений.
+ *
+ * ### Описание
+ *
+ * Функция `array_uintersect` используется для вычисления пересечения между массивами с использованием пользовательской функции сравнения для значений.
+ * Она возвращает массив, содержащий элементы из первого массива, которые присутствуют в других массивах.
+ *
+ * ### Параметры
+ *
+ * - `value_compare_func` (function): Функция для сравнения значений.
+ * - `original_array` (array): Исходный массив.
+ * - `...arrays` (array): Массивы для сравнения.
+ *
+ * ### Возвращаемое значение
+ *
+ * Возвращает массив, содержащий элементы из первого массива, которые присутствуют в других массивах.
+ *
+ * ### Примеры использования
+ *
+ * 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(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(value_compare_func, original_array, array1);
+ *    console.log(result); // {}
+ *    ```
+ *
+ * 3. Обработка значений, не являющихся массивами:
+ *
+ *    ```js
+ *    try {
+ *        const result = array_uintersect('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(value_compare_func, original_array, array1);
+ *    console.log(result); // { a: 1 }
+ *    ```
+ *
+ * @param {function} value_compare_func Функция для сравнения значений.
+ * @param {object} original_array Исходный массив.
+ * @param {...object} arrays Массивы для сравнения.
+ * @returns {object} Возвращает массив, содержащий элементы из первого массива, которые присутствуют в других массивах.
+ * @throws {TypeError} Если параметры не являются функциями или массивами.
+ */
+export default function array_uintersect(value_compare_func, original_array, ...arrays) {
+    return array_uintersect_uassoc(value_compare_func, () => true, original_array, ...arrays);
+}

package/src/helpers/array/array_uintersect_assoc.mjs

@@ -0,0 +1,77 @@
+import array_uintersect_uassoc from './array_uintersect_uassoc.mjs';
+
+/**
+ * Вычисляет пересечение между массивами с использованием пользовательской функции сравнения для значений и стандартной функции сравнения для ключей.
+ *
+ * ### Описание
+ *
+ * Функция `array_uintersect_assoc` используется для вычисления пересечения между массивами с использованием пользовательской функции сравнения для значений и стандартной функции сравнения для ключей.
+ * Она возвращает массив, содержащий элементы из первого массива, которые присутствуют в других массивах.
+ *
+ * ### Параметры
+ *
+ * - `value_compare_func` (function): Функция для сравнения значений.
+ * - `original_array` (array): Исходный массив.
+ * - `...arrays` (array): Массивы для сравнения.
+ *
+ * ### Возвращаемое значение
+ *
+ * Возвращает массив, содержащий элементы из первого массива, которые присутствуют в других массивах.
+ *
+ * ### Примеры использования
+ *
+ * 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 }
+ *    ```
+ *
+ * @param {function} value_compare_func Функция для сравнения значений.
+ * @param {object} original_array Исходный массив.
+ * @param {...object} arrays Массивы для сравнения.
+ * @returns {object} Возвращает массив, содержащий элементы из первого массива, которые присутствуют в других массивах.
+ * @throws {TypeError} Если параметры не являются функциями или массивами.
+ */
+export default function array_uintersect_assoc(value_compare_func, original_array, ...arrays) {
+    return array_uintersect_uassoc(
+        value_compare_func,
+        (a, b) => a === b,
+        original_array,
+        ...arrays,
+    );
+}

package/src/helpers/array/array_uintersect_uassoc.mjs

@@ -0,0 +1,121 @@
+import is_array from '../is_array.mjs';
+import is_function from '../is_function.mjs';
+
+/**
+ * Вычисляет пересечение между массивами с использованием пользовательских функций сравнения для значений и ключей.
+ *
+ * ### Описание
+ *
+ * Функция `array_uintersect_uassoc` используется для вычисления пересечения между массивами с использованием пользовательских функций сравнения для значений и ключей.
+ * Она возвращает массив, содержащий элементы из первого массива, которые присутствуют в других массивах.
+ *
+ * ### Параметры
+ *
+ * - `value_compare_func` (function): Функция для сравнения значений.
+ * - `key_compare_func` (function): Функция для сравнения ключей.
+ * - `original_array` (array): Исходный массив.
+ * - `...arrays` (array): Массивы для сравнения.
+ *
+ * ### Возвращаемое значение
+ *
+ * Возвращает массив, содержащий элементы из первого массива, которые присутствуют в других массивах.
+ *
+ * ### Примеры использования
+ *
+ * 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); // {}
+ *    ```
+ *
+ * @param {function} value_compare_func Функция для сравнения значений.
+ * @param {function} key_compare_func Функция для сравнения ключей.
+ * @param {object} original_array Исходный массив.
+ * @param {...object} arrays Массивы для сравнения.
+ * @returns {object} Возвращает массив, содержащий элементы из первого массива, которые присутствуют в других массивах.
+ * @throws {TypeError} Если параметры не являются функциями или массивами.
+ */
+export default function array_uintersect_uassoc(
+    value_compare_func,
+    key_compare_func,
+    original_array,
+    ...arrays
+) {
+    if (!is_function(value_compare_func)) {
+        throw new TypeError('Параметр "value_compare_func" должен быть функцией.');
+    }
+
+    if (!is_function(key_compare_func)) {
+        throw new TypeError('Параметр "key_compare_func" должен быть функцией.');
+    }
+
+    if (!is_array(original_array)) {
+        throw new TypeError('Параметр "original_array" должен быть массивом.');
+    }
+
+    if (!arrays.every((v) => is_array(v))) {
+        throw new TypeError('Параметр "arrays" должен быть массивом.');
+    }
+
+    const result = {};
+
+    // Перебираем исходный массив
+    for (const original_key in original_array) {
+        const original_value = original_array[original_key];
+
+        // Каждую пару ключ-значение из исходного массива мы сравниваем с парами из массивов для сравнения.
+        // Если совпадение найдено, записываем ее в результат.
+        for (const array of arrays) {
+            for (const key in array) {
+                const value = array[key];
+
+                if (
+                    key_compare_func(original_key, key) &&
+                    value_compare_func(original_value, value)
+                ) {
+                    result[original_key] = original_value;
+                }
+            }
+        }
+    }
+
+    return result;
+}

package/src/helpers/array/array_unique.mjs

@@ -0,0 +1,77 @@
+import array from '../array.mjs';
+import is_array from '../is_array.mjs';
+import is_list from '../is_list.mjs';
+
+/**
+ * Удаляет дублирующиеся значения из массива.
+ *
+ * ### Описание
+ *
+ * Функция `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" должен быть массивом.
+ *    }
+ *    ```
+ *
+ * @param {object} arr Исходный массив.
+ * @returns {object} Возвращает новый массив без дублирующихся значений.
+ * @throws {TypeError} Если параметр не является массивом.
+ */
+export default function array_unique(arr) {
+    if (!is_array(arr)) {
+        throw new TypeError('Параметр "arr" должен быть массивом.');
+    }
+
+    if (is_list(arr)) {
+        return arr.reduce((carry, v) => {
+            if (!carry.includes(v)) {
+                carry.push(v);
+            }
+
+            return carry;
+        }, []);
+    }
+
+    const result = array({});
+
+    for (const [k, v] of Object.entries(arr)) {
+        if (!Object.values(result).includes(v)) {
+            result[k] = v;
+        }
+    }
+
+    return result;
+}

package/src/helpers/array/array_unshift.mjs

@@ -0,0 +1,64 @@
+import is_array from '../is_array.mjs';
+import array_splice from './array_splice.mjs';
+
+/**
+ * Добавляет один или несколько элементов в начало массива.
+ *
+ * ### Описание
+ *
+ * Функция `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" должен быть массивом.
+ *    }
+ *    ```
+ *
+ * @param {object} arr Исходный массив.
+ * @param {...any} values Элементы для добавления в начало массива.
+ * @returns {number} Возвращает новую длину массива после добавления элементов.
+ * @throws {TypeError} Если параметр не является массивом.
+ */
+export default function array_unshift(arr, ...values) {
+    if (!is_array(arr)) {
+        throw new TypeError('Параметр "arr" должен быть массивом.');
+    }
+
+    array_splice(arr, 0, 0, ...values);
+
+    return Object.keys(arr).length;
+}

package/src/helpers/array/array_values.mjs

@@ -0,0 +1,57 @@
+import is_array from '../is_array.mjs';
+
+/**
+ * Возвращает массив значений из переданного массива или объекта.
+ *
+ * ### Описание
+ *
+ * Функция `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" должен быть массивом.
+ *    }
+ *    ```
+ *
+ * @param {object} arr Исходный массив или объект.
+ * @returns {any[]} Возвращает массив значений из переданного массива или объекта.
+ * @throws {TypeError} Если параметр не является массивом или объектом.
+ */
+export default function array_values(arr) {
+    if (!is_array(arr)) {
+        throw new TypeError('Параметр "arr" должен быть массивом.');
+    }
+
+    return Object.values(arr);
+}

package/src/helpers/array/array_walk.mjs

@@ -0,0 +1,95 @@
+import is_array from '../is_array.mjs';
+import is_function from '../is_function.mjs';
+
+/**
+ * Применяет пользовательскую функцию к каждому элементу массива.
+ *
+ * ### Описание
+ *
+ * Функция `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" должен быть массивом.
+ *    }
+ *    ```
+ *
+ * @param {object} arr Исходный массив.
+ * @param {function} callback Функция, которая будет применена к каждому элементу массива.
+ * @param {any} [arg=null] Дополнительный аргумент, который будет передан в функцию обратного вызова.
+ * @returns {boolean} Возвращает `true` после успешного выполнения функции для всех элементов массива.
+ * @throws {TypeError} Если параметры не являются массивом или функцией.
+ */
+export default function array_walk(arr, callback, arg = null) {
+    if (!is_array(arr)) {
+        throw new TypeError('Параметр "arr" должен быть массивом.');
+    }
+
+    if (!is_function(callback)) {
+        throw new TypeError('Параметр "callback" должен быть функцией.');
+    }
+
+    for (const [k, v] of Object.entries(arr)) {
+        callback(v, k, arg);
+    }
+
+    return true;
+}

package/src/helpers/array/array_walk_recursive.mjs

@@ -0,0 +1,104 @@
+import is_array from '../is_array.mjs';
+import is_function from '../is_function.mjs';
+
+/**
+ * Применяет пользовательскую функцию к каждому элементу массива рекурсивно.
+ *
+ * ### Описание
+ *
+ * Функция `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" должен быть массивом.
+ *    }
+ *    ```
+ *
+ * @param {object} arr Исходный массив.
+ * @param {function} callback Функция, которая будет применена к каждому элементу массива.
+ * @param {any} [arg=null] Дополнительный аргумент, который будет передан в функцию обратного вызова.
+ * @returns {boolean} Возвращает `true` после успешного выполнения функции для всех элементов массива.
+ * @throws {TypeError} Если параметры не являются массивом или функцией.
+ */
+export default function array_walk_recursive(arr, callback, arg = null) {
+    if (!is_array(arr)) {
+        throw new TypeError('Параметр "arr" должен быть массивом.');
+    }
+
+    if (!is_function(callback)) {
+        throw new TypeError('Параметр "callback" должен быть функцией.');
+    }
+
+    for (const [k, v] of Object.entries(arr)) {
+        if (is_array(v)) {
+            array_walk_recursive(v, callback, arg);
+        } else {
+            callback(v, k, arg);
+        }
+    }
+
+    return true;
+}