அடிப்படை ஆபரேட்டர்கள்

JavaScript இல், ஒரு ஆபரேட்டர் என்பது operands (மதிப்புகள் மற்றும் மாறிகள்) இல் செயல்பாடுகளை செய்ய பயனர் பயன்படுத்தும் ஒரு சின்னம் அல்லது முக்கியசொல். எடுத்துக்காட்டாக:

2 + 3; //5

இங்கே + கூட்டலை செய்யும் ஆபரேட்டர், மற்றும் 2 மற்றும் 3 operands.

ஆபரேட்டர்களின் வகைகள்

JavaScript ஆல் ஆதரிக்கப்படும் பல்வேறு ஆபரேட்டர்கள் உள்ளன. அவை பின்வருமாறு:

கணித ஆபரேட்டர்கள்
ஒதுக்கீடு ஆபரேட்டர்கள்
ஒப்பீடு ஆபரேட்டர்கள்
தர்க்க ஆபரேட்டர்கள்
Ternary ஆபரேட்டர்கள்
Bitwise ஆபரேட்டர்கள்
typeof ஆபரேட்டர்கள்

கணித ஆபரேட்டர்கள்

கணித ஆபரேட்டர்கள் மதிப்புகளில் கணித செயல்பாடுகளை செய்ய பயன்படுத்தப்படுகின்றன. அவை உள்ளடக்குகின்றன:

கூட்டல் (+) ஆபரேட்டர்
கழித்தல் (-) ஆபரேட்டர்
பெருக்கல் (*) ஆபரேட்டர்
வகுத்தல் (/) ஆபரேட்டர்
மீதி (%) ஆபரேட்டர்

கூட்டல் ஆபரேட்டர் (`+`)

கூட்டல் ஆபரேட்டர் இரண்டு எண்களை கூட்டுகிறது. எடுத்துக்காட்டாக:

console.log(1 + 2); // 3
console.log(1 + -2); // -1

கழித்தல் ஆபரேட்டர் (`-`)

கழித்தல் ஆபரேட்டர் ஒரு எண்ணிலிருந்து மற்றொரு எண்ணை கழிக்கிறது. எடுத்துக்காட்டாக:

console.log(3 - 2); // 1
console.log(3 - -2); // 5

பெருக்கல் ஆபரேட்டர் (`*`)

பெருக்கல் ஆபரேட்டர் இரண்டு எண்களை பெருக்குகிறது. எடுத்துக்காட்டாக:

console.log(2 * 3); // 6
console.log(2 * -3); // -6

வகுத்தல் ஆபரேட்டர் (`/`)

வகுத்தல் ஆபரேட்டர் ஒரு எண்ணை மற்றொரு எண்ணால் வகுக்கிறது. எடுத்துக்காட்டாக:

console.log(6 / 2); // 3
console.log(6 / -2); // -3

மீதி ஆபரேட்டர் (`%`)

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

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

JavaScript மொழிபெயர்ப்பாளர் இடமிருந்து வலமாக செயல்படுகிறது. வெளிப்பாடுகளை பிரிக்கவும் குழுவாக்கவும் கணிதத்தில் போல அடைப்புக்குறிகளைப் பயன்படுத்தலாம்: c = (a / b) + d

JavaScript கூட்டல் மற்றும் இணைப்பு இரண்டிற்கும் + ஆபரேட்டரைப் பயன்படுத்துகிறது. எண்கள் கூட்டப்படுகின்றன, சரங்கள் இணைக்கப்படுகின்றன.

NaN என்பது ஒரு எண் சட்டபூர்வமான எண் அல்ல என்பதை சுட்டும் ஒரு ஒதுக்கப்பட்ட வார்த்தை, இது எண் அல்லாத சரத்துடன் கணிதம் செய்யும்போது NaN (Not a Number) ஐ விளைவிக்கும்.

let x = 100 / "10";

parseInt முறை ஒரு மதிப்பை சரமாக பார்ஸ் செய்து முதல் முழு எண்ணை திரும்பப் பெறுகிறது.

