阳光梦想

解决 Xcode 26 编译报错 Use of private header from outside its module: netinet6/in6.h

Thu, 30 Apr 2026 10:41:25 +0800

报错信息

Use of private header from outside its module: 'netinet6/in6.h'

文件路径

Pods/AFNetworking/AFNetworking/AFNetworking/AFHTTPSessionManager.m:32:9
Pods/AFNetworking/AFNetworking/AFNetworking/AFNetworkReachabilityManager.m:26:9

问题原因

新版 Xcode（Xcode 26+）升级了 SDK，将 <netinet6/in6.h> 标记为模块私有头文件（private header），禁止从模块外部直接 #import。

这两个文件头部都引用了

#import <netinet6/in6.h>

由于 <netinet/in.h> 已经间接包含了 IPv6 相关的类型定义，这行 #import 实际上是多余的，删除即可~

解决方案

1、在 Podfile 的 post_install 钩子中加入以下代码，每次 pod install 后自动扫描并修复所有受影响的文件

post_install do |installer|
  # ... 其他配置 ...

  # 修复新版 Xcode SDK 中 netinet6/in6.h 私有头文件问题
  # 全局扫描
  Dir.glob('Pods/**/*.{m,mm}').each do |file|
    content = File.read(file)
    if content.include?("#import <netinet6/in6.h>")
      content.gsub!("#import <netinet6/in6.h>\n", '')
      # 移除只读限制
      File.chmod(0644, file)
      File.write(file, content)
      puts "已修复 #{file} 的 netinet6/in6.h 问题"
    end
  end
end

2、执行 pod install 后会看到如下输出

已修复 Pods/AFNetworking/AFNetworking/AFNetworking/AFNetworkReachabilityManager.m 的 netinet6/in6.h 问题
已修复 Pods/AFNetworking/AFNetworking/AFNetworking/AFHTTPSessionManager.m 的 netinet6/in6.h 问题

3、也可以直接用我的fork（集成了隐私清单，仅作为网络请求库的情况）

编辑 Podfile 把 AFNetworking 这部分改成这样~

pod 'AFNetworking', :git => 'https://github.com/xiaozhongmiao/AFNetworking.git', :tag => '4.0.1-privacy'

vscode 里面没有远程分支的解决方案

Fri, 06 Mar 2026 18:52:45 +0800

在终端里面、当前项目目录执行这个就可以

git remote update origin --prune

【代码】Haversine 距离计算的Java实现

Wed, 25 Feb 2026 18:50:31 +0800

1、介绍

Haversine 距离用于计算地球上两点之间的大圆距离
当考虑地球真实曲率时，它特别适用于计算两个经纬度坐标之间的距离

2、Java实现

public class HaversineUtil {
    /**
     * Great-circle distance on a spherical Earth using the haversine formula.
     * 返回两点间球面最短距离（大圆距离）。
     *
     * 注意：
     * - 结果适用于大多数业务距离计算（附近/范围/配送），属于“球体近似”。
     * - 单位：公里（km）
     */
    public static double haversineDistanceKm(double lat1, double lon1, double lat2, double lon2) {
        // 平均地球半径（km），用 6371.0 也可以
        final double R_KM = 6371.0088;

        validateLatLon(lat1, lon1);
        validateLatLon(lat2, lon2);

        // 归一化经度到 [-180, 180)
        lon1 = normalizeLonDeg(lon1);
        lon2 = normalizeLonDeg(lon2);

        // 计算差值（经度差做最短角差归一化，避免跨国际日期变更线时误差）
        double dLatDeg = lat2 - lat1;
        double dLonDeg = shortestDeltaLonDeg(lon1, lon2);

        double dLat = Math.toRadians(dLatDeg);
        double dLon = Math.toRadians(dLonDeg);

        double rLat1 = Math.toRadians(lat1);
        double rLat2 = Math.toRadians(lat2);

        double sinDLat = Math.sin(dLat / 2.0);
        double sinDLon = Math.sin(dLon / 2.0);

        double a = sinDLat * sinDLat
                + Math.cos(rLat1) * Math.cos(rLat2) * sinDLon * sinDLon;

        // 浮点保护：防止极端情况下 a 略超出 [0,1] 导致 NaN
        a = Math.min(1.0, Math.max(0.0, a));

        double c = 2.0 * Math.atan2(Math.sqrt(a), Math.sqrt(1.0 - a));
        return R_KM * c;
    }

    /**
     * Great-circle distance on a spherical Earth using the haversine formula.
     * 返回两点间球面最短距离（大圆距离）。
     *
     * 注意：
     * - 结果适用于大多数业务距离计算（附近/范围/配送），属于“球体近似”。
     * - 单位：米（m）
     */
    public static double haversineDistanceMeters(double lat1, double lon1, double lat2, double lon2) {
        return haversineDistanceKm(lat1, lon1, lat2, lon2) * 1000.0;
    }

    /** 校验纬度/经度输入是否合理 */
    private static void validateLatLon(double lat, double lon) {
        if (!Double.isFinite(lat) || !Double.isFinite(lon)) {
            throw new IllegalArgumentException("lat/lon must be finite numbers (not NaN/Infinity).");
        }
        if (lat < -90.0 || lat > 90.0) {
            throw new IllegalArgumentException("lat out of range [-90, 90]: " + lat);
        }
    }

    /** 把经度归一化到 [-180, 180) */
    private static double normalizeLonDeg(double lon) {
        // 结果落在 [-180, 180)
        lon = ((lon + 180.0) % 360.0 + 360.0) % 360.0 - 180.0;
        return lon;
    }

    /** 计算两经度的最短角差（单位：度），结果落在 [-180, 180] */
    private static double shortestDeltaLonDeg(double lon1, double lon2) {
        double d = lon2 - lon1;
        // 归一化到 (-180, 180]
        d = ((d + 180.0) % 360.0 + 360.0) % 360.0 - 180.0;
        return d;
    }
}

在 JavaScript 中实现 BigDecimal

Fri, 06 Feb 2026 14:55:37 +0800

最近项目要求，在前端计算单价，由于 JavaScript 是二进制浮点，十进制小数（比如：0.1、0.01、19.99）在二进制表示不精确，直接运算会得到一个很接近但是不等于的结果。而价格这个东西对于精度又极其敏感。

看到 Java 中是用BigDecimal进行计算的，所以，我这在 JavaScript 中实现了相近的功能

实现代码（ES2020以上）：

/* BigDecimal.ts
 *
 * https://www.yangguangdream.com/?id=2270
 *
 * 精確十進位運算（BigInt + scale 定點小數）
 * Precise decimal arithmetic using BigInt + scale (fixed-point).
 *
 * 建議 TS target / lib: ES2020 以上（需要 BigInt）
 * Recommended TS target/lib: ES2020+ (BigInt required).
 */

export type RoundingMode =
    | "DOWN"       // toward zero
    | "UP"         // away from zero
    | "FLOOR"      // toward -∞
    | "CEILING"    // toward +∞
    | "HALF_UP"    // ties away from zero
    | "HALF_DOWN"  // ties toward zero
    | "HALF_EVEN"; // banker's rounding

export interface MathContext {
    /** 有效位數（precision），必須 >= 1。Significant digits (precision), must be >= 1. */
    precision: number;
    /** 捨入模式。Rounding mode. */
    roundingMode: RoundingMode;
}

export class BigDecimal {
    /** 去掉小數點後的整數值（可能為負）。Unscaled integer value (may be negative). */
    private readonly intVal: bigint;

    /** 小數位數（>= 0）。Scale (digits to the right of the decimal point, >= 0). */
    private readonly scale: number;

    /**
     * 建立 BigDecimal。
     * - 建議使用字串輸入以確保「完全精確」。
     * - number 會先轉字串，可能已經有二進位浮點誤差。
     *
     * Create a BigDecimal.
     * - Prefer string input for exactness.
     * - number is converted to string and may already contain IEEE-754 rounding artifacts.
     */
    constructor(value: string | number | bigint | BigDecimal, scale?: number) {
        if (value instanceof BigDecimal) {
            this.intVal = value.intVal;
            this.scale = value.scale;
            return;
        }

        if (typeof value === "bigint") {
            const s = scale ?? 0;
            if (!Number.isInteger(s) || s < 0) throw new Error("scale must be a non-negative integer");
            this.intVal = value === 0n ? 0n : value;
            this.scale = s;
            return;
        }

        if (typeof value === "number") {
            if (!Number.isFinite(value)) throw new Error("Invalid number");
            value = String(value);
        }

        const parsed = BigDecimal.parseDecimalString(value);
        this.intVal = parsed.intVal === 0n ? 0n : parsed.intVal; // avoid -0
        this.scale = parsed.scale;
    }


   

