Jassif Team Institution

எண் வகைகள்

ஜாவாஸ்கிரிப்ட்டில் ஒரே ஒரு வகையான எண் மட்டுமே உள்ளது. எண்களை தசமங்களுடன் அல்லது இல்லாமல் எழுதலாம்.

let x = 3.14;    // தசமங்களுடன் கூடிய எண்
let y = 3;       // தசமங்கள் இல்லாத எண்

மிகப்பெரிய அல்லது மிகச்சிறிய எண்களை அறிவியல் (அடுக்கு) குறியீட்டில் எழுதலாம்:

let x = 123e5;    // 12300000
let y = 123e-5;   // 0.00123

ஜாவாஸ்கிரிப்ட் எண்கள் எப்போதும் 64-பிட் மிதவைப் புள்ளி

பல பிற நிரலாக்க மொழிகளைப் போலன்றி, ஜாவாஸ்கிரிப்ட் முழு எண்கள், குறுகிய, நீண்ட, மிதவைப் புள்ளி போன்ற வெவ்வேறு வகையான எண்களை வரையறுக்காது.

ஜாவாஸ்கிரிப்ட் எண்கள் எப்போதும் இரட்டைத் துல்லிய மிதவைப் புள்ளி எண்களாக சேமிக்கப்படுகின்றன, சர்வதேச IEEE 754 தரத்தைப் பின்பற்றுகின்றன.

இந்த வடிவமைப்பு எண்களை 64 பிட்களில் சேமிக்கிறது, அங்கு எண் (பின்னம்) 0 முதல் 51 வரையிலான பிட்களில் சேமிக்கப்படுகிறது, அடுக்கு 52 முதல் 62 வரையிலான பிட்களில் மற்றும் அடையாளம் 63 வது பிட்டில்:

முழு எண் துல்லியம்

முழு எண்கள் (காலம் அல்லது அடுக்கு குறியீடு இல்லாத எண்கள்) 15 இலக்கங்கள் வரை துல்லியமானவை.

let x = 999999999999999;   // x ஆனது 999999999999999 ஆக இருக்கும்
let y = 9999999999999999;  // y ஆனது 10000000000000000 ஆக இருக்கும்

தசமங்களின் அதிகபட்ச எண்ணிக்கை 17 ஆகும்.

மிதவைப் புள்ளி துல்லியம்

மிதவைப் புள்ளி கணிதம் எப்போதும் 100% துல்லியமாக இருக்காது:

let x = 0.2 + 0.1;  // 0.30000000000000004

மேலே உள்ள சிக்கலைத் தீர்க்க, பெருக்கி வகுப்பது உதவியாக இருக்கும்:

let x = (0.2 * 10 + 0.1 * 10) / 10;  // 0.3

எண்கள் மற்றும் சரங்களைச் சேர்த்தல்

நீங்கள் இரண்டு எண்களைச் சேர்த்தால், முடிவு ஒரு எண்ணாக இருக்கும்:

let x = 10;
let y = 20;
let z = x + y;  // z = 30 (எண்)

நீங்கள் இரண்டு சரங்களைச் சேர்த்தால், முடிவு சர இணைப்பாக இருக்கும்:

let x = "10";
let y = "20";
let z = x + y;  // z = "1020" (சரம்)

நீங்கள் ஒரு எண்ணையும் சரத்தையும் சேர்த்தால், முடிவு சர இணைப்பாக இருக்கும்:

let x = 10;
let y = "20";
let z = x + y;  // z = "1020" (சரம்)

let x = 10;
let y = 20;
let z = "The result is: " + x + y;  // "The result is: 1020"

let x = 10;
let y = 20;
let z = "30";
let result = x + y + z;  // "3030" (முதலில் 10+20=30, பிறகு 30+"30"="3030")

எண் சரங்கள்

ஜாவாஸ்கிரிப்ட் சரங்களுக்கு எண் உள்ளடக்கம் இருக்கலாம்:

let x = 100;         // x ஒரு எண்
let y = "100";       // y ஒரு சரம்

அனைத்து எண் செயல்பாடுகளிலும் ஜாவாஸ்கிரிப்ட் சரங்களை எண்களாக மாற்ற முயற்சிக்கும்:

let x = "100";
let y = "10";
let z = x / y;  // 10

