JavaScript Number Properties

ஜாவாஸ்கிரிப்ட்டில், Number பொருள் பல பயனுள்ள பண்புகளை வழங்குகிறது. இந்த பண்புகள் எண் மதிப்புகள், வரம்புகள் மற்றும் கணித மாறிலிகளை குறிப்பிடுகின்றன.

Number.EPSILON

1 ஐ விட அதிகமான மிகச் சிறிய மிதவைப் புள்ளி எண்ணுக்கும் 1 க்கும் இடையே உள்ள வித்தியாசம்

Number.MAX_VALUE

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

Number.MIN_VALUE

ஜாவாஸ்கிரிப்ட்டில் சாத்தியமான மிகச்சிறிய நேர்மறை எண்ணைக் குறிக்கும் மாறிலி

Number.MAX_SAFE_INTEGER

ஜாவாஸ்கிரிப்ட்டில் அதிகபட்ச பாதுகாப்பான முழு எண்ணைக் குறிக்கிறது

Number.MIN_SAFE_INTEGER

ஜாவாஸ்கிரிப்ட்டில் குறைந்தபட்ச பாதுகாப்பான முழு எண்ணைக் குறிக்கிறது

Number.POSITIVE_INFINITY

நேர்மறை முடிவிலியைக் குறிக்கிறது

Number.NEGATIVE_INFINITY

எதிர்மறை முடிவிலியைக் குறிக்கிறது

Number.NaN

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

📚 மேலும் பார்க்க:

எண்கள் டுடோரியல் - எண்கள் பற்றிய அடிப்படை கருத்துகள்

எண் முறைகள் - எண்களுடன் வேலை செய்வதற்கான முறைகள்

எண் குறிப்பு - முழுமையான எண் முறைகள் மற்றும் பண்புகள்

JavaScript EPSILON

Number.EPSILON என்பது 1 ஐ விட அதிகமான மிகச் சிறிய மிதவைப் புள்ளி எண்ணுக்கும் 1 க்கும் இடையே உள்ள வித்தியாசம்.

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

let x = Number.EPSILON;
console.log(x);  // 2.220446049250313e-16

🔬 நடைமுறை பயன்பாடு:

Number.EPSILON மிதவைப் புள்ளி கணிதத்தில் உள்ள பிழைகளைக் கையாள்வதற்கு பயனுள்ளதாக இருக்கும்:

// மிதவைப் புள்ளி எண்களை ஒப்பிடுதல்
function numbersEqual(a, b) {
    return Math.abs(a - b) < Number.EPSILON;
}

console.log(numbersEqual(0.1 + 0.2, 0.3));  // true
console.log(0.1 + 0.2 === 0.3);             // false

⚠️ குறிப்பு:

Number.EPSILON என்பது ஒரு ES6 அம்சம். இது Internet Explorer இல் வேலை செய்யாது.

JavaScript MAX_VALUE

Number.MAX_VALUE என்பது ஜாவாஸ்கிரிப்ட்டில் சாத்தியமான மிகப்பெரிய எண்ணைக் குறிக்கும் மாறிலியாகும்.

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

let x = Number.MAX_VALUE;
console.log(x);  // 1.7976931348623157e+308

ℹ️ Number Properties Cannot be Used on Variables:

Number பண்புகள் ஜாவாஸ்கிரிப்ட் Number பொருளுக்கு சொந்தமானது. இந்த பண்புகளை Number.MAX_VALUE போன்று மட்டுமே அணுகலாம்.

X ஒரு மாறி அல்லது மதிப்பாக இருக்கும் இடத்தில் X.MAX_VALUE பயன்படுத்துவது undefined ஐத் திருப்பி அனுப்பும்:

let x = 6;
console.log(x.MAX_VALUE);  // undefined

💡 MAX_VALUE ஐ மீறுதல்:

Number.MAX_VALUE ஐ விட பெரிய எண்களை உருவாக்க முயற்சித்தால், முடிவு Infinity ஆக இருக்கும்:

let max = Number.MAX_VALUE;
let overflow = max * 2;
console.log(overflow);  // Infinity

JavaScript MIN_VALUE

Number.MIN_VALUE என்பது ஜாவாஸ்கிரிப்ட்டில் சாத்தியமான மிகச்சிறிய நேர்மறை எண்ணைக் குறிக்கும் மாறிலியாகும்.

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

let x = Number.MIN_VALUE;
console.log(x);  // 5e-324

📝 குறிப்பு:

Number.MIN_VALUE மிகச்சிறிய நேர்மறை எண்ணாகும், மிகச்சிறது எண் அல்ல. மிகச்சிறது எண் Number.NEGATIVE_INFINITY ஆகும்.

console.log(Number.MIN_VALUE > 0);  // true
console.log(Number.MIN_VALUE < Number.MAX_VALUE);  // true

குறைந்தபட்ச மற்றும் அதிகபட்ச பாதுகாப்பான முழு எண்கள்

ES6 Number பொருளில் அதிகபட்ச மற்றும் குறைந்தபட்ச பண்புகளை சேர்த்தது:

Number.MAX_SAFE_INTEGER
Number.MIN_SAFE_INTEGER

JavaScript MIN_SAFE_INTEGER

Number.MIN_SAFE_INTEGER ஜாவாஸ்கிரிப்ட்டில் குறைந்தபட்ச பாதுகாப்பான முழு எண்ணைக் குறிக்கிறது.

Number.MIN_SAFE_INTEGER என்பது -(2⁵³ - 1).

let x = Number.MIN_SAFE_INTEGER;
console.log(x);  // -9007199254740991

JavaScript MAX_SAFE_INTEGER

Number.MAX_SAFE_INTEGER ஜாவாஸ்கிரிப்ட்டில் அதிகபட்ச பாதுகாப்பான முழு எண்ணைக் குறிக்கிறது.

Number.MAX_SAFE_INTEGER என்பது (2⁵³ - 1).

let x = Number.MAX_SAFE_INTEGER;
console.log(x);  // 9007199254740991

🔒 பாதுகாப்பான முழு எண்கள்:

பாதுகாப்பான முழு எண்கள் அனைத்தும் -(2⁵³ - 1) முதல் +(2⁵³ - 1) வரையிலான முழு எண்கள் ஆகும்.

இது பாதுகாப்பானது: 9007199254740991
இது பாதுகாப்பானது அல்ல: 9007199254740992

பாதுகாப்பான முழு எண்கள் 64-பிட் மிதவைப் புள்ளி வடிவத்தில் இழப்பின்றி குறிப்பிடக்கூடியவை.

பாதுகாப்பான முழு எண்கள் சோதனை:

// பாதுகாப்பான முழு எண்களை சோதிக்க Number.isSafeInteger() பயன்படுத்தவும்
console.log(Number.isSafeInteger(9007199254740991));  // true
console.log(Number.isSafeInteger(9007199254740992));  // false

console.log(Number.isSafeInteger(Number.MAX_SAFE_INTEGER));     // true
console.log(Number.isSafeInteger(Number.MAX_SAFE_INTEGER + 1)); // false

JavaScript POSITIVE_INFINITY

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

let x = Number.POSITIVE_INFINITY;
console.log(x);  // Infinity
console.log(typeof x);  // "number"

POSITIVE_INFINITY என்பது நிலைத்தன்மையை மீறும் போது திருப்பி அனுப்பப்படும்:

let x = 1 / 0;
console.log(x);  // Infinity
console.log(x === Number.POSITIVE_INFINITY);  // true

∞ Infinity பண்புகள்:

Infinity என்பது Number.POSITIVE_INFINITY க்கு சமம்
-Infinity என்பது Number.NEGATIVE_INFINITY க்கு சமம்
Infinity எப்போதும் எந்த வரையறுக்கப்பட்ட எண்ணையும் விட பெரியது
Infinity * 0 என்பது NaN
Infinity / Infinity என்பது NaN

