a-js-tools 0.5.4 → 0.6.1

package/README.md

@@ -27,6 +27,14 @@ npm install   a-js-tools  --save
 - `toLowerCamelCase` 转化为小驼峰
 - `toSplitCase` 转化为连接符分隔
 
+## 数组相关
+
+- `intersection` 方法，计算两个数组的交集（两个数组共有的元素）
+- `union` 方法，计算两个数组的并集（两个数组合并在一起并去重）
+- `difference` 方法，计算两个数组的差集（以第一个数组为基准）
+- `symmetricDifference` 方法，计算两个数组的对称差集（在两个数组都不共有的元素）
+- `enArr` 对象，包含上面的方法
+
 ## 查看文档
 
-产看 [https://earthnut.dev/a-js-tools](https://earthnut.dev/a-js-tools)
+查看 [https://earthnut.dev/a-js-tools](https://earthnut.dev/a-js-tools)

package/cjs/index.cjs

@@ -7,7 +7,12 @@ var performance = require('./src/performance.cjs');
 var escapeRegExp = require('./src/regexp/escapeRegExp.cjs');
 var autoEscapedRegExp = require('./src/regexp/autoEscapedRegExp.cjs');
 var isNode = require('./src/isNode.cjs');
-var createConstructor = require('./src/createConstructor.cjs');
+var createConstructor = require('./src/object/createConstructor.cjs');
+var index = require('./src/array/index.cjs');
+var intersection = require('./src/array/intersection.cjs');
+var union = require('./src/array/union.cjs');
+var difference = require('./src/array/difference.cjs');
+var symmetricDifference = require('./src/array/symmetricDifference.cjs');
 
 
 
@@ -23,3 +28,8 @@ exports.autoEscapedRegExp = autoEscapedRegExp.autoEscapedRegExp;
 exports.isBrowser = isNode.isBrowser;
 exports.isNode = isNode.isNode;
 exports.createConstructor = createConstructor.createConstructor;
+exports.enArr = index.enArr;
+exports.intersection = intersection.intersection;
+exports.union = union.union;
+exports.difference = difference.difference;
+exports.symmetricDifference = symmetricDifference.symmetricDifference;

package/cjs/src/array/difference.cjs

@@ -0,0 +1,51 @@
+'use strict';
+
+var aTypeOfJs = require('a-type-of-js');
+
+/**
+ *  求给出的两个数组的差值（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 (a.length === 0 || b.length === 0) {
+        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));
+}
+
+exports.difference = difference;

package/cjs/src/array/index.cjs

@@ -0,0 +1,154 @@
+'use strict';
+
+var intersection = require('./intersection.cjs');
+var union = require('./union.cjs');
+var difference = require('./difference.cjs');
+var symmetricDifference = require('./symmetricDifference.cjs');
+
+/**
+ *
+ * 数组的一些方法
+ *
+ * - 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: union.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: intersection.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: difference.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: symmetricDifference.symmetricDifference,
+};
+
+exports.intersection = intersection.intersection;
+exports.union = union.union;
+exports.difference = difference.difference;
+exports.symmetricDifference = symmetricDifference.symmetricDifference;
+exports.enArr = enArr;

package/cjs/src/array/intersection.cjs

@@ -0,0 +1,45 @@
+'use strict';
+
+var aTypeOfJs = require('a-type-of-js');
+
+/**
+ *
+ * 两个数组的交集
+ *
+ * @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 (a.length === 0 || b.length === 0) {
+        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));
+}
+
+exports.intersection = intersection;

package/cjs/src/array/symmetricDifference.cjs

@@ -0,0 +1,51 @@
+'use strict';
+
+var aTypeOfJs = require('a-type-of-js');
+var difference = require('./difference.cjs');
+
+/**
+ *
+ * 对称差集 （ 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 (a.length === 0) {
+        return [...b];
+    }
+    if (b.length === 0) {
+        return [...a];
+    }
+    return [...difference.difference(a, b), ...difference.difference(b, a)];
+}
+
+exports.symmetricDifference = symmetricDifference;

package/cjs/src/array/union.cjs

@@ -0,0 +1,65 @@
+'use strict';
+
+var aTypeOfJs = require('a-type-of-js');
+
+/**
+ *
+ * 数组的并集
+ *
+ *  <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 (arrays.length === 0) {
+        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);
+}
+
+exports.union = union;

package/mjs/index.mjs

@@ -5,4 +5,9 @@ export { debounce, throttle } from './src/performance.mjs';
 export { escapeRegExp } from './src/regexp/escapeRegExp.mjs';
 export { autoEscapedRegExp } from './src/regexp/autoEscapedRegExp.mjs';
 export { isBrowser, isNode } from './src/isNode.mjs';
-export { createConstructor } from './src/createConstructor.mjs';
+export { createConstructor } from './src/object/createConstructor.mjs';
+export { enArr } from './src/array/index.mjs';
+export { intersection } from './src/array/intersection.mjs';
+export { union } from './src/array/union.mjs';
+export { difference } from './src/array/difference.mjs';
+export { symmetricDifference } from './src/array/symmetricDifference.mjs';

package/mjs/src/array/difference.mjs

@@ -0,0 +1,49 @@
+import { isArray } from 'a-type-of-js';
+
+/**
+ *  求给出的两个数组的差值（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 (!isArray(a) || !isArray(b)) {
+        throw new TypeError('参数需为数组');
+    }
+    if (a.length === 0 || b.length === 0) {
+        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));
+}
+
+export { difference };

package/mjs/src/array/index.mjs

@@ -0,0 +1,148 @@
+import { intersection } from './intersection.mjs';
+import { union } from './union.mjs';
+import { difference } from './difference.mjs';
+import { symmetricDifference } from './symmetricDifference.mjs';
+
+/**
+ *
+ * 数组的一些方法
+ *
+ * - 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,
+};
+
+export { difference, enArr, intersection, symmetricDifference, union };

package/mjs/src/array/intersection.mjs

@@ -0,0 +1,43 @@
+import { isArray } from 'a-type-of-js';
+
+/**
+ *
+ * 两个数组的交集
+ *
+ * @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 (!isArray(a) || !isArray(b)) {
+        throw new TypeError('参数必须是数组类型数据');
+    }
+    // 任意数组为空，则返回空数组
+    if (a.length === 0 || b.length === 0) {
+        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));
+}
+
+export { intersection };

package/mjs/src/array/symmetricDifference.mjs

@@ -0,0 +1,49 @@
+import { isArray } from 'a-type-of-js';
+import { difference } from './difference.mjs';
+
+/**
+ *
+ * 对称差集 （ 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 (!isArray(a) || !isArray(b)) {
+        throw new TypeError('参数必须是数组');
+    }
+    if (a.length === 0) {
+        return [...b];
+    }
+    if (b.length === 0) {
+        return [...a];
+    }
+    return [...difference(a, b), ...difference(b, a)];
+}
+
+export { symmetricDifference };

package/mjs/src/array/union.mjs

@@ -0,0 +1,63 @@
+import { isArray } from 'a-type-of-js';
+
+/**
+ *
+ * 数组的并集
+ *
+ *  <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 (arrays.length === 0) {
+        return [];
+    }
+    if (arrays.some(i => !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);
+}
+
+export { union };

package/package.json

@@ -1,6 +1,6 @@
 {
   "type": "module",
-  "version": "0.5.4",
+  "version": "0.6.1",
   "name": "a-js-tools",
   "description": "一点点 🤏  js 函数",
   "license": "ISC",

package/types/index.d.ts

@@ -3,5 +3,6 @@ export { throttle, debounce } from './src/performance';
 export type { DebounceAndThrottleReturnType } from './src/performance';
 export { escapeRegExp, autoEscapedRegExp } from './src/regexp';
 export { isBrowser, isNode } from './src/isNode';
-export { createConstructor } from './src/createConstructor';
-export type { CreateConstructor } from './src/createConstructor';
+export { createConstructor } from './src/object/createConstructor';
+export type { CreateConstructor } from './src/object/createConstructor';
+export { intersection, enArr, union, difference, symmetricDifference, } from './src/array/';

package/types/src/array/difference.d.ts

@@ -0,0 +1,32 @@
+/**
+ *  求给出的两个数组的差值（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));
+ * ```
+ *
+ */
+export declare function difference<T>(a: T[], b: T[]): T[];

package/types/src/array/index.d.ts

@@ -0,0 +1,146 @@
+import { intersection } from './intersection';
+import { union } from './union';
+import { difference } from './difference';
+import { symmetricDifference } from './symmetricDifference';
+export { union, intersection, difference, symmetricDifference };
+/**
+ *
+ * 数组的一些方法
+ *
+ * - union 两个数组的并集（排除共有项）
+ * - intersection 两个数组的交集（共有项）
+ * - difference 两个数组的差集 （A - B）
+ * - symmetricDifference  对称差集 （ A △ B）
+ *
+ */
+export declare 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: typeof 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: typeof 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: typeof 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: typeof symmetricDifference;
+};

package/types/src/array/intersection.d.ts

@@ -0,0 +1,22 @@
+/**
+ *
+ * 两个数组的交集
+ *
+ * @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]
+ *
+ * ```
+ *
+ */
+export declare function intersection<T>(a: T[], b: T[]): T[];

package/types/src/array/symmetricDifference.d.ts

@@ -0,0 +1,33 @@
+/**
+ *
+ * 对称差集 （ 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, []));
+ *
+ * ```
+ *
+ */
+export declare function symmetricDifference<T>(a: T[], b: T[]): T[];

package/types/src/array/union.d.ts

@@ -0,0 +1,42 @@
+/**
+ *
+ * 数组的并集
+ *
+ *  <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]));
+ * ```
+ *
+ */
+export declare function union<T>(...arrays: T[][]): T[];