    /**
     * 快速建立實例（同 constructor）。
     * Convenience factory (same as constructor).
     */
    static from(value: string | number | bigint | BigDecimal, scale?: number): BigDecimal {
        return new BigDecimal(value as any, scale);
    }

    /**
     * 取得 scale（小數位數）。
     * Get scale (digits after decimal point).
     */
    getScale(): number {
        return this.scale;
    }

    /**
     * 取得未縮放整數值（unscaled value）。
     * Get unscaled value (BigInt).
     */
    unscaledValue(): bigint {
        return this.intVal;
    }

    /**
     * 回傳數值的正負號（-1, 0, 1）。
     * Returns signum of this value (-1, 0, 1).
     */
    signum(): -1 | 0 | 1 {
        if (this.intVal === 0n) return 0;
        return this.intVal < 0n ? -1 : 1;
    }

    /**
     * 取絕對值。
     * Absolute value.
     */
    abs(): BigDecimal {
        return this.intVal < 0n ? new BigDecimal(-this.intVal, this.scale) : this;
    }

    /**
     * 取相反數（negate）。
     * Negation.
     */
    negate(): BigDecimal {
        return this.intVal === 0n ? this : new BigDecimal(-this.intVal, this.scale);
    }

    /**
     * 加法（結果 scale = max(a.scale, b.scale)，與 Java BigDecimal.add 類似）。
     * Addition (result scale = max scales, Java-like).
     */
    add(other: BigDecimal | string | number | bigint): BigDecimal {
        const b = BigDecimal.from(other);
        const [aAdj, bAdj, s] = BigDecimal.alignScales(this, b);
        return new BigDecimal(aAdj + bAdj, s);
    }

    /**
     * 減法（結果 scale = max(a.scale, b.scale)，與 Java BigDecimal.subtract 類似）。
     * Subtraction (result scale = max scales, Java-like).
     */
    sub(other: BigDecimal | string | number | bigint): BigDecimal {
        const b = BigDecimal.from(other);
        const [aAdj, bAdj, s] = BigDecimal.alignScales(this, b);
        return new BigDecimal(aAdj - bAdj, s);
    }

    /**
     * 乘法（結果 scale = a.scale + b.scale，與 Java BigDecimal.multiply 類似）。
     * Multiplication (result scale = sum of scales, Java-like).
     */
    mul(other: BigDecimal | string | number | bigint): BigDecimal {
        const b = BigDecimal.from(other);
        return new BigDecimal(this.intVal * b.intVal, this.scale + b.scale);
    }

    /**
     * 除法（Java 風格 overload）：
     * 1) divide(b)        -> 精確除法；若結果為無限小數，會拋錯（需指定 scale/rounding）。
     * 2) divide(b, s, rm) -> 指定結果 scale 與捨入模式。
     *
     * Division (Java-like overload):
     * 1) divide(b)        -> exact division; throws if non-terminating.
     * 2) divide(b, s, rm) -> with specified result scale and rounding mode.
     */
    divide(other: BigDecimal | string | number | bigint): BigDecimal;
    divide(other: BigDecimal | string | number | bigint, resultScale: number, rounding: RoundingMode): BigDecimal;
    divide(other: BigDecimal | string | number | bigint, resultScale?: number, rounding?: RoundingMode): BigDecimal {
        const b = BigDecimal.from(other);
        if (b.intVal === 0n) throw new Error("Division by zero");

        if (resultScale === undefined) {
            return this.divideExact(b);
        }

        const rm: RoundingMode = rounding ?? "HALF_UP";
        return this.divideScaled(b, resultScale, rm);
    }

    /**
     * 指定 scale（小數位）並捨入，等同 Java BigDecimal.setScale。
     * Set scale with rounding (like Java BigDecimal.setScale).
     */
    setScale(newScale: number, rounding: RoundingMode = "HALF_UP"): BigDecimal {
        if (!Number.isInteger(newScale) || newScale < 0) throw new Error("newScale must be a non-negative integer");
        if (newScale === this.scale) return this;

        if (newScale > this.scale) {
            const factor = BigDecimal.pow10(newScale - this.scale);
            return new BigDecimal(this.intVal * factor, newScale);
        }

        const diff = this.scale - newScale;
        const divisor = BigDecimal.pow10(diff); // positive
        const { q, r } = BigDecimal.divmodPosDenom(this.intVal, divisor);
        const roundedQ = BigDecimal.roundQuotient(q, r, divisor, this.intVal, rounding);
        return new BigDecimal(roundedQ, newScale);
    }

    /**
     * 移除尾端多餘的 0（會改變 scale），等同 Java BigDecimal.stripTrailingZeros。
     * Strip trailing zeros (changes scale), like Java BigDecimal.stripTrailingZeros.
     */
    stripTrailingZeros(): BigDecimal {
        if (this.intVal === 0n) return this; // keep scale as-is (Java keeps representation)
        let v = this.intVal;
        let s = this.scale;
        while (s > 0 && (v % 10n) === 0n) {
            v /= 10n;
            s -= 1;
        }
        return (v === this.intVal && s === this.scale) ? this : new BigDecimal(v, s);
    }

    /**
     * 比較大小（忽略 scale 差異；數值相等則回傳 0），等同 Java compareTo 語義。
     * Compare numerically (ignores scale differences), like Java compareTo.
     */
    compareTo(other: BigDecimal | string | number | bigint): -1 | 0 | 1 {
        const b = BigDecimal.from(other);
        const [aAdj, bAdj] = BigDecimal.alignScales(this, b);
        if (aAdj < bAdj) return -1;
        if (aAdj > bAdj) return 1;
        return 0;
    }

    /**
     * equals（Java 語義：數值與 scale 都必須相同）。
     * equals (Java semantics: both value AND scale must match).
     */
    equals(other: BigDecimal | string | number | bigint): boolean {
        const b = BigDecimal.from(other);
        return this.scale === b.scale && this.intVal === b.intVal;
    }

    /**
     * 只比「數值是否相等」（忽略 scale），相當於 compareTo(other) === 0。
     * Numeric equality ignoring scale (compareTo(other) === 0).
     */
    equalsValue(other: BigDecimal | string | number | bigint): boolean {
        return this.compareTo(other) === 0;
    }

    /**
     * 回傳有效位數（precision），與 Java BigDecimal.precision 類似。
     * Returns precision (count of significant digits), Java-like.
     */
    precision(): number {
        // Java: precision of 0 is 1
        if (this.intVal === 0n) return 1;
        const abs = this.intVal < 0n ? -this.intVal : this.intVal;
        // NOTE: unscaled value may include trailing zeros; precision counts them too (Java does).
        return abs.toString().length;
    }

    /**
     * 以 MathContext（precision + rounding）做四捨五入（有效位數）。
     * Round using MathContext (precision + rounding mode).
     */
    round(mc: MathContext): BigDecimal {
        if (!mc || !Number.isInteger(mc.precision) || mc.precision < 1) {
            throw new Error("MathContext.precision must be an integer >= 1");
        }
        const rm = mc.roundingMode ?? "HALF_UP";

        const curPrec = this.precision();
        if (curPrec <= mc.precision) return this;

        const drop = curPrec - mc.precision;      // digits to drop from unscaled value
        const divisor = BigDecimal.pow10(drop);   // 10^drop
        const { q, r } = BigDecimal.divmodPosDenom(this.intVal, divisor);
        const roundedQ = BigDecimal.roundQuotient(q, r, divisor, this.intVal, rm);

        // scale decreases by drop; if becomes negative, convert to scale=0 by shifting left.
        let newScale = this.scale - drop;
        let newIntVal = roundedQ;

        if (newScale < 0) {
            newIntVal = newIntVal * BigDecimal.pow10(-newScale);
            newScale = 0;
        }

        return new BigDecimal(newIntVal, newScale);
    }

