రెగ్యులర్ ఎక్స్‌ప్రెషన్ ఆప్టిమైజేషన్: రెక్స్ పర్ఫార్మెన్స్ ట్యూనింగ్‌పై లోతైన పరిశీలన

రెగ్యులర్ ఎక్స్‌ప్రెషన్స్, లేదా రెక్స్, ఆధునిక ప్రోగ్రామర్ టూల్‌కిట్‌లో ఒక అనివార్యమైన సాధనం. యూజర్ ఇన్‌పుట్‌ను ధృవీకరించడం, లాగ్ ఫైల్‌లను పార్స్ చేయడం నుండి అధునాతన సెర్చ్-అండ్-రీప్లేస్ ఆపరేషన్లు మరియు డేటా ఎక్స్‌ట్రాక్షన్ వరకు, వాటి శక్తి మరియు బహుముఖ ప్రజ్ఞ కాదనలేనిది. అయితే, ఈ శక్తితో ఒక దాగి ఉన్న మూల్యం ఉంది. సరిగ్గా వ్రాయని రెక్స్ నిశ్శబ్దంగా పనితీరును దెబ్బతీస్తుంది, గణనీయమైన జాప్యాన్ని పరిచయం చేస్తుంది, CPU స్పైక్‌లకు కారణమవుతుంది, మరియు చెత్త సందర్భాలలో, మీ అప్లికేషన్‌ను నిలిపివేస్తుంది. ఇక్కడే రెగ్యులర్ ఎక్స్‌ప్రెషన్ ఆప్టిమైజేషన్ అనేది కేవలం 'ఉంటే బాగుంటుంది' అనే నైపుణ్యం మాత్రమే కాకుండా, దృఢమైన మరియు స్కేలబుల్ సాఫ్ట్‌వేర్‌ను నిర్మించడానికి ఒక క్లిష్టమైనదిగా మారుతుంది.

ఈ సమగ్ర గైడ్ మిమ్మల్ని రెక్స్ పనితీరు ప్రపంచంలోకి లోతుగా తీసుకువెళుతుంది. ఒక సాధారణ నమూనా ఎందుకు విపరీతంగా నెమ్మదిగా ఉంటుందో మేము అన్వేషిస్తాము, రెక్స్ ఇంజిన్‌ల అంతర్గత పనితీరును అర్థం చేసుకుంటాము, మరియు సరిగ్గా మాత్రమే కాకుండా అత్యంత వేగంగా ఉండే రెగ్యులర్ ఎక్స్‌ప్రెషన్‌లను వ్రాయడానికి మీకు శక్తివంతమైన సూత్రాలు మరియు పద్ధతులతో సన్నద్ధం చేస్తాము.

'ఎందుకు' అని అర్థం చేసుకోవడం: ఒక చెడ్డ రెక్స్ యొక్క మూల్యం

మనం ఆప్టిమైజేషన్ పద్ధతులలోకి వెళ్ళే ముందు, మనం పరిష్కరించడానికి ప్రయత్నిస్తున్న సమస్యను అర్థం చేసుకోవడం చాలా ముఖ్యం. రెగ్యులర్ ఎక్స్‌ప్రెషన్స్‌తో సంబంధం ఉన్న అత్యంత తీవ్రమైన పనితీరు సమస్యను కెటాస్ట్రాఫిక్ బ్యాక్‌ట్రాకింగ్ (Catastrophic Backtracking) అని అంటారు, ఇది రెగ్యులర్ ఎక్స్‌ప్రెషన్ డినయల్ ఆఫ్ సర్వీస్ (ReDoS) వల్నరబిలిటీకి దారితీస్తుంది.

కెటాస్ట్రాఫిక్ బ్యాక్‌ట్రాకింగ్ అంటే ఏమిటి?