parseInt("10"); // 10
parseInt("10.00"); // 10
parseInt("10.33"); // 10
parseInt("34 45 66"); // 34
parseInt(" 60 "); // 60
parseInt("40 years"); //40
parseInt("He was 40"); //NaN

JavaScript இல், மிகப் பெரிய சாத்தியமான எண்ணுக்கு வெளியே ஒரு எண்ணை கணக்கிட்டால் Infinity திரும்பப் பெறுகிறது.

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

Correct!

False!

`num1` மற்றும் `num2` இல் பின்வரும் செயல்பாடுகளை செய்ய +, -, \*, /, மற்றும் % கணித ஆபரேட்டர்களைப் பயன்படுத்தவும்.

let num1 = 10; let num2 = 5; // num1 மற்றும் num2 ஐ கூட்டவும். let addResult = // num1 இலிருந்து num2 ஐ கழிக்கவும். let subtractResult = // num1 மற்றும் num2 ஐ பெருக்கவும். let multiplyResult = // num1 ஐ num2 ஆல் வகுக்கவும். let divideResult = // num1 num2 ஆல் வகுக்கப்படும்போது மீதியை கண்டுபிடிக்கவும். let reminderResult =

let num1 = 10;
let num2 = 5;

// num1 மற்றும் num2 ஐ கூட்டவும்.
let addResult = (num1 + num2);
// num1 இலிருந்து num2 ஐ கழிக்கவும்.
let subtractResult = (num1 - num2);
// num1 மற்றும் num2 ஐ பெருக்கவும்.
let multiplyResult = (num1 \* num2);
// num1 ஐ num2 ஆல் வகுக்கவும்.
let divideResult = (num1 / num2);
// num1 num2 ஆல் வகுக்கப்படும்போது மீதியை கண்டுபிடிக்கவும்.
let reminderResult = (num1 % num2);

assert(addResult === 15 && subtractResult === 5 && multiplyResult === 50 && divideResult === 2 && reminderResult === 0 );

Submit Solution

ஒதுக்கீடு ஆபரேட்டர்கள்

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

`=` (ஒதுக்கீடு ஆபரேட்டர்)

இந்த ஆபரேட்டர் வலது பக்கத்தில் உள்ள மதிப்பை இடது பக்கத்தில் உள்ள மாறிக்கு ஒதுக்க பயன்படுத்தப்படுகிறது. எடுத்துக்காட்டுகள்:

let x = 10; // மாறி x க்கு 10 மதிப்பை ஒதுக்குகிறது.

கூட்டு ஒதுக்கீடு ஆபரேட்டர்கள்

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

`+=` (கூட்டல் ஒதுக்கீடு)

வலது பக்கத்தில் உள்ள மதிப்பை மாறியுடன் கூட்டி முடிவை மாறிக்கு திரும்ப ஒதுக்குகிறது.

`-=` (கழித்தல் ஒதுக்கீடு)

மாறியிலிருந்து வலது பக்கத்தில் உள்ள மதிப்பை கழித்து முடிவை மாறிக்கு திரும்ப ஒதுக்குகிறது.

`*=-` (பெருக்கல் ஒதுக்கீடு)

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

`/=` (வகுத்தல் ஒதுக்கீடு)

மாறியை வலது பக்கத்தில் உள்ள மதிப்பால் வகுத்து முடிவை மாறிக்கு திரும்ப ஒதுக்குகிறது.

`%=` (Modules/மீதி ஒதுக்கீடு)

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

let a = 10;
a += 5; // a = a + 5; க்கு சமம் (a 15 ஆகிறது)
a -= 3; // a = a - 3; க்கு சமம் (a 12 ஆகிறது)
a *= 2; // a = a * 2; க்கு சமம் (a 24 ஆகிறது)
a /= 4; // a = a / 4; க்கு சமம் (a 6 ஆகிறது)
a %= 5; // a = a % 5; க்கு சமம் (a 1 ஆகிறது)

