JavaScript Use Strict
The "use strict" Directive
"use strict" directive ECMAScript பதிப்பு 5 இல் புதியதாக இருந்தது.
இது JavaScript குறியீடு "strict mode" இல் செயல்படுத்தப்பட வேண்டும் என வரையறுக்கிறது.
இது ஒரு அறிக்கை அல்ல. இது ஒரு நேரடி வெளிப்பாடு, JavaScript இன் முந்தைய பதிப்புகளால் புறக்கணிக்கப்படுகிறது.
"use strict" இன் நோக்கம் குறியீடு "strict mode" இல் செயல்படுத்தப்பட வேண்டும் என்பதைக் குறிப்பிடுவதாகும்.
கடுமையான முறையுடன், எடுத்துக்காட்டாக, அறிவிக்கப்படாத மாறிகளைப் பயன்படுத்த முடியாது.
Declaring Strict Mode
ஒரு ஸ்கிரிப்ட் அல்லது செயல்பாட்டின் தொடக்கத்தில் "use strict"; சேர்ப்பதன் மூலம் கடுமையான முறை அறிவிக்கப்படுகிறது.
ஒரு ஸ்கிரிப்டின் தொடக்கத்தில் அறிவிக்கப்பட்டால், அது global scope கொண்டுள்ளது (ஸ்கிரிப்டில் உள்ள அனைத்து குறியீடும் கடுமையான முறையில் செயல்படுத்தப்படும்):
எடுத்துக்காட்டு
"use strict";
x = 3.14; // இது ஒரு பிழையை ஏற்படுத்தும் ஏனெனில் x அறிவிக்கப்படவில்லைஎடுத்துக்காட்டு
"use strict";
myFunction();
function myFunction() {
y = 3.14; // இதுவும் ஒரு பிழையை ஏற்படுத்தும் ஏனெனில் y அறிவிக்கப்படவில்லை
}ஒரு செயல்பாட்டிற்குள் அறிவிக்கப்பட்டால், அது local scope கொண்டுள்ளது (செயல்பாட்டிற்குள் உள்ள குறியீடு மட்டுமே கடுமையான முறையில் உள்ளது):
x = 3.14; // இது பிழையை ஏற்படுத்தாது.
myFunction();
function myFunction() {
"use strict";
y = 3.14; // இது பிழையை ஏற்படுத்தும்
}The "use strict"; Syntax
கடுமையான முறையை அறிவிப்பதற்கான தொடரியல், JavaScript இன் பழைய பதிப்புகளுடன் பொருந்தக்கூடியதாக வடிவமைக்கப்பட்டது.
ஒரு எண்ணியல் நேரடி (4 + 5;) அல்லது ஒரு சரம் நேரடி ("John Doe";) ஒரு JavaScript நிரலில் தொகுப்பது பக்க விளைவுகள் இல்லை. இது வெறுமனே இல்லாத மாறிக்கு தொகுக்கப்பட்டு முடிகிறது.
எனவே "use strict"; அதன் அர்த்தத்தை "புரிந்துகொள்ளும்" புதிய தொகுப்பிகளுக்கு மட்டுமே முக்கியமானது.
Why Strict Mode?
கடுமையான முறை "பாதுகாப்பான" JavaScript எழுதுவதை எளிதாக்குகிறது.
கடுமையான முறை முன்பு ஏற்றுக்கொள்ளப்பட்ட "மோசமான தொடரியலை" உண்மையான பிழைகளாக மாற்றுகிறது.
ஒரு எடுத்துக்காட்டாக, சாதாரண JavaScript இல், ஒரு மாறி பெயரை தவறாக தட்டச்சு செய்வது ஒரு புதிய global மாறியை உருவாக்குகிறது. கடுமையான முறையில், இது ஒரு பிழையை எறியும், தற்செயலாக ஒரு global மாறியை உருவாக்க முடியாமல் செய்யும்.
சாதாரண JavaScript இல், ஒரு டெவலப்பர் எழுத முடியாத பண்புகளுக்கு மதிப்புகளை ஒதுக்குவதில் எந்த பிழை கருத்துகளையும் பெற மாட்டார்.
கடுமையான முறையில், எழுத முடியாத பண்பு, getter-மட்டும் பண்பு, இல்லாத பண்பு, இல்லாத மாறி அல்லது இல்லாத பொருளுக்கு எந்த ஒதுக்கீடும் பிழையை எறியும்.
Not Allowed in Strict Mode
அறிவிக்காமல் ஒரு மாறியைப் பயன்படுத்துவது அனுமதிக்கப்படாது:
"use strict";
x = 3.14; // இது பிழையை ஏற்படுத்தும்பொருள்களும் மாறிகளே.
அறிவிக்காமல் ஒரு பொருளைப் பயன்படுத்துவது அனுமதிக்கப்படாது:
"use strict";
x = {p1:10, p2:20}; // இது பிழையை ஏற்படுத்தும்ஒரு மாறியை (அல்லது பொருளை) நீக்குவது அனுமதிக்கப்படாது.
"use strict";
let x = 3.14;
delete x; // இது பிழையை ஏற்படுத்தும்ஒரு செயல்பாட்டை நீக்குவது அனுமதிக்கப்படாது.
"use strict";
function x(p1, p2) {};
delete x; // இது பிழையை ஏற்படுத்தும்ஒரு அளவுரு பெயரை நகலெடுப்பது அனுமதிக்கப்படாது:
"use strict";
function x(p1, p1) {}; // இது பிழையை ஏற்படுத்தும்ஆக்டல் எண்ணியல் நேரடிகள் அனுமதிக்கப்படாது:
"use strict";
let x = 010; // இது பிழையை ஏற்படுத்தும்ஆக்டல் எஸ்கேப் எழுத்துகள் அனுமதிக்கப்படாது:
"use strict";
let x = "\010"; // இது பிழையை ஏற்படுத்தும்படிக்க-மட்டும் பண்புக்கு எழுதுவது அனுமதிக்கப்படாது:
"use strict";
const obj = {};
Object.defineProperty(obj, "x", {value:0, writable:false});
obj.x = 3.14; // இது பிழையை ஏற்படுத்தும்get-மட்டும் பண்புக்கு எழுதுவது அனுமதிக்கப்படாது:
"use strict";
const obj = {get x() {return 0} };
obj.x = 3.14; // இது பிழையை ஏற்படுத்தும்நீக்க முடியாத பண்பை நீக்குவது அனுமதிக்கப்படாது:
"use strict";
delete Object.prototype; // இது பிழையை ஏற்படுத்தும்eval என்ற வார்த்தை ஒரு மாறியாக பயன்படுத்த முடியாது:
"use strict";
let eval = 3.14; // இது பிழையை ஏற்படுத்தும்arguments என்ற வார்த்தை ஒரு மாறியாக பயன்படுத்த முடியாது:
"use strict";
let arguments = 3.14; // இது பிழையை ஏற்படுத்தும்with அறிக்கை அனுமதிக்கப்படாது:
"use strict";
with (Math){x = cos(2)}; // இது பிழையை ஏற்படுத்தும்பாதுகாப்பு காரணங்களுக்காக, eval() அது அழைக்கப்பட்ட scope இல் மாறிகளை உருவாக்க அனுமதிக்கப்படாது.
கடுமையான முறையில், ஒரு மாறி அது அறிவிக்கப்படுவதற்கு முன்பு பயன்படுத்த முடியாது:
"use strict";
eval ("x = 2");
alert (x); // இது பிழையை ஏற்படுத்தும்கடுமையான முறையில், eval() var வார்த்தையைப் பயன்படுத்தி ஒரு மாறியை அறிவிக்க முடியாது:
"use strict";
eval ("var x = 2");
alert (x); // இது பிழையை ஏற்படுத்தும்eval() let வார்த்தையைப் பயன்படுத்தி ஒரு மாறியை அறிவிக்க முடியாது:
eval ("let x = 2");
alert (x); // இது பிழையை ஏற்படுத்தும்கடுமையான முறையில் செயல்பாடுகளில் this வார்த்தை வித்தியாசமாக செயல்படுகிறது.
this வார்த்தை செயல்பாட்டை அழைத்த பொருளைக் குறிக்கிறது.
பொருள் குறிப்பிடப்படாவிட்டால், கடுமையான முறையில் உள்ள செயல்பாடுகள் undefined ஐ வழங்கும் மற்றும் சாதாரண முறையில் உள்ள செயல்பாடுகள் global பொருளை (window) வழங்கும்:
"use strict";
function myFunction() {
alert(this); // "undefined" ஐ அலர்ட் செய்யும்
}
myFunction();Future Proof!
எதிர்கால JavaScript பதிப்புகளுக்காக ஒதுக்கப்பட்ட வார்த்தைகளை கடுமையான முறையில் மாறி பெயர்களாக பயன்படுத்த முடியாது.
இவை:
- implements
- interface
- let
- package
- private
- protected
- public
- static
- yield
"use strict";
let public = 1500; // இது பிழையை ஏற்படுத்தும்Watch Out!
"use strict" directive ஒரு ஸ்கிரிப்ட் அல்லது செயல்பாட்டின் தொடக்கத்தில் மட்டுமே அங்கீகரிக்கப்படுகிறது.
Exercise
JavaScript குறியீடு 'strict mode' இல் செயல்படுத்தப்பட வேண்டும் என எவ்வாறு வரையறுப்பது?