அத்தியாயம் 14

Regular Expression

ஒரு regular expression என்பது RegEx கன்ஸ்ட்ரக்டர் மூலம் உருவாக்கப்படக்கூடிய ஒரு பொருளாகும் (object), அல்லது முன்னோக்கி சாய்வு (/) எழுத்துக்களில் ஒரு வடிவத்தை அடைப்பதன் மூலம் ஒரு நேரடி மதிப்பாக (literal value) எழுதப்படும். ஒரு regular expression ஐ உருவாக்குவதற்கான தொடரியல் கீழே காட்டப்பட்டுள்ளது.

// regular expression கன்ஸ்ட்ரக்டரைப் பயன்படுத்துதல்
new RegExp(pattern[, flags]);

// literals ஐப் பயன்படுத்துதல்
/pattern/flags

literals ஐப் பயன்படுத்தி ஒரு regular expression ஐ உருவாக்கும் போது கொடிகள் (flags) விருப்பமானவை. மேலே குறிப்பிட்டுள்ள முறையைப் பயன்படுத்தி ஒரே மாதிரியான regular expression ஐ உருவாக்குவதற்கான எடுத்துக்காட்டு பின்வருமாறு.

let re1 = new RegExp("xyz"); 
let re2 = /xyz/;

இரண்டு வழிகளிலும் ஒரு regex பொருள் உருவாக்கப்படும் மற்றும் ஒரே முறைகள் மற்றும் பண்புகளைக் கொண்டிருக்கும். ஒரு regular expression ஐ உருவாக்க நமக்கு டைனமிக் மதிப்புகள் தேவைப்படக்கூடிய சந்தர்ப்பங்கள் உள்ளன, அந்தச் சந்தர்ப்பத்தில், literals வேலை செய்யாது மற்றும் கன்ஸ்ட்ரக்டருடன் செல்ல வேண்டும்.

கேஸ் சென்சிடிவ் இல்லாத (case-insensitive) தேடல்களைச் செய்யப் பயன்படுத்தப்படும் வெவ்வேறு மாற்றிகள் (modifiers):

• g - உலகளாவிய தேடல் (global search) (முதல் பொருத்தத்திற்குப் பிறகு நிறுத்தாமல் அனைத்து பொருத்தங்களையும் கண்டறிகிறது)

எடுத்துக்காட்டு :

const str = "Hello world, hello again!";
const regex = /hello/gi;
const matches = str.match(regex);
// நீங்கள் .match() பற்றி நினைத்தால் இதைப் படியுங்கள் 👇
// இது ஜாவாஸ்கிரிப்டில் உள்ளமைக்கப்பட்ட ஒரு முறையாகும், இது ஒரு வெளிப்பாட்டிற்கு (expression) எதிரான பொருத்தத்திற்காக ஒரு சரத்தைத் தேடப் பயன்படுகிறது.
// பொருத்தம் கண்டறியப்பட்டால், கண்டறியப்பட்ட அனைத்துப் பொருத்தங்களின் வரிசையையும் (array) இது திரும்பப் பெறுகிறது. இல்லையெனில், .match() முறை null ஐத் திரும்பப் பெறுகிறது.

console.log(matches); // ["Hello", "hello"]

• i - கேஸ் சென்சிடிவ் இல்லாத (case insensitive) தேடல்

எடுத்துக்காட்டு :

const str = "HeLlO WoRlD";
const regex = /hello/i;
const match = regex.test(str);
// .test() முறை ஒரு பூலியன் மதிப்பைத் திரும்பப் பெறுகிறது: 
// பொருத்தம் கண்டறியப்பட்டால் true, மற்றும் பொருத்தம் கண்டறியப்படவில்லை என்றால் false.

console.log(match); // true

• m - பல வரிப் பொருத்தம் (multiline matching)

எடுத்துக்காட்டு :

const str = "This is a\nmultiline string.";
const regex = /./mg;
const matches = str.match(regex);
// m கொடியானது புதிய வரி எழுத்துக்களை (\n) பொருத்தப் பயன்படுகிறது.
// அதாவது புதிய வரி எழுத்து உட்பட, சரத்தில் உள்ள 26 எழுத்துக்களுடனும் regex பொருந்தும்.

console.log(matches.length); // 26

அடைப்புக்குறிகள் (Brackets) எழுத்துக்களின் வரம்பைக் (range) கண்டறிய ஒரு regular expression இல் பயன்படுத்தப்படுகின்றன. அவற்றில் சில கீழே குறிப்பிடப்பட்டுள்ளன.

• [abc] - அடைப்புக்குறிக்குள் இருக்கும் ஏதேனும் ஒரு எழுத்தைக் கண்டறியும்

எடுத்துக்காட்டு :

const str = "The cat and the dog are both animals.";
const regex = /[abc]/g;
const matches = str.match(regex);

console.log(matches); // a, b மற்றும் c இன் அனைத்து நிகழ்வுகளின் வரிசை (Array)

[
  'c', 'a', 'a',
  'a', 'b', 'a',
  'a'
]

• [^abc] - அடைப்புக்குறிக்குள் இல்லாத எந்தவொரு எழுத்தையும் கண்டறியும்

எடுத்துக்காட்டு :

const str = "The cat and dog.";
const regex = /[^abc]/g; // 'a', 'b', அல்லது 'c' அல்லாத எந்தவொரு எழுத்துடனும் பொருந்தும்
const matches = str.match(regex);