ఒక రెక్స్ ఇంజిన్ ఒక సరిపోలికను కనుగొనడానికి (లేదా సరిపోలిక సాధ్యం కాదని నిర్ధారించడానికి) అసాధారణంగా ఎక్కువ సమయం తీసుకున్నప్పుడు కెటాస్ట్రాఫిక్ బ్యాక్‌ట్రాకింగ్ జరుగుతుంది. ఇది నిర్దిష్ట రకాల నమూనాలకు వ్యతిరేకంగా నిర్దిష్ట రకాల ఇన్‌పుట్ స్ట్రింగ్‌లతో జరుగుతుంది. ఇంజిన్ నమూనాను సంతృప్తి పరచడానికి ప్రతి సాధ్యమైన మార్గాన్ని ప్రయత్నిస్తూ, ఒక గందరగోళమైన ప్రస్తారాల చిట్టడవిలో చిక్కుకుపోతుంది. ఇన్‌పుట్ స్ట్రింగ్ పొడవుతో దశల సంఖ్య ఘాతాంకపరంగా పెరగవచ్చు, ఇది ఒక అప్లికేషన్ స్తంభించినట్లు అనిపించడానికి దారితీస్తుంది.

ఈ ప్రమాదకరమైన రెక్స్ యొక్క క్లాసిక్ ఉదాహరణను పరిగణించండి: ^(a+)+$

ఈ నమూనా చాలా సరళంగా కనిపిస్తుంది: ఇది ఒకటి లేదా అంతకంటే ఎక్కువ 'a'లతో కూడిన స్ట్రింగ్‌ను వెతుకుతుంది. ఇది "a", "aa", మరియు "aaaaa" వంటి స్ట్రింగ్‌ల కోసం ఖచ్చితంగా పనిచేస్తుంది. సమస్య మనం దానిని దాదాపు సరిపోలి, చివరికి విఫలమయ్యే స్ట్రింగ్‌తో పరీక్షించినప్పుడు తలెత్తుతుంది, ఉదాహరణకు "aaaaaaaaaaaaaaaaaaaaaaaaaaab".

ఇది ఎందుకు అంత నెమ్మదిగా ఉందో ఇక్కడ ఉంది:

• బయటి (...)+ మరియు లోపలి a+ రెండూ గ్రీడీ క్వాంటిఫైయర్‌లు.
• లోపలి a+ మొదట అన్ని 27 'a'లను సరిపోల్చుతుంది.
• బయటి (...)+ ఈ ఒకే సరిపోలికతో సంతృప్తి చెందుతుంది.
• ఆ తర్వాత ఇంజిన్ స్ట్రింగ్ ముగింపు యాంకర్ $ను సరిపోల్చడానికి ప్రయత్నిస్తుంది. 'b' ఉండటం వల్ల అది విఫలమవుతుంది.
• ఇప్పుడు, ఇంజిన్ బ్యాక్‌ట్రాక్ చేయాలి. బయటి గ్రూప్ ఒక అక్షరాన్ని వదులుకుంటుంది, కాబట్టి లోపలి a+ ఇప్పుడు 26 'a'లను సరిపోల్చుతుంది, మరియు బయటి గ్రూప్ యొక్క రెండవ పునరావృతం చివరి 'a'ని సరిపోల్చడానికి ప్రయత్నిస్తుంది. ఇది కూడా 'b' వద్ద విఫలమవుతుంది.
• ఇప్పుడు ఇంజిన్ లోపలి a+ మరియు బయటి (...)+ మధ్య 'a'ల స్ట్రింగ్‌ను విభజించడానికి ప్రతి ఒక్క సాధ్యమైన మార్గాన్ని ప్రయత్నిస్తుంది. N 'a'ల స్ట్రింగ్ కోసం, దానిని విభజించడానికి 2^N-1 మార్గాలు ఉన్నాయి. సంక్లిష్టత ఘాతాంకపరమైనది, మరియు ప్రాసెసింగ్ సమయం ఆకాశాన్నంటుతుంది.

ఈ ఒక్క, హానికరం కానిదిగా కనిపించే రెక్స్ ఒక CPU కోర్‌ను సెకన్లు, నిమిషాలు, లేదా అంతకంటే ఎక్కువ సేపు లాక్ చేయగలదు, తద్వారా ఇతర ప్రక్రియలు లేదా వినియోగదారులకు సేవను నిరాకరిస్తుంది.

విషయం యొక్క హృదయం: రెక్స్ ఇంజిన్

రెక్స్‌ను ఆప్టిమైజ్ చేయడానికి, ఇంజిన్ మీ నమూనాను ఎలా ప్రాసెస్ చేస్తుందో మీరు అర్థం చేసుకోవాలి. రెండు ప్రాథమిక రకాల రెక్స్ ఇంజిన్‌లు ఉన్నాయి, మరియు వాటి అంతర్గత పనితీరు పనితీరు లక్షణాలను నిర్దేశిస్తుంది.

