Jassif Team Institution

JavaScript பொதுவான தவறுகள்

இந்த அத்தியாயம் சில பொதுவான JavaScript தவறுகளைச் சுட்டிக்காட்டுகிறது.

தற்செயலாக ஒதுக்கீட்டு ஆபரேட்டரைப் பயன்படுத்துதல்

ஒரு நிரலர் ஒரு if அறிக்கையில் ஒரு ஒப்பீட்டு ஆபரேட்டருக்கு (=) பதிலாக ஒரு ஒதுக்கீட்டு ஆபரேட்டரை (=) தற்செயலாகப் பயன்படுத்தினால், JavaScript நிரல்கள் எதிர்பாராத முடிவுகளை உருவாக்கக்கூடும்.

இந்த if அறிக்கை false (எதிர்பார்த்தபடி) திருப்பித் தரும், ஏனெனில் x 10க்கு சமமாக இல்லை:

let x = 0;
if (x == 10)

இந்த if அறிக்கை true (எதிர்பார்க்கப்படாமல் இருக்கலாம்) திருப்பித் தரும், ஏனெனில் 10 உண்மை:

let x = 0;
if (x = 10)

இந்த if அறிக்கை false (எதிர்பார்க்கப்படாமல் இருக்கலாம்) திருப்பித் தரும், ஏனெனில் 0 பொய்:

let x = 0;
if (x = 0)

ஒரு ஒதுக்கீடு எப்போதும் ஒதுக்கீட்டின் மதிப்பைத் திருப்பித் தரும்.

தளர்வான ஒப்பீட்டை எதிர்பார்த்தல்

வழக்கமான ஒப்பீட்டில், தரவு வகை முக்கியமில்லை. இந்த if அறிக்கை true திருப்பித் தரும்:

let x = 10;
let y = "10";
if (x == y)

கண்டிப்பான ஒப்பீட்டில், தரவு வகை முக்கியமானது. இந்த if அறிக்கை false திருப்பித் தரும்:

let x = 10;
let y = "10";
if (x === y)

switch அறிக்கைகள் கண்டிப்பான ஒப்பீட்டைப் பயன்படுத்துகின்றன என்பதை மறப்பது ஒரு பொதுவான தவறு:

இந்த case switch ஒரு எச்சரிக்கையைக் காண்பிக்கும்:

let x = 10;
switch(x) {
  case 10: alert("Hello");
}

இந்த case switch ஒரு எச்சரிக்கையைக் காண்பிக்காது:

let x = 10;
switch(x) {
  case "10": alert("Hello");
}

கூட்டல் & இணைப்பை குழப்புதல்

கூட்டல் என்பது எண்களைச் சேர்ப்பது பற்றியது.

இணைப்பு என்பது சரங்களைச் சேர்ப்பது பற்றியது.

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

இதன் காரணமாக, ஒரு எண்ணை எண்ணாகச் சேர்ப்பது, ஒரு எண்ணைச் சரமாகச் சேர்ப்பதிலிருந்து வேறுபட்ட முடிவை உருவாக்கும்:

let x = 10;
x = 10 + 5;       // இப்போது x 15

let y = 10;
y += "5";        // இப்போது y "105"

இரண்டு மாறிகளைச் சேர்க்கும்போது, முடிவை முன்கணிப்பது கடினமாக இருக்கலாம்:

let x = 10;
let y = 5;
let z = x + y;     // இப்போது z 15

let x = 10;
let y = "5";
let z = x + y;     // இப்போது z "105"

மிதவை எண்களை தவறாக புரிந்து கொள்ளுதல்

JavaScript இல் உள்ள அனைத்து எண்களும் 64-பிட் மிதவை புள்ளி எண்களாக (மிதவைகள்) சேமிக்கப்படுகின்றன.

JavaScript உட்பட அனைத்து நிரலாக்க மொழிகளும் துல்லியமான மிதவை புள்ளி மதிப்புகளுடன் சிரமங்களைக் கொண்டுள்ளன:

let x = 0.1;
let y = 0.2;
let z = x + y            // z இல் உள்ள முடிவு 0.3 ஆக இருக்காது

மேலே உள்ள சிக்கலை தீர்க்க, பெருக்குவதும் வகுப்பதும் உதவுகிறது:

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

let z = (x * 10 + y * 10) / 10;       // z 0.3 ஆக இருக்கும்

ஒரு JavaScript சரத்தை உடைத்தல்

JavaScript ஒரு அறிக்கையை இரண்டு வரிகளாக உடைக்க உங்களை அனுமதிக்கும்:

எடுத்துக்காட்டு 1

let x =
"Hello World!";

ஆனால், ஒரு சரத்தின் நடுவில் ஒரு அறிக்கையை உடைப்பது வேலை செய்யாது:

எடுத்துக்காட்டு 2

let x = "Hello
World!";

நீங்கள் ஒரு சரத்தில் ஒரு அறிக்கையை உடைக்க வேண்டியிருந்தால், "பேக்ஸ்லாஷ்" பயன்படுத்த வேண்டும்:

எடுத்துக்காட்டு 3

let x = "Hello \
World!";

அரைப்புள்ளியை தவறான இடத்தில் வைத்தல்

தவறான இடத்தில் வைக்கப்பட்ட அரைப்புள்ளியின் காரணமாக, x இன் மதிப்பைப் பொருட்படுத்தாமல் இந்த குறியீட்டுத் தொகுதி செயல்படுத்தப்படும்:

if (x == 19);
{
  // code block 
}

Return அறிக்கையை உடைத்தல்

ஒரு வரியின் முடிவில் ஒரு அறிக்கையை தானாக மூடுவது ஒரு இயல்புநிலை JavaScript நடத்தையாகும்.

இதன் காரணமாக, இந்த இரண்டு எடுத்துக்காட்டுகளும் ஒரே முடிவைத் திருப்பித் தரும்:

எடுத்துக்காட்டு 1

function myFunction(a) {
  let power = 10 
  return a * power
}

எடுத்துக்காட்டு 2

function myFunction(a) {
  let power = 10;
  return a * power;
}

JavaScript ஒரு அறிக்கையை இரண்டு வரிகளாக உடைக்கவும் உங்களை அனுமதிக்கும்.

இதன் காரணமாக, எடுத்துக்காட்டு 3 ம் ஒரே முடிவைத் திருப்பித் தரும்:

எடுத்துக்காட்டு 3

function myFunction(a) {
  let
  power = 10; 
  return a * power;
}

ஆனால், நீங்கள் return அறிக்கையை இப்படி இரண்டு வரிகளாக உடைத்தால் என்ன நடக்கும்:

எடுத்துக்காட்டு 4

function myFunction(a) {
  let
  power = 10; 
  return
  a * power;
}

செயல்பாடு undefined திருப்பித் தரும்!

ஏன்? ஏனெனில் JavaScript நீங்கள் இதைக் குறித்தீர்கள் என்று நினைத்தது:

எடுத்துக்காட்டு 5

function myFunction(a) {
  let
  power = 10; 
  return;
  a * power;
}

விளக்கம்

ஒரு அறிக்கை முழுமையடையவில்லை என்றால்:

let

JavaScript அடுத்த வரியைப் படிப்பதன் மூலம் அறிக்கையை முடிக்க முயற்சிக்கும்:

power = 10;

ஆனால் இந்த அறிக்கை முழுமையானதாக இருப்பதால்:

return

JavaScript இதை தானாகவே மூடிவிடும்:

return;

JavaScript இல் அறிக்கைகளை அரைப்புள்ளியுடன் மூடுவது (முடிப்பது) விருப்பமானது என்பதால் இது நிகழ்கிறது.

JavaScript வரியின் முடிவில் return அறிக்கையை மூடிவிடும், ஏனெனில் அது ஒரு முழுமையான அறிக்கையாகும்.

