இடைநிலை நிலை ஜாவாஸ்கிரிப்ட் நேர்காணல் கேள்விகள் (Intermediate Level JavaScript Interview Questions)

1. சுழல்கள் (Loops)

1.1. ஜாவாஸ்கிரிப்ட் சுழலில் ஒரு மறு செய்கையின் (iteration) வரையறை என்ன?

பதில்: ஜாவாஸ்கிரிப்ட் சுழலில் ஒரு மறு செய்கை (iteration) என்பது சுழலின் உடலின் ஒவ்வொரு தனிப்பட்ட செயலாக்கத்தையும் குறிக்கிறது, பொதுவாகச் சுழலின் ஒரு சுழற்சியுடன் (cycle) ஒத்துள்ளது.

1.2. ஜாவாஸ்கிரிப்டில் உள்ள அனைத்து லூப்பிங் கட்டமைப்புகளும் (looping structures) என்ன?

பதில்: ஜாவாஸ்கிரிப்டில் பல்வேறு லூப்பிங் கட்டமைப்புகள் பயன்படுத்தப்படுகின்றன. அவற்றில் சில பின்வருமாறு:

While சுழல் (While loop): while சுழல் என்பது கட்டுப்பாடு ஓட்ட அறிக்கையாகும் (control flow statement), இது கொடுக்கப்பட்ட பூலியன் நிபந்தனையின் (Boolean condition) அடிப்படையில் குறியீட்டை மீண்டும் மீண்டும் செயல்படுத்த அனுமதிக்கிறது. while சுழலை மீண்டும் மீண்டும் if அறிக்கையாகக் கருதலாம்.

For சுழல் (For loop): for சுழல் லூப் அமைப்பை (loop structure) எழுதுவதற்கான சுருக்கமான வழியை வழங்குகிறது. while சுழல் போலல்லாமல், for அறிக்கையானது தொடக்கமாக்கல் (initialization), நிபந்தனை மற்றும் அதிகரிப்பு/குறைவு (increment/decrement) ஆகியவற்றை ஒரே வரியில் பயன்படுத்துகிறது, இதன் மூலம் குறியீட்டைச் சுருக்கமாகவும் எளிதாகவும் பிழைத்திருத்தவும் (debug) வழங்குகிறது.

Do while: do-while சுழல் என்பது while சுழலைப் போன்றது, அறிக்கைகளைச் செயல்படுத்திய பிறகு நிபந்தனையைச் சரிபார்க்கிறது என்பதே ஒரே வித்தியாசம், எனவே இது வெளியேறும் கட்டுப்பாட்டுச் சுழலுக்கு (Exit Control Loop) ஒரு எடுத்துக்காட்டு ஆகும்.

1.3. சுழலில் `break` அறிக்கை (statement) எவ்வாறு செயல்படுகிறது?

பதில்: பிரேக் அறிக்கை (break statement) தற்போதைய சுழல் அல்லது சுவிட்ச் (switch) அறிக்கையை நிறுத்துகிறது மற்றும் நிறுத்தப்பட்ட அறிக்கையைத் தொடர்ந்து வரும் அறிக்கைக்கு நிரல் கட்டுப்பாட்டை (program control) மாற்றுகிறது. லேபிளிடப்பட்ட அறிக்கைக்குள் (labeled statement) பயன்படுத்தப்படும் போது லேபிளிடப்பட்ட அறிக்கையைக் கடந்தும் இது பயன்படுத்தப்படலாம்.

1.4. சுழலில் `continue` அறிக்கை எவ்வாறு செயல்படுகிறது?

பதில்: continue உத்தரவு (directive) என்பது break அறிக்கையின் "இலகுவான பதிப்பு (lighter version)" ஆகும். இது முழுச் சுழலையும் (loop) நிறுத்தாது; அதற்குப் பதிலாக, இது தற்போதைய மறு செய்கையை (iteration) நிறுத்தி, சுழலை புதியதைத் தொடங்கும்படி கட்டாயப்படுத்துகிறது (நிபந்தனை அனுமதித்தால்).

2. சுவிட்ச் அறிக்கை (Switch statement)

2.1. ஜாவாஸ்கிரிப்டில் சுவிட்ச் (switch) அறிக்கை என்றால் என்ன?

பதில்: ஜாவாஸ்கிரிப்டில் ஒரு சுவிட்ச் (switch) அறிக்கை என்பது ஒரு கட்டுப்பாட்டு ஓட்ட அறிக்கை (control flow statement) ஆகும், இது ஒரு கோவையை (expression) மதிப்பிடுகிறது மற்றும் பொருந்திய வழக்கின் (matched case) அடிப்படையில் குறியீட்டின் குறிப்பிட்ட தொகுதியை (block) செயல்படுத்துகிறது.

2.2. சுவிட்ச் அறிக்கையைப் பயன்படுத்துவதன் நன்மைகள் என்ன?

