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

1. வரலாறு மற்றும் மாறிகளை வரையறுத்தல் (History and Defining Variables).

1.1. ஜாவாஸ்கிரிப்ட் என்றால் என்ன?

பதில்: ஜாவாஸ்கிரிப்ட் என்பது உயர்மட்ட, விளக்கப்பட்ட நிரலாக்க மொழி (high-level, interpreted programming language), இது வலைத்தளங்களுக்கு ஊடாடும் (interactivity) மற்றும் மாறும் நடத்தையைச் (dynamic behavior) சேர்க்க இணைய மேம்பாட்டிற்குப் பரவலாகப் பயன்படுத்தப்படுகிறது.

1.2. ஜாவாஸ்கிரிப்டை உருவாக்கியவர்/உருவாக்கியவர் யார்?

பதில்: ஜாவாஸ்கிரிப்ட் Netscape Communications Corporation இல் பணிபுரிந்தபோது Brendan Eich என்பவரால் உருவாக்கப்பட்டது. அவர் மே 1995 இல் வெறும் பத்து நாட்களில் மொழியை உருவாக்கினார். ஜாவாஸ்கிரிப்ட் முதலில் "Mocha" என்று அழைக்கப்பட்டது, ஆனால் பின்னர் "LiveScript" என மறுபெயரிடப்பட்டது, இறுதியில் Sun Microsystems (இப்போது Oracle Corporation) உடனான சந்தைப்படுத்தல் ஒத்துழைப்பின் (marketing collaboration) ஒரு பகுதியாக "JavaScript" எனப் பெயரிடப்பட்டது, அந்த நேரத்தில் Java எனப்படும் நிரலாக்க மொழிப் பிரபலமடைந்து வந்தது. பெயரில் ஒற்றுமை இருந்தபோதிலும், ஜாவாஸ்கிரிப்ட் மற்றும் ஜாவா ஆகியவை முற்றிலும் வேறுபட்ட நிரலாக்க மொழிகளாகும், அவை தனித்துவமான நோக்கங்கள் மற்றும் பண்புகளுடன் உள்ளன.

1.3. ஜாவாஸ்கிரிப்டில் ஒரு மாறியை (variable) எவ்வாறு அறிவிப்பது?

பதில்: var, let, அல்லது const ஐப் பயன்படுத்தி நீங்கள் ஒரு மாறியை அறிவிக்கலாம்:

  • var (செயல்பாட்டு-ஸ்கோப்டு - function-scoped)
  • let (பிளாக்-ஸ்கோப்டு - block-scoped)
  • const (பிளாக்-ஸ்கோப்டு, மாறிலிகளுக்கு - for constants)

1.4. let, var, மற்றும் const ஆகியவற்றுக்கு இடையேயான வேறுபாடு என்ன?

பதில்:

  • var என்பது செயல்பாட்டு-ஸ்கோப்டு, அதே சமயம் let மற்றும் const ஆகியவை பிளாக்-ஸ்கோப்டு.
  • let மாறி மறுஒதுக்கீட்டை (reassignment) அனுமதிக்கிறது, அதே சமயம் const மாறிலிகளுக்குப் (constants) பயன்படுத்தப்படுகிறது.
  • var உடன் அறிவிக்கப்பட்ட மாறிகள் ஹொயிஸ்ட் (hoisted) செய்யப்படுகின்றன, அதேசமயம் let மற்றும் const ஹொயிஸ்ட் செய்யப்படவில்லை.

1.5. ஜாவாஸ்கிரிப்ட் ஒரு நிலையான தட்டச்சு செய்யப்பட்டதா (statically typed) அல்லது மாறும் தட்டச்சு செய்யப்பட்ட மொழியா (dynamically typed)?

பதில்: ஜாவாஸ்கிரிப்ட் என்பது மாறும் தட்டச்சு செய்யப்பட்ட (dynamically typed) மொழியாகும். மாறும் வகையில் தட்டச்சு செய்யப்பட்ட மொழியில், ஒரு மாறியின் வகை (type) செயல்பாட்டு நேரத்தில் (run-time) சோதிக்கப்படுகிறது, இது நிலையான தட்டச்சு செய்யப்பட்ட மொழிக்கு மாறாக, ஒரு மாறியின் வகை தொகுக்கும் நேரத்தில் (compile-time) சோதிக்கப்படுகிறது.

அம்சம் (Feature) நிலையான தட்டச்சு (Static Typing) மாறும் தட்டச்சு (Dynamic Typing)
மாறிகள் வகைகளைக் கொண்டுள்ளன ஆம் இல்லை
மதிப்புகள் வகைகளைக் கொண்டுள்ளன ஆம் ஆம்
மாறிகள் வகையை மாற்றலாம் இல்லை ஆம்
மாறிகள் வகையைப் பெரிதும் மாற்றலாம் இல்லை ஆம்

ஜாவாஸ்கிரிப்ட் ஒரு தளர்வாக(மாறும்) (loosely(dynamically)) தட்டச்சு செய்யப்பட்ட மொழியாக இருப்பதால், JS இல் உள்ள மாறிகள் எந்த வகையுடனும் தொடர்புபடுத்தப்படவில்லை. ஒரு மாறி எந்தத் தரவு வகையின் மதிப்பையும் வைத்திருக்க முடியும்.

எடுத்துக்காட்டாக, எண் (number) வகையை ஒதுக்கப்பட்ட ஒரு மாறியைச் சரம் (string) வகைக்கு மாற்றலாம்:

var a = 23;
var a = "Hello World!";

1.6. ஜாவாஸ்கிரிப்டில் பிழைகளின் (errors) வகைகள் யாவை?

பதில்: ஜாவாஸ்கிரிப்டில் ஏழு வகையான பிழைகள் உள்ளன.

  1. தொடரியல் பிழை (Syntax error) - முன்வரையறுக்கப்பட்ட தொடரியலை (predefined syntax) நீங்கள் தவறாகப் பயன்படுத்தும்போது பிழை ஏற்படுகிறது.
    const func = () =>
console.log(hello)
}
  2. குறிப்புப் பிழை (Reference Error) - மாறி குறிப்பைக் (variable reference) கண்டறிய முடியாத அல்லது அறிவிக்கப்படாத நிலையில், குறிப்புப் பிழை ஏற்படும்.
    console.log(x);
  3. வகை பிழை (Type Error) - ஒரு மதிப்பு அதன் தரவு வகையின் நோக்கத்திற்கு (scope) வெளியே பயன்படுத்தப்படும்போது பிழை ஏற்படுகிறது.
    let num = 15;
console.log(num.split(""));
  4. மதிப்பீட்டுப் பிழை (Evaluation Error) - தற்போதைய ஜாவாஸ்கிரிப்ட் இயந்திரங்கள் (engines) மற்றும் EcmaScript விவரக்குறிப்புகள் (specifications) இந்தப் பிழையை எறிவதில்லை (throw). இருப்பினும், பின்தங்கிய இணக்கத்தன்மைக்கு (backward compatibility) இது இன்னும் கிடைக்கிறது. பின்வரும் குறியீட்டுத் தொகுதியில் (code block) காட்டப்பட்டுள்ளபடி, eval() பின்தங்கிய செயல்பாடு (backward function) பயன்படுத்தப்படும்போது பிழை அழைக்கப்படுகிறது
try{
  throw new EvalError("'Throws an error'")
}catch(error){
  console.log(error.name, error.message)
}
  1. வரம்புப் பிழை (RangeError) - எதிர்பார்க்கப்படும் மதிப்புகளின் வரம்பு தேவைப்படும்போது பிழை உள்ளது.
const checkRange = (num)=>{
  if (num < 30) throw new RangeError("Wrong number");
  return true
}

checkRange(20);
  1. URI பிழை (URI Error) - URI செயல்பாட்டில் தவறான எழுத்து(கள்) பயன்படுத்தப்பட்டால், பிழையானது uri பிழை என அழைக்கப்படும்
    console.log(decodeURI("https://www.educative.io/shoteditor"))
