Operator - "கருவி"

JavaScript-ல் Operator என்பது ஒரு வேலையைச் செய்யப் பயன்படும் "கருவி" (Tool) அல்லது "குறியீடு" (Symbol) ஆகும்.

1. What: Operator-ன்னா என்ன?

ரெண்டு டேட்டாவை (Data) வச்சு ஏதாச்சும் ஒரு வேலையைச் செய்யப் பயன்படும் குறியீடுகள்தான் Operators.

Example: ஒரு மனுஷன் கையில இருக்குற "கத்தி" (Knife) அல்லது "கரண்டி" (Spoon) மாதிரி. கத்தியை வச்சு காய்கறி வெட்டலாம், கரண்டியை வச்சு சாப்பிடலாம். அதே மாதிரி, Operator-ஐ வச்சு ரெண்டு எண்களைக் கூட்டலாம் அல்லது ஒப்பிடலாம்.

let sum = 10 + 5; -> இதில் + என்பதுதான் Operator. 10 மற்றும் 5 என்பது Operands (யாரு மேல வேலை நடக்குதோ அவங்க).

2. Why: இது எதுக்கு தேவை?

Example: உங்களுக்கு ரெண்டு ஆப்பிள் இருக்கு, உங்க ரண்டுக்கு மூணு இருக்கு. மொத்தம் எத்தனைன்னு தெரிய ஒரு "கூட்டல்" (+) தேவைப்படுதுல?

லாஜிக் போட: "இவன் உயரமா? அல்லது அவன் உயரமா?"னு செக் பண்ண ஒரு ஒப்பீடு (Comparison) தேவை. இந்த மாதிரி கணக்கு போடவும், கண்டிஷன் செக் பண்ணவும் Operators கண்டிப்பா வேணும்.

3. Where & How: முக்கியமான Operator வகைகள் (With Human Example)

1. Arithmetic Operators (கணக்கீடு செய்பவர்கள்)

ஒரு மனிதன் தன் வரவு-செலவு கணக்கைச் சரிபார்ப்பது போன்றது இது.

• 
  + (Addition): இருவரை இணைப்பது (உதாரணம்: அப்பா + அம்மா = குடும்பம்).


• 
  - (Subtraction): ஒருவரிடமிருந்து ஒன்றைப் பிரிப்பது.


• 
  ** (Exponentiation): இது நவீன ஜாவாஸ்கிரிப்ட்டில் அதிகம் பயன்படும் (Power of).

Example: let power = 2 ** 3; (2-ன் அடுக்கு 3 = 8).

• 
  %(Modulus): மீதி (Remainder) கண்டுபிடிப்பது. 10 சாக்லேட்டை 3
  பேருக்குப் பிரித்துக் கொடுத்தால் மீதி 1 இருக்கும்.

Example: 10 % 3 அவுட்புட் 1 என வரும்.

2. Assignment Operators (பொறுப்பு கொடுப்பவர்கள்)

ஒரு மனிதனுக்கு ஒரு வேலையையோ அல்லது ஒரு பொருளையோ ஒதுக்குவது.

• 
  = (Simple Assignment): let job = "Doctor"; (வேலை ‘டாக்டர்’ என்று உறுதி செய்தல்).


• 
  += (Add and Assign): உங்களிடம் 10 ரூபாய் இருக்கிறது, யாரோ 5 ரூபாய் தருகிறார்கள். இப்போது மொத்தம் 15.

Example: money += 5; (இதன் அர்த்தம் money = money + 5). இது கோடைச் சுருக்கப் பயன்படுகிறது.

3. Comparison Operators (ஒப்பீடு செய்பவர்கள்) **

மிக முக்கியம் இங்குதான் லாஜிக் (Logic) ஆரம்பிக்கிறது. இருவரை ஒப்பிடுவது.

**== vs === (The Deep Difference):

• 
  == (Abstract Equality): இது மதிப்பை மட்டும் பார்க்கும். (உதாரணம்: "5" மற்றும் 5 சமம் என்று சொல்லும்).


• 
  ===(Strict Equality): இது மதிப்பு மற்றும் டேட்டா வகை (Data Type) இரண்டையும் பார்க்கும். 2026-ல் இதைப் பயன்படுத்துவதுதான் புத்திசாலித்தனம்.

Example: 5 === "5" என்பது False என வரும், ஏன்னா ஒன்று எண், இன்னொன்று டெக்ஸ்ட்.

• 
  != vs !==: சமம் இல்லை என்பதை உறுதி செய்ய.

