જાવાસ્ક્રિપ્ટ પેટર્ન મેચિંગ રેગ્યુલર એક્સપ્રેશન્સ સાથે: એક વ્યાપક માર્ગદર્શિકા

રેગ્યુલર એક્સપ્રેશન્સ (રેજેક્સ) જાવાસ્ક્રિપ્ટમાં પેટર્ન મેચિંગ અને ટેક્સ્ટ મેનીપ્યુલેશન માટે એક શક્તિશાળી સાધન છે. તે ડેવલપર્સને નિર્ધારિત પેટર્નના આધારે સ્ટ્રિંગ્સને શોધવા, માન્ય કરવા અને રૂપાંતરિત કરવાની મંજૂરી આપે છે. આ માર્ગદર્શિકા જાવાસ્ક્રિપ્ટમાં રેગ્યુલર એક્સપ્રેશન્સની વ્યાપક ઝાંખી પૂરી પાડે છે, જેમાં સિન્ટેક્સ, ઉપયોગ અને અદ્યતન તકનીકોને આવરી લેવામાં આવી છે.

રેગ્યુલર એક્સપ્રેશન્સ શું છે?

રેગ્યુલર એક્સપ્રેશન એ અક્ષરોનો ક્રમ છે જે શોધ પેટર્નને વ્યાખ્યાયિત કરે છે. આ પેટર્નનો ઉપયોગ સ્ટ્રિંગ્સને મેચ કરવા અને મેનીપ્યુલેટ કરવા માટે થાય છે. રેગ્યુલર એક્સપ્રેશન્સનો ઉપયોગ પ્રોગ્રામિંગમાં વ્યાપકપણે થાય છે, જેવા કે:

• ડેટા વેલિડેશન: વપરાશકર્તા ઇનપુટ ચોક્કસ ફોર્મેટને અનુરૂપ છે તેની ખાતરી કરવી (દા.ત., ઇમેઇલ એડ્રેસ, ફોન નંબર).
• ડેટા એક્સટ્રેક્શન: ટેક્સ્ટમાંથી ચોક્કસ માહિતી પુનઃપ્રાપ્ત કરવી (દા.ત., તારીખો, URLs, અથવા કિંમતો કાઢવી).
• શોધો અને બદલો: જટિલ પેટર્નના આધારે ટેક્સ્ટ શોધવું અને બદલવું.
• ટેક્સ્ટ પ્રોસેસિંગ: નિર્ધારિત નિયમોના આધારે સ્ટ્રિંગ્સને વિભાજીત કરવું, જોડવું, અથવા રૂપાંતરિત કરવું.

જાવાસ્ક્રિપ્ટમાં રેગ્યુલર એક્સપ્રેશન્સ બનાવવું

જાવાસ્ક્રિપ્ટમાં, રેગ્યુલર એક્સપ્રેશન્સ બે રીતે બનાવી શકાય છે:

1. રેગ્યુલર એક્સપ્રેશન લિટરલનો ઉપયોગ કરીને: પેટર્નને ફોરવર્ડ સ્લેશ (/) ની અંદર મૂકો.
2. RegExp કન્સ્ટ્રક્ટરનો ઉપયોગ કરીને: પેટર્નને સ્ટ્રિંગ તરીકે સાથે RegExp ઑબ્જેક્ટ બનાવો.

ઉદાહરણ:

// Using a regular expression literal
const regexLiteral = /hello/;

// Using the RegExp constructor
const regexConstructor = new RegExp("hello");

બંને પદ્ધતિઓ વચ્ચેની પસંદગી એના પર નિર્ભર કરે છે કે પેટર્ન કમ્પાઈલ સમયે જ્ઞાત છે કે ગતિશીલ રીતે જનરેટ થયેલ છે. જ્યારે પેટર્ન નિશ્ચિત હોય અને અગાઉથી જાણીતી હોય ત્યારે લિટરલ નોટેશનનો ઉપયોગ કરો. જ્યારે પેટર્નને પ્રોગ્રામેટિકલી બનાવવાની જરૂર હોય, ખાસ કરીને જ્યારે વેરિયેબલ્સનો સમાવેશ થતો હોય ત્યારે કન્સ્ટ્રક્ટરનો ઉપયોગ કરો.