பதில்: switch அறிக்கை பல காசோலைகளை (checks) மாற்றும், மேலும் இது மிகவும் விளக்கமான மற்றும் படிக்க எளிதானது. சுவிட்ச் அறிக்கைகள் குறியீடு வாசிப்புத்திறனை (code readability) மேம்படுத்துகின்றன, சிறந்த செயல்திறனை (performance) வழங்குகின்றன, சிக்கலான நிபந்தனைகளை (complex conditionals) எளிதாக்குகின்றன, பராமரிப்பை (maintainability) மேம்படுத்துகின்றன மற்றும் சுத்தமான தொடரியல் (cleaner syntax) ஆதரிக்கின்றன.

2.3. சுவிட்ச் அறிக்கையில் கேஸ் (case) அறிக்கைகளின் வரிசை முக்கியமானதா?

பதில்: சுவிட்ச் (switch) அறிக்கையில் கேஸ் (case) அறிக்கைகளின் வரிசை முக்கியமானது, குறிப்பாக வீழ்ச்சி நடத்தை (fall-through behavior) பயன்படுத்தும் போது. வழக்குகள் (Cases) தொடர்ச்சியாக மதிப்பிடப்படுகின்றன (sequentially), எனவே முன்னதாகக் கண்டறியப்பட்ட பொருந்தக்கூடிய வழக்கு (matching case), அடுத்தடுத்த வழக்குகள் சோதிக்கப்படுவதைத் தடுக்கும், இது செயல்பாட்டையும் செயல்திறனையும் பாதிக்கும்.

3. ஜாவாஸ்கிரிப்ட் குக்கீகள் (JavaScript cookies)

3.1. ஜாவாஸ்கிரிப்ட் குக்கீகள் என்றால் என்ன?

பதில்: குக்கீகள் (Cookies) என்பவை பயனரின் கணினியில் சேமிக்கப்படும் சிறிய கோப்புகள். ஒரு குறிப்பிட்ட கிளையன்ட் (client) மற்றும் இணையதளத்திற்கு (website) குறிப்பிட்ட அளவிலான தரவை வைத்திருக்க அவை பயன்படுத்தப்படுகின்றன மற்றும் வலைச் சேவையகம் (web server) அல்லது வாடிக்கையாளரின் கணினி (client’s computer) மூலம் அணுகலாம். குக்கீகள் கண்டுபிடிக்கப்பட்டபோது, அவை அடிப்படையில் உங்களைப் பற்றியும் உங்கள் விருப்பங்களைப் பற்றியும் (preferences) தகவல்களைக் கொண்ட சிறிய ஆவணங்களாகும். எடுத்துக்காட்டாக, உங்கள் வலைத்தளத்தைப் பார்க்க விரும்பும் மொழியை நீங்கள் தேர்ந்தெடுக்கும்போது, இணையதளம் உங்கள் கணினியில் உள்ள குக்கீ (cookie) எனப்படும் ஆவணத்தில் தகவலைச் சேமிக்கும், அடுத்த முறை நீங்கள் இணையதளத்திற்குச் செல்லும்போது, அதைப் படிக்க முடியும். முன்னதாகவே சேமிக்கப்பட்ட குக்கீ.

3.2. ஜாவாஸ்கிரிப்ட் பயன்படுத்தி குக்கீயை எவ்வாறு உருவாக்குவது?

பதில்: ஜாவாஸ்கிரிப்டைப் பயன்படுத்தி குக்கீயை (cookie) உருவாக்க document.cookie பொருளுக்கு ஒரு சரம் (string) மதிப்பை ஒதுக்க வேண்டும்.

document.cookie = "key1 = value1; key2 = value2; expires = date";

பதில்: document.cookie இன் மதிப்பு ஒரு குக்கீயை (cookie) உருவாக்கப் பயன்படுகிறது. நீங்கள் குக்கீயை (cookie) அணுக விரும்பும் போதெல்லாம் சரத்தைப் (string) பயன்படுத்தலாம். document.cookie சரமானது அரைப்புள்ளிகளால் (semicolons) பிரிக்கப்பட்ட name = value ஜோடிகளின் பட்டியலை வைத்திருக்கிறது, இதில் பெயர் என்பது குக்கீயின் பெயராகும் மற்றும் மதிப்பு அதன் சரம் மதிப்பு.

3.4. ஜாவாஸ்கிரிப்டைப் பயன்படுத்தி குக்கீயை எவ்வாறு நீக்குவது?

பதில்: ஒரு குக்கீயை நீக்குவது குக்கீயை உருவாக்குவது அல்லது படிப்பதை விட மிகவும் எளிதானது, நீங்கள் expires = “past time” என்பதை அமைக்க வேண்டும் மற்றும் குக்கீயை நீக்கச் சிலர் உங்களை அனுமதிக்காவிட்டால், சரியான குக்கீ பாதையை (cookie path) வரையறுக்கிறது என்பதை உறுதிப்படுத்திக் கொள்ளவும்.

4. ஜாவாஸ்கிரிப்டில் பாப்-அப் பெட்டிகள் (Pop-up boxes in JavaScript)

