JavaScript
आरक्षित खोजशब्द

Angular 2 AngularJS ASP.NET CSS HTML jQuery Node.js PHP React Regular Expressions

परिचय

कुछ शब्द - तथाकथित कीवर्ड - विशेष रूप से जावास्क्रिप्ट में व्यवहार किए जाते हैं। विभिन्न प्रकार के खोजशब्दों का बहुतायत है, और वे भाषा के विभिन्न संस्करणों में बदल गए हैं।

आरक्षित खोजशब्द

जावास्क्रिप्ट में आरक्षित खोजशब्दों का पूर्वनिर्धारित संग्रह है जिसे आप चर, लेबल या फ़ंक्शन नामों के रूप में उपयोग नहीं कर सकते।

ECMAScript 1

_{ए - ई}	_{ई - आर}	_{एस - जेड}
`break`	`export`	`super`
`case`	`extends`	`switch`
`catch`	`false`	`this`
`class`	`finally`	`throw`
`const`	`for`	`true`
`continue`	`function`	`try`
`debugger`	`if`	`typeof`
`default`	`import`	`var`
`delete`	`in`	`void`
`do`	`new`	`while`
`else`	`null`	`with`
`enum`	`return`

ECMAScript 2

24 अतिरिक्त आरक्षित कीवर्ड जोड़े। (बोल्ड में नया जोड़)।

3 ई 4 एक्स

_{ए एफ}	_{एफ - पी}	_{पी - जेड}
`abstract`	`final`	`public`
`boolean`	`finally`	`return`
`break`	`float`	`short`
`byte`	`for`	`static`
`case`	`function`	`super`
`catch`	`goto`	`switch`
`char`	`if`	`synchronized`
`class`	`implements`	`this`
`const`	`import`	`throw`
`continue`	`in`	`throws`
`debugger`	`instanceof`	`transient`
`default`	`int`	`true`
`delete`	`interface`	`try`
`do`	`long`	`typeof`
`double`	`native`	`var`
`else`	`new`	`void`
`enum`	`null`	`volatile`
`export`	`package`	`while`
`extends`	`private`	`with`
`false`	`protected`

ECMAScript 5 / 5.1

ECMAScript 3 के बाद से कोई बदलाव नहीं हुआ था।

ECMAScript 5 ने int , byte , char , goto , long , final , float , short , double , native , throws , boolean , abstract , volatile , transient और synchronized हटा दिया; यह जोड़ा let और yield ।

_{ए एफ}	_{एफ - पी}	_{पी - जेड}
`break`	`finally`	`public`
`case`	`for`	`return`
`catch`	`function`	`static`
`class`	`if`	`super`
`const`	`implements`	`switch`
`continue`	`import`	`this`
`debugger`	`in`	`throw`
`default`	`instanceof`	`true`
`delete`	`interface`	`try`
`do`	`let`	`typeof`
`else`	`new`	`var`
`enum`	`null`	`void`
`export`	`package`	`while`
`extends`	`private`	`with`
`false`	`protected`	`yield`

implements , let , private , public , interface , package , protected , static और yield केवल सख्त मोड में अस्वीकृत हैं।

eval और arguments आरक्षित शब्द नहीं हैं, लेकिन वे इसे सख्त मोड में पसंद करते हैं।

ECMAScript 6 / ECMAScript 2015

_{ए - ई}	_{ई - आर}	_{एस - जेड}
`break`	`export`	`super`
`case`	`extends`	`switch`
`catch`	`finally`	`this`
`class`	`for`	`throw`
`const`	`function`	`try`
`continue`	`if`	`typeof`
`debugger`	`import`	`var`
`default`	`in`	`void`
`delete`	`instanceof`	`while`
`do`	`new`	`with`
`else`	`return`	`yield`

भविष्य के आरक्षित खोजशब्द

निम्नलिखित ECMAScript विनिर्देश द्वारा भविष्य के कीवर्ड के रूप में आरक्षित हैं। वर्तमान में उनकी कोई विशेष कार्यक्षमता नहीं है, लेकिन वे भविष्य के कुछ समय पर हो सकते हैं, इसलिए उन्हें पहचानकर्ता के रूप में उपयोग नहीं किया जा सकता है।


`enum`

निम्नलिखित केवल तभी आरक्षित होते हैं जब वे सख्त मोड कोड में पाए जाते हैं:


`implements`	`package`	`public`
`interface`	`private`	`स्थिर '
`let`	`protected`

पुराने मानकों में भविष्य के आरक्षित कीवर्ड

निम्नलिखित भविष्य के कीवर्ड के रूप में पुराने ECMAScript विनिर्देशों (ECMAScript 1 को 3 तक) द्वारा आरक्षित किया जाता है।


`abstract`	`float`	`short`
`boolean`	`goto`	`synchronized`
`byte`	`instanceof`	`throws`
`char`	`int`	`transient`
`double`	`long`	`volatile`
`final`	`native`

इसके अतिरिक्त, ECMAScript में पहचानकर्ता के रूप में शाब्दिक अशक्त, सत्य और असत्य का उपयोग नहीं किया जा सकता है।

मोज़िला डेवलपर नेटवर्क से ।

पहचानकर्ता और पहचानकर्ता नाम

आरक्षित शब्दों के संबंध में चर या फ़ंक्शन नामों की पसंद के लिए उपयोग किए जाने वाले "पहचानकर्ता" के बीच एक छोटा सा अंतर होता है और "पहचानकर्ता नाम" को समग्र डेटा प्रकारों के गुणों के रूप में अनुमति दी जाती है।

उदाहरण के लिए निम्नलिखित में एक अवैध वाक्यविन्यास त्रुटि होगी:

var break = true;

अनकांशस सिन्टैक्सेर: अनपेक्षित टोकन ब्रेक

हालाँकि नाम को एक वस्तु की संपत्ति के रूप में वैध माना जाता है (ECMAScript 5+ के अनुसार):

var obj = {
    break: true
};
console.log(obj.break);

इस उत्तर से उद्धरण के लिए:

ECMAScript® 5.1 भाषा विशिष्टता से :

खंड 7.6
पहचानकर्ता नाम कुछ छोटे संशोधनों के साथ यूनिकोड मानक के अध्याय 5 के "पहचानकर्ता" खंड में दिए गए व्याकरण के अनुसार व्याख्या किए गए टोकन हैं। एक Identifier एक है IdentifierName है कि एक नहीं है ReservedWord (देखें 7.6.1 )।

वाक्य - विन्यास
Identifier ::
  IdentifierName but not ReservedWord

विनिर्देशन द्वारा, एक ReservedWord है:

धारा 7.6.1
एक आरक्षित शब्द एक है IdentifierName है कि एक के रूप में इस्तेमाल नहीं किया जा सकता Identifier ।
ReservedWord :: 
  Keyword
  FutureReservedWord
  NullLiteral
  BooleanLiteral

इसमें कीवर्ड, भविष्य के कीवर्ड, null और बूलियन शाब्दिक शामिल हैं। खोजशब्दों की पूरी सूची खंड 7.6.1 में है और शाब्दिक धारा 7.8 में हैं ।

उपरोक्त (धारा 7.6) का तात्पर्य है कि IdentifierName s को ReservedWord किया जा सकता है, और ऑब्जेक्ट आरंभीकरण के लिए विनिर्देशन से:

धारा 11.1.5
वाक्य - विन्यास
ObjectLiteral :
  { }
  { PropertyNameAndValueList }
  { PropertyNameAndValueList , }

PropertyName कहां है, विनिर्देश द्वारा:

PropertyName :
  IdentifierName
  StringLiteral
  NumericLiteral

आप देख सकते हैं, एक PropertyName एक हो सकता है IdentifierName , इस प्रकार की अनुमति के ReservedWord रों होने की PropertyName रों। यही कारण है कि अंतिम तौर हमें बताता है कि, विनिर्देश के द्वारा, यह है करने के लिए अनुमति दी है ReservedWord के रूप में इस तरह के class और var के रूप में PropertyName रों सिर्फ स्ट्रिंग शाब्दिक या संख्यात्मक शाब्दिक तरह गैर उद्धृत।

अधिक पढ़ने के लिए, खंड 7.6 - पहचानकर्ता नाम और पहचानकर्ता देखें।

नोट: इस उदाहरण में वाक्यविन्यास हाइलाइटर ने आरक्षित शब्द को देखा है और फिर भी इसे उजागर किया है। जबकि उदाहरण वैध है जावास्क्रिप्ट डेवलपर्स कुछ संकलक / ट्रांसपिलर, लाइनर और मिनिफायर टूल द्वारा पकड़े जा सकते हैं जो अन्यथा तर्क देते हैं।

Modified text is an extract of the original Stack Overflow Documentation

के तहत लाइसेंस प्राप्त है CC BY-SA 3.0

से संबद्ध नहीं है Stack Overflow