    /**
     * 小數點左移 n 位（相當於 / 10^n）。
     * Move decimal point left by n (equivalent to / 10^n).
     */
    movePointLeft(n: number): BigDecimal {
        if (!Number.isInteger(n)) throw new Error("n must be an integer");
        if (n === 0) return this;
        if (n < 0) return this.movePointRight(-n);
        return new BigDecimal(this.intVal, this.scale + n);
    }

    /**
     * 小數點右移 n 位（相當於 * 10^n）；若 scale 變成負數會自動轉為 scale=0 並擴大 intVal。
     * Move decimal point right by n (equivalent to * 10^n). If scale becomes negative, it is normalized to scale=0 by expanding intVal.
     */
    movePointRight(n: number): BigDecimal {
        if (!Number.isInteger(n)) throw new Error("n must be an integer");
        if (n === 0) return this;
        if (n < 0) return this.movePointLeft(-n);

        const newScale = this.scale - n;
        if (newScale >= 0) return new BigDecimal(this.intVal, newScale);

        // scale would be negative -> shift intVal and set scale=0
        const factor = BigDecimal.pow10(-newScale);
        return new BigDecimal(this.intVal * factor, 0);
    }

    /**
     * 輸出「一般十進位字串」（不使用科學記號）。
     * Plain decimal string (no scientific notation).
     */
    toPlainString(): string {
        const sign = this.intVal < 0n ? "-" : "";
        const abs = this.intVal < 0n ? -this.intVal : this.intVal;

        if (this.scale === 0) return sign + abs.toString();

        const s = abs.toString();

        const pointPos = s.length - this.scale;
        if (pointPos > 0) {
            const intPart = s.slice(0, pointPos);
            const fracPart = s.slice(pointPos);
            return sign + intPart + "." + fracPart;
        } else {
            const zeros = "0".repeat(-pointPos);
            return sign + "0." + zeros + s;
        }
    }

    /**
     * toString（此實作等同 toPlainString，避免出現科學記號）。
     * toString (this implementation equals toPlainString to avoid scientific notation).
     */
    toString(): string {
        return this.toPlainString();
    }

    /**
     * 嘗試轉成 number（可能失去精度，不建議用於財務/精準計算）。
     * Convert to number (may lose precision; not recommended for money/precise math).
     */
    toNumber(): number {
        return Number(this.toPlainString());
    }

    // -------------------- private core division helpers --------------------

    /**
     * 精確除法；若除不盡（無限小數），會拋錯。
     * Exact division; throws if the decimal expansion is non-terminating.
     */
    private divideExact(divisor: BigDecimal): BigDecimal {
        // Build fraction: value = (A * 10^(sb-sa)) / B
        let num = this.intVal;
        let den = divisor.intVal;

        // adjust by exponent = sb - sa
        const exp = divisor.scale - this.scale;
        if (exp >= 0) num = num * BigDecimal.pow10(exp);
        else den = den * BigDecimal.pow10(-exp);

        // normalize denominator to positive
        if (den < 0n) {
            den = -den;
            num = -num;
        }

        // reduce fraction
        const g = BigDecimal.gcd(BigDecimal.absBigInt(num), den);
        num /= g;
        den /= g;

        // den must be 2^a * 5^b for terminating decimal
        let d = den;
        let p2 = 0;
        let p5 = 0;

        while (d % 2n === 0n) { d /= 2n; p2++; }
        while (d % 5n === 0n) { d /= 5n; p5++; }

        if (d !== 1n) {
            throw new Error("Non-terminating decimal expansion; specify scale and rounding mode");
        }

        const s = Math.max(p2, p5);
        // intVal = num * 10^s / den = num * 2^(s-p2) * 5^(s-p5)
        const mul2 = BigDecimal.powBigInt(2n, s - p2);
        const mul5 = BigDecimal.powBigInt(5n, s - p5);
        const intVal = num * mul2 * mul5;

        return new BigDecimal(intVal, s);
    }

    /**
     * 指定結果小數位（scale）與捨入模式的除法。
     * Division with specified result scale and rounding mode.
     */
    private divideScaled(divisor: BigDecimal, resultScale: number, rounding: RoundingMode): BigDecimal {
        if (!Number.isInteger(resultScale) || resultScale < 0) throw new Error("resultScale must be a non-negative integer");

        // Compute q = round( numerator / denominator ) where result has `resultScale`.
        // exp = resultScale + sb - sa
        const exp = resultScale + divisor.scale - this.scale;

        let numerator: bigint;
        let denominator: bigint;

        if (exp >= 0) {
            numerator = this.intVal * BigDecimal.pow10(exp);
            denominator = divisor.intVal;
        } else {
            numerator = this.intVal;
            denominator = divisor.intVal * BigDecimal.pow10(-exp);
        }

        // normalize denominator to positive
        if (denominator < 0n) {
            denominator = -denominator;
            numerator = -numerator;
        }

        const { q, r } = BigDecimal.divmodPosDenom(numerator, denominator);
        const roundedQ = BigDecimal.roundQuotient(q, r, denominator, numerator, rounding);

        return new BigDecimal(roundedQ, resultScale);
    }

    // -------------------- private parsing & math helpers --------------------

    /**
     * 解析十進位字串（支援科學記號 e/E）。
     * Parse decimal string (supports scientific notation e/E).
     */
    private static parseDecimalString(input: string): { intVal: bigint; scale: number } {
        const str = input.trim();
        if (!str) throw new Error("Empty decimal");

        // Allow: [+|-]? (digits? "." digits? | digits ".") ( [eE][+|-]?digits )?
        const m = /^([+-])?(?:(\d+)?(?:\.(\d*)?)?|\.(\d+))(?:[eE]([+-]?\d+))?$/.exec(str);
        if (!m) throw new Error(`Invalid decimal string: ${input}`);

        const sign = m[1] === "-" ? -1n : 1n;

        // Two possible captures:
        // - m[2] digits before dot (optional)
        // - m[3] digits after dot (optional, can be empty when "12.")
        // - or m[4] digits after dot when string starts with "."
        const intPart = (m[2] ?? "");
        const fracPart = (m[4] ?? m[3] ?? "");
        const expStr = m[5] ?? "0";
        const exp = Number(expStr);
        if (!Number.isInteger(exp)) throw new Error(`Invalid exponent: ${expStr}`);

        // Digits without dot
        let digits = (intPart + fracPart);
        // remove leading zeros for BigInt parsing (keep at least one digit if all zeros)
        digits = digits.replace(/^0+(?=\d)/, "");
        if (digits === "") digits = "0";

        // scale = fracLen - exp  (moving decimal right by exp reduces scale)
        let scale = fracPart.length - exp;

        let intVal = BigInt(digits) * sign;
        if (intVal === 0n) intVal = 0n; // avoid -0

        if (scale < 0) {
            // shift left if scale would be negative
            intVal = intVal * BigDecimal.pow10(-scale);
            scale = 0;
        }

        if (!Number.isInteger(scale) || scale < 0) throw new Error("Invalid scale after parsing");
        return { intVal, scale };
    }

    /**
     * 將兩個 BigDecimal 對齊到相同 scale（用於加減比大小）。
     * Align scales of two BigDecimals (used for add/sub/compare).
     */
    private static alignScales(a: BigDecimal, b: BigDecimal): [bigint, bigint, number] {
        const s = Math.max(a.scale, b.scale);
        const aFactor = BigDecimal.pow10(s - a.scale);
        const bFactor = BigDecimal.pow10(s - b.scale);
        return [a.intVal * aFactor, b.intVal * bFactor, s];
    }

    /**
     * 10 的 n 次方（BigInt）。
     * 10^n as BigInt.
     */
    private static pow10(n: number): bigint {
        if (!Number.isInteger(n) || n < 0) throw new Error("pow10 expects non-negative integer");
        return BigDecimal.powBigInt(10n, n);
    }

    /**
     * base 的 exp 次方（BigInt，快速冪）。
     * base^exp using fast exponentiation (BigInt).
     */
    private static powBigInt(base: bigint, exp: number): bigint {
        if (!Number.isInteger(exp) || exp < 0) throw new Error("powBigInt exp must be non-negative integer");
        let r = 1n;
        let b = base;
        let e = exp;
        while (e > 0) {
            if (e & 1) r *= b;
            b *= b;
            e >>= 1;
        }
        return r;
    }