JavaScript NEGATIVE_INFINITY

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

let x = Number.NEGATIVE_INFINITY;
console.log(x);  // -Infinity
console.log(typeof x);  // "number"

NEGATIVE_INFINITY என்பது நிலைத்தன்மையை மீறும் போது திருப்பி அனுப்பப்படும்:

let x = -1 / 0;
console.log(x);  // -Infinity
console.log(x === Number.NEGATIVE_INFINITY);  // true

-∞ எதிர்மறை முடிவிலி செயல்பாடுகள்:

console.log(Number.NEGATIVE_INFINITY * 2);      // -Infinity
console.log(Number.NEGATIVE_INFINITY * -1);     // Infinity
console.log(Number.NEGATIVE_INFINITY / 2);      // -Infinity
console.log(Number.NEGATIVE_INFINITY + 100);    // -Infinity
console.log(Number.NEGATIVE_INFINITY - 100);    // -Infinity

JavaScript NaN - Not a Number

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

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

let x = Number.NaN;
console.log(x);  // NaN
console.log(typeof x);  // "number"

// எண்ணல்லாத சரத்துடன் கணிதம் செய்ய முயற்சித்தால் NaN (Not a Number) விளையும்:
let y = 100 / "Apple";
console.log(y);  // NaN

console.log(y === Number.NaN);  // false (!)
console.log(Number.isNaN(y));   // true

⚠️ NaN ஒப்பீடு எச்சரிக்கை:

NaN உடன் நேரடியாக ஒப்பிட முடியாது. NaN === NaN எப்போதும் false ஐத் திருப்பி அனுப்பும்.

NaN ஐ சோதிக்க சரியான வழி Number.isNaN() அல்லது isNaN() பயன்படுத்துவதாகும்:

console.log(NaN === NaN);          // false
console.log(Number.NaN === NaN);  // false
console.log(isNaN(NaN));          // true
console.log(Number.isNaN(NaN));   // true

🔢 பாதுகாப்பான முழு எண்கள் மறுபார்வை:

பாதுகாப்பான முழு எண்கள் அனைத்தும் -(2⁵³ - 1) முதல் +(2⁵³ - 1) வரையிலான முழு எண்கள் ஆகும்.

இது பாதுகாப்பானது: 9007199254740991. இது பாதுகாப்பானது அல்ல: 9007199254740992.

எண் பண்புகள் சுருக்கம்

பண்பு	மதிப்பு	விளக்கம்
`Number.EPSILON`	2.220446049250313e-16	1 ஐ விட அதிகமான மிகச் சிறிய மிதவைப் புள்ளி எண்ணுக்கும் 1 க்கும் இடையே உள்ள வித்தியாசம்
`Number.MAX_VALUE`	1.7976931348623157e+308	ஜாவாஸ்கிரிப்ட்டில் சாத்தியமான மிகப்பெரிய எண்
`Number.MIN_VALUE`	5e-324	ஜாவாஸ்கிரிப்ட்டில் சாத்தியமான மிகச்சிறிய நேர்மறை எண்
`Number.MAX_SAFE_INTEGER`	9007199254740991	அதிகபட்ச பாதுகாப்பான முழு எண் (2⁵³ - 1)
`Number.MIN_SAFE_INTEGER`	-9007199254740991	குறைந்தபட்ச பாதுகாப்பான முழு எண் -(2⁵³ - 1)
`Number.POSITIVE_INFINITY`	Infinity	நேர்மறை முடிவிலி
`Number.NEGATIVE_INFINITY`	-Infinity	எதிர்மறை முடிவிலி
`Number.NaN`	NaN	சட்டப்பூர்வமான எண் அல்லாத எண்

💡 நினைவில் கொள்ள வேண்டியவை:

