M

MLOG

ಕನ್ನಡ

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನ BigInt ಪ್ರಕಾರಕ್ಕೆ ಸಮಗ್ರ ಮಾರ್ಗದರ್ಶಿ. ಇದರ ವೈಶಿಷ್ಟ್ಯಗಳು, ಬಳಕೆ ಮತ್ತು ದೊಡ್ಡ ಪೂರ್ಣಾಂಕ ಗಣಿತದಲ್ಲಿ ಅದರ ಅನ್ವಯಗಳನ್ನು ತಿಳಿಯಿರಿ. ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನ ಮಿತಿಗಳನ್ನು ನಿವಾರಿಸಿ ನಿಖರವಾದ ಲೆಕ್ಕಾಚಾರಗಳನ್ನು ಮಾಡಿ.

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ BigInt: ದೊಡ್ಡ ಪೂರ್ಣಾಂಕ ಗಣಿತವನ್ನು ಕರಗತ ಮಾಡಿಕೊಳ್ಳುವುದು

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್, ಒಂದು ಬಹುಮುಖಿ ಭಾಷೆಯಾಗಿದ್ದರೂ, ಅತಿ ದೊಡ್ಡ ಪೂರ್ಣಾಂಕಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸುವಾಗ ಮಿತಿಗಳನ್ನು ಹೊಂದಿದೆ. ಸ್ಟ್ಯಾಂಡರ್ಡ್ `Number` ಪ್ರಕಾರವು ಕೇವಲ `Number.MAX_SAFE_INTEGER` ಎಂದು ಕರೆಯಲ್ಪಡುವ ನಿರ್ದಿಷ್ಟ ಮಿತಿಯವರೆಗೆ ಮಾತ್ರ ಪೂರ್ಣಾಂಕಗಳನ್ನು ನಿಖರವಾಗಿ ಪ್ರತಿನಿಧಿಸಬಲ್ಲದು. ಈ ಮಿತಿಯನ್ನು ಮೀರಿದಾಗ, ಲೆಕ್ಕಾಚಾರಗಳು ಅನಿಖರವಾಗುತ್ತವೆ, ಇದು ಅನಿರೀಕ್ಷಿತ ಫಲಿತಾಂಶಗಳಿಗೆ ಕಾರಣವಾಗುತ್ತದೆ. ಇಲ್ಲಿಯೇ BigInt ಸಹಾಯಕ್ಕೆ ಬರುತ್ತದೆ. ECMAScript 2020 ರಲ್ಲಿ ಪರಿಚಯಿಸಲಾದ BigInt, ಒಂದು ಅಂತರ್ನಿರ್ಮಿತ ಆಬ್ಜೆಕ್ಟ್ ಆಗಿದ್ದು, ಇದು ಸ್ಟ್ಯಾಂಡರ್ಡ್ `Number` ಪ್ರಕಾರದ ಮಿತಿಗಳನ್ನು ಮೀರಿ, ಯಾವುದೇ ಗಾತ್ರದ ಪೂರ್ಣಾಂಕಗಳನ್ನು ಪ್ರತಿನಿಧಿಸಲು ಮತ್ತು ನಿರ್ವಹಿಸಲು ಒಂದು ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತದೆ.

BigIntನ ಅವಶ್ಯಕತೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು

BigInt ಬರುವುದಕ್ಕಿಂತ ಮೊದಲು, ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಡೆವಲಪರ್‌ಗಳು ದೊಡ್ಡ ಪೂರ್ಣಾಂಕ ಲೆಕ್ಕಾಚಾರಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಲೈಬ್ರರಿಗಳು ಅಥವಾ ಕಸ್ಟಮ್ ಇಂಪ್ಲಿಮೆಂಟೇಷನ್‌ಗಳನ್ನು ಅವಲಂಬಿಸಬೇಕಾಗಿತ್ತು. ಈ ಪರಿಹಾರಗಳು ಸಾಮಾನ್ಯವಾಗಿ ಕಾರ್ಯಕ್ಷಮತೆಯ ಹೊರೆ ಮತ್ತು ಹೆಚ್ಚಿದ ಸಂಕೀರ್ಣತೆಯೊಂದಿಗೆ ಬರುತ್ತಿದ್ದವು. BigIntನ ಪರಿಚಯವು ದೊಡ್ಡ ಪೂರ್ಣಾಂಕಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಒಂದು ಸ್ಥಳೀಯ ಮತ್ತು ದಕ್ಷ ಮಾರ್ಗವನ್ನು ಒದಗಿಸಿತು, ಇದು ವಿವಿಧ ಕ್ಷೇತ್ರಗಳಲ್ಲಿನ ಅನ್ವಯಗಳಿಗೆ ಸಾಧ್ಯತೆಗಳನ್ನು ತೆರೆಯಿತು, ಅವುಗಳೆಂದರೆ:

BigInt ಮೌಲ್ಯಗಳನ್ನು ರಚಿಸುವುದು

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ BigInt ಮೌಲ್ಯಗಳನ್ನು ರಚಿಸಲು ಎರಡು ಪ್ರಾಥಮಿಕ ಮಾರ್ಗಗಳಿವೆ:

  1. BigInt() ಕನ್ಸ್ಟ್ರಕ್ಟರ್ ಬಳಸುವುದು: ಈ ಕನ್ಸ್ಟ್ರಕ್ಟರ್ ಒಂದು ಸಂಖ್ಯೆ, ಸ್ಟ್ರಿಂಗ್, ಅಥವಾ ಬೂಲಿಯನ್ ಮೌಲ್ಯವನ್ನು BigInt ಆಗಿ ಪರಿವರ್ತಿಸಬಲ್ಲದು.
  2. n ಪ್ರತ್ಯಯವನ್ನು ಬಳಸುವುದು: ಪೂರ್ಣಾಂಕದ ಅಕ್ಷರಶಃ ರೂಪಕ್ಕೆ n ಸೇರಿಸುವುದರಿಂದ BigInt ರಚನೆಯಾಗುತ್ತದೆ.

ಉದಾಹರಣೆಗಳು:

BigInt() ಕನ್ಸ್ಟ್ರಕ್ಟರ್ ಬಳಸುವುದು:


const bigIntFromNumber = BigInt(12345678901234567890);
const bigIntFromString = BigInt("98765432109876543210");
const bigIntFromBoolean = BigInt(true); // ಫಲಿತಾಂಶ 1n
const bigIntFromFalseBoolean = BigInt(false); // ಫಲಿತಾಂಶ 0n

console.log(bigIntFromNumber); // ಔಟ್‌ಪುಟ್: 12345678901234567890n
console.log(bigIntFromString); // ಔಟ್‌ಪುಟ್: 98765432109876543210n
console.log(bigIntFromBoolean); // ಔಟ್‌ಪುಟ್: 1n
console.log(bigIntFromFalseBoolean); // ಔಟ್‌ಪುಟ್: 0n

n ಪ್ರತ್ಯಯವನ್ನು ಬಳಸುವುದು:


const bigIntLiteral = 12345678901234567890n;
console.log(bigIntLiteral); // ಔಟ್‌ಪುಟ್: 12345678901234567890n

ಪ್ರಮುಖ ಸೂಚನೆ: ನೀವು ಅಂಕಗಣಿತದ ಕಾರ್ಯಾಚರಣೆಗಳಲ್ಲಿ BigInt ಮತ್ತು Number ಮೌಲ್ಯಗಳನ್ನು ನೇರವಾಗಿ ಮಿಶ್ರಣ ಮಾಡಲು ಸಾಧ್ಯವಿಲ್ಲ. ಲೆಕ್ಕಾಚಾರಗಳನ್ನು ಮಾಡುವ ಮೊದಲು ನೀವು ಅವುಗಳನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಒಂದೇ ಪ್ರಕಾರಕ್ಕೆ ಪರಿವರ್ತಿಸಬೇಕಾಗುತ್ತದೆ. ಅವುಗಳನ್ನು ನೇರವಾಗಿ ಮಿಶ್ರಣ ಮಾಡಲು ಪ್ರಯತ್ನಿಸಿದರೆ TypeError ಉಂಟಾಗುತ್ತದೆ.