4.1. ஜாவாஸ்கிரிப்டில் கிடைக்கும் பாப் அப் பெட்டிகளின் வகைகள் யாவை?

பதில்: ஜாவாஸ்கிரிப்டில் மூன்று வகையான பாப் பெட்டிகள் (pop boxes) உள்ளன: எச்சரிக்கை (Alert), உறுதிப்படுத்தல் (Confirm), தூண்டுதல் (Prompt).

4.2. எச்சரிக்கைப் பெட்டிக்கும் (alert box) உறுதிப்படுத்தல் பெட்டிக்கும் (confirmation box) என்ன வித்தியாசம்?

பதில்: ஒரு எச்சரிக்கைப் பெட்டியானது (alert box) OK பட்டனை மட்டுமே காண்பிக்கும். பயனர் ஒப்புக்கொள்ள வேண்டும் என்ற ஒப்பந்தத்தைப் பற்றிப் பயனருக்குத் தெரிவிக்க இது பயன்படுகிறது. ஆனால் ஒரு உறுதிப்படுத்தல் பெட்டி (Confirmation box) OK மற்றும் Cancel ஆகிய இரண்டு பொத்தான்களைக் காண்பிக்கும், அங்குப் பயனர் ஏற்க வேண்டுமா இல்லையா என்பதை முடிவு செய்யலாம்.

5. அம்பு செயல்பாடுகள் (Arrow Functions)

5.1. அம்பு செயல்பாட்டின் (arrow function) வரையறை என்ன?

பதில்: அம்பு குறியீட்டைப் (arrow notation) பயன்படுத்தி, ஜாவாஸ்கிரிப்டில் அநாமதேயச் செயல்பாடுகளை (anonymous functions) வரையறுப்பதற்கான ஒரு சுருக்கமான தொடரியல் (syntax) ஒரு அம்புச் செயல்பாடு (arrow function) ஆகும். இது குறுகிய தொடரியல் (shorter syntax), "this" என்பதன் லெக்சிக்கல் ஸ்கோப்பிங் (lexical scoping) ஆகியவற்றை வழங்குகிறது மற்றும் கட்டமைப்பாளராகப் (constructor) பயன்படுத்த முடியாது.

5.2. செயல்பாட்டுக் கோவைகளிலிருந்து (function expressions) அம்பு செயல்பாடுகள் (arrow functions) எவ்வாறு வேறுபடுகின்றன?

பதில்: அம்புச் செயல்பாடுகள் (Arrow functions) குறுகிய தொடரியல் (shorter syntax) வழங்குகின்றன, அவற்றின் சொந்த this, arguments, super அல்லது new.target ஆகியவற்றைக் கொண்டிருக்கவில்லை, மேலும் செயல்பாட்டுக் கோவைகளைப் (function expressions) போலன்றி, கன்ஸ்ட்ரக்டர்களாகப் பயன்படுத்த முடியாது.

5.3. லெக்சிகல் 'this' பிணைப்பு என்பது அம்பு செயல்பாடுகளில் (arrow functions) என்ன அர்த்தம்?

பதில்: அம்பு செயல்பாடுகளில் "லெக்சிகல் திஸ் (Lexical this)" பிணைப்பு என்பது அவை தங்களுக்குரிய 'this' சூழலை உருவாக்கவில்லை என்பதாகும்; அதற்குப் பதிலாக, அவை சுற்றியுள்ள, இணைக்கும் ஸ்கோப்பில் (enclosing scope) இருந்து 'this' மரபுரிமையாகப் (inherit) பெறுகின்றன, பொதுவான 'this'-தொடர்புடைய சிக்கல்களைக் குறைக்கின்றன.

5.4. அம்பு செயல்பாடுகளைப் (arrow functions) பயன்படுத்துவதன் நன்மைகள் என்ன?

பதில்: ஜாவாஸ்கிரிப்டில் அம்பு செயல்பாடுகளைப் (arrow functions) பயன்படுத்துவதன் நன்மைகள் குறுகிய தொடரியல் (shorter syntax), மறைமுகமான வருமானம் (implicit return) மற்றும் லெக்சிகல் 'this' பிணைப்பு ஆகியவை அடங்கும்.

5.5. அம்பு செயல்பாடுகளுக்கான (arrow functions) பொதுவான பயன்பாட்டு வழக்குகள் (use cases) யாவை?

பதில்: ஆப்ஜெக்ட் முறைகள் (object methods), ஈவென்ட் லிசனர்ஸ் (event listeners), கால்பேக்குகள் (callbacks) மற்றும் குறுகிய, சுருக்கமான தொடரியல் (syntax) தேவைப்படும் பிற செயல்பாடுகளுக்கு அம்பு செயல்பாடுகள் பொதுவாகப் பயன்படுத்தப்படுகின்றன.

6. வழக்கமான கோவை (Regular Expression)

6.1. வழக்கமான கோவை (Regular Expression) என்றால் என்ன?

