a-js-tools 1.0.13-beta.0 → 1.0.13-beta.2

package/index.cjs.js

@@ -1,37 +1,883 @@
 'use strict';
 
-var createConstructor = require('./src/object/createConstructor.cjs.js');
-var getRandomNumber = require('./src/getRandomNumber.cjs.js');
-var className = require('./src/className.cjs.js');
-var getRandomString = require('./src/getRandomString.cjs.js');
-var performance = require('./src/performance.cjs.js');
-var escapeRegExp = require('./src/regexp/escapeRegExp.cjs.js');
-var autoEscapedRegExp = require('./src/regexp/autoEscapedRegExp.cjs.js');
-var isNode = require('./src/isNode.cjs.js');
-var index = require('./src/array/index.cjs.js');
-var sleep = require('./src/sleep.cjs.js');
-var intersection = require('./src/array/intersection.cjs.js');
-var union = require('./src/array/union.cjs.js');
-var difference = require('./src/array/difference.cjs.js');
-var symmetricDifference = require('./src/array/symmetricDifference.cjs.js');
-
-
-
-exports.createConstructor = createConstructor.createConstructor;
-exports.getRandomFloat = getRandomNumber.getRandomFloat;
-exports.getRandomInt = getRandomNumber.getRandomInt;
-exports.toLowerCamelCase = className.toLowerCamelCase;
-exports.toSplitCase = className.toSplitCase;
-exports.getRandomString = getRandomString.getRandomString;
-exports.debounce = performance.debounce;
-exports.throttle = performance.throttle;
-exports.escapeRegExp = escapeRegExp.escapeRegExp;
-exports.autoEscapedRegExp = autoEscapedRegExp.autoEscapedRegExp;
-exports.isBrowser = isNode.isBrowser;
-exports.isNode = isNode.isNode;
-exports.enArr = index.enArr;
-exports.sleep = sleep.sleep;
-exports.intersection = intersection.intersection;
-exports.union = union.union;
-exports.difference = difference.difference;
-exports.symmetricDifference = symmetricDifference.symmetricDifference;
+var aTypeOfJs = require('a-type-of-js');
+
+/**
+ *
+ * 构建一个 Constructor 构造函数
+ *
+ * 接收一个构造函数，然后返回 TS 能识别的构造函数自身
+ *
+ * 函数本身并没有执行任何逻辑，仅是简单的返回了实参自身
+ *
+ * 而经过该函数的包装，构造函数成了能够被 TS 识别为可用 new 实例的构造函数
+ *
+ * @param constructor - 传入一个构造函数
+ * @returns 返回传入的构造函数
+ *
+ * ```ts
+ * import { createConstructor } from "a-js-tools";
+ *
+ * type Tom = {
+ *   a: number
+ * }
+ *
+ * function _Tom (this: TomType): Tom {
+ *    this.a = 1;
+ *
+ *    return this;
+ * }
+ *
+ * // 逻辑上没有错，但是会造成 ts 显示
+ * // 其目标缺少构造签名的 "new" 表达式隐式具有 "any" 类型。ts(7009)
+ * const a = new _Tom();
+ *
+ * const tomConstructor = createConstructor(_tom);
+ *
+ * const b = new tomConstructor(); // 这时就不会显示错误
+ *
+ * ```
+ *
+ */
+function createConstructor(constructor) {
+    constructor.prototype.apply = Function.apply;
+    constructor.prototype.bind = Function.bind;
+    constructor.prototype.call = Function.call;
+    constructor.prototype.length = Function.length;
+    // constructor.prototype.arguments = Function.arguments;
+    constructor.prototype.name = Function.name;
+    constructor.prototype.toString = Function.toString;
+    return constructor;
+}
+/** 对象的 assign 用法 */
+function ObjectAssign(target, bar) {
+    const keys = Object.keys(bar);
+    keys.forEach(key => (target[key] = bar[key]));
+    return target;
+}
+
+/**
+ * 过去随机数
+ *
+ * @packageDocumentation
+ * @module @a-js-tools/get-random-number
+ * @license MIT
+ */
+/**
+ *
+ * 获取一个随机的整数类型
+ *
+ * 您可以传入两个参数并获取它们之间的任意数字，返回值<span style="color:#ff0;">*会包含端值*</span>
+ *
+ * 如果只传递一个参数，则如果提供的值为负数，则得到一个小于（或大于）该数字的整数
+ *
+ * @param   max 较大值 ，不允许为`NaN`
+ * @param   min 较小值，不允许为 `NaN`
+ * @returns  任意的整数
+ */
+function getRandomInt(max = 1, min = 0) {
+    //  判断是否为 NaN 或 不是数字
+    if (!isFinite(max) ||
+        !isFinite(min) ||
+        aTypeOfJs.isNaN(max) ||
+        aTypeOfJs.isNaN(min) ||
+        !aTypeOfJs.isNumber(max) ||
+        !aTypeOfJs.isNumber(min)) {
+        throw new TypeError('getRandomInt: max or min is NaN or is not a number');
+    }
+    /**  获取最小值  */
+    let _min = Math.ceil(Number(min)), 
+    /**  获取最大值  */
+    _max = Math.floor(Number(max));
+    //  两值相等时，直接返回最大值
+    if (_max === _min)
+        return _max;
+    //  两值交换
+    if (_min > _max)
+        [_max, _min] = [_min, _max];
+    return Math.round(Math.random() * (_max - _min) + _min);
+}
+/**
+ *
+ * 获取任意的浮点数
+ *
+ * 您可以传入两个参数并获取它们之间的任意数字
+ *
+ * 如果只传入一个参数，则如果提供的值为负数，则获取小于（或大于）该数字的浮点数
+ *
+ * @param   max 较大数，缺省值为 1
+ * @param min 较小值，缺省值为 0
+ * @returns  任意的浮点数
+ */
+function getRandomFloat(max = 1, min = 0) {
+    //  判断是否为 NaN 或 不是数字
+    if (!isFinite(max) ||
+        !isFinite(min) ||
+        aTypeOfJs.isNaN(max) ||
+        aTypeOfJs.isNaN(min) ||
+        !aTypeOfJs.isNumber(max) ||
+        !aTypeOfJs.isNumber(min)) {
+        throw new TypeError('getRandomInt: max or min is NaN or is not a number');
+    }
+    if (max == min)
+        max++;
+    if (min > max)
+        [max, min] = [min, max];
+    return Math.random() * (max - min) + min;
+}
+
+/**
+ * 驼峰命名与连字符命名法的互换
+ *
+ * @packageDocumentation
+ * @module @a-js-tools/class-name
+ * @license MIT
+ */
+/**
+ *
+ * 连字符连接转化为小/大驼峰命名法
+ *
+ * @param str    待转化文本
+ * @param dividingType   连字符，缺省值为 "-"
+ * @param initial 是否转换第一个字符。默认值为 false （小驼峰类型）
+ * @returns 驼峰命名法字符串（e.g. “helloWorld”）
+ *
+ */
+function toLowerCamelCase(
+/**  待转化文本  */
+str, 
+/**  连字符，缺省值为 "-"  */
+dividingType = '-', 
+/** 是否转换第一个字符。默认值为 false （小驼峰类型） */
+initial = false) {
+    let result = str;
+    /**
+     * 匹配规则
+     *
+     * - 匹配到分隔符，将分隔符后面的字符转化为大写
+     */
+    const template = /[\\]|[\^]|[?]|[-]|[.]|[(]|[)]|[|]|[[]\[\]]|[{]|[}]|[+]|[*]|[$]/;
+    /**  转化首字符   */
+    const toTransform = (_str, _dividingType) => _str.replace(new RegExp(`${template.test(_dividingType) ? `\\${_dividingType}` : _dividingType}([a-zA-Z])`, 'g'), (match, p1) => p1.toUpperCase());
+    // 多分隔符转化
+    dividingType
+        .split('')
+        .forEach((item) => (result = toTransform(result, item)));
+    return initial
+        ? result.replace(/^./, (match) => match.toUpperCase())
+        : result;
+}
+/**
+ * 驼峰命名法转化为连字符连接
+ *
+ * @param str          待转化文本
+ * @param dividingType       分割符
+ * @returns 分割符转化的文本 (e.g. 'hello-world')
+ *
+ */
+function toSplitCase(str, dividingType = '-') {
+    const result = str.replace(/[A-Z]/g, (match) => dividingType.concat(match.toLowerCase()));
+    return result.startsWith(dividingType) ? result.substring(1) : result;
+}
+
+/**
+ * 获取随机字符串
+ *
+ * @packageDocumentation
+ * @module @a-js-tools/get-random-string
+ * @license MIT
+ */
+/**
+ *
+ *  获取简单的随机字符串
+ *
+ *  @param   options - 字符串长度
+ *  @returns  - 随机字符串
+ *
+ *
+ */
+function getRandomString(options) {
+    //   验证输入参数
+    if (
+    // 参数类型错误
+    (!aTypeOfJs.isPlainObject(options) && !aTypeOfJs.isNumber(options)) ||
+        // 参数为 NaN
+        (aTypeOfJs.isNumber(options) && aTypeOfJs.isNaN(options)) ||
+        // 参数为数字时为无穷大
+        (aTypeOfJs.isNumber(options) && !isFinite(options)) ||
+        // 参数为数字时为非整数
+        (aTypeOfJs.isNumber(options) && !Number.isInteger(options)) ||
+        // 参数为数字时为负数
+        (aTypeOfJs.isNumber(options) && Number.isInteger(options) && options < 1) ||
+        // 参数为数值然而却小于 1
+        (aTypeOfJs.isNumber(options) && options < 1) ||
+        // 参数为对象但是 length 属性非数值
+        (aTypeOfJs.isPlainObject(options) &&
+            (!aTypeOfJs.isNumber(options.length) ||
+                options.length < 1 ||
+                !Number.isInteger(options.length))))
+        throw new TypeError('参数类型错误 ❌ (getRandomString)');
+    const initOptions = {
+        length: 32,
+        chars: 'abcdefghijklmnopqrstuvwxyz',
+        chars2: '0123456789',
+        chars3: '!@#$%^&*()_+~`|}{[]:;?><,./-=',
+        type: 'string',
+        includeUppercaseLetters: false,
+        includeNumbers: false,
+        includeSpecial: false,
+    };
+    /// 生成 UUID
+    if (initOptions.type === 'uuid')
+        return crypto.randomUUID();
+    // 验证输入参数
+    if (aTypeOfJs.isNumber(options) && Number.isInteger(options) && options > 0)
+        ObjectAssign(initOptions, { length: options });
+    if (aTypeOfJs.isPlainObject(options)) {
+        ObjectAssign(initOptions, options);
+        initOptions.length = initOptions.length < 1 ? 32 : initOptions.length;
+    }
+    /**  生成随机字符串  */
+    const templateCharsArr = initOptions.chars.split('');
+    // 添加大写字母
+    if (initOptions.includeUppercaseLetters)
+        interleaveString(templateCharsArr, initOptions.chars.toUpperCase());
+    // 添加数字
+    if (initOptions.includeNumbers)
+        interleaveString(templateCharsArr, initOptions.chars2);
+    // 添加特殊字符
+    if (initOptions.includeSpecial)
+        interleaveString(templateCharsArr, initOptions.chars3);
+    // 使用密码学安全的随机数生成器
+    const bytes = globalThis.crypto.getRandomValues(new Uint8Array(initOptions.length));
+    let result = '';
+    /**  获取最后的 chars 数据  */
+    const chars = templateCharsArr.join('');
+    // 循环遍历
+    bytes.forEach(byte => (result += chars.charAt(byte % chars.length)));
+    /**
+     *
+     *  字符串交叉函数
+     *
+     *  非线形串交叉，对相交叉
+     *
+     *  @param  str1 - 字符串1
+     *  @param  str2 - 字符串2
+     *  @returns - 交叉后的字符串
+     *  @example
+     *  ```ts
+     *  interleaveString('abc', '123') // 'a1b2c3'
+     *  ```
+     */
+    function interleaveString(str1, str2) {
+        const str1Length = str1.length, str2Length = str2.length;
+        const maxLength = Math.max(str1Length, str2Length);
+        for (let i = 0; i < maxLength; i++) {
+            if (i < str1Length && !aTypeOfJs.isUndefined(str2[i]))
+                str1[i] += str2[i];
+            else if (i < str2Length)
+                str1[i] = str2[i];
+        }
+    }
+    return result;
+}
+
+/**
+ * 防抖和节流
+ *
+ * @packageDocumentation
+ * @module @a-js-tools/performance
+ * @license MIT
+ */
+/**
+ *
+ * 防抖
+ *
+ * @param   callback 回调函数
+ * @param   options    延迟时间（毫秒），默认 200 (ms) 或包含 this 的配置
+ * @returns   返回的闭包函数
+ * @example
+ *
+ * ```ts
+ * const debounce = (callback: Function, delay = 300) => {
+ *   let timer: any = null
+ *   return (...args: any[]) => {
+ *     clearTimeout(timer)
+ *   }
+ * }
+ *
+ */
+function debounce(callback, options = 200) {
+    if (!aTypeOfJs.isFunction(callback))
+        throw new TypeError('callback must be a function');
+    if (aTypeOfJs.isNumber(options))
+        options = {
+            delay: options,
+            this: null,
+        };
+    if (aTypeOfJs.isUndefined(options.delay) ||
+        !isFinite(options.delay) ||
+        options.delay < 0)
+        // 强制转换非数值
+        options.delay = 200;
+    /**  定时器返回的 id  */
+    let timeoutId;
+    const clear = () => {
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+            timeoutId = undefined;
+        }
+    };
+    const delay = options && options.delay ? options.delay : 5;
+    const result = (...args) => {
+        clear();
+        timeoutId = setTimeout(() => {
+            try {
+                const _this = options && options.this ? options.this : null;
+                callback.apply(_this, args);
+                // Reflect.apply(callback, options?.this ?? null, args);
+            }
+            catch (error) {
+                console.log('Debounce callback throw an error', error);
+            }
+        }, Math.max(delay, 5));
+    };
+    result.cancel = () => clear();
+    return result;
+}
+/**
+ *   节流
+ *
+ * @param callback   回调函数
+ * @param options      延迟时间（毫秒），默认 200 (ms) 或设置 this
+ * @returns   返回的闭包函数
+ */
+function throttle(callback, options = 200) {
+    if (!aTypeOfJs.isFunction(callback))
+        throw new TypeError('callback must be a function');
+    if (aTypeOfJs.isNumber(options))
+        options = {
+            delay: options,
+            this: null,
+        };
+    if (aTypeOfJs.isUndefined(options.delay) ||
+        !isFinite(options.delay) ||
+        options.delay < 0)
+        // 强制转换非数值
+        options.delay = 200;
+    /**  延迟控制插销   */
+    let inThrottle = false;
+    /**  延迟控制   */
+    let timeoutId = null;
+    const delay = options && options.delay ? options.delay : 5;
+    const throttled = (...args) => {
+        if (inThrottle)
+            return;
+        try {
+            const _this = options && options.this ? options.this : null;
+            callback.apply(_this, args);
+        }
+        catch (error) {
+            console.error('Throttle 执行回调抛出问题', error);
+        }
+        inThrottle = true;
+        if (!aTypeOfJs.isNull(timeoutId))
+            clearTimeout(timeoutId);
+        timeoutId = setTimeout(() => {
+            inThrottle = false;
+            timeoutId = null;
+        }, Math.max(delay, 5));
+    };
+    throttled.cancel = () => {
+        if (!aTypeOfJs.isNull(timeoutId))
+            clearTimeout(timeoutId);
+        inThrottle = false;
+        timeoutId = null;
+    };
+    return throttled;
+}
+
+/**
+ *
+ * 将一个字符串转化为符合正则要求的字符串
+ *
+ * @param str 需要转义的字符串
+ * @requires escapeRegExp 转化后字符串
+ * @example
+ *
+ * ```ts
+ *  import { escapeRegExp  } from 'a-js-tools';
+ *
+ *  escapeRegExp('a.b.c'); // 'a\\.b\\.c'
+ *  escapeRegExp('a\\.b\\.c'); // 'a\\\\.b\\\\.c'
+ *  escapeRegExp('[a-z]'); // '\\[a-z\\]'
+ *  escapeRegExp('^abc$'); // '\\^abc\\$'
+ * ```
+ */
+function escapeRegExp(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+/**
+ *
+ * 解析 options
+ *
+ */
+function parse(options) {
+    // 处理 options
+    if (aTypeOfJs.isString(options)) {
+        options = {
+            flags: options,
+        };
+    }
+    // 处理 flags
+    if (!aTypeOfJs.isString(options.flags))
+        options.flags = '';
+    else {
+        // 需求是保留字符串中的某一部分，使用
+        const regexp = /[migsuy]/g;
+        const matchResult = options.flags.match(regexp);
+        if (aTypeOfJs.isNull(matchResult))
+            options.flags = '';
+        else
+            options.flags = [...new Set(matchResult)].join('');
+    }
+    return options;
+}
+
+/**
+ *
+ * ##  适用于简单的文本字符串自动转化为简单模式正则表达式
+ *
+ * *若字符串包含且需保留字符类、组、反向引用、量词等时，该方法可能不适用*
+ *
+ * @param pattern 待转化的文本字符串
+ * @param options 转化选项。 为文本字符串时，默认为正则表达式的标志，还可指定是否匹配开头或结尾
+ * @returns 正则表达式
+ * @example
+ *
+ * ```ts
+ * import { autoEscapedRegExp } from 'a-regexp';
+ *
+ * autoEscapedRegExp('abc'); // => /abc/
+ * autoEscapedRegExp('abc', 'gim'); // => /abc/gim
+ * autoEscapedRegExp('abc',  { flags: 'g', start: true }); // => /^abc/g
+ * autoEscapedRegExp('abc',  { flags: 'g', end: true }); // => /abc$/g
+ * autoEscapedRegExp('abc',  { start: true, end: true }); // => /^abc$/
+ *
+ * // 转化特殊字符类、组、反向引用、量词等
+ * // 无法保留匹配规则
+ * autoEscapedRegExp('a-zA-Z0-9'); // => /a-zA-Z0-9/
+ * autoEscapedRegExp('a-zA-Z0-9', 'g'); // => /a-zA-Z0-9/g
+ * autoEscapedRegExp('[a-zA-Z0-9]'); // => /\[a-zA-Z0-9\]/
+ * autoEscapedRegExp('^[a-zA-Z0-9]+$'); // => /\^\[a-zA-Z0-9\]\$/
+ *
+ * ```
+ *
+ */
+function autoEscapedRegExp(pattern, options) {
+    if (!aTypeOfJs.isString(pattern))
+        throw new TypeError('pattern must be a 字符串');
+    pattern = escapeRegExp(pattern);
+    /** 简单转化  */
+    if (aTypeOfJs.isUndefined(options))
+        return new RegExp(pattern);
+    options = parse(options);
+    return new RegExp(`${options.start ? '^' : ''}${pattern}${options.end ? '$' : ''}`, options.flags);
+}
+
+/**
+ *
+ * 判断当前环境是否为 node 环境
+ *
+ */
+function isNode() {
+    return !aTypeOfJs.isUndefined((globalThis &&
+        globalThis.process &&
+        globalThis.process.versions &&
+        globalThis.process.versions.node) ||
+        undefined);
+}
+/**
+ *
+ * 是否为浏览器环境
+ *
+ */
+function isBrowser() {
+    return !isNode();
+}
+
+/**
+ *
+ * 两个数组的交集
+ *
+ * @param a 数组 1️⃣
+ * @param b 数组 2️⃣
+ * @returns 返回两个数组的交集
+ * @example
+ *
+ * ```ts
+ * import { intersection } from 'a-js-tools';
+ *
+ * const log = console.log;
+ *
+ *
+ * log(intersection([1, 2, 3, 4], [2, 3])); // [2, 3]
+ * log(intersection([1, 3, 5, 7], [2, 3, 4])); // [3]
+ *
+ * ```
+ *
+ */
+function intersection(a, b) {
+    if (!aTypeOfJs.isArray(a) || !aTypeOfJs.isArray(b))
+        throw new TypeError('参数必须是数组类型数据');
+    // 任意数组为空，则返回空数组
+    if (aTypeOfJs.isEmptyArray(a) || aTypeOfJs.isEmptyArray(b))
+        return [];
+    /**
+     * 在实际运算中， new Set() 的 开销为 O(n) ,filter 的开销也为 O(n)
+     *
+     * 但是以较短的数组创建 Set ，可以节省内存开销
+     */
+    const [shorter, longer] = a.length <= b.length ? [a, b] : [b, a];
+    // 提前创建工具 Set
+    const shortSet = new Set(shorter);
+    return longer.filter(item => shortSet.has(item));
+}
+
+/**
+ *
+ * 数组的并集
+ *
+ *  <span style="color:#f36;">请注意，参数有不为数组时直接抛出 TypeError</span>
+ * @param arrays  - 多个数组
+ * @returns 联合后的数组
+ *
+ *
+ * @example
+ *
+ * ```ts
+ * import { union } from 'a-js-tools';
+ *
+ * const log = console.log;
+ *
+ * // []
+ * log(union());
+ *
+ * // [1, 2, 3]
+ * log(union([1, 2, 3]));
+ *
+ * //  TypeError
+ * log(union([1, 2, 3], 'i'));
+ * log(union([1, 2, 3], undefined));
+ * log(union([1, 2, 3], null));
+ * log(union([1, 2, 3], 4));
+ * log(union([1, 2, 3], {}));
+ * log(union([1, 2, 3], false));
+ *
+ * // [1, 2, 3, 4, 6]
+ * log(union([1, 2, 3], [2, 4, 6]));
+ *
+ * // [1, 2, 3, 4, 6]
+ * log(union([1, 2, 3], [2, 4, 6], [1, 2, 3]));
+ *
+ * // [1, 2, 3, 4, 6]
+ * log(union([1, 2, 3], [2, 4, 6], [1, 2, 3], [1, 2, 3]));
+ * ```
+ *
+ */
+function union(...arrays) {
+    if (aTypeOfJs.isEmptyArray(arrays))
+        return [];
+    if (arrays.some(i => !aTypeOfJs.isArray(i)))
+        throw new TypeError('参数必须都是数组形式的元素');
+    if (arrays.length === 1)
+        return [...arrays[0]];
+    const resultSet = new Set();
+    for (const array of arrays) {
+        for (const item of array)
+            resultSet.add(item);
+    }
+    return Array.from(resultSet);
+}
+
+/**
+ *  求给出的两个数组的差值（A - B）
+ *
+ * @param a  - 第一个数组
+ * @param b - 第二个数组
+ * @throws {TypeError} 当两个参数有一个不是
+ * @description 当两个参数有一个不是数组时将抛出
+ * @returns 返回第一个参数相对第二个参数的差值
+ * @example
+ *
+ * ```ts
+ * import { difference} from 'a-js-tools';
+ *
+ * const log = console.log;
+ *
+ *
+ * log(difference([], [1, 2, 3])); // []
+ *
+ * log([1, 2, 3], []); //[1, 2, 3]
+ *
+ * log([1, 2, 3, 4, 5, 6, 7], [1, 2, 3, 4, 5]); //[6, 7]
+ *
+ * // 将抛出 TypeError
+ * log(difference([1, 2, 3], 'a'));
+ * log(difference([1, 2, 3], 1));
+ * log(difference([1, 2, 3], undefined));
+ * log(difference([1, 2, 3], null));
+ * log(difference([1, 2, 3],  true));
+ * ```
+ *
+ */
+function difference(a, b) {
+    if (!aTypeOfJs.isArray(a) || !aTypeOfJs.isArray(b))
+        throw new TypeError('参数需为数组');
+    if (aTypeOfJs.isEmptyArray(a) || aTypeOfJs.isEmptyArray(b))
+        return a;
+    /**  获取两个数组中长度较小的  */
+    // 参数有顺序要求
+    // const [shorter, longer] = a.length > b.length ? [b, a] : [a, b];
+    // const shorterSet = new Set(shorter);
+    const bSet = new Set(b);
+    return a.filter(i => !bSet.has(i));
+}
+
+/**
+ *
+ * 对称差集 （ A △ B）
+ *
+ * @param a  - 数组 a
+ * @param b  - 数组 b
+ * @returns - 返回一个全新的数组
+ *
+ * @example
+ *
+ * ```ts
+ * import { symmetricDifference } from 'a-js-tools';
+ *
+ * const log = console.log;
+ *
+ * log(symmetricDifference([1, 2], [2, 3])); // [1, 3]
+ *
+ * log(symmetricDifference([1, 2, 3], [1, 2, 4])); // [3, 4]
+ *
+ * log(symmetricDifference([1, 2, 3], [1, 2, 3])); // []
+ *
+ *
+ * /// TypeError
+ * log(symmetricDifference(1, []));
+ * log(symmetricDifference(undefined, []));
+ * log(symmetricDifference(null, []));
+ * log(symmetricDifference('a', []));
+ * log(symmetricDifference(true, []));
+ *
+ * ```
+ *
+ */
+function symmetricDifference(a, b) {
+    if (!aTypeOfJs.isArray(a) || !aTypeOfJs.isArray(b))
+        throw new TypeError('参数必须是数组');
+    if (aTypeOfJs.isEmptyArray(a))
+        return [...b];
+    if (aTypeOfJs.isEmptyArray(b))
+        return [...a];
+    return [...difference(a, b), ...difference(b, a)];
+}
+
+/**
+ *
+ * 数组的一些方法
+ *
+ * - union 两个数组的并集（排除共有项）
+ * - intersection 两个数组的交集（共有项）
+ * - difference 两个数组的差集 （A - B）
+ * - symmetricDifference  对称差集 （ A △ B）
+ *
+ */
+const enArr = {
+    /**
+     *
+     * 数组的并集
+     *
+     *  <span style="color:#f36;">请注意，参数有不为数组时直接抛出 TypeError</span>
+     * @param arrays  - 多个数组
+     * @returns 联合后的数组
+     *
+     *
+     * @example
+     *
+     * ```ts
+     * import { union } from 'a-js-tools';
+     *
+     * const log = console.log;
+     *
+     * // []
+     * log(union());
+     *
+     * // [1, 2, 3]
+     * log(union([1, 2, 3]));
+     *
+     * //  TypeError
+     * log(union([1, 2, 3], 'i'));
+     * log(union([1, 2, 3], undefined));
+     * log(union([1, 2, 3], null));
+     * log(union([1, 2, 3], 4));
+     * log(union([1, 2, 3], {}));
+     * log(union([1, 2, 3], false));
+     *
+     * // [1, 2, 3, 4, 6]
+     * log(union([1, 2, 3], [2, 4, 6]));
+     *
+     * // [1, 2, 3, 4, 6]
+     * log(union([1, 2, 3], [2, 4, 6], [1, 2, 3]));
+     *
+     * // [1, 2, 3, 4, 6]
+     * log(union([1, 2, 3], [2, 4, 6], [1, 2, 3], [1, 2, 3]));
+     * ```
+     *
+     */
+    union,
+    /**
+     *
+     * 两个数组的交集
+     *
+     * @param a 数组 1️⃣
+     * @param b 数组 2️⃣
+     * @returns 返回两个数组的交集
+     * @example
+     *
+     * ```ts
+     * import { intersection } from 'a-js-tools';
+     *
+     * const log = console.log;
+     *
+     *
+     * log(intersection([1, 2, 3, 4], [2, 3])); // [2, 3]
+     * log(intersection([1, 3, 5, 7], [2, 3, 4])); // [3]
+     *
+     * ```
+     *
+     */
+    intersection,
+    /**
+     *  求给出的两个数组的差值（A - B）
+     *
+     * @param a  - 第一个数组
+     * @param b - 第二个数组
+     * @throws {TypeError} 当两个参数有一个不是
+     * @description 当两个参数有一个不是数组时将抛出
+     * @returns 返回第一个参数相对第二个参数的差值
+     * @example
+     *
+     * ```ts
+     * import { difference} from 'a-js-tools';
+     *
+     * const log = console.log;
+     *
+     *
+     * log(difference([], [1, 2, 3])); // []
+     *
+     * log([1, 2, 3], []); //[1, 2, 3]
+     *
+     * log([1, 2, 3, 4, 5, 6, 7], [1, 2, 3, 4, 5]); //[6, 7]
+     *
+     * // 将抛出 TypeError
+     * log(difference([1, 2, 3], 'a'));
+     * log(difference([1, 2, 3], 1));
+     * log(difference([1, 2, 3], undefined));
+     * log(difference([1, 2, 3], null));
+     * log(difference([1, 2, 3],  true));
+     * ```
+     *
+     */
+    difference,
+    /**
+     *
+     * 对称差集 （ A △ B）
+     *
+     * @param a  - 数组 a
+     * @param b  - 数组 b
+     * @returns - 返回一个全新的数组
+     *
+     * @example
+     *
+     * ```ts
+     * import { symmetricDifference } from 'a-js-tools';
+     *
+     * const log = console.log;
+     *
+     * log(symmetricDifference([1, 2], [2, 3])); // [1, 3]
+     *
+     * log(symmetricDifference([1, 2, 3], [1, 2, 4])); // [3, 4]
+     *
+     * log(symmetricDifference([1, 2, 3], [1, 2, 3])); // []
+     *
+     *
+     * /// TypeError
+     * log(symmetricDifference(1, []));
+     * log(symmetricDifference(undefined, []));
+     * log(symmetricDifference(null, []));
+     * log(symmetricDifference('a', []));
+     * log(symmetricDifference(true, []));
+     *
+     * ```
+     *
+     */
+    symmetricDifference,
+};
+
+/**
+ *
+ * ## 线程休息
+ *
+ * 但从调用到执行完毕总是与期望的时间并不相吻合，除非执行是线型的（也不保证时间的严格性）
+ *
+ * - 宏任务：整体代码、setTimeout、DOM 事件回调、requestAnimationFrame、setImmediate、setInterval、I/O操作、UI渲染等
+ * - 微任务：Promise的then/catch/finally、process.nextTick（Node.js）、MutationObserver、queueMicrotask（显示添加微任务）等
+ *
+ * <span style="color:#ff0;">*Node.js中的process.nextTick优先级高于其他微任务*</span>
+ *
+ * @param delay 睡觉时长（机器时间，毫秒为单位）
+ * @returns 🈳
+ * @example
+ *
+ * ```ts
+ * import { sleep } from 'a-js-tools';
+ *
+ * console.log(Date.now()); // 1748058118471
+ * await sleep(1000);
+ * console.log(Date.now()); // 1748058119473
+ *
+ * ```
+ *
+ */
+async function sleep(delay = 1000) {
+    if (!isFinite(delay) || delay < 0)
+        throw new TypeError('delay 应该是一个正常的数值');
+    if (aTypeOfJs.isZero(delay))
+        return Promise.resolve();
+    return new Promise(resolve => setTimeout(resolve, delay));
+}
+
+exports.ObjectAssign = ObjectAssign;
+exports.autoEscapedRegExp = autoEscapedRegExp;
+exports.createConstructor = createConstructor;
+exports.debounce = debounce;
+exports.difference = difference;
+exports.enArr = enArr;
+exports.escapeRegExp = escapeRegExp;
+exports.getRandomFloat = getRandomFloat;
+exports.getRandomInt = getRandomInt;
+exports.getRandomString = getRandomString;
+exports.intersection = intersection;
+exports.isBrowser = isBrowser;
+exports.isNode = isNode;
+exports.sleep = sleep;
+exports.symmetricDifference = symmetricDifference;
+exports.throttle = throttle;
+exports.toLowerCamelCase = toLowerCamelCase;
+exports.toSplitCase = toSplitCase;
+exports.union = union;