మాడ్యూల్ పాఠాలు (3/4)
అత్యాశ vs సోమరితనం
డిఫాల్ట్‌గా క్వాంటిఫైయర్‌లు అత్యాశ: అవి వీలైనంత ఎక్కువగా వినియోగిస్తాయి
నమూనాను చెల్లుబాటులో ఉంచేటప్పుడు. క్వాంటిఫైయర్ తర్వాత ?ని జోడిస్తోంది (*?, +?,
??, {n,m}?) మీకు లేజీ వెర్షన్‌ని అందిస్తుంది: ఇది తక్కువగా వినియోగిస్తుంది
సాధ్యం.
Sample: **uno** e *due*
Greedy pattern <.*> matches: **uno** e *due* (everything)
Lazy pattern <.*?> matches: ** **
* * (4 matches with the g flag)ఖచ్చితమైన అదే నమూనా, తేడా యొక్క ఒకే అక్షరం (? జోడించబడింది
క్వాంటిఫైయర్), పూర్తిగా భిన్నమైన ఫలితాలు.
ఇది ముఖ్యమైనప్పుడు
- డీలిమిటర్‌ల మధ్య కంటెంట్‌ని సంగ్రహించడానికి (HTML ట్యాగ్‌లు, కోట్‌లు, కుండలీకరణాలు) ** lazy** సంస్కరణ దాదాపు ఎల్లప్పుడూ సరైనది.
- పంక్తి చివరి వరకు సరిపోలడానికి మీకు సాధారణంగా అత్యాశ కావాలి (
.*).
ఇంజిన్‌లో గ్రీడీ vs లేజీ వ్యూహాలు
ఒక అత్యాశతో కూడిన క్వాంటిఫైయర్ సాధ్యమైనంత ఎక్కువ వచనాన్ని వినియోగిస్తుంది మరియు బలవంతంగా మాత్రమే వెనక్కి తీసుకుంటుంది. ? (lazy) జోడించడం ద్వారా, ఇంజిన్ ఖచ్చితమైన కనిష్టాన్ని వినియోగిస్తుంది మరియు నమూనా యొక్క తదుపరి సరిపోలిక కోసం శోధించడంలో ఒక్కో అక్షరాన్ని పురోగమిస్తుంది.
దీనిని ప్రయత్నించండి
లేజీ వెర్షన్ `.*?`ని ఉపయోగించి నమూనా (ఉదా. `**`, `**`, `*`, `*`) నుండి ప్రతి HTML ట్యాగ్‌ని సంగ్రహించండి.
సూచనను చూపించు
గ్రీడీ <.*> మొదటి ట్యాగ్ ప్రారంభం నుండి చివరి ట్యాగ్ చివరి వరకు సరిపోలుతుంది. లేజీ <.*?> మొదటి వద్ద ఆగుతుంది > అది ఎదురవుతుంది.
3 ప్రయత్నాల తర్వాత పరిష్కారం లభిస్తుంది
వ్యాయామం సమీక్షించండి
టెక్స్ట్‌లోని డబుల్ కోట్‌ల మధ్య ఉన్న ప్రతి స్ట్రింగ్‌ను ఎక్స్‌ట్రాక్ట్ చేయండి (ఉదా. "ciao", "mondo"). తర్వాత మూసివేతలకు వెళ్లకుండా ఉండటానికి క్వాంటిఫైయర్ యొక్క లేజీ వెర్షన్‌ను ఉపయోగించండి.
సూచనను చూపించు
".*?" మొదటి ముగింపు డబుల్ కోట్ వద్ద ఆగుతుంది.
3 ప్రయత్నాల తర్వాత పరిష్కారం లభిస్తుంది
అదనపు సవాలు
Extract all text blocks enclosed in square brackets (e.g. `[text]`), including the brackets, using a lazy quantifier so as not to merge separate blocks.
సూచనను చూపించు
ఓపెన్ బ్రాకెట్ కోసం \\[ని ఉపయోగించండి, ఆపై .*? మరియు చివరగా \\] క్లోజ్డ్ బ్రాకెట్ కోసం.
3 ప్రయత్నాల తర్వాత పరిష్కారం లభిస్తుంది