பதில்: ஒரு வழக்கமான கோவை (regular expression) என்பது தேடல் வடிவத்தை (search pattern) உருவாக்கும் எழுத்துக்களின் வரிசையாகும். உரை (text) தரவைத் தேட இந்தத் தேடல் வடிவத்தைப் பயன்படுத்தலாம். அனைத்து வகையான உரை தேடல் மற்றும் உரை மாற்றீட்டுச் செயல்பாடுகளைச் (textreplace operations) செய்ய இவற்றைப் பயன்படுத்தலாம். இப்போது தொடரியல் வடிவமைப்பைப் (syntax format) பார்ப்போம்,

 /pattern/modifiers;

எடுத்துக்காட்டாக, கேஸ்-இன்சென்சிட்டிவ் பயனர்பெயருடன் (case-insensitive username) வழக்கமான கோவை (regular expression) அல்லது தேடல் வடிவம் (search pattern) பின்வருமாறு,

/John/i;

6.2. வழக்கமான கோவையில் (Regular expression) கிடைக்கும் சரம் முறைகள் (string methods) யாவை?

பதில்: ரெகுலர் எக்ஸ்பிரஷன்களில் இரண்டு சரம் முறைகள் உள்ளன: search() மற்றும் replace(). search() முறையானது ஒரு பொருத்தத்தைத் தேட ஒரு கோவையைப் பயன்படுத்துகிறது மற்றும் போட்டியின் நிலையை (position) வழங்குகிறது.

var msg = "Hello John";
var n = msg.search(/John/i); // 6

வடிவமைப்பு மாற்றப்படும் திருத்தப்பட்ட சரத்தைத் திருப்பியளிக்க replace() முறை பயன்படுத்தப்படுகிறது.

var msg = "Hello John";
var n = msg.replace(/John/i, "Buttler"); // Hello Buttler

6.3. வழக்கமான கோவையில் மாற்றிகள் (modifiers) என்றால் என்ன?

பதில்: கேஸ்-இன்சென்சிட்டிவ் மற்றும் உலகளாவிய தேடல்களைச் (case-insensitive and global searches) செய்ய மாற்றிகளைப் (Modifiers) பயன்படுத்தலாம். சில மாற்றிகளைப் பட்டியலிடுவோம்:

மாற்றி (Modifier)	விளக்கம் (Description)
`i`	கேஸ்-இன்சென்சிட்டிவ் பொருத்தம் (case-insensitive matching) செய்யவும்.
`g`	உலகளாவிய பொருத்தத்தைச் (global match) செய்யவும் (அனைத்துப் பொருத்தங்களையும் கண்டறியவும்).
`m`	பன்வரிசைப் பொருத்தம் (multiline matching) செய்யவும்.

உலகளாவிய மாற்றியின் (global modifier) உதாரணத்தை எடுத்துக் கொள்வோம்,

var text = "Learn JS one by one";
var pattern = /one/g;
var result = text.match(pattern); // one,one

6.4. வழக்கமான கோவை வடிவங்கள் (regular expression patterns) என்றால் என்ன?

பதில்: எழுத்துகளைப் பொருத்துவதற்காக (match characters) வழக்கமான கோவைகள் (Regular Expressions) வடிவங்களின் குழுவை வழங்குகின்றன. அடிப்படையில் அவை 3 வகைகளாகப் பிரிக்கப்பட்டுள்ளன,

i.அடைப்புக்குறிகள் (Brackets): இவை எழுத்துகளின் வரம்பைக் (range) கண்டறியப் பயன்படுகின்றன. எடுத்துக்காட்டாக, கீழே சில பயன்பாட்டு வழக்குகள் (use cases) உள்ளன,
- a. [abc]: அடைப்புக்குறிக்குள் (a,b,c) உள்ள எழுத்துக்களில் ஏதேனும் ஒன்றைக் கண்டறியப் பயன்படுகிறது.
- b. [0-9]: அடைப்புக்குறிக்கு இடையே உள்ள இலக்கங்களில் ஏதேனும் ஒன்றைக் கண்டறியப் பயன்படுகிறது.
- c. (a|b): | உடன் பிரிக்கப்பட்ட மாற்றுருக்களில் (alternatives) ஏதேனும் ஒன்றைக் கண்டறியப் பயன்படுகிறது
ii.மெட்டாக்கரக்டர்கள் (Metacharacters): இவை சிறப்பு அர்த்தம் கொண்ட எழுத்துகள், எடுத்துக்காட்டாக, கீழே சில பயன்பாட்டு வழக்குகள் உள்ளன.
- a. \d: இலக்கத்தைக் கண்டறியப் பயன்படுகிறது
- b. \s: ஒரு இடைவெளி (whitespace) எழுத்தைக் கண்டறியப் பயன்படுகிறது
- c. \b: ஒரு வார்த்தையின் தொடக்கத்தில் அல்லது முடிவில் பொருத்தத்தைக் கண்டறியப் பயன்படுகிறது
iii.அளவீடுகள் (Quantifiers): அளவுகளை வரையறுக்க இவை பயன்படுகின்றன எடுத்துக்காட்டாக, கீழே சில பயன்பாட்டு வழக்குகள் உள்ளன
- a. n+: குறைந்தது ஒரு nஐயாவது கொண்ட எந்தச் சரத்திற்கும் (string) பொருத்தங்களைக் கண்டறியப் பயன்படுகிறது
- b. n*: n இன் பூஜ்ய அல்லது அதற்கு மேற்பட்ட நிகழ்வுகளைக் (occurrences) கொண்ட எந்தச் சரத்திற்கும் பொருத்தங்களைக் கண்டறியப் பயன்படுகிறது
- c. n?: n இன் பூஜ்ய அல்லது ஒரு நிகழ்வைக் கொண்ட எந்தச் சரத்திற்கும் பொருத்தங்களைக் கண்டறியப் பயன்படுகிறது

