✨ feature(lib): In the plan, all random string and array functions have been completed, and the code coverage rate is 100%

Author: kwooshung

package.json

@@ -74,5 +74,8 @@
     "tsup": "^8.0.1",
     "typescript": "^5.3.3"
   },
-  "license": "MIT"
+  "license": "MIT",
+  "dependencies": {
+    "decimal.js": "^10.4.3"
+  }
 }

pnpm-lock.yaml

@@ -1 +1,9 @@
+export { default as number } from './number';
+export { default as numberStep } from './number/step';
+export { default as numberNonConsecutiveFn } from './number/nonConsecutiveFn';
+export { default as numbers } from './number/array';
+export { default as numbersUnique } from './number/unique';
 export { default as string } from './string';
+export { default as stringNonConsecutiveFn } from './string/nonConsecutiveFn';
+export { default as strings } from './string/array';
+export { default as stringsUnique } from './string/unique';

src/index.ts

@@ -0,0 +1,42 @@
+import array from '.';
+
+describe('@/number/array', () => {
+  it('生成指定长度和范围的随机数数组', () => {
+    const result = array(1, 10, 5);
+    expect(result).toHaveLength(5);
+    result.forEach((num) => {
+      expect(num).toBeGreaterThanOrEqual(1);
+      expect(num).toBeLessThanOrEqual(10);
+    });
+  });
+
+  it('当步长非0时，生成步长间隔的随机数数组', () => {
+    const result = array(0, 10, 6, 2);
+    expect(result).toHaveLength(6);
+    result.forEach((num) => {
+      expect(num % 2).toBe(0);
+    });
+  });
+
+  it('当未指定数量时，默认生成长度为10的数组', () => {
+    const result = array(1, 10);
+    expect(result).toHaveLength(10);
+  });
+
+  it('当最小值等于最大值时，数组中所有元素相同', () => {
+    const result = array(5, 5, 5);
+    expect(result).toHaveLength(5);
+    result.forEach((num) => {
+      expect(num).toBe(5);
+    });
+  });
+
+  it('当步长为0时，生成最小值和最大值之间的随机数数组', () => {
+    const result = array(0, 5, 5, 0);
+    expect(result).toHaveLength(5);
+    result.forEach((num) => {
+      expect(num).toBeGreaterThanOrEqual(0);
+      expect(num).toBeLessThanOrEqual(5);
+    });
+  });
+});

src/number/array/index.test.ts

@@ -0,0 +1,13 @@
+import stepFn from '@/number/step';
+
+/**
+ * 生成指定数量的随机数数组
+ * @param {number} minimum 最小值 (Minimum value)
+ * @param {number} maximum 最大值 (Maximum value)
+ * @param {number} [count = 10] 数组长度 (Array length)
+ * @param {number} [step = 0] 步长，如果为 0 则不限制步长，假设 minimum 为 0，maximum 为 10，step 为 2，则生成的随机数为 0、2、4、6、8、10 (Step size, if it is 0, the step size is not limited, assuming that the minimum is 0, the maximum is 10, and the step is 2, then the generated random number is 0, 2, 4, 6, 8, 10)
+ * @returns {number[]} 随机数数组 (Random number array)
+ */
+const array = (minimum: number, maximum: number, count: number = 10, step: number = 0): number[] => Array.from({ length: count }, () => stepFn(minimum, maximum, step));
+
+export default array;

src/number/array/index.ts

@@ -0,0 +1,24 @@
+import number from '.';
+
+describe('@/number/index.ts', () => {
+  it('应当生成指定范围内的随机数', () => {
+    const min = 5;
+    const max = 10;
+    const result = number(min, max);
+    expect(result).toBeGreaterThanOrEqual(min);
+    expect(result).toBeLessThanOrEqual(max);
+  });
+
+  it('当最小值等于最大值时，应当返回该值', () => {
+    const minMax = 7;
+    expect(number(minMax, minMax)).toBe(minMax);
+  });
+
+  it('应当正确处理浮点数范围', () => {
+    const min = 5.5;
+    const max = 5.9;
+    const result = number(min, max);
+    expect(result).toBeGreaterThanOrEqual(min);
+    expect(result).toBeLessThanOrEqual(max);
+  });
+});

src/number/index.test.ts