ஒருபோதும் return அறிக்கையை உடைக்க வேண்டாம்.

பெயரிடப்பட்ட குறியீடுகளுடன் வரிசைகளை அணுகுதல்

பல நிரலாக்க மொழிகள் பெயரிடப்பட்ட குறியீடுகளுடன் கூடிய வரிசைகளை ஆதரிக்கின்றன.

பெயரிடப்பட்ட குறியீடுகளுடன் கூடிய வரிசைகள் தொடர்புடைய வரிசைகள் (அல்லது ஹாஷ்கள்) என்று அழைக்கப்படுகின்றன.

JavaScript பெயரிடப்பட்ட குறியீடுகளுடன் கூடிய வரிசைகளை ஆதரிப்பதில்லை.

JavaScript இல், வரிசைகள் எண்ணிடப்பட்ட குறியீடுகளைப் பயன்படுத்துகின்றன:

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

const person = [];
person[0] = "John";
person[1] = "Doe";
person[2] = 46;
person.length;       // person.length 3 ஐ திருப்பித் தரும்
person[0];           // person[0] "John" ஐ திருப்பித் தரும்

JavaScript இல், பொருள்கள் பெயரிடப்பட்ட குறியீடுகளைப் பயன்படுத்துகின்றன.

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

தானியங்கி மறுவரையறைக்குப் பிறகு, வரிசை முறைகள் மற்றும் பண்புகள் undefined அல்லது தவறான முடிவுகளை உருவாக்கும்:

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

const person = [];
person["firstName"] = "John";
person["lastName"] = "Doe";
person["age"] = 46;
person.length;      // person.length 0 ஐ திருப்பித் தரும்
person[0];          // person[0] undefined ஐ திருப்பித் தரும்

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

பொருள் மற்றும் வரிசை வரையறையில் பின்தொடர் காற்புள்ளிகள் ECMAScript 5 இல் சட்டபூர்வமானவை.

பொருள் எடுத்துக்காட்டு:

person = {firstName:"John", lastName:"Doe", age:46,}

வரிசை எடுத்துக்காட்டு:

points = [40, 100, 1, 5, 25, 10,];

JSON:

person = {"firstName":"John", "lastName":"Doe", "age":46}

JSON:

points = [40, 100, 1, 5, 25, 10];

Undefined என்பது Null அல்ல

JavaScript பொருள்கள், மாறிகள், பண்புகள் மற்றும் முறைகள் undefined ஆக இருக்கலாம்.

கூடுதலாக, காலி JavaScript பொருள்களுக்கு null மதிப்பு இருக்கலாம்.

இது ஒரு பொருள் காலியாக உள்ளதா என்று சோதிப்பது சற்று கடினமாக இருக்கும்.

வகை undefined ஆக உள்ளதா என்று சோதிப்பதன் மூலம் ஒரு பொருள் இருக்கிறதா என்று சோதிக்கலாம்:

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

if (typeof myObj === "undefined")

ஆனால் ஒரு பொருள் null ஆக உள்ளதா என்று சோதிக்க முடியாது, ஏனெனில் பொருள் undefined ஆக இருந்தால் இது பிழையை எறியும்:

தவறானது:

if (myObj === null)

இந்த சிக்கலைத் தீர்க்க, ஒரு பொருள் null அல்ல, மற்றும் undefined அல்ல என்பதை சோதிக்க வேண்டும்.

ஆனால் இது இன்னும் பிழையை எறியலாம்:

தவறானது:

if (myObj !== null && typeof myObj !== "undefined")

இதன் காரணமாக, நீங்கள் not null என்பதை சோதிக்கும் முன் not undefined என்பதை சோதிக்க வேண்டும்:

சரியானது:

if (typeof myObj !== "undefined" && myObj !== null)

JavaScript பொதுவான தவறுகள் பயிற்சி

இந்த பயிற்சி உங்கள் JavaScript பொதுவான தவறுகள் பற்றிய அறிவைச் சோதிக்க உதவும்.