console.log(matches); // 'a', 'b', அல்லது 'c' அல்லாத எழுத்துக்களின் அனைத்து நிகழ்வுகளின் வரிசை

[
  'T', 'h', 'e', ' ',
  't', ' ', 'n', 'd',
  ' ', 'd', 'o', 'g',
  '.'
]

• [0-9] - அடைப்புக்குறிக்குள் உள்ள ஏதேனும் ஒரு இலக்கத்தைக் (digit) கண்டறியும்

எடுத்துக்காட்டு :

const str = "The price of the item is $25, but it may change to $30.";
const regex = /[0-9]/g; // 0 முதல் 9 வரையிலான எந்த இலக்கத்துடனும் பொருந்தும்
const matches = str.match(regex);

console.log(matches); // இலக்கங்களின் அனைத்து நிகழ்வுகளின் வரிசை

[
  '2', '5', '3', '0'
]

• [^0-9] - அடைப்புக்குறிக்குள் இல்லாத எந்தவொரு எழுத்தையும் கண்டறியும் (இலக்கம் அல்லாதவை)

எடுத்துக்காட்டு :

const str = "The price is $25.";
const regex = /[^0-9]/g; // இலக்கமில்லாத எந்த எழுத்துடனும் பொருந்தும்
const matches = str.match(regex);

console.log(matches); // இலக்கமற்றவற்றின் அனைத்து நிகழ்வுகளின் வரிசை

[
  'T', 'h', 'e', ' ',
  'p', 'r', 'i', 'c',
  'e', ' ', 'i', 's',
  ' ', '$', '.'
]

• (x|y)- | ஆல் பிரிக்கப்பட்ட மாற்றுகளில் ஏதேனும் ஒன்றைக் கண்டறியும்

எடுத்துக்காட்டு :

const str = "The words 'xylophone' and 'yellow' contain the letters 'x' and 'y'.";
const regex = /(x|y)/g; // 'x' அல்லது 'y' உடன் பொருந்தும்
const matches = str.match(regex);

console.log(matches); // 'x' அல்லது 'y' இன் அனைத்து நிகழ்வுகளின் வரிசை

[
  'x', 'y', 'y', 'x', 'x', 'y'
]

Metacharacters என்பவை சிறப்பு எழுத்துக்கள், இவை regular expression இல் சிறப்புப் பொருளைக் கொண்டுள்ளன. இந்த எழுத்துக்கள் கீழே மேலும் விவரிக்கப்பட்டுள்ளன:

RegEx ஆல் ஆதரிக்கப்படும் பண்புகள் மற்றும் முறைகள் கீழே பட்டியலிடப்பட்டுள்ளன.

Regular expression இன் பொதுவான உதாரணம்

let text = "The best things in life are free";
let result = /e/.exec(text); // சரத்தில் e இன் பொருத்தத்தைத் தேடுகிறது
// result: e

console.log(result); // Result: ["e", 2, "The best things in life ar..."]
let helloWorldText = "Hello world!";
// "Hello" ஐத் தேடவும்
let pattern1 = /Hello/g;
let result1 = pattern1.test(helloWorldText);
// result1: true

let pattern1String = pattern1.toString();
// pattern1String : '/Hello/g'

பின்கோடு (Pincode) சரிபார்த்தலில் Regex இன் நிஜ வாழ்க்கை உதாரணம்

const handleSubmit = (e) => {
  // இயல்புநிலை படிவ சமர்ப்பிப்பு நடத்தையைத் தடுக்கவும்
  e.preventDefault();

  // செல்லுபடியாகும் பின்கோடுகளின் பட்டியலை வரையறுக்கவும்
  const validPincodes = [
    110001, 110002, 110003, 110004, 110005, 110006, 110007, 110008, 110009,
    110010, 110011, 110012, 110013, 110014, 110015, 110016, 110017, 110018,
    110019, 110020, 110021, 110022, 110023, 110050, 110051, 110056, 110048,
    110057, 110058, 110059, 110060, 110061, 110062, 110063, 110064
  ];

  // செல்லுபடியாகும் பின்கோடுகளை சரங்களாக மாற்றவும்
  const validPincodeStrings = validPincodes.map((pincode) => String(pincode));

  // செல்லுபடியாகும் பின்கோடுகளுடன் பொருந்துவதற்கு ஒரு regular expression வடிவத்தை (pattern) உருவாக்கவும்
  const regexPattern = new RegExp(`^(${validPincodeStrings.join("|")})$`);

  // உள்ளீட்டு புலத்தில் (input field) சமர்ப்பிக்கப்பட்ட பின்கோடைப் பெறவும்
  const submittedPincode = pincode; // 'pincode' வேறு எங்காவது வரையறுக்கப்பட்டுள்ளது என்பதை உறுதிப்படுத்திக் கொள்ளுங்கள்

  // சமர்ப்பிக்கப்பட்ட பின்கோடு செல்லுபடியாகும் பின்கோடு வடிவத்துடன் பொருந்துகிறதா எனச் சரிபார்க்கவும்
  if (regexPattern.test(submittedPincode)) {
    // வெற்றிச் செய்தியைக் காண்பி
    // ...
  } else if (submittedPincode === "") {
    // வெற்று உள்ளீட்டிற்கான பிழைச் செய்தியைக் காண்பி
    // ...
  } else if (submittedPincode.length < 6) {
    // தவறான பின்கோடு நீளத்திற்கான பிழைச் செய்தியைக் காண்பி
    // ...
  }
}