ஒப்பீடு ஆபரேட்டர்கள்

ஒப்பீடு ஆபரேட்டர்கள் இரண்டு மதிப்புகள் அல்லது வெளிப்பாடுகளை ஒப்பிட்டு boolean முடிவை திரும்பப் பெற பயன்படுத்தப்படுகின்றன, இது true அல்லது false. இந்த ஆபரேட்டர்கள் பொதுவாக நிபந்தனை அறிக்கைகளில் முடிவு எடுக்க அல்லது நிபந்தனைகளை மதிப்பீடு செய்ய பயன்படுத்தப்படுகின்றன.

சமம் (`==`)

இந்த ஆபரேட்டர் இடது மற்றும் வலது பக்கங்களில் உள்ள மதிப்புகள் சமனாக இருக்கின்றனவா என சரிபார்க்கிறது. அவை சமனாக இருந்தால், true திரும்பப் பெறுகிறது இல்லையெனில், false திரும்பப் பெறுகிறது. தரவு வகைகளை கவனிக்காது.

5 == 5; // true
"5" == 5; // true (implicit type conversion)

சமமில்லை (`!=`)

இந்த ஆபரேட்டர் இடது மற்றும் வலது பக்கங்களில் உள்ள மதிப்புகள் சமனாக இல்லையா என சரிபார்க்கிறது. அவை சமனாக இல்லை என்றால், true திரும்பப் பெறுகிறது இல்லையெனில், false திரும்பப் பெறுகிறது.

5 != 3; // true
"5" != 5; // false (implicit type conversion)

கடுமையான சமம் (`===`)

இந்த ஆபரேட்டர் இடது மற்றும் வலது பக்கங்களில் உள்ள மதிப்புகள் சமனாக இருக்கின்றனவா மற்றும் ஒரே தரவு வகை கொண்டவையா என சரிபார்க்கிறது. மதிப்பு மற்றும் தரவு வகை இரண்டும் பொருந்தினால், true திரும்பப் பெறுகிறது இல்லையெனில், false திரும்பப் பெறுகிறது.

5 === 5; // true
"5" === 5; // false (வெவ்வேறு தரவு வகைகள்)

கடுமையான சமமில்லை (`!==`)

இந்த ஆபரேட்டர் இடது மற்றும் வலது பக்கங்களில் உள்ள மதிப்புகள் சமனாக இல்லையா அல்லது வெவ்வேறு தரவு வகைகள் கொண்டவையா என சரிபார்க்கிறது. அவை சமனாக இல்லை அல்லது வெவ்வேறு தரவு வகைகள் கொண்டவை என்றால், true திரும்பப் பெறுகிறது இல்லையெனில், false திரும்பப் பெறுகிறது.

5 !== "5"; // true (வெவ்வேறு தரவு வகைகள்)
5 !== 5; // false

பெரியது (`>`)

இந்த ஆபரேட்டர் இடது பக்கத்தில் உள்ள மதிப்பு வலது பக்கத்தில் உள்ள மதிப்பை விட பெரியதா என சரிபார்க்கிறது. இடது மதிப்பு பெரியதாக இருந்தால், true திரும்பப் பெறுகிறது இல்லையெனில், false திரும்பப் பெறுகிறது.

8 > 5; // true
3 > 10; // false

சிறியது (`<`)

இந்த ஆபரேட்டர் இடது பக்கத்தில் உள்ள மதிப்பு வலது பக்கத்தில் உள்ள மதிப்பை விட சிறியதா என சரிபார்க்கிறது. இடது மதிப்பு சிறியதாக இருந்தால், true திரும்பப் பெறுகிறது இல்லையெனில், false திரும்பப் பெறுகிறது.

3 < 5; // true
8 < 2; // false

பெரியதாக அல்லது சமம் (`>=`)

