JavaScript Comparison

Comparison Operators

ஒப்பீட்டு ஆபரேட்டர்கள் இரண்டு மதிப்புகளை ஒப்பிட பயன்படுகின்றன.

ஒப்பீட்டு ஆபரேட்டர்கள் எப்போதும் true அல்லது false தருகின்றன.

x = 5 என்று கொடுக்கப்பட்டால், கீழே உள்ள அட்டவணை ஒப்பீட்டு ஆபரேட்டர்களை விளக்குகிறது:

Comparison Operators

Operator	Description	Comparing	Returns
`==`	equal to	`x == 8`	`false`
		`x == 5`	`true`
		`x == "5"`	`true`
`===`	equal value and equal type	`x === 5`	`true`
		`x === "5"`	`false`
`!=`	not equal	`x != 8`	`true`
`!==`	not equal value or not equal type	`x !== 5`	`false`
		`x !== "5"`	`true`
		`x !== 8`	`true`
`>`	greater than	`x > 8`	`false`
`<`	less than	`x < 8`	`true`
`>=`	greater than or equal to	`x >= 8`	`false`
`<=`	less than or equal to	`x <= 8`	`true`

💡 == vs === வித்தியாசம்:

== (loose equality) - மதிப்பை மட்டும் சரிபார்க்கிறது, வகையை மாற்ற முயற்சிக்கிறது

=== (strict equality) - மதிப்பு மற்றும் வகை இரண்டையும் சரிபார்க்கிறது

Usage in Conditional Statements

மதிப்புகளை ஒப்பிட்டு முடிவின் அடிப்படையில் செயல்களை எடுக்க நிபந்தனை அறிக்கைகளில் ஒப்பீட்டு ஆபரேட்டர்களைப் பயன்படுத்தலாம்:

Example: Comparison in if statement

if (age < 18) {
  text = "Too young to buy alcohol";
}

📚 கற்றல்:

நிபந்தனை அறிக்கைகளின் பயன்பாட்டைப் பற்றி இந்த டுடோரியலின் if...else அத்தியாயத்தில் மேலும் அறிவீர்கள்.

JavaScript String Comparison

மேலே உள்ள அனைத்து ஒப்பீட்டு ஆபரேட்டர்களும் சரங்களிலும் பயன்படுத்தப்படலாம்:

Example: String Comparison

let text1 = "A";
let text2 = "B";
let result = text1 < text2;  // true

சரங்கள் அகரவரிசையில் ஒப்பிடப்படுகின்றன என்பதைக் கவனிக்கவும்:

Example: Alphabetical Comparison

let text1 = "20";
let text2 = "5";
let result = text1 < text2;  // true

🔤 அகரவரிசை ஒப்பீடு:

சரங்கள் ஒப்பிடப்படும்போது, JavaScript ஒவ்வொரு எழுத்தின் Unicode மதிப்பையும் ஒப்பிடுகிறது. "20" < "5" என்பது உண்மை, ஏனெனில் "2" (Unicode 50) "5" (Unicode 53) ஐ விட குறைவாக உள்ளது.

Comparing Different Types

வெவ்வேறு வகையான தரவுகளை ஒப்பிடுவது எதிர்பாராத முடிவுகளைத் தரலாம்.

ஒரு சரத்தை ஒரு எண்ணுடன் ஒப்பிடும்போது, JavaScript ஒப்பீடு செய்யும் போது சரத்தை எண்ணாக மாற்றும். ஒரு காலி சரம் 0 ஆக மாற்றப்படும். எண்ணல்லாத சரம் NaN ஆக மாற்றப்படும், இது எப்போதும் false ஆகும்.

Case	Value	Result	Explanation
`2 < 12`	`true`	`true`	இரண்டும் எண்கள், 2 < 12 உண்மை
`2 < "12"`	`true`	`true`	"12" எண்ணாக மாற்றப்பட்டு 12 ஆகிறது, 2 < 12 உண்மை
`2 < "John"`	`false`	`false`	"John" NaN ஆக மாற்றப்படுகிறது, எந்த எண்ணும் NaN ஐ விட குறைவாக இல்லை
`2 > "John"`	`false`	`false`	"John" NaN ஆக மாற்றப்படுகிறது, எந்த எண்ணும் NaN ஐ விட அதிகமாக இல்லை
`2 == "John"`	`false`	`false`	"John" NaN ஆக மாற்றப்படுகிறது, 2 == NaN பொய்
`"2" < "12"`	`false`	`false`	சர ஒப்பீடு: "2" (Unicode 50) "1" (Unicode 49) ஐ விட அதிகம்
`"2" > "12"`	`true`	`true`	சர ஒப்பீடு: "2" > "1" உண்மை
`"2" == "12"`	`false`	`false`	சரங்கள் வெவ்வேறானவை