6.5. RegExp பொருள் (object) என்றால் என்ன?

பதில்: RegExp பொருள் (object) என்பது முன்வரையறுக்கப்பட்ட பண்புகள் (predefined properties) மற்றும் முறைகளைக் (methods) கொண்ட வழக்கமான வெளிப்பாடு (regular expression) பொருளாகும். RegExp பொருளின் எளிய பயன்பாட்டைப் பார்ப்போம்,

var regexp = new RegExp("\\w+");
console.log(regexp);
// expected output: /\w+/

6.6. ஒரு வடிவமைப்புக்கான சரத்தை (string) எவ்வாறு தேடுவது?

பதில்: வடிவமைப்பிற்கான சரத்தைத் தேடுவதற்கு, முடிவைப் பொறுத்து true அல்லது false என்பதைத் திருப்பித் தர வழக்கமான கோவையின் test() முறையைப் பயன்படுத்தலாம்.

var pattern = /you/;
console.log(pattern.test("How are you?")); //true

6.7. ஜாவாஸ்கிரிப்டில் கரியிங் (Currying) என்றால் என்ன?

பதில்: ஜாவாஸ்கிரிப்டில் கரியிங் பல வாதங்களைக் (arguments) கொண்ட செயல்பாட்டை (function) ஒரு ஒற்றை வாதத்தை எடுக்கும் செயல்பாடுகளின் உள்ளமைக்கப்பட்ட (nested) தொடராக மாற்றுகிறது. ஒரே மாறியை (variable) பலமுறை கடந்து செல்வதைத் தவிர்க்க கரியிங் உங்களுக்கு உதவுகிறது, மேலும் உயர் வரிசைச் செயல்பாட்டை (higher order function) உருவாக்க இது உங்களுக்கு உதவுகிறது.

அதாவது, ஒரு செயல்பாடு அழைப்பை (function call) sum(1,2,3) லிருந்து sum(1)(2)(3) என மாற்றும்போது.

ஒரு செயல்பாடு எடுக்கும் வாதங்களின் (arguments) எண்ணிக்கை ஆரிட்டி (arity) என்றும் அழைக்கப்படுகிறது.

function sum(a, b) {
    // do something
}
function _sum(a, b, c) {
    // do something
}

sum செயல்பாடு இரண்டு வாதங்களை (arguments) (இரண்டு ஆரிட்டி செயல்பாடு) எடுக்கிறது மற்றும் _sum மூன்று வாதங்களை (மூன்று ஆரிட்டி செயல்பாடு) எடுக்கிறது.

கரியிங் செய்யப்பட்ட (Curried) செயல்பாடுகள் க்ளோஷர்களைச் சங்கிலி (chaining) மூலமாகவும் அவற்றின் உள் செயல்பாடுகளை ஒரே நேரத்தில் வரையறுத்து உடனடியாகத் திருப்பித் தருவதன் மூலமும் கட்டமைக்கப்படுகின்றன.

7. தற்காலிக டெட் ஸோன் (Temporal Dead Zone)

7.1. ES6 இல் டெம்போரல் டெட் ஸோன் (Temporal Dead Zone) என்றால் என்ன?

பதில்: ES6 இல் let மற்றும் const ஹொயிஸ்ட் (hoist) செய்யப்படுகின்றன (var, class மற்றும் function போன்றவை), ஆனால் ஸ்கோப்பிற்குள் நுழைவதற்கும் அறிவிக்கப்படுவதற்கும் இடையே ஒரு கால அவகாசம் உள்ளது, அங்கு அவற்றை அணுக முடியாது. இந்தக் கால அவகாசமே தற்காலிக டெட் ஸோன் (TDZ - temporal dead zone) ஆகும்.

//console.log(aLet)  // would throw ReferenceError 
let aLet; 
console.log(aLet); // undefined 
aLet = 10; 
console.log(aLet); // 10

7.2. ஜாவாஸ்கிரிப்டில் ட்ரூத்தி (Truthy) மற்றும் ஃபால்சி (Falsy) மதிப்புகள் என்றால் என்ன?