@@ -0,0 +1,28 @@
+import { Decimal } from 'decimal.js';
+
+/**
+ * 生成随机数 (Generate random number)
+ * @param {number} minimum 最小值 (Minimum value)
+ * @param {number} maximum 最大值 (Maximum value)
+ * @returns {number} 包含最小值或最大值的随机数 (Random number containing minimum or maximum value)
+ */
+const number = (minimum: number, maximum: number): number => {
+  if (minimum === maximum) {
+    return minimum;
+  }
+
+  const minDecimal = new Decimal(minimum);
+  const maxDecimal = new Decimal(maximum);
+
+  // 计算范围并生成随机数
+  const range = maxDecimal.minus(minDecimal);
+  const randomDecimal = Decimal.random().mul(range).plus(minDecimal);
+
+  // 确定结果的小数位数
+  const maxDp = Math.max(minDecimal.dp(), maxDecimal.dp());
+
+  // 使用 Decimal 对象进行四舍五入，以确保精度
+  return randomDecimal.toDecimalPlaces(maxDp, Decimal.ROUND_HALF_UP).toNumber();
+};
+
+export default number;

src/number/index.ts

@@ -0,0 +1,44 @@
+import nonConsecutiveFn from '.';
+
+describe('@/number/nonConsecutiveFn', () => {
+  it('生成的随机数应该是非连续的', () => {
+    const min = 1;
+    const max = 10;
+    const generateRandom = nonConsecutiveFn(min, max);
+
+    let prevNumber = generateRandom();
+    let nonConsecutive = true;
+
+    for (let i = 0; i < 100; i++) {
+      const newNumber = generateRandom();
+      if (newNumber === prevNumber) {
+        nonConsecutive = false;
+        break;
+      }
+      prevNumber = newNumber;
+    }
+
+    expect(nonConsecutive).toBe(true);
+  });
+
+  it('生成的随机数应在指定范围内', () => {
+    const min = 1;
+    const max = 5;
+    const generateRandom = nonConsecutiveFn(min, max);
+
+    for (let i = 0; i < 100; i++) {
+      const number = generateRandom();
+      expect(number).toBeGreaterThanOrEqual(min);
+      expect(number).toBeLessThanOrEqual(max);
+    }
+  });
+
+  it('当最小值等于最大值时，应总是返回该值', () => {
+    const minMax = 3;
+    const generateRandom = nonConsecutiveFn(minMax, minMax);
+
+    for (let i = 0; i < 10; i++) {
+      expect(generateRandom()).toBe(minMax);
+    }
+  });
+});

src/number/nonConsecutiveFn/index.test.ts

@@ -0,0 +1,29 @@
+import number from '@/number';
+
+/**
+ * 生成不连续的随机数，即连续两次生成的随机数100%不相同 (Generate random numbers that are not consecutive, that is, the random numbers generated twice are 100% different)
+ * @param {number} minimum 最小值 (Minimum value)
+ * @param {number} maximum 最大值 (Maximum value)
+ * @returns {() => number} 生成不连续的随机数的函数 (Function that generates random numbers that are not consecutive)
+ */
+const nonConsecutiveFn = (minimum: number, maximum: number): (() => number) => {
+  let previousValue: number;
+
+  return () => {
+    // 当最小值等于最大值时，总是返回该值
+    if (minimum === maximum) {
+      return minimum;
+    }
+
+    let num: number;
+
+    do {
+      num = number(minimum, maximum);
+    } while (num === previousValue);
+
+    previousValue = num;
+    return num;
+  };
+};
+
+export default nonConsecutiveFn;

src/number/nonConsecutiveFn/index.ts