console.log(decodeURI("%sdfk"));
  2. உள் பிழை (Internal Error) - JS இயந்திரத்தில் (engine), அதிகத் தரவு இருக்கும்போது மற்றும் ஸ்டாக் (stack) அதன் முக்கியமான அளவைத் (critical size) தாண்டும்போது இந்தப் பிழை அடிக்கடி நிகழ்கிறது. அதிக மறுநிகழ்வு வடிவங்கள் (recursion patterns), ஸ்விட்ச் கேஸ்கள் (switch cases) போன்றவை இருக்கும்போது, JS இயந்திரம் அதிகமாகிறது.
    switch(condition) {
case 1:
...
break
case 2:
...
break
case 3:
...
break
case 4:
...
break
case 5:
...
break
case 6:
...
break
case 7:
...
break
... up to 500 cases
}

1.7. ஜாவாஸ்கிரிப்ட்டின் சில நன்மைகளைக் குறிப்பிடவும்.

பதில்: ஜாவாஸ்கிரிப்டில் பல நன்மைகள் உள்ளன. அவற்றில் சில

  • ஜாவாஸ்கிரிப்ட் கிளையண்ட் பக்கத்திலும் (client-side) சர்வர் பக்கத்திலும் (server-side) செயல்படுத்தப்படுகிறது. நீங்கள் படித்துப் பயன்படுத்தக்கூடிய பல்வேறு Frontend Frameworks உள்ளன. இருப்பினும், நீங்கள் பின்தளத்தில் (backend) ஜாவாஸ்கிரிப்டைப் பயன்படுத்த விரும்பினால், நீங்கள் NodeJS ஐக் கற்றுக்கொள்ள வேண்டும். பின்தளத்தில் பயன்படுத்தப்படக்கூடிய ஒரே ஜாவாஸ்கிரிப்ட் கட்டமைப்பு இதுவாகும்.
  • ஜாவாஸ்கிரிப்ட் கற்றுக்கொள்வதற்கு எளிய மொழியாகும்.
  • ஜாவாஸ்கிரிப்ட் காரணமாக இணையப் பக்கங்கள் (Web pages) இப்போது அதிகச் செயல்பாட்டைக் (functionality) கொண்டுள்ளன.
  • இறுதிப் பயனருக்கு, ஜாவாஸ்கிரிப்ட் மிகவும் விரைவானது.

1.8. ஜாவாஸ்கிரிப்டில் this முக்கியச் சொல் (keyword) என்றால் என்ன?

பதில்: பொருளின் பண்புகளுக்கு (object properties) மதிப்புகளை (values) ஒதுக்க தற்போதைய பொருளை (current object) ஒரு கன்ஸ்ட்ரக்டராக (constructor) அழைக்க ஜாவாஸ்கிரிப்டில் this என்ற முக்கியச் சொல் பயன்படுத்தப்படுகிறது.

2. செயல்பாடுகள் (Functions)

2.1. ஜாவாஸ்கிரிப்டில் செயல்பாட்டை எவ்வாறு உருவாக்குவது?

பதில்: function முக்கியச் சொல் அல்லது அம்பு செயல்பாடுகளை (arrow functions) (=>) பயன்படுத்தி நீங்கள் ஒரு செயல்பாட்டை உருவாக்கலாம்: எடுத்துக்காட்டு:

function myFunction() {
  // Function body
}

const myArrowFunction = () => {
  // Function body
};

2.2. கால்பேக்குகள் (Callbacks) என்றால் என்ன?

பதில்: கால்பேக் (callback) என்பது மற்றொரு செயல்பாடு (function) செயல்படுத்தப்பட்ட பிறகு செயல்படுத்தப்படும் ஒரு செயல்பாடாகும். ஜாவாஸ்கிரிப்டில், செயல்பாடுகள் முதல் தரக் குடிமக்களாகக் (first-class citizens) கருதப்படுகின்றன, அவை மற்றொரு செயல்பாட்டின் வாதமாகப் (argument) பயன்படுத்தப்படலாம், மற்றொரு செயல்பாட்டினால் திருப்பித் தரப்படலாம் மற்றும் ஒரு பொருளின் பண்பாகப் (property) பயன்படுத்தப்படலாம்.

மற்றொரு செயல்பாட்டிற்கு ஒரு வாதமாகப் பயன்படுத்தப்படும் செயல்பாடுகள் கால்பேக் செயல்பாடுகள் என அழைக்கப்படுகின்றன.

எடுத்துக்காட்டு:

function divideByHalf(sum) {
  console.log(Math.floor(sum / 2));
}

function multiplyBy2(sum) {
  console.log(sum * 2);
}

function operationOnSum(num1, num2, operation) {
  var sum = num1 + num2;
  operation(sum);
}

operationOnSum(3, 3, divideByHalf); // Outputs 3

operationOnSum(5, 5, multiplyBy2); // Outputs 20
  • மேலே உள்ள குறியீட்டில், இரண்டு எண்களின் கூட்டுத்தொகையில் கணிதச் செயல்பாடுகளைச் செய்து வருகிறோம். operationOnSum செயல்பாடு 3 வாதங்களை (arguments) எடுத்துக்கொள்கிறது, முதல் எண், இரண்டாவது எண் மற்றும் அவற்றின் கூட்டுத்தொகையில் (கால்பேக்) செய்யப்படும் செயல்பாடு.
  • divideByHalf மற்றும் multiplyBy2 ஆகிய இரண்டு செயல்பாடுகளும் மேலே உள்ள குறியீட்டில் கால்பேக் செயல்பாடுகளாகப் பயன்படுத்தப்படுகின்றன.
  • operationOnSum செயல்பாடு செயல்படுத்தப்பட்ட பின்னரே இந்தக் கால்பேக் செயல்பாடுகள் செயல்படுத்தப்படும்.
  • எனவே, கால்பேக் என்பது மற்றொரு செயல்பாடு செயல்படுத்தப்பட்ட பிறகு செயல்படுத்தப்படும் ஒரு செயல்பாடாகும்.

2.3. ஜாவாஸ்கிரிப்டில் ஸ்கோப் (Scope) மற்றும் ஸ்கோப் செயினை (Scope Chain) விளக்குங்கள்.

பதில்: JS இல் ஸ்கோப் ஒருவரின் குறியீட்டின் பல்வேறு பகுதிகளில் மாறிகள் (variables) மற்றும் செயல்பாடுகளின் (functions) அணுகலைத் (accessibility) தீர்மானிக்கிறது.

பொதுவான விதிமுறைகளில், குறியீட்டின் குறிப்பிட்ட பகுதியில், நாம் அணுகக்கூடிய அல்லது அணுக முடியாத மாறிகள் மற்றும் செயல்பாடுகள் என்ன என்பதை ஸ்கோப் நமக்குத் தெரியப்படுத்தும்.

JS இல் மூன்று வகையான ஸ்கோப்கள் உள்ளன:

உலகளாவிய ஸ்கோப் (Global Scope): உலகளாவிய பெயர்வெளியில் (global namespace) அறிவிக்கப்பட்டுள்ள மாறிகள் அல்லது செயல்பாடுகள் உலகளாவிய ஸ்கோப்பைக் கொண்டுள்ளன, அதாவது உலகளாவிய ஸ்கோப்பைக் கொண்ட அனைத்து மாறிகள் மற்றும் செயல்பாடுகளைக் குறியீட்டிற்குள் எங்கிருந்தும் அணுகலாம்.

var globalVariable = "Hello world";

function sendMessage() {
  return globalVariable; // can access globalVariable since it's written in global space
}
function sendMessage2() {
  return sendMessage(); // Can access sendMessage function since it's written in global space
}
sendMessage2(); // Returns “Hello world”

செயல்பாட்டு ஸ்கோப் (Function Scope): ஒரு செயல்பாட்டிற்குள் அறிவிக்கப்பட்ட ஏதேனும் மாறிகள் அல்லது செயல்பாடுகள் உள்ளூர்/செயல்பாட்டு ஸ்கோப்பைக் (local/function scope) கொண்டுள்ளன, அதாவது ஒரு செயல்பாட்டிற்குள் அறிவிக்கப்பட்ட அனைத்து மாறிகள் மற்றும் செயல்பாடுகள் செயல்பாட்டிற்குள் இருந்து அணுகப்படலாம் மற்றும் அதற்கு வெளியே இல்லை.