DFA (డెటర్మినిస్టిక్ ఫైనైట్ ఆటోమేటాన్) ఇంజిన్‌లు

DFA ఇంజిన్‌లు రెక్స్ ప్రపంచంలో వేగవంతమైనవి. అవి ఇన్‌పుట్ స్ట్రింగ్‌ను ఎడమ నుండి కుడికి, అక్షరం అక్షరంగా ఒకే పాస్‌లో ప్రాసెస్ చేస్తాయి. ఏ సమయంలోనైనా, ప్రస్తుత అక్షరం ఆధారంగా తదుపరి స్థితి ఏమిటో DFA ఇంజిన్‌కు ఖచ్చితంగా తెలుసు. దీని అర్థం అది ఎప్పుడూ బ్యాక్‌ట్రాక్ చేయాల్సిన అవసరం లేదు. ప్రాసెసింగ్ సమయం సరళంగా ఉంటుంది మరియు ఇన్‌పుట్ స్ట్రింగ్ పొడవుకు నేరుగా అనులోమానుపాతంలో ఉంటుంది. grep మరియు awk వంటి సాంప్రదాయ యునిక్స్ సాధనాలు DFA-ఆధారిత ఇంజిన్‌లను ఉపయోగించే సాధనాలకు ఉదాహరణలు.

ప్రోస్: అత్యంత వేగవంతమైన మరియు ఊహించదగిన పనితీరు. కెటాస్ట్రాఫిక్ బ్యాక్‌ట్రాకింగ్‌కు గురికాదు.

కాన్స్: పరిమిత ఫీచర్ సెట్. అవి బ్యాక్‌రిఫరెన్స్‌లు, లుక్‌అరౌండ్‌లు, లేదా క్యాప్చరింగ్ గ్రూపులు వంటి అధునాతన ఫీచర్‌లకు మద్దతు ఇవ్వవు, ఇవి బ్యాక్‌ట్రాక్ చేసే సామర్థ్యంపై ఆధారపడతాయి.

NFA (నాన్‌డెటర్మినిస్టిక్ ఫైనైట్ ఆటోమేటాన్) ఇంజిన్‌లు

పైథాన్, జావాస్క్రిప్ట్, జావా, C# (.NET), రూబీ, PHP, మరియు పెర్ల్ వంటి ఆధునిక ప్రోగ్రామింగ్ భాషలలో ఉపయోగించే అత్యంత సాధారణ రకం NFA ఇంజిన్‌లు. అవి "నమూనా-ఆధారితమైనవి," అంటే ఇంజిన్ నమూనాను అనుసరిస్తుంది, అది వెళ్ళే కొద్దీ స్ట్రింగ్ ద్వారా ముందుకు సాగుతుంది. అది ఒక అస్పష్టత ఉన్న బిందువుకు చేరుకున్నప్పుడు (ఒక ప్రత్యామ్నాయం | లేదా ఒక క్వాంటిఫైయర్ *, + వంటివి), అది ఒక మార్గాన్ని ప్రయత్నిస్తుంది. ఆ మార్గం చివరికి విఫలమైతే, అది చివరి నిర్ణయ బిందువుకు బ్యాక్‌ట్రాక్ చేసి, అందుబాటులో ఉన్న తదుపరి మార్గాన్ని ప్రయత్నిస్తుంది.

ఈ బ్యాక్‌ట్రాకింగ్ సామర్థ్యమే NFA ఇంజిన్‌లను అంత శక్తివంతంగా మరియు ఫీచర్-రిచ్‌గా చేస్తుంది, లుక్‌అరౌండ్‌లు మరియు బ్యాక్‌రిఫరెన్స్‌లతో సంక్లిష్టమైన నమూనాలను అనుమతిస్తుంది. అయితే, ఇది వారి అకిలెస్ హీల్ కూడా, ఎందుకంటే కెటాస్ట్రాఫిక్ బ్యాక్‌ట్రాకింగ్‌ను ప్రారంభించే మెకానిజం ఇదే.

ఈ గైడ్ యొక్క మిగిలిన భాగం కోసం, మా ఆప్టిమైజేషన్ పద్ధతులు NFA ఇంజిన్‌ను నియంత్రించడంపై దృష్టి పెడతాయి, ఎందుకంటే డెవలపర్‌లు చాలా తరచుగా పనితీరు సమస్యలను ఇక్కడే ఎదుర్కొంటారు.

