जावास्क्रिप्ट BigInt: मोठ्या पूर्णांक अंकगणितावर प्रभुत्व मिळवणे

जावास्क्रिप्ट, एक बहुपयोगी भाषा असूनही, खूप मोठ्या पूर्णांकांशी व्यवहार करताना त्यात काही मर्यादा आहेत. मानक `Number` प्रकार फक्त एका विशिष्ट मर्यादेपर्यंत पूर्णांक अचूकपणे दर्शवू शकतो, ज्याला `Number.MAX_SAFE_INTEGER` म्हणून ओळखले जाते. या मर्यादेच्या पलीकडे, गणना अचूक राहत नाही, ज्यामुळे अनपेक्षित परिणाम मिळतात. इथेच BigInt मदतीला येते. ECMAScript 2020 मध्ये सादर केलेले, BigInt एक अंगभूत ऑब्जेक्ट आहे जो मानक `Number` प्रकाराच्या मर्यादा ओलांडून, कोणत्याही आकाराच्या पूर्णांकांचे प्रतिनिधित्व आणि हाताळणी करण्याचा मार्ग प्रदान करतो.

BigInt ची गरज समजून घेणे

BigInt पूर्वी, जावास्क्रिप्ट डेव्हलपर्सना मोठ्या पूर्णांक गणनेसाठी लायब्ररी किंवा कस्टम इम्प्लिमेंटेशन्सवर अवलंबून राहावे लागत होते. या सोल्यूशन्समध्ये अनेकदा कार्यक्षमतेचा अभाव आणि वाढलेली गुंतागुंत असायची. BigInt च्या परिचयाने मोठ्या पूर्णांकांसह काम करण्याचा एक नेटिव्ह आणि कार्यक्षम मार्ग प्रदान केला, ज्यामुळे विविध क्षेत्रांमध्ये अनुप्रयोगांसाठी संधी उपलब्ध झाल्या, ज्यात खालील गोष्टींचा समावेश आहे:

क्रिप्टोग्राफी: क्रिप्टोग्राफिक अल्गोरिदमसाठी मोठ्या अविभाज्य संख्या सुरक्षितपणे हाताळणे महत्त्वाचे आहे.
आर्थिक गणना: अचूकतेच्या नुकसानाशिवाय मोठ्या आर्थिक मूल्यांचे अचूक प्रतिनिधित्व करणे.
वैज्ञानिक संगणन: अत्यंत मोठ्या किंवा लहान संख्यांचा समावेश असलेल्या जटिल गणना करणे.
उच्च-अचूक टाइमस्टॅम्प: नॅनोसेकंद अचूकतेसह टाइमस्टॅम्प दर्शवणे.
आयडी जनरेशन: अद्वितीय आणि खूप मोठे आयडेंटिफायर तयार करणे.

BigInt व्हॅल्यू तयार करणे

जावास्क्रिप्टमध्ये BigInt व्हॅल्यू तयार करण्याचे दोन प्राथमिक मार्ग आहेत:

BigInt() कन्स्ट्रक्टर वापरून: हा कन्स्ट्रक्टर संख्या, स्ट्रिंग किंवा बूलियन व्हॅल्यूला BigInt मध्ये रूपांतरित करू शकतो.
`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); // यूलरचे टोटिएंट फंक्शन

  // एक 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("पब्लिक की:", keyPair.publicKey);
console.log("प्रायव्हेट की:", keyPair.privateKey);

टीप: हे केवळ प्रात्यक्षिकासाठी एक सोपे उदाहरण आहे. वास्तविक-जगातील क्रिप्टोग्राफीमध्ये खूप मोठ्या अविभाज्य संख्या आणि अधिक अत्याधुनिक अल्गोरिदम वापरले जातात.

आर्थिक गणना

मोठ्या रकमेच्या पैशांशी व्यवहार करताना, विशेषतः आंतरराष्ट्रीय व्यवहारांमध्ये, अचूकता महत्त्वाची असते. BigInt गोलाकार त्रुटी (rounding errors) टाळू शकते आणि अचूक गणना सुनिश्चित करू शकते.


// उदाहरण: चक्रवाढ व्याजाची गणना
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 मध्ये रूपांतरित केला जातो.

मोठ्या आयडीसह काम करणे

वितरित प्रणालींमध्ये (distributed systems), एकाधिक सर्व्हरवर अद्वितीय आयडी तयार करणे आव्हानात्मक असू शकते. 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 द्वारे नेटिव्हली समर्थित नाहीत. JSON.stringify() वापरून BigInt असलेल्या जावास्क्रिप्ट ऑब्जेक्टला सिरीयलाइज करण्याचा प्रयत्न केल्यास `TypeError` येईल. JSON सह काम करताना BigInt व्हॅल्यू हाताळण्यासाठी, आपल्याकडे काही पर्याय आहेत:

स्ट्रिंगमध्ये रूपांतरित करा: सिरीयलाइज करण्यापूर्वी BigInt ला स्ट्रिंगमध्ये रूपांतरित करा. हा सर्वात सामान्य आणि सोपा दृष्टीकोन आहे.
कस्टम सिरीयलाइजेशन/डिसिरियलाइजेशन: BigInt व्हॅल्यू हाताळण्यासाठी कस्टम सिरीयलाइजेशन/डिसिरियलाइजेशन फंक्शन वापरा.

उदाहरणे:

स्ट्रिंगमध्ये रूपांतरित करणे:


const data = {
  id: 12345678901234567890n,
  name: "उदाहरण डेटा",
};

// सिरीयलाइज करण्यापूर्वी BigInt ला स्ट्रिंगमध्ये रूपांतरित करा
data.id = data.id.toString();

const jsonData = JSON.stringify(data);
console.log(jsonData); // आउटपुट: {"id":"12345678901234567890","name":"उदाहरण डेटा"}

// डिसिरियलाइज करताना, तुम्हाला स्ट्रिंगला पुन्हा 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: "उदाहरण डेटा",
};

// कस्टम सिरीयलाइजेशन
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 वापरताना ब्राउझर सुसंगतता आणि कार्यप्रदर्शन परिणामांचा विचार करणे लक्षात ठेवा.

पुढील अन्वेषण

हे मार्गदर्शक जावास्क्रिप्टमधील BigInt चे सर्वसमावेशक विहंगावलोकन प्रदान करते. अधिक सखोल माहिती आणि प्रगत तंत्रांसाठी लिंक केलेल्या संसाधनांचे अन्वेषण करा.