Jassif Team Institution

JavaScript Assignment Operators

ஒதுக்கீட்டு ஆபரேட்டர்கள் JavaScript மாறிகளுக்கு மதிப்புகளை ஒதுக்குகின்றன.

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

Assignment Operators

Logical Assignment Operators

The = Operator

எளிய ஒதுக்கீட்டு ஆபரேட்டர் ஒரு மாறிக்கு எளிய மதிப்பை ஒதுக்குகிறது.

let x = 10;
let y = 10 + 5;  // y = 15

The += Operator

கூட்டல் ஒதுக்கீட்டு ஆபரேட்டர் ஒரு மாறிக்கு ஒரு மதிப்பைச் சேர்க்கிறது.

let x = 10;
x += 5;  // x = 15

let y = 20;
y += 3;  // y = 23

The -= Operator

கழித்தல் ஒதுக்கீட்டு ஆபரேட்டர் ஒரு மாறியிலிருந்து ஒரு மதிப்பைக் கழிக்கிறது.

let x = 10;
x -= 5;  // x = 5

The *= Operator

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

let x = 10;
x *= 5;  // x = 50

The **= Operator

அடுக்குக்குறி ஒதுக்கீட்டு ஆபரேட்டர் ஒரு மாறியை operand இன் அடுக்குக்கு உயர்த்துகிறது.

let x = 10;
x **= 5;  // x = 100000 (10⁵)

The /= Operator

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

let x = 10;
x /= 5;  // x = 2

The %= Operator

மீதி ஒதுக்கீட்டு ஆபரேட்டர் ஒரு மாறிக்கு மீதியை ஒதுக்குகிறது.

let x = 10;
x %= 5;  // x = 0 (10 ÷ 5 = 2, remainder 0)

String Assignment

இரண்டு ஒதுக்கீட்டு ஆபரேட்டர்கள் சரங்களுக்கு மதிப்புகளை ஒதுக்கலாம்:

எளிய ஒதுக்கீட்டு ஆபரேட்டர் ஒரு சரத்திற்கு எளிய மதிப்பை ஒதுக்குகிறது.

கூட்டல் ஒதுக்கீட்டு ஆபரேட்டர் ஒரு சரத்திற்கு மதிப்பைச் சேர்க்கிறது.

let text = "Hello";
let greeting = "Hi";

let text = "Hello";
text += " World";  // text = "Hello World"

The &&= Operator

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

முதல் மதிப்பு true எனில், இரண்டாவது மதிப்பு ஒதுக்கப்படுகிறது.

let x = true;
let y = x &&= 10;  // y = 10

let x = false;
let y = x &&= 10;  // y = false

let x = 1;         // truthy
let y = x &&= 10;  // y = 10

let x = 0;         // falsy
let y = x &&= 10;  // y = 0

let x = undefined;
let y = x &&= 10;  // y = undefined

let x = null;
let y = x &&= 10;  // y = null

The ||= Operator

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

முதல் மதிப்பு false எனில், இரண்டாவது மதிப்பு ஒதுக்கப்படுகிறது.

let x = false;
let y = x ||= 10;  // y = 10

let x = true;
let y = x ||= 10;  // y = true

let x = null;      // falsy
let y = x ||= 10;  // y = 10

let x = undefined; // falsy
let y = x ||= 10;  // y = 10

let x = 0;         // falsy
let y = x ||= 10;  // y = 10

let x = "";        // falsy (empty string)
let y = x ||= 10;  // y = 10

The ??= Operator

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

முதல் மதிப்பு undefined அல்லது null எனில், இரண்டாவது மதிப்பு ஒதுக்கப்படுகிறது.

let x;
x ??= 10;          // x = 10 (undefined)

let x = 0;
x ??= 10;          // x = 0 (not nullish)

let x = null;
x ??= 10;          // x = 10 (null)

let x = undefined;
x ??= 10;          // x = 10 (undefined)

let x = false;
x ??= 10;          // x = false (not nullish)

let x = "";
x ??= 10;          // x = "" (not nullish)

The Spread (...) Operator

... ஆபரேட்டர் iterables ஐ தனிப்பட்ட கூறுகளாகப் பிரிக்கிறது.

let text = "12345";

let min = Math.min(...text);  // min = 1
let max = Math.max(...text);  // max = 5

||= vs ??= Comparison

Exercise

let x = 5;
x += 10;