आप सभी को अर्धविराम के बारे में जानना चाहिए

अर्धविराम (";") का स्वतः-सम्मिलन जावास्क्रिप्ट की सबसे विवादास्पद विशेषताओं में से एक है, जिसके चारों ओर बहुत सी गलतफहमी जमा हो गई है।



कुछ प्रोग्रामर ने "" प्रत्येक कथन के अंत में, कुछ केवल जहां सख्ती से आवश्यक हैं। अधिकांश कहीं बीच में हैं, हालांकि वहाँ हैं जो अतिरिक्त जोड़ते हैं ";" शैलीगत कारणों से।



यहां तक ​​कि अगर आप हमेशा डालते हैं ";" प्रत्येक कथन के अंत में, कुछ निर्माणों को एक स्पष्ट तरीके से पार्स किया जाता है। "," के बारे में आपकी प्राथमिकताओं के बावजूद, पेशेवर भाषा का उपयोग करने के लिए इस तरह के पार्सिंग के नियमों को जानना चाहिए। नीचे कुछ सरल नियमों को याद करते हुए, आप समझेंगे कि किसी भी कार्यक्रम को कैसे पार्स किया जाएगा, और ऑटो-इंसर्ट में विशेषज्ञ बनेंगे ";" जावास्क्रिप्ट में।

जहां टीके स्वीकार्य है

ECMAscript विनिर्देश में दिए गए औपचारिक व्याकरण में, ";" प्रत्येक ऑपरेटर के अंत में हैं जहां वे हो सकते हैं। यहाँ है, जबकि कथन है:



जबकि कथन (अभिव्यक्ति);



टीके भी व्याकरण में विरल कथनों, अभिव्यक्ति कथनों (जैसे "4 + 4;" या f ();) के अंत में प्रकट होते हैं, जारी रखते हैं, लौटते हैं, विराम देते हैं, कथन और डिबगर कथन को जारी रखते हैं।



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



कभी-कभी खाली बयान उपयोगी होते हैं, कम से कम वाक्यात्मक रूप से। उदाहरण के लिए, एक अनंत लूप के लिए, आप "जबकि (1)?" लिख सकते हैं, अर्धविराम को एक खाली कथन के रूप में पार्स किया जाता है, जबकि कथन को वाक्यगत रूप से मान्य बनाया जाता है। टीके के बिना, जबकि स्टेटमेंट अधूरा होगा, क्योंकि लूप कंडीशन के बाद ऑपरेटर की जरूरत होती है।



अंत में, "" "के लिए (अभिव्यक्ति; अभिव्यक्ति; अभिव्यक्ति) ऑपरेटर" के रूप में छोरों में उपयोग किया जाता है, और निश्चित रूप से, लोअरकेस और regexp शाब्दिक रूप में इस्तेमाल किया जा सकता है।

जहां अर्धविरामों को छोड़ दिया जा सकता है

ECMAscript विनिर्देशों से औपचारिक व्याकरण में ";" जैसा कि ऊपर वर्णित है। हालांकि, विनिर्देश यह भी बताता है कि औपचारिक व्याकरण से वास्तविक पार्सिंग अलग-अलग हैं। नियमों को काल्पनिक के माध्यम से वर्णित किया गया है ";" इनपुट स्ट्रीम में डाला गया है, लेकिन यह सिर्फ एक विनिर्देश मॉडल है; व्यवहार में, पार्सर्स को छद्म उत्पन्न करने की आवश्यकता नहीं है ";", लेकिन आप अनुभव कर सकते हैं ";" विशिष्ट स्थानों पर वैकल्पिक व्याकरण के रूप में (उदाहरण के लिए, ECMAscript में विशेष रूप से स्टेटमेंट, स्टेटमेंट, EOS, EOSnoLB और SnoLB नियमों को व्याकरण पार्स करना)। जहां भी एक विनिर्देश "सम्मिलित" कहा जाता है, "", इसका मतलब है कि वर्तमान विवरण समाप्त होता है।



TK के ऑटो-सम्मिलन के नियमों को ECMA-262 [pdf] की धारा 7.9 में वर्णित किया गया है।



अनुभाग उन्हें तीन नियम और दो अपवाद देता है।



नियम इस प्रकार हैं:



जब कोई प्रोग्राम एक टोकन का सामना करता है जो व्याकरण द्वारा अमान्य है, तो ";" डाला जाता है अगर (ए) इस स्थान पर एक लाइन ब्रेक है, या (बी) अमान्य टोकन एक करीबी घुंघराले ब्रैकेट है। जब फ़ाइल के अंत तक पहुँचने और एक अलग व्याख्या की असंभवता, ";" डाला जाता है। जब "प्रतिबंधित उत्पादन" प्रकट होता है, तो व्याकरण उस स्थान पर लाइन टर्मिनेटर से युक्त होता है जहाँ व्याकरण कहता है "[यहाँ कोई लाइनटर्मिनेटर नहीं"], ";" डाला गया है।



दूसरे शब्दों में, ये नियम कहते हैं कि ऑपरेटर "के बिना समाप्त हो सकता है?" (ए) कार्यक्रम के अंत में समापन ब्रेस, (बी) से पहले (सी) यदि अगले टोकन को अन्यथा पार्स नहीं किया जा सकता है, और, इसके अलावा, व्याकरण में कुछ स्थान हैं जहां लाइन ब्रेक स्टेटमेंट को अनजाने में पूरा करता है। व्यवहार में यह क्या है नीचे चर्चा की गई है।



अपवाद: ";" "(अभिव्यक्ति; अभिव्यक्ति; अभिव्यक्ति) ऑपरेटर", और "" के लिए फ़ॉर्म के लूप हेडर में कभी नहीं डाला गया; कभी नहीं डाला अगर परिणाम एक खाली बयान है।



यह सब हमारे लिए क्या मायने रखता है?



सबसे पहले, "" केवल पंक्ति के अंत में, समापन ब्रेस से पहले, और कार्यक्रम के अंत में वैकल्पिक। इसके अलावा, "?" यह पंक्ति के अंत में नहीं माना जाता है यदि अगली पंक्ति का पहला टोकन पिछले कथन के भाग के रूप में पार्स किया जा सकता है।



"42; "हैलो!" "एक वैध कार्यक्रम का एक उदाहरण है, साथ ही साथ" 42 \ n "हैलो!" "(जहां" \ n "एक लाइन ब्रेक का प्रतिनिधित्व करता है), लेकिन" 42 "हैलो!" "अब नहीं है, क्योंकि लाइन रैपिंग एक ऑटो-डालने का कारण बनता है"; “लेकिन कोई जगह नहीं। "यदि (x) {y ()}" भी मान्य है। यहाँ, "y ()" एक अभिव्यक्ति कथन है जो ";" के साथ समाप्त हो सकता है, लेकिन चूंकि अगला टोकन समापन ग्रेस है, ";" वैकल्पिक, लाइन टूटने की अनुपस्थिति के बावजूद।



छोरों और एक खाली बयान के लिए, दोनों अपवादों को एक साथ चित्रित किया जा सकता है:

  (नोड = getNode) के लिए;
      node.parent;
      नोड = नोड.परेंट); 

लूप क्रमिक रूप से अगले अभिभावक नोड को तब तक कॉल करता है जब तक कि एक अभिभावक के बिना एक नोड नहीं मिलता है। यह सब लूप हैडर में होता है, इसलिए लूप बॉडी के लिए कुछ भी नहीं रहता है। हालांकि, लूप सिंटैक्स को एक ऑपरेटर की आवश्यकता होती है, और हम एक खाली ऑपरेटर डालते हैं। इस तथ्य के बावजूद कि सभी तीन हैं ";" इस उदाहरण में, लाइनों के सिरों पर, सभी तीन आवश्यक हैं, ";" लूप हेडर में डाला नहीं जाता है या एक खाली स्टेटमेंट नहीं बनाया जाता है।

सीमित स्पॉन

सीमित स्पॉनों में, लाइन ब्रेक को कुछ स्थानों पर नहीं पाया जा सकता है, क्योंकि यदि आप इन स्थानों में एक लाइन तोड़ते हैं, तो प्रोग्राम उसी तरह से पार्स नहीं करता है, लेकिन यह अलग तरीके से पार्स कर सकता है।



व्याकरण में पाँच सीमित स्पान हैं, ये उपसर्ग संचालक ++ और -, जारी, विराम और वापसी कथन हैं। विराम और जारी बयानों में एक विशेष लूप से नियंत्रण पारित करने के लिए एक वैकल्पिक पहचानकर्ता हो सकता है। इस सुविधा का उपयोग करते समय, पहचानकर्ता को एक ही पंक्ति पर होना चाहिए। यह एक मान्य कार्यक्रम है:

 var c, i, l, लेफ्टचर्स
 पदचिन्ह = ['क्ष ’,' क्यू’]
 charloop: जबकि (c = getc ()) {
     के लिए (i = 0; मैं <putchars.length; मैं ++) {
         अगर (c == शमशान) [i]) चार्लोप तोड़ते हैं
     }
     / * ... अन्य पात्रों के लिए कोड ... * /
 }

यदि getc () इनपुट स्ट्रीम से एक कैरेक्टर लौटाता है, तो प्रोग्राम इसे पढ़ता है, यह चेक करता है कि क्या यह आउटपुट कैरेक्टर है, और यदि है, तो लूप पर कंट्रोल ट्रांसफर करता है। बाहरी लूप को तोड़ने के लिए चिह्नित ब्रेक स्टेटमेंट की आवश्यकता होती है, न कि केवल आंतरिक लूप की। एक ही कार्यक्रम, केवल पंक्ति विराम में भिन्न, समान परिणाम नहीं देगा:

 var c, i, l, लेफ्टचर्स
 पदचिन्ह = ['क्ष ’,' क्यू’]
 charloop: जबकि (c = getc ()) {
     के लिए (i = 0; मैं <putchars.length; मैं ++) {
         if (c == शमशान] [i] टूटना
             charloop
     }
     / * ... अन्य पात्रों के लिए कोड ... * /
 }

इस मामले में, चार्लूप टोकन ब्रेक स्टेटमेंट का हिस्सा नहीं है। चूंकि ब्रेक स्टेटमेंट सीमित है, इस स्थिति में एक लाइन ब्रेक स्टेटमेंट को पूरा करता है। चार्लूप टोकन को एक चार्टल चर की तरह पार्स किया गया है, लेकिन इस स्थान को नियंत्रण नहीं मिलेगा, और विराम कथन आंतरिक लूप से बाहर निकलेगा, और बाहरी नहीं, जैसा कि इरादा था।



अन्य चार बंधे हुए शावकों के उदाहरण:

 // पोस्टफिक्स एक्सप्रेशन:                                            
 // LeftHandSideExpression [यहां कोई लाइनटर्मिनेटर नहीं] ++
 // LeftHandSideExpression [यहां कोई लाइनटर्मिनेटर नहीं] -
 var i = 1;
 मैं
 ++;

यह एक त्रुटि फेंक देगा, और "i ++" के रूप में पार्स नहीं करेगा। टर्मिनेटर पोस्टफिक्स इन्क्रीमेंट या डेक्रिमेंट ऑपरेटर को अलग नहीं कर सकता है, इसलिए लाइन की शुरुआत में "++" या "-" पिछली लाइन के हिस्से के रूप में कभी पार्स नहीं किया जाता है।

 मैं
 ++
 j

और यह कोई गलती नहीं है, इसे "i; ++ जे। " उपसर्ग वृद्धि और गिरावट एक सीमित पीढ़ी नहीं है, इसलिए लाइन ब्रेक "++" या "-" और अभिव्यक्ति को संशोधित करने के बीच हो सकता है।

 // ReturnStatement: वापसी [यहां कोई भी लाइनटर्मिनेटर] अभिव्यक्ति नहीं;
 वापसी
   {i: i, j: j}

इसे एक खाली रिटर्न स्टेटमेंट के रूप में प्रस्तुत किया गया है, इसके बाद एक अभिव्यक्ति ऑपरेटर जिसे नियंत्रण कभी नहीं पहुंचेगा। लेकिन यह योजना के अनुसार तैयार किया गया है:

 वापसी {
   i: i, j: j}
 वापसी (
   {i: i, j: j})
 वापसी {i: i
        , j: j}

ध्यान दें कि वापसी के बयान में अभिव्यक्ति के अंदर हाइफ़न होते हैं, लेकिन रिटर्न टोकन और अभिव्यक्ति की शुरुआत के बीच नहीं। ";" के जानबूझकर चूक के साथ, वापसी विवरण की सीमित पीढ़ी सुविधाजनक है, क्योंकि यह आपको गलती से एक खाली रिटर्न लिखने की अनुमति देता है बिना गलती से निम्नलिखित पंक्ति से एक अभिव्यक्ति लौटा सकता है:

 फ़ंक्शन प्रारंभ (a) {
   // यदि ए पहले से ही आरंभिक है, तो वापस लौटें
   अगर (a.initialized) रिटर्न
   a.initialized = सत्य
   / * ... प्रारंभ करें ... * /
 }

जारी रखने और फेंकने के बयान तोड़ने और लौटने के समान हैं:

 जारी रखें innerloop // true
 
 जारी रखने के लिए
     innerloop;  // गलत है
 // ThrowStatement: फेंक [कोई LineTerminator यहाँ] अभिव्यक्ति;
 फेंक // पार्स त्रुटि
   new MyComplexError (a, b, c, more, args);
 // रिटर्न के विपरीत, ब्रेक, जारी, 
 // अभिव्यक्ति के बाद फेंक आवश्यक है, 
 // इसलिए ऊपर से पार्स नहीं किया गया है।
 नई MyComplexError (a, b, c, more, args) फेंकें;  // सच
 नई MyComplexError फेंकें (
     ए, बी, सी, अधिक, आर्ग्स);  // भी सच है
 // एक ही लाइन पर थ्रो और नए के साथ कोई भी विकल्प सही है।

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



वापसी के बाद लाइन ब्रेक, ब्रेक, जारी और ++ से पहले और - पार्सिंग को प्रभावित करते हैं। चूंकि केवल ये उत्पाद सीमित हैं, कार्यक्रम की पठनीयता में सुधार के लिए रिक्त स्थान और लाइन ब्रेक का उपयोग कहीं और किया जा सकता है। विशेष रूप से, तार्किक, अंकगणित, स्ट्रिंग संघनन ऑपरेटर, ट्रिपल (या सशर्त) ऑपरेटर, एक अवधि या ब्रैकेट के माध्यम से एक सदस्य तक पहुंच, फ़ंक्शन कॉल, जबकि, लूप के लिए, स्विथ स्टेटमेंट और अन्य नियंत्रण संरचनाओं को लाइन ब्रेक के साथ कहीं भी लिखा जा सकता है।



विनिर्देश पढ़ता है:

ECMAScript प्रोग्रामर के लिए व्यावहारिक सलाह: पोस्टफ़िक्स ऑपरेटर "++" और "-" अपने ऑपरेंड के साथ एक ही लाइन पर होना चाहिए। रिटर्न या थ्रो स्टेटमेंट में अभिव्यक्ति को उसी लाइन पर शुरू होना चाहिए जो रिटर्न या थ्रो टोकन है। ब्रेक या जारी बयान में पहचानकर्ता को ब्रेक या टोकन जारी रखने के समान लाइन पर होना चाहिए।

सीमित स्पॉन के साथ प्रोग्रामर की सबसे आम गलती रिटर्न टोकन के बाद लाइन पर रिटर्न वैल्यू डालना है, खासकर अगर एक बड़ी वस्तु या सरणी शाब्दिक वापस आ गई है, या एक बहु-लाइन स्थिरांक है। पोस्टफ़िक्स संचालकों के साथ त्रुटियां, और तोड़ना, जारी रखना, फेंकने वाले ऑपरेटर व्यवहार में दुर्लभ हैं, इस तथ्य के कारण कि इस तरह के लाइन ब्रेक अधिकांश प्रोग्रामर के लिए अप्राकृतिक लगते हैं।



ऑटो डालने की अंतिम सूक्ष्मता ";" पहले नियम से इस प्रकार है, प्रोग्राम को सम्मिलित करने के लिए एक अमान्य टोकन शामिल करने की आवश्यकता है ";"। यदि आप वैकल्पिक को छोड़ देते हैं ";", तो याद रखें कि गैर-वैकल्पिक हैं, जिन्हें छोड़ दिया नहीं जा सकता है। यह नियम आपको कई लाइनों में स्टेटमेंट्स को स्ट्रेच करने की अनुमति देता है:

 वापसी obj.method ('एबीसी')
           .method ('xyz')
           .मिथोड ('pqr')
 
 वापसी "लंबी स्ट्रिंग \ n"
      + "बढ़ाया \ n"
      + "कई के लिए"
 
 TotalArea = rect_a.height * rect_a.width
           + rect_b.height * rect_b.width
           + circ.radius * circ.radius * Math.PI

नियम केवल पहले टोकन में लागू होता है। यदि इस टोकन को ऑपरेटर के हिस्से के रूप में पार्स किया जा सकता है, तो ऑपरेटर जारी रहता है (भले ही पार्सिंग आगे विफल हो जाए)। यदि पहला टोकन ऑपरेटर द्वारा जारी नहीं रखा जा सकता है, तो अगला शुरू होता है (इस बिंदु पर विनिर्देश "सम्मिलित" कहते हैं; "")।



त्रुटियों की क्षमता तब उत्पन्न होती है जब ऑपरेटरों ए और बी की एक जोड़ी में दोनों व्यक्तिगत रूप से मान्य होते हैं, लेकिन पहले टोकन बी को भी ए की निरंतरता के रूप में स्वीकार किया जा सकता है। ऐसे मामलों में, अगर कोई "नहीं है?", पार्सर बी को अलग ऑपरेटर के रूप में पार्स नहीं करेगा, और या तो; त्रुटि, या प्रोग्राम को अनपेक्षित तरीके से पार्स करता है। इस प्रकार, यदि ";" छोड़ दिया जाता है, प्रोग्रामर को किसी भी ऑपरेटर ए और बी को लाइन ब्रेक द्वारा अलग करने की निगरानी करने की आवश्यकता होती है, बी एक टोकन के साथ शुरू होता है, जिसे ए के अंत में संलग्न किया जा सकता है।



जावास्क्रिप्ट में अधिकांश ऑपरेटर एक पहचानकर्ता के साथ शुरू होते हैं, और बाकी के सभी कीवर्ड जैसे "var", "function", "if"। ऐसे किसी भी ऑपरेटर बी के लिए जो एक पहचानकर्ता या कीवर्ड के साथ शुरू होता है, साथ ही साथ किसी भी लाइन के साथ शुरू होता है, एक वैध ऑपरेटर ए मौजूद नहीं होता है (भाषा के व्याकरण से इसका प्रमाण पाठक के लिए एक अभ्यास के रूप में छोड़ दिया जाता है)।

 एक
 फ़ंक्शन f (x) {रिटर्न x * x}
 
 किसी भी ऑपरेटर के लिए // बिना टीके
 // इन सभी उदाहरणों को सही ढंग से पार्स किया गया है
 
 एक
 च (7)
 
 एक
 "एक तार"। गति

दुर्भाग्य से, पांच टोकन हैं जो दोनों ऑपरेटर को शुरू कर सकते हैं और पहले से ही पूर्ण एक को जारी रख सकते हैं। ये "(", "[", "/", "+" और "-" हैं। व्यवहार में, पहले दो समस्याएँ पैदा करते हैं।



इसका मतलब है कि हमेशा लाइन ब्रेक "प्रतिस्थापित नहीं कर सकते हैं;" ऑपरेटरों के बीच।



विनिर्देश एक उदाहरण देता है:

                    a = b + c
                    (d + e) ​​.प्रिंट ()

ऑटो इंसर्ट द्वारा परिवर्तित नहीं किया जा सकता है ";", चूंकि ब्रैकेट में एक्सप्रेशन को फ़ंक्शन कॉल के तर्क के रूप में पार्स किया जा सकता है:

                    a = b + c (d + e) ​​.प्रिंट ()

विनिर्देश का सुझाव है, "जब एक असाइनमेंट ऑपरेटर को बाएं ब्रैकेट के साथ शुरू करना चाहिए, तो यह स्पष्ट रूप से पिछली पंक्ति पर एक अर्धविराम लगाया जाना चाहिए।" अधिक कठोर विकल्प टीके को लाइन की शुरुआत में, टोकन से तुरंत पहले स्थापित करने का अभ्यास है, जो जोखिम को अस्पष्टता से पेश करता है:

                    a = b + c
                    ; (डी + ई) .प्रिंट ()

एक कोष्ठक या एक वर्ग कोष्ठक के साथ शुरू होने वाले संचालक अक्सर होते हैं लेकिन होते हैं।



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

 [['जनवरी', 'जन']
 , ['फरवरी', 'फ़रवरी']
 , ['मार्च', 'मार्च']
 , ['अप्रैल', 'अप्रैल']
 , ['मे', 'मे']
 , ['जून', 'जून']
 , ['जुलाई', 'जुलाई']
 , ['अगस्त', 'अगस्त']
 , ['सितंबर', 'सितम्बर']
 , ['अक्टूबर', 'अक्टूबर']
 , ['नवंबर', 'नवंबर']
 , ['दिसंबर', 'दिसंबर']
 ] .forEach (फ़ंक्शन (ए) {प्रिंट ("" + ए [0] + "का संक्षिप्त नाम" + ए [1] + "है।)}}।
 
 [ '/Script.js'
 , '/ style1.css'
 , '/ style2.css'
 , '/ page1.html'
 ] .प्रत्येक (फ़ंक्शन (यूआरआई) {
    लॉग ('ऊपर देख रहे हैं और कैशिंग' + उरी)
    fetch_and_cache (uri)})

यदि असाइनमेंट में बड़े पैमाने पर शाब्दिक का उपयोग किया जाता है, या फ़ंक्शंस पारित किए जाते हैं, तो वे बयान की शुरुआत में प्रकट नहीं होते हैं, इसलिए प्रारंभिक उद्घाटन वर्ग ब्रैकेट अनंतिम है, लेकिन होता है।



आखिरी समस्या टोकन एक स्लैश है, और यह बहुत ही अनपेक्षित है। एक बार देख लो:

 var i, s
 s = "यहाँ एक स्ट्रिंग है"
 मैं = ०
 /[az]/g.exec(s)

1-3 लाइनों में, हम चर शुरू करते हैं, और चौथे पर हम रेक्स संदर्भ शाब्दिक "/ [az] / g" लिखते हैं, जो विश्व स्तर पर az को पाता है, और फिर हम इस रेगेक्स को निष्पादन विधि का उपयोग करके स्ट्रिंग के साथ कहते हैं। चूंकि निष्पादन का वापसी मूल्य () का उपयोग नहीं किया गया है, कोड विशेष रूप से उपयोगी नहीं है, लेकिन हम इसे कम से कम संकलन की उम्मीद करेंगे। हालांकि, स्लैश न केवल regexp शुरू करता है, बल्कि एक डिवीजन ऑपरेटर भी है। इसका अर्थ है कि लाइन 4 पर अग्रणी स्लैश को पिछली लाइन पर असाइनमेंट ऑपरेटर की निरंतरता के रूप में पार्स किया जाएगा। इन पंक्तियों को "i" के बराबर [az] द्वारा विभाजित करके g.exec (s) द्वारा विभाजित किया जाएगा।



व्यवहार में, यह समस्या लगभग कभी नहीं उठती है, क्योंकि regexp ऑपरेटर को शुरू करने के कुछ कारण हैं। ऊपर दिए गए उदाहरण में, निष्पादन के लिए कॉल का मूल्य () आमतौर पर एक फ़ंक्शन को दिया जाएगा या किसी चर को सौंपा जाएगा, किसी भी स्थिति में लाइन स्लैश से शुरू नहीं होगी। एक संभावित अपवाद, फिर से, पूर्व विधि है, जिसे आप निष्पादन निष्पादित () द्वारा लौटाए गए मूल्य पर [ मूल: उपयोगी रूप से उपयोग ] कर सकते हैं।



संचालकों "+" और "-" का उपयोग यूनिरी के रूप में किया जा सकता है, मान को संख्या प्रकार में परिवर्तित करने के लिए, और "-" के मामले में साइन को उल्टा करने के लिए। जब ";" के साथ एक पंक्ति की शुरुआत में उपयोग किया जाता है उन्हें संबंधित बाइनरी ऑपरेटर और पिछले ऑपरेटर की निरंतरता के रूप में माना जा सकता है। लेकिन यह शायद ही कभी एक समस्या है, क्योंकि प्रारंभिक एकरी संचालक regexp से भी कम सामान्य है (और यह भी पूर्ण नहीं दिखता है)। रेगेक्स के साथ, यदि कोई प्रोग्रामर किसी नंबर पर वैल्यू डालना चाहता है, तो वह किसी तरह इस वैल्यू का इस्तेमाल करेगा, इसे एक वैरिएबल को असाइन करेगा, या इसे एक फंक्शन में पास करेगा, और किसी भी स्थिति में यूनीरी ऑपरेटर शुरुआत में नहीं होगा:

 var x, y, z
 x = + y;  // उपयोगी
 य = -य;  // उपयोगी
 प्रिंट (-य);  // उपयोगी
 + z;  // बेकार

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

गलतफहमी

कई नौसिखिया जावास्क्रिप्ट प्रोग्रामर को ";" हर जगह, और वे मानते हैं कि यदि वे ऑटो-इंसर्ट नियमों का उपयोग नहीं करते हैं ";", भाषा की इस संपत्ति को अनदेखा किया जा सकता है। ऊपर दिए गए सीमित पीढ़ी के नियमों, विशेष रूप से रिटर्न स्टेटमेंट के कारण यह मामला नहीं है। और जब वे सीमित स्पैनिंग से परिचित हो जाते हैं, तो वे लाइन ब्रेक से डरने लगते हैं, और जब वे पठनीयता में सुधार करते हैं, तब भी दूर हो जाते हैं। ऑटो-इन्सर्ट के नियमों को सीखना सबसे अच्छा है ";" किसी भी कोड को पढ़ने में सक्षम होने के लिए, और सबसे स्पष्ट तरीके से कोड लिखने में सक्षम होना चाहिए।



एक और गलत धारणा यह है कि जावास्क्रिप्ट ब्राउज़र इंजन में कीड़े का मतलब है कि अर्धविराम हर जगह अधिक विश्वसनीय हैं, और इससे संगतता में सुधार होता है। यह बस ऐसा नहीं है। सभी मौजूदा ब्राउज़र ऑटो-इन्सर्ट के संबंध में विनिर्देश को सही ढंग से कार्यान्वित करते हैं ";", और जो भी बग मौजूद हो सकते थे वे लंबे समय तक वेब के प्रारंभिक इतिहास के अंधेरे में चले गए थे। ब्राउज़र संगतता के बारे में चिंता करने का कोई कारण नहीं है: सभी ब्राउज़र ऊपर वर्णित इन नियमों को लागू करते हैं।

निष्कर्ष

क्या मुझे अर्धविराम लगाना चाहिए? आपका व्यवसाय बस, चुनाव सूचना के आधार पर किया जाना चाहिए, और अज्ञात वाक्यविन्यास जाल या कोई भी ब्राउज़र ब्राउज़र के बारे में अस्पष्ट आशंका नहीं। यदि आप इन नियमों को याद करते हैं, तो आप सही विकल्प के लिए सशस्त्र हैं, और जावास्क्रिप्ट में कोड को पढ़ना आसान होगा।



यदि आप "नहीं?" का निर्णय लेते हैं, तो मैं आपको सलाह देता हूं कि आप अपने साथ शुरू होने वाले ऑपरेटरों में उन्हें खोलने वाले कोष्ठक से पहले रखें, और ऐसे ऑपरेटरों में "/", "+", "-" के साथ शुरू करें, यदि आप ऐसा ऑपरेटर लिखने के लिए करते हैं।



अर्धविरामों के बावजूद, सीमित पीढ़ी (वापसी, तोड़ना, जारी रखना, फेंकना और उपसर्ग वृद्धि और क्षय संचालकों) के लिए नियमों को याद रखें, और आप कोड की सुविधा और पठनीयता के लिए किसी भी अन्य स्थानों पर लाइनें तोड़ सकते हैं।