జావాస్క్రిప్ట్ 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 విలువలతో ఉపయోగించలేరు ఎందుకంటే ఇది పాత asm.js కోడ్‌తో విభేదిస్తుంది. మీకు సంఖ్యా ప్రాతినిధ్యం అవసరమైతే (కచ్చితత్వం కోల్పోయే అవకాశం ఉందని అర్థం చేసుకుని) ఒక BigIntను ఒక Numberగా మార్చడానికి `Number()` మార్పిడి ఫంక్షన్‌ను ఉపయోగించండి.
• బిట్‌వైజ్ ఆపరేటర్లు: BigInt బిట్‌వైజ్ ఆపరేటర్లు `&`, `|`, `^`, `~`, `<<`, మరియు `>>` లకు కూడా మద్దతు ఇస్తుంది. ఈ ఆపరేటర్లు BigInt విలువల బైనరీ ప్రాతినిధ్యంపై ఊహించిన విధంగా పనిచేస్తాయి.

పోలిక ఆపరేటర్లు

మీరు BigInt విలువలను ఇతర BigInt విలువలతో లేదా Number విలువలతో కూడా పోల్చడానికి ప్రామాణిక పోలిక ఆపరేటర్లను (`==`, `!=`, `<`, `>`, `<=`, `>=`) ఉపయోగించవచ్చు. అయినప్పటికీ, రకం మార్పిడి (type coercion) సంభావ్యత గురించి జాగ్రత్తగా ఉండండి.

ఉదాహరణలు:

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 కార్యకలాపాలు ప్రామాణిక Number కార్యకలాపాల కంటే నెమ్మదిగా ఉండవచ్చు.
• BigInt మరియు Number మధ్య మార్పిడి కూడా ఓవర్‌హెడ్‌ను పరిచయం చేయవచ్చు.

అందువల్ల, అవసరమైనప్పుడు మాత్రమే BigIntను ఉపయోగించండి, మరియు మీరు పెద్ద సంఖ్యలో BigInt కార్యకలాపాలను నిర్వహిస్తుంటే పనితీరు కోసం మీ కోడ్‌ను ఆప్టిమైజ్ చేయండి.

ముగింపు

BigInt జావాస్క్రిప్ట్‌కు ఒక విలువైన అదనంగా ఉంది, డెవలపర్లు పెద్ద పూర్ణాంకాల గణితాన్ని కచ్చితత్వంతో నిర్వహించడానికి వీలు కల్పిస్తుంది. దాని ఫీచర్లు, పరిమితులు, మరియు వినియోగ సందర్భాలను అర్థం చేసుకోవడం ద్వారా, మీరు క్రిప్టోగ్రఫీ, ఆర్థిక గణనలు, మరియు శాస్త్రీయ కంప్యూటింగ్ వంటి వివిధ రంగాలలో పటిష్టమైన మరియు కచ్చితమైన అనువర్తనాలను నిర్మించడానికి BigIntను ఉపయోగించవచ్చు. మీ ప్రాజెక్ట్‌లలో BigIntను ఉపయోగిస్తున్నప్పుడు బ్రౌజర్ అనుకూలత మరియు పనితీరు ప్రభావాలను పరిగణలోకి తీసుకోవడం గుర్తుంచుకోండి.

మరింత అన్వేషణ

• మోజిల్లా డెవలపర్ నెట్‌వర్క్ (MDN) - BigInt
• V8 బ్లాగ్ - BigInt: జావాస్క్రిప్ట్‌లో ఏకపక్ష-కచ్చితత్వ పూర్ణాంకాలు

ఈ గైడ్ జావాస్క్రిప్ట్‌లో BigInt యొక్క సమగ్ర అవలోకనాన్ని అందిస్తుంది. మరింత లోతైన సమాచారం మరియు అధునాతన పద్ధతుల కోసం లింక్ చేయబడిన వనరులను అన్వేషించండి.