இந்த ஆபரேட்டர் இடது பக்கத்தில் உள்ள மதிப்பு வலது பக்கத்தில் உள்ள மதிப்பை விட பெரியதாக அல்லது சமனாக இருக்கிறதா என சரிபார்க்கிறது. இடது மதிப்பு பெரியதாக அல்லது சமனாக இருந்தால், true திரும்பப் பெறுகிறது இல்லையெனில், false திரும்பப் பெறுகிறது.

8 >= 5; // true
3 >= 8; // false

சிறியதாக அல்லது சமம் (`<=`)

இந்த ஆபரேட்டர் இடது பக்கத்தில் உள்ள மதிப்பு வலது பக்கத்தில் உள்ள மதிப்பை விட சிறியதாக அல்லது சமனாக இருக்கிறதா என சரிபார்க்கிறது. இடது மதிப்பு சிறியதாக அல்லது சமனாக இருந்தால், true திரும்பப் பெறுகிறது இல்லையெனில், false திரும்பப் பெறுகிறது.

3 <= 5; // true
8 <= 2; // false

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

தர்க்க ஆபரேட்டர்கள் Boolean மதிப்புகள் அல்லது வெளிப்பாடுகளில் தர்க்க செயல்பாடுகளை செய்ய பயன்படுத்தப்படுகின்றன. இந்த ஆபரேட்டர்கள் முடிவெடுக்க அல்லது சிக்கலான நிபந்தனைகளை மதிப்பீடு செய்ய Boolean மதிப்புகளை இணைக்க அல்லது கையாள அனுமதிக்கின்றன.

தர்க்க AND (`&&`)

தர்க்க AND ஆபரேட்டர் இரண்டு operands உம் true என்றால் true திரும்பப் பெறுகிறது. operands இல் குறைந்தது ஒன்று false என்றால், false திரும்பப் பெறுகிறது.

true && true; // true
true && false; // false
false && true; // false
false && false; // false

தர்க்க OR (`||`)

தர்க்க OR ஆபரேட்டர் operands இல் குறைந்தது ஒன்று true என்றால் true திரும்பப் பெறுகிறது. இரண்டு operands உம் false என்றால் மட்டுமே false திரும்பப் பெறுகிறது.

true || true; // true
true || false; // true
false || true; // true
false || false; // false

தர்க்க NOT (`!`)

தர்க்க NOT ஆபரேட்டர் ஒரு operand இன் மதிப்பை மறுக்கிறது. operand false என்றால் true திரும்பப் பெறுகிறது, operand true என்றால் false திரும்பப் பெறுகிறது.

!true; // false
!false; // true

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

Ternary ஆபரேட்டர் மூன்று operands கொண்டது. இது if/else இன் எளிமைப்படுத்தப்பட்ட ஆபரேட்டர்.

இது if-else நிபந்தனையின் குறுகிய வடிவம்.

தொடரியல்

Y =  ? A : B
நிபந்தனை உண்மை என்றால் Y = A இல்லையெனில் Y = B

let isEven = 8 % 2 === 0 ? "Even" : "Odd";
console.log(isEven); // "Even"

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

Bitwise ஆபரேட்டர்கள் இரண்டு எண்களின் தனிப்பட்ட bits ஐ கையாள பயன்படுத்தப்படுகின்றன. அவை bit மட்டத்தில் செயல்பாடுகளை செய்கின்றன, இது குறைந்த-நிலை தரவை கட்டுப்படுத்த அல்லது பகுப்பாய்வு செய்ய வேண்டிய சூழல்களில் மிகவும் பயனுள்ளது.

Bitwise AND (`&`)

இந்த ஆபரேட்டர் இரண்டு எண்களின் ஒவ்வொரு bit ஐயும் ஒப்பிட்டு இரண்டு எண்களிலும் 1 ஆக உள்ள ஒவ்வொரு bit க்கும் 1 திரும்பப் பெறுகிறது. மற்ற அனைத்து bits உம் 0 ஆக அமைக்கப்படுகின்றன.

1010 & 1100; // 1000

Bitwise OR (`|`)