⚠️ முக்கியமான குறிப்பு:

இரண்டு சரங்களை ஒப்பிடும்போது, "2" என்பது "12" ஐ விட அதிகமாக இருக்கும்.

அகரவரிசையில் 1 என்பது 2 ஐ விட குறைவு (Unicode மதிப்புகள்: "1" = 49, "2" = 50).

Type Conversion for Proper Comparison

சரியான முடிவைப் பெற, ஒப்பீட்டுக்கு முன் மாறிகள் சரியான வகையாக மாற்றப்பட வேண்டும்:

Example: Proper Type Conversion

age = Number(age);
if (isNaN(age)) {
  voteable = "Input is not a number";
} else {
  voteable = (age < 18) ? "Too young" : "Old enough";
}

🏆 சிறந்த நடைமுறை:

எப்போதும் கலப்பு வகை ஒப்பீடுகளைத் தவிர்க்கவும். ஒப்பீட்டுக்கு முன் வெளிப்படையாக வகைகளை மாற்றவும்.

கடுமையான சமத்துவத்திற்கு (=== மற்றும் !==) சாதகமான முன்னுரிமை அளிக்கவும்.

== vs === Deep Comparison

Comparison	`==` Result	`===` Result	Explanation
`5 == 5`	`true`	`true`	ஒரே மதிப்பு மற்றும் வகை
`5 == "5"`	`true`	`false`	`==` வகையை மாற்றுகிறது, `===` வகையை சரிபார்க்கிறது
`0 == false`	`true`	`false`	`==` false ஐ 0 ஆக மாற்றுகிறது
`1 == true`	`true`	`false`	`==` true ஐ 1 ஆக மாற்றுகிறது
`"" == false`	`true`	`false`	`==` இரண்டையும் 0 ஆக மாற்றுகிறது
`null == undefined`	`true`	`false`	`==` சிறப்பு விதி, `===` வெவ்வேறு வகைகள்
`null == 0`	`false`	`false`	`null` 0 க்கு சமமாக இல்லை

Comparison with NaN

NaN (Not a Number) என்பது ஒரு சிறப்பு மதிப்பு, இது எந்த ஒப்பீட்டிலும் வித்தியாசமாக செயல்படுகிறது:

Example: NaN Comparisons

NaN == NaN;      // false
NaN === NaN;     // false
NaN != NaN;      // true
NaN !== NaN;     // true
NaN < 5;         // false
NaN > 5;         // false
NaN == 5;        // false

🚫 NaN ஒப்பீடு விதிகள்:

NaN எந்த மதிப்புக்கும் சமமாக இல்லை, NaN உட்பட! NaN உடன் ஒப்பிட isNaN() செயல்பாட்டைப் பயன்படுத்தவும்:

let x = NaN;
isNaN(x);        // true
Number.isNaN(x); // true

Exercise

❓ பின்வரும் ஒப்பீட்டின் முடிவு என்ன?

5 === "5"

true

✗ தவறு! === ஆபரேட்டர் கடுமையான சமத்துவத்தைச் சரிபார்க்கிறது. இடது பக்கம் எண் (5), வலது பக்கம் சரம் ("5") - வகைகள் வித்தியாசமாக உள்ளன

false

✓ சரி! === ஆபரேட்டர் மதிப்பு மற்றும் வகை இரண்டையும் சரிபார்க்கிறது. 5 (எண்) மற்றும் "5" (சரம்) வெவ்வேறு வகைகள், எனவே முடிவு false

TypeError

✗ தவறு! ஒப்பீட்டு ஆபரேட்டர்கள் TypeError ஐ வீசாது. அவை எப்போதும் true அல்லது false தரும். வெவ்வேறு வகைகளை ஒப்பிடலாம், ஆனால் === வகை வேறுபாட்டிற்காக false தரும்

undefined

✗ தவறு! ஒப்பீட்டு ஆபரேட்டர்கள் எப்போதும் boolean மதிப்பை (true/false) தரும். அவை undefined தராது