// 安全整數(shù)的邊界
console.log(Number.MAX_SAFE_INTEGER); // 9007199254740991

// 精度丟失示例
console.log(9007199254740992 === 9007199254740993); // true（實際應為 false）
console.log(1234567890123456789 + 1); // 1234567890123456800（結(jié)果錯誤）

// 1. 字面量方式（推薦，數(shù)字后加 n）
const bigInt1 = 123456789012345678901234567890n;

// 2. 構造函數(shù)方式（傳入整數(shù)或數(shù)字字符串）
const bigInt2 = BigInt(1234567890);
const bigInt3 = BigInt('98765432109876543210');

// 3. 注意：不能用非整數(shù)字符串創(chuàng)建
// const invalid = BigInt('123.45'); // 報錯

const a = 9007199254740993n;
const b = 1n;
console.log(a + b); // 9007199254740994n（精確計算）
console.log(1000000000000000000000n * 2n); // 2000000000000000000000n

const big = 10n;
const num = 5;

// 錯誤：不同類型直接運算
// console.log(big + num); // TypeError: Cannot mix BigInt and other types

// 正確：先統(tǒng)一類型
console.log(big + BigInt(num)); // 15n（Number → BigInt）
console.log(Number(big) + num); // 15（BigInt → Number，注意精度風險）

console.log(10n / 3n); // 3n（結(jié)果為整數(shù)，非 3.333...）
console.log(7n % 4n); // 3n

const data = { 
  id: 123456789012345678901234567890n, 
  count: 100n 
};

// 錯誤：直接序列化會報錯
// JSON.stringify(data); // TypeError

// 正確：自定義序列化函數(shù)
const jsonStr = JSON.stringify(data, (key, value) => {
  return typeof value === 'bigint' ? value.toString() : value;
});

// 反序列化時轉(zhuǎn)回 BigInt
const parsed = JSON.parse(jsonStr, (key, value) => {
  if (/^\d+$/.test(value)) { // 僅對純數(shù)字字符串轉(zhuǎn)換
    return BigInt(value);
  }
  return value;
});

/**
 * 安全解析后端返回的大整數(shù) ID
 * @param {string} idString - 后端返回的 ID 字符串（避免直接傳 Number）
 * @returns {Object} 包含多種類型的 ID 數(shù)據(jù)
 */
function parseBigId(idString) {
  const bigId = BigInt(idString);
  const isSafe = bigId <= Number.MAX_SAFE_INTEGER;
  
  return {
    raw: idString,          // 原始字符串（最安全）
    bigint: bigId,          // BigInt 類型（精確計算用）
    number: isSafe ? Number(bigId) : null // 安全范圍內(nèi)才轉(zhuǎn) Number
  };
}

// 示例：處理后端返回的 ID
const apiResponse = { 
  userId: "12345678901234567890" // 后端用字符串返回（推薦）
};

const userId = parseBigId(apiResponse.userId);
console.log(userId.bigint === 12345678901234567890n); // true（精確比對）

/**
 * 安全計算金額（避免浮點數(shù)誤差）
 * @param {number} yuan1 - 金額1（元）
 * @param {number} yuan2 - 金額2（元）
 * @returns {number} 總和（元）
 */
function safeAddMoney(yuan1, yuan2) {
  // 轉(zhuǎn)換為分（避免浮點數(shù)，用 Math.round 處理四舍五入）
  const cents1 = BigInt(Math.round(yuan1 * 100));
  const cents2 = BigInt(Math.round(yuan2 * 100));
  
  // 整數(shù)相加（無精度損失）
  const totalCents = cents1 + cents2;
  
  // 轉(zhuǎn)回元（此時精度風險已消除）
  return Number(totalCents) / 100;
}

// 測試浮點數(shù)敏感場景
console.log(0.1 + 0.2); // 0.30000000000000004（錯誤）
console.log(safeAddMoney(0.1, 0.2)); // 0.3（正確）
console.log(safeAddMoney(199.99, 299.99)); // 499.98（正確）

// 處理超大時間戳（如 100 年后的毫秒級時間戳）
const futureTimestamp = BigInt('1000000000000000000'); // 超過安全整數(shù)范圍
console.log(futureTimestamp + 86400000n); // 正確計算一天后的時間戳

// 大數(shù)據(jù)統(tǒng)計累加
function sumLargeNumbers(numbers) {
  return numbers.reduce((total, num) => total + BigInt(num), 0n);
}

const largeNumbers = [
  '9007199254740993', 
  '1234567890123456789', 
  '98765432109876543210'
];
console.log(sumLargeNumbers(largeNumbers).toString()); // 正確累加結(jié)果

// 檢測 BigInt 支持性
const supportsBigInt = typeof BigInt !== 'undefined';

/**
 * 安全創(chuàng)建大整數(shù)（兼容不支持 BigInt 的環(huán)境）
 * @param {string|number} value - 數(shù)值
 * @returns {BigInt|string} 支持則返回 BigInt，否則返回字符串
 */
function safeBigInt(value) {
  if (supportsBigInt) {
    return BigInt(value);
  }
  
  // 不支持時用字符串兜底（需確保后續(xù)操作兼容字符串）
  console.warn('當前環(huán)境不支持 BigInt，使用字符串處理大數(shù)值');
  return String(value);
}

// 解決 0.1 + 0.2 精度問題
const sum = new BigNumber('0.1').plus('0.2');
console.log(sum.toString()); // "0.3"

// 復雜計算
const result = new BigNumber('123456789.123456789')
  .multipliedBy('987654321.987654321')
  .dividedBy('123456789.123456789');
console.log(result.toString()); // 精確結(jié)果