இந்த ஆபரேட்டர் இரண்டு எண்களின் ஒவ்வொரு bit ஐயும் ஒப்பிட்டு குறைந்தது ஒரு எண்ணில் 1 ஆக உள்ள ஒவ்வொரு bit க்கும் 1 திரும்பப் பெறுகிறது.

1010 | 1100; // 1110

Bitwise XOR (`^`)

இந்த ஆபரேட்டர் இரண்டு எண்களின் ஒவ்வொரு bit ஐயும் ஒப்பிட்டு ஒரு எண்ணில் 1 ஆக இருந்து இரண்டிலும் அல்ல என்ற ஒவ்வொரு bit க்கும் 1 திரும்பப் பெறுகிறது.

1010 ^ 1100; // 0110

Bitwise NOT (`-`)

இந்த ஆபரேட்டர் ஒரு எண்ணின் அனைத்து bits ஐயும் தலைகீழாக்குகிறது (flip செய்கிறது). ஒவ்வொரு 0 ஐயும் 1 ஆக மற்றும் ஒவ்வொரு 1 ஐயும் 0 ஆக மாற்றுகிறது.

~1010; // 0101

இடது Shift (`<<`)

இந்த ஆபரேட்டர் ஒரு எண்ணின் bits ஐ குறிப்பிட்ட எண்ணிக்கையிலான நிலைகளால் இடதுபுறம் நகர்த்துகிறது, நகர்த்தப்பட்ட நிலைகளை 0 ஆல் நிரப்புகிறது.

1010 << 2; // 101000 (2 நிலைகளால் இடதுபுறம் நகர்த்தப்பட்டது)

வலது Shift (`>>`)

இந்த ஆபரேட்டர் ஒரு எண்ணின் bits ஐ குறிப்பிட்ட எண்ணிக்கையிலான நிலைகளால் வலதுபுறம் நகர்த்துகிறது. நகர்த்தப்பட்ட நிலைகள் மிகவும் இடது bit (sign bit) அடிப்படையில் நிரப்பப்படுகின்றன.

1010 >> 2; // 0010 (2 நிலைகளால் வலதுபுறம் நகர்த்தப்பட்டது)

`typeof` ஆபரேட்டர்கள்

இது operand வகையை திரும்பப் பெறுகிறது, JavaScript இல் இருக்கக்கூடிய வகைகள் undefined, Object, boolean, number, string, symbol, மற்றும் function.

let value1 = 42;
let value2 = "Hello, World!";
let value3 = true;
let value4 = null;

console.log(typeof value1); // "number"
console.log(typeof value2); // "string"
console.log(typeof value3); // "boolean"
console.log(typeof value4); // "object" (குறிப்பு: `typeof null` வரலாற்று காரணங்களால் "object" திரும்பப் பெறுகிறது)

அடிப்படை ஆபரேட்டர்கள்

ஆபரேட்டர்களின் வகைகள்

கணித ஆபரேட்டர்கள்

கூட்டல் ஆபரேட்டர் (+)

கழித்தல் ஆபரேட்டர் (-)

பெருக்கல் ஆபரேட்டர் (*)

வகுத்தல் ஆபரேட்டர் (/)

மீதி ஆபரேட்டர் (%)

ஒதுக்கீடு ஆபரேட்டர்கள்

= (ஒதுக்கீடு ஆபரேட்டர்)

கூட்டு ஒதுக்கீடு ஆபரேட்டர்கள்

+= (கூட்டல் ஒதுக்கீடு)

-= (கழித்தல் ஒதுக்கீடு)

*=- (பெருக்கல் ஒதுக்கீடு)

/= (வகுத்தல் ஒதுக்கீடு)

%= (Modules/மீதி ஒதுக்கீடு)

ஒப்பீடு ஆபரேட்டர்கள்

சமம் (==)

சமமில்லை (!=)

கடுமையான சமம் (===)

கடுமையான சமமில்லை (!==)

பெரியது (>)

சிறியது (<)

பெரியதாக அல்லது சமம் (>=)

சிறியதாக அல்லது சமம் (<=)