Jassif Team Institution

JavaScript சிறந்த நடைமுறைகள்

பொது மாறிகள், புதியது, ==, eval() ஆகியவற்றைத் தவிர்க்கவும்

பொது மாறிகள் தவிர்க்கவும்

பொது மாறிகளின் பயன்பாட்டைக் குறைக்கவும்.

இதில் அனைத்து தரவு வகைகள், பொருள்கள் மற்றும் செயல்பாடுகளும் அடங்கும்.

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

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

எப்போதும் உள்ளூர் மாறிகளை அறிவிக்கவும்

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

உள்ளூர் மாறிகள் var, let, அல்லது const விசையுடன் அறிவிக்கப்பட வேண்டும், இல்லையெனில் அவை பொது மாறிகளாக மாறும்.

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

மேலே அறிவிப்புகள்

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

இது:

• தூய்மையான குறியீட்டைத் தரும்
• உள்ளூர் மாறிகளைப் பார்க்க ஒற்றை இடத்தை வழங்கும்
• தேவையில்லாத (மறைமுகமான) பொது மாறிகளைத் தவிர்ப்பது எளிதாக்கும்
• தேவையில்லாத மறு-அறிவிப்புகளின் சாத்தியத்தைக் குறைக்கும்

// தொடக்கத்தில் அறிவிக்கவும்
let firstName, lastName, price, discount, fullPrice;

// பின்னர் பயன்படுத்தவும்
firstName = "John";
lastName = "Doe";

price = 19.90;
discount = 0.10;

fullPrice = price - discount;

இது வளைய மாறிகளுக்கும் செல்கிறது:

for (let i = 0; i < 5; i++) {

மாறிகளைத் துவக்கவும்

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

இது:

• தூய்மையான குறியீட்டைத் தரும்
• மாறிகளைத் துவக்க ஒற்றை இடத்தை வழங்கும்
• வரையறுக்கப்படாத மதிப்புகளைத் தவிர்க்கும்

// தொடக்கத்தில் அறிவிக்கவும் மற்றும் துவக்கவும்
let firstName = "";
let lastName = "";
let price = 0;
let discount = 0;
let fullPrice = 0,
const myArray = [];
const myObject = {};

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

JavaScript மாறிகளை மீண்டும் அறிவித்தல்

நீங்கள் var உடன் அறிவிக்கப்பட்ட ஒரு JavaScript மாறியை மீண்டும் அறிவித்தால், அது அதன் மதிப்பை இழக்காது.

இந்த அறிக்கைகளின் செயல்பாட்டிற்குப் பிறகு carName மாறி இன்னும் "Volvo" மதிப்பைக் கொண்டிருக்கும்:

எடுத்துக்காட்டு (பரிந்துரைக்கப்படவில்லை)

var carName = "Volvo";
var carName;

let அல்லது const உடன் அறிவிக்கப்பட்ட மாறியை நீங்கள் மீண்டும் அறிவிக்க முடியாது.

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

இது வேலை செய்யாது:

let carName = "Volvo";
let carName;

இது வேலை செய்யாது:

const carName = "Volvo";
const carName;

const உடன் பொருள்களை அறிவிக்கவும்

const உடன் பொருள்களை அறிவிப்பது வகையின் எந்த தற்செயல் மாற்றத்தையும் தடுக்கும்:

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

let car = {type:"Fiat", model:"500", color:"white"};
car = "Fiat";      // பொருளை சரமாக மாற்றுகிறது

const car = {type:"Fiat", model:"500", color:"white"};
car = "Fiat";      // சாத்தியமில்லை

const உடன் வரிசைகளை அறிவிக்கவும்

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

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

let cars = ["Saab", "Volvo", "BMW"];
cars = 3;    // வரிசையை எண்ணாக மாற்றுகிறது

const cars = ["Saab", "Volvo", "BMW"];
cars = 3;    // சாத்தியமில்லை

new Object() பயன்படுத்த வேண்டாம்

• new String()க்குப் பதிலாக "" பயன்படுத்தவும்
• new Number()க்குப் பதிலாக 0 பயன்படுத்தவும்
• new Boolean()க்குப் பதிலாக false பயன்படுத்தவும்
• new Object()க்குப் பதிலாக {} பயன்படுத்தவும்
• new Array()க்குப் பதிலாக [] பயன்படுத்தவும்
• new RegExp()க்குப் பதிலாக /()/ பயன்படுத்தவும்
• new Function()க்குப் பதிலாக function (){} பயன்படுத்தவும்

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

let x1 = "";             // புதிய பழமையான சரம்
let x2 = 0;              // புதிய பழமையான எண்
let x3 = false;          // புதிய பழமையான பூலியன்
const x4 = {};           // புதிய பொருள்
const x5 = [];           // புதிய வரிசை பொருள்
const x6 = /()/;         // புதிய regexp பொருள்
const x7 = function(){}; // புதிய செயல்பாடு பொருள்

தானியங்கி வகை மாற்றங்களில் எச்சரிக்கையாக இருங்கள்

JavaScript லூச்லி டைப் செய்யப்பட்டது.

ஒரு மாறி அனைத்து தரவு வகைகளையும் கொண்டிருக்கலாம்.

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

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

let x = "Hello";     // typeof x என்பது ஒரு சரம்
x = 5;               // typeof x ஐ எண்ணாக மாற்றுகிறது

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

கணித செயல்பாடுகளைச் செய்யும்போது, JavaScript எண்களை சரங்களாக மாற்றலாம்:

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

let x = 5 + 7;       // x.valueOf() 12, typeof x எண்
let x = 5 + "7";     // x.valueOf() 57, typeof x சரம்
let x = "5" + 7;     // x.valueOf() 57, typeof x சரம்
let x = 5 - 7;       // x.valueOf() -2, typeof x எண்
let x = 5 - "7";     // x.valueOf() -2, typeof x எண்
let x = "5" - 7;     // x.valueOf() -2, typeof x எண்
let x = 5 - "x";     // x.valueOf() NaN, typeof x எண்

ஒரு சரத்திலிருந்து ஒரு சரத்தைக் கழிப்பது, பிழையை உருவாக்காது ஆனால் NaN (ஒரு எண் அல்ல) திருப்பித் தரும்:

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

"Hello" - "Dolly"    // NaN திருப்பித் தரும்

=== ஒப்பீட்டைப் பயன்படுத்தவும்

== ஒப்பீட்டு ஆபரேட்டர் ஒப்பீட்டிற்கு முன் எப்போதும் (பொருந்தக்கூடிய வகைகளுக்கு) மாற்றுகிறது.

=== ஆபரேட்டர் மதிப்புகள் மற்றும் வகையின் ஒப்பீட்டைக் கட்டாயப்படுத்துகிறது:

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

0 == "";        // true
1 == "1";       // true
1 == true;      // true

0 === "";       // false
1 === "1";      // false
1 === true;     // false

அளவுரு இயல்புநிலைகளைப் பயன்படுத்தவும்

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

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

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

function myFunction(x, y) {
  if (y === undefined) {
    y = 0;
  }
}

ECMAScript 2015 செயல்பாடு வரையறையில் இயல்புநிலை அளவுருக்களை அனுமதிக்கிறது:

function (a=1, b=1) { /*function code*/ }

Function Parameters இல் செயல்பாடு அளவுருக்கள் மற்றும் வாதங்கள் பற்றி மேலும் படிக்கவும்

இயல்புநிலைகளுடன் உங்கள் சுவிட்சுகளை முடிக்கவும்

எப்போதும் உங்கள் சுவிட்ச் அறிக்கைகளை இயல்புநிலையுடன் முடிக்கவும். அதற்கு தேவை இல்லை என்று நீங்கள் நினைத்தாலும் கூட.

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

switch (new Date().getDay()) {
  case 0:
    day = "Sunday";
    break;
  case 1:
    day = "Monday";
    break;
  case 2:
    day = "Tuesday";
    break;
  case 3:
    day = "Wednesday";
    break;
  case 4:
    day = "Thursday";
    break;
  case 5:
    day = "Friday";
    break;
  case 6:
    day = "Saturday";
    break;
  default:
    day = "Unknown";
}

எண், சரம் மற்றும் பூலியன் ஆகியவற்றைப் பொருள்களாகத் தவிர்க்கவும்

எப்போதும் எண்கள், சரங்கள் அல்லது பூலியன்களை பழமையான மதிப்புகளாகக் கருதுங்கள். பொருள்களாக அல்ல.

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

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

let x = "John";             
let y = new String("John");
(x === y) // false ஏனெனில் x ஒரு சரம் மற்றும் y ஒரு பொருள்.

அல்லது இன்னும் மோசமாக:

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

let x = new String("John");             
let y = new String("John");
(x == y) // false ஏனெனில் நீங்கள் பொருள்களை ஒப்பிட முடியாது.

eval() பயன்படுத்துவதைத் தவிர்க்கவும்

eval() செயல்பாடு உரையை குறியீடாக இயக்க பயன்படுகிறது. கிட்டத்தட்ட எல்லா நிகழ்வுகளிலும், அதைப் பயன்படுத்த வேண்டிய அவசியமில்லை.

அது தன்னிச்சையான குறியீட்டை இயக்க அனுமதிப்பதால், அது ஒரு பாதுகாப்பு சிக்கலைக் குறிக்கிறது.

JavaScript சிறந்த நடைமுறைகள் பயிற்சி

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