function awesomeFunction() {
  var a = 2;

  var multiplyBy2 = function () {
    console.log(a * 2); // Can access variable "a" since a and multiplyBy2 both are written inside the same function
  };
}
console.log(a); // Throws reference error since a is written in local scope and cannot be accessed outside

multiplyBy2(); // Throws reference error since multiplyBy2 is written in local scope

பிளாக் ஸ்கோப் (Block Scope): பிளாக் ஸ்கோப் என்பது let மற்றும் const ஐப் பயன்படுத்தி அறிவிக்கப்பட்ட மாறிகளுடன் தொடர்புடையது. var உடன் அறிவிக்கப்பட்ட மாறிகளுக்கு பிளாக் ஸ்கோப் இல்லை. ஒரு பிளாக்கிற்குள் { } அறிவிக்கப்பட்ட எந்த மாறியும் அந்த பிளாக்கிற்குள் மட்டுமே அணுகப்படும் மற்றும் அதற்கு வெளியே அணுக முடியாது என்று பிளாக் ஸ்கோப் சொல்கிறது.

{
  let x = 45;
}

console.log(x); // Gives reference error since x cannot be accessed outside of the block

for (let i = 0; i < 2; i++) {
  // do something
}

console.log(i); // Gives reference error since i cannot be accessed outside of the for loop block

ஸ்கோப் செயின் (Scope Chain): ஜாவாஸ்கிரிப்ட் இயந்திரம் மாறிகளைக் கண்டறிய ஸ்கோப்பைப் பயன்படுத்துகிறது. ஒரு உதாரணத்தைப் பயன்படுத்திப் புரிந்துகொள்வோம்:

var y = 24;

function favFunction() {
  var x = 667;
  var anotherFavFunction = function () {
    console.log(x); // Does not find x inside anotherFavFunction, so looks for variable inside favFunction, outputs 667
  };

  var yetAnotherFavFunction = function () {
    console.log(y); // Does not find y inside yetAnotherFavFunction, so looks for variable inside favFunction and does not find it, so looks for variable in global scope, finds it and outputs 24
  };

  anotherFavFunction();
  yetAnotherFavFunction();
}
favFunction();

மேலே உள்ள குறியீட்டில் நீங்கள் பார்க்கிறபடி, ஜாவாஸ்கிரிப்ட் இயந்திரம் உள்ளூர் ஸ்கோப்பில் மாறியைக் கண்டுபிடிக்கவில்லை என்றால், அது வெளி ஸ்கோப்பில் (outer scope) மாறியைச் சரிபார்க்க முயற்சிக்கிறது. வெளி ஸ்கோப்பில் மாறி இல்லை என்றால், அது உலகளாவிய ஸ்கோப்பில் (global scope) மாறியைக் கண்டறிய முயற்சிக்கிறது.

உலகளாவிய இடத்திலும் மாறியைக் காணவில்லை எனில், ஒரு குறிப்புப் பிழை (reference error) எறியப்படும்.

2.4. ஜாவாஸ்கிரிப்டில் உயர் வரிசை செயல்பாடுகளை (Higher Order Functions) விளக்குங்கள்.

பதில்: மற்றச் செயல்பாடுகளை வாதங்களாக (arguments) எடுத்துக்கொள்வதன் மூலம் அல்லது அவற்றைத் திருப்பி அனுப்புவதன் மூலம் (returning) செயல்படும் செயல்பாடுகள் உயர் வரிசை செயல்பாடுகள் எனப்படும்.

ஜாவாஸ்கிரிப்டில் செயல்பாடுகள் முதல்-தரக் குடிமக்களாக (first-class citizens) இருப்பதன் விளைவாக உயர் வரிசை செயல்பாடுகள் உள்ளன.

உயர் வரிசை செயல்பாடுகளின் எடுத்துக்காட்டுகள்:

function higherOrder(fn) {
  fn();
}

higherOrder(function () {
  console.log("Hello world");
});
function higherOrder2() {
  return function () {
    return "Do something";
  };
}
var x = higherOrder2();
x(); // Returns "Do something"

2.5. ஜாவாஸ்கிரிப்டில் செல்ஃப் இன்வோக்கிங் ஃபங்ஷன்ஸ் (Self Invoking Functions) என்றால் என்ன?

பதில்: கோரப்படாமல் (Without being requested), சுய-அழைப்பு (self-invoking) கோவை (expression) தானாகவே செயல்படுத்தப்படும் (தொடங்கப்படும்). ஒரு செயல்பாட்டுக் கோவை (function expression) தொடர்ந்து () இருந்தால், அது தானாகவே செயல்படுத்தப்படும். செயல்பாட்டு அறிவிப்பை (function declaration) தானாகவே செயல்படுத்த முடியாது.

பொதுவாக, நாங்கள் ஒரு செயல்பாட்டை அறிவித்து அதை அழைக்கிறோம், இருப்பினும், அநாமதேயச் செயல்பாடுகள் (anonymous functions) ஒரு செயல்பாட்டை விவரிக்கும் போது தானாகவே இயங்குவதற்குப் பயன்படுத்தப்படலாம், மேலும் அவை மீண்டும் அழைக்கப்படாது. மேலும் இந்த வகையான செயல்பாடுகளுக்குப் பெயர் இல்லை.

2.6. ஜாவாஸ்கிரிப்டில் exec() மற்றும் test() முறைகளுக்கு (methods) என்ன வித்தியாசம்?

பதில்: பின்வரும் புள்ளிகள் test() மற்றும் exec() முறைகளுக்கு இடையிலான வேறுபாடுகளைப் பற்றி விவாதிக்கின்றன.

  • test() மற்றும் exec() ஆகியவை ஜாவாஸ்கிரிப்டில் பயன்படுத்தப்படும் RegExp வெளிப்பாடு முறைகள் (expression methods).

  • ஒரு குறிப்பிட்ட வடிவத்திற்கான (pattern) சரத்தைத் (string) தேட நாங்கள் exec() ஐப் பயன்படுத்துவோம், அது அதைக் கண்டால், அது வடிவத்தை நேரடியாகத் திருப்பித் தரும்; இல்லையெனில், அது 'வெற்று (empty)' முடிவைத் தரும்.

  • குறிப்பிட்ட வடிவத்திற்கான சரத்தைக் கண்டறிய ஒரு test() ஐப் பயன்படுத்துவோம். கொடுக்கப்பட்ட உரையைக் கண்டறிந்தால் பூலியன் (Boolean) மதிப்பு true எனத் திருப்பித் தரும், இல்லையெனில், அது false எனத் திருப்பித் தரும்

2.7. செயல்பாட்டு அறிவிப்பு (Function declaration) மற்றும் செயல்பாட்டுக் கோவை (Function expression) ஆகியவற்றுக்கு இடையேயான வேறுபாடு என்ன?

பதில்: செயல்பாட்டு அறிவிப்பு மற்றும் செயல்பாட்டுக் கோவைக்கு இடையிலான வேறுபாடு பின்வருமாறு:

செயல்பாட்டு அறிவிப்பு (Function declaration):

  1. முக்கிய ஜாவாஸ்கிரிப்ட் குறியீட்டிற்குள் தனி அறிக்கையாக (statement) அறிவிக்கப்பட்டது.
  2. செயல்பாடு வரையறுக்கப்படுவதற்கு முன்பு அழைக்கப்படலாம்.
  3. சிறந்த குறியீடு வாசிப்புத்திறன் (code readability) மற்றும் சிறந்த குறியீடு அமைப்பை (code organization) வழங்குகிறது.

எடுத்துக்காட்டு:

function abc() {
    return 5;
}