    /**
     * BigInt 絕對值。
     * BigInt absolute value.
     */
    private static absBigInt(x: bigint): bigint {
        return x < 0n ? -x : x;
    }

    /**
     * 最大公因數 gcd（BigInt）。
     * Greatest common divisor (BigInt).
     */
    private static gcd(a: bigint, b: bigint): bigint {
        let x = a;
        let y = b;
        while (y !== 0n) {
            const t = x % y;
            x = y;
            y = t;
        }
        return x;
    }

    /**
     * BigInt 除法與餘數（保證除數為正數）。
     * divmod with positive denominator.
     */
    private static divmodPosDenom(numer: bigint, denomPos: bigint): { q: bigint; r: bigint } {
        if (denomPos <= 0n) throw new Error("denominator must be positive");
        const q = numer / denomPos; // trunc toward zero
        const r = numer % denomPos; // same sign as numer
        return { q, r };
    }

    /**
     * 依照捨入模式把 q + r/denom 進行捨入，denom 必須為正。
     * Round quotient for q + r/denom using rounding mode; denom must be positive.
     */
    private static roundQuotient(
        q: bigint,
        r: bigint,
        denomPos: bigint,
        numer: bigint,
        mode: RoundingMode
    ): bigint {
        if (r === 0n) return q;
        if (denomPos <= 0n) throw new Error("denominator must be positive");

        const sign = numer < 0n ? -1n : 1n; // sign of exact value since denom > 0
        const awayFromZero = (x: bigint) => (sign >= 0n ? x + 1n : x - 1n);

        switch (mode) {
            case "DOWN":
                // toward zero
                return q;

            case "UP":
                // away from zero
                return awayFromZero(q);

            case "FLOOR":
                // toward -∞
                return (numer < 0n) ? (q - 1n) : q;

            case "CEILING":
                // toward +∞
                return (numer > 0n) ? (q + 1n) : q;

            case "HALF_UP":
            case "HALF_DOWN":
            case "HALF_EVEN": {
                const rAbs = BigDecimal.absBigInt(r);
                const twiceR = rAbs * 2n;

                if (twiceR > denomPos) return awayFromZero(q);
                if (twiceR < denomPos) return q;

                // exactly half
                if (mode === "HALF_UP") return awayFromZero(q);
                if (mode === "HALF_DOWN") return q;

                // HALF_EVEN: round to make result even
                const isOdd = (q & 1n) !== 0n;
                return isOdd ? awayFromZero(q) : q;
            }

            default: {
                const _never: never = mode;
                return q;
            }
        }
    }
}

使用方法（由于JavaScript 精度问题，请直接把数字转为字符串）：

const a = new BigDecimal("0.1");
const b = new BigDecimal("0.2");
console.log(a.add(b).toString()); // 0.3

console.log(new BigDecimal("1").divide("3", 10, "HALF_UP").toString()); // 0.3333333333

console.log(new BigDecimal("1").divide("8").toString()); // 0.125（精确可除）
try {
  console.log(new BigDecimal("1").divide("3").toString()); // 无限小数会报错
} catch (e) {
  console.log(String(e));
}

console.log(new BigDecimal("1.2300").stripTrailingZeros().toString()); // 1.23
console.log(new BigDecimal("1.2300").equals(new BigDecimal("1.23"))); // false（Java equals）
console.log(new BigDecimal("1.2300").equalsValue(new BigDecimal("1.23"))); // true（比较数值）

ES2020以下版本兼容（ES2020以下版本不支持 bigint）（AI按照我上面写的跑出来的）

/* BigDecimal.ts (Safari 13 compatible)
 *
 * - No BigInt, no bigint literals.
 * - Internal integer is stored as a decimal string (abs digits) + sign + scale.
 * - Works in Safari 13.
 *
 * Tradeoff:
 * - Slower than BigInt version for very large numbers.
 * - unscaledValue() returns string (typed as any for drop-in tolerance).
 */

export type RoundingMode =
    | "DOWN"       // toward zero
    | "UP"         // away from zero
    | "FLOOR"      // toward -∞
    | "CEILING"    // toward +∞
    | "HALF_UP"    // ties away from zero
    | "HALF_DOWN"  // ties toward zero
    | "HALF_EVEN"; // banker's rounding

export interface MathContext {
    precision: number;
    roundingMode: RoundingMode;
}

type Sign = -1 | 0 | 1;

function isInt(n: number): boolean {
    return typeof n === "number" && isFinite(n) && Math.floor(n) === n;
}

function stripLeadingZeros(d: string): string {
    // keep at least one digit
    d = d.replace(/^0+(?=\d)/, "");
    return d === "" ? "0" : d;
}

function isZeroDigits(d: string): boolean {
    return d === "0";
}

function cmpAbs(a: string, b: string): -1 | 0 | 1 {
    a = stripLeadingZeros(a);
    b = stripLeadingZeros(b);
    if (a.length < b.length) return -1;
    if (a.length > b.length) return 1;
    if (a === b) return 0;
    return a < b ? -1 : 1; // lexicographic works for same length digits
}

function addAbs(a: string, b: string): string {
    let i = a.length - 1;
    let j = b.length - 1;
    let carry = 0;
    const out: number[] = [];

    while (i >= 0 || j >= 0 || carry) {
        const da = i >= 0 ? (a.charCodeAt(i) - 48) : 0;
        const db = j >= 0 ? (b.charCodeAt(j) - 48) : 0;
        const s = da + db + carry;
        out.push(s % 10);
        carry = Math.floor(s / 10);
        i--; j--;
    }
    out.reverse();
    return stripLeadingZeros(out.join(""));
}

function subAbs(a: string, b: string): string {
    // assumes a >= b (abs)
    let i = a.length - 1;
    let j = b.length - 1;
    let borrow = 0;
    const out: number[] = [];

    while (i >= 0) {
        let da = (a.charCodeAt(i) - 48) - borrow;
        const db = j >= 0 ? (b.charCodeAt(j) - 48) : 0;
        if (da < db) {
            da += 10;
            borrow = 1;
        } else {
            borrow = 0;
        }
        out.push(da - db);
        i--; j--;
    }
    out.reverse();
    return stripLeadingZeros(out.join(""));
}

function mulAbs(a: string, b: string): string {
    a = stripLeadingZeros(a);
    b = stripLeadingZeros(b);
    if (a === "0" || b === "0") return "0";

    const al = a.length;
    const bl = b.length;
    const res = new Array(al + bl).fill(0);

    for (let i = al - 1; i >= 0; i--) {
        const da = a.charCodeAt(i) - 48;
        for (let j = bl - 1; j >= 0; j--) {
            const db = b.charCodeAt(j) - 48;
            const idx = i + j + 1;
            res[idx] += da * db;
        }
    }

    // carry
    for (let k = res.length - 1; k > 0; k--) {
        const carry = Math.floor(res[k] / 10);
        res[k] = res[k] % 10;
        res[k - 1] += carry;
    }

    return stripLeadingZeros(res.join(""));
}

function mulSmallAbs(a: string, k: number): string {
    a = stripLeadingZeros(a);
    if (a === "0" || k === 0) return "0";
    if (k === 1) return a;

    let carry = 0;
    const out: number[] = [];
    for (let i = a.length - 1; i >= 0; i--) {
        const da = a.charCodeAt(i) - 48;
        const p = da * k + carry;
        out.push(p % 10);
        carry = Math.floor(p / 10);
    }
    while (carry) {
        out.push(carry % 10);
        carry = Math.floor(carry / 10);
    }
    out.reverse();
    return stripLeadingZeros(out.join(""));
}

function divmodAbs(a: string, b: string): { q: string; r: string } {
    a = stripLeadingZeros(a);
    b = stripLeadingZeros(b);
    if (b === "0") throw new Error("Division by zero");
    if (a === "0") return { q: "0", r: "0" };
    if (cmpAbs(a, b) < 0) return { q: "0", r: a };

    let rem = "0";
    const qChars: string[] = [];

    for (let i = 0; i < a.length; i++) {
        const digit = a.charAt(i);
        // rem = rem * 10 + digit
        rem = rem === "0" ? digit : (rem + digit);
        rem = stripLeadingZeros(rem);

        if (cmpAbs(rem, b) < 0) {
            qChars.push("0");
            continue;
        }

        // find qd in [1..9]
        let lo = 0, hi = 9;
        while (lo < hi) {
            const mid = Math.ceil((lo + hi) / 2);
            const prod = mulSmallAbs(b, mid);
            const c = cmpAbs(prod, rem);
            if (c <= 0) lo = mid;
            else hi = mid - 1;
        }

        const qd = lo;
        qChars.push(String(qd));
        const sub = mulSmallAbs(b, qd);
        rem = subAbs(rem, sub);
    }

    const q = stripLeadingZeros(qChars.join(""));
    const r = stripLeadingZeros(rem);
    return { q, r };
}