NFA ఇంజిన్‌ల కోసం కోర్ ఆప్టిమైజేషన్ సూత్రాలు

ఇప్పుడు, అధిక-పనితీరు గల రెగ్యులర్ ఎక్స్‌ప్రెషన్‌లను వ్రాయడానికి మీరు ఉపయోగించగల ఆచరణాత్మక, చర్య తీసుకోగల పద్ధతులలోకి ప్రవేశిద్దాం.

1. నిర్దిష్టంగా ఉండండి: కచ్చితత్వం యొక్క శక్తి

అత్యంత సాధారణ పనితీరు యాంటీ-ప్యాటర్న్ .* వంటి అతి సాధారణ వైల్డ్‌కార్డ్‌లను ఉపయోగించడం. చుక్క . (దాదాపు) ఏ అక్షరాన్నైనా సరిపోల్చుతుంది, మరియు ఆస్టరిస్క్ * అంటే "సున్నా లేదా అంతకంటే ఎక్కువ సార్లు." కలిపినప్పుడు, అవి ఇంజిన్‌కు స్ట్రింగ్ యొక్క మిగిలిన భాగాన్ని అత్యాశతో వినియోగించుకోవాలని మరియు నమూనా యొక్క మిగిలిన భాగం సరిపోలుతుందో లేదో చూడటానికి ఒక అక్షరం చొప్పున బ్యాక్‌ట్రాక్ చేయమని సూచిస్తాయి. ఇది చాలా అసమర్థమైనది.

చెడ్డ ఉదాహరణ (ఒక HTML టైటిల్‌ను పార్స్ చేయడం):

<title>.*</title>

ఒక పెద్ద HTML పత్రానికి వ్యతిరేకంగా, .* మొదట ఫైల్ ముగింపు వరకు ప్రతిదీ సరిపోల్చుతుంది. ఆ తర్వాత, అది చివరి </title>ను కనుగొనే వరకు, అక్షరం అక్షరంగా బ్యాక్‌ట్రాక్ చేస్తుంది. ఇది చాలా అనవసరమైన పని.

మంచి ఉదాహరణ (ఒక నిరాకరించబడిన అక్షర తరగతిని ఉపయోగించడం):

<title>[^<]*</title>

ఈ వెర్షన్ చాలా సమర్థవంతమైనది. నిరాకరించబడిన అక్షర తరగతి [^<]* అంటే "సున్నా లేదా అంతకంటే ఎక్కువ సార్లు '<' కాని ఏ అక్షరాన్నైనా సరిపోల్చండి." ఇంజిన్ ముందుకు సాగుతుంది, మొదటి '<'ను తాకే వరకు అక్షరాలను వినియోగించుకుంటుంది. ఇది ఎప్పుడూ బ్యాక్‌ట్రాక్ చేయాల్సిన అవసరం లేదు. ఇది ఒక ప్రత్యక్ష, అస్పష్టత లేని సూచన, ఇది భారీ పనితీరు లాభానికి దారితీస్తుంది.

2. అత్యాశ వర్సెస్ సోమరితనం: ప్రశ్న గుర్తు యొక్క శక్తి

రెక్స్‌లోని క్వాంటిఫైయర్‌లు డిఫాల్ట్‌గా అత్యాశతో ఉంటాయి. దీని అర్థం మొత్తం నమూనా సరిపోలడానికి అనుమతిస్తూనే అవి వీలైనంత ఎక్కువ టెక్స్ట్‌ను సరిపోల్చుతాయి.

• అత్యాశ (Greedy): *, +, ?, {n,m}

మీరు ఏ క్వాంటిఫైయర్‌కైనా తర్వాత ప్రశ్న గుర్తును జోడించడం ద్వారా దానిని సోమరి (lazy)గా మార్చవచ్చు. ఒక సోమరి క్వాంటిఫైయర్ వీలైనంత తక్కువ టెక్స్ట్‌ను సరిపోల్చుతుంది.

• సోమరి (Lazy): *?, +?, ??, {n,m}?

ఉదాహరణ: బోల్డ్ ట్యాగ్‌లను సరిపోల్చడం

ఇన్‌పుట్ స్ట్రింగ్: <b>First</b> and <b>Second</b>