செயல்பாட்டுக் கோவை (Function expression):

  1. ஒரு கோவையின் (expression) உள்ளே அல்லது வேறு ஏதேனும் கட்டமைப்பிற்குள் உருவாக்கப்பட்டது.
  2. செயலாக்கப் புள்ளி (execution point) அதை அடையும் போது உருவாக்கப்பட்டது; அதன் பிறகு மட்டுமே பயன்படுத்த முடியும்.
  3. செயல்பாட்டின் நிபந்தனை அறிவிப்பு (conditional declaration) தேவைப்படும்போது பயன்படுத்தப்படுகிறது.

எடுத்துக்காட்டு:

var a = function abc() {
    return 5;
}

2.8. ஜாவாஸ்கிரிப்டில் அம்பு செயல்பாடுகள் (arrow functions) என்ன?

பதில்: ஜாவாஸ்கிரிப்டில் செயல்பாடுகளை எழுதுவதற்கு அம்பு செயல்பாடுகள் (arrow functions) ஒரு குறுகிய மற்றும் சுருக்கமான வழியாகும். அம்பு செயல்பாட்டின் பொதுவான தொடரியல் (syntax) கீழே உள்ளபடி:

const helloWorld = () => {
  console.log("hello world!");
};

2.9. மதிப்பால் கடந்து (Passed by value) மற்றும் குறிப்பால் கடந்து (passed by reference) :

பதில்:

  • மதிப்பால் கடந்து (Passed By Values) என்பவை பழமையான தரவு வகைகள் (Primitive Data Types) ஆகும்.

    பின்வரும் உதாரணத்தைக் கவனியுங்கள்:

இங்கே, a=432 என்பது பழமையான தரவு வகையாகும், அதாவது ஆபரேட்டரால் ஒதுக்கப்பட்ட மதிப்பைக் (assigned value) கொண்ட எண் (number) வகை. var b=a குறியீடு செயல்படுத்தப்படும்போது, var a இன் மதிப்பானது var b க்கு நினைவகத்தில் (memory) புதிய இட ஒதுக்கீட்டை வழங்குவதன் மூலம் புதிய முகவரியைத் (address) திருப்பித் தருகிறது, இதனால் 'var b' புதிய இடத்தில் இயக்கப்படும்.

எடுத்துக்காட்டு:

var a = 432;
var b = a;

Passed_by_values_new

  • குறிப்புகளால் கடந்து (Passed by References) என்பவை பழமையானவை அல்லாத தரவு வகைகள் (Non-primitive Data Types).

பின்வரும் உதாரணத்தைக் கவனியுங்கள்:

1 வது மாறி பொருளின் (variable object) குறிப்பு (reference), அதாவது var obj, ஒதுக்கப்பட்ட ஆபரேட்டரின் (assigned operator) உதவியுடன் மற்றொரு மாறியின் இருப்பிடத்தின் வழியாக அனுப்பப்படுகிறது, அதாவது var obj2.

எடுத்துக்காட்டு: 

var obj = { name: "Raj", surname: "Sharma" };
var obj2 = obj;

3. தரவு வகைகள் மற்றும் ஆபரேட்டர் (Data Types and Operator)

3.1. ஜாவாஸ்கிரிப்டில் உள்ள வெவ்வேறு தரவு வகைகள் (data types) யாவை?

பதில்: ஜாவாஸ்கிரிப்டில் உள்ள வெவ்வேறு தரவு வகைகள் பின்வருமாறு:

  1. பழமையான வகைகள் (Primitive types)

    • சரம் (String) - இது எழுத்துகளின் (characters) தொடரைக் குறிக்கிறது மற்றும் மேற்கோள்களுடன் (quotes) எழுதப்பட்டுள்ளது. ஒற்றை (single) அல்லது இரட்டை (double) மேற்கோளைப் பயன்படுத்தி ஒரு சரத்தைக் குறிப்பிடலாம்.

      எடுத்துக்காட்டு (Example) :

      var str = "Vivek Singh Bisht"; //using double quotes
var str2 = "John Doe"; //using single quotes

    • எண் (Number) - இது ஒரு எண்ணைக் குறிக்கிறது மற்றும் தசமங்களுடன் (decimals) அல்லது தசமங்கள் இல்லாமல் எழுதப்படலாம்.

      எடுத்துக்காட்டு (Example) :

      var x = 3; //without decimal
var y = 3.6; //with decimal

    • BigInt - Number தரவு வகையின் வரம்பிற்கு (limitation) மேலான எண்களைச் சேமிக்க இந்தத் தரவு வகை பயன்படுத்தப்படுகிறது. இது பெரிய முழு எண்களைச் (large integers) சேமிக்க முடியும் மற்றும் ஒரு முழு எண் லிட்டரலுடன் (integer literal) "n" ஐச் சேர்ப்பதன் மூலம் குறிக்கப்படுகிறது.

      எடுத்துக்காட்டு (Example) :

      var bigInteger = 234567890123456789012345678901234567890;

    • பூலியன் (Boolean) - இது ஒரு தர்க்கரீதியான உட்பொருளைக் (logical entity) குறிக்கிறது மற்றும் இரண்டு மதிப்புகளை மட்டுமே கொண்டிருக்க முடியும்: true அல்லது false. நிபந்தனை சோதனைக்குச் (conditional testing) பூலியன்கள் பொதுவாகப் பயன்படுத்தப்படுகின்றன.

      எடுத்துக்காட்டு (Example) :

      var a = 2;
var b = 3;
var c = 2;
(a == b)(
  // returns false
  a == c
); //returns true

    • வரையறுக்கப்படாதது (Undefined) - ஒரு மாறி அறிவிக்கப்பட்டு ஆனால் ஒதுக்கப்படாமல் இருக்கும் போது, அது வரையறுக்கப்படாத (undefined) மதிப்பைக் கொண்டுள்ளது மற்றும் அதன் வகையும் வரையறுக்கப்படவில்லை.

      எடுத்துக்காட்டு (Example) :

      var x; // value of x is undefined
var y = undefined; // we can also set the value of a variable as undefined

    • வெற்று (Null) - இது இல்லாத (non-existent) அல்லது தவறான மதிப்பைக் குறிக்கிறது.

      எடுத்துக்காட்டு (Example) :

      var z = null;

    • சின்னம் (Symbol) - இது ஜாவாஸ்கிரிப்டின் ES6 பதிப்பில் அறிமுகப்படுத்தப்பட்ட ஒரு புதிய தரவு வகையாகும். அநாமதேய (anonymous) மற்றும் தனித்துவமான (unique) மதிப்பைச் சேமிக்க இது பயன்படுகிறது.

      எடுத்துக்காட்டு:

      var symbol1 = Symbol('symbol');
typeof of primitive types :
typeof "John Doe" // Returns "string"
typeof 3.14 // Returns "number"
typeof true // Returns "boolean"
typeof 234567890123456789012345678901234567890n // Returns bigint
typeof undefined // Returns "undefined"
typeof null // Returns "object" (kind of a bug in JavaScript)
typeof Symbol('symbol') // Returns Symbol 2. Non-primitive types

பழமையான தரவு வகைகள் (Primitive data types) ஒற்றை மதிப்பை மட்டுமே சேமிக்க முடியும். பல மற்றும் சிக்கலான மதிப்புகளைச் சேமிக்க, பழமையானவை அல்லாத (non-primitive) தரவு வகைகள் பயன்படுத்தப்படுகின்றன.

  1. பழமையானவை அல்லாத வகைகள் (Non-Primitive types)

    • பொருள் (Object) - தரவுகளின் தொகுப்பைச் (collection of data) சேமிக்கப் பயன்படுகிறது.

      எடுத்துக்காட்டு (Example):

      // Collection of data in key-value pairs
var obj1 = {
  x: 43,
  y: "Hello world!",
  z: function () {
    return this.x;
  },
};

    • வரிசை (Array)

      எடுத்துக்காட்டு:

      // Collection of data as an ordered list

var array1 = [5, "Hello", true, 4.1];