பதில்: ஜாவாஸ்கிரிப்டில், "ட்ரூத்தி (truthy)" மற்றும் "ஃபால்சி (falsy)" என்பது பூலியன் சூழல்களில் (Boolean contexts) நிபந்தனைகள் (conditions), சுழல்கள் (loops) போன்ற மதிப்புகள் எவ்வாறு மதிப்பிடப்படுகின்றன என்பதை விவரிக்கப் பயன்படுத்தப்படும் சொற்கள். நிபந்தனை தர்க்கத்துடன் (conditional logic) வேலை செய்யும் போது உண்மையான (truthy) மற்றும் தவறான (falsy) மதிப்புகளைப் புரிந்துகொள்வது முக்கியமானது.

ஃபால்சி மதிப்புகள் (Falsy Values):

false: பூலியன் மதிப்பு false.
0: எண் (numeric) மதிப்பு பூஜ்ஜியம்.
"": வெற்றுச் சரம் (empty string).
null: பொருளின் இல்லாமையைக் குறிக்கும் ஒரு சிறப்பு மதிப்பு (special value).
undefined: மதிப்பு ஒதுக்கப்படாத மாறி (variable).
NaN: "எண் அல்ல (Not-a-Number)" என்பதைக் குறிக்கிறது மற்றும் தவறான எண்ணைக் (invalid number) குறிக்கிறது.
இந்த மதிப்புகளில் ஏதேனும் பூலியன் (Boolean) சூழலில் பயன்படுத்தப்படும்போது, அவை "தவறானவை (falsy)" என்று கருதப்படுகின்றன, அதாவது அவை தவறு (false) என்பதற்குச் சமமாகக் கருதப்படுகின்றன.

ஃபால்சி மதிப்புகளின் எடுத்துக்காட்டுகள்:

if (false) {
    // This code block won't execute because false is falsy.
}

if (0) {
    // This code block won't execute because 0 is falsy.
}

if ("" === false) {
    // This comparison is true because an empty string is falsy.
}

if (null) {
    // This code block won't execute because null is falsy.
}

if (undefined) {
    // This code block won't execute because undefined is falsy.
}

if (NaN) {
    // This code block won't execute because NaN is falsy.
}

ட்ரூத்தி மதிப்புகள் (Truthy Values):

ஜாவாஸ்கிரிப்டில் வெளிப்படையாகத் "தவறானது (falsy)" அல்லாத எந்த மதிப்பும் "உண்மையானது (truthy)" என்று கருதப்படுகிறது. பூலியன் சூழல்களில் (Boolean contexts) இந்த மதிப்புகள் உண்மை (true) என்பதற்குச் சமமாகக் கருதப்படுகின்றன.

ட்ரூத்தி (truth) மதிப்புகளின் எடுத்துக்காட்டு:

if (true) {
    // This code block will execute because true is truthy.
}

if (42) {
    // This code block will execute because 42 is truthy.
}

if ("Hello") {
    // This code block will execute because a non-empty string is truthy.
}

if ({} === true) {
    // This comparison is false because an empty object is truthy but not equal to true.
}

if ([] === true) {
    // This comparison is false because an empty array is truthy but not equal to true.
}

உண்மையான (truthy) மற்றும் தவறான (falsy) மதிப்புகளைப் புரிந்துகொள்வது, மிகவும் சுருக்கமான மற்றும் வெளிப்படையான குறியீட்டை (expressive code) எழுத அனுமதிக்கிறது, குறிப்பாக நிபந்தனை தர்க்கத்தைக் (conditional logic) கையாளும் போது. நிபந்தனைகளை மதிப்பிடும்போதும் (evaluating) மற்றும் இரண்டு மதிப்புகள் அல்லது செயல்களுக்கு இடையே தேர்வு செய்யும்போதும் சிறிய மற்றும் படிக்கக்கூடிய குறியீட்டை (readable code) எழுத இந்த நடத்தையை நாம் பயன்படுத்தலாம்.

8. வகுப்புகள் (Classes)

8.1. ஜாவாஸ்கிரிப்ட் வகுப்புகள் (classes) என்றால் என்ன?

பதில்: வகுப்புகள் பொருள்களை (objects) உருவாக்குவதற்கான வார்ப்புருக்கள் (templates). அவை தரவையும் (data) தரவுடன் செயல்படும் தர்க்கத்தையும் (logic) இணைக்கின்றன (encapsulate).

8.2. வகுப்பு உறுப்பினர்கள் (class members) என்றால் என்ன?

பதில்: வகுப்பு உறுப்பினர்கள் என்பது ஒரு வகுப்பிற்குள் (class) உள்ள முறைகள் (methods) மற்றும் புலங்களைக் (fields) குறிக்கிறது.