function divmodSmallAbs(a: string, small: number): { q: string; r: number } {
    a = stripLeadingZeros(a);
    if (small <= 0) throw new Error("small divisor must be positive");
    if (a === "0") return { q: "0", r: 0 };

    let rem = 0;
    const out: number[] = [];
    for (let i = 0; i < a.length; i++) {
        const d = a.charCodeAt(i) - 48;
        const x = rem * 10 + d;
        const qd = Math.floor(x / small);
        rem = x % small;
        out.push(qd);
    }
    return { q: stripLeadingZeros(out.join("")), r: rem };
}

function powAbs(base: string, exp: number): string {
    if (!isInt(exp) || exp < 0) throw new Error("exp must be non-negative integer");
    if (exp === 0) return "1";
    let result = "1";
    let b = stripLeadingZeros(base);
    let e = exp;
    while (e > 0) {
        if (e & 1) result = mulAbs(result, b);
        e >>= 1;
        if (e) b = mulAbs(b, b);
    }
    return stripLeadingZeros(result);
}

function appendZeros(absDigits: string, n: number): string {
    if (n <= 0) return absDigits;
    if (absDigits === "0") return "0";
    return absDigits + new Array(n + 1).join("0");
}

function isOddAbs(absDigits: string): boolean {
    const last = absDigits.charCodeAt(absDigits.length - 1) - 48;
    return (last & 1) === 1;
}

function roundQuotientAbs(
    qAbs: string,
    rAbs: string,
    denomAbs: string,
    signExact: Sign,
    mode: RoundingMode
): string {
    qAbs = stripLeadingZeros(qAbs);
    rAbs = stripLeadingZeros(rAbs);
    denomAbs = stripLeadingZeros(denomAbs);

    if (rAbs === "0") return qAbs;

    const add1 = () => addAbs(qAbs, "1");

    switch (mode) {
        case "DOWN":
            return qAbs;

        case "UP":
            return add1();

        case "FLOOR":
            return signExact < 0 ? add1() : qAbs;

        case "CEILING":
            return signExact > 0 ? add1() : qAbs;

        case "HALF_UP":
        case "HALF_DOWN":
        case "HALF_EVEN": {
            const twiceR = mulSmallAbs(rAbs, 2);
            const c = cmpAbs(twiceR, denomAbs);

            if (c > 0) return add1();
            if (c < 0) return qAbs;

            // tie
            if (mode === "HALF_UP") return add1();
            if (mode === "HALF_DOWN") return qAbs;

            // HALF_EVEN
            return isOddAbs(qAbs) ? add1() : qAbs;
        }
        default:
            return qAbs;
    }
}

function gcdAbs(a: string, b: string): string {
    a = stripLeadingZeros(a);
    b = stripLeadingZeros(b);
    while (b !== "0") {
        const r = divmodAbs(a, b).r;
        a = b;
        b = r;
    }
    return a;
}

function divExactAbs(a: string, b: string): string {
    const dm = divmodAbs(a, b);
    if (dm.r !== "0") throw new Error("Not divisible exactly");
    return dm.q;
}

export class BigDecimal {
    private sign!: Sign;     // -1 / 0 / 1
    private digits!: string; // abs(unscaled int), decimal string, no leading zeros except "0"
    private scale!: number;  // >= 0

    private static fromParts(sign: Sign, digits: string, scale: number): BigDecimal {
        const bd = Object.create(BigDecimal.prototype) as BigDecimal;
        bd.scale = scale;
        bd.digits = stripLeadingZeros(digits);
        bd.sign = sign;

        // normalize -0
        if (bd.digits === "0") bd.sign = 0;
        return bd;
    }

    constructor(value: string | number | bigint | BigDecimal, scale?: number) {
        // clone
        if (value instanceof BigDecimal) {
            this.sign = value.sign;
            this.digits = value.digits;
            this.scale = value.scale;
            return;
        }

        // bigint input (won't exist on Safari13, but kept for compatibility on modern engines)
        if (typeof value === "bigint") {
            const s = (scale === undefined ? 0 : scale);
            if (!isInt(s) || s < 0) throw new Error("scale must be a non-negative integer");
            const str = String(value); // e.g. "-123"
            const neg = str.charAt(0) === "-";
            const abs = neg ? str.slice(1) : str;
            this.sign = abs === "0" ? 0 : (neg ? -1 : 1);
            this.digits = stripLeadingZeros(abs);
            this.scale = s;
            return;
        }

        if (typeof value === "number") {
            if (!Number.isFinite(value)) throw new Error("Invalid number");
            value = String(value);
        }

        if (typeof value !== "string") {
            throw new Error("Unsupported value type");
        }

        const parsed = BigDecimal.parseDecimalString(value);
        this.sign = parsed.sign;
        this.digits = parsed.digits;
        this.scale = parsed.scale;
    }

    static from(value: string | number | bigint | BigDecimal, scale?: number): BigDecimal {
        return new BigDecimal(value as any, scale);
    }

    getScale(): number {
        return this.scale;
    }

    /** Safari13 版：没有 BigInt，返回“未缩放整数”的字符串（带符号）。 */
    unscaledValue(): any {
        if (this.sign === 0) return "0";
        return (this.sign < 0 ? "-" : "") + this.digits;
    }

    signum(): -1 | 0 | 1 {
        return this.sign;
    }

    abs(): BigDecimal {
        if (this.sign >= 0) return this;
        return BigDecimal.fromParts(1, this.digits, this.scale);
    }

    negate(): BigDecimal {
        if (this.sign === 0) return this;
        return BigDecimal.fromParts((this.sign === 1 ? -1 : 1), this.digits, this.scale);
    }

    add(other: BigDecimal | string | number | bigint): BigDecimal {
        const b = BigDecimal.from(other);
        const s = Math.max(this.scale, b.scale);
        const aDigits = appendZeros(this.digits, s - this.scale);
        const bDigits = appendZeros(b.digits, s - b.scale);

        if (this.sign === 0) return BigDecimal.fromParts(b.sign, bDigits, s);
        if (b.sign === 0) return BigDecimal.fromParts(this.sign, aDigits, s);

        if (this.sign === b.sign) {
            const sum = addAbs(aDigits, bDigits);
            return BigDecimal.fromParts(this.sign, sum, s);
        }

        // different signs => subtraction
        const c = cmpAbs(aDigits, bDigits);
        if (c === 0) {
            // result is 0, keep scale = s (like your BigInt version)
            return BigDecimal.fromParts(0, "0", s);
        }
        if (c > 0) {
            const diff = subAbs(aDigits, bDigits);
            return BigDecimal.fromParts(this.sign, diff, s);
        } else {
            const diff = subAbs(bDigits, aDigits);
            return BigDecimal.fromParts(b.sign, diff, s);
        }
    }

    sub(other: BigDecimal | string | number | bigint): BigDecimal {
        const b = BigDecimal.from(other);
        return this.add(b.negate());
    }

    mul(other: BigDecimal | string | number | bigint): BigDecimal {
        const b = BigDecimal.from(other);
        if (this.sign === 0 || b.sign === 0) {
            return BigDecimal.fromParts(0, "0", this.scale + b.scale);
        }
        const sign: Sign = (this.sign === b.sign ? 1 : -1);
        const prod = mulAbs(this.digits, b.digits);
        return BigDecimal.fromParts(sign, prod, this.scale + b.scale);
    }

    divide(other: BigDecimal | string | number | bigint): BigDecimal;
    divide(other: BigDecimal | string | number | bigint, resultScale: number, rounding: RoundingMode): BigDecimal;
    divide(other: BigDecimal | string | number | bigint, resultScale?: number, rounding?: RoundingMode): BigDecimal {
        const b = BigDecimal.from(other);
        if (b.sign === 0) throw new Error("Division by zero");

        if (resultScale === undefined) {
            return this.divideExact(b);
        }
        const rm: RoundingMode = rounding ? rounding : "HALF_UP";
        return this.divideScaled(b, resultScale, rm);
    }

