JavaScript BigInt - Jassif Team

JavaScript BigInt என்றால் என்ன?

BigInt என்பது பெரிய முழு எண் மதிப்புகளைக் கையாளவும் சேமிக்கவும் ஒரு JavaScript தரவு வகை.

BigInt எண்களின் வரம்புக்கு அப்பாற்பட்ட பெரிய முழு எண்களுடன் வேலை செய்ய உங்களை அனுமதிக்கிறது.

BigInt எந்த அளவிலான முழு எண்ணையும் குறிக்க முடியும், கிடைக்கும் நினைவகத்தால் மட்டுமே வரையறுக்கப்படுகிறது.

JavaScript துல்லியம்

JavaScript எண்கள் 15 இலக்கங்கள் வரை மட்டுமே துல்லியமானவை:

எடுத்துக்காட்டு

                // 15 இலக்கங்கள்:

                let x = 999999999999999; // சரி

                // 16 இலக்கங்கள்:

                let y = 9999999999999999; // துல்லியம் இழக்கும்

எண்கள் 64-பிட் மிதவை புள்ளி

அனைத்து JavaScript எண்களும் 64-பிட் மிதவை-புள்ளி வடிவமைப்பில் சேமிக்கப்படுகின்றன (IEEE 754 தரநிலை).

இந்த தரநிலையுடன், பெரிய எண்களை சரியாக குறிப்பிட முடியாது, ஆனால் வட்டமிடப்படும்.

பாதுகாப்பான எண் வரம்புகள்:

JavaScript 2⁵³-1 (9007199254740991) வரை மட்டுமே பாதுகாப்பாக முழு எண்களைக் குறிக்க முடியும்.

JavaScript -2⁵³-1 (-9007199254740991) வரை மட்டுமே பாதுகாப்பாக முழு எண்களைக் குறிக்க முடியும்.

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

                // MAX = 9007199254740991

                let x = Number.MAX_SAFE_INTEGER;

                // MIN = -9007199254740991

                let y = Number.MIN_SAFE_INTEGER;

Number.MAX_SAFE_INTEGER ஐ விட பெரிய முழு எண்கள் துல்லியத்தை இழக்கும்:

                // Max (துல்லியமானது)

                let x = 9007199254740991;

                // Max + 10 (துல்லியமற்றது)

                let y = x + 10; // துல்லியம் இழக்கும்!

⚠️ குறிப்பு:

JavaScript Integer என்று எதுவும் இல்லை.

அனைத்து JavaScript எண்களும் 64-பிட் மிதவை புள்ளி.

BigInt ஐ எவ்வாறு உருவாக்குவது

நீங்கள் இரண்டு வழிகளில் ஒரு BigInt ஐ உருவாக்கலாம்:

ஒரு முழு எண் மாறிலியை n பின்னொட்டுடன் பயன்படுத்துதல்
BigInt() கட்டமைப்பாளரை சரத்துடன் பயன்படுத்துதல்

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

                // n பின்னொட்டுடன் முழு எண் மாறிலியைப் பயன்படுத்துதல்:

                let x = 999999999999999n;

                // சரத்துடன் BigInt() கட்டமைப்பாளரைப் பயன்படுத்துதல்:

                let y = BigInt("999999999999999");

                let x = 12345678901234567890n;

                let y = BigInt("12345678901234567890")

⚠️ எச்சரிக்கை:

எண்ணுடன் Bigint() கட்டமைப்பாளரைப் பயன்படுத்துவது பரிந்துரைக்கப்படாது. எண்கள் 15 இலக்கங்கள் வரை மட்டுமே துல்லியமானவை.

BigInt உருவாக்குதல் டெமோ:

BigInt உருவாக்கப்பட்டது:

BigInt ஒரு JavaScript தரவு வகை

ஒரு BigInt இன் JavaScript typeof "bigint" ஆகும்:

                let x = BigInt(999999999999999);

                let type = typeof x; // "bigint"

BigInt என்பது JavaScript இல் இரண்டாவது எண் தரவு வகை (Number க்குப் பிறகு).

BigInt உடன் JavaScript இல் ஆதரிக்கப்படும் மொத்த தரவு வகைகளின் எண்ணிக்கை 8:

String

"Hello"

Number

123

புதியது

Bigint

123n

Boolean

true/false

Undefined

undefined

Null

null

Symbol

Symbol()

Object

{}

கணித செயலிகள்

BigInt நிலையான JavaScript கணித செயலிகளை ஆதரிக்கிறது.

(+, -, ++, --, *, /, %, **)

எடுத்துக்காட்டு

                // பெருக்கல்:

                let x = 9007199254740995n;

                let y = 9007199254740995n;

                let z = x * y; // BigInt பெருக்கல்

BigInt மற்றும் எண்களை கலத்தல்

BigInt மற்றும் Number க்கு இடையேயான கணிதம் அனுமதிக்கப்படாது (TypeError ஏற்படும்).

முதலில் வெளிப்படையான மாற்றம் செய்யப்பட வேண்டும்.

❌ அனுமதிக்கப்படாது:

                    let x = 10n;

                    let y = 5;

                    let z = x + y; // ❌ TypeError