குறிப்பு- பழமையான தரவு வகை (primitive data type) அல்லாத எந்தத் தரவு வகையும், ஜாவாஸ்கிரிப்டில் பொருள் (Object) வகை என்பதை நினைவில் கொள்வது அவசியம்.

3.2 == மற்றும் === ஆபரேட்டர்களுக்கு (operators) இடையிலான வேறுபாடு.

பதில்: இரண்டும் ஒப்பீட்டு ஆபரேட்டர்கள் (comparison operators). இரண்டு ஆபரேட்டர்களுக்கும் உள்ள வித்தியாசம் என்னவென்றால், == என்பது மதிப்புகளை (values) ஒப்பிடப் பயன்படுத்தப்படுகிறது, அதே சமயம் === என்பது மதிப்புகள் மற்றும் வகைகள் (types) இரண்டையும் ஒப்பிடப் பயன்படுத்தப்படுகிறது.

எடுத்துக்காட்டு:

var x = 2;
var y = "2";
(x == y)(
  // Returns true since the value of both x and y is the same
  x === y
); // Returns false since the typeof x is "number" and typeof y is "string"

3.3. ஜாவாஸ்கிரிப்டில் NaN பண்பு (property) என்ன?

பதில்: NaN பண்பு “Not-a-Number (எண் அல்லாதது)” மதிப்பைக் குறிக்கிறது. இது சட்டப்பூர்வமான எண் அல்லாத மதிப்பைக் (value that is not a legal number) குறிக்கிறது.

NaN இன் typeof ஒரு எண்ணைத் (Number) திருப்பித் தரும்.

ஒரு மதிப்பு NaN என்பதைச் சரிபார்க்க, நாம் isNaN() செயல்பாட்டைப் பயன்படுத்துகிறோம்,

குறிப்பு- isNaN() செயல்பாடு கொடுக்கப்பட்ட மதிப்பை Number வகைக்கு மாற்றுகிறது, பின்னர் NaN க்குச் சமம் (equates) செய்கிறது.

எடுத்துக்காட்டு:

isNaN("Hello"); // Returns true
isNaN(345); // Returns false
isNaN("1"); // Returns false, since '1' is converted to Number type which results in 0 ( a number)
isNaN(true); // Returns false, since true converted to Number type results in 1 ( a number)
isNaN(false); // Returns false
isNaN(undefined); // Returns true

3.4. ஒரு குறிப்பிட்ட குறியீட்டிலிருந்து (index) ஒரு எழுத்தை (character) மீட்டெடுக்க (retrieve) எந்த முறை (method) பயன்படுத்தப்படுகிறது?

பதில்: ஜாவாஸ்கிரிப்ட் சரத்தின் (string) charAt() செயல்பாடு (function), வழங்கப்பட்ட குறியீட்டில் (index) ஒரு சார் உறுப்பைக் (char element) கண்டறியும். குறியீட்டு எண் 0 இல் தொடங்கி n-1 வரை தொடர்கிறது, இங்கே n என்பது சரத்தின் நீளம் (string length). குறியீட்டு மதிப்பு நேர்மறையாக (positive), அதிகமாக அல்லது சரத்தின் நீளத்திற்குச் சமமாக இருக்க வேண்டும்.

4. சில முக்கியமான கருத்துக்கள் (Some important concepts)

4.1. ஜாவாஸ்கிரிப்டில் ஹொயிஸ்டிங் (Hoisting) என்றால் என்ன?

பதில்: ஹொயிஸ்டிங் என்பது ஒரு ஜாவாஸ்கிரிப்ட் பொறிமுறையாகும் (mechanism), அங்கு மாறிகள் மற்றும் செயல்பாட்டு அறிவிப்புகள் (function declarations) குறியீடு செயல்படுத்துவதற்கு முன்பு அவற்றின் ஸ்கோப்பின் உச்சிக்கு நகர்த்தப்படுகின்றன. தவிர்க்க முடியாமல், செயல்பாடுகள் மற்றும் மாறிகள் எங்கு அறிவிக்கப்பட்டாலும், அவற்றின் ஸ்கோப் உலகளாவியதாக இருந்தாலும் அல்லது உள்ளூர் (global or local) ஆக இருந்தாலும் அவற்றின் ஸ்கோப்பின் உச்சிக்கு அவை நகர்த்தப்படும் என்பதை இது குறிக்கிறது.

எடுத்துக்காட்டு 1: மாறியின் ஹொயிஸ்டிங் (Hoisting of variable)

hoistedVariable = 3;
console.log(hoistedVariable); // outputs 3 even when the variable is declared after it is initialized    
var hoistedVariable;

எடுத்துக்காட்டு 2: செயல்பாட்டின் ஹொயிஸ்டிங் (Hoisting of function)

hoistedFunction();  // Outputs " Hello world! " even when the function is declared after calling

function hoistedFunction(){ 
  console.log(" Hello world! ");
}

எடுத்துக்காட்டு 3: செயல்பாட்டுக் கோவையின் ஹொயிஸ்டிங் (Hoisting of function expression)

// Hoisting takes place in the local scope as well
function doSomething(){
  x = 33;
  console.log(x);
  var x;
} 
doSomething(); // Outputs 33 since the local variable “x” is hoisted inside the local scope

/* Note - Variable initializations are not hoisted, only variable declarations are hoisted: */
var x;
console.log(x); // Outputs "undefined" since the initialization of "x" is not hoisted
x = 23;

/* Note - To avoid hoisting, you can run javascript in strict mode by using “use strict” on top of the code: */
"use strict";
x = 23; // Gives an error since 'x' is not declared
var x;

4.2. ஜாவாஸ்கிரிப்டில் "பிழைத்திருத்தி (debugger)" என்ற வார்த்தையை நாம் ஏன் பயன்படுத்துகிறோம்?

பதில்: குறியீட்டில் பிரேக் பாயிண்டுகளை (breakpoints) உருவாக்க debugger முக்கியச் சொல் பயன்படுத்தப்படுகிறது. குறியீட்டில் உள்ள பிழைத்திருத்தி (debugger) முக்கியச்சொல்லை (keyword) உலாவி (browser) கண்டால், அது குறியீட்டைச் செயல்படுத்துவதை நிறுத்தி, உலாவியின் பிழைத்திருத்தக் கருவியைத் (debugging tool) திறக்கும்.

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

பதில்: கரியிங் என்பது n வாதங்களின் (arguments) செயல்பாட்டை (function) ஒன்று அல்லது குறைவான வாதங்களின் n செயல்பாடுகளாக மாற்றுவதற்கான மேம்பட்ட நுட்பமாகும்.

கரியிங் செய்யப்பட்ட செயல்பாட்டின் எடுத்துக்காட்டு (Example of a curried function):

function add (a) {
  return function(b){
    return a + b;
  }
}

add(3)(4)

எடுத்துக்காட்டாக, எங்களிடம் ஒரு செயல்பாடு f(a,b) இருந்தால், கரியிங் செய்த பிறகு உள்ள செயல்பாடு f(a)(b) என மாற்றப்படும்.

கரியிங் நுட்பத்தைப் பயன்படுத்துவதன் மூலம், ஒரு செயல்பாட்டின் செயல்பாட்டை (functionality) நாங்கள் மாற்றுவதில்லை, அது எவ்வாறு செயல்படுத்தப்படுகிறது (invoked) என்பதை மட்டுமே மாற்றுகிறோம்.

செயலில் உள்ள கரியிங்கைப் (currying) பார்ப்போம்:

function multiply(a,b){
  return a*b;
}

function currying(fn){
  return function(a){
    return function(b){
      return fn(a,b);
    }
  }
}

var curriedMultiply = currying(multiply);

multiply(4, 3); // Returns 12

curriedMultiply(4)(3); // Also returns 12

மேலே உள்ள குறியீட்டில் ஒருவர் பார்க்கிறபடி, நாங்கள் function multiply(a,b) ஐ curriedMultiply என்ற செயல்பாட்டிற்கு மாற்றியுள்ளோம், இது ஒரு நேரத்தில் ஒரு அளவுருவை (parameter) எடுக்கும்.

