மேம்பட்ட ஆபரேட்டர்கள்

ஆபரேட்டர்கள் அடைப்புக்குறிகள் இல்லாமல் ஒன்றாக வரும்போது, அவை பயன்படுத்தப்படும் வரிசை ஆபரேட்டர்களின் முன்னுரிமை மூலம் தீர்மானிக்கப்படுகிறது. பெருக்கல் (*) மற்றும் வகுத்தல் (/) கூட்டல் (+) மற்றும் கழித்தல் (-) ஐ விட அதிக முன்னுரிமை கொண்டவை.

// பெருக்கல் முதலில் செய்யப்படுகிறது, பின்னர் கூட்டல் வருகிறது
let x = 100 + 50 * 3; // 250
// அடைப்புக்குறிகளுடன் அடைப்புக்குறிகளுக்குள் உள்ள செயல்பாடுகள் முதலில் கணக்கிடப்படுகின்றன
let y = (100 + 50) * 3; // 450
// ஒரே முன்னுரிமை கொண்ட செயல்பாடுகள் இடமிருந்து வலமாக கணக்கிடப்படுகின்றன
let z = 100 / 50 * 3;

நிரல் எழுதும்போது பல மேம்பட்ட கணித ஆபரேட்டர்களைப் பயன்படுத்தலாம். சில முக்கிய மேம்பட்ட கணித ஆபரேட்டர்களின் பட்டியல்:

• Modulo ஆபரேட்டர் (%): Modulo ஆபரேட்டர் ஒரு வகுத்தல் செயல்பாட்டின் மீதியை திரும்பப் பெறுகிறது. எடுத்துக்காட்டாக:

console.log(10 % 3); // 1
console.log(11 % 3); // 2
console.log(12 % 3); // 0

• Exponentiation ஆபரேட்டர் (* *): Exponentiation ஆபரேட்டர் ஒரு எண்ணை மற்றொரு எண்ணின் சக்தியாக உயர்த்துகிறது. இது ஒரு புதிய ஆபரேட்டர் மற்றும் அனைத்து உலாவிகளிலும் ஆதரிக்கப்படவில்லை, எனவே Math.pow செயல்பாட்டை பதிலாக பயன்படுத்த வேண்டியிருக்கலாம். எடுத்துக்காட்டாக:

console.log(2 ** 3); // 8
console.log(3 ** 2); // 9
console.log(4 ** 3); // 64

• Increment ஆபரேட்டர் (++): Increment ஆபரேட்டர் ஒரு எண்ணை ஒன்றால் அதிகரிக்கிறது. இதை prefix (operand க்கு முன்பு) அல்லது postfix (operand க்கு பிறகு) ஆக பயன்படுத்தலாம். எடுத்துக்காட்டாக:

let x = 1;
x++; // x இப்போது 2
++x; // x இப்போது 3

• Decrement ஆபரேட்டர் (--): Decrement ஆபரேட்டர் ஒரு எண்ணை ஒன்றால் குறைக்கிறது. இதை prefix (operand க்கு முன்பு) அல்லது postfix (operand க்கு பிறகு) ஆக பயன்படுத்தலாம். எடுத்துக்காட்டாக:

let y = 3;
y--; // y இப்போது 2
--y; // y இப்போது 1

• Math பொருள்: Math பொருள் JavaScript இல் கணித செயல்பாடுகள் மற்றும் மாறிலிகளை வழங்கும் ஒரு உள்ளமைக்கப்பட்ட பொருளாகும். ஒரு எண்ணின் வர்க்கமூலத்தை கண்டுபிடிக்க, ஒரு எண்ணின் sine ஐ கணக்கிட, அல்லது சீரற்ற எண்ணை உருவாக்க போன்ற மேம்பட்ட கணித செயல்பாடுகளை செய்ய Math பொருளின் முறைகளைப் பயன்படுத்தலாம். எடுத்துக்காட்டாக:

console.log(Math.sqrt(9)); // 3
console.log(Math.sin(0)); // 0
console.log(Math.random()); // 0 மற்றும் 1 க்கு இடையே சீரற்ற எண்

இவை JavaScript இல் கிடைக்கும் மேம்பட்ட கணித ஆபரேட்டர்கள் மற்றும் செயல்பாடுகளின் சில எடுத்துக்காட்டுகள் மட்டுமே. நிரல் எழுதும்போது மேம்பட்ட கணித செயல்பாடுகளை செய்ய பயன்படுத்தக்கூடிய இன்னும் பல உள்ளன.

let num1 = 10;
let num2 = 5;

// num1 இன் மதிப்பை அதிகரிக்க ++ ஆபரேட்டர்.

num1++;
const result1 = num1; // 11
// num2 இன் மதிப்பை குறைக்க -- ஆபரேட்டர்.
num2--;
const result2 = num2; // 4
// num1 உடன் num2 ஐ கூட்ட += ஆபரேட்டர்.
num1 += num2;
const result3 = num1 // 15
// num1 இலிருந்து num2 ஐ கழிக்க -= ஆபரேட்டர்.
num1 -= num2;
const result4 = num1 // 11

assert(result1 === 11 && result2 === 4 && result3 === 15 && result4 === 11 );

Nullish coalescing ஆபரேட்டர் '??'

nullish coalescing ஆபரேட்டர் முதல் வாதம் null/undefined இல்லை என்றால் அதை திரும்பப் பெறுகிறது, இல்லையெனில் இரண்டாவதை. இது இரண்டு கேள்விக்குறிகளாக ?? எழுதப்படுகிறது. x ?? y இன் முடிவு:

• x வரையறுக்கப்பட்டிருந்தால், x,
• y வரையறுக்கப்படவில்லை என்றால், y.