    setScale(newScale: number, rounding: RoundingMode = "HALF_UP"): BigDecimal {
        if (!isInt(newScale) || newScale < 0) throw new Error("newScale must be a non-negative integer");
        if (newScale === this.scale) return this;

        if (newScale > this.scale) {
            const diff = newScale - this.scale;
            const newDigits = appendZeros(this.digits, diff);
            return BigDecimal.fromParts(this.sign, newDigits, newScale);
        }

        // newScale < this.scale => divide by 10^(diff)
        const diff = this.scale - newScale;

        // qAbs / rAbs when dividing by 10^diff can be done by slicing
        const denomAbs = "1" + new Array(diff + 1).join("0");
        const len = this.digits.length;

        let qAbs: string;
        let rAbs: string;

        if (len <= diff) {
            qAbs = "0";
            rAbs = this.digits;
        } else {
            qAbs = stripLeadingZeros(this.digits.slice(0, len - diff));
            rAbs = stripLeadingZeros(this.digits.slice(len - diff));
        }

        const roundedQAbs = roundQuotientAbs(qAbs, rAbs, denomAbs, this.sign, rounding);
        return BigDecimal.fromParts(this.sign, roundedQAbs, newScale);
    }

    stripTrailingZeros(): BigDecimal {
        if (this.sign === 0) return this; // keep representation scale
        let d = this.digits;
        let s = this.scale;
        while (s > 0 && d.length > 1 && d.charAt(d.length - 1) === "0") {
            d = d.slice(0, -1);
            s -= 1;
        }
        if (d === this.digits && s === this.scale) return this;
        return BigDecimal.fromParts(this.sign, d, s);
    }

    compareTo(other: BigDecimal | string | number | bigint): -1 | 0 | 1 {
        const b = BigDecimal.from(other);
        if (this.sign < b.sign) return -1;
        if (this.sign > b.sign) return 1;
        if (this.sign === 0) return 0;

        const s = Math.max(this.scale, b.scale);
        const aDigits = appendZeros(this.digits, s - this.scale);
        const bDigits = appendZeros(b.digits, s - b.scale);
        const c = cmpAbs(aDigits, bDigits);

        return this.sign > 0 ? c : (c === 0 ? 0 : (c === 1 ? -1 : 1));
    }

    equals(other: BigDecimal | string | number | bigint): boolean {
        const b = BigDecimal.from(other);
        return this.scale === b.scale && this.sign === b.sign && this.digits === b.digits;
    }

    equalsValue(other: BigDecimal | string | number | bigint): boolean {
        return this.compareTo(other) === 0;
    }

    precision(): number {
        if (this.sign === 0) return 1;
        return this.digits.length;
    }

    round(mc: MathContext): BigDecimal {
        if (!mc || !isInt(mc.precision) || mc.precision < 1) {
            throw new Error("MathContext.precision must be an integer >= 1");
        }
        const rm: RoundingMode = mc.roundingMode ? mc.roundingMode : "HALF_UP";

        const curPrec = this.precision();
        if (curPrec <= mc.precision) return this;

        const drop = curPrec - mc.precision; // digits to drop from unscaled
        const denomAbs = "1" + new Array(drop + 1).join("0");

        const len = this.digits.length;
        let qAbs: string;
        let rAbs: string;

        if (len <= drop) {
            qAbs = "0";
            rAbs = this.digits;
        } else {
            qAbs = stripLeadingZeros(this.digits.slice(0, len - drop));
            rAbs = stripLeadingZeros(this.digits.slice(len - drop));
        }

        const roundedQAbs = roundQuotientAbs(qAbs, rAbs, denomAbs, this.sign, rm);

        let newScale = this.scale - drop;
        let newDigits = roundedQAbs;

        if (newScale < 0) {
            newDigits = appendZeros(newDigits, -newScale);
            newScale = 0;
        }

        return BigDecimal.fromParts(this.sign, newDigits, newScale);
    }

    movePointLeft(n: number): BigDecimal {
        if (!isInt(n)) throw new Error("n must be an integer");
        if (n === 0) return this;
        if (n < 0) return this.movePointRight(-n);
        return BigDecimal.fromParts(this.sign, this.digits, this.scale + n);
    }

    movePointRight(n: number): BigDecimal {
        if (!isInt(n)) throw new Error("n must be an integer");
        if (n === 0) return this;
        if (n < 0) return this.movePointLeft(-n);

        const newScale = this.scale - n;
        if (newScale >= 0) {
            return BigDecimal.fromParts(this.sign, this.digits, newScale);
        }
        // scale would become negative => expand digits and set scale=0
        const newDigits = appendZeros(this.digits, -newScale);
        return BigDecimal.fromParts(this.sign, newDigits, 0);
    }

    toPlainString(): string {
        const signStr = this.sign < 0 ? "-" : "";
        const abs = this.digits;

        if (this.scale === 0) return signStr + abs;

        const s = abs; // already a string digits
        const pointPos = s.length - this.scale;

        if (pointPos > 0) {
            const intPart = s.slice(0, pointPos);
            const fracPart = s.slice(pointPos);
            return signStr + intPart + "." + fracPart;
        } else {
            const zeros = new Array((-pointPos) + 1).join("0");
            return signStr + "0." + zeros + s;
        }
    }

    toString(): string {
        return this.toPlainString();
    }

    toNumber(): number {
        return Number(this.toPlainString());
    }

    // -------------------- division helpers --------------------

    private divideExact(divisor: BigDecimal): BigDecimal {
        if (this.sign === 0) {
            // 0 / x = 0 (scale 0 like BigInt version)
            return BigDecimal.fromParts(0, "0", 0);
        }
        if (divisor.sign === 0) throw new Error("Division by zero");

        const signExact: Sign = (this.sign === divisor.sign ? 1 : -1);

        // num/den adjust for scales: num * 10^(sb-sa) / den
        let numAbs = this.digits;
        let denAbs = divisor.digits;
        const exp = divisor.scale - this.scale;
        if (exp >= 0) numAbs = appendZeros(numAbs, exp);
        else denAbs = appendZeros(denAbs, -exp);

        // reduce fraction by gcd
        const g = gcdAbs(numAbs, denAbs);
        numAbs = divExactAbs(numAbs, g);
        denAbs = divExactAbs(denAbs, g);

        // den must be 2^a * 5^b for terminating decimal
        let d = denAbs;
        let p2 = 0;
        let p5 = 0;

        while (d !== "0") {
            const dm2 = divmodSmallAbs(d, 2);
            if (dm2.r !== 0) break;
            d = dm2.q;
            p2++;
        }
        while (d !== "0") {
            const dm5 = divmodSmallAbs(d, 5);
            if (dm5.r !== 0) break;
            d = dm5.q;
            p5++;
        }

        if (stripLeadingZeros(d) !== "1") {
            throw new Error("Non-terminating decimal expansion; specify scale and rounding mode");
        }

        const s = Math.max(p2, p5);
        const mul2 = powAbs("2", s - p2);
        const mul5 = powAbs("5", s - p5);
        let intAbs = mulAbs(numAbs, mul2);
        intAbs = mulAbs(intAbs, mul5);

        return BigDecimal.fromParts(signExact, intAbs, s);
    }

    private divideScaled(divisor: BigDecimal, resultScale: number, rounding: RoundingMode): BigDecimal {
        if (!isInt(resultScale) || resultScale < 0) throw new Error("resultScale must be a non-negative integer");
        if (divisor.sign === 0) throw new Error("Division by zero");

        if (this.sign === 0) {
            return BigDecimal.fromParts(0, "0", resultScale);
        }

        const signExact: Sign = (this.sign === divisor.sign ? 1 : -1);

        // exp = resultScale + sb - sa
        const exp = resultScale + divisor.scale - this.scale;

        let numeratorAbs: string;
        let denominatorAbs: string;

        if (exp >= 0) {
            numeratorAbs = appendZeros(this.digits, exp);
            denominatorAbs = divisor.digits;
        } else {
            numeratorAbs = this.digits;
            denominatorAbs = appendZeros(divisor.digits, -exp);
        }

        // denominator is positive abs here
        const dm = divmodAbs(numeratorAbs, denominatorAbs);
        const qAbs = dm.q;
        const rAbs = dm.r;

        const roundedQAbs = roundQuotientAbs(qAbs, rAbs, denominatorAbs, signExact, rounding);

        return BigDecimal.fromParts(signExact, roundedQAbs, resultScale);
    }