4.4. வெளிப்புற ஜாவாஸ்கிரிப்டைப் (External JavaScript) பயன்படுத்துவதன் சில நன்மைகள் என்ன?

பதில்: எக்ஸ்டர்னல் ஜாவாஸ்கிரிப்ட் (External JavaScript) என்பது ஜாவாஸ்கிரிப்ட் குறியீடு (ஸ்கிரிப்ட்) extension.js உடன் தனி கோப்பில் எழுதப்பட்டுள்ளது, பின்னர் குறியீடு வைக்கப்பட வேண்டிய HTML கோப்பின் <head> அல்லது <body> உறுப்புக்குள் அந்தக் கோப்பை இணைக்கிறோம்.

வெளிப்புற ஜாவாஸ்கிரிப்டின் (external javascript) சில நன்மைகள்:

  • இது வலை வடிவமைப்பாளர்கள் (web designers) மற்றும் டெவலப்பர்களை HTML மற்றும் ஜாவாஸ்கிரிப்ட் கோப்புகளில் ஒத்துழைக்க அனுமதிக்கிறது.
  • நாம் குறியீட்டை மீண்டும் பயன்படுத்தலாம்.
  • வெளிப்புற ஜாவாஸ்கிரிப்டில் குறியீடு வாசிப்புத்திறன் (Code readability) எளிமையானது.

4.5. ஜாவாஸ்கிரிப்டில் க்ளோஷர் (closure) என்றால் என்ன?

பதில்: க்ளோஷர் (closure) என்பது வெளிப்புறச் செயல்பாடு திரும்பிய பிறகும் அதன் வெளிப்புறச் செயல்பாட்டு ஸ்கோப்பிற்கான (outer function scope) அணுகலைக் கொண்ட ஒரு செயல்பாடாகும். இதன் பொருள் ஒரு க்ளோஷர் அதன் வெளிப்புறச் செயல்பாட்டின் மாறிகள் (variables) மற்றும் வாதங்களை (arguments) செயல்பாடு முடிந்த பின்னரும் நினைவில் வைத்து அணுக முடியும்.

சுருக்கமாக- க்ளோஷர் என்பது அதன் வெளிப்புற (இணைக்கும்) செயல்பாட்டு ஸ்கோப்பிலிருந்து மாறிகளுக்கான அணுகலைக் கொண்ட ஒரு செயல்பாடாகும், வெளிப்புறச் செயல்பாடு செயல்படுத்துவதை முடித்த பிறகும்.

4.6. ஜாவாஸ்கிரிப்டில் DOM என்றால் என்ன?

பதில்: ஆவணப் பொருள் மாதிரி (Document Object Model - DOM) என்பது HTML மற்றும் XML ஆவணங்களுக்கான நிரலாக்க இடைமுகமாகும் (programming interface). இது பக்கத்தைக் குறிக்கிறது, இதனால் நிரல்கள் ஆவணத்தின் அமைப்பு, நடை மற்றும் உள்ளடக்கத்தை மாற்ற முடியும். DOM ஆனது ஆவணத்தை முனைகள் (nodes) மற்றும் பொருள்களாகக் (objects) குறிக்கிறது. இதன் மூலம், நிரலாக்க மொழிகள் பக்கத்துடன் இணைக்க முடியும்.

4.7. நிகழ்வு பிரதிநிதித்துவம் (event delegation) என்றால் என்ன?

பதில்: நிகழ்வு பிரதிநிதித்துவம் (Event delegation) என்பது நிகழ்வுகளைக் (events) கேட்பதற்கான (listening) ஒரு நுட்பமாகும், அங்கு ஒரு பெற்றோர் உறுப்பை (parent element) உள்ளே நடக்கும் அனைத்து நிகழ்வுகளுக்கும் கேட்பவராக (listener) நியமிக்கிறீர்கள். நிகழ்வுகள் பெற்றோர் உறுப்பின் கால்பேக் (callback) செயல்பாட்டின் மூலம் கையாளப்படுகின்றன.

4.8. ஜாவாஸ்கிரிப்டில் AJAX கோரிக்கையை (AJAX request) எவ்வாறு செய்யலாம்?

பதில்: AJAX என்பது Asynchronous JavaScript and XML ஐக் குறிக்கிறது. ஒத்திசைவற்ற (asynchronous) வலைப் பயன்பாடுகளை உருவாக்க கிளையன்ட் பக்கத்தில் (client-side) பல வலைத் தொழில்நுட்பங்களைப் பயன்படுத்தும் வலை மேம்பாட்டு நுட்பங்களின் (web development techniques) தொகுப்பாகும். AJAX உடன், இணையப் பயன்பாடுகள் தற்போதுள்ள பக்கத்தின் காட்சி மற்றும் நடத்தையில் தலையிடாமல் ஒத்திசைவின்றி (asynchronously) (பின்னணியில் - in the background) தரவை அனுப்பவும் மீட்டெடுக்கவும் முடியும்.

XMLHttpRequest பொருளைப் பயன்படுத்தி அல்லது fetch API ஐப் பயன்படுத்தி நீங்கள் AJAX கோரிக்கைகளை (requests) செய்யலாம். ஃபெட்ச் (fetch) பயன்படுத்தும் ஒரு எடுத்துக்காட்டு இங்கே:

  fetch('https://example.com/api/data')
    .then(response => response.json())
    .then(data => console.log(data))
    .catch(error => console.error(error));

4.9. ஜாவாஸ்கிரிப்டில் ஒரு பிராமிஸ் (promise) என்றால் என்ன?

பதில்: ஒரு பிராமிஸ் என்பது எதிர்காலத்தில் ஒரு மதிப்பை (single value) உருவாக்கக்கூடிய ஒரு பொருளாகும்: ஒரு தீர்க்கப்பட்ட மதிப்பு (resolved value) அல்லது அது தீர்க்கப்படாததற்கான காரணம் (எ.கா., நெட்வொர்க் பிழை ஏற்பட்டது). ஒரு பிராமிஸ் 3 சாத்தியமான நிலைகளில் ஒன்றில் இருக்கலாம்: நிறைவேற்றப்பட்டது (fulfilled), நிராகரிக்கப்பட்டது (rejected), அல்லது நிலுவையில் உள்ளது (pending). நிறைவேற்றப்பட்ட மதிப்பை அல்லது நிராகரிப்பதற்கான காரணத்தைக் கையாள, பிராமிஸ் பயனர்கள் கால்பேக்குகளை (callbacks) இணைக்கலாம்.

4.10. ஜாவாஸ்கிரிப்டில் உங்களுக்கு ஏன் ஒரு பிராமிஸ் (promise) தேவை?

பதில்: ஒத்திசைவற்ற செயல்பாடுகளைக் (asynchronous operations) கையாளப் பிராமிஸ்கள் பயன்படுத்தப்படுகின்றன. அவை கால்பேக் நரகத்தைக் (callback hell) குறைப்பதன் மூலமும் தூய்மையான குறியீட்டை எழுதுவதன் மூலமும் கால்பேக்குகளுக்கு மாற்று அணுகுமுறையை (alternative approach) வழங்குகின்றன.

4.11. ஜாவாஸ்கிரிப்டில் சமத்துவத்தை (equality) விளக்குக?