let x = "100";
let y = "10";
let z = x * y;  // 1000

let x = "100";
let y = "10";
let z = x - y;  // 90

let x = "100";
let y = "10";
let z = x + y;  // "10010"

NaN - ஒரு எண் அல்ல

NaN என்பது ஒரு எண் சட்டபூர்வமான எண் அல்ல என்பதைக் குறிக்கும் ஜாவாஸ்கிரிப்ட் ஒதுக்கப்பட்ட சொல்.

let x = 100 / "Apple";  // NaN

சரம் எண்ணாக இருந்தால், முடிவு ஒரு எண்ணாக இருக்கும்:

let x = 100 / "10";  // 10

ஒரு மதிப்பு எண்ணாக இல்லையா என்பதைக் கண்டறிய உலகளாவிய ஜாவாஸ்கிரிப்ட் செயல்பாடு isNaN() ஐப் பயன்படுத்தலாம்:

let x = 100 / "Apple";
isNaN(x);  // true

let x = NaN;
let y = 5;
let z = x + y;  // NaN

let x = NaN;
let y = "5";
let z = x + y;  // "NaN5"

NaN ஒரு எண்: typeof NaN எண்ணைத் திருப்பி அனுப்புகிறது:

typeof NaN;  // "number"

முடிவிலி

முடிவிலி (அல்லது -முடிவிலி) என்பது மிகப்பெரிய சாத்தியமான எண்ணுக்கு வெளியே ஒரு எண்ணைக் கணக்கிட்டால் ஜாவாஸ்கிரிப்ட் திருப்பி அனுப்பும் மதிப்பாகும்.

let myNumber = 2;
// முடிவிலி வரை இயக்கவும்
while (myNumber != Infinity) {
  myNumber = myNumber * myNumber;
}

0 (பூஜ்ஜியத்தால்) வகுத்தலும் முடிவிலியை உருவாக்குகிறது:

let x =  2 / 0;   // Infinity
let y = -2 / 0;   // -Infinity

முடிவிலி ஒரு எண்: typeof Infinity எண்ணைத் திருப்பி அனுப்புகிறது.

typeof Infinity;  // "number"

பதினறும எண்

ஜாவாஸ்கிரிப்ட் எண் மாறிலிகளை 0x முன்னொட்டுடன் இருந்தால் பதினறும எண்ணாக விளக்கம் செய்கிறது.

let x = 0xFF;  // 255

இயல்பாக, ஜாவாஸ்கிரிப்ட் எண்களை அடிப்படை 10 தசமங்களாகக் காட்டுகிறது. ஆனால் நீங்கள் அடிப்படை 2 முதல் அடிப்படை 36 வரையிலான எண்களை வெளியிட toString() முறையைப் பயன்படுத்தலாம்.

let myNumber = 32;
myNumber.toString(32);  // "10"
myNumber.toString(16);  // "20"
myNumber.toString(12);  // "28"
myNumber.toString(10);  // "32"
myNumber.toString(8);   // "40"
myNumber.toString(2);   // "100000"

ஜாவாஸ்கிரிப்ட் எண்கள் பொருள்களாக

பொதுவாக ஜாவாஸ்கிரிப்ட் எண்கள் நிலையான மதிப்புகளிலிருந்து உருவாக்கப்பட்ட பழமையான மதிப்புகள்:

let x = 123;

ஆனால் எண்களும் new முக்கிய சொல்லுடன் பொருள்களாக வரையறுக்கப்படலாம்:

let y = new Number(123);

Number பொருள்கள் எதிர்பாராத முடிவுகளை உருவாக்கலாம்:

== ஆபரேட்டரைப் பயன்படுத்தும் போது, x மற்றும் y சமமாக இருக்கும்:

let x = 500;
let y = new Number(500);
console.log(x == y);  // true

=== ஆபரேட்டரைப் பயன்படுத்தும் போது, x மற்றும் y சமமாக இருக்காது:

let x = 500;
let y = new Number(500);
console.log(x === y);  // false

let x = new Number(500);
let y = new Number(500);
console.log(x == y);   // false
console.log(x === y);  // false

ஜாவாஸ்கிரிப்ட் எண்கள் பயிற்சி

கீழே உள்ள குறியீட்டைக் கவனியுங்கள்:

let x = 10;
let y = 20;
let z = x + y;

மேலும் அறிக