JavaScript RegExp Objects

RegExp பொருள்

JavaScript இல், RegExp என்பது முன்வரையறுக்கப்பட்ட பண்புகள் மற்றும் முறைகளுடன் கூடிய ஒரு வழக்கமான வெளிப்பாட்டு பொருள்.

test() பயன்படுத்துதல்

test() முறை ஒரு RegExp வெளிப்பாடு முறை.

இது ஒரு சரத்தில் ஒரு முறையைத் தேடுகிறது, முடிவைப் பொறுத்து true அல்லது false ஐ வழங்குகிறது.

பின்வரும் எடுத்துக்காட்டு ஒரு சரத்தில் "e" எழுத்தைத் தேடுகிறது:

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

const pattern = /e/;
pattern.test("The best things in life are free!");

சரத்தில் "e" இருப்பதால், மேலே உள்ள குறியீட்டின் வெளியீடு:

true

நீங்கள் வழக்கமான வெளிப்பாட்டை முதலில் ஒரு மாறியில் வைக்க வேண்டியதில்லை. மேலே உள்ள இரண்டு வரிகள் ஒன்றாக குறுக்கலாம்:

/e/.test("The best things in life are free!");

💡 test() முறை பயன்பாடுகள்:

உள்ளீட்டு சரிபார்ப்பு (மின்னஞ்சல், தொலைபேசி எண் போன்றவை)
சரத்தில் ஒரு முறை உள்ளதா என சோதித்தல்
நிபந்தனை சோதனைகள்
படிவ சரிபார்ப்பு

exec() பயன்படுத்துதல்

exec() முறை ஒரு RegExp வெளிப்பாடு முறை.

இது ஒரு சரத்தில் குறிப்பிட்ட முறையைத் தேடுகிறது, மற்றும் கண்டுபிடிக்கப்பட்ட உரையை ஒரு பொருளாக வழங்குகிறது.

பொருத்தம் காணப்படவில்லை என்றால், இது வெற்று (null) பொருளை வழங்குகிறது.

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

பின்வரும் எடுத்துக்காட்டு ஒரு சரத்தில் "e" எழுத்தைத் தேடுகிறது:

/e/.exec("The best things in life are free!");

🔍 exec() vs test():

test(): பொருத்தம் உள்ளதா என்பதை மட்டும் சோதிக்கிறது (true/false)
exec(): பொருத்தத்தின் விவரங்களை வழங்குகிறது (இடம், குழுக்கள் போன்றவை)
test() வேகமானது, பூலியன் முடிவு மட்டும் தேவைப்படும் போது
exec() பொருத்த விவரங்கள் தேவைப்படும் போது

விரிவான exec() எடுத்துக்காட்டு

const pattern = /\b\w+\b/g;
let text = "Hello Jassif Team";
let result;

while ((result = pattern.exec(text)) !== null) {
  console.log(`Found: ${result[0]} at position: ${result.index}`);
}

📝 exec() வெளியீடு:

exec() பின்வரும் பண்புகளைக் கொண்ட ஒரு வரிசையை வழங்குகிறது:

[0]: முழு பொருத்தம்
[1], [2], ...: குழு பொருத்தங்கள்
index: பொருத்தம் தொடங்கும் குறியீடு
input: அசல் உள்ளீட்டு சரம்
groups: பெயரிடப்பட்ட குழுக்களின் பொருள்

RegExp.escape() முறை

RegExp.escape() முறை வழக்கமான வெளிப்பாடு தொடரியலுக்கு சொந்தமான எழுத்துகள் தப்பிக்கப்பட்ட ஒரு சரத்தை வழங்குகிறது.

இது +, *, ?, ^, $, (, ), [, ], {, }, |, மற்றும் \ போன்ற எழுத்துகளை உண்மையில் சிகிச்சையளிக்கவும், ஒரு வழக்கமான வெளிப்பாட்டின் ஒரு பகுதியாக அல்லவும் செய்கிறது.

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

"[*]" சரத்தை பொருத்தும் ஒரு வழக்கமான வெளிப்பாட்டை உருவாக்கவும்:

// ஒரு வழக்கமான வெளிப்பாடாகப் பயன்படுத்த உரையை தப்பிக்கவும்
const safe = RegExp.escape("[*]");

// புதிய வழக்கமான வெளிப்பாட்டை உருவாக்கவும்
const regex = new RegExp(safe);

// மாற்ற வேண்டிய உரை
const oldText = "[*] is a web school.";

// மாற்றீட்டை செயல்படுத்தவும்
const newText = oldText.replace(regex, "Jassif Team");

🛡️ RegExp.escape() முக்கியத்துவம்:

பயனர் உள்ளீடு அடிப்படையில் வழக்கமான வெளிப்பாடுகளை உருவாக்கும் போது RegExp.escape() மிகவும் முக்கியமானது. இது:

சாத்தியமான ரெக்ஸ் இன்ஜெக்ஷன் தாக்குதல்களைத் தடுக்கிறது
சிறப்பு எழுத்துகள் உண்மையில் பொருள்படுவதை உறுதிசெய்கிறது
மிகவும் பாதுகாப்பான குறியீட்டை எழுத உதவுகிறது

உலாவி ஆதரவு

RegExp.escape() ஒரு ES2025 அம்சம்.

JavaScript 2025 மே 2025 முதல் அனைத்து நவீன உலாவிகளிலும் முழுமையாக ஆதரிக்கப்படுகிறது:

உலாவி	பதிப்பு	தேதி
Chrome	136	ஏப்ரல் 2025
Edge	136	ஏப்ரல் 2025
Firefox	129	ஆகஸ்ட் 2024
Safari	18.2	டிசம்பர் 2024
Opera	120	மே 2025

⚠️ பின்னணி ஆதரவு:

பழைய உலாவிகளுக்கு RegExp.escape() கிடைக்கவில்லை என்றால், நீங்கள் உங்கள் சொந்த தப்பிப்பு செயல்பாட்டை எழுதலாம்:

function regexEscape(str) {
  return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
}

RegExp பொருள் பண்புகள்

global

/g கொடி அமைக்கப்பட்டுள்ளதா என சோதிக்கிறது

const regex = /test/g;
console.log(regex.global); // true

ignoreCase

/i கொடி அமைக்கப்பட்டுள்ளதா என சோதிக்கிறது

const regex = /test/i;
console.log(regex.ignoreCase); // true

multiline

/m கொடி அமைக்கப்பட்டுள்ளதா என சோதிக்கிறது

const regex = /test/m;
console.log(regex.multiline); // true

source

வழக்கமான வெளிப்பாட்டின் மூல உரை

const regex = /test/gi;
console.log(regex.source); // "test"

நடைமுறை எடுத்துக்காட்டுகள்

மின்னஞ்சல் சரிபார்ப்பு

function isValidEmail(email) {
  const emailPattern = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
  return emailPattern.test(email);
}

console.log(isValidEmail("user@jassifteam.com")); // true

பாதுகாப்பான தேடல்

function safeSearch(text, searchTerm) {
  // சிறப்பு எழுத்துகளை தப்பிக்கவும்
  const escaped = RegExp.escape(searchTerm);
  const pattern = new RegExp(escaped, 'gi');
  return pattern.test(text);
}

console.log(safeSearch("Test [special]", "[special]")); // true

தரவு பிரித்தெடுத்தல்

function extractEmails(text) {
  const emailPattern = /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b/g;
  return text.match(emailPattern) || [];
}

const text = "Contact: info@jassifteam.com or support@example.com";
console.log(extractEmails(text)); // ["info@jassifteam.com", "support@example.com"]

டைனமிக் பேட்டர்ன்

function createSearchPattern(keywords) {
  // ஒவ்வொரு முக்கிய வார்த்தையையும் தப்பிக்கவும்
  const escapedKeywords = keywords.map(k => RegExp.escape(k));
  // OR ஆபரேட்டருடன் இணைக்கவும்
  const patternStr = escapedKeywords.join('|');
  return new RegExp(patternStr, 'gi');
}

const pattern = createSearchPattern(["test", "example", "demo"]);
console.log(pattern.test("This is a test example")); // true

மேலும் அறிய

📚 Jassif Team குறிப்பு:

JavaScript RegExp டுடோரியல்
JavaScript RegExp கொடிகள்
JavaScript RegExp எழுத்து வகுப்புகள்
JavaScript RegExp மெட்டாஎழுத்துகள்
JavaScript RegExp உறுதிப்படுத்தல்கள்
JavaScript RegExp அளவீடுகள்
JavaScript RegExp முறைகள்

RegExp பொருள்கள் பயிற்சி

❓ ஒரு சரத்தில் ஒரு முறை உள்ளதா இல்லையா என சோதிக்க பின்வரும் எந்த RegExp முறை பயன்படுத்தப்படுகிறது?

RegExp.exec()

✗ தவறு! exec() பொருத்த விவரங்களை வழங்குகிறது, ஆனால் பூலியன் முடிவு மட்டுமே தேவைப்படும் போது test() பயன்படுத்தப்படுகிறது

RegExp.test()

✓ சரி! test() முறை ஒரு சரத்தில் ஒரு முறை உள்ளதா இல்லையா என சோதிக்க பயன்படுகிறது மற்றும் true/false முடிவை வழங்குகிறது

RegExp.escape()

✗ தவறு! escape() முறை சிறப்பு எழுத்துகளை தப்பிக்க பயன்படுகிறது, சரத்தில் முறை உள்ளதா என சோதிக்க அல்ல

RegExp.match()

✗ தவறு! match() ஒரு String முறை, RegExp முறை அல்ல. மேலும் இது பொருத்தங்களின் வரிசையை வழங்குகிறது