    // -------------------- parsing --------------------

    private static parseDecimalString(input: string): { sign: Sign; digits: string; scale: number } {
        const str = (input || "").trim();
        if (!str) throw new Error("Empty decimal");

        // [+|-]? (digits? "." digits? | "." digits) ( [eE][+|-]?digits )?
        const m = /^([+-])?(?:(\d+)?(?:\.(\d*)?)?|\.(\d+))(?:[eE]([+-]?\d+))?$/.exec(str);
        if (!m) throw new Error("Invalid decimal string: " + input);

        const signChar = m[1] || "";
        let sign: Sign = signChar === "-" ? -1 : 1;

        const intPart = m[2] ? m[2] : "";
        const fracPart = (m[4] ? m[4] : (m[3] ? m[3] : ""));
        const expStr = m[5] ? m[5] : "0";
        const exp = Number(expStr);
        if (!isInt(exp)) throw new Error("Invalid exponent: " + expStr);

        let digits = stripLeadingZeros((intPart + fracPart) || "0");
        let scale = fracPart.length - exp;

        if (scale < 0) {
            digits = appendZeros(digits, -scale);
            scale = 0;
        }

        // normalize sign for zero, but keep scale representation
        if (digits === "0") sign = 0;

        if (!isInt(scale) || scale < 0) throw new Error("Invalid scale after parsing");
        return { sign, digits, scale };
    }
}

JavaScript中，实现数组 sum/avg/min/max

Tue, 27 Jan 2026 12:27:22 +0800

JavaScript中实现类似于Java 的数组操作

直接上代码（TypeScript写法）

/**
 * ArrayAgg - 数据组合工具
 * https://www.yangguangdream.com/?id=2269
 * 
 * 
 * 用法：
 * ArrayAgg.of(list).mapToInt(x => x.price * x.count).sum()
 * ArrayAgg.of(list).sumBy(x => x.count)
 * ArrayAgg.of(list).count(x => x.count > 0)
 * ArrayAgg.of(list).anyMatch(x => x.count > 0)
 * ArrayAgg.of(list).allMatch(x => x.count > 0)
 * ArrayAgg.of(list).mapToInt(x => x.count).sum()
 * ArrayAgg.of(list).mapToInt(x => x.count).count()
 * ArrayAgg.of(list).mapToInt(x => x.count).avg()
 * ArrayAgg.of(list).mapToInt(x => x.count).min()
 * ArrayAgg.of(list).mapToInt(x => x.count).max()
 */
export class ArrayAgg<T> {
  private readonly arr: readonly T[];

  private constructor(arr: readonly T[]) {
    this.arr = arr ?? [];
  }
  //实例化
  static of<T>(arr: readonly T[] | null | undefined): ArrayAgg<T> {
    return new ArrayAgg<T>(arr ?? []);
  }

  //就是类似Java里面的mapToInt，返回IntAgg对象（数字聚合器，用来进行计算)
  mapToInt(selector: (item: T, index: number) => number): IntAgg {
    const nums = this.arr.map((it, i) => selector(it, i));
    return new IntAgg(nums);
  }

  //直接对对象数组按字段求和：sumBy(x => x.xxx)
  sumBy(selector: (item: T, index: number) => number): number {
    return this.mapToInt(selector).sum();
  }

  //直接计数（可选predicate过滤）
  count(predicate?: (item: T, index: number) => boolean): number {
    if (!predicate) return this.arr.length;
    let c = 0;
    for (let i = 0; i < this.arr.length; i++) if (predicate(this.arr[i], i)) c++;
    return c;
  }

  //anyMatch：是否存在任意一个元素满足条件 ,类似于 Array.some()
  anyMatch(predicate: (item: T, index: number) => boolean): boolean {
    for (let i = 0; i < this.arr.length; i++) if (predicate(this.arr[i], i)) return true;
    return false;
  }
  //allMatch：是否所有元素都满足条件,类似于 Array.every()
  allMatch(predicate: (item: T, index: number) => boolean): boolean {
    for (let i = 0; i < this.arr.length; i++) if (!predicate(this.arr[i], i)) return false;
    return true;
  }
}

//数字聚合器类：sum/avg/min/max
export class IntAgg {
  private readonly nums: readonly number[];

  constructor(nums: readonly number[]) {
    this.nums = nums ?? [];
  }

  //mapToInt(xxx).sum() 求和
  sum(): number {
    let s = 0;
    for (let i = 0; i < this.nums.length; i++) {
      const n = this.nums[i];
      // 忽略 NaN / Infinity（按你需要也可以改成 throw）
      if (Number.isFinite(n)) s += n;
    }
    return s;
  }
  //mapToInt(xxx).count() 计数
  count(): number {
    return this.nums.length;
  }
  //mapToInt(xxx).avg() 平均值
  avg(): number {
    const c = this.count();
    return c === 0 ? 0 : this.sum() / c;
  }
  //mapToInt(xxx).min() 最小值
  min(): number | undefined {
    let m: number | undefined = undefined;
    for (const n of this.nums) {
      if (!Number.isFinite(n)) continue;
      if (m === undefined || n < m) m = n;
    }
    return m;
  }

  //mapToInt(xxx).max() 最大值
  max(): number | undefined {
    let m: number | undefined = undefined;
    for (const n of this.nums) {
      if (!Number.isFinite(n)) continue;
      if (m === undefined || n > m) m = n;
    }
    return m;
  }
}

JavaScript 数组扩展 Array.some() 和 Array.every() 的区别

Wed, 21 Jan 2026 17:00:51 +0800

首先说他俩的区别：

1、Array.some() 用于检测数组中的元素是否有满足指定条件的，若有，返回true如果全都不满足，则返回false

2、Array.every() 则与some相反，检测数组中元素是否全部满足指定条件，如果全部满足，返回true，如果有一个条件不满足，则返回false

一、Array.some()

语法（你可以把它理解成为一个foreach循环，你需要为当前循环到的元素，返回一个true/false）：

   let arr=[];
   arr.some((item,index,array)=>{
    //item为当前的对象
    //index为当前的索引
    //array为当前的数组对象

    
   });

some() 会依次执行数组的每个元素
如果其中任意一个数组满足条件，就是说function里面返回了false，则剩余元素不再检测，直接返回true，
如果这个数组循环了一圈下来没有符合条件的元素，则返回false

请注意：

some()不会对空数组检测
some()不会改变原数组

案例：

我有一个采购清单，我需要查找一下有没有大于200元的物品，并且要找一下是否有已经购买的东西（防止买重）

   const arr=[{
    prodName:"键盘",
    price:100,
    isPurchased:false,
    isArrival:false
   },{
    prodName:"显示器",
    price:300,
    isPurchased:false,
    isArrival:false
   },
  {
    prodName:"鼠标",
    price:50,
    isPurchased:false,
    isArrival:false
   }];
   //查找是否有大于200元的物品
   const res= arr.some((item,index,array)=>{
      return item.price>200
   });
   console.log("是否有大于200的物品：",res);
  //查找是否有已经购买的物品
   const resIsPurchased= arr.some((item,index,array)=>{
      return item.isPurchased==true;
   });
   console.log("是否有已经购买的物品",resIsPurchased);

二、Array.every()

语法：和some一样，也可以理解成为一个foreach循环，你需要为当前循环到的元素，返回一个true/false

let arr=[];
   arr.every((item,index,array)=>{
    //item为当前的对象
    //index为当前的索引
    //array为当前的数组对象

   
   });

every() 会使用指定函数检测数组中的所有元素
如果元素中有任意一个元素不满足（function中返回false），则会立即返回false,
如果所有元素都满足条件，则返回true

请注意：

some()不会对空数组检测
some()不会改变原数组

案例：