பதில்: ஜாவாஸ்கிரிப்ட் இரண்டு வகையான சமத்துவ ஆபரேட்டர்களை (equality operators) வழங்குகிறது: கண்டிப்பான சமத்துவம் (strict equality) (===) மற்றும் தளர்வான சமத்துவம் (loose equality) (==)

  • கண்டிப்பான சமத்துவம் (Strict Equality) (===): எந்த வகை மாற்றமும் (type conversion) செய்யாமல் இந்த ஆபரேட்டர் இரண்டு மதிப்புகளை ஒப்பிடுகிறது. மதிப்புகள் வெவ்வேறு வகைகளைக் கொண்டிருந்தால் (different types), அவை சமமற்றவையாகக் கருதப்படும். மதிப்புகள் ஒரே வகையைக் கொண்டிருந்தால், அவை எண்கள் அல்ல, ஒரே மதிப்பைக் கொண்டிருந்தால், அவை சமமாகக் கருதப்படும். எண்களுக்கு, இரண்டும் NaN ஆக இல்லாமல் ஒரே மதிப்பைக் கொண்டிருந்தாலோ அல்லது ஒன்று +0 மற்றும் மற்றொன்று -0 ஆக இருந்தாலோ அவை சமமாகக் கருதப்படும்.

  • தளர்வான சமத்துவம் (Loose Equality) (==): செயல்பாடுகளை (operands) ஒப்பிடும்போது இந்த ஆபரேட்டர் வகை மாற்றத்தைச் (type conversion) செய்கிறது. செயல்பாடுகள் (operands) ஒரே வகையாக இருந்தால், கண்டிப்பான சமத்துவ ஆபரேட்டரைப் (strict equality operator) போலவே அவை ஒப்பிடப்படும். செயல்பாடுகள் வெவ்வேறு வகைகளைக் கொண்டிருந்தால், ஜாவாஸ்கிரிப்ட் அவற்றை ஒரு பொதுவான வகையாக மாற்ற முயற்சிக்கிறது, பின்னர் அவற்றை ஒப்பிடுகிறது. வகை மாற்றத்திற்கான (type conversion) விதிகள் சில நேரங்களில் எதிர்பாராத முடிவுகளுக்கு வழிவகுக்கும், எனவே சாத்தியமான சிக்கல்களைத் தவிர்க்கக் கண்டிப்பான சமத்துவ ஆபரேட்டரைப் (strict equality operator) பயன்படுத்தப் பொதுவாகப் பரிந்துரைக்கப்படுகிறது

5. பொருள் (Object)

5.1. ஜாவாஸ்கிரிப்டில் பொருட்களை உருவாக்க சாத்தியமான வழிகள் என்ன?

பதில்: கீழே உள்ளதைப் போல ஜாவாஸ்கிரிப்டில் ஆப்ஜெக்ட்களை (objects) உருவாக்கப் பல வழிகள் உள்ளன

ஆப்ஜெக்ட் கன்ஸ்ட்ரக்டர் (Object constructor):

i. ஒரு வெற்றுப் பொருளை (empty object) உருவாக்குவதற்கான எளிய வழி Object constructor ஐப் பயன்படுத்துவதாகும். தற்போது இந்த அணுகுமுறை பரிந்துரைக்கப்படவில்லை.

var object = new Object();

Object() என்பது ஒரு உள்ளமைக்கப்பட்ட கன்ஸ்ட்ரக்டர் செயல்பாடு (built-in constructor function), எனவே "new" முக்கியச் சொல் தேவையில்லை. மேலே உள்ளதை இவ்வாறு எழுதலாம்:

var object = Object();

ii. ஆப்ஜெக்ட்டின் (Object's) உருவாக்க முறை (create method):

ஒரு Object இன் create முறையானது, முன்மாதிரிப் பொருளை (prototype object) அளவுருவாக (parameter) கடந்து (passing) புதிய பொருளை உருவாக்குகிறது.

var object = Object.create(null);

iii. ஆப்ஜெக்ட் லிட்டரல் தொடரியல் (Object literal syntax):

ஆப்ஜெக்ட் லிட்டரல் தொடரியல் (அல்லது ஆப்ஜெக்ட் இனிஷியலைசர் - object initializer), சுருள் அடைப்புக்குறிக்குள் (curly braces) சுற்றப்பட்ட பெயர்-மதிப்பு ஜோடிகளின் (name-value pairs) கமாவால் பிரிக்கப்பட்ட தொகுப்பாகும் (comma-separated set).

var object = {
     name: "Sudheer",
     age: 34
};

Object literal property values can be of any data type, including array, function, and nested object.

குறிப்பு: ஆப்ஜெக்ட்டை உருவாக்க இது எளிதான வழியாகும்

iv. கன்ஸ்ட்ரக்டர் செயல்பாடு (Function constructor):

பொருள் நிகழ்வுகளை (object instances) உருவாக்க எந்தச் செயல்பாட்டையும் உருவாக்கி, new ஆபரேட்டரைப் பயன்படுத்தவும்,

function Person(name) {
  this.name = name;
  this.age = 21;
}
var object = new Person("Sudheer");

v. முன்மாதிரியுடன் கன்ஸ்ட்ரக்டர் செயல்பாடு (Function constructor with prototype):

இது கன்ஸ்ட்ரக்டர் செயல்பாட்டைப் போன்றது ஆனால் அவற்றின் பண்புகள் மற்றும் முறைகளுக்கு முன்மாதிரியைப் (prototype) பயன்படுத்துகிறது,

function Person() {}
Person.prototype.name = "Sudheer";
var object = new Person();

இது ஒரு செயல்பாட்டு முன்மாதிரியுடன் (function prototype) object create முறையுடன் உருவாக்கப்பட்ட ஒரு நிகழ்வுக்குச் (instance) சமமானதாகும், பின்னர் அந்தச் செயல்பாட்டை ஒரு நிகழ்வு மற்றும் அளவுருக்களை (parameters) வாதங்களாக (arguments) கொண்டு அழைக்கவும்.

function func() {}

new func(x, y, z);

(அல்லது - OR)

// Create a new instance using function prototype.
var newInstance = Object.create(func.prototype)

// Call the function
var result = func.call(newInstance, x, y, z),

// If the result is a non-null object then use it otherwise just use the new instance.
console.log(result && typeof result === 'object' ? result : newInstance);

vi. ES6 வகுப்புத் தொடரியல் (ES6 Class syntax):

ஆப்ஜெக்ட்களை உருவாக்க ES6 class அம்சத்தை அறிமுகப்படுத்துகிறது

class Person {
  constructor(name) {
    this.name = name;
  }
}

var object = new Person("Sudheer");

6. பலவகைப்பட்ட (Miscellaneous)

6.1. ஜாவாஸ்கிரிப்டில் ஸ்ட்ரிக்ட் மோட் (strict mode) என்றால் என்ன?

பதில்: ஸ்ட்ரிக்ட் மோட் (Strict Mode) என்பது ECMAScript 5 இல் உள்ள ஒரு புதிய அம்சமாகும், இது ஒரு நிரல் அல்லது ஒரு செயல்பாட்டை "ஸ்ட்ரிக்ட் (strict)" இயக்கச் சூழலில் வைக்க உங்களை அனுமதிக்கிறது. இந்த வழியில் இது சில நடவடிக்கைகள் எடுக்கப்படுவதைத் தடுக்கிறது மற்றும் கூடுதல் விதிவிலக்குகளை (exceptions) வீசுகிறது. லிட்டரல் எக்ஸ்பிரஷன் (literal expression) "use strict"; ஸ்ட்ரிக்ட் மோடில் (Strict mode) ஜாவாஸ்கிரிப்ட் குறியீட்டைப் பயன்படுத்த உலாவிக்கு அறிவுறுத்துகிறது.

6.2. ஜாவாஸ்கிரிப்டில் நல் மதிப்பு (null value) என்றால் என்ன?

பதில்: null மதிப்பானது எந்தவொரு பொருளின் மதிப்பும் உள்நோக்கத்துடன் இல்லாததைக் குறிக்கிறது. இது ஜாவாஸ்கிரிப்ட்டின் பழமையான மதிப்புகளில் (primitive values) ஒன்றாகும். நல் மதிப்பின் (null value) வகை பொருள் (object) ஆகும். மதிப்பை null என அமைப்பதன் மூலம் நீங்கள் மாறியை காலியாக்கலாம்.

var user = null;
console.log(typeof user); //object

6.3. ஜாவாஸ்கிரிப்டில் eval என்றால் என்ன?

பதில்: eval() செயல்பாடு சரமாகக் (string) குறிக்கப்படும் ஜாவாஸ்கிரிப்ட் குறியீட்டை மதிப்பிடுகிறது. சரமானது ஜாவாஸ்கிரிப்ட் கோவை (expression), மாறி (variable), அறிக்கை (statement) அல்லது அறிக்கைகளின் வரிசையாக இருக்கலாம்.

console.log(eval("1 + 2")); //  3

6.4. ஜாவாஸ்கிரிப்ட் தொகுக்கப்பட்ட (compiled) அல்லது விளக்கப்பட்ட (interpreted) மொழியா?

பதில்: ஜாவாஸ்கிரிப்ட் ஒரு விளக்கப்பட்ட மொழி (interpreted language), தொகுக்கப்பட்ட மொழி (compiled language) அல்ல. உலாவியில் உள்ள ஒரு மொழிபெயர்ப்பாளர் (interpreter) ஜாவாஸ்கிரிப்ட் குறியீட்டைப் படித்து, ஒவ்வொரு வரியையும் விளக்கி, அதை இயக்குகிறார். இப்போதெல்லாம் நவீன உலாவிகள் Just-In-Time (JIT) Compilation எனப்படும் தொழில்நுட்பத்தைப் பயன்படுத்துகின்றன, இது ஜாவாஸ்கிரிப்டை இயங்கும் போது இயங்கக்கூடிய பைட்குறியீட்டில் (executable bytecode) தொகுக்கிறது.

6.5. exec() மற்றும் test() முறைகளுக்கு (methods) இடையிலான வேறுபாடு

பதில் exec() மற்றும் test() முறைகளுக்கு இடையிலான வேறுபாடுகள் பின்வருமாறு:

exec(): 1) இது ஜாவாஸ்கிரிப்டில் உள்ள ஒரு எக்ஸ்பிரஷன் முறையாகும் (expression method), இது குறிப்பிட்ட வடிவமைப்புடன் (pattern) சரத்தைத் (string) தேடப் பயன்படுகிறது. 2) அது கண்டுபிடிக்கப்பட்டதும், வடிவமைப்பு நேரடியாகத் திருப்பியளிக்கப்படும், இல்லையெனில், அது ஒரு "வெற்று (empty)" முடிவைத் தரும்.