4. Logical Operators (முடிவு எடுப்பவர்கள்)

ஒரு மனிதன் மூளை மூலம் சிந்தித்து முடிவெடுப்பது போன்றது.

• 
  && (AND): "எனக்கு பசியும் எடுக்கணும், சாப்பாடும் இருக்கணும் - அப்போதான் சாப்பிடுவேன்". இரண்டுமே உண்மையாக (True) இருக்க வேண்டும்.


• 
  || (OR): "டீ அல்லது காபி - எது இருந்தாலும் குடிப்பேன்". ஏதேனும் ஒன்று உண்மையாக இருந்தால் போதும்.


• 
  ! (NOT): தலைகீழாக மாற்றுவது. உண்மையை பொய் என்றும், பொய்யை உண்மை என்றும் மாற்றும்.

Example: !true என்பது false என மாறும்.

5. Ternary Operator (குறுக்கு வழி - Short-cut)

இது if-else கண்டிஷனுக்கு மாற்றாகப் பயன்படுத்தப்படும் ஒரு ஸ்டைலான வழி.

Syntax: condition ? value_if_true : value_if_false

மனுஷன் எக்ஸாம்பிள்: கல்யாண வயசு வந்துடுச்சா?

let age = 22;

let status = (age >= 21) ? "Eligible" : "Not Eligible";

console.log(status); // Output: Eligible

6. Nullish Coalescing Operator (??) - Modern JS

இது 2026-ல் மிக முக்கியமான ஆப்பரேட்டர். ஒரு வேரியபிளில் மதிப்பு இல்லை என்றால் (null அல்லது undefined), ஒரு டீபால்ட் மதிப்பைக் கொடுக்க இது உதவும்.

Example: ஒரு மனுஷனுக்கு இன்னும் பெயர் வைக்கவில்லை என்றால், அவரை "Guest" என்று கூப்பிடு.

let username = null;

let displayName = username ?? "Guest"; 

console.log(displayName); // Output: Guest

4. Operator-ல் செய்யக்கூடாதவை (Logic Mistakes)

• 
  == பயன்படுத்துவதைத் தவிர்க்கவும்: இது டேட்டா வகையைச் சரிபார்க்காது (5 == "5" என்பது True என வரும்). எப்போதும் === (Strict Equality) பயன்படுத்துங்கள்.

Assignment மற்றும் Equality-ஐக் குழப்பிக் கொள்ளாதீர்கள்:

• 
  if (age = 18) -> இது தவறு (மதிப்பை மாற்றுகிறது).


• 
  if (age === 18) -> இதுதான் சரி (சரிபார்க்கிறது).

சரியான அடைப்புக்குறிகள் (Parentheses) இன்றி எழுதாதீர்கள்:

• 
  let result = 2 + 3 * 5; -> இது 17 வரும் (முதலில் பெருக்கல் நடக்கும்).


• உங்களுக்கு கூட்டல் முதலில் நடக்க வேண்டுமென்றால் (2 + 3) * 5 என்று எழுதுங்கள். ஆப்பரேட்டர் முன்னுரிமை (Precedence) தெரியாமல் கோடு எழுதாதீர்கள்.

சரம் (String) மற்றும் எண்களைக் கூட்டும்போது கவனம்:

• 
  console.log(5 + "5"); -> இது 55 என்று வரும் (கூட்டாது, இணைத்துவிடும்). எண்களைக் கூட்டும்போது அவை உண்மையில் எண்கள்தானா என்று உறுதி செய்து கொள்ளவும்.

5. பொதுவான தவறுகள்

• 
  Don't use var: var பயன்படுத்துவது மிகவும் பழைய முறை. எப்போதும் let அல்லது const பயன்படுத்துங்கள். இது Identifier-ல் ஏற்படும் குழப்பங்களைத் தவிர்க்கும்.


• 
  Don't ignore Null/Undefined: ஒரு வேரியபிளில் மதிப்பு இருக்கிறதா இல்லையா என்று தெரியாமல் ஆப்பரேட்டர்களைப் பயன்படுத்தாதீர்கள். ?? (Nullish Coalescing) பயன்படுத்தி டீபால்ட் மதிப்பைக் கொடுக்கப் பழகுங்கள்.


• 
  Don't write "Spaghetti Code": ஆப்பரேட்டர்களைப் பயன்படுத்தி ஒரே வரியில் மிக நீளமான லாஜிக் எழுதாதீர்கள். அதைப் பிரித்து எழுதுவது மற்றவர்கள் படிக்க எளிதாக இருக்கும்.