రెజెక్స్ కోర్సు

రీజెక్స్ యొక్క పునాదులు: సాహిత్య నమూనాలు, ప్రాథమిక అక్షర తరగతులు, `.` వైల్డ్‌కార్డ్ మరియు ఎస్కేపింగ్ మెటా-పాత్రలు.

1. 1.1సాహిత్య నమూనాలుసాధారణ అక్షరాలు, కేస్ సెన్సిటివిటీ మరియు మొదటి పరుగు: మ్యాచ్ మరియు ఇండెక్స్.~8 min
2. 1.2ప్రాథమిక తరగతులు: \d \w \sఅంకెలు, పద అక్షరాలు మరియు వైట్‌స్పేస్ (మరియు వాటి నిరాకరణ సంస్కరణలు) కోసం ముందే నిర్వచించిన తరగతులు.~10 min
3. 1.3వైల్డ్ కార్డ్: చుక్క `.``.` అక్షరం దాదాపు ప్రతిదానికీ సరిపోలుతుంది: ఇందులో ఏమి ఉంటుంది, ఏది మినహాయిస్తుంది మరియు `s` ఫ్లాగ్ ఎందుకు ముఖ్యమైనది.~8 min
4. 1.4మెటా-పాత్రల నుండి తప్పించుకోవడంమీకు డబుల్ బ్యాక్‌స్లాష్ అవసరమైనప్పుడు మరియు ఎందుకు `\`తో తప్పించుకోవాల్సిన 12 మెటా-అక్షరాలు.~10 min

ఎంత పునరావృతం చేయాలి: `*`, `+`, `?`, విరామాలు `{n,m}` మరియు అత్యాశ మరియు సోమరితనం మధ్య వ్యత్యాసం.

1. 2.1`*`, `+`, `?`సున్నా లేదా అంతకంటే ఎక్కువ, ఒకటి లేదా అంతకంటే ఎక్కువ, ఐచ్ఛికం: మూడు ప్రాథమిక క్వాంటిఫైయర్‌లు.~10 min
2. 2.2ఖచ్చితమైన పరిమాణాలు `{n,m}`సరిగ్గా `n`, `n` నుండి `m` వరకు, కనీసం `n`: సంఖ్యా పరిమాణీకరణం.~10 min
3. 2.3అత్యాశ vs సోమరితనండిఫాల్ట్‌గా క్వాంటిఫైయర్‌లు అత్యాశతో ఉంటాయి (`.*`); లేజీ వెర్షన్ (`.*?`) కోసం `?` జోడించండి.~10 min
4. 2.4బ్యాక్‌ట్రాకింగ్: ఒక అవలోకనంఅత్యాశతో కూడిన క్వాంటిఫైయర్ విఫలమైనప్పుడు ఇంజిన్ ఏమి చేస్తుంది మరియు అది ఎందుకు ఖరీదైనది కావచ్చు.~12 min

స్థానం, అక్షరాలు కాదు: స్ట్రింగ్ ప్రారంభం/ముగింపు వరకు, పద సరిహద్దులకు మరియు `m` ఫ్లాగ్‌తో ప్రతి పంక్తి ప్రారంభం/ముగింపు వరకు యాంకరింగ్ చేయడం.

1. 3.1ప్రారంభం మరియు ముగింపు: `^` మరియు `$`స్ట్రింగ్ యొక్క మొదటి లేదా చివరి అక్షరానికి నమూనాను యాంకరింగ్ చేయడం.~8 min
2. 3.2పద సరిహద్దులు: `\b` `\B`పదం మరియు పదం కాని అక్షరాల మధ్య మార్పు; మొత్తం పదాలను కనుగొనడం.~10 min
3. 3.3`m` ఫ్లాగ్: మల్టీలైన్`m` ఫ్లాగ్‌తో, ప్రతి పంక్తి ప్రారంభం/ముగింపు వరకు `^` మరియు `$` యాంకర్.~10 min
4. 3.4ఖాళీ లైన్లు మరియు ట్రిమ్ఉపయోగకరమైన నమూనాలు: ఖాళీ లైన్‌లను సరిపోల్చడం, పంక్తి ప్రారంభంలో/చివరిలో వైట్‌స్పేస్‌ని కత్తిరించడం.~10 min

`()`తో సమూహం చేయండి, `|`తో ప్రత్యామ్నాయాలను ఎంచుకోండి, `(?:...)`తో క్యాప్చర్ చేయడాన్ని నివారించండి, `(?<పేరు>...)`తో సమూహాలకు పేరు పెట్టండి మరియు వెనుక సూచనలతో మునుపటి సంగ్రహాన్ని తిరిగి చూడండి.

1. 4.1గుంపులను క్యాప్చర్ చేయండి: `(...)`సమూహం మరియు సంగ్రహించడానికి కుండలీకరణాలు; మ్యాచ్‌లలో 1, 2, 3… సమూహాలను యాక్సెస్ చేయండి.~10 min
2. 4.2ప్రత్యామ్నాయం: `|`పైప్ రెండు లేదా అంతకంటే ఎక్కువ ఉప-నమూనాల మధ్య ఎంచుకుంటుంది; ప్రాధాన్యత మరియు కుండలీకరణాలు.~10 min
3. 4.3సంగ్రహించని సమూహాలు: `(?:...)`క్యాప్చర్‌ని సృష్టించకుండానే సమూహపరచండి: మీరు పరిమాణాన్ని లేదా ప్రత్యామ్నాయం చేయవలసి వచ్చినప్పుడు మాత్రమే ఉపయోగపడుతుంది.~10 min
4. 4.4పేరు పెట్టబడిన సమూహాలు మరియు వెనుక సూచనలుపేరు ఇవ్వడానికి `(?<పేరు>...)`; క్యాప్చర్‌ని తిరిగి సూచించడానికి `\1` `\k<పేరు>`.~12 min

`[...]`తో అనుకూల సెట్‌లను నిర్వచించండి, పరిధులను ఉపయోగించండి, `[^...]`తో తిరస్కరించండి మరియు `\p{...}` మరియు `u` ఫ్లాగ్‌తో యూనికోడ్ లక్షణాలను చేరుకోండి.

1. 5.1అక్షర సమితులు: `[abc]`స్క్వేర్ బ్రాకెట్‌లు ఒక స్థానంలో అనుమతించబడిన అక్షరాల సమితిని నిర్వచించాయి.~8 min
2. 5.2తరగతుల లోపల పరిధులు: `[a-z0-9]`డాష్ ద్వారా విరామాలు; పరిధులు మరియు ఒకే అక్షరాలు కలపడం.~8 min
3. 5.3నిరాకరణ: `[^...]`తిరస్కరించబడిన తరగతి ఏదైనా **తప్ప** జాబితా చేయబడిన అక్షరాలతో సరిపోలుతుంది.~8 min
4. 5.4యూనికోడ్ ఆస్తి తప్పించుకుంటుంది`u` ఫ్లాగ్‌తో `\p{L}`, `\p{N}`, `\p{Script=...}`: సెమాంటిక్ యూనికోడ్ తరగతులు.~12 min

సున్నా-వెడల్పు ప్రకటనలు: అక్షరాలను వినియోగించకుండా స్ట్రింగ్‌లో ముందుకు లేదా వెనుకకు చూడండి. లుక్‌ఎహెడ్ `(?=)` `(?!)`, వెనుకవైపు చూడు `(?<=)` `(?<!)`.

1. 6.1సానుకూల దృష్టి: `(?=...)`ఒక నిర్దిష్ట నమూనా ప్రస్తుత స్థానాన్ని వినియోగించకుండానే అనుసరిస్తుందో లేదో తనిఖీ చేయండి.~10 min
2. 6.2ప్రతికూల దృష్టి: `(?!...)`నిర్దిష్ట నమూనా ప్రస్తుత స్థానాన్ని అనుసరించడం లేదని తనిఖీ చేయండి.~10 min
3. 6.3వెనుకవైపు చూడు: `(?<=...)` `(?<!...)`లుక్‌అరౌండ్ యొక్క "లుక్-బ్యాక్‌వర్డ్" వెర్షన్‌లు; ES2018+ మద్దతు.~12 min
4. 6.4ఆచరణలో చుట్టూ చూడండిసందర్భాన్ని చేర్చకుండా విలువను సంగ్రహించండి, పాస్‌వర్డ్‌లను ధృవీకరించండి, వేరు చేయబడిన సంఖ్యలను అన్వయించండి.~12 min

రీజెక్స్‌తో అన్ని ఫ్లాగ్‌లు (`d`, `v`తో సహా), `String.prototype.replace`/`replaceAll`/`split`, ప్రత్యామ్నాయ స్ట్రింగ్‌లో `$1`/`$<name>` సూచనలు మరియు కాల్‌బ్యాక్‌లను భర్తీ చేయండి.

1. 7.1అన్ని జెండాలు వివరంగా`g i m s u v y d`: ప్రతి ఒక్కరు ఏమి చేస్తారు మరియు అవి ఎలా కలిసిపోతాయి.~12 min
2. 7.2ప్రాథమిక భర్తీ మరియు `$1`సరిపోలికలను స్థిర స్ట్రింగ్‌తో లేదా బ్యాక్-రిఫరెన్స్‌లతో భర్తీ చేయండి `$1` / `$<name>`.~10 min
3. 7.3కాల్‌బ్యాక్‌తో భర్తీ చేయండిప్రత్యామ్నాయం ఫంక్షన్: ప్రతి మ్యాచ్‌ను ఏకపక్ష JS కోడ్‌తో మార్చండి, సమూహాలకు యాక్సెస్.~12 min
4. 7.4రెజెక్స్‌తో విభజించండినమూనాపై స్ట్రింగ్‌ను విభజించండి (అనుమతించే CSV, కనిష్ట టోకెనైజర్).~10 min

వాస్తవ సమస్యలపై అన్నింటినీ కలిపి ఉంచండి: ఇమెయిల్‌లను ధృవీకరించండి, లాగ్‌లను అన్వయించండి, URLలు/IPలను సంగ్రహించండి, ReDoS-నిరోధక నమూనాలను వ్రాయండి.

1. 8.1ఇమెయిల్‌ని ధృవీకరిస్తోందిఇమెయిల్‌ల కోసం "తగినంత మంచి" నమూనా, ట్రేడ్-ఆఫ్‌లు వివరించబడ్డాయి.~12 min
2. 8.2అపాచీ లాగ్ పార్సర్పేరున్న సమూహాలను ఉపయోగించి లాగ్ లైన్ నుండి IP, పద్ధతి, మార్గం మరియు స్థితి కోడ్‌ను సంగ్రహించండి.~12 min
3. 8.3URLలు మరియు IPలను సంగ్రహించడంఉచిత-ఫారమ్ టెక్స్ట్‌లో http(లు) URLలు మరియు IPv4 చిరునామాలను గుర్తించండి.~12 min
4. 8.4ReDoS-సురక్షిత నమూనాలను వ్రాయడంవిపత్తు నమూనాలను గుర్తించండి (`(a+)+b`), వాటిని రీఫాక్టర్ చేయండి, పరమాణు-వంటి క్వాంటిఫైయర్‌లను ఉపయోగించండి.~14 min