test(): 1) இது ஜாவாஸ்கிரிப்டில் உள்ள ஒரு எக்ஸ்பிரஷன் முறையாகும், இது ஒரு குறிப்பிட்ட வடிவமைப்பு (pattern) அல்லது உரையுடன் (text) ஒரு சரத்தைத் தேடப் பயன்படுகிறது. 2) அது கண்டறியப்பட்டதும், வடிவமைப்பு பூலியன் மதிப்பை true எனத் திருப்பியளிக்கும், இல்லையெனில் false எனத் திருப்பியளிக்கும்.

6.6. ஜாவாஸ்கிரிப்ட் கேஸ் சென்சிட்டிவ் மொழியா (case-sensitive language) ?

பதில்: ஆம், ஜாவாஸ்கிரிப்ட் ஒரு கேஸ் சென்சிட்டிவ் (case sensitive) மொழியாகும். மொழி முக்கியச் சொற்கள் (keywords), மாறிகள் (variables), செயல்பாடு & பொருள் பெயர்கள் (function & object names) மற்றும் வேறு ஏதேனும் அடையாளங்காட்டிகள் (identifiers) எப்பொழுதும் சீரான பெரிய எழுத்துக்களுடன் (consistent capitalization) தட்டச்சு செய்யப்பட வேண்டும்.

7. JSON

7.1. JSON என்றால் என்ன?

பதில்: JSON (JavaScript Object Notation) என்பது தரவுப் பரிமாற்றத்திற்குப் (data interchanging) பயன்படுத்தப்படும் இலகுரக வடிவமாகும் (lightweight format). ஜாவாஸ்கிரிப்டில் பொருள்கள் (objects) கட்டமைக்கப்படும் விதத்தில் இது ஜாவாஸ்கிரிப்ட் மொழியின் துணைக்குழுவை (subset) அடிப்படையாகக் கொண்டது.

7.2. JSON இன் தொடரியல் விதிகள் (syntax rules) யாவை?

பதில்: கீழே JSON இன் தொடரியல் விதிகளின் பட்டியல் உள்ளது

  • தரவு பெயர்/மதிப்பு ஜோடிகளில் (name/value pairs) உள்ளது
  • தரவு கமாக்களால் (commas) பிரிக்கப்படுகிறது
  • சுருள் அடைப்புக்குறிகள் (Curly braces) பொருட்களைப் (objects) பிடித்துக் கொள்கின்றன
  • சதுர அடைப்புக்குறிகள் (Square brackets) வரிசைகளைப் (arrays) பிடித்துக் கொள்கின்றன

7.3. JSON ஸ்ட்ரிங்ஃபையின் (stringify) நோக்கம் என்ன?

பதில்: ஒரு இணையச் சேவையகத்திற்குத் (web server) தரவை அனுப்பும் போது, தரவு சரம் (string) வடிவத்தில் இருக்க வேண்டும். JSON பொருளை stringify() முறையைப் பயன்படுத்திச் சரமாக (string) மாற்றுவதன் மூலம் இதை அடையலாம்.

var userJSON = { name: "John", age: 31 };
var userString = JSON.stringify(userJSON);
console.log(userString); //"{"name":"John","age":31}"

7.4. நீங்கள் JSON சரத்தை (string) எவ்வாறு பாகுபடுத்துகிறீர்கள் (parse)?

பதில்: இணையச் சேவையகத்திலிருந்து தரவைப் பெறும்போது, தரவு எப்போதும் சரம் (string) வடிவத்தில் இருக்கும். ஆனால் parse() முறையைப் பயன்படுத்தி இந்தச் சரம் மதிப்பை ஜாவாஸ்கிரிப்ட் பொருளாக (javascript object) மாற்றலாம்.

var userString = '{"name":"John","age":31}';
var userJSON = JSON.parse(userString);
console.log(userJSON); // {name: "John", age: 31}

7.5. உங்களுக்கு ஏன் JSON தேவை?

பதில்: உலாவிக்கும் (browser) சேவையகத்திற்கும் (server) இடையே தரவைப் பரிமாறிக் கொள்ளும்போது, தரவு உரையாக (text) மட்டுமே இருக்க முடியும். JSON என்பது உரை மட்டுமே என்பதால், அதை எளிதாகச் சேவையகத்திற்கு (server) அனுப்பலாம், மேலும் எந்த நிரலாக்க மொழியாலும் தரவு வடிவமாகப் (data format) பயன்படுத்தலாம்.

7.6. JSON வரிசைகளை (arrays) எப்படி வரையறுக்கிறீர்கள்?

பதில்: JSON வரிசைகள் சதுர அடைப்புக்குறிக்குள் (square brackets) எழுதப்பட்டுள்ளன மற்றும் வரிசைகள் ஜாவாஸ்கிரிப்ட் பொருள்களைக் (javascript objects) கொண்டுள்ளன. எடுத்துக்காட்டாக, பயனர்களின் JSON வரிசை கீழே இருக்கும்,

"users":[
  {"firstName":"John", "lastName":"Abrahm"},
  {"firstName":"Anna", "lastName":"Smith"},
  {"firstName":"Shane", "lastName":"Warn"}
]

7.6. JSON இல், சதுர அடைப்புக்குறிகளின் (square brackets) நோக்கம் என்ன, அவை எவ்வாறு பயன்படுத்தப்படுகின்றன?

பதில்: JSON இல், சதுர அடைப்புக்குறிகள் [ ] ஆனது JSON தரவுக் கட்டமைப்பிற்குள் (data structures) வரிசைகளை (arrays) இணைக்கவும் (encapsulate) வரையறுக்கவும் பயன்படுத்தப்படுகின்றன. JSON வரிசைகள் (arrays) மதிப்புகளின் தொகுப்பைக் கொண்டிருக்கலாம், அவை பொருள்கள் (objects), சரங்கள் (strings), எண்கள் (numbers) மற்றும் பிற JSON வரிசைகள் உட்படப் பல்வேறு தரவு வகைகளாக இருக்கலாம்.

results matching ""

    No results matching ""