• అత్యాశ నమూనా: <b>.*</b>
  ఇది సరిపోలుతుంది: <b>First</b> and <b>Second</b>. .* అత్యాశతో చివరి </b> వరకు ప్రతిదీ వినియోగించుకుంది.
• సోమరి నమూనా: <b>.*?</b>
  ఇది మొదటి ప్రయత్నంలో <b>First</b>ను సరిపోల్చుతుంది, మరియు మీరు మళ్లీ శోధిస్తే <b>Second</b>ను సరిపోల్చుతుంది. .*? నమూనా యొక్క మిగిలిన భాగాన్ని (</b>) సరిపోలడానికి అవసరమైన కనీస అక్షరాలను సరిపోల్చింది.

సోమరితనం కొన్ని సరిపోలిక సమస్యలను పరిష్కరించగలిగినప్పటికీ, ఇది పనితీరుకు ఒక సంజీవని కాదు. ఒక సోమరి సరిపోలిక యొక్క ప్రతి దశలో ఇంజిన్ నమూనా యొక్క తదుపరి భాగం సరిపోలుతుందో లేదో తనిఖీ చేయాలి. ఒక అత్యంత నిర్దిష్ట నమూనా (మునుపటి పాయింట్ నుండి నిరాకరించబడిన అక్షర తరగతి వంటిది) తరచుగా ఒక సోమరి నమూనా కంటే వేగంగా ఉంటుంది.

పనితీరు క్రమం (వేగవంతమైనది నుండి నెమ్మదైనది):

1. నిర్దిష్ట/నిరాకరించబడిన అక్షర తరగతి: <b>[^<]*</b>
2. సోమరి క్వాంటిఫైయర్: <b>.*?</b>
3. చాలా బ్యాక్‌ట్రాకింగ్‌తో అత్యాశ క్వాంటిఫైయర్: <b>.*</b>

3. కెటాస్ట్రాఫిక్ బ్యాక్‌ట్రాకింగ్‌ను నివారించండి: నెస్ట్ చేయబడిన క్వాంటిఫైయర్‌లను నియంత్రించడం

మనం ప్రారంభ ఉదాహరణలో చూసినట్లుగా, కెటాస్ట్రాఫిక్ బ్యాక్‌ట్రాకింగ్‌కు ప్రత్యక్ష కారణం ఒక క్వాంటిఫైడ్ గ్రూప్ అదే టెక్స్ట్‌ను సరిపోల్చగల మరొక క్వాంటిఫైయర్‌ను కలిగి ఉన్న నమూనా. ఇంజిన్ ఇన్‌పుట్ స్ట్రింగ్‌ను విభజించడానికి బహుళ మార్గాలతో ఒక అస్పష్టమైన పరిస్థితిని ఎదుర్కొంటుంది.

సమస్యాత్మక నమూనాలు:

• (a+)+
• (a*)*
• (a|aa)+
• (a|b)* ఇక్కడ ఇన్‌పుట్ స్ట్రింగ్‌లో చాలా 'a'లు మరియు 'b'లు ఉంటాయి.

పరిష్కారం నమూనాను అస్పష్టత లేకుండా చేయడం. ఇచ్చిన స్ట్రింగ్‌ను సరిపోల్చడానికి ఇంజిన్‌కు ఒకే ఒక మార్గం ఉందని మీరు నిర్ధారించుకోవాలి.

4. అటామిక్ గ్రూపులు మరియు పొసెసివ్ క్వాంటిఫైయర్‌లను స్వీకరించండి

ఇది మీ ఎక్స్‌ప్రెషన్‌ల నుండి బ్యాక్‌ట్రాకింగ్‌ను తొలగించడానికి అత్యంత శక్తివంతమైన పద్ధతులలో ఒకటి. అటామిక్ గ్రూపులు మరియు పొసెసివ్ క్వాంటిఫైయర్‌లు ఇంజిన్‌కు ఇలా చెబుతాయి: "మీరు నమూనా యొక్క ఈ భాగాన్ని సరిపోల్చిన తర్వాత, ఏ అక్షరాలనూ ఎప్పటికీ తిరిగి ఇవ్వవద్దు. ఈ ఎక్స్‌ప్రెషన్‌లో బ్యాక్‌ట్రాక్ చేయవద్దు."

పొసెసివ్ క్వాంటిఫైయర్‌లు

