ரெகுலர் எக்ஸ்பிரஷன்களைப் பயன்படுத்தி மேம்பட்ட JavaScript பேட்டர்ன் மேட்சிங்கை ஆராயுங்கள். திறமையான மற்றும் வலுவான குறியீட்டிற்காக ரெஜெக்ஸ் சிண்டாக்ஸ், நடைமுறைப் பயன்பாடுகள் மற்றும் மேம்படுத்தல் நுட்பங்கள் பற்றி அறியுங்கள்.
ரெகுலர் எக்ஸ்பிரஷன்களைக் கொண்டு JavaScript பேட்டர்ன் மேட்சிங்: ஒரு விரிவான வழிகாட்டி
ரெகுலர் எக்ஸ்பிரஷன்கள் (regex) ஜாவாஸ்கிரிப்டில் பேட்டர்ன் மேட்சிங் மற்றும் டெக்ஸ்ட் கையாளுதலுக்கான ஒரு சக்திவாய்ந்த கருவியாகும். அவை டெவலப்பர்களை வரையறுக்கப்பட்ட பேட்டர்ன்களின் அடிப்படையில் ஸ்டிரிங்குகளைத் தேட, சரிபார்க்க மற்றும் மாற்ற அனுமதிக்கின்றன. இந்த வழிகாட்டி ஜாவாஸ்கிரிப்டில் உள்ள ரெகுலர் எக்ஸ்பிரஷன்கள் பற்றிய ஒரு விரிவான கண்ணோட்டத்தை வழங்குகிறது, இதில் சிண்டாக்ஸ், பயன்பாடு மற்றும் மேம்பட்ட நுட்பங்கள் அடங்கும்.
ரெகுலர் எக்ஸ்பிரஷன்கள் என்றால் என்ன?
ரெகுலர் எக்ஸ்பிரஷன் என்பது ஒரு தேடல் பேட்டர்னை வரையறுக்கும் எழுத்துகளின் வரிசையாகும். இந்த பேட்டர்ன்கள் ஸ்டிரிங்குகளைப் பொருத்தவும் கையாளவும் பயன்படுத்தப்படுகின்றன. ரெகுலர் எக்ஸ்பிரஷன்கள் நிரலாக்கத்தில் பரவலாகப் பயன்படுத்தப்படுகின்றன, அவை:
- தரவு சரிபார்ப்பு: பயனர் உள்ளீடு குறிப்பிட்ட வடிவங்களுக்கு (எ.கா., மின்னஞ்சல் முகவரிகள், தொலைபேசி எண்கள்) இணங்குகிறதா என்பதை உறுதி செய்தல்.
- தரவு பிரித்தெடுத்தல்: டெக்ஸ்டில் இருந்து குறிப்பிட்ட தகவல்களைப் பெறுதல் (எ.கா., தேதிகள், URL-கள் அல்லது விலைகளைப் பிரித்தெடுத்தல்).
- தேடி மாற்றுதல்: சிக்கலான பேட்டர்ன்களின் அடிப்படையில் டெக்ஸ்டைக் கண்டறிந்து மாற்றுதல்.
- டெக்ஸ்ட் பிராசசிங்: வரையறுக்கப்பட்ட விதிகளின் அடிப்படையில் ஸ்டிரிங்குகளைப் பிரித்தல், இணைத்தல் அல்லது மாற்றுதல்.
ஜாவாஸ்கிரிப்டில் ரெகுலர் எக்ஸ்பிரஷன்களை உருவாக்குதல்
ஜாவாஸ்கிரிப்டில், ரெகுலர் எக்ஸ்பிரஷன்களை இரண்டு வழிகளில் உருவாக்கலாம்:
- ரெகுலர் எக்ஸ்பிரஷன் லிட்டரலைப் பயன்படுத்துதல்: பேட்டர்னை முன்னோக்கிச் சாய்க்கோடுகளுக்குள் (
/) வைப்பது. RegExpகன்ஸ்ட்ரக்டரைப் பயன்படுத்துதல்: பேட்டர்னை ஒரு ஸ்டிரிங்காகக் கொண்டு ஒருRegExpஆப்ஜெக்டை உருவாக்குதல்.
எடுத்துக்காட்டு:
// ரெகுலர் எக்ஸ்பிரஷன் லிட்டரலைப் பயன்படுத்துதல்
const regexLiteral = /hello/;
// RegExp கன்ஸ்ட்ரக்டரைப் பயன்படுத்துதல்
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" என்ற முழு வார்த்தையைப் பொருத்தும்.
பிளாகுகள் (Flags):
ரெஜெக்ஸ் பிளாகுகள் ரெகுலர் எக்ஸ்பிரஷன்களின் நடத்தையை மாற்றியமைக்கின்றன. அவை ரெஜெக்ஸ் லிட்டரலின் முடிவில் சேர்க்கப்படுகின்றன அல்லது RegExp கன்ஸ்ட்ரக்டருக்கு இரண்டாவது ஆர்குமென்டாக அனுப்பப்படுகின்றன.
g(global): பேட்டர்னின் முதல் நிகழ்வை மட்டுமல்ல, அனைத்து நிகழ்வுகளையும் பொருத்தும்.i(ignore case): எழுத்து வடிவம்-உணராப் பொருத்தத்தைச் செய்யும் (case-insensitive matching).m(multiline): பல வரிப் பயன்முறையை இயக்கும், இதில்^மற்றும்$ஒவ்வொரு வரியின் தொடக்கத்தையும் முடிவையும் (\nஆல் பிரிக்கப்பட்டது) பொருத்தும்.s(dotAll): புள்ளி (.) புதிய வரி எழுத்துகளையும் பொருத்த அனுமதிக்கும்.u(unicode): முழுமையான யூனிகோட் ஆதரவை இயக்கும்.y(sticky): ரெஜெக்ஸின்lastIndexபண்பால் சுட்டிக்காட்டப்பட்ட குறியீட்டிலிருந்து மட்டுமே பொருத்தும்.
JavaScript ரெஜெக்ஸ் மெத்தடுகள்
ஜாவாஸ்கிரிப்ட் ரெகுலர் எக்ஸ்பிரஷன்களுடன் வேலை செய்ய பல மெத்தடுகளை வழங்குகிறது:
test(): ஒரு ஸ்டிரிங் பேட்டர்னுடன் பொருந்துகிறதா என்று சோதிக்கிறது.trueஅல்லதுfalseஐ வழங்கும்.exec(): ஒரு ஸ்டிரிங்கில் ஒரு பொருத்தத்தைத் தேடுகிறது. பொருத்தப்பட்ட டெக்ஸ்ட் மற்றும் கைப்பற்றப்பட்ட குழுக்களைக் கொண்ட ஒரு அரே அல்லது பொருத்தம் காணப்படவில்லை என்றால்nullஐ வழங்கும்.match(): ஒரு ஸ்டிரிங்கை ஒரு ரெகுலர் எக்ஸ்பிரஷனுக்கு எதிராகப் பொருத்துவதன் முடிவுகளைக் கொண்ட ஒரு அரேவை வழங்கும்.gபிளாக் உடன் மற்றும் இல்லாமல் வித்தியாசமாகச் செயல்படும்.search(): ஒரு ஸ்டிரிங்கில் ஒரு பொருத்தத்தைச் சோதிக்கிறது. முதல் பொருத்தத்தின் குறியீட்டை அல்லது பொருத்தம் காணப்படவில்லை என்றால் -1 ஐ வழங்கும்.replace(): ஒரு பேட்டர்னின் நிகழ்வுகளை ஒரு மாற்று ஸ்டிரிங் அல்லது மாற்று ஸ்டிரிங்கை வழங்கும் ஒரு சார்புடன் மாற்றுகிறது.split(): ஒரு ஸ்டிரிங்கை ஒரு ரெகுலர் எக்ஸ்பிரஷனின் அடிப்படையில் துணை ஸ்டிரிங்குகளின் அரேவாகப் பிரிக்கிறது.
ரெஜெக்ஸ் மெத்தடுகளைப் பயன்படுத்தும் எடுத்துக்காட்டுகள்:
// test()
const regex = /hello/;
const str = "hello world";
console.log(regex.test(str)); // வெளியீடு: true
// exec()
const regex2 = /hello (\w+)/;
const str2 = "hello world";
const result = regex2.exec(str2);
console.log(result); // வெளியீடு: ["hello world", "world", index: 0, input: "hello world", groups: undefined]
// 'g' பிளாக் உடன் match()
const regex3 = /\d+/g; // ஒன்று அல்லது அதற்கு மேற்பட்ட இலக்கங்களை உலகளாவிய ரீதியில் பொருத்தும்
const str3 = "There are 123 apples and 456 oranges.";
const matches = str3.match(regex3);
console.log(matches); // வெளியீடு: ["123", "456"]
// 'g' பிளாக் இல்லாமல் match()
const regex4 = /\d+/;
const str4 = "There are 123 apples and 456 oranges.";
const match = str4.match(regex4);
console.log(match); // வெளியீடு: ["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)); // வெளியீடு: 6
// replace()
const regex6 = /world/;
const str6 = "hello world";
const newStr = str6.replace(regex6, "JavaScript");
console.log(newStr); // வெளியீடு: hello JavaScript
// ஒரு சார்புடன் replace()
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); // வெளியீடு: Today's date is 27/10/2023
// split()
const regex8 = /, /;
const str8 = "apple, banana, cherry";
const arr = str8.split(regex8);
console.log(arr); // வெளியீடு: ["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]); // வெளியீடு: 2023-10-27 (முழுப் பொருத்தம்)
console.log(match[1]); // வெளியீடு: 2023 (முதல் கைப்பற்றப்பட்ட குழு - ஆண்டு)
console.log(match[2]); // வெளியீடு: 10 (இரண்டாவது கைப்பற்றப்பட்ட குழு - மாதம்)
console.log(match[3]); // வெளியீடு: 27 (மூன்றாவது கைப்பற்றப்பட்ட குழு - நாள்)
பெயரிடப்பட்ட கேப்சரிங் குரூப்புகள்:
ES2018 பெயரிடப்பட்ட கேப்சரிங் குரூப்புகளை அறிமுகப்படுத்தியது, இது (? சிண்டாக்ஸைப் பயன்படுத்தி கேப்சரிங் குரூப்புகளுக்குப் பெயர்களை ஒதுக்க உங்களை அனுமதிக்கிறது. இது குறியீட்டை மேலும் படிக்கக்கூடியதாகவும் பராமரிக்கக்கூடியதாகவும் ஆக்குகிறது.
const regex = /(?\d{4})-(?\d{2})-(?\d{2})/;
const dateString = "2023-10-27";
const match = regex.exec(dateString);
console.log(match.groups.year); // வெளியீடு: 2023
console.log(match.groups.month); // வெளியீடு: 10
console.log(match.groups.day); // வெளியீடு: 27
நான்-கேப்சரிங் குரூப்புகள்:
ஒரு ரெஜெக்ஸின் பகுதிகளைக் கைப்பற்றாமல் குழுவாக்க வேண்டியிருந்தால் (எ.கா., ஒரு குழுவிற்கு ஒரு அளவீட்டாளரைப் பயன்படுத்த), நீங்கள் (?:...) சிண்டாக்ஸுடன் ஒரு நான்-கேப்சரிங் குரூப்பைப் பயன்படுத்தலாம். இது கைப்பற்றப்பட்ட குழுக்களுக்குத் தேவையற்ற நினைவக ஒதுக்கீட்டைத் தவிர்க்கிறது.
const regex = /(?:https?:\/\/)?([\w\.]+)/; // ஒரு URL ஐப் பொருத்துகிறது ஆனால் டொமைன் பெயரை மட்டுமே கைப்பற்றுகிறது
const url = "https://www.example.com/path";
const match = regex.exec(url);
console.log(match[1]); // வெளியீடு: www.example.com
லுக்அரவுண்டுகள் (Lookarounds):
லுக்அரவுண்டுகள் பூஜ்ஜிய-அகல மதிப்பீடுகளாகும், அவை ஒரு ஸ்டிரிங்கில் ஒரு நிலையை, அந்த நிலைக்கு முன் (lookbehind) அல்லது பின் (lookahead) வரும் ஒரு பேட்டர்னின் அடிப்படையில் பொருத்துகின்றன, லுக்அரவுண்ட் பேட்டர்னைப் பொருத்தத்தில் சேர்க்காமல்.
- பாசிட்டிவ் லுக்அஹெட்:
(?=...)லுக்அஹெட்டின் உள்ளே இருக்கும் பேட்டர்ன் தற்போதைய நிலையைப் *பின்தொடர்ந்தால்* பொருத்தும். - நெகட்டிவ் லுக்அஹெட்:
(?!...)லுக்அஹெட்டின் உள்ளே இருக்கும் பேட்டர்ன் தற்போதைய நிலையைப் *பின்தொடரவில்லை* என்றால் பொருத்தும். - பாசிட்டிவ் லுக்பிஹைண்ட்:
(?<=...)லுக்பிஹைண்டின் உள்ளே இருக்கும் பேட்டர்ன் தற்போதைய நிலைக்கு *முன்னால்* இருந்தால் பொருத்தும். - நெகட்டிவ் லுக்பிஹைண்ட்:
(? லுக்பிஹைண்டின் உள்ளே இருக்கும் பேட்டர்ன் தற்போதைய நிலைக்கு *முன்னால் இல்லை* என்றால் பொருத்தும்.
எடுத்துக்காட்டு:
// பாசிட்டிவ் லுக்அஹெட்: USD ஐப் பின்தொடரும்போது மட்டும் விலையைப் பெறுங்கள்
const regex = /\d+(?= USD)/;
const text = "The price is 100 USD";
const match = text.match(regex);
console.log(match); // வெளியீடு: ["100"]
// நெகட்டிவ் லுக்அஹெட்: ஒரு எண்ணால் பின்தொடரப்படாதபோது மட்டும் வார்த்தையைப் பெறுங்கள்
const regex2 = /\b\w+\b(?! \d)/;
const text2 = "apple 123 banana orange 456";
const matches = text2.match(regex2);
console.log(matches); // வெளியீடு: null ஏனெனில் match() 'g' பிளாக் இல்லாமல் முதல் பொருத்தத்தை மட்டுமே தரும், இது நமக்குத் தேவையானது அல்ல.
// இதைச் சரிசெய்ய:
const regex3 = /\b\w+\b(?! \d)/g;
const text3 = "apple 123 banana orange 456";
const matches3 = text3.match(regex3);
console.log(matches3); // வெளியீடு: [ 'banana' ]
// பாசிட்டிவ் லுக்பிஹைண்ட்: $ க்கு முன்னால் இருக்கும்போது மட்டும் மதிப்பைப் பெறுங்கள்
const regex4 = /(?<=\$)\d+/;
const text4 = "The price is $200";
const match4 = text4.match(regex4);
console.log(match4); // வெளியீடு: ["200"]
// நெகட்டிவ் லுக்பிஹைண்ட்: 'not' என்ற வார்த்தைக்கு முன்னால் இல்லாதபோது மட்டும் வார்த்தையைப் பெறுங்கள்
const regex5 = /(?
பேக்ரெபரன்ஸ்கள் (Backreferences):
பேக்ரெபரன்ஸ்கள் ஒரே ரெகுலர் எக்ஸ்பிரஷனுக்குள் முன்பு கைப்பற்றப்பட்ட குழுக்களைக் குறிப்பிட உங்களை அனுமதிக்கின்றன. அவை \1, \2, போன்ற சிண்டாக்ஸைப் பயன்படுத்துகின்றன, இதில் எண் கைப்பற்றப்பட்ட குழு எண்ணுடன் தொடர்புடையது.
const regex = /([a-z]+) \1/;
const text = "hello hello world";
const match = regex.exec(text);
console.log(match); // வெளியீடு: ["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")); // வெளியீடு: true
console.log(emailRegex.test("invalid-email")); // வெளியீடு: false
console.log(emailRegex.test("test@sub.example.co.uk")); // வெளியீடு: true
டெக்ஸ்டில் இருந்து URL-களைப் பிரித்தெடுத்தல்:
ஒரு டெக்ஸ்ட் தொகுப்பிலிருந்து URL-களைப் பிரித்தெடுக்க நீங்கள் ரெகுலர் எக்ஸ்பிரஷன்களைப் பயன்படுத்தலாம்:
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); // வெளியீடு: ["https://www.example.com", "http://blog.example.org"]
CSV தரவைப் பாகுபடுத்துதல்:
CSV (காற்புள்ளியால் பிரிக்கப்பட்ட மதிப்புகள்) தரவைப் பாகுபடுத்த ரெகுலர் எக்ஸ்பிரஷன்கள் பயன்படுத்தப்படலாம். மேற்கோள் இடப்பட்ட புலங்களைக் கையாளும் ஒரு CSV ஸ்டிரிங்கை மதிப்புகளின் அரேவாகப் பிரிப்பதற்கான ஒரு எடுத்துக்காட்டு இங்கே:
const csvString = 'John,Doe,"123, Main St",New York';
const csvRegex = /(?:"([^"]*(?:""[^"]*)*)")|([^,]+)/g; //சரிசெய்யப்பட்ட CSV ரெஜெக்ஸ்
let values = [];
let match;
while (match = csvRegex.exec(csvString)) {
values.push(match[1] ? match[1].replace(/""/g, '"') : match[2]);
}
console.log(values); // வெளியீடு: ["John", "Doe", "123, Main St", "New York"]
சர்வதேச தொலைபேசி எண் சரிபார்ப்பு
சர்வதேச தொலைபேசி எண்களை சரிபார்ப்பது மாறுபட்ட வடிவங்கள் மற்றும் நீளங்கள் காரணமாக சிக்கலானது. ஒரு வலுவான தீர்வு பெரும்பாலும் ஒரு லைப்ரரியைப் பயன்படுத்துவதை உள்ளடக்கியது, ஆனால் ஒரு எளிமைப்படுத்தப்பட்ட ரெஜெக்ஸ் அடிப்படை சரிபார்ப்பை வழங்க முடியும்:
const phoneRegex = /^\+(?:[0-9] ?){6,14}[0-9]$/;
console.log(phoneRegex.test("+1 555 123 4567")); // வெளியீடு: true (US எடுத்துக்காட்டு)
console.log(phoneRegex.test("+44 20 7946 0500")); // வெளியீடு: true (UK எடுத்துக்காட்டு)
console.log(phoneRegex.test("+81 3 3224 5000")); // வெளியீடு: true (Japan எடுத்துக்காட்டு)
console.log(phoneRegex.test("123-456-7890")); // வெளியீடு: false
கடவுச்சொல் வலிமை சரிபார்ப்பு
கடவுச்சொல் வலிமைக் கொள்கைகளைச் செயல்படுத்த ரெகுலர் எக்ஸ்பிரஷன்கள் பயனுள்ளவை. கீழே உள்ள எடுத்துக்காட்டு குறைந்தபட்ச நீளம், பெரிய எழுத்து, சிறிய எழுத்து மற்றும் ஒரு எண்ணைச் சரிபார்க்கிறது.
const passwordRegex = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)[a-zA-Z\d]{8,}$/;
console.log(passwordRegex.test("P@ssword123")); // வெளியீடு: true
console.log(passwordRegex.test("password")); // வெளியீடு: false (பெரிய எழுத்து அல்லது எண் இல்லை)
console.log(passwordRegex.test("Password")); // வெளியீடு: false (எண் இல்லை)
console.log(passwordRegex.test("Pass123")); // வெளியீடு: false (சிறிய எழுத்து இல்லை)
console.log(passwordRegex.test("P@ss1")); // வெளியீடு: false (8 எழுத்துகளுக்குக் குறைவு)
ரெஜெக்ஸ் மேம்படுத்தல் நுட்பங்கள்
ரெகுலர் எக்ஸ்பிரஷன்கள் கணக்கீட்டு ரீதியாக செலவுமிக்கதாக இருக்கலாம், குறிப்பாக சிக்கலான பேட்டர்ன்கள் அல்லது பெரிய உள்ளீடுகளுக்கு. ரெஜெக்ஸ் செயல்திறனை மேம்படுத்துவதற்கான சில நுட்பங்கள் இங்கே:
- குறிப்பாக இருங்கள்: ഉദ്ദേശിച്ചதை விட அதிகமாகப் பொருந்தக்கூடிய மிகவும் பொதுவான பேட்டர்ன்களைப் பயன்படுத்துவதைத் தவிர்க்கவும்.
- ஆங்கர்களைப் பயன்படுத்தவும்: முடிந்தவரை ரெஜெக்ஸை ஸ்டிரிங்கின் தொடக்கத்திலோ அல்லது முடிவிலோ நங்கூரமிடவும் (
^,$). - பின்தடமறிதலைத் தவிர்க்கவும்: பொருத்தமான இடங்களில் பொசசிவ் குவாண்டிஃபையர்களை (எ.கா.,
+க்கு பதிலாக++) அல்லது அணு குழுக்களை ((?>...)) பயன்படுத்தி பின்தடமறிதலைக் குறைக்கவும். - ஒருமுறை கம்பைல் செய்யவும்: நீங்கள் ஒரே ரெஜெக்ஸை பலமுறை பயன்படுத்தினால், அதை ஒருமுறை கம்பைல் செய்து
RegExpஆப்ஜெக்டை மீண்டும் பயன்படுத்தவும். - எழுத்து வகுப்புகளை புத்திசாலித்தனமாகப் பயன்படுத்தவும்: எழுத்து வகுப்புகள் (
[]) பொதுவாக மாற்றுகளுக்கு (|) விட வேகமானவை. - எளிமையாக வைத்திருங்கள்: புரிந்துகொள்வதற்கும் பராமரிப்பதற்கும் கடினமான மிகவும் சிக்கலான ரெஜெக்ஸைத் தவிர்க்கவும். சில நேரங்களில், ஒரு சிக்கலான பணியை பல எளிய ரெஜெக்ஸாக உடைப்பது அல்லது பிற ஸ்டிரிங் கையாளுதல் நுட்பங்களைப் பயன்படுத்துவது மிகவும் திறமையானதாக இருக்கும்.
பொதுவான ரெஜெக்ஸ் தவறுகள்
- மெட்டா எழுத்துகளை எஸ்கேப் செய்ய மறப்பது:
.,*,+,?,$,^,(,),[,],{,},|, மற்றும்\போன்ற சிறப்பு எழுத்துகளை நீங்கள் நேரடியாகப் பொருத்த விரும்பும்போது அவற்றை எஸ்கேப் செய்யத் தவறுதல். .(புள்ளி) ஐ அதிகமாகப் பயன்படுத்துதல்: புள்ளி எந்த எழுத்தையும் (சில முறைகளில் புதிய வரியைத் தவிர) பொருத்தும், இது கவனமாகப் பயன்படுத்தப்படாவிட்டால் எதிர்பாராத பொருத்தங்களுக்கு வழிவகுக்கும். முடிந்தவரை எழுத்து வகுப்புகள் அல்லது பிற கட்டுப்படுத்தப்பட்ட பேட்டர்ன்களைப் பயன்படுத்தி மேலும் குறிப்பாக இருங்கள்.- பேராசை: இயல்பாக,
*மற்றும்+போன்ற அளவீட்டாளர்கள் பேராசை கொண்டவை மற்றும் முடிந்தவரை அதிகமாகப் பொருத்தும். நீங்கள் சாத்தியமான குறுகிய ஸ்டிரிங்கைப் பொருத்த வேண்டியிருக்கும்போது சோம்பேறி அளவீட்டாளர்களை (*?,+?) பயன்படுத்தவும். - ஆங்கர்களைத் தவறாகப் பயன்படுத்துதல்:
^(ஸ்டிரிங்/வரியின் தொடக்கம்) மற்றும்$(ஸ்டிரிங்/வரியின் முடிவு) ஆகியவற்றின் நடத்தையைத் தவறாகப் புரிந்துகொள்வது தவறான பொருத்தத்திற்கு வழிவகுக்கும். பல வரி ஸ்டிரிங்குகளுடன் வேலை செய்யும்போது^மற்றும்$ஒவ்வொரு வரியின் தொடக்கத்தையும் முடிவையும் பொருத்த வேண்டுமென்றால்m(multiline) பிளாக்கைப் பயன்படுத்த நினைவில் கொள்ளுங்கள். - விளிம்பு நிலைகளைக் கையாளாதது: சாத்தியமான அனைத்து உள்ளீட்டு சூழ்நிலைகளையும் மற்றும் விளிம்பு நிலைகளையும் கருத்தில் கொள்ளத் தவறுவது பிழைகளுக்கு வழிவகுக்கும். உங்கள் ரெஜெக்ஸை வெற்று ஸ்டிரிங்குகள், செல்லுபடியாகாத எழுத்துகள் மற்றும் எல்லை நிபந்தனைகள் உள்ளிட்ட பல்வேறு உள்ளீடுகளுடன் முழுமையாகச் சோதிக்கவும்.
- செயல்திறன் சிக்கல்கள்: மிகவும் சிக்கலான மற்றும் திறமையற்ற ரெஜெக்ஸை உருவாக்குவது செயல்திறன் சிக்கல்களை ஏற்படுத்தக்கூடும், குறிப்பாக பெரிய உள்ளீடுகளுடன். மேலும் குறிப்பிட்ட பேட்டர்ன்களைப் பயன்படுத்துதல், தேவையற்ற பின்தடமறிதலைத் தவிர்த்தல் மற்றும் மீண்டும் மீண்டும் பயன்படுத்தப்படும் ரெஜெக்ஸை கம்பைல் செய்வதன் மூலம் உங்கள் ரெஜெக்ஸை மேம்படுத்தவும்.
- எழுத்து குறியாக்கத்தைப் புறக்கணித்தல்: எழுத்து குறியாக்கங்களை (குறிப்பாக யூனிகோட்) சரியாகக் கையாளாதது எதிர்பாராத முடிவுகளுக்கு வழிவகுக்கும். சரியான பொருத்தத்தை உறுதிப்படுத்த யூனிகோட் எழுத்துகளுடன் வேலை செய்யும்போது
uபிளாக்கைப் பயன்படுத்தவும்.
முடிவுரை
ரெகுலர் எக்ஸ்பிரஷன்கள் ஜாவாஸ்கிரிப்டில் பேட்டர்ன் மேட்சிங் மற்றும் டெக்ஸ்ட் கையாளுதலுக்கான ஒரு மதிப்புமிக்க கருவியாகும். ரெஜெக்ஸ் சிண்டாக்ஸ் மற்றும் நுட்பங்களில் தேர்ச்சி பெறுவது, தரவு சரிபார்ப்பு முதல் சிக்கலான டெக்ஸ்ட் பிராசசிங் வரை பரந்த அளவிலான சிக்கல்களைத் திறமையாகத் தீர்க்க உங்களை அனுமதிக்கிறது. இந்த வழிகாட்டியில் விவாதிக்கப்பட்ட கருத்துக்களைப் புரிந்துகொண்டு, நிஜ உலக எடுத்துக்காட்டுகளுடன் பயிற்சி செய்வதன் மூலம், உங்கள் ஜாவாஸ்கிரிப்ட் மேம்பாட்டுத் திறன்களை மேம்படுத்த ரெகுலர் எக்ஸ்பிரஷன்களைப் பயன்படுத்துவதில் நீங்கள் திறமையானவராக ஆகலாம்.
ரெகுலர் எக்ஸ்பிரஷன்கள் சிக்கலானதாக இருக்கலாம் என்பதை நினைவில் கொள்ளுங்கள், மேலும் regex101.com அல்லது regexr.com போன்ற ஆன்லைன் ரெஜெக்ஸ் சோதனையாளர்களைப் பயன்படுத்தி அவற்றை முழுமையாகச் சோதிப்பது பெரும்பாலும் உதவியாக இருக்கும். இது பொருத்தங்களை நீங்கள் காட்சிப்படுத்தவும் மற்றும் எந்தவொரு சிக்கலையும் திறம்பட சரிசெய்யவும் அனுமதிக்கிறது. மகிழ்ச்சியான குறியீட்டு முறை!