i. முறைகள் (Methods)
- வகுப்பிற்குள் (class) வரையறுக்கப்பட்ட செயல்பாடுகள் (Functions).
- அவர்கள் புலங்களில் (fields) செயல்பட முடியும் மற்றும் தரவுடன் செயல்களைச் செய்ய முடியும்.
- அவர்கள் வகுப்பின் நடத்தையை (behavior) வரையறுக்கிறார்கள்.
ii. புலங்கள் (Fields)
- வகுப்பிற்குள் (class) வரையறுக்கப்பட்ட மாறிகள் (Variables).
- அவர்கள் கிளாஸ் இன்ஸ்டன்ஸ்களுக்கு (class instance) குறிப்பிட்ட தரவை வைத்திருக்கிறார்கள்.
- அவை வகுப்பின் நிலையை (state) வரையறுக்கின்றன.

8.3. ஜாவாஸ்கிரிப்டில் அணுகல் மாற்றிகளின் (access modifiers) வகைகள் மற்றும் அவற்றின் நோக்கத்தை விளக்குங்கள்

பதில்: தகவலை என்காப்சுலேட் (encapsulate) செய்யப் பயன்படுத்தப்படும் மூன்று வகையான அணுகல் மாற்றிகள் (access modifiers) உள்ளன.

பொது (Public)
- எங்கிருந்தும் அணுகலாம்.
தனியார் (Private)
- # குறியீட்டுடன் உறுப்பினர்களை முன்னொட்டுவதன் மூலம் (prefixing) குறிக்கப்படுகிறது.
- நிகழ்வுகள் (instances) அல்லது குழந்தை (child) வகுப்புகளிலிருந்து அணுக முடியாது.
- வகுப்பிற்குள்ளேயே (class itself) கிடைக்கும்.
- தகவலை மறைக்கப் பயன்படுகிறது.
பாதுகாக்கப்பட்டது (Protected)
- _ குறியீட்டுடன் உறுப்பினர்களை முன்னொட்டுவதன் மூலம் குறிக்கப்படுகிறது.
- வகுப்பிற்குள் இருந்தும் அதிலிருந்து மரபுரிமையாக (inherits) வரும் எந்த வகுப்பிலிருந்தும் அணுகலாம்.
- வகுப்புகளுக்கு இடையே நிலையைப் (state) பகிர்வதற்குப் பயனுள்ளதாக இருக்கும்.

8.4. வகுப்புப் பண்புகள் (class properties) யாவை?

பதில்: பண்புகள் (Properties) என்பது ஒரு வகுப்பிற்குள் உள்ள பெறுபவர் (getter) மற்றும் அமைப்பவரைக் (setter) குறிக்கிறது, இது ஒரு வகுப்பின் புலங்களுக்கான (fields) அணுகலைக் கட்டுப்படுத்த ஒரு வழியை வழங்குகிறது. பெறுபவர் (getter) மற்றும் அமைப்பவர் (setter) என்பவை ஒரு செயல்பாடு (function) அணுகப்படும்போது அழைக்கப்படும் பண்புப் பிணைப்புகள் (property bindings) ஆகும்.

i. கெட்டர் (Getter)
- கெட்டர் என்பது ஒரு புலத்தின் (field) மதிப்பைப் பெறும் முறையாகும்.
- இது சரியாகப் பூஜ்ஜிய அளவுருக்களைக் (parameters) கொண்டிருக்க வேண்டும்.
- இது ஒரு மதிப்பை (value) வழங்க வேண்டும்.
- இது get முக்கியச்சொல்லைப் (keyword) பயன்படுத்தி வரையறுக்கப்படுகிறது.
ii. செட்டர் (Setter)
- செட்டர் என்பது ஒரு புலத்தின் (field) மதிப்பை அமைக்கும் முறையாகும்.
- இது சரியாக ஒரு அளவுருவைக் (parameter) கொண்டிருக்க வேண்டும்.
- இது set முக்கியச்சொல்லைப் (keyword) பயன்படுத்தி வரையறுக்கப்படுகிறது.

சில குறிப்பிட்ட புலங்களை (fields) ஒரு குறிப்பிட்ட வழியில் மட்டுமே அணுக முடியும் அல்லது மாற்றியமைக்க முடியும் என்பதை உறுதிப்படுத்த தரவை என்காப்சுலேட் (encapsulate) செய்ய அவை பயன்படுத்தப்படுகின்றன.

கெட்டர்கள் (getters) மற்றும் செட்டர்களைப் (setters) பயன்படுத்தி என்காப்சுலேஷனின் (encapsulation) எடுத்துக்காட்டு:

  class Task {
    #id;
    #description;

    constructor(id, description, ) {
      //  Use setters instead of directly modifying the private fields
      this.id = id;
      this.description = description;
    }

    //  Use getters to read the values
    get id() {
      return this.#id;
    }

    //  ...

    //  Use setters to validate data before writing
    set id(id) {
      //  ...validate new ID
      this.#id = id;
    }

    //  ...
  }

8.5. வகுப்பு கன்ஸ்ட்ரக்டர்களை (class constructors) விளக்குக