BigInt ಅಂಕಗಣಿತದ ಕಾರ್ಯಾಚರಣೆಗಳು

BigInt ಹೆಚ್ಚಿನ ಪ್ರಮಾಣಿತ ಅಂಕಗಣಿತದ ಆಪರೇಟರ್‌ಗಳನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ, ಅವುಗಳೆಂದರೆ:

ಉದಾಹರಣೆಗಳು:


const a = 12345678901234567890n;
const b = 98765432109876543210n;

const sum = a + b;
const difference = a - b;
const product = a * b;
const quotient = a / 2n; // ಸೂಚನೆ: ಭಾಗಾಕಾರವು ಸೊನ್ನೆಯ ಕಡೆಗೆ ಮೊಟಕುಗೊಳಿಸುತ್ತದೆ
const remainder = a % 7n;
const power = a ** 3n; // ಘಾತಾಂಕವು ನಿರೀಕ್ಷೆಯಂತೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ

console.log("ಮೊತ್ತ:", sum); // ಔಟ್‌ಪುಟ್: ಮೊತ್ತ: 111111111011111111100n
console.log("ವ್ಯತ್ಯಾಸ:", difference); // ಔಟ್‌ಪುಟ್: ವ್ಯತ್ಯಾಸ: -86419753208641975320n
console.log("ಗುಣಲಬ್ಧ:", product); // ಔಟ್‌ಪುಟ್: ಗುಣಲಬ್ಧ: 1219326311370217957951669538098765432100n
console.log("ಭಾಗಲಬ್ಧ:", quotient); // ಔಟ್‌ಪುಟ್: ಭಾಗಲಬ್ಧ: 6172839450617283945n
console.log("ಶೇಷ:", remainder); // ಔಟ್‌ಪುಟ್: ಶೇಷ: 5n
console.log("ಘಾತ:", power); // ಔಟ್‌ಪುಟ್: ಘಾತ: 187641281029182300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000n

ಪ್ರಮುಖ ಪರಿಗಣನೆಗಳು:

ಹೋಲಿಕೆ ಆಪರೇಟರ್‌ಗಳು

ನೀವು BigInt ಮೌಲ್ಯಗಳನ್ನು ಇತರ BigInt ಮೌಲ್ಯಗಳೊಂದಿಗೆ ಅಥವಾ Number ಮೌಲ್ಯಗಳೊಂದಿಗೆ ಹೋಲಿಸಲು ಪ್ರಮಾಣಿತ ಹೋಲಿಕೆ ಆಪರೇಟರ್‌ಗಳನ್ನು (==, !=, <, >, <=, >=) ಬಳಸಬಹುದು. ಆದಾಗ್ಯೂ, ಪ್ರಕಾರದ ಪರಿವರ್ತನೆಯ ಸಂಭಾವ್ಯತೆಯ ಬಗ್ಗೆ ಗಮನವಿರಲಿ.

ಉದಾಹರಣೆಗಳು:


const a = 10n;
const b = 20n;
const c = 10;

console.log(a == b);   // ಔಟ್‌ಪುಟ್: false
console.log(a != b);   // ಔಟ್‌ಪುಟ್: true
console.log(a < b);    // ಔಟ್‌ಪುಟ್: true
console.log(a > b);    // ಔಟ್‌ಪುಟ್: false
console.log(a <= b);   // ಔಟ್‌ಪುಟ್: true
console.log(a >= b);   // ಔಟ್‌ಪುಟ್: false

console.log(a == c);   // ಔಟ್‌ಪುಟ್: true (ಪ್ರಕಾರದ ಪರಿವರ್ತನೆ)
console.log(a === c);  // ಔಟ್‌ಪುಟ್: false (ಪ್ರಕಾರದ ಪರಿವರ್ತನೆ ಇಲ್ಲ)

