RegExp Type in JavaScript

RegExp Type in JavaScript – ECMAScript RegExp Type द्वारा Regular Expressions को Support करता है। Regular Expressions को निम्नानुसार Syntax द्वारा आसानी से Create किया जा सकता है, जो कि Perl Syntax की तरह ही होता है:

      var expression = /pattern/flags;

इस Syntax का pattern Part कोई भी Simple या Complex Regular Expression हो सकता है। हर Expression में Zero या अधिक Flags हो सकते हैं जो इस बात को Indicate करते हैं कि Expression किस प्रकार से Behave करेगा। ECMAScript में तीन Supported Flags हैं जो तीन अलग Matching Modes को Represent करते हैं। ये Flags निम्नानुसार हैं:

g – ये Flag Global Mode को Represent करता है। यानी इस Mode को Use करने पर Specified Pattern String के सभी Matching Combinations पर Apply होंगे न कि केवल First Matching Combination पर।

i – ये Flag Case-Insensitive Mode को Represent करता है। यानी इस Mode को Use करने पर Specified Pattern String के सभी Matching Combinations पर Apply होंगे भले ही ैजतपदह में वह Pattern Capital Case में हो या Lower Case में अथवा दोनों में।

m – ये Flag Multiline Mode को Represent करता है। यानी इस Mode को Use करने पर Specified Pattern String के पहली Line के सभी Matching Combinations पर Apply होने के बाद अगली Line के सभी Matching Combination पर भी Apply होगा।

Regular Expressions को विभिन्न प्रकार के Results प्राप्त करने के लिए Pattern व Flags के Combination के रूप में Create किया जाता है। जैसे-

/* Match all instances of “at” in a string. */
var pattern1 = /at/g;

/* Match the first instance of “bat” or “cat”, regardless of case. */
var pattern2 = /[bc]at/i;

/* Match all three-character combinations ending with “at”, regardless of case. */
var pattern3 = /.at/gi;