还是那个采购单，我要找一下是否全部购买，并且全部到货了

   const arr=[{
    prodName:"键盘",
    price:100,
    isPurchased:true,
    isArrival:true
   },{
    prodName:"显示器",
    price:300,
    isPurchased:true,
    isArrival:true
   },
  {
    prodName:"鼠标",
    price:50,
    isPurchased:true,
    isArrival:false
   }];
   //查找是否全部购买了
   const allPurchasedRes=arr.every((item,index,array)=>{
    return item.isPurchased==true;
   });
   console.log("物品是否全部购买：",allPurchasedRes);
   //查找是否全部到货
   const allArrivalRes=arr.every((item,index,array)=>{
    return item.isArrival==true;
   });
   console.log("是否全部到货",allArrivalRes);

【代码】Java 匹配文本相似度基于 Cosine Similarity

Mon, 15 Dec 2025 17:23:20 +0800

直接上代码（返回0-1的小数，数值越大匹配度越高）

import java.util.HashMap;
import java.util.Map;

public class CosineSimilarityUtil {
    //计算两个字符串的字符频向量
    private static Map<String, Integer> getCharacterFrequency(String text) {
        Map<String, Integer> frequencyMap = new HashMap<>();
        char[] chars = text.toCharArray();//按字符分割
        for (char c : chars) {
            String charStr = String.valueOf(c);
            frequencyMap.put(charStr, frequencyMap.getOrDefault(charStr, 0) + 1);
        }
        return frequencyMap;
    }

    //计算Cosine相似度
    public static double calculateCosineSimilarity(String text1, String text2) {
        Map<String, Integer> freqMap1 = getCharacterFrequency(text1);
        Map<String, Integer> freqMap2 = getCharacterFrequency(text2);

        //计算点积
        double dotProduct = 0;
        for (String charStr : freqMap1.keySet()) {
            if (freqMap2.containsKey(charStr)) {
                dotProduct += freqMap1.get(charStr) * freqMap2.get(charStr);
            }
        }



        //计算模长
        double magnitude1 = 0;
        for (int freq : freqMap1.values()) {
            magnitude1 += Math.pow(freq, 2);
        }
        magnitude1 = Math.sqrt(magnitude1);

        double magnitude2 = 0;
        for (int freq : freqMap2.values()) {
            magnitude2 += Math.pow(freq, 2);
        }
        magnitude2 = Math.sqrt(magnitude2);


        //计算余弦相似度
        if (magnitude1 == 0 || magnitude2 == 0) {
            return 0.0;//避免除以0
        }

        return dotProduct / (magnitude1 * magnitude2);
    }

    public static void main(String[] args) {
        String targetText = "相卡整盒";
        String matchingText1 = "相卡随机一发";
        String matchingText2 = "吧唧随机一发";
        String matchingText3 = "路飞相卡";



        System.out.println("相卡随机一发: " + calculateCosineSimilarity(targetText, matchingText1));
        System.out.println("吧唧随机一发: " + calculateCosineSimilarity(targetText, matchingText2));
        System.out.println("路飞相卡: " + calculateCosineSimilarity(targetText, matchingText3));
    }
}

【代码】C#实现输入密码自动隐藏

Wed, 05 Nov 2025 17:51:44 +0800

直接上代码，C# 8.0以上可以直接用

// 密码输入时隐藏
static string ReadPassword()
{
    string password = "";//密码明文
    ConsoleKeyInfo key;//当前按键

    //只要没按enter就一直死循环读取
    while ((key = Console.ReadKey(true)).Key != ConsoleKey.Enter)
    {
        //用户按下退格键，并且当前有输入
        if (key.Key == ConsoleKey.Backspace && password.Length > 0)
        {
            password = password[..^1];//移除最后一个字符
            Console.Write("\b \b");//先退一格，写空格覆盖，再退回光标
        }
        //如果输入的是正常字符
        else if (!char.IsControl(key.KeyChar))
        {
            password += key.KeyChar;//拼接明文
            Console.Write("*");//拼上一个*
        }
    }

    Console.WriteLine();
    return password;
}

使用：

 Console.Write("请输入 p12 密码: ");
 string password = ReadPassword();

【代码】使用HTML5+CSS+SVG 实现苹果液态玻璃(Liquid Glass)效果

Fri, 24 Oct 2025 17:51:24 +0800

来晚了，昨天发现TouTube的播放页面改了，改成了苹果的液态玻璃效果，就好奇他怎么实现的。这东西的核心理念就是【模糊背景】+【不规则扭曲】，像是透过正在晃动的水来看下面的东西一样

1、原理

使用svg 的 feDisplacementMap 这个属性扭曲背景

再配合 backdrop-filter: blur(1px) 做出流动的视觉

传统的毛玻璃效果，我们用 backdrop-filter: blur(10px); 就能轻松搞定。但那只是一个均匀的模糊，看起来很「平」。而「液态」效果的关键在于不均匀的扭曲。

光线穿过一块完全平坦的毛玻璃，和穿过一块表面凹凸不平、像水波一样的玻璃，看到的景象肯定不同。后者会产生更多奇妙的折射和位移。我们的目标，就是用一张「凹凸不平的纹理图」，来告诉浏览器如何去扭曲、置换背景的像素。

2、准备HTML及SVG

<!--這是我們想變成液態玻璃的任何內容-->
<div class="liquid">測試~</div>

<!--svg  濾鏡-->
<svg width="0" height="0" style="position:fixed;left:-9999px;top:-9999px">
    <defs>
        <filter id="liquid_glass_filter" x="0%" y="0%" width="100%" height="100%" filterUnits="objectBoundingBox">
            <feTurbulence type="fractalNoise" baseFrequency="0.003" numOctaves="2" seed="7" result="noise"/>
            <feGaussianBlur in="noise" stdDeviation="1.2" result="map"/>
            <feDisplacementMap in="SourceGraphic" in2="map" scale="110" xChannelSelector="R" yChannelSelector="G"/>
        </filter>
    </defs>
</svg>

<!-- 可微調參數（按需改一兩個就有感）
- 更波動：baseFrequency 調到 0.025 ~ 0.03 或 scale 調到 120~150。
- 更柔順：stdDeviation 調到 1.6 ~ 2.2。
- 降低上下晃動：把 <feDisplacementMap> 的 yChannelSelector="G" 改成 B，上下位移會比較弱。 -->

3、核心CSS样式

.liquid {
    /* 真正的液態關鍵：先模糊、再用 SVG 位移地圖扭曲背景 */
    backdrop-filter: blur(1px) url(#liquid_glass_filter);

    /* 用 box-shadow 取代邊框，營造厚度與光暈 */
    box-shadow:
            inset 0 1px 0 rgba(255,255,255,0.45),
            inset 0 -1px 0 rgba(255,255,255,0.18),
            inset 6px 6px 16px rgba(255,255,255,0.12),
            0 10px 28px rgba(0,0,0,0.35);

    background: rgba(255,255,255, 0.1);
    /*     mask: linear-gradient(90deg, transparent, #000); */

}

/* 若瀏覽器不支援 backdrop-filter，就用柔和漸層墊底 */
@supports not (backdrop-filter: blur(1px)) {
    .liquid {
        background: linear-gradient(135deg, rgba(255,255,255,0.10), rgba(255,255,255,0.04));
    }
}

4、实现效果

【代码】Java实现SHA1加密

Fri, 19 Sep 2025 16:28:27 +0800

这里直接就用 java.security.MessageDigest 这个类进行加密

直接上代码

public class ShaUtils {


    public static String shaEncode(String inStr) throws Exception {
        MessageDigest sha = null;
        try {
            sha = MessageDigest.getInstance("SHA");//获取SHA实例，环境不支持会报错
        } catch (Exception e) {
            System.out.println(e.toString());
            e.printStackTrace();
            return "";
        }

        byte[] byteArray = inStr.getBytes("UTF-8");
        byte[] md5Bytes = sha.digest(byteArray);
        StringBuffer hexValue = new StringBuffer();
        for (int i = 0; i < md5Bytes.length; i++) {
            int val = ((int) md5Bytes[i]) & 0xff;
            if (val < 16) {
                hexValue.append("0");
            }
            hexValue.append(Integer.toHexString(val));
        }
        return hexValue.toString();
    }

    public static void main(String args[]) throws Exception {
        String str = "www.yangguangdream.com";
        System.out.println("source：" + str);//source：www.yangguangdream.com
        System.out.println("sha：" + shaEncode(str));//sha：64a687b0966d568fc893646492743ec268d9ecde
    }

}

使用

String shaStr = Sha1Utils.shaEncode(token);