✓ சரி செய்யப்பட்டது:

                    let x = 10n;

                    let y = 5;

                    let z = Number(x) + y; // வெளிப்படையான மாற்றம்

மாற்றுதல் டெமோ:

மாற்றல் முடிவுகள்:

BigInt தசமங்கள்

ஒரு BigInt க்கு தசமங்கள் இருக்க முடியாது.

let x = 1.5n; // ❌ TypeError

⚠️ குறிப்பு:

பகுதியளவு பகுதி கொண்ட எண்ணை BigInt ஆக மாற்ற முயற்சிப்பது பிழையை ஏற்படுத்தும்.

ஒப்பீட்டு செயலிகள்

Bigint நிலையான JavaScript ஒப்பீட்டு செயலிகளை ஆதரிக்கிறது.

(<, > ==, ===, !==, <=, >=)

நிலையான ஒப்பீட்டு செயலிகளைப் பயன்படுத்தி BigInt களை எண்களுடன் ஒப்பிடலாம்.

எடுத்துக்காட்டு

                // true

                let x = (10n > 5n);

                // false (வெவ்வேறு வகைகள்)

                let y = (10n === 10);

                // true (தளர்வான சமன்பாடு)

                let z = (10n == 10);

📝 குறிப்பு:

BigInt மற்றும் Number க்கு இடையேயான கண்டிப்பான சமன்பாடு (===) எப்போதும் false ஆக இருக்கும், ஏனெனில் அவை வெவ்வேறு வகைகள்.

BigInt ஹெக்ஸா, ஆக்டல் மற்றும் பைனரி

BigInt ஐ ஹெக்ஸாடெசிமல், ஆக்டல் அல்லது பைனரி குறியீட்டிலும் எழுதலாம்:

சாதாரணம்

256n

ஆக்டல்

0o400n

ஹெக்ஸாடெசிமல்

0x100n

பைனரி

0b100000000n

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

                let num = 256n;

                let oct = 0o400n; // ஆக்டல்

                let hex = 0x100n; // ஹெக்ஸாடெசிமல்

                let bin = 0b100000000n; // பைனரி

                let hex = 0x20000000000003n;

                let oct = 0o400000000000000003n;

                let bin = 0b100000000000000000000000000000000000000000000000000011n;

துல்லிய கவர்ச்சி

JavaScript இல் அதிகபட்ச பாதுகாப்பான முழு எண் 9007199254740991.

வட்டமிடல் நிரல் பாதுகாப்பை சீர்குலைக்கலாம்:

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

                    9007199254740992 === 9007199254740993; // true !!! (தவறு)

                    9007199254740992n === 9007199254740993n; // false !!! (சரி)

துல்லிய சிக்கல் டெமோ:

ஒப்பீடு முடிவுகள்:

உலாவி ஆதரவு

BigInt() ஒரு ES2020 அம்சமாகும்.

ES2020 செப்டம்பர் 2020 முதல் அனைத்து நவீன உலாவிகளிலும் முழுமையாக ஆதரிக்கப்படுகிறது:

Chrome 85

ஆகஸ்ட் 2020

Edge 85

ஆகஸ்ட் 2020

Firefox 79

மார்ச் 2020

Safari 14

செப்டம்பர் 2020

Opera 71

செப்டம்பர் 2020

சுருக்கம்

அம்சம்	விளக்கம்
தன்னிச்சையான-துல்லிய முழு எண்கள்	BigInt தன்னிச்சையான-துல்லிய முழு எண்களை அனுமதிக்கிறது
அளவு வரம்பு	BigInt எண்கள் உங்கள் நினைவகம் அனுமதிக்கும் அளவுக்கு பெரியதாக (அல்லது சிறியதாக) இருக்கலாம்
பயன்பாடுகள்	BigInt மிகப் பெரிய முழு எண்களுக்கு பயன்படுத்தப்படுகிறது (குறியாக்கவியல், IDs, நேர முத்திரைகள், போன்றவை)
தசமங்கள்	BigInt தசமங்களுக்கு ஏற்றதல்ல - முழு எண்கள் மட்டுமே
கணித செயல்பாடுகள்	கணித செயல்பாடுகள் (Math.sqrt() போன்றவை) BigInt களுடன் வேலை செய்யாது
JSON	JSON.stringify() BigInt களைக் கையாள முடியாது - பிழையை ஏற்படுத்தும்

JavaScript பயிற்சிகள்

இந்த டுடோரியலில் உள்ள பல அத்தியாயங்கள் உங்கள் அறிவு நிலையைச் சரிபார்க்கக்கூடிய பயிற்சியுடன் முடிகின்றன.

❓ BigInt எண்ணை உருவாக்க சட்டபூர்வமான JavaScript தொடரியல் எது?

1234567890123456789m

✗ தவறு! 'm' பின்னொட்டு JavaScript இல் BigInt க்கு பயன்படுத்தப்படுவதில்லை

1234567890123456789max

✗ தவறு! 'max' பின்னொட்டு JavaScript இல் BigInt க்கு பயன்படுத்தப்படுவதில்லை

1234567890123456789n

✓ சரி! 'n' பின்னொட்டு JavaScript இல் BigInt ஐ உருவாக்குவதற்கான சரியான தொடரியல்