Number பண்புகள் Number பொருளில் மட்டுமே அணுகலாம் (Number.MAX_VALUE)
மாறிகள் அல்லது மதிப்புகளில் இவற்றை அணுக முடியாது (x.MAX_VALUE பிழையைத் தரும்)
இவை அனைத்தும் ES6 இல் அறிமுகப்படுத்தப்பட்டது (Internet Explorer ஆதரவு இல்லை)
பாதுகாப்பான முழு எண் செயல்பாடுகளுக்கு Number.isSafeInteger() பயன்படுத்தவும்

எண் பண்புகள் பயிற்சி

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

❓ ஜாவாஸ்கிரிப்டில் சாத்தியமான மிகப்பெரிய எண்ணைத் திருப்பி அனுப்பும் பண்பின் பெயர் என்ன?

POSSIBLE_MAX

✗ தவறு! JavaScript இல் POSSIBLE_MAX என்ற பண்பு இல்லை.

MAX_POSSIBLE

✗ தவறு! JavaScript இல் MAX_POSSIBLE என்ற பண்பு இல்லை.

MAX_VALUE

✓ சரி! Number.MAX_VALUE என்பது ஜாவாஸ்கிரிப்ட்டில் சாத்தியமான மிகப்பெரிய எண்ணைக் குறிக்கும் மாறிலியாகும்.

MAX_POSITIVE

✗ தவறு! JavaScript இல் MAX_POSITIVE என்ற பண்பு இல்லை. நேர்மறை முடிவிலிக்கு Number.POSITIVE_INFINITY பயன்படுத்தப்படுகிறது.

💡 தீர்வு விளக்கம்:

Number.MAX_VALUE என்பது ஜாவாஸ்கிரிப்ட் Number பொருளின் ஒரு பண்பாகும், இது ஜாவாஸ்கிரிப்ட்டில் சாத்தியமான மிகப்பெரிய எண்ணைக் குறிக்கிறது. இதன் மதிப்பு தோராயமாக 1.7976931348623157 × 10³⁰⁸ ஆகும்.

console.log(Number.MAX_VALUE);  // 1.7976931348623157e+308
console.log(typeof Number.MAX_VALUE);  // "number"

// MAX_VALUE ஐ மீறும் முயற்சி Infinity ஐ விளைவிக்கும்
let max = Number.MAX_VALUE;
console.log(max * 2);  // Infinity

ஜாவாஸ்கிரிப்டில் பிற எண் பண்புகள்:

Number.MIN_VALUE: மிகச்சிறிய நேர்மறை எண்
Number.MAX_SAFE_INTEGER: அதிகபட்ச பாதுகாப்பான முழு எண்
Number.MIN_SAFE_INTEGER: குறைந்தபட்ச பாதுகாப்பான முழு எண்

முழுமையான ஜாவாஸ்கிரிப்ட் குறிப்பு

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

📖 Jassif Team இன் முழுமையான ஜாவாஸ்கிரிப்ட் குறிப்பு

இந்த குறிப்பில் 1999 முதல் 2025 வரையிலான அனைத்து ஜாவாஸ்கிரிப்ட் புதுப்பிப்புகளும் அடங்கும்.

உங்கள் ஜாவாஸ்கிரிப்ட் திறன்களை விரிவுபடுத்த, எங்கள் முழுமையான ஆன்லைன் டுடோரியல்கள் மற்றும் குறிப்பு வளங்களைப் பார்க்கவும்.

ஜாவாஸ்கிரிப்ட் பாடநெறிகள்

நிபுணர் வழிகாட்டுதலுடன் கூடிய கட்டமைக்கப்பட்ட கற்றல் பாதைகள்

நிகழ்நேர குறியீடு எடிட்டர்

உங்கள் ஜாவாஸ்கிரிப்ட் குறியீட்டை உடனடியாகச் சோதிக்கவும் மற்றும் இயக்கவும்

சான்றிதழ்கள்

உங்கள் ஜாவாஸ்கிரிப்ட் திறமைகளை சான்றளிக்க சான்றிதழ் தேர்வுகளை எடுக்கவும்