जावास्क्रिप्ट में वीएस निष्पादन

Question

मुझे जावास्क्रिप्ट में मैच बनाम exec के लिए कुछ स्पष्टीकरण की आवश्यकता है; here कुछ एक का कहना है कि

लेकिन सब से पहले तुम मेरे उदाहरण में देख के रूप में यह स्थिति नहीं है "एक वैश्विक नियमित अभिव्यक्ति के साथ कार्यकारी एक पाश में इस्तेमाल किया जा करने के लिए है"; मेरे उदाहरण में वैश्विक नियमित अभिव्यक्ति के साथ निष्पादन एक सरणी में सभी मैचों को वापस कर रहा है! दूसरा, वे कहते हैं कि String.match के लिए यह सभी मैचों को लौटाने की ज़रूरत नहीं है! लेकिन फिर से यह मेरे उदाहरण में नहीं हो रहा है और यह सिर्फ इनपुट स्ट्रिंग को वापस कर रहा है? क्या मैंने कुछ गलत समझा/किया है?

var myString = "[22].[44].[33]."; 
var myRegexp = /.*\[(\d*)*\].*\[(\d*)*\].*\[(\d*)*\].*/g; 

var execResult = myRegexp.exec(myString); 
console.log(execResult.length); 
console.log(execResult[1]);// returns 22 and execResult has all of my matches from index 1 to the length of array 


var matchResult = myString.match(myRegexp); 
console.log(matchResult.length); 
console.log(matchResult);// returns just myString which is "[22].[44].[33]."! Why is that? 

Answer 1

1. string.match पहला मैच पाता है और वास्तविक मैच के साथ देता है, जब वैश्विक ध्वज नहीं किया जाता है, जिस पर सूचकांक पाठ मिला था और वास्तविक इनपुट, ।

2. string.match वैश्विक ध्वज का उपयोग होने पर सभी मैच, लौटाता है।

   var myString = "[22].[44].[33]."; 
   
   console.log(myString.match(/\d+/)); 
   # [ '22', index: 1, input: '[22].[44].[33].' ] 
   console.log(myString.match(/\d+/g)); 
   # [ '22', '44', '33' ] 
   

string.match और regex.exec के बीच मुख्य अंतर है, regex वस्तु regex.exec कॉल के साथ मौजूदा मैच के अद्यतन किया जाएगा। उदाहरण के लिए,

var myString = "[22].[44].[33].", myRegexp = /\d+/g, result; 

while (result = myRegexp.exec(myString)) { 
    console.log(result, myRegexp.lastIndex); 
} 

वापस आ जाएगी

[ '22', index: 1, input: '[22].[44].[33].' ] 3 
[ '44', index: 6, input: '[22].[44].[33].' ] 8 
[ '33', index: 11, input: '[22].[44].[33].' ] 13 

आप देख सकते हैं, lastIndex संपत्ति अद्यतन किया जाता है जब भी मिलान हो जाता है। इसलिए, जब आप exec, या का उपयोग करते हैं तो आप दो चीजों को ध्यान में रखें, आप एक अनंत लूप में भाग लेंगे।

1. आप g विकल्प का उपयोग नहीं करते हैं, तो आप हमेशा पहले मैच मिल जाएगा अगर वहाँ एक null है, अन्यथा। तो, निम्नलिखित एक अनंत लूप में चला जाएगा।

   var myString = "[22].[44].[33].", myRegexp = /\d+/, result; 
   
   while (result = myRegexp.exec(myString)) { 
       console.log(result, myRegexp.lastIndex); 
   } 
   

2. बाद के कॉल के साथ समान नियमित अभिव्यक्ति ऑब्जेक्ट का उपयोग करना न भूलें। क्योंकि, regex ऑब्जेक्ट हर बार अद्यतन किया जाता है, और यदि आप नई ऑब्जेक्ट पास करते हैं, तो प्रोग्राम एक अनंत लूप में चला जाएगा।

   var myString = "[22].[44].[33].", result; 
   
   while (result = /\d+/g.exec(myString)) { 
       console.log(result); 
   } 
   

Answer 2

String.prototype.match() और RegExp.prototype.exec() दोनों अनेक गतिविधियां खोजने और उन्हें एक सरणी में लौटने में समान हैं। फिर भी निष्पादन विधि अधिक विस्तृत जानकारी की एक सरणी देता है। उदाहरण के लिए मैच के विपरीत यह कैप्चर समूहों की कई घटनाएं भी पा सकता है। तो यदि आपके पास समूह समूह हैं, तो निष्पादन आवश्यक है। निष्पादन के साथ काम करते समय ध्यान में रखना एक बात है यदि आपको शाब्दिक regexp से नहीं आना चाहिए। अपने रेगेक्स को पहले एक वैरिएबल पर असाइन करें और इसे अपनी निष्पादन विधि से कॉल करने के लिए उपयोग करें। एक और बात यह है कि, जबकि मैच एक ही समय में वस्तुओं की एक श्रृंखला में कई घटनाएं लाएगा, निष्पादन के साथ आपको प्रत्येक घटना को कैप्चर करने के लिए पुनरावृत्ति करना होगा।

मिलान का मिलान काफी सरल है।चूंकि यह एक स्ट्रिंग प्रोटोटाइप विधि है, इसलिए आप इसे एक स्ट्रिंग पर ले जाते हैं और मैच विधि के लिए तर्क के रूप में regexp प्रदान करते हैं; "परीक्षण"। मैच (/ es ​​/) किसी रेगेक्स का शाब्दिक प्रतिनिधित्व किसी समस्या के साथ उपयोग नहीं किया जा सकता है।

लागू कार्यकारी अधिक जटिल है। जैसा कि मैंने पहले उल्लेख किया था कि रेगेक्स को पहले कुछ सौंपा गया है। ठीक एक उदाहरण

var text = '["job name 1","nat 1"],["job name 2","nat 2"],["job name 3","nat 3"]', 
 
    reg = /([^"]+)","([^"]+)/g, 
 
     tm = [], 
 
     te = []; 
 

 
tm = text.match(reg); // tm has result of match 
 
while(te[te.length]=reg.exec(text)); // te has result of exec + an extra null item at the end 
 
te.length--; // te normalized. 
 

 
document.write("<pre>" + JSON.stringify(tm,null,2) + "</pre>\n"); 
 
document.write("<pre>" + JSON.stringify(te,null,2) + "</pre>\n");

जैसा कि आप देख कार्यकारी के परिणाम भी कैप्चर समूहों में शामिल हैं देख सकते हैं। जिस तरह से मैं te सरणी को पॉप्युलेट करना चुनता हूं वह कुछ हद तक अपरंपरागत है लेकिन मुझे लूप के सशर्त हिस्से में एक अस्थायी सरणी का उपयोग करने से नफरत है। यह मुझे और अधिक साफ दिखता है। एकमात्र चीज यह है कि te सरणी के अंत में लूप को रोकने के लिए अंतिम शून्य। इसलिए निम्नलिखित te.length-- निर्देश।