Regex lookahead va lookbehind: (?=), (?!), (?<=), (?<!)

Qisqacha: Lookahead (?=...) — "bu joydan keyin shu narsa turibdimi?" deb tekshiradi, lekin uni moslikka qo'shmaydi. Lookbehind (?<=...) — "bu joydan oldin shu narsa turibdimi?". Inkor shakllari: (?!...) — "keyin bu yo'q", (?<!...) — "oldin bu yo'q". Ular langarlar kabi nol kenglikdagi: joyni tekshiradi, belgi yemaydi.

Bu darsda

• To'rtta lookaround shaklini o'qiysiz va yozasiz: (?=), (?!), (?<=), (?<!).
• \d+(?= so'm) bilan faqat narxni olasiz — so'm so'zisiz.
• Bir nechta lookahead bilan parol talablarini bitta naqshda tekshirasiz va bu yondashuvning chegarasini bilasiz.
• 35000 ni 35 000 ko'rinishiga keltiradigan mashhur regex'ni qismma-qism tushuntira olasiz.
• O'zbekcha apostrofli so'zlar uchun \b dan ishonchliroq "so'z chegarasi" yasaysiz.

Oldin bilishingiz kerak: Langarlar va so'z chegarasi, Quantifierlar: greedy va lazy, Guruhlar va alternation, Flaglar va lastIndex tuzog'i.

1. Nega bu kerak?

«Bahor» egasi Jasur aka Sardordan so'radi: "Sharhlardan faqat narxlarni ajratib ber. Kishilar soni, stol raqami kerak emas". Narxning belgisi bor — undan keyin so'm turadi:

const sharh = "Osh 35000 so'm, choy 5000 so'm, stol 4";

console.log(sharh.match(/\d+ so'm/g));
// [ "35000 so'm", "5000 so'm" ]

To'g'ri sonlar topildi, lekin ular bilan birga so'm ham keldi. Endi har birini yana tozalash kerak. Guruh bilan olish mumkin — matchAll va [1]. Lekin bu ham ortiqcha qadam.

Sardorga boshqacha vosita kerak: "son, undan keyin so'm turgan bo'lsin, lekin so'm ni olma". Ya'ni atrofga qarash, lekin uni yemaslik.

Siz bunday vositani bilasiz. ^, $ va \b ham belgi yemaydi — ular faqat joyni tekshiradi (Langarlar darsidan). Bugungi to'rt vosita — ularning kuchaytirilgan varianti: "bu joyda nima turibdi?" degan savolni istalgan naqsh bilan berish mumkin. To'rttasining umumiy nomi — lookaround ("atrofga qarash"): ikkitasi oldinga, ikkitasi orqaga qaraydi.

2. Lookahead: (?=...) — "keyin shu turibdimi?"

2.1 Qarash, lekin olmaslik

Lookahead ("oldinga qarash") — (?=...). U regex dvigateli (naqshni matn bo'ylab bajaradigan qism, Quantifierlar darsidan) turgan joydan o'ngga qaraydi. Qavs ichidagi naqsh shu yerda mos kelsa — tekshiruv o'tadi. Lekin dvigatel joyidan siljimaydi va qaragan matni moslikka qo'shilmaydi.

Hayotiy o'xshatish: ko'chani kesib o'tishdan oldin chap-o'ngga qaraysiz. Qarash — yo'lning bir qismi emas, siz hali ham trotuardasiz. Faqat "yo'l bo'shmi?" degan savolga javob oldingiz.

Sardorning masalasi:

const sharh = "Osh 35000 so'm, choy 5000 so'm, stol 4";

console.log(sharh.match(/\d+(?= so'm)/g)); // [ '35000', '5000' ]

\d+ sonni oladi. (?= so'm) esa so'raydi: "shu sondan keyin so'm bormi?". Bor bo'lsa — moslik o'tadi, lekin so'm unga kirmaydi. stol 4 dagi 4 dan keyin so'm yo'q — u tushib qoldi.

Maydonda sinang:

2.2 Nol kenglik — nima degani

Langarlar darsida langarlarni nol kenglikdagi tekshiruv degan edik: ular ikki belgi orasidagi joyga mos keladi, belgining o'ziga emas. Lookaround ham xuddi shunday.

Buni ko'rish uchun lookahead'ni yolg'iz ishlatamiz:

console.log("osh".search(/(?=s)/)); // 1
console.log("osh".match(/(?=s)/g)); // [ '' ]

search 1-o'rinni qaytardi — o va s orasidagi joy. Topilgan moslik esa bo'sh satr: lookahead hech qanday belgi olmadi, faqat "shu yerdan keyin s bor" deb tasdiqladi.

Shuning uchun bir nechta lookahead'ni ketma-ket qo'yish mumkin: hammasi bitta joydan qaraydi. Bu parol tekshiruvining siri — birozdan keyin ko'ramiz.

Tekshirib ko'ring: "Lag'mon 28000 so'm".match(/\d+(?= so'm)/)[0].length nima qaytaradi?

3. Inkor lookahead: (?!...) — "keyin bu yo'q"

3.1 Teskari savol

Inkor lookahead — (?!...). U teskari savolni beradi: "shu joydan keyin bu naqsh yo'qmi?". Yo'q bo'lsa — o'tadi.

Belgilar va belgi klasslari darsida bir savol ochiq qolgan edi: [^osh] "osh so'zidan boshqa" degani emas, u faqat bitta belgini inkor qiladi. So'zni inkor qilish uchun — inkor lookahead:

const taomlar = "osh manti oshxona somsa";

console.log(taomlar.match(/\b(?!osh\b)\w+/g));
// [ 'manti', 'oshxona', 'somsa' ]

O'qiymiz: so'z boshida (\b) turib, oldinga qara — "bu yerdan osh so'zi (va so'z chegarasi) boshlanmaydimi?". Boshlanmasa, so'zni ol. oshxona o'tdi: unda osh dan keyin chegara yo'q, x bor.

3.2 Tuzoq: orqaga qaytish lookahead'ni aldaydi

Sardor endi teskarisini xohladi: so'm siz sonlar — ya'ni kishilar soni va stol raqami. Mantiqan:

Nega 3500? Quantifierlar darsidagi orqaga qaytish (backtracking) ishladi. Dvigatel avval 35000 ni oldi va qaradi: keyin so'm bor — inkor muvaffaqiyatsiz. Taslim bo'lmasdan, \d+ dan bitta raqam qaytardi. Endi moslik 3500, undan keyin esa 0 turibdi, so'm emas — inkor o'tdi!

Tuzatish — son bo'linmasligini talab qilish. \b\d+\b — son butunligicha olinsin, keyin tekshirilsin:

const sharh = "Osh 35000 so'm, choy 5000 so'm, stol 4";

console.log(sharh.match(/\b\d+\b(?! so'm)/g)); // [ '4' ]

Qoida: inkor lookahead'dan oldin quantifier bo'lsa, u qisqarib, tekshiruvni chetlab o'tishi mumkin. Bo'lakning chegarasini aniq belgilang.

4. Lookbehind: (?<=...) va (?<!...)

4.1 Orqaga qarash

Lookbehind ("orqaga qarash") — (?<=...). Lookahead'ning ko'zgudagi aksi: "shu joydan oldin bu naqsh bormi?". Inkor shakli — (?<!...): "oldin bu yo'qmi?". Qavs ichida ? dan keyin < belgisi — "chapga" degan ishora.

vazifalar dagi teglardan # belgisisiz nomlarni olamiz:

Inkor lookbehind — oldida biror narsa yo'q bo'lsin. Masalan, chegirmani (-5000) narx deb olmaslik:

const chek = "Chegirma: -5000, narx 35000";

console.log(chek.match(/(?<![-\d])\d+/g)); // [ '35000' ]

[-\d] — "minus yoki raqam". Nega raqam ham? Yana orqaga qaytish tufayli: busiz dvigatel -5000 ning ichidan 000 ni topardi — undan oldin 5 turibdi, minus emas. Raqamni ham taqiqlab, sonni o'rtasidan boshlashga yo'l qo'ymadik.

4.2 JavaScript lookbehind'i — erkin

Ko'p tillarda lookbehind ichiga faqat aniq uzunlikdagi naqsh yozish mumkin: (?<=abc) — ha, (?<=a+) — yo'q. JavaScript'da bunday cheklov yo'q — istalgan naqsh ishlaydi:

const menyu = "Osh 35000\nManti 30000\nKo'k choy 5000";

console.log(menyu.match(/(?<=^[\w' ]+ )\d+/gm));
// [ '35000', '30000', '5000' ]

Lookbehind ichida langar, quantifier, klass — hammasi bor. m flagi tufayli ^ har qator boshi. Natija: "qator boshidan so'zlar va bo'sh joy kelgan joydan keyingi son". Internetdan boshqa til uchun yozilgan regex'ni ko'chirsangiz, bu farq teskari ham ishlaydi: JavaScript'dagi naqsh boshqa tilda xato berishi mumkin.

4.3 Brauzer mosligi — tarixiy tuzoq

Lookahead JavaScript'da boshidan bor. Lookbehind esa ES2018 da qo'shilgan. Chrome uni 2017-yildan, Firefox 2020-yildan qo'llaydi, Safari esa faqat 16.4 versiyadan — 2023-yil mart oyidan (MDN ma'lumotlari).

Bu ko'p saytlarni sindirgan. Gap shundaki, brauzer tanimagan regex literal butun faylni o'qib bo'lmaydigan qiladi. Bitta (?<=...) tufayli eski iPhone'larda saytning hamma JavaScript'i ishlamay qolgan. Bugun bu xavf ancha kamaygan, lekin qoida qoladi: yangi sintaksisni ishlatishdan oldin u qaysi brauzerlarda borligini tekshiring. Buni JS versiyalari va brauzer mosligi darsida o'rganamiz.

Tekshirib ko'ring: /(?<=\+998 )\d{2}/ naqshi "Tel: +998 90 000 00 00" da nimani topadi?

To'rttala shakl bitta jadvalda. Eslab qolish uchun: < — "orqaga", = — "bor", ! — "yo'q":

O'zingiz to'ldiring: "oldin minus yo'q" degan tekshiruv — (?<!-), "oldin minus bor" esa — .

5. Parol talablari: bir nechta lookahead birga

5.1 Bitta joydan uchta savol

Ro'yxatdan o'tish formasida parolga uchta talab bor: kamida 8 belgi, kamida bitta raqam, kamida bitta harf. Va bo'sh joy bo'lmasin.

Oddiy naqsh bilan "raqam qayerdadir bor" deyish qiyin: raqam boshida ham, oxirida ham, o'rtada ham bo'lishi mumkin. Lookahead esa bunga qulay. U matn boshida turib, oldinga qaraydi — va joyidan siljimaydi. Shuning uchun keyingi lookahead ham o'sha boshdan qaraydi:

const parol = /^(?=.*\d)(?=.*[A-Za-z])(?!.*\s).{8,}$/;

console.log(parol.test("bahor2026")); // true
console.log(parol.test("bahorbahor")); // false
console.log(parol.test("12345678")); // false
console.log(parol.test("bahor 2026")); // false
console.log(parol.test("b2026")); // false

Qismma-qism:

.*\d — "istalgan belgilar, keyin raqam": raqam qayerda bo'lsa ham topiladi. Uch tekshiruv ham ^ joyidan bajariladi. Faqat oxirgi bo'lak belgilarni yeydi.

Maydonda har qatorni alohida parol deb sinang (m flagi bilan):

5.2 Yaxshiroq foydalanuvchi tajribasi

Bitta katta regex faqat true yoki false beradi. Foydalanuvchi esa nima yetishmayotganini bilishi kerak: "raqam qo'shing", "8 belgidan kam". Shuning uchun real formalarda talablar ko'pincha alohida tekshiriladi:

function yetishmaydi(parol) {
  const xatolar = [];
  if (parol.length < 8) xatolar.push("kamida 8 belgi");
  if (!/\d/.test(parol)) xatolar.push("raqam");
  if (!/[A-Za-z]/.test(parol)) xatolar.push("harf");
  if (/\s/.test(parol)) xatolar.push("bo'sh joy bo'lmasin");
  return xatolar;
}

console.log(yetishmaydi("bahor")); // [ 'kamida 8 belgi', 'raqam' ]
console.log(yetishmaydi("bahor2026")); // []

Lookahead'li bitta regex HTML pattern atributi uchun qulay (Mobil klaviatura darsida ko'rgansiz) — u yerda faqat bitta naqsh yoziladi. Brauzerdagi formani JavaScript bilan tekshirish — Constraint Validation API.

Diqqat: Xavfsizlik bo'yicha zamonaviy tavsiya (AQSh standartlar instituti NIST, SP 800-63B hujjati) murakkablik qoidalarini — "katta harf, raqam, belgi majburiy" — taqiqlaydi. Ular parolni kuchli qilmaydi: odamlar Parol123! deb yozadi. Tavsiya — uzunlik (kamida 8, yaxshisi 15 belgi) va parolni sizib chiqqan parollar ro'yxati bilan solishtirish. Regex texnikasi baribir kerak, lekin parol siyosatini tanlashda shuni yodda tuting. Parolni serverda xavfsiz saqlash — kursning backend qismida, Parolni xavfsiz saqlash darsida.

6. Sonni minglik bo'yicha ajratish

6.1 Mashhur bir qator

35000 ni 35 000 ko'rinishiga keltirish — internetda eng ko'p ko'chiriladigan regex'lardan biri:

function minglikBilan(son) {
  return String(son).replace(/\B(?=(\d{3})+(?!\d))/g, " ");
}

console.log(minglikBilan(35000)); // 35 000
console.log(minglikBilan(1234567)); // 1 234 567
console.log(minglikBilan(500)); // 500

Ko'pchilik uni tushunmasdan ko'chiradi. Siz esa endi har bo'lagini o'qiy olasiz.

6.2 Qismma-qism

Naqsh hech qanday belgi yemaydi — u faqat joylarni topadi. replace esa har topilgan joyga bo'sh joy qo'yadi.

• \B — so'z chegarasi bo'lmagan joy. Ya'ni ikki raqam orasi. Bu son boshiga bo'sh joy qo'yilishiga yo'l qo'ymaydi.
• (?=...) — shu joydan oldinga qaraymiz.
• (\d{3})+ — oldinda bir yoki bir nechta uchtalik raqam guruhi.
• (?!\d) — va ulardan keyin boshqa raqam yo'q, ya'ni son shu yerda tugaydi.

Birgalikda: "o'ngida raqamlar soni 3 ga karrali bo'lgan va son oxirigacha yetadigan joy". 1234567 da bunday joy ikkita: 1|234567 (o'ngda 6 ta) va 1234|567 (o'ngda 3 ta).

Maydonda bu joylar bo'sh mosliklar sifatida ko'rinadi — chiziqcha belgilar:

Bo'sh mosliklar — nol kenglikdagi naqshning odatiy natijasi. replace ularning har biriga bo'sh joy "qistirdi".

O'zingiz to'ldiring: 35000 sonida minglik ajratuvchi qo'yiladigan joylar soni — .

6.3 Haqiqiy loyihada

Bu regex o'rganish uchun ajoyib misol. Lekin real loyihada pul summasini formatlash uchun brauzerning o'z vositasi bor — Intl.NumberFormat. U har mamlakatning qoidasini biladi: o'zbek va rus tilida minglik orasiga bo'sh joy qo'yiladi, ingliz tilida vergul. Uni Intl.NumberFormat darsida o'rganamiz.

Regex varianti kasr qismini ham buzishi mumkin — buni 3-mashqda ko'rasiz.

7. O'zbekcha so'z chegarasi

Langarlar va so'z chegarasi darsida \b o'zbekcha matnda aldagan edi. \b apostrofni so'z belgisi deb hisoblamaydi, shuning uchun bo'lim ichidan lim ni alohida so'z deb topardi. O'shanda "lookaround bilan aniqroq chegara yasaymiz" degan edik.

\b aslida "bir tomonda so'z belgisi bor, boshqa tomonda yo'q" degani. Biz o'z "so'z belgisi"mizni aniqlaymiz — [\w'] — va ikki tomonga inkor lookaround qo'yamiz:

(?<![\w']) — "oldin harf, raqam yoki apostrof yo'q". (?![\w']) — "keyin ham yo'q". Endi apostrof so'zning bir qismi.

Kirill harflari uchun esa [\w'] ham yetmaydi — u faqat lotin harflarini biladi. Har qanday alifbodagi harf uchun \p{L} kerak. U Unicode regex darsida — shu usul bilan u yerda har tilga mos chegara yasaymiz.

8. Ko'p uchraydigan xatolar

8.1 Inkor lookahead'ni quantifier chetlab o'tadi

\d+(?! so'm) 35000 so'm dan 3500 ni oladi. Quantifier bitta raqam qaytarib, tekshiruvdan qochdi. Tuzatish: chegarani aniqlang: \b\d+\b(?! so'm).

8.2 Lookaround'dan keyin quantifier

Lookaround belgi yemaydi, uni takrorlashning ma'nosi yo'q. Unicode rejimida bu xato:

const naqsh = new RegExp("(?=osh)+", "u");

SyntaxError: Invalid regular expression: /(?=osh)+/u: Invalid quantifier

Tarjimasi: "Noto'g'ri muntazam ifoda: noto'g'ri quantifier." u siz JavaScript buni eski kod uchun jimgina qabul qiladi — lekin ma'nosi baribir yo'q.

8.3 Lookahead'da .* ni unutish

^(?=\d) — "birinchi belgi raqam". "Qayerdadir raqam bor" — ^(?=.*\d). Parol tekshiruvidagi eng ko'p xato shu.

8.4 Lookbehind'ni eski brauzer uchun ishlatish

Literaldagi (?<=...) Safari 16.4 dan eski brauzerda butun skriptni to'xtatadi. Tuzatish: saytingiz qaysi brauzerlarni qo'llashini biling. Kerak bo'lsa — guruh bilan yozing: /#([\w']+)/ va [1].

8.5 Hammasini lookaround bilan yozish

Lookaround — kuchli, lekin o'qish qiyin. \d+(?= so'm) aniq. Beshta lookaround'li naqsh esa bir oydan keyin o'zingizga ham tushunarsiz. Tuzatish: oddiy guruh yoki ikkita alohida test yetarli bo'lsa — shuni tanlang.

9. Mashqlar

1-mashq (oson): Dollar emas, so'm

Matnda narxlar ham so'mda, ham dollarda keladi: "Osh 35000 so'm, vino $25, choy 5000 so'm". somdagiNarxlar(matn) faqat so'mdagi narxlarni son sifatida qaytarsin. Lookahead ishlating.

const chek = "Osh 35000 so'm, vino $25, choy 5000 so'm";
console.log(somdagiNarxlar(chek));
// [ 35000, 5000 ]

function somdagiNarxlar(matn) {
  const narxlar = matn.match(/\d+(?= so'm)/g) ?? [];
  return narxlar.map(Number);
}

const chek = "Osh 35000 so'm, vino $25, choy 5000 so'm";
console.log(somdagiNarxlar(chek));
// [ 35000, 5000 ]

2-mashq (o'rta): Promo-kod

«Bahor» promo-kodi qoidasi: 6 dan 10 gacha belgi, faqat katta lotin harflari va raqamlar, kamida bitta raqam va kamida bitta harf. promoTogrimi(kod) ni bitta regex bilan yozing.

console.log(promoTogrimi("BAHOR26")); // true
console.log(promoTogrimi("BAHORBAHOR")); // false
console.log(promoTogrimi("2026")); // false
console.log(promoTogrimi("bahor26")); // false

function promoTogrimi(kod) {
  return /^(?=.*\d)(?=.*[A-Z])[A-Z\d]{6,10}$/.test(kod);
}

console.log(promoTogrimi("BAHOR26")); // true
console.log(promoTogrimi("BAHORBAHOR")); // false
console.log(promoTogrimi("2026")); // false
console.log(promoTogrimi("bahor26")); // false

3-mashq (qiyin): Kasr qismi buzilmasin

Darsdagi minglikBilan funksiyasi 12500.12345 ni 12 500.12 345 qilib yuboradi — kasr qismiga ham bo'sh joy qo'yadi. Avval buni o'zingiz ko'ring. Keyin naqshga inkor lookbehind qo'shib tuzating: nuqtadan keyingi raqamlar orasiga bo'sh joy qo'yilmasin. Ishora: "oldida nuqta va raqamlar yo'q" — (?<!\.\d*).

console.log(minglikBilan("12500.12345")); // 12 500.12345

const eski = /\B(?=(\d{3})+(?!\d))/g;
const yangi = /(?<!\.\d*)\B(?=(\d{3})+(?!\d))/g;

console.log("12500.12345".replace(eski, " "));

function minglikBilan(son) {
  return String(son).replace(yangi, " ");
}

console.log(minglikBilan("12500.12345"));
console.log(minglikBilan(1234567));

12 500.12 345
12 500.12345
1 234 567

4-mashq: Vazifalar qadami — teg oldida apostrof

Langarlar darsida teglarni \B#[\w']+ bilan ajratgan edik (kurs/mashqlar/12/03-teglar/teglar.mjs). Bu naqsh do'#x dagi #x ni ham teg deb oladi: apostrof \w emas, shuning uchun ' va # orasida chegara yo'q va \B o'tadi. kurs/mashqlar/12/07-teglar/teglar.mjs da inkor lookbehind bilan tuzating: # oldida harf, raqam va apostrof bo'lmasin. Ikkala natijani chiqaring.

const matn = "Sut#2 olish #bozor #do'kon do'#x";

console.log(matn.match(/\B#[\w']+/g));
console.log(matn.match(/(?<![\w'])#[\w']+/g));

[ '#bozor', "#do'kon", '#x' ]
[ '#bozor', "#do'kon" ]

git add 12/07-teglar/teglar.mjs
git commit -m "12/07: teg oldida apostrof — inkor lookbehind"

10. Real ishda

• Forma tekshiruvi. Parol, promo-kod, login qoidalari — "kamida bitta raqam", "bo'sh joy yo'q". Ko'p kutubxonalarning tayyor tekshiruvlari ichida lookahead turadi.
• Formatlash. Narx, karta raqami, telefonni bo'laklarga ajratish (8600 0000...), log'larda maxfiy qismni yashirish — lookaround bilan joy topib, replace qilish.
• Matn tahlili. "Oldida minus yo'q son", "keyin so'm turgan son", "boshqa so'zning bo'lagi bo'lmagan so'z" — ma'lumot ajratishda doimiy vazifalar.
• Intervyu. "Lookahead va lookbehind farqi?", "Parol tekshiradigan regex yozing", "\B(?=(\d{3})+(?!\d)) nima qiladi?" — middle intervyularida tez-tez beriladi.

Xulosa

• Lookaround — nol kenglikdagi tekshiruv: atrofga qaraydi, belgi yemaydi, moslikka qo'shilmaydi.
• (?=X) — keyin X bor; (?!X) — keyin X yo'q; (?<=X) — oldin X bor; (?<!X) — oldin X yo'q.
• Bir nechta lookahead bitta joydan qaraydi — parol talablari ^(?=.*\d)(?=.*[A-Za-z]).{8,}$.
• Inkor lookaround'ni orqaga qaytish chetlab o'tishi mumkin — bo'lak chegarasini aniq belgilang (\b\d+\b).
• JavaScript lookbehind ichida istalgan naqsh mumkin; Safari uni faqat 16.4 dan beri qo'llaydi.
• (?<![\w'])...(?![\w']) — o'zbekcha apostrofni hisobga oladigan so'z chegarasi.

Keyingi dars: Unicode regex: u va v flag — \p{L} bilan har qanday alifbodagi harfni, emoji'ni to'g'ri moslaymiz va o'zbekcha so'z chegarasini oxirigacha hal qilamiz.

Manbalar

• MDN: "Lookahead assertion", "Lookbehind assertion" — developer.mozilla.org
• ECMAScript 2025 Language Specification, 22.2.2.4 "Assertion" — tc39.es/ecma262
• NIST SP 800-63B (Digital Identity Guidelines: Authentication) — pages.nist.gov/800-63-4
• MDN browser-compat-data 8.1.4 — lookbehind qo'llanishi (Chrome 62, Firefox 78, Safari 16.4)