రెగ్యులర్ ఎక్స్‌ప్రెషన్‌లను ఉపయోగించి అధునాతన జావాస్క్రిప్ట్ ప్యాటర్న్ మ్యాచింగ్‌ను అన్వేషించండి. రెజెక్స్ సింటాక్స్, ఆచరణాత్మక అనువర్తనాలు, మరియు సమర్థవంతమైన, బలమైన కోడ్ కోసం ఆప్టిమైజేషన్ పద్ధతులను నేర్చుకోండి.
జావాస్క్రిప్ట్ రెగ్యులర్ ఎక్స్‌ప్రెషన్‌లతో ప్యాటర్న్ మ్యాచింగ్: ఒక సమగ్ర గైడ్
రెగ్యులర్ ఎక్స్‌ప్రెషన్‌లు (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" అనే పదంతో సరిపోలుతుంది.
ఫ్లాగ్స్:
రెజెక్స్ ఫ్లాగ్స్ రెగ్యులర్ ఎక్స్‌ప్రెషన్‌ల ప్రవర్తనను మారుస్తాయి. అవి రెజెక్స్ లిటరల్ చివర జోడించబడతాయి లేదా 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)); // అవుట్‌పుట్: 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 నేమ్డ్ క్యాప్చరింగ్ గ్రూప్స్‌ను పరిచయం చేసింది, ఇవి (?<name>...) సింటాక్స్‌ను ఉపయోగించి క్యాప్చరింగ్ గ్రూప్స్‌కు పేర్లను కేటాయించడానికి మిమ్మల్ని అనుమతిస్తాయి. ఇది కోడ్‌ను మరింత చదవగలిగేలా మరియు నిర్వహించగలిగేలా చేస్తుంది.
const regex = /(?<year>\d{4})-(?<month>\d{2})-(?<day>\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
లుక్‌రౌండ్స్:
లుక్‌రౌండ్స్ అనేవి జీరో-విడ్త్ అసర్షన్స్, ఇవి స్ట్రింగ్‌లోని ఒక స్థానాన్ని ఆ స్థానానికి ముందు (లుక్‌బిహైండ్) లేదా తర్వాత (లుక్‌హెడ్) ఉన్న ప్యాటర్న్ ఆధారంగా సరిపోల్చుతాయి, కానీ లుక్‌రౌండ్ ప్యాటర్న్‌ను సరిపోలికలో చేర్చవు.
- పాజిటివ్ లుక్‌హెడ్:
(?=...)లుక్‌హెడ్ లోపల ఉన్న ప్యాటర్న్ ప్రస్తుత స్థానాన్ని *అనుసరిస్తే* సరిపోలుతుంది. - నెగెటివ్ లుక్‌హెడ్:
(?!...)లుక్‌హెడ్ లోపల ఉన్న ప్యాటర్న్ ప్రస్తుత స్థానాన్ని *అనుసరించకపోతే* సరిపోలుతుంది. - పాజిటివ్ లుక్‌బిహైండ్:
(?<=...)లుక్‌బిహైండ్ లోపల ఉన్న ప్యాటర్న్ ప్రస్తుత స్థానానికి *ముందు ఉంటే* సరిపోలుతుంది. - నెగెటివ్ లుక్‌బిహైండ్:
(?<!...)లుక్‌బిహైండ్ లోపల ఉన్న ప్యాటర్న్ ప్రస్తుత స్థానానికి *ముందు లేకపోతే* సరిపోలుతుంది.
ఉదాహరణ:
// పాజిటివ్ లుక్‌హెడ్: 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 = /(?<!not )\w+/;
const text5 = "I am not happy, I am content.";
const match5 = text5.match(regex5); // సరిపోలితే మొదటి సరిపోలికను ఇస్తుంది, అర్రేను కాదు
console.log(match5); // అవుట్‌పుట్: ['am', index: 2, input: 'I am not happy, I am content.', groups: undefined]
// సరిచేయడానికి, g ఫ్లాగ్ మరియు exec() ఉపయోగించండి, కానీ జాగ్రత్తగా ఉండండి ఎందుకంటే regex.exec ఇండెక్స్‌ను సేవ్ చేస్తుంది
const regex6 = /(?<!not )\w+/g;
let text6 = "I am not happy, I am content.";
let match6; let matches6=[];
while ((match6 = regex6.exec(text6)) !== null) {
matches6.push(match6[0]);
}
console.log(matches6); // అవుట్‌పుట్: [ 'I', 'am', 'happy', 'I', 'am', 'content' ]
బ్యాక్‌రిఫరెన్సెస్:
బ్యాక్‌రిఫరెన్సెస్ ఒకే రెగ్యులర్ ఎక్స్‌ప్రెషన్‌లో గతంలో క్యాప్చర్ చేయబడిన గ్రూప్స్‌ను సూచించడానికి మిమ్మల్ని అనుమతిస్తాయి. అవి \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 (జపాన్ ఉదాహరణ)
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(మల్టీలైన్) ఫ్లాగ్‌ను ఉపయోగించడం గుర్తుంచుకోండి. - ఎడ్జ్ కేసులను నిర్వహించకపోవడం: సాధ్యమయ్యే అన్ని ఇన్‌పుట్ దృశ్యాలు మరియు ఎడ్జ్ కేసులను పరిగణనలోకి తీసుకోకపోవడం బగ్స్‌కు దారితీయవచ్చు. మీ రెజెక్స్‌లను ఖాళీ స్ట్రింగ్‌లు, చెల్లని అక్షరాలు మరియు బౌండరీ పరిస్థితులతో సహా వివిధ రకాల ఇన్‌పుట్‌లతో క్షుణ్ణంగా పరీక్షించండి.
- పనితీరు సమస్యలు: అతి సంక్లిష్టమైన మరియు అసమర్థమైన రెజెక్స్‌లను నిర్మించడం పనితీరు సమస్యలను కలిగిస్తుంది, ముఖ్యంగా పెద్ద ఇన్‌పుట్‌లతో. మరింత నిర్దిష్ట ప్యాటర్న్‌లను ఉపయోగించడం, అనవసరమైన బ్యాక్‌ట్రాకింగ్‌ను నివారించడం, మరియు పదేపదే ఉపయోగించే రెజెక్స్‌లను కంపైల్ చేయడం ద్వారా మీ రెజెక్స్‌లను ఆప్టిమైజ్ చేయండి.
- క్యారెక్టర్ ఎన్‌కోడింగ్‌ను విస్మరించడం: క్యారెక్టర్ ఎన్‌కోడింగ్‌లను (ముఖ్యంగా యూనికోడ్) సరిగ్గా నిర్వహించకపోవడం ఊహించని ఫలితాలకు దారితీయవచ్చు. సరైన సరిపోలికను నిర్ధారించడానికి యూనికోడ్ అక్షరాలతో పనిచేసేటప్పుడు
uఫ్లాగ్‌ను ఉపయోగించండి.
ముగింపు
రెగ్యులర్ ఎక్స్‌ప్రెషన్‌లు జావాస్క్రిప్ట్‌లో ప్యాటర్న్ మ్యాచింగ్ మరియు టెక్స్ట్ మానిప్యులేషన్ కోసం ఒక విలువైన సాధనం. రెజెక్స్ సింటాక్స్ మరియు టెక్నిక్స్‌లో నైపుణ్యం సాధించడం వలన మీరు డేటా ధ్రువీకరణ నుండి సంక్లిష్ట టెక్స్ట్ ప్రాసెసింగ్ వరకు విస్తృత శ్రేణి సమస్యలను సమర్థవంతంగా పరిష్కరించగలరు. ఈ గైడ్‌లో చర్చించిన భావనలను అర్థం చేసుకోవడం మరియు వాస్తవ-ప్రపంచ ఉదాహరణలతో సాధన చేయడం ద్వారా, మీరు మీ జావాస్క్రిప్ట్ అభివృద్ధి నైపుణ్యాలను మెరుగుపరచడానికి రెగ్యులర్ ఎక్స్‌ప్రెషన్‌లను ఉపయోగించడంలో నిపుణులు కావచ్చు.
రెగ్యులర్ ఎక్స్‌ప్రెషన్‌లు సంక్లిష్టంగా ఉండవచ్చని గుర్తుంచుకోండి, మరియు వాటిని regex101.com లేదా regexr.com వంటి ఆన్‌లైన్ రెజెక్స్ టెస్టర్‌లను ఉపయోగించి క్షుణ్ణంగా పరీక్షించడం తరచుగా సహాయపడుతుంది. ఇది సరిపోలికలను విజువలైజ్ చేయడానికి మరియు ఏవైనా సమస్యలను సమర్థవంతంగా డీబగ్ చేయడానికి మిమ్మల్ని అనుమతిస్తుంది. హ్యాపీ కోడింగ్!