@@ -0,0 +1,84 @@
+import step from '.';
+
+describe('@/number/step', () => {
+  it('当最小值和最大值相等时应该直接返回该值', () => {
+    expect(step(5, 5)).toBe(5);
+  });
+
+  it('步长为0时应该生成最小值和最大值之间的随机数', () => {
+    const result = step(0, 10);
+    expect(result).toBeGreaterThanOrEqual(0);
+    expect(result).toBeLessThanOrEqual(10);
+  });
+
+  it('步长大于最大值和最小值之差时应该返回最小值', () => {
+    expect(step(0, 5, 10)).toBe(0);
+  });
+
+  it('生成指定步长的随机数', () => {
+    const result = step(0, 10, 2);
+    expect([0, 2, 4, 6, 8, 10]).toContain(result);
+  });
+
+  it('生成指定步长的随机整数', () => {
+    const result = step(0, 100, 10);
+    expect(result % 10).toBe(0);
+    expect(result).toBeGreaterThanOrEqual(0);
+    expect(result).toBeLessThanOrEqual(100);
+  });
+
+  it('生成指定步长的随机小数', () => {
+    const result = step(0, 1, 0.1);
+    expect(result).toBeGreaterThanOrEqual(0);
+    expect(result).toBeLessThanOrEqual(1);
+    expect(Math.round(result * 10) / 10).toBe(result); // 确保是0.1的倍数
+  });
+
+  it('生成的随机数应该在最小值和最大值之间，并且与最小值的差是步长的倍数', () => {
+    const min = 2,
+      max = 12,
+      stepSize = 3;
+    const result = step(min, max, stepSize);
+
+    expect([2, 5, 8, 11]).toContain(result);
+  });
+
+  it('应该处理浮点步长', () => {
+    const result = step(0, 1, 0.1);
+    expect(result).toBeGreaterThanOrEqual(0);
+    expect(result).toBeLessThanOrEqual(1);
+    expect(Math.round(result * 10) / 10).toBe(result);
+  });
+
+  it('处理带有小数的步长', () => {
+    const result = step(0.5, 5.5, 0.3);
+    expect(result).toBeGreaterThanOrEqual(0.5);
+    expect(result).toBeLessThanOrEqual(5.5);
+    expect([0.5, 0.8, 1.1, 1.4, 1.7, 2.0, 2.3, 2.6, 2.9, 3.2, 3.5, 3.8, 4.1, 4.4, 4.7, 5.0, 5.3]).toContain(result);
+  });
+
+  it('应正确处理负数步长', () => {
+    const result = step(-10, 0, 2);
+    expect(result).toBeGreaterThanOrEqual(-10);
+    expect(result).toBeLessThanOrEqual(0);
+  });
+
+  it('生成指定步长的随机小数', () => {
+    const min = 3.14;
+    const max = 10;
+    const stepSize = 2;
+    const result = step(min, max, stepSize);
+    expect([3.14, 5.14, 7.14, 9.14]).toContain(result);
+  });
+
+  it('步长大于最大值和最小值之差时返回最小值', () => {
+    const min = 1;
+    const max = 6.00000000001;
+    const stepSize = 10;
+    expect(step(min, max, stepSize)).toBe(1);
+  });
+
+  it('当步长为负数且绝对值大于最大值和最小值之差时应返回最小值', () => {
+    expect(step(-5, 0, -6)).toBe(-5);
+  });
+});

src/number/step/index.test.ts

@@ -0,0 +1,43 @@
+import { Decimal } from 'decimal.js';
+import number from '@/number';
+
+/**
+ * 生成指定步长的随机数 (Generate random numbers with specified step size)
+ * @param {number} minimum 最小值 (Minimum value)
+ * @param {number} maximum 最大值 (Maximum value)
+ * @param {number} [step = 0] 步长，如果为 0 则不限制步长，假设 minimum 为 3，maximum 为 10，step 为 2，则生成的随机数为 3 5 7 9 (Step size, if it is 0, the step size is not limited, assuming that the minimum is 3, the maximum is 10, and the step is 2, then the generated random number is 3 5 7 9)
+ * @returns {number} 包含最小值或最大值的随机数 (Random number containing minimum or maximum value)
+ */
+const step = (minimum: number, maximum: number, step: number = 0): number => {
+  // 当最小值和最大值相等时，直接返回该值
+  if (minimum === maximum) {
+    return minimum;
+  }
+
+  // 如果步长为0，则生成最小值和最大值之间的随机数
+  if (step === 0) {
+    return number(minimum, maximum);
+  }
+
+  const minDecimal = new Decimal(minimum);
+  const maxDecimal = new Decimal(maximum);
+  const stepDecimal = new Decimal(step);
+
+  // 如果步长大于最大值和最小值之差，则返回最小值
+  if (stepDecimal.abs().greaterThan(maxDecimal.minus(minDecimal))) {
+    return minimum;
+  }
+
+  // 根据最小值和步长计算随机数范围
+  const range = maxDecimal.minus(minDecimal).div(stepDecimal).floor();
+  const randomIndex = number(0, range.toNumber());
+  const randomStep = minDecimal.plus(new Decimal(randomIndex).mul(stepDecimal));
+
+  // 确定最长的小数位数
+  const maxDp = Math.max(minDecimal.dp(), maxDecimal.dp(), stepDecimal.dp());
+
+  // 使用最长的小数位数来确定结果的精度
+  return randomStep.toDecimalPlaces(maxDp, Decimal.ROUND_HALF_UP).toNumber();
+};
+
+export default step;