ఒక సాధారణ క్వాంటిఫైయర్ తర్వాత + జోడించడం ద్వారా ఒక పొసెసివ్ క్వాంటిఫైయర్ సృష్టించబడుతుంది (ఉదా., *+, ++, ?+, {n,m}+). జావా, PCRE (PHP, R), మరియు రూబీ వంటి ఇంజిన్‌ల ద్వారా వీటికి మద్దతు ఉంది.

ఉదాహరణ: ఒక సంఖ్య తర్వాత 'a' సరిపోల్చడం

ఇన్‌పుట్ స్ట్రింగ్: 12345

• సాధారణ రెక్స్: \d+a
\d+ "12345"ను సరిపోల్చుతుంది. ఆ తర్వాత, ఇంజిన్ 'a'ను సరిపోల్చడానికి ప్రయత్నించి విఫలమవుతుంది. అది బ్యాక్‌ట్రాక్ చేస్తుంది, కాబట్టి \d+ ఇప్పుడు "1234"ను సరిపోల్చుతుంది, మరియు అది '5'కు వ్యతిరేకంగా 'a'ను సరిపోల్చడానికి ప్రయత్నిస్తుంది. \d+ దాని అన్ని అక్షరాలను వదులుకునే వరకు ఇది కొనసాగుతుంది. విఫలం కావడానికి ఇది చాలా పని.
• పొసెసివ్ రెక్స్: \d++a
\d++ పొసెసివ్‌గా "12345"ను సరిపోల్చుతుంది. ఇంజిన్ ఆ తర్వాత 'a'ను సరిపోల్చడానికి ప్రయత్నించి విఫలమవుతుంది. క్వాంటిఫైయర్ పొసెసివ్ అయినందున, ఇంజిన్ \d++ భాగంలోకి బ్యాక్‌ట్రాక్ చేయడం నిషిద్ధం. అది వెంటనే విఫలమవుతుంది. దీనిని 'వేగంగా విఫలం కావడం' (failing fast) అంటారు మరియు ఇది చాలా సమర్థవంతమైనది.

అటామిక్ గ్రూపులు

అటామిక్ గ్రూపులకు (?>...) అనే సింటాక్స్ ఉంటుంది మరియు పొసెసివ్ క్వాంటిఫైయర్‌ల కంటే విస్తృతంగా మద్దతు ఉంది (ఉదా., .NET, పైథాన్ యొక్క కొత్త `regex` మాడ్యూల్‌లో). అవి పొసెసివ్ క్వాంటిఫైయర్‌ల వలె ప్రవర్తిస్తాయి కానీ మొత్తం గ్రూప్‌కు వర్తిస్తాయి.

(?>\d+)a అనే రెక్స్ ఫంక్షనల్‌గా \d++aకు సమానం. మీరు అసలు కెటాస్ట్రాఫిక్ బ్యాక్‌ట్రాకింగ్ సమస్యను పరిష్కరించడానికి అటామిక్ గ్రూపులను ఉపయోగించవచ్చు:

అసలు సమస్య: (a+)+
అటామిక్ పరిష్కారం: ((?>a+))+

ఇప్పుడు, లోపలి గ్రూప్ (?>a+) 'a'ల శ్రేణిని సరిపోల్చినప్పుడు, అది వాటిని బయటి గ్రూప్ మళ్లీ ప్రయత్నించడానికి ఎప్పటికీ వదులుకోదు. ఇది అస్పష్టతను తొలగిస్తుంది మరియు ఘాతాంక బ్యాక్‌ట్రాకింగ్‌ను నివారిస్తుంది.

5. ప్రత్యామ్నాయాల క్రమం ముఖ్యం

ఒక NFA ఇంజిన్ ఒక ప్రత్యామ్నాయాన్ని (`|` పైప్‌ను ఉపయోగించి) ఎదుర్కొన్నప్పుడు, అది ప్రత్యామ్నాయాలను ఎడమ నుండి కుడికి ప్రయత్నిస్తుంది. దీని అర్థం మీరు అత్యంత సంభావ్య ప్రత్యామ్నాయాన్ని మొదట ఉంచాలి.

ఉదాహరణ: ఒక ఆదేశాన్ని పార్స్ చేయడం

మీరు ఆదేశాలను పార్స్ చేస్తున్నారని ఊహించుకోండి, మరియు మీకు `GET` ఆదేశం 80% సమయం, `SET` 15% సమయం, మరియు `DELETE` 5% సమయం కనిపిస్తుందని తెలుసు.

