ஜாவாஸ்கிரிப்ட் பிக்இன்ட்: பெரிய முழு எண் கணிதத்தில் தேர்ச்சி பெறுதல்

ஜாவாஸ்கிரிப்ட், ஒரு பல்துறை மொழியாக இருந்தாலும், மிகப் பெரிய முழு எண்களைக் கையாளும் போது அதற்கு வரம்புகள் உள்ளன. நிலையான `Number` வகை `Number.MAX_SAFE_INTEGER` எனப்படும் ஒரு குறிப்பிட்ட வரம்பு வரை மட்டுமே முழு எண்களைத் துல்லியமாகக் குறிக்க முடியும். இந்த வரம்பிற்கு அப்பால், கணக்கீடுகள் துல்லியமற்றதாகி, எதிர்பாராத முடிவுகளுக்கு வழிவகுக்கும். இந்த இடத்தில்தான் BigInt உதவிக்கு வருகிறது. ECMAScript 2020 இல் அறிமுகப்படுத்தப்பட்ட, BigInt என்பது ஒரு உள்ளமைக்கப்பட்ட பொருளாகும், இது நிலையான `Number` வகையின் வரம்புகளை மீறி, எந்த அளவிலான முழு எண்களையும் குறிக்கவும் கையாளவும் ஒரு வழியை வழங்குகிறது.

பிக்இன்ட்டின் தேவையைப் புரிந்துகொள்ளுதல்

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 பின்வருபவை உட்பட பெரும்பாலான நிலையான எண்கணித ஆபரேட்டர்களை ஆதரிக்கிறது:

• கூட்டல் (`+`)
• கழித்தல் (`-`)
• பெருக்கல் (`*`)
• வகுத்தல் (`/`)
• மீதி (`%`)
• அடுக்குக்குறி (`**`)

எடுத்துக்காட்டுகள்:

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: 111111111011111111100n
console.log("வித்தியாசம்:", difference); // வெளியீடு: Difference: -86419753208641975320n
console.log("பெருக்கற்பலன்:", product); // வெளியீடு: Product: 1219326311370217957951669538098765432100n
console.log("ஈவு:", quotient); // வெளியீடு: Quotient: 6172839450617283945n
console.log("மீதி:", remainder); // வெளியீடு: Remainder: 5n
console.log("அடுக்கு:", power); // வெளியீடு: Power: 187641281029182300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000n

முக்கிய கருத்தாய்வுகள்:

• வகுத்தல்: BigInt மதிப்புகளுடன் வகுத்தல் பூஜ்ஜியத்தை நோக்கிச் சுருக்கப்படும். இதன் பொருள் முடிவின் தசமப் பகுதி நிராகரிக்கப்படுகிறது. உங்களுக்கு இன்னும் துல்லியமான வகுத்தல் தேவைப்பட்டால், தன்னிச்சையான-துல்லிய கணிதத்தை ஆதரிக்கும் நூலகங்களைப் பயன்படுத்துவதைக் கருத்தில் கொள்ளுங்கள்.
• யூனரி பிளஸ் ஆபரேட்டர் (+): யூனரி பிளஸ் ஆபரேட்டர் (+) BigInt மதிப்புகளுடன் பயன்படுத்த முடியாது, ஏனெனில் அது மரபு asm.js குறியீட்டுடன் முரண்படும். உங்களுக்கு ஒரு எண் பிரதிநிதித்துவம் தேவைப்பட்டால் (நீங்கள் துல்லியத்தை இழக்க நேரிடும் என்பதைப் புரிந்துகொண்டு), ஒரு BigInt ஐ ஒரு எண்ணாக மாற்ற `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.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); // வெளியீடு: 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("தனிப்பட்ட ஐடி 1:", id1);
console.log("தனிப்பட்ட ஐடி 2:", id2);

பிக்இன்ட் மற்றும் 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) - பிக்இன்ட்
• V8 வலைப்பதிவு - பிக்இன்ட்: ஜாவாஸ்கிரிப்டில் தன்னிச்சையான-துல்லிய முழு எண்கள்

இந்த வழிகாட்டி ஜாவாஸ்கிரிப்டில் BigInt இன் விரிவான கண்ணோட்டத்தை வழங்குகிறது. மேலும் ஆழமான தகவல்கள் மற்றும் மேம்பட்ட நுட்பங்களுக்கு இணைக்கப்பட்ட ஆதாரங்களை ஆராயுங்கள்.