ಉತ್ತಮ ಅಭ್ಯಾಸ: BigInt ಮತ್ತು Number ಮೌಲ್ಯಗಳನ್ನು ಹೋಲಿಸುವಾಗ ಅನಿರೀಕ್ಷಿತ ಪ್ರಕಾರದ ಪರಿವರ್ತನೆಯನ್ನು ತಪ್ಪಿಸಲು ಕಟ್ಟುನಿಟ್ಟಾದ ಸಮಾನತೆ (===) ಮತ್ತು ಕಟ್ಟುನಿಟ್ಟಾದ ಅಸಮಾನತೆ (!==) ಬಳಸಿ.

BigInt ಮತ್ತು Number ನಡುವೆ ಪರಿವರ್ತನೆ

BigInt ಮತ್ತು Number ನಡುವೆ ನೇರ ಅಂಕಗಣಿತದ ಕಾರ್ಯಾಚರಣೆಗಳಿಗೆ ಅನುಮತಿಸಲಾಗದಿದ್ದರೂ, ನೀವು ಎರಡು ಪ್ರಕಾರಗಳ ನಡುವೆ ಪರಿವರ್ತಿಸಬಹುದು. ಆದಾಗ್ಯೂ, BigInt ಮೌಲ್ಯವು `Number.MAX_SAFE_INTEGER` ಮೀರಿದಾಗ BigInt ಅನ್ನು Number ಗೆ ಪರಿವರ್ತಿಸುವಾಗ ನಿಖರತೆಯ ನಷ್ಟದ ಸಂಭಾವ್ಯತೆಯ ಬಗ್ಗೆ ತಿಳಿದಿರಲಿ.

ಉದಾಹರಣೆಗಳು:


const bigIntValue = 9007199254740991n; // Number.MAX_SAFE_INTEGER
const numberValue = Number(bigIntValue); // BigInt ಅನ್ನು Number ಗೆ ಪರಿವರ್ತಿಸುವುದು
console.log(numberValue); // ಔಟ್‌ಪುಟ್: 9007199254740991

const largerBigIntValue = 9007199254740992n; // Number.MAX_SAFE_INTEGER ಮೀರಿದೆ
const largerNumberValue = Number(largerBigIntValue);
console.log(largerNumberValue); // ಔಟ್‌ಪುಟ್: 9007199254740992 (ಅನಿಖರವಾಗಿರಬಹುದು)

const numberToBigInt = BigInt(12345); // Number ಅನ್ನು BigInt ಗೆ ಪರಿವರ್ತಿಸುವುದು
console.log(numberToBigInt); // ಔಟ್‌ಪುಟ್: 12345n

ಬಳಕೆಯ ಪ್ರಕರಣಗಳು ಮತ್ತು ಉದಾಹರಣೆಗಳು

ಕ್ರಿಪ್ಟೋಗ್ರಫಿ

ಕ್ರಿಪ್ಟೋಗ್ರಾಫಿಕ್ ಅಲ್ಗಾರಿದಮ್‌ಗಳು ಭದ್ರತೆಗಾಗಿ ಸಾಮಾನ್ಯವಾಗಿ ಅತಿ ದೊಡ್ಡ ಅವಿಭಾಜ್ಯ ಸಂಖ್ಯೆಗಳನ್ನು ಅವಲಂಬಿಸಿವೆ. BigInt ಈ ಸಂಖ್ಯೆಗಳನ್ನು ದಕ್ಷತೆಯಿಂದ ಪ್ರತಿನಿಧಿಸಲು ಮತ್ತು ನಿರ್ವಹಿಸಲು ಒಂದು ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತದೆ.


// ಉದಾಹರಣೆ: ಸರಳ (ಅಸುರಕ್ಷಿತ) ಕೀ ಜೋಡಿಯನ್ನು ರಚಿಸುವುದು
function generateKeyPair() {
  const p = 281n; // ಒಂದು ಅವಿಭಾಜ್ಯ ಸಂಖ್ಯೆ
  const q = 283n; // ಇನ್ನೊಂದು ಅವಿಭಾಜ್ಯ ಸಂಖ್ಯೆ
  const n = p * q; // ಮಾಡ್ಯುಲಸ್
  const totient = (p - 1n) * (q - 1n); // ಯೂಲರ್‌ನ ಟೋಟಿಯೆಂಟ್ ಫಂಕ್ಷನ್

  // 1 < e < totient ಮತ್ತು gcd(e, totient) = 1 ಆಗಿರುವಂತೆ e (ಸಾರ್ವಜನಿಕ ಘಾತ) ಅನ್ನು ಆಯ್ಕೆಮಾಡಿ
  const e = 17n;

  // (d * e) % totient = 1 ಆಗಿರುವಂತೆ d (ಖಾಸಗಿ ಘಾತ) ಅನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡಿ
  let d = 0n;
  for (let i = 1n; i < totient; i++) {
    if ((i * e) % totient === 1n) {
      d = i;
      break;
    }
  }

  return {
    publicKey: { n, e },
    privateKey: { n, d },
  };
}

const keyPair = generateKeyPair();
console.log("ಸಾರ್ವಜನಿಕ ಕೀ:", keyPair.publicKey);
console.log("ಖಾಸಗಿ ಕೀ:", keyPair.privateKey);

ಸೂಚನೆ: ಇದು ಪ್ರದರ್ಶನ ಉದ್ದೇಶಗಳಿಗಾಗಿ ಮಾತ್ರ ಸರಳೀಕೃತ ಉದಾಹರಣೆಯಾಗಿದೆ. ನೈಜ-ಪ್ರಪಂಚದ ಕ್ರಿಪ್ಟೋಗ್ರಫಿಯು ಹೆಚ್ಚು ದೊಡ್ಡ ಅವಿಭಾಜ್ಯ ಸಂಖ್ಯೆಗಳನ್ನು ಮತ್ತು ಹೆಚ್ಚು ಅತ್ಯಾಧುನಿಕ ಅಲ್ಗಾರಿದಮ್‌ಗಳನ್ನು ಬಳಸುತ್ತದೆ.

ಹಣಕಾಸಿನ ಲೆಕ್ಕಾಚಾರಗಳು

ದೊಡ್ಡ ಮೊತ್ತದ ಹಣದೊಂದಿಗೆ, ವಿಶೇಷವಾಗಿ ಅಂತರರಾಷ್ಟ್ರೀಯ ವಹಿವಾಟುಗಳಲ್ಲಿ ವ್ಯವಹರಿಸುವಾಗ, ನಿಖರತೆ ನಿರ್ಣಾಯಕವಾಗಿದೆ. BigInt ಪೂರ್ಣಾಂಕ ದೋಷಗಳನ್ನು ತಡೆಯಬಹುದು ಮತ್ತು ನಿಖರವಾದ ಲೆಕ್ಕಾಚಾರಗಳನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ.


// ಉದಾಹರಣೆ: ಚಕ್ರಬಡ್ಡಿಯನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುವುದು
function calculateCompoundInterest(principal, rate, time) {
  const principalBigInt = BigInt(principal * 100); // ಸೆಂಟ್‌ಗಳಿಗೆ ಪರಿವರ್ತಿಸಿ
  const rateBigInt = BigInt(rate * 10000);       // ಶೇಕಡಾದ ಹತ್ತು-ಸಾವಿರದ ಒಂದು ಭಾಗಕ್ಕೆ ಪರಿವರ್ತಿಸಿ
  const timeBigInt = BigInt(time);

  let amount = principalBigInt;
  for (let i = 0n; i < timeBigInt; i++) {
    amount = amount * (10000n + rateBigInt) / 10000n;
  }

  const amountInDollars = Number(amount) / 100;
  return amountInDollars;
}

const principal = 1000000; // $1,000,000
const rate = 0.05;    // 5% ಬಡ್ಡಿ ದರ
const time = 10;     // 10 ವರ್ಷಗಳು

const finalAmount = calculateCompoundInterest(principal, rate, time);
console.log("ಅಂತಿಮ ಮೊತ್ತ:", finalAmount); // ಔಟ್‌ಪುಟ್: ಅಂತಿಮ ಮೊತ್ತ: 1628894.6267774413 (ಸರಿಸುಮಾರು)

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ಲೆಕ್ಕಾಚಾರದ ಸಮಯದಲ್ಲಿ ಪೂರ್ಣಾಂಕ ದೋಷಗಳನ್ನು ತಪ್ಪಿಸಲು ನಾವು ಅಸಲು ಮತ್ತು ಬಡ್ಡಿದರವನ್ನು BigInt ಮೌಲ್ಯಗಳಿಗೆ ಪರಿವರ್ತಿಸುತ್ತೇವೆ. ನಂತರ ಫಲಿತಾಂಶವನ್ನು ಪ್ರದರ್ಶನಕ್ಕಾಗಿ Number ಗೆ ಹಿಂತಿರುಗಿಸಲಾಗುತ್ತದೆ.

ದೊಡ್ಡ ಐಡಿಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವುದು

ವಿತರಿಸಿದ ವ್ಯವಸ್ಥೆಗಳಲ್ಲಿ, ಅನೇಕ ಸರ್ವರ್‌ಗಳಾದ್ಯಂತ ಅನನ್ಯ ಐಡಿಗಳನ್ನು ರಚಿಸುವುದು ಸವಾಲಿನದ್ದಾಗಿರಬಹುದು. BigInt ಬಳಸುವುದರಿಂದ ನೀವು ಸಂಘರ್ಷಕ್ಕೆ ಒಳಗಾಗುವ ಸಾಧ್ಯತೆ ಕಡಿಮೆ ಇರುವ ಅತಿ ದೊಡ್ಡ ಐಡಿಗಳನ್ನು ರಚಿಸಬಹುದು.


// ಉದಾಹರಣೆ: ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಮತ್ತು ಸರ್ವರ್ ಐಡಿ ಆಧಾರದ ಮೇಲೆ ಅನನ್ಯ ಐಡಿ ರಚಿಸುವುದು
function generateUniqueId(serverId) {
  const timestamp = BigInt(Date.now());
  const serverIdBigInt = BigInt(serverId);
  const random = BigInt(Math.floor(Math.random() * 1000)); // ಸ್ವಲ್ಪ ಯಾದೃಚ್ಛಿಕತೆಯನ್ನು ಸೇರಿಸಿ

  // ಅನನ್ಯ ಐಡಿ ರಚಿಸಲು ಮೌಲ್ಯಗಳನ್ನು ಸಂಯೋಜಿಸಿ
  const uniqueId = (timestamp << 20n) + (serverIdBigInt << 10n) + random;
  return uniqueId.toString(); // ಸುಲಭ ನಿರ್ವಹಣೆಗಾಗಿ ಸ್ಟ್ರಿಂಗ್ ಆಗಿ ಹಿಂತಿರುಗಿಸಿ
}

const serverId = 123; // ಉದಾಹರಣೆ ಸರ್ವರ್ ಐಡಿ
const id1 = generateUniqueId(serverId);
const id2 = generateUniqueId(serverId);

console.log("ಅನನ್ಯ ಐಡಿ 1:", id1);
console.log("ಅನನ್ಯ ಐಡಿ 2:", id2);

BigInt ಮತ್ತು JSON

BigInt ಮೌಲ್ಯಗಳು JSON ನಿಂದ ಸ್ಥಳೀಯವಾಗಿ ಬೆಂಬಲಿತವಾಗಿಲ್ಲ. BigInt ಹೊಂದಿರುವ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು `JSON.stringify()` ಬಳಸಿ ಸೀರಿಯಲೈಸ್ ಮಾಡಲು ಪ್ರಯತ್ನಿಸಿದರೆ `TypeError` ಉಂಟಾಗುತ್ತದೆ. JSON ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ BigInt ಮೌಲ್ಯಗಳನ್ನು ನಿರ್ವಹಿಸಲು, ನಿಮಗೆ ಒಂದೆರಡು ಆಯ್ಕೆಗಳಿವೆ:

  1. ಸ್ಟ್ರಿಂಗ್‌ಗೆ ಪರಿವರ್ತಿಸಿ: ಸೀರಿಯಲೈಸ್ ಮಾಡುವ ಮೊದಲು BigInt ಅನ್ನು ಸ್ಟ್ರಿಂಗ್‌ಗೆ ಪರಿವರ್ತಿಸಿ. ಇದು ಅತ್ಯಂತ ಸಾಮಾನ್ಯ ಮತ್ತು ನೇರವಾದ ವಿಧಾನವಾಗಿದೆ.
  2. ಕಸ್ಟಮ್ ಸೀರಿಯಲೈಸೇಶನ್/ಡಿಸೀರಿಯಲೈಸೇಶನ್: BigInt ಮೌಲ್ಯಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಕಸ್ಟಮ್ ಸೀರಿಯಲೈಸೇಶನ್/ಡಿಸೀರಿಯಲೈಸೇಶನ್ ಫಂಕ್ಷನ್ ಬಳಸಿ.

ಉದಾಹರಣೆಗಳು:

ಸ್ಟ್ರಿಂಗ್‌ಗೆ ಪರಿವರ್ತಿಸುವುದು:


const data = {
  id: 12345678901234567890n,
  name: "Example Data",
};

// ಸೀರಿಯಲೈಸ್ ಮಾಡುವ ಮೊದಲು BigInt ಅನ್ನು ಸ್ಟ್ರಿಂಗ್‌ಗೆ ಪರಿವರ್ತಿಸಿ
data.id = data.id.toString();

const jsonData = JSON.stringify(data);
console.log(jsonData); // ಔಟ್‌ಪುಟ್: {"id":"12345678901234567890","name":"Example Data"}

// ಡಿಸೀರಿಯಲೈಸ್ ಮಾಡುವಾಗ, ನೀವು ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಮತ್ತೆ BigInt ಗೆ ಪರಿವರ್ತಿಸಬೇಕಾಗುತ್ತದೆ
const parsedData = JSON.parse(jsonData, (key, value) => {
  if (key === "id") {
    return BigInt(value);
  }
  return value;
});

console.log(parsedData.id); // ಔಟ್‌ಪುಟ್: 12345678901234567890n

ಕಸ್ಟಮ್ ಸೀರಿಯಲೈಸೇಶನ್/ಡಿಸೀರಿಯಲೈಸೇಶನ್ (`replacer` ಮತ್ತು `reviver` ಬಳಸಿ):


const data = {
  id: 12345678901234567890n,
  name: "Example Data",
};

// ಕಸ್ಟಮ್ ಸೀರಿಯಲೈಸೇಶನ್
const jsonData = JSON.stringify(data, (key, value) => {
  if (typeof value === 'bigint') {
    return value.toString();
  } else {
    return value;
  }
});

console.log(jsonData);

// ಕಸ್ಟಮ್ ಡಿಸೀರಿಯಲೈಸೇಶನ್
const parsedData = JSON.parse(jsonData, (key, value) => {
    if (typeof value === 'string' && /^[0-9]+$/.test(value)) { //ಇದು ಸಂಖ್ಯೆ ಮತ್ತು ಸ್ಟ್ರಿಂಗ್ ಆಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಿ
      try {
        return BigInt(value);
      } catch(e) {
          return value;
      }
    }
    return value;
});

console.log(parsedData.id);

ಬ್ರೌಸರ್ ಹೊಂದಾಣಿಕೆ

BigInt ಆಧುನಿಕ ಬ್ರೌಸರ್‌ಗಳಲ್ಲಿ ವ್ಯಾಪಕವಾಗಿ ಬೆಂಬಲಿತವಾಗಿದೆ. ಆದಾಗ್ಯೂ, ಹಳೆಯ ಬ್ರೌಸರ್‌ಗಳು ಅಥವಾ ಪರಿಸರಗಳಿಗಾಗಿ ಹೊಂದಾಣಿಕೆಯನ್ನು ಪರಿಶೀಲಿಸುವುದು ಅತ್ಯಗತ್ಯ. ಬ್ರೌಸರ್ ಬೆಂಬಲವನ್ನು ಪರಿಶೀಲಿಸಲು ನೀವು Can I use ನಂತಹ ಸಾಧನವನ್ನು ಬಳಸಬಹುದು. ನೀವು ಹಳೆಯ ಬ್ರೌಸರ್‌ಗಳನ್ನು ಬೆಂಬಲಿಸಬೇಕಾದರೆ, ನೀವು ಪಾಲಿಫಿಲ್ ಬಳಸುವುದನ್ನು ಪರಿಗಣಿಸಬಹುದು, ಆದರೆ ಪಾಲಿಫಿಲ್‌ಗಳು ಕಾರ್ಯಕ್ಷಮತೆಯ ಮೇಲೆ ಪರಿಣಾಮ ಬೀರಬಹುದು ಎಂಬುದನ್ನು ಗಮನದಲ್ಲಿರಲಿ.

ಕಾರ್ಯಕ್ಷಮತೆಯ ಪರಿಗಣನೆಗಳು

BigInt ದೊಡ್ಡ ಪೂರ್ಣಾಂಕಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಶಕ್ತಿಯುತ ಮಾರ್ಗವನ್ನು ಒದಗಿಸಿದರೂ, ಸಂಭಾವ್ಯ ಕಾರ್ಯಕ್ಷಮತೆಯ ಪರಿಣಾಮಗಳ ಬಗ್ಗೆ ತಿಳಿದಿರುವುದು ಮುಖ್ಯ.

ಆದ್ದರಿಂದ, ಅಗತ್ಯವಿದ್ದಾಗ ಮಾತ್ರ BigInt ಬಳಸಿ, ಮತ್ತು ನೀವು ಹೆಚ್ಚಿನ ಸಂಖ್ಯೆಯ BigInt ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನಿರ್ವಹಿಸುತ್ತಿದ್ದರೆ ಕಾರ್ಯಕ್ಷಮತೆಗಾಗಿ ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಆಪ್ಟಿಮೈಜ್ ಮಾಡಿ.

ತೀರ್ಮಾನ

BigInt ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ಗೆ ಒಂದು ಮೌಲ್ಯಯುತ ಸೇರ್ಪಡೆಯಾಗಿದ್ದು, ಡೆವಲಪರ್‌ಗಳಿಗೆ ದೊಡ್ಡ ಪೂರ್ಣಾಂಕ ಗಣಿತವನ್ನು ನಿಖರತೆಯೊಂದಿಗೆ ನಿರ್ವಹಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ಅದರ ವೈಶಿಷ್ಟ್ಯಗಳು, ಮಿತಿಗಳು ಮತ್ತು ಬಳಕೆಯ ಪ್ರಕರಣಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಮೂಲಕ, ಕ್ರಿಪ್ಟೋಗ್ರಫಿ, ಹಣಕಾಸಿನ ಲೆಕ್ಕಾಚಾರಗಳು ಮತ್ತು ವೈಜ್ಞಾನಿಕ ಕಂಪ್ಯೂಟಿಂಗ್ ಸೇರಿದಂತೆ ವಿವಿಧ ಕ್ಷೇತ್ರಗಳಲ್ಲಿ ದೃಢವಾದ ಮತ್ತು ನಿಖರವಾದ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಲು ನೀವು BigInt ಅನ್ನು ಬಳಸಿಕೊಳ್ಳಬಹುದು. ನಿಮ್ಮ ಪ್ರಾಜೆಕ್ಟ್‌ಗಳಲ್ಲಿ BigInt ಬಳಸುವಾಗ ಬ್ರೌಸರ್ ಹೊಂದಾಣಿಕೆ ಮತ್ತು ಕಾರ್ಯಕ್ಷಮತೆಯ ಪರಿಣಾಮಗಳನ್ನು ಪರಿಗಣಿಸಲು ಮರೆಯದಿರಿ.

ಹೆಚ್ಚಿನ ಅನ್ವೇಷಣೆ

ಈ ಮಾರ್ಗದರ್ಶಿಯು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿನ BigInt ಬಗ್ಗೆ ಸಮಗ್ರ ಅವಲೋಕನವನ್ನು ಒದಗಿಸುತ್ತದೆ. ಹೆಚ್ಚು ಆಳವಾದ ಮಾಹಿತಿ ಮತ್ತು ಸುಧಾರಿತ ತಂತ್ರಗಳಿಗಾಗಿ ಲಿಂಕ್ ಮಾಡಲಾದ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಅನ್ವೇಷಿಸಿ.