பதில்: கன்ஸ்ட்ரக்டர் என்பது அந்த வகுப்பின் துவக்கத்தில் (initialization) அழைக்கப்பட்ட ஒரு வகுப்பின் (class) சிறப்பு முறையாகும். பொருளின் பண்புகளைத் துவக்குவதற்கும் பொருள் (object) உருவாக்கப்படும்போது தேவையான அமைப்பைச் (setup) செய்வதற்கும் இது பயன்படுகிறது.

i. அறிவிப்பு (Declaration)
- கன்ஸ்ட்ரக்டர் முறையானது கிளாஸ் பாடிக்குள் (class body) constructor முக்கியச்சொல்லைப் (keyword) பயன்படுத்தி அறிவிக்கப்படுகிறது.
- ஒவ்வொரு வகுப்பிலும் ஒரு கன்ஸ்ட்ரக்டர் முறை மட்டுமே இருக்கும்.
- கன்ஸ்ட்ரக்டர் ஒரு ஒத்திசைவற்ற முறையாக (async method) இருக்க முடியாது.
- கன்ஸ்ட்ரக்டர் ஒரு தனிப்பட்ட முறையாக (private method) இருக்க முடியாது.
ii. துவக்கம் (Initialization)
- நிகழ்வின் பண்புகளைத் (instance's properties) துவக்கப் பயன்படும் அளவுருக்களைக் (parameters) கன்ஸ்ட்ரக்டர் ஏற்க முடியும்.
- பண்புகளுக்கு (properties) மதிப்புகளை ஒதுக்குவதன் மூலம் இது ஆரம்ப நிலையை (initial state) அமைக்கிறது.
iii. பரம்பரை (Inheritance)
- பெறப்பட்ட வகுப்புகளில் (derived classes - மற்றொரு வகுப்பை நீட்டிக்கும் வகுப்புகள்), பெற்றோர் (parent) வகுப்பின் கன்ஸ்ட்ரக்டரை அழைக்க குழந்தையின் (child) கன்ஸ்ட்ரக்டருக்குள் super முக்கியச்சொல் (keyword) பயன்படுத்தப்படுகிறது.
- பெறப்பட்ட (derived) வகுப்பின் கன்ஸ்ட்ரக்டரில் எந்தப் பண்புகளையும் அணுகுவதற்கு முன் super அழைப்பு செய்யப்பட வேண்டும். கன்ஸ்ட்ரக்டர் பரம்பரையின் (constructor inheritance) எடுத்துக்காட்டு:
```
class Animal {
    constructor(species) {
        this.species = species;
    }
}

class Person extends Animal {
    constructor(name) {
        super("Human"); //  Call the parent class constructor
        this.name = name;
    } 
}
```
iv. இயல்புநிலை கன்ஸ்ட்ரக்டர் (Default constructor) - கன்ஸ்ட்ரக்டர் வெளிப்படையாக அறிவிக்கப்படவில்லை என்றால், ஒரு இயல்புநிலை கன்ஸ்ட்ரக்டர் வகுப்பிற்குக் கொடுக்கப்படும்.
- அடிப்படை வகுப்பு (Base class) - வகுப்பு வேறு எந்த வகுப்பையும் நீட்டிக்கவில்லை (extend) என்றால், அதற்கு ஒரு இயல்புநிலைக் கன்ஸ்ட்ரக்டர் ஒதுக்கப்படும்:
```
constructor() {}
```
- குழந்தை வகுப்பு (Child class) - ஒரு வகுப்பு மற்றொரு வகுப்பை நீட்டித்தால் (extends), அதன் கன்ஸ்ட்ரக்டரைப் பெற்றிருக்கும் (inherit)
```
class Vehicle {
  constructor(type) {
    this.type = type;
  }

  move() {
    return `The ${this.type} is moving`;
  }
}

class Car extends Vehicle {
  #model;

  set model(model) {
    this.#model = model;
  }

  drive() {
    `Driving ${this.#model}`;
  }
}
```
  கன்ஸ்ட்ரக்டர் வெளிப்படையாக (explicitly) அறிவிக்கப்படவில்லை என்றாலும், Car வகுப்பு அதை Vehicle வகுப்பிலிருந்து பெறுகிறது:
```
constructor(type) {
  super(type);
}
```

8.6. நிலையான உறுப்பினர்கள் (Static members) vs நிகழ்வு உறுப்பினர்கள் (Instance members)

பதில்: முன்னிருப்பாக, நாம் ஒரு வகுப்பிற்குள் (class) வரையறுக்கும் பண்புகள் (properties) மற்றும் முறைகள் (methods) நாம் உருவாக்கும் வகுப்பின் ஒவ்வொரு நிகழ்விற்கும் (instance) சொந்தமானது. நாம் வகுப்பிற்கு உறுப்பினர்களையும் ஒதுக்கலாம். இத்தகைய உறுப்பினர்கள் நிலையானவை (static) என்று அழைக்கப்படுகின்றன மற்றும் அவை static முக்கியச்சொல்லைப் பயன்படுத்தி அறிவிக்கப்படுகின்றன. வகுப்பின் நிகழ்வுகளில் (instances) அவற்றை நேரடியாக அணுக முடியாது.