Regex Tester — Online JavaScript Regular Expression Tester _

Paano gumagana ang regex sa iyong browser?

Ang bawat JavaScript runtime ay may kasamang native regular expression engine — ang new RegExp(pattern, flags) ay nag-co-compile ng iyong pattern, tapos ang mga method tulad ng String.prototype.match, String.prototype.replace, at RegExp.prototype.exec ay nagpapatakbo nito laban sa anumang input string. Binabalot ng tester na ito ang engine na iyon sa isang UI para maaari kang mag-edit, magpatakbo, at mag-inspect ng mga pattern nang hindi umaalis sa iyong browser. Walang iyong tina-type — pattern, flag, test string, o replacement — ang ipinapadala sa network.

Paano gumagana ang regex tester?

Ang pipeline ay iilang maikling hakbang, lahat ay tumatakbo sa client-side sa bawat keystroke (dine-debounce ng 150 ms para manatiling maayos ang pagta-type):

1. Ang iyong pattern body ay binabasa mula sa input sa itaas (walang nangunguna o sumusunod na / delimiter — dekoratibo lang ang mga ito). Ang mga napiling flag pill ay pinagsasama sa isang flags string tulad ng gi o gimsuy.
2. Ang new RegExp(patternBody, flags) ay nag-co-compile ng pattern. Kung ang engine ay mag-tthrow ng SyntaxError (hal. hindi magkaparehong panaklong o hindi valid na escape), ang mensahe ay nire-render sa itaas ng test string at ang match list ay naklikliro. Ang compile error ay ang aktwal na err.message mula sa V8 / SpiderMonkey / JavaScriptCore kaya tumutugma ito sa makikita mo sa DevTools.
3. Para sa match list, ang tester ay laging ine-enumerate gamit ang synthetic global flag — kaya kahit i-off mo ang g, ang listahan ay nagpapakita pa rin ng bawat match. Ang standard zero-width-match guard (if (m.index === rx.lastIndex) rx.lastIndex++) ay nagpapanatili ng loop na hindi umiikot sa mga pattern na nag-ma-match ng empty string. Ang Replace mode ay sumusunod sa iyong tunay na flag set kaya ang $& ay kumikilos nang katulad ng String.prototype.replace.
4. Sa pagitan ng bawat iteration, sinusuri ng tester ang performance.now() - start at inaabort kapag lumipas na ang 50 ms. Nagpoprotekta ito laban sa catastrophic backtracking sa mga input tulad ng (a+)+$ laban sa mahabang serye ng a — ang tab ay mag-ha-hang kung wala ito. Best-effort ang guard: ang isang pathological single-match pattern ay maaari pa ring kumonsumo ng oras sa loob ng isang exec call. Kung mangyari iyon, i-refresh ang tab at isulat muli ang pattern gamit ang non-greedy quantifier o atomic-style possessive (hal. [^x]*x).
5. Ang test string ay hinihiwalay sa mga segment sa bawat range ng match at ang mga matched segment ay nakabalot sa mga <mark class="rx-match rx-cap-N"> element, kung saan ang N ay umiikot sa anim na palette na kulay para ang mga kalapit na match ay madaling makilala sa isang tingin. Ang numbered group (m[1], m[2], …) at named group (m.groups) ng bawat match ay nire-render bilang mga may label na row sa ibaba; kung naka-set ang d flag, ipinapakita rin ang per-group [start, end] index.

Bakit gamitin ang regex tester na ito?

• Privacy: ang bawat pattern, test string, at replacement ay tumatakbo sa iyong browser gamit ang built-in na JavaScript RegExp engine. Walang lumalabas sa tab — mahalaga kapag ang input ay customer log, leaked credential pattern, o kahit anong hindi mo ipipe-paste sa hosted SaaS regex playground.
• Tapat na flavor: inilalabas ng tester ang eksaktong regex engine na pinapatakbo ng Node.js, Chrome, Safari, Firefox, at ng bawat browser-based form validator. Walang Perl-flavor translation layer na nagtatago ng mga banayad na pagkakaiba — ang gumagana dito ay gumagana sa iyong code.
• Pag-debug ng capture at named group: ang bawat numbered group ($1, $2, …) at named group ($<year>) ay ipinapakita bawat match para mabuo mo ang isang parser at mabasa ang mga slot nang hindi na hulaan. Pinapahintulutan ng Replace mode na paghaluin mo ang mga group nang malaya — ang $2-$1 ay nagpapalit ng unang dalawang slot, ang $<name> ay naglalagay ng named slot, at ang $& ay ineecho ang buong match.
• Catastrophic-backtracking guard: ang 50 ms na ceiling sa enumeration ay nag-aabort ng pathological na pattern tulad ng (a+)+$ bago i-freeze ang tab. Nakikita mo ang nagpapaliwanag na error imbes na naka-hang na browser, at agad na nare-recover ang page.

Ano ang mga karaniwang gamit ng regex tester?

Ang mga regular expression ay lumalabas sa web development, security, at data work — tina-target ng tester na ito ang mga pinaka-karaniwang use case:

• Form validation: gumawa ng email, telepono, o postal-code pattern, mag-paste ng mga sample input sa test string, at kumpirmahin na ang bawat positibong kaso ay nag-ma-match at ang bawat negatibong kaso ay hindi bago mo i-ship ang pattern sa production code.
• Log scraping: mag-paste ng chunk ng NGINX, application, o audit-log output, sumulat ng pattern na may named group para sa mga bahaging mahalaga sa iyo ((?<ip>…) (?<path>…)), at basahin ang mga captured slot bawat match para kumpirmahing tama ang iyong parser.
• Refactor search-and-replace: gamitin ang Replace mode para sumulat muli ng mga identifier sa isang snippet — ang (\w+)\.set(\w+)\( → $1.$2 = ay nagpapalit ng getter call sa property assignment, at ang live preview ay nagpapakita ng resulta bago mo i-commit ito sa isang codemod.

Ano ang hitsura ng isang halimbawang regex?

Kunin ang pattern na (\d{4})-(\d{2})-(\d{2}) na may g flag, patakbuhin laban sa test string na release 2025-11-15, prerelease 2026-05-25. Nakahanap ang engine ng dalawang match. Ang unang match ay 2025-11-15 na may group 1 = 2025, group 2 = 11, group 3 = 15. Ang pangalawang match ay 2026-05-25 na may parehong group shape. Sa Replace mode, ang replacement template na $3/$2/$1 ay nagsusulat muli ng parehong petsa sa 15/11/2025 at 25/05/2026 — isang one-pattern ISO-to-DMY conversion na maaari mong i-verify nang biswal bago isaksak ang pattern sa isang script.

Gamitin ang tester na ito bilang mabilis na landas para sa anumang regex work — pagbuo, pag-debug, o pag-rewrite ng mga pattern. Lahat ay tumatakbo nang lokal; walang nilo-log; ang regex engine ay anuman ang naka-ship sa iyong browser, kaya ang gawi ay tumutugma sa makikita ng production code sa runtime.