తక్కువ సమర్థవంతమైనది: ^(DELETE|SET|GET)
మీ ఇన్‌పుట్‌లలో 80% మీద, ఇంజిన్ మొదట `DELETE`ను సరిపోల్చడానికి ప్రయత్నిస్తుంది, విఫలమవుతుంది, బ్యాక్‌ట్రాక్ చేస్తుంది, `SET`ను సరిపోల్చడానికి ప్రయత్నిస్తుంది, విఫలమవుతుంది, బ్యాక్‌ట్రాక్ చేస్తుంది, మరియు చివరకు `GET`తో విజయం సాధిస్తుంది.

మరింత సమర్థవంతమైనది: ^(GET|SET|DELETE)
ఇప్పుడు, 80% సమయం, ఇంజిన్ మొదటి ప్రయత్నంలోనే సరిపోలికను పొందుతుంది. ఈ చిన్న మార్పు మిలియన్ల కొద్దీ లైన్‌లను ప్రాసెస్ చేసేటప్పుడు గుర్తించదగిన ప్రభావాన్ని చూపుతుంది.

6. మీకు క్యాప్చర్ అవసరం లేనప్పుడు నాన్-క్యాప్చరింగ్ గ్రూపులను ఉపయోగించండి

రెక్స్‌లోని కుండలీకరణాలు (...) రెండు పనులు చేస్తాయి: అవి ఒక ఉప-నమూనాను సమూహం చేస్తాయి, మరియు అవి ఆ ఉప-నమూనాతో సరిపోలిన టెక్స్ట్‌ను క్యాప్చర్ చేస్తాయి. ఈ క్యాప్చర్ చేయబడిన టెక్స్ట్ తరువాత ఉపయోగం కోసం మెమరీలో నిల్వ చేయబడుతుంది (ఉదా., `\1` వంటి బ్యాక్‌రిఫరెన్స్‌లలో లేదా కాలింగ్ కోడ్ ద్వారా వెలికితీత కోసం). ఈ నిల్వకు చిన్నదైనా కొలవదగిన ఓవర్‌హెడ్ ఉంటుంది.

మీకు కేవలం గ్రూపింగ్ ప్రవర్తన మాత్రమే అవసరమైతే కానీ టెక్స్ట్‌ను క్యాప్చర్ చేయనవసరం లేకపోతే, ఒక నాన్-క్యాప్చరింగ్ గ్రూప్‌ను ఉపయోగించండి: (?:...).

క్యాప్చరింగ్: (https?|ftp)://([^/]+)
ఇది "http" మరియు డొమైన్ పేరును విడిగా క్యాప్చర్ చేస్తుంది.

నాన్-క్యాప్చరింగ్: (?:https?|ftp)://([^/]+)
ఇక్కడ, మనం ఇప్పటికీ `https?|ftp`ను సమూహం చేస్తాము కాబట్టి `://` సరిగ్గా వర్తిస్తుంది, కానీ మనం సరిపోలిన ప్రోటోకాల్‌ను నిల్వ చేయము. మీరు కేవలం డొమైన్ పేరును (గ్రూప్ 1లో ఉన్నది) వెలికితీయడం గురించి మాత్రమే శ్రద్ధ వహిస్తే ఇది కొద్దిగా సమర్థవంతమైనది.

అధునాతన పద్ధతులు మరియు ఇంజిన్-నిర్దిష్ట చిట్కాలు

లుక్‌అరౌండ్‌లు: శక్తివంతమైనవి కానీ జాగ్రత్తగా వాడాలి

లుక్‌అరౌండ్‌లు (లుక్‌అహెడ్ (?=...), (?!...) మరియు లుక్‌బిహైండ్ (?<=...), (?) సున్నా-వెడల్పు నిర్ధారణలు. అవి ఏ అక్షరాలనూ వాస్తవంగా వినియోగించకుండా ఒక షరతును తనిఖీ చేస్తాయి. ఇది సందర్భాన్ని ధృవీకరించడానికి చాలా సమర్థవంతంగా ఉంటుంది.

import re

# రెక్స్‌ను ఒకసారి కంపైల్ చేయండి
log_pattern = re.compile(r'(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})')

for line in log_file:
    # కంపైల్ చేసిన ఆబ్జెక్ట్‌ను ఉపయోగించండి
    match = log_pattern.search(line)
    if match:
        print(match.group(1))