જાવાસ્ક્રિપ્ટ BigInt: મોટી પૂર્ણાંક અંકગણિતમાં નિપુણતા

જાવાસ્ક્રિપ્ટ, એક બહુમુખી ભાષા હોવા છતાં, જ્યારે ખૂબ મોટા પૂર્ણાંકો સાથે કામ કરવાની વાત આવે ત્યારે તેની મર્યાદાઓ છે. પ્રમાણભૂત `Number` પ્રકાર ફક્ત `Number.MAX_SAFE_INTEGER` તરીકે ઓળખાતી ચોક્કસ મર્યાદા સુધીના પૂર્ણાંકોને સચોટ રીતે રજૂ કરી શકે છે. આ મર્યાદાની બહાર, ગણતરીઓ અચોક્કસ બની જાય છે, જે અનપેક્ષિત પરિણામો તરફ દોરી જાય છે. અહીં જ BigInt બચાવમાં આવે છે. ECMAScript 2020 માં રજૂ કરાયેલ, BigInt એ એક બિલ્ટ-ઇન ઑબ્જેક્ટ છે જે પ્રમાણભૂત `Number` પ્રકારની મર્યાદાઓને ઓળંગીને, મનસ્વી કદના પૂર્ણાંકોને રજૂ કરવા અને હેરફેર કરવાની રીત પ્રદાન કરે છે.

BigInt ની જરૂરિયાતને સમજવું

BigInt પહેલાં, જાવાસ્ક્રિપ્ટ ડેવલપર્સે મોટી પૂર્ણાંક ગણતરીઓ સંભાળવા માટે લાઇબ્રેરીઓ અથવા કસ્ટમ અમલીકરણો પર આધાર રાખવો પડતો હતો. આ ઉકેલો ઘણીવાર પ્રદર્શન ઓવરહેડ અને વધેલી જટિલતા સાથે આવતા હતા. BigInt ની રજૂઆતે મોટા પૂર્ણાંકો સાથે કામ કરવાની એક મૂળ અને કાર્યક્ષમ રીત પ્રદાન કરી, જે વિવિધ ડોમેન્સમાં એપ્લિકેશન્સ માટે શક્યતાઓ ખોલે છે, જેમાં નીચેનાનો સમાવેશ થાય છે:

ક્રિપ્ટોગ્રાફી: ક્રિપ્ટોગ્રાફિક અલ્ગોરિધમ્સ માટે મોટા અવિભાજ્ય નંબરોને સુરક્ષિત રીતે સંભાળવું મહત્વપૂર્ણ છે.
નાણાકીય ગણતરીઓ: ચોકસાઈ ગુમાવ્યા વિના મોટા નાણાકીય મૂલ્યોનું સચોટ પ્રતિનિધિત્વ કરવું.
વૈજ્ઞાનિક કમ્પ્યુટિંગ: અત્યંત મોટા અથવા નાના નંબરોને સંડોવતી જટિલ ગણતરીઓ કરવી.
ઉચ્ચ-ચોકસાઇવાળા ટાઇમસ્ટેમ્પ્સ: નેનોસેકન્ડ ચોકસાઈ સાથે ટાઇમસ્ટેમ્પ્સનું પ્રતિનિધિત્વ કરવું.
ID જનરેશન: અનન્ય અને ખૂબ મોટા ઓળખકર્તાઓ બનાવવું.

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); // આઉટપુટ: ઘાત: 187641281029182300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000n

મહત્વપૂર્ણ વિચારણાઓ:

ભાગાકાર: BigInt મૂલ્યો સાથેનો ભાગાકાર શૂન્ય તરફ પૂર્ણાંકમાં ફેરવાય છે. આનો અર્થ એ છે કે પરિણામનો દશાંશ ભાગ કાઢી નાખવામાં આવે છે. જો તમને વધુ ચોક્કસ ભાગાકારની જરૂર હોય, તો મનસ્વી-ચોકસાઇ અંકગણિતને સમર્થન આપતી લાઇબ્રેરીઓનો ઉપયોગ કરવાનું વિચારો.
યુનરી પ્લસ ઓપરેટર (+): યુનરી પ્લસ ઓપરેટર (+) નો ઉપયોગ BigInt મૂલ્યો સાથે કરી શકાતો નથી કારણ કે તે લેગસી asm.js કોડ સાથે સંઘર્ષ કરશે. જો તમને સંખ્યાત્મક રજૂઆતની જરૂર હોય તો BigInt ને Number માં રૂપાંતરિત કરવા માટે `Number()` કન્વર્ઝન ફંક્શનનો ઉપયોગ કરો (એ સમજણ સાથે કે તમે ચોકસાઈ ગુમાવી શકો છો).
બિટવાઇઝ ઓપરેટરો: BigInt `&`, `|`, `^`, `~`, `<<`, અને `>>` જેવા બિટવાઇઝ ઓપરેટરોને પણ સમર્થન આપે છે. આ ઓપરેટરો BigInt મૂલ્યોની બાઈનરી રજૂઆત પર અપેક્ષા મુજબ કામ કરે છે.

સરખામણી ઓપરેટરો

તમે 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); // યુલરનું ટોટિયન્ટ ફંક્શન

  // એક 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 રાઉન્ડિંગ ભૂલોને અટકાવી શકે છે અને સચોટ ગણતરીઓ સુનિશ્ચિત કરી શકે છે.


// ઉદાહરણ: ચક્રવૃદ્ધિ વ્યાજની ગણતરી
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 માં પાછું રૂપાંતરિત કરવામાં આવે છે.

મોટા IDs સાથે કામ કરવું

વિતરિત સિસ્ટમોમાં, બહુવિધ સર્વરો પર અનન્ય IDs બનાવવું પડકારજનક હોઈ શકે છે. BigInt નો ઉપયોગ કરવાથી તમે ખૂબ મોટા IDs બનાવી શકો છો જેની ટકરાવાની શક્યતા ઓછી હોય છે.


// ઉદાહરણ: ટાઇમસ્ટેમ્પ અને સર્વર ID પર આધારિત અનન્ય ID બનાવવું
function generateUniqueId(serverId) {
  const timestamp = BigInt(Date.now());
  const serverIdBigInt = BigInt(serverId);
  const random = BigInt(Math.floor(Math.random() * 1000)); // થોડી રેન્ડમનેસ ઉમેરો

  // અનન્ય ID બનાવવા માટે મૂલ્યોને જોડો
  const uniqueId = (timestamp << 20n) + (serverIdBigInt << 10n) + random;
  return uniqueId.toString(); // સરળ હેન્ડલિંગ માટે સ્ટ્રિંગ તરીકે પાછા ફરો
}

const serverId = 123; // ઉદાહરણ સર્વર ID
const id1 = generateUniqueId(serverId);
const id2 = generateUniqueId(serverId);

console.log("અનન્ય ID 1:", id1);
console.log("અનન્ય ID 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 ની એક વ્યાપક ઝાંખી પૂરી પાડે છે. વધુ ઊંડાણપૂર્વકની માહિતી અને અદ્યતન તકનીકો માટે લિંક કરેલા સંસાધનોનું અન્વેષણ કરો.