నా Best Practices – JavaScript

1. Cacheను ఆఫ్ చేయండి

Firefox:
Developer Tools తెరవండి -> Settings తెరవండి (F1) -> "Disable HTTP Cache (when toolbox is open)"

Chrome:
Developer Tools తెరవండి -> Settings తెరవండి (F1) -> "Disable cache (while DevTools is open)"

2. JS consoleను తెరిచే ఉంచండి

Dev Toolsలో Console tabను తెరిచి అలాగే ఉంచండి; అప్పుడే దశ 1 పనిచేస్తూ ఉంటుంది, network, JS errorలు కూడా మీ కంటపడతాయి.

ఈ pluginను కూడా సిఫార్సు చేస్తాను; మీరే గమనించడం మర్చిపోయినా, ఇది JS errorలను ఇంకా బాగా చూపిస్తుంది:

3. JavaScript: తప్పక చదవాల్సినది “You Don't Know JS”

• You Don't Know JS (1st Edition)
• thisను ఎందుకు తప్పించుకోవాలో వివరిస్తుంది
• JSలో కొన్నిసార్లు విచిత్రంగా అనిపించే విషయాలు ఎందుకు జరుగుతాయో వివరిస్తుంది (కీలక పదాలు: Lexical Scope, Closures)

4. Semicolon

• ఎప్పుడూ పెట్టండి
• ఇది తప్పనిసరి కాదు, కానీ ఉదాహరణకు ఈ ఉచ్చును తప్పించుకోవడానికి సహాయపడుతుంది: Stack Overflow
• JavaScript ఆటోమేటిక్‌గా semicolon పెడుతుంది:

// you want to return 5 and have ugly formatting:
return
5

// JavaScript Interpretation:
return;
5;

5. Logical operatorలు &&, ||

• Javaలో a && b, a || b Boolean బీజగణితం ప్రకారం evaluate అవుతాయి. a, b తప్పనిసరిగా Booleanలు అయి ఉండాలి.
• JavaScriptలో:
  • a && bలో, a true అయితే b return అవుతుంది
  • a || bలో, a false అయితే b return అవుతుంది

Expressionలను కూడా ఇలా జోడించవచ్చు; దీనితో సాధ్యమైనంత చిన్న if-statement లభిస్తుంది – Syntax Sugar:

• isAdmin && showDeleteButton();
• (కచ్చితంగా చెప్పాలంటే, ఇది ఇక statement కాదు)

Default విలువల కోసం కూడా దీన్ని తరచూ వాడతారు:

• let sendNewsletter = form.getNewsletterOptIn() || false;

6. JavaScript pass-by-referenceనా, pass-by-valueనా?

JavaScriptలో ఇది ఆసక్తికరంగా ఉంటుంది. ఉదాహరణ:

function changeStuff(a, b, c) {
    a = a * 10;
    b.item = "changed";
    c = {item: "changed"};
}

var num = 10;
var obj1 = {item: "unchanged"};
var obj2 = {item: "unchanged"};

changeStuff(num, obj1, obj2);

console.log(num);
console.log(obj1.item);
console.log(obj2.item);

ఇది కింది outputను ఇస్తుంది:

10
changed
unchanged

obj1 అసలు reference కాకపోతే, obj1.itemను మార్చడం function బయట ఉన్న obj1పై ఎలాంటి ప్రభావమూ చూపేది కాదు.

Argument నిజమైన reference అయి ఉంటే, అంతా మారిపోయేది: num 100 అయ్యేది, obj2.itemలో “changed” ఉండేది. దానికి బదులు num 10 గానే ఉంటుంది, obj2.item “unchanged” గానే ఉంటుంది.

నిజానికి, పంపిన అంశం valueగానే పంపబడుతుంది. కానీ valueగా పంపబడేది స్వయంగా ఒక reference. సాంకేతికంగా దీన్ని call-by-sharing అంటారు.

ఆచరణలో దీని అర్థం: మీరు parameterనే మార్చితే (num, obj2 లాగా), functionకు పంపిన అసలు objectపై దాని ప్రభావం ఉండదు. కానీ parameter లోపలి విలువలను మార్చితే, ఆ మార్పులు నిలిచి ఉంటాయి (obj1 లాగా).