મૂળભૂત રેજેક્સ સિન્ટેક્સ

રેગ્યુલર એક્સપ્રેશન્સમાં એવા અક્ષરો હોય છે જે મેચ થનારી પેટર્નનું પ્રતિનિધિત્વ કરે છે. અહીં કેટલાક મૂળભૂત રેજેક્સ ઘટકો છે:

• લિટરલ કેરેક્ટર્સ: અક્ષરોને પોતાની રીતે મેચ કરે છે (દા.ત., /a/ 'a' અક્ષરને મેચ કરે છે).
• મેટાકેરેક્ટર્સ: ખાસ અર્થ ધરાવે છે (દા.ત., ., ^, $, *, +, ?, [], {}, (), \, |).
• કેરેક્ટર ક્લાસીસ: અક્ષરોના સેટનું પ્રતિનિધિત્વ કરે છે (દા.ત., [abc] 'a', 'b', અથવા 'c' ને મેચ કરે છે).
• ક્વોન્ટિફાયર્સ: કોઈ અક્ષર અથવા જૂથ કેટલી વખત આવવું જોઈએ તે સ્પષ્ટ કરે છે (દા.ત., *, +, ?, {n}, {n,}, {n,m}).
• એન્કર્સ: સ્ટ્રિંગમાં સ્થિતિઓને મેચ કરે છે (દા.ત., ^ શરૂઆતને મેચ કરે છે, $ અંતને મેચ કરે છે).

સામાન્ય મેટાકેરેક્ટર્સ:

• . (ડોટ): નવી લાઇન સિવાયના કોઈપણ એક અક્ષરને મેચ કરે છે.
• ^ (કેરેટ): સ્ટ્રિંગની શરૂઆતને મેચ કરે છે.
• $ (ડોલર): સ્ટ્રિંગના અંતને મેચ કરે છે.
• * (એસ્ટરિસ્ક): આગળના અક્ષર અથવા જૂથની શૂન્ય અથવા વધુ ઘટનાઓને મેચ કરે છે.
• + (પ્લસ): આગળના અક્ષર અથવા જૂથની એક અથવા વધુ ઘટનાઓને મેચ કરે છે.
• ? (પ્રશ્ન ચિહ્ન): આગળના અક્ષર અથવા જૂથની શૂન્ય અથવા એક ઘટનાને મેચ કરે છે. વૈકલ્પિક અક્ષરો માટે વપરાય છે.
• [] (ચોરસ કૌંસ): એક કેરેક્ટર ક્લાસ વ્યાખ્યાયિત કરે છે, કૌંસની અંદરના કોઈપણ એક અક્ષરને મેચ કરે છે.
• {} (છગડીયા કૌંસ): મેચ કરવા માટેની ઘટનાઓની સંખ્યા સ્પષ્ટ કરે છે. {n} બરાબર n વખત મેચ કરે છે, {n,} n અથવા વધુ વખત મેચ કરે છે, {n,m} n અને m વખતની વચ્ચે મેચ કરે છે.
• () (ગોળ કૌંસ): અક્ષરોને એકસાથે જૂથબદ્ધ કરે છે અને મેચ થયેલ સબસ્ટ્રિંગને કેપ્ચર કરે છે.
• \ (બેકસ્લેશ): મેટાકેરેક્ટર્સને એસ્કેપ કરે છે, જેથી તમે તેમને શાબ્દિક રીતે મેચ કરી શકો.
• | (પાઈપ): "અથવા" ઓપરેટર તરીકે કાર્ય કરે છે, તેની પહેલાં કે પછીના એક્સપ્રેશનને મેચ કરે છે.

કેરેક્ટર ક્લાસીસ:

• [abc]: a, b, અથવા c અક્ષરોમાંથી કોઈ એકને મેચ કરે છે.
• [^abc]: a, b, અથવા c *ન હોય* તેવા કોઈપણ અક્ષરને મેચ કરે છે.
• [a-z]: a થી z સુધીના કોઈપણ નાના અક્ષરને મેચ કરે છે.
• [A-Z]: A થી Z સુધીના કોઈપણ મોટા અક્ષરને મેચ કરે છે.
• [0-9]: 0 થી 9 સુધીના કોઈપણ અંકને મેચ કરે છે.
• [a-zA-Z0-9]: કોઈપણ આલ્ફાન્યૂમેરિક અક્ષરને મેચ કરે છે.
• \d: કોઈપણ અંકને મેચ કરે છે ([0-9] ની સમકક્ષ).
• \D: કોઈપણ બિન-અંક અક્ષરને મેચ કરે છે ([^0-9] ની સમકક્ષ).
• \w: કોઈપણ શબ્દ અક્ષરને મેચ કરે છે (આલ્ફાન્યૂમેરિક વત્તા અન્ડરસ્કોર; [a-zA-Z0-9_] ની સમકક્ષ).
• \W: કોઈપણ બિન-શબ્દ અક્ષરને મેચ કરે છે ([^a-zA-Z0-9_] ની સમકક્ષ).
• \s: કોઈપણ વ્હાઇટસ્પેસ અક્ષરને મેચ કરે છે (સ્પેસ, ટેબ, નવી લાઇન, વગેરે).
• \S: કોઈપણ બિન-વ્હાઇટસ્પેસ અક્ષરને મેચ કરે છે.

ક્વોન્ટિફાયર્સ:

• *: આગળના ઘટકને શૂન્ય અથવા વધુ વખત મેચ કરે છે. ઉદાહરણ તરીકે, a* "", "a", "aa", "aaa", અને તેથી વધુને મેચ કરે છે.
• +: આગળના ઘટકને એક અથવા વધુ વખત મેચ કરે છે. ઉદાહરણ તરીકે, a+ "a", "aa", "aaa" ને મેચ કરે છે, પરંતુ "" ને નહીં.
• ?: આગળના ઘટકને શૂન્ય અથવા એક વખત મેચ કરે છે. ઉદાહરણ તરીકે, a? "" અથવા "a" ને મેચ કરે છે.
• {n}: આગળના ઘટકને બરાબર *n* વખત મેચ કરે છે. ઉદાહરણ તરીકે, a{3} "aaa" ને મેચ કરે છે.
• {n,}: આગળના ઘટકને *n* અથવા વધુ વખત મેચ કરે છે. ઉદાહરણ તરીકે, a{2,} "aa", "aaa", "aaaa", અને તેથી વધુને મેચ કરે છે.
• {n,m}: આગળના ઘટકને *n* અને *m* વખતની વચ્ચે (સમાવિષ્ટ) મેચ કરે છે. ઉદાહરણ તરીકે, a{2,4} "aa", "aaa", અથવા "aaaa" ને મેચ કરે છે.

એન્કર્સ:

• ^: સ્ટ્રિંગની શરૂઆતને મેચ કરે છે. ઉદાહરણ તરીકે, ^Hello તે સ્ટ્રિંગ્સને મેચ કરે છે જે "Hello" થી *શરૂ* થાય છે.
• $: સ્ટ્રિંગના અંતને મેચ કરે છે. ઉદાહરણ તરીકે, World$ તે સ્ટ્રિંગ્સને મેચ કરે છે જે "World" થી *અંત* થાય છે.
• \b: શબ્દની સીમાને મેચ કરે છે. આ એક શબ્દ અક્ષર (\w) અને બિન-શબ્દ અક્ષર (\W) વચ્ચેની સ્થિતિ અથવા સ્ટ્રિંગની શરૂઆત કે અંત છે. ઉદાહરણ તરીકે, \bword\b સંપૂર્ણ શબ્દ "word" ને મેચ કરે છે.

ફ્લેગ્સ:

રેજેક્સ ફ્લેગ્સ રેગ્યુલર એક્સપ્રેશન્સના વર્તનને સુધારે છે. તે રેજેક્સ લિટરલના અંતમાં ઉમેરવામાં આવે છે અથવા RegExp કન્સ્ટ્રક્ટરને બીજા આર્ગ્યુમેન્ટ તરીકે પસાર કરવામાં આવે છે.