अन्‍य Programming Languages की तरह] JavaScript में भी Pattern में Specify किए जाने वाले सभी Metacharacters को Escape करना जरूरी होता है। Regular Expressions में Use किए जा सकने वाले विभिन्न Metacharacters निम्नानुसार हैं:

      (     [     {     \    $    |     )     ?    &   +   .

Regular Expression Syntax में हर Metacharacter का एक या एक से ज्यादा उपयोग होता है। इसलिए जब हम किसी String में किसी Character Combination की Matching करने के लिए Regular Expression Pattern Create करते हैं, तो हर Metacharacter को JavaScript में एक Backslash द्वारा Escape करना जरूरी होता है। कुछ Regular Expression Patterns के उदाहरण निम्नानुसार हैं:

/* Match the first instance of “bat” or “cat”, regardless of case. */
var pattern1 = /[bc]at/i;

/* Match the first instance of “[bc]at”, regardless of case. */
var pattern2 = /\[bc\]at/i;

/* Match all three-character combinations ending with “at”, regardless of case. */
var pattern3 = /.at/gi;

/* Match all instances of “.at”, regardless of case. */
var pattern4 = /\.at/gi;

उपरोक्त Regular Expressions में pattern1 किसी Specify की जाने वाली String में Case Insensitive Form में उन सभी Patterns को Match करेगा जिनमें “b” या “c” के बाद at आया हो। जैसे- bat, Cat, Mat, gat आदि।

चूंकि “/[bc]at/i”Pattern में हमने Square Bracket Metacharacter का प्रयोग किया है, इसलिए JavaScript में हमें इसे pattern2 के साथ Specify किए गए Pattern/\[bc\]at/i की तरह Escape करना होगा।

तीसरे Patterns में ( . ) Dot Symbol इस बात को Indicate कर रहा है “at” से पहले कोई भी Character होने की स्थिति में वह String Match होगा। यदि हम String Pattern में इस Regular Expression को Specify करना चाहें, तो हमें Dot को Escape करना होगा जैसा कि pattern4 में किया गया है।

इन सभी उदाहरणों में हमने Literal Form में Regular Expressions को Crete किया है। लेकिन Regular Expressions Create करने के लिए हम RegExp Constructor को भी Use कर सकते हैं।

जब हम RegExp Constructor को Use करते हुए Regular Expression Create करते हैं, तब हमें इस Constructor में दो Arguments Pass करने होते हैं। पहला Argument Matching Pattern की एक String होता है, जबकि दूसरा Argument एक Flag होता है।

यदि हम उपरोक्त Literal Notation वाले Regular Expressions को RegExp Constructor द्वारा Create करना चाहें, तो ये काम हम निम्नानुसार कर सकते हैं:

var pattern1 = new RegExp(“/[bc]at/”, “i”);
var pattern2 = new RegExp(“[bc]at”, “i”);
var pattern3 = new RegExp(“/.at/g”, “i”);
var pattern4 = (“/\.at/g”, “i”);

चूंकि जब हम RegExp() Constructor का प्रयोग करते हैं, तब हमें Pattern व Mode दोनों को String Format में Specify करना जरूरी होता है। इसीलिए उपरोक्त चारों Patterns में हमने RegExp() Constructor में Pattern व Mode दोनों को String Format में Specify किया है।

लेकिन जब हम RegExp() Constructor में Patterns को String Format में Specify करते हैं, तब कई बार हमें Metacharacters को Double Escape करने की जरूरत पडती है, क्योंकि सामान्‍यत: RegExp() Constructor पहले Slash को Ignore कर देता है। आगे कुछ Regular Expressions के Literal Notation व RegExp() Constructor String Format को Define किया गया है, जो Concept समझने में आपकी मदद करेगा।

RegExp Instance Properties

हर RegExp Instance की कुछ Basic Properties होती हैं, जो हमें Specify किए गए Pattern के बारे में कुछ जानकारियां प्रदान करती हैं। ये Properties निम्नानुसार हैं:

global

ये एक Boolean Property है जो इस बात को Indicate करती है कि हमने हमारे Pattern के साथ “g” Flag को Set किया है या नहीं।

ignoreCase

ये भी एक Boolean Property है, जो इस बात को Indicate करती है कि हमने हमारे Pattern के साथ “i” Flag को Set किया है या नहीं।

lastIndex

ये एक Integer Value होता है जो उस Character Position को Represent करता है, जिससे Source String में अगले Pattern Matching के लिए JavaScript Searching रेगा। इस Property में Pattern Matching की शुरूआत में हमेंशा 0 होता है।

multiline

ये भी एक Boolean Property है, जो इस बात को Indicate करती है कि हमने हमारे Pattern के साथ “m” Flag को Set किया है या नहीं।

source

इस Property में RegExp Constructor में Specify किए गए Pattern का Source होता है। यानी इस Property को Use करके हम किसी RegExp Object में Specify किए गए Regular Expression के Pattern को Return करवा सकते हैं।

उपरोक्त सभी Properties को हम निम्नानुसार Use कर सकते हैं:

[code]
      var pattern1 = /\[bc\]at/i;
      alert(pattern1.global);                        //false
      alert(pattern1.ignoreCase);                    //true
      alert(pattern1.multiline);                     //false
      alert(pattern1.lastIndex);                     //0
      alert(pattern1.source);                        //”\[bc\]at”

      var pattern2 = new RegExp(“\\[bc\\]at”, “i”);
      alert(pattern2.global);                        //false
      alert(pattern2.ignoreCase);                    //true
      alert(pattern2.multiline);                     //false
      alert(pattern2.lastIndex);                     //0
      alert(pattern2.source);                        //”\[bc\]at”
[/code]

उपरोक्त Code में जब हमने RegExp()Constructor का प्रयोग करके RegExp Object Create किया है, तब हमने Double Escape तरीके को Use किया है। लेकिन जैसा कि उपरोक्त Codes की अन्तिम Line में आप देख सकते हैं, कि JavaScript ने उन Double Escapes को Single Escapes में Convert कर दिया है। RegExp() Constructor का प्रयोग करते समय हमें हमेंशा Double Escapes का प्रयोग करना चाहिए, अन्‍यथा कई बार हमें जटिल समस्याओं का सामना करना पडता है।