M

MLOG

हिन्दी

जावास्क्रिप्ट के BigInt प्रकार के लिए एक व्यापक गाइड, जिसमें बड़ी पूर्णांक अंकगणित को संभालने में इसकी विशेषताओं, उपयोग और अनुप्रयोगों को शामिल किया गया है। जानें कि जावास्क्रिप्ट की सीमाओं को कैसे दूर करें और सटीकता के साथ जटिल गणनाएँ करें।

जावास्क्रिप्ट BigInt: बड़े पूर्णांक अंकगणित में महारत हासिल करना

जावास्क्रिप्ट, एक बहुमुखी भाषा होने के बावजूद, बहुत बड़े पूर्णांकों से निपटने में इसकी सीमाएँ हैं। मानक `Number` प्रकार केवल एक निश्चित सीमा तक पूर्णांकों का सटीक रूप से प्रतिनिधित्व कर सकता है, जिसे `Number.MAX_SAFE_INTEGER` के रूप में जाना जाता है। इस सीमा से परे, गणनाएँ imprecise हो जाती हैं, जिससे अप्रत्याशित परिणाम सामने आते हैं। यहीं पर 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:", sum); // आउटपुट: Sum: 111111111011111111100n
console.log("Difference:", difference); // आउटपुट: Difference: -86419753208641975320n
console.log("Product:", product); // आउटपुट: Product: 1219326311370217957951669538098765432100n
console.log("Quotient:", quotient); // आउटपुट: Quotient: 6172839450617283945n
console.log("Remainder:", remainder); // आउटपुट: Remainder: 5n
console.log("Power:", power); // आउटपुट: 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 में बदलते समय सटीकता के संभावित नुकसान से अवगत रहें, यदि BigInt मान `Number.MAX_SAFE_INTEGER` से अधिक हो।

उदाहरण:


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 (imprecise हो सकता है)

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); // यूलर का टोटिएंट फ़ंक्शन

  // एक e (सार्वजनिक घातांक) चुनें ताकि 1 < e < totient और gcd(e, totient) = 1 हो
  const e = 17n;

  // d (निजी घातांक) की गणना करें ताकि (d * e) % totient = 1 हो
  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("Public Key:", keyPair.publicKey);
console.log("Private Key:", 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("Final Amount:", finalAmount); // आउटपुट: Final Amount: 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("Unique ID 1:", id1);
console.log("Unique ID 2:", id2);

BigInt और JSON

BigInt मान JSON द्वारा मूल रूप से समर्थित नहीं हैं। JSON.stringify() का उपयोग करके BigInt वाले जावास्क्रिप्ट ऑब्जेक्ट को सीरियलाइज़ करने का प्रयास करने पर `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 का एक व्यापक अवलोकन प्रदान करता है। अधिक गहन जानकारी और उन्नत तकनीकों के लिए लिंक किए गए संसाधनों का अन्वेषण करें।