• g (ગ્લોબલ): પેટર્નની બધી ઘટનાઓને મેચ કરે છે, માત્ર પ્રથમ જ નહીં.
• i (ઇગ્નોર કેસ): કેસ-ઇનસેન્સિટિવ મેચિંગ કરે છે.
• m (મલ્ટિલાઇન): મલ્ટિલાઇન મોડને સક્ષમ કરે છે, જ્યાં ^ અને $ દરેક લાઇન (\n દ્વારા વિભાજિત) ની શરૂઆત અને અંતને મેચ કરે છે.
• s (ડોટઓલ): ડોટ (.) ને નવી લાઇન અક્ષરોને પણ મેચ કરવાની મંજૂરી આપે છે.
• u (યુનિકોડ): સંપૂર્ણ યુનિકોડ સપોર્ટને સક્ષમ કરે છે.
• y (સ્ટીકી): રેજેક્સની lastIndex પ્રોપર્ટી દ્વારા દર્શાવેલ ઇન્ડેક્સથી જ મેચ કરે છે.

જાવાસ્ક્રિપ્ટ રેજેક્સ મેથડ્સ

જાવાસ્ક્રિપ્ટ રેગ્યુલર એક્સપ્રેશન્સ સાથે કામ કરવા માટે ઘણી મેથડ્સ પૂરી પાડે છે:

• test(): કોઈ સ્ટ્રિંગ પેટર્ન સાથે મેચ થાય છે કે નહીં તે તપાસે છે. true અથવા false પરત કરે છે.
• exec(): સ્ટ્રિંગમાં મેચ માટે શોધ ચલાવે છે. મેચ થયેલ ટેક્સ્ટ અને કેપ્ચર થયેલ જૂથો ધરાવતો એરે પરત કરે છે, અથવા જો કોઈ મેચ ન મળે તો null પરત કરે છે.
• match(): સ્ટ્રિંગને રેગ્યુલર એક્સપ્રેશન સામે મેચ કરવાના પરિણામો ધરાવતો એરે પરત કરે છે. g ફ્લેગ સાથે અને વગર અલગ રીતે વર્તે છે.
• search(): સ્ટ્રિંગમાં મેચ માટે પરીક્ષણ કરે છે. પ્રથમ મેચનો ઇન્ડેક્સ પરત કરે છે, અથવા જો કોઈ મેચ ન મળે તો -1 પરત કરે છે.
• replace(): પેટર્નની ઘટનાઓને રિપ્લેસમેન્ટ સ્ટ્રિંગ અથવા રિપ્લેસમેન્ટ સ્ટ્રિંગ પરત કરતા ફંક્શનથી બદલે છે.
• split(): સ્ટ્રિંગને રેગ્યુલર એક્સપ્રેશનના આધારે સબસ્ટ્રિંગ્સના એરેમાં વિભાજીત કરે છે.

રેજેક્સ મેથડ્સનો ઉપયોગ કરીને ઉદાહરણો:

// test()
const regex = /hello/;
const str = "hello world";
console.log(regex.test(str)); // Output: true

// exec()
const regex2 = /hello (\w+)/;
const str2 = "hello world";
const result = regex2.exec(str2);
console.log(result); // Output: ["hello world", "world", index: 0, input: "hello world", groups: undefined]

// match() with 'g' flag
const regex3 = /\d+/g; // Matches one or more digits globally
const str3 = "There are 123 apples and 456 oranges.";
const matches = str3.match(regex3);
console.log(matches); // Output: ["123", "456"]

// match() without 'g' flag
const regex4 = /\d+/;
const str4 = "There are 123 apples and 456 oranges.";
const match = str4.match(regex4);
console.log(match); // Output: ["123", index: 11, input: "There are 123 apples and 456 oranges.", groups: undefined]

// search()
const regex5 = /world/;
const str5 = "hello world";
console.log(str5.search(regex5)); // Output: 6

// replace()
const regex6 = /world/;
const str6 = "hello world";
const newStr = str6.replace(regex6, "JavaScript");
console.log(newStr); // Output: hello JavaScript

// replace() with a function
const regex7 = /(\d+)-(\d+)-(\d+)/;
const str7 = "Today's date is 2023-10-27";
const newStr2 = str7.replace(regex7, (match, year, month, day) => {
  return `${day}/${month}/${year}`;
});
console.log(newStr2); // Output: Today's date is 27/10/2023

// split()
const regex8 = /, /;
const str8 = "apple, banana, cherry";
const arr = str8.split(regex8);
console.log(arr); // Output: ["apple", "banana", "cherry"]

અદ્યતન રેજેક્સ તકનીકો

કેપ્ચરિંગ ગ્રુપ્સ:

કૌંસ () નો ઉપયોગ રેગ્યુલર એક્સપ્રેશન્સમાં કેપ્ચરિંગ ગ્રુપ્સ બનાવવા માટે થાય છે. કેપ્ચર થયેલ ગ્રુપ્સ તમને મેચ થયેલ ટેક્સ્ટના ચોક્કસ ભાગોને કાઢવાની મંજૂરી આપે છે. exec() અને match() મેથડ્સ એક એરે પરત કરે છે જ્યાં પ્રથમ ઘટક સંપૂર્ણ મેચ હોય છે, અને પછીના ઘટકો કેપ્ચર થયેલ ગ્રુપ્સ હોય છે.

const regex = /(\d{4})-(\d{2})-(\d{2})/;
const dateString = "2023-10-27";
const match = regex.exec(dateString);

console.log(match[0]); // Output: 2023-10-27 (The entire match)
console.log(match[1]); // Output: 2023 (The first captured group - year)
console.log(match[2]); // Output: 10 (The second captured group - month)
console.log(match[3]); // Output: 27 (The third captured group - day)

નામવાળા કેપ્ચરિંગ ગ્રુપ્સ:

ES2018 એ નામવાળા કેપ્ચરિંગ ગ્રુપ્સ રજૂ કર્યા, જે તમને (?...) સિન્ટેક્સનો ઉપયોગ કરીને કેપ્ચરિંગ ગ્રુપ્સને નામ આપવાની મંજૂરી આપે છે. આ કોડને વધુ વાંચનીય અને જાળવણીપાત્ર બનાવે છે.

const regex = /(?\d{4})-(?\d{2})-(?\d{2})/;
const dateString = "2023-10-27";
const match = regex.exec(dateString);

console.log(match.groups.year);  // Output: 2023
console.log(match.groups.month); // Output: 10
console.log(match.groups.day);   // Output: 27

નોન-કેપ્ચરિંગ ગ્રુપ્સ:

જો તમારે રેજેક્સના ભાગોને કેપ્ચર કર્યા વિના જૂથબદ્ધ કરવાની જરૂર હોય (દા.ત., જૂથ પર ક્વોન્ટિફાયર લાગુ કરવા માટે), તો તમે (?:...) સિન્ટેક્સ સાથે નોન-કેપ્ચરિંગ ગ્રુપનો ઉપયોગ કરી શકો છો. આ કેપ્ચર થયેલ ગ્રુપ્સ માટે બિનજરૂરી મેમરી ફાળવણીને ટાળે છે.

const regex = /(?:https?:\/\/)?([\w\.]+)/; // Matches a URL but only captures the domain name
const url = "https://www.example.com/path";
const match = regex.exec(url);

console.log(match[1]); // Output: www.example.com

લુકાહેડ્સ:

લુકાહેડ્સ શૂન્ય-પહોળાઈના એસર્શન્સ છે જે સ્ટ્રિંગમાં એક એવી સ્થિતિને મેચ કરે છે જે એક પેટર્ન પર આધારિત હોય છે જે તે સ્થિતિની પહેલા (લુકબિહાઈન્ડ) અથવા પછી (લુકાહેડ) આવે છે, લુકાહેડ પેટર્નને મેચમાં સમાવ્યા વિના.

• પોઝિટિવ લુકાહેડ: (?=...) જો લુકાહેડની અંદરની પેટર્ન વર્તમાન સ્થિતિને *અનુસરે* તો મેચ કરે છે.
• નેગેટિવ લુકાહેડ: (?!...) જો લુકાહેડની અંદરની પેટર્ન વર્તમાન સ્થિતિને *ન અનુસરે* તો મેચ કરે છે.
• પોઝિટિવ લુકબિહાઈન્ડ: (?<=...) જો લુકબિહાઈન્ડની અંદરની પેટર્ન વર્તમાન સ્થિતિની *પહેલાં* આવે તો મેચ કરે છે.
• નેગેટિવ લુકબિહાઈન્ડ: (? જો લુકબિહાઈન્ડની અંદરની પેટર્ન વર્તમાન સ્થિતિની *પહેલાં ન આવે* તો મેચ કરે છે.

// Positive Lookahead: Get the price only when followed by USD
const regex = /\d+(?= USD)/;
const text = "The price is 100 USD";
const match = text.match(regex);
console.log(match); // Output: ["100"]

// Negative Lookahead: Get the word only when not followed by a number
const regex2 = /\b\w+\b(?! \d)/;
const text2 = "apple 123 banana orange 456";
const matches = text2.match(regex2);
console.log(matches); // Output: null because match() only returns the first match without 'g' flag, which isn't what we need.
// to fix it:
const regex3 = /\b\w+\b(?! \d)/g;
const text3 = "apple 123 banana orange 456";
const matches3 = text3.match(regex3);
console.log(matches3); // Output: [ 'banana' ]

// Positive Lookbehind: Get the value only when preceded by $
const regex4 = /(?<=\$)\d+/;
const text4 = "The price is $200";
const match4 = text4.match(regex4);
console.log(match4); // Output: ["200"]

// Negative Lookbehind: Get the word only when not preceded by the word 'not'
const regex5 = /(?

const regex = /([a-z]+) \1/;
const text = "hello hello world";
const match = regex.exec(text);
console.log(match); // Output: ["hello hello", "hello", index: 0, input: "hello hello world", groups: undefined]

const emailRegex = /^[\w-\.]+@([\w-]+\.)+[\w-]{2,4}$/;

console.log(emailRegex.test("test@example.com"));    // Output: true
console.log(emailRegex.test("invalid-email"));       // Output: false
console.log(emailRegex.test("test@sub.example.co.uk")); // Output: true

const urlRegex = /https?:\/\/(www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_\+.~#?&//=]*)/g;
const text = "Visit our website at https://www.example.com or check out http://blog.example.org.";
const urls = text.match(urlRegex);
console.log(urls); // Output: ["https://www.example.com", "http://blog.example.org"]

const csvString = 'John,Doe,"123, Main St",New York';
const csvRegex = /(?:"([^"]*(?:""[^"]*)*)")|([^,]+)/g; //Corrected CSV regex
let values = [];
let match;  

while (match = csvRegex.exec(csvString)) {
  values.push(match[1] ? match[1].replace(/""/g, '"') : match[2]);
}


console.log(values); // Output: ["John", "Doe", "123, Main St", "New York"]

const phoneRegex = /^\+(?:[0-9] ?){6,14}[0-9]$/;
console.log(phoneRegex.test("+1 555 123 4567")); // Output: true (US Example)
console.log(phoneRegex.test("+44 20 7946 0500")); // Output: true (UK Example)
console.log(phoneRegex.test("+81 3 3224 5000"));  // Output: true (Japan Example)
console.log(phoneRegex.test("123-456-7890"));   // Output: false

const passwordRegex = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)[a-zA-Z\d]{8,}$/;

console.log(passwordRegex.test("P@ssword123")); // Output: true
console.log(passwordRegex.test("password"));       // Output: false (no uppercase or number)
console.log(passwordRegex.test("Password"));       // Output: false (no number)
console.log(passwordRegex.test("Pass123"));        // Output: false (no lowercase)
console.log(passwordRegex.test("P@ss1"));          // Output: false (less than 8 characters)