เครื่องมือทดสอบและดีบัก Regex

ทดสอบและดีบัก Regular Expression ของ JavaScript ในเบราว์เซอร์ของคุณ ตรวจสอบ Named Capture Group ตำแหน่งการจับคู่ แฟล็ก และการแทนที่สตริงแบบสด

ไม่ต้องอัปโหลดไม่ต้องลงทะเบียนผลลัพธ์ทันที
แฟล็ก g · i · m · s · u · v · yกลุ่มแคปเจอร์ & กลุ่มระบุชื่อ + แทนที่ประมวลผลในเครื่อง 100% • ไม่มีการอัปโหลด
ทดสอบนิพจน์ปรกติ (Regex)
ระบบออฟไลน์พร้อมใช้งานพื้นที่ทำงานบนเบราว์เซอร์ส่วนตัว 100% • ไม่มีการอัปโหลดลงคลาวด์
ส่วนตัว 100% • ไม่อัปโหลดไฟล์ขึ้นเซิร์ฟเวอร์

ทำไมต้องใช้ เครื่องมือทดสอบและดีบัก Regex ฟรีของ Utiliome?

ออกแบบมาเพื่อความเป็นส่วนตัวสูงสุด ทำงานได้ทันที ไม่มีสะดุด ไม่ต้องสมัครสมาชิก ไม่ต้องเสียเงิน และไม่ต้องลงทะเบียน

ทำงานตรงตามมาตรฐาน ECMA-262 RegExp

ประมวลผลด้วยเอนจิน Regular Expression มาตรฐาน ECMAScript ของเบราว์เซอร์โดยตรง พร้อมสลับแฟล็กสำหรับการค้นหาทั้งหมด (g), ไม่สนใจตัวพิมพ์ใหญ่-เล็ก (i), หลายบรรทัด (m), dotAll (s), Unicode (u) และ sticky (y) ได้ทันที

ตรวจสอบ Capture Group ทั้งแบบลำดับเลขและตั้งชื่อ

ดึงข้อมูลช่วงตำแหน่งรหัส UTF-16 แบบเริ่มจากศูนย์ [start, end), กลุ่มย่อยแบบลำดับตัวเลข ($1 ถึง $99) และดิกชันนารีของกลุ่มที่ตั้งชื่อ ((?<name>...)) สำหรับทุกการจับคู่ในข้อความหลายบรรทัด

ดูตัวอย่างการแทนที่สตริงและ Backreference แบบสด

ประมวลผลเทมเพลต String.prototype.replace และ replaceAll แบบเรียลไทม์โดยใช้โทเค็น $1, $<name>, $& (ข้อความที่ตรงทั้งหมด), $' (ข้อความต่อท้ายหลังจุดที่ตรง) และ $$ สำหรับแทนอักขระดอลลาร์

แจ้งเตือนความเสี่ยง ReDoS และปลอดภัยโดยไม่อัปโหลดข้อมูล

ตรวจจับโครงสร้างตัวระบุจำนวนซ้อนทับที่เสี่ยงต่อการเกิด Catastrophic Backtracking พร้อมเก็บรักษาล็อกระบบงานจริง โทเค็นยืนยันตัวตน และข้อมูลส่วนบุคคล (PII) ไว้ในหน่วยความจำของเบราว์เซอร์คุณเท่านั้น

Utiliome เปรียบเทียบกับทางเลือกคลาวด์แบบเดิม

เปรียบเทียบขีดความสามารถของเอนจิน WebAssembly ภายในเครื่อง กับเครื่องมือคลาวด์แบบเก่า

ฟีเจอร์ Utiliome (ประมวลผลในเบราว์เซอร์) เครื่องมือแปลงไฟล์บนคลาวด์แบบเดิม
ทำงานตรงตามมาตรฐาน ECMA-262 RegExp ประมวลผลด้วยเอนจิน Regular Expression มาตรฐาน ECMAScript ของเบราว์เซอร์โดยตรง พร้อมสลับแฟล็กสำหรับการค้นหาทั้งหมด (g), ไม่สนใจตัวพิมพ์ใหญ่-เล็ก (i), หลายบรรทัด (m), dotAll (s), Unicode (u) และ sticky (y) ได้ทันที ตัวเลือกจำกัดและไม่มีการปรับแต่งขั้นสูง
ตรวจสอบ Capture Group ทั้งแบบลำดับเลขและตั้งชื่อ ดึงข้อมูลช่วงตำแหน่งรหัส UTF-16 แบบเริ่มจากศูนย์ [start, end), กลุ่มย่อยแบบลำดับตัวเลข ($1 ถึง $99) และดิกชันนารีของกลุ่มที่ตั้งชื่อ ((?<name>...)) สำหรับทุกการจับคู่ในข้อความหลายบรรทัด ต้องใช้โปรแกรมเสริมหรือแก้ไขด้วยตนเอง
ความเป็นส่วนตัวและการประมวลผล ประมวลผลในเบราว์เซอร์ 100% (ไม่อัปโหลดขึ้นเซิร์ฟเวอร์) อัปโหลดข้อมูลไปยังเซิร์ฟเวอร์คลาวด์ภายนอก
ราคาและการสมัครสมาชิก ฟรี 100% ตลอดชีพโดยไม่ต้องสมัครสมาชิก บังคับสมัครสมาชิกหรือต้องจ่ายค่าบริการรายเดือน
วิธีใช้งาน

วิธีใช้งาน เครื่องมือทดสอบและดีบัก Regex ใน 3 ขั้นตอนง่ายๆ

ไม่ต้องติดตั้งโปรแกรม ทุกอย่างทำงานได้โดยตรงผ่านเว็บเบราว์เซอร์ของคุณ

1

กรอกแพตเทิร์นและเลือกแฟล็กของเอนจิน

พิมพ์นิพจน์ทั่วไปโดยไม่ต้องใส่เครื่องหมายทับปิดหัวท้าย และเปิดใช้งานแฟล็ก ECMAScript (g, i, m, s, u, y) ให้ตรงกับรันไทม์ JavaScript หรือ TypeScript เป้าหมายของคุณ

2

วางข้อความตัวอย่างและตรวจสอบกลุ่มข้อมูลที่จับได้

วางสตริงทดสอบหรือโหลดไฟล์ล็อกจากเครื่องเพื่อตรวจสอบขอบเขตการจับคู่ที่ถูกไฮไลต์ ช่วงดัชนีอักขระ ช่องเก็บกลุ่มย่อยตามลำดับเลข และการจับคู่กลุ่ม (?<name>...)

3

ดูตัวอย่างการแทนที่ข้อความและคัดลอกนิพจน์

ป้อนสตริงสำหรับแทนที่โดยอ้างอิง $1, $<name> หรือ $& เพื่อตรวจสอบผลลัพธ์การแปลงข้อความแบบสด จากนั้นคัดลอกนิพจน์ Regex ที่ผ่านการตรวจสอบแล้วไปใช้งาน

การดีบักล็อกเชิงโครงสร้างด้วย Named Capture Group และการแทนที่ข้อความแบบสด

คำตอบโดยย่อ: ผสานการใช้งานกลุ่มจับคู่แบบตั้งชื่อ ((?<name>...)) เข้ากับแฟล็ก global (g) และ multiline (m) เพื่อแยกวิเคราะห์บรรทัดล็อกเชิงโครงสร้างให้อยู่ในรูปดิกชันนารีคีย์-ค่า ตรวจสอบตำแหน่งการจับคู่ UTF-16 ที่แม่นยำ และดูตัวอย่างการแปลงสตริงด้วย $<name> ก่อนนำโค้ดไปใช้งานจริง

เมื่อต้องแก้ไขปัญหา Regular Expression กับข้อมูลเทเลเมทรีหลายบรรทัดหรือไฟล์ล็อกการเข้าถึง ข้อผิดพลาดเพียงเล็กน้อยในการใช้ตัวระบุตำแหน่ง (Anchor) หรือตัวระบุจำนวน (Quantifier) มักทำให้การจับคู่ล้มเหลวโดยไม่มีการแจ้งเตือน หรือทำให้ลำดับกลุ่มตัวเลขคลาดเคลื่อน ลองพิจารณาบรรทัดล็อกของแอปพลิเคชันเชิงโครงสร้างสองบรรทัดที่ประกอบด้วยเวลาตามมาตรฐาน ISO-8601, ป้ายระบุระดับความรุนแรง, ชื่อบริการ, รหัส Trace ID แบบเลขฐานสิบหก 16 ตัวอักษร, รหัสสถานะ HTTP และค่าความหน่วงแบบทศนิยม:

2026-11-01T14:22:08.419Z [ERROR] svc=checkout trace_id=4bf92f3577b34da6 status=502 latency_ms=184.7
2026-11-01T14:22:09.004Z [INFO] svc=inventory trace_id=00f067aa0ba902b7 status=200 latency_ms=12.3

หากต้องการแยกวิเคราะห์ทุกบรรทัดอย่างแม่นยำโดยไม่ต้องพึ่งพาดัชนีอาร์เรย์ตามตำแหน่งที่เปราะบาง ให้ผูกแต่ละฟิลด์ด้วยกลุ่มจับคู่แบบตั้งชื่อของ ECMAScript ((?<name>...)), ครอบส่วนทศนิยมมิลลิวินาทีที่เป็นทางเลือกด้วยกลุ่มแบบไม่จับค่า ((?:...)) และเปิดใช้งานทั้งแฟล็ก g (ค้นหาทั่วทั้งข้อความ) และ m (ให้ ^ และ $ ทำงานแยกตามบรรทัด):

^(?<ts>\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z)\s+\[(?<level>ERROR|WARN|INFO)\]\s+svc=(?<service>[a-z0-9_-]+)\s+trace_id=(?<trace>[0-9a-f]{16})\s+status=(?<status>\d{3})\s+latency_ms=(?<ms>\d+(?:\.\d+)?)$

หากไม่เปิดแฟล็ก m ตัวอักษร ^ และ $ จะยึดติดเฉพาะตำแหน่งดัชนี 0 และจุดสิ้นสุดของบัฟเฟอร์ข้อความทั้งหมดเท่านั้น ทำให้นิพจน์จับคู่ล้มเหลวทันทีเมื่อมีอักขระขึ้นบรรทัดใหม่ (\n) คั่นระหว่างรายการ แต่เมื่อเปิดใช้งาน gm ตัวดีบักกลุ่มจับคู่จะแยกผลลัพธ์ของการจับคู่แต่ละรอบออกมาเป็นทั้งกลุ่มย่อยตามลำดับ (เริ่มนับจาก 1) และออบเจ็กต์ groups ที่มีโครงสร้างชัดเจน:

{
  "matchIndex": 0,
  "span": [0, 99],
  "fullMatch": "2026-11-01T14:22:08.419Z [ERROR] svc=checkout trace_id=4bf92f3577b34da6 status=502 latency_ms=184.7",
  "captures": [
    "2026-11-01T14:22:08.419Z",
    "ERROR",
    "checkout",
    "4bf92f3577b34da6",
    "502",
    "184.7"
  ],
  "groups": {
    "ts": "2026-11-01T14:22:08.419Z",
    "level": "ERROR",
    "service": "checkout",
    "trace": "4bf92f3577b34da6",
    "status": "502",
    "ms": "184.7"
  }
}

เมื่อตรวจสอบขอบเขตการจับคู่เรียบร้อยแล้ว คุณสามารถทดสอบการจัดรูปแบบ String.prototype.replaceAll ได้โดยตรงในพาเนลการแทนที่ข้อความ การระบุเทมเพลต [$<level>] $<service>: HTTP $<status> ($<ms>ms, trace=$<trace>) จะสร้างผลลัพธ์ที่จัดรูปแบบมาตรฐานออกมาทันที:

[ERROR] checkout: HTTP 502 (184.7ms, trace=4bf92f3577b34da6)
[INFO] inventory: HTTP 200 (12.3ms, trace=00f067aa0ba902b7)

หลักการทำงานของเอนจิน ECMA-262 RegExp, กลไกของแฟล็ก และปัญหา Catastrophic Backtracking

คำตอบโดยย่อ: Regular Expression ของ JavaScript ทำงานบนกลไก Backtracking NFA ตามข้อกำหนด ECMA-262 ส่วนที่ 22.2 โดยประมวลผลบนหน่วยรหัส UTF-16 ขนาด 16 บิต เว้นแต่จะเปิดแฟล็ก u เพื่อรองรับการจับคู่ค่าสเกลาร์ Unicode เต็มรูปแบบ การหลีกเลี่ยงตัวระบุจำนวนซ้อนทับที่กำกวมจะช่วยป้องกันอาการค้างแบบ ReDoS ที่มีความซับซ้อนระดับเอ็กซ์โพเนนเชียล O(2^n) ได้

การประมวลผลแบบ Backtracking NFA และสถานะของ `lastIndex`

ต่างจากเอนจิน Deterministic Finite Automata (DFA) แท้ เอนจินของ ECMAScript (เช่น V8 Irregexp, JavaScriptCore Yarr, SpiderMonkey) เลือกใช้สถาปัตยกรรม Nondeterministic Finite Automaton แบบย้อนกลับ (Backtracking NFA) เพื่อรองรับการอ้างอิงย้อนหลัง (\1, \k<name>) และการตรวจสอบเงื่อนไขข้างหน้าและข้างหลัง ((?=...), (?!...), (?<=...), (?<!...)) ทางเลือกที่คั่นด้วย | จะถูกประเมินจากซ้ายไปขวา ส่วนตัวระบุจำนวนแบบ Greedy (*, +, ?, {m,n}) จะจับคู่อักขระให้มากที่สุดเท่าที่เป็นไปได้ก่อน แล้วค่อยถอยกลับมาทีละขั้นเพื่อให้โทเค็นถัดไปจับคู่สำเร็จ ในขณะที่ตัวระบุจำนวนแบบ Reluctant (*?, +?, ??, {m,n}?) จะลองจับคู่ในระยะที่สั้นที่สุดก่อน

เมื่อมีการตั้งค่าแฟล็ก g (global) หรือ y (sticky) เมธอด RegExp.prototype.exec() จะอ่านและแก้ไขค่าพร็อพเพอร์ตี้ lastIndex ของอินสแตนซ์นั้น:

  • Global (g): ค้นหาตั้งแต่ตำแหน่ง lastIndex เป็นต้นไป จากนั้นเลื่อน lastIndex ไปยังตำแหน่งสิ้นสุดของการจับคู่แต่ละครั้ง (หรือเลื่อนไปหนึ่งจุดรหัส Unicode หากเป็นการจับคู่ที่มีความยาวเป็นศูนย์) และรีเซ็ตค่ากลับเป็น 0 เมื่อค้นหาไม่พบ
  • Sticky (y): บังคับให้การจับคู่ต้องเริ่มต้นที่ตำแหน่ง lastIndex เท่านั้นโดยไม่สแกนข้ามไปข้างหน้า หากไม่มีการจับคู่ใดเริ่มที่ตำแหน่ง lastIndex การจับคู่จะล้มเหลวทันทีและรีเซ็ต lastIndex เป็น 0 จึงเหมาะอย่างยิ่งสำหรับการสร้าง Lexical Scanner แบบไม่คัดลอกข้อมูล

อักขระจบบรรทัด, คู่ตัวแทน UTF-16 (Surrogate Pairs) และแฟล็ก `u`

มาตรฐาน ECMA-262 กำหนดจุดรหัสสำหรับอักขระจบบรรทัดไว้ 4 ตัวอย่างชัดเจน ได้แก่ \n (U+000A), \r (U+000D), Line Separator (U+2028) และ Paragraph Separator (U+2029) การเปิดแฟล็ก m จะทำให้ ^ และ $ จับคู่ขอบเขตที่ติดกับจุดรหัสทั้งสี่นี้ได้ และการเปิดแฟล็ก s (dotAll) จะอนุญาตให้ . จับคู่อักขระเหล่านี้ได้ด้วย

โดยค่าเริ่มต้น สตริงใน JavaScript จะถูกจัดเก็บดัชนีเป็นลำดับของหน่วยรหัส UTF-16 ขนาด 16 บิต อักขระ Unicode เพิ่มเติมที่มีค่ารหัสสูงกว่า U+FFFF (เช่น อีโมจิ หรือสัญลักษณ์ทางคณิตศาสตร์) จะใช้พื้นที่เป็นคู่ตัวแทน (Surrogate Pair) จำนวน 2 หน่วย (0xD800–0xDBFF สำหรับ High Surrogate ตามด้วย 0xDC00–0xDFFF สำหรับ Low Surrogate) หากไม่เปิดแฟล็ก u คำสั่ง /^.$/.test("🚀") จะได้ค่าเป็น false เนื่องจาก "🚀".length มีค่าเท่ากับ 2 การเปิดแฟล็ก u จะเปลี่ยนโหมดการจับคู่ให้ใช้ค่าสเกลาร์ Unicode ขนาด 21 บิต, เปิดใช้งานการระบุคุณสมบัติ Unicode (\p{Letter}, \p{Script=Latin}, \P{Control}) และปิดการอนุโลมการใช้อักขระหลีก (Identity Escape) แบบเก่าตามภาคผนวก B เพื่อให้ตรวจพบไวยากรณ์ที่ผิดพลาดได้ตั้งแต่ขั้นตอนคอมไพล์

ไวยากรณ์การแทนที่ข้อความตามมาตรฐาน `GetSubstitution` ของ ECMA-262

การแทนที่ข้อความแบบสดจะทำงานตามตารางกฎ GetSubstitution มาตรฐานดังนี้:

  • $$: แทรกอักขระ $ จริงหนึ่งตัว
  • $&: แทรกสตริงย่อยทั้งหมดที่จับคู่ได้ (match[0])
  • $': แทรกสตริงย่อยส่วนที่อยู่ถัดจากช่วงที่จับคู่ได้
  • $n / $nn: แทรกกลุ่มจับคู่ตามลำดับตัวเลข n โดยเริ่มนับจาก 1 (1 ถึง 99)
  • $<name>: แทรกสตริงที่จับได้จากกลุ่ม (?<name>...) หรือแทรกสตริงว่าง "" หากกลุ่มที่ตั้งชื่อนั้นไม่ได้มีส่วนร่วมในกิ่งการจับคู่ปัจจุบัน

การป้องกันปัญหา Catastrophic Backtracking (ReDoS)

ช่องโหว่ Regular Expression Denial of Service (ReDoS) เกิดขึ้นเมื่อตัวระบุจำนวนที่ซ้อนกันหรือทับซ้อนกัน เช่น (a+)+$, ([a-zA-Z0-9]+\s?)*$ หรือ (.*a){12} พยายามจับคู่สตริงย่อยชุดเดียวกันผ่านการแบ่งส่วนที่มีความเป็นไปได้เพิ่มขึ้นแบบทวีคูณ (O(2^n) ขั้นตอน) ก่อนที่จะล้มเหลวที่อักขระตัวสุดท้าย เนื่องจากมาตรฐาน ECMA-262 ไม่มีตัวระบุจำนวนแบบ Possessive (++) และกลุ่มอะตอมมิก ((?>...)) คุณจึงควรปรับปรุงแพตเทิร์นให้ปลอดภัยด้วยวิธีต่อไปนี้:

  1. ใช้เซตอักขระที่ไม่ทับซ้อนกัน: แทนที่การใช้ .* แบบ Greedy ระหว่างตัวคั่นด้วยคลาสอักขระแบบปฏิเสธ เช่น [^,\r\n]* เพื่อไม่ให้เอนจินกวาดข้ามขอบเขตของตัวคั่น
  2. คลี่โครงสร้างตัวคั่น (Delimiter Unrolling): เขียนแพตเทิร์น ^(\w+-?)+$ (ซึ่งกำกวมเมื่อไม่มีเครื่องหมาย -) ใหม่เป็น ^\w+(?:-\w+)*$ เพื่อลดความซับซ้อนในกรณีเลวร้ายที่สุดให้เป็นเชิงเส้น O(n) อย่างแท้จริง
  3. จำลองการทำงานแบบ Atomic ด้วย Lookahead: ในจุดที่ต้องห้ามไม่ให้มีการถอยกลับเข้าไปในนิพจน์ย่อย ให้จับคู่ภายใน Positive Lookahead แล้วบังคับอ่านค่าทันทีด้วยการอ้างอิงย้อนหลัง เช่น (?=(\w+))\1

เครื่องมือทดสอบ Regex เทียบกับเครื่องมือสร้างโค้ด Regex: คุณควรใช้ตัวไหน?

คำตอบโดยย่อ: ใช้เครื่องมือทดสอบและดีบัก Regex เมื่อคุณมีแพตเทิร์นอยู่แล้วและต้องการตรวจสอบตำแหน่งการจับคู่ ดีบักกลุ่มจับคู่แบบตั้งชื่อ สลับแฟล็ก ECMAScript หรือทดสอบการแทนที่สตริงด้วย $<name> กับข้อมูลจริง และใช้เครื่องมือสร้างโค้ด Regex จากตัวอย่าง เมื่อต้องการประกอบนิพจน์ใหม่ด้วยบล็อกแบบเห็นภาพหรือส่งออกโค้ด Regex สำหรับหลายภาษา

แม้ว่าการทดสอบและการสร้างแพตเทิร์นจะอยู่ในกระบวนการทำงานกับ Regular Expression เหมือนกัน แต่ทั้งสองเครื่องมือถูกออกแบบมาเพื่อแก้ปัญหาทางวิศวกรรมที่ต่างกัน เครื่องมือทดสอบและดีบัก Regex คือพื้นที่ทำงานเชิงโต้ตอบสำหรับวิเคราะห์ว่าแพตเทิร์น ECMAScript ที่มีอยู่ทำงานอย่างไรเมื่อเจอกับข้อมูลจริงที่ซับซ้อน แต่หากคุณต้องการประกอบนิพจน์ใหม่จากบล็อกส่วนประกอบ เริ่มต้นจากเทมเพลตมาตรฐาน RFC หรือส่งออกโค้ดที่มีการทำ Escape อย่างถูกต้องสำหรับภาษา Python, Go หรือ Rust ให้สลับไปใช้ เครื่องมือสร้างโค้ด Regex จากตัวอย่าง แทน

ความสามารถ เครื่องมือทดสอบและดีบัก Regex เครื่องมือสร้างโค้ด Regex จากตัวอย่าง
งานวิศวกรรมหลัก ดีบักการจับคู่ ช่วงตำแหน่งของกลุ่ม แฟล็ก และการแทนที่ข้อความในแพตเทิร์นที่มีอยู่ สร้างแพตเทิร์นใหม่แบบเห็นภาพจากบล็อกหรือเทมเพลตมาตรฐาน RFC ที่ผ่านการตรวจสอบแล้ว
ข้อมูลตั้งต้น นิพจน์ Regex ดิบ แฟล็ก ECMAScript และข้อความทดสอบหรือไฟล์ล็อกหลายบรรทัด บล็อกโทเค็นที่นำมาประกอบกันได้ หรือสูตรสำเร็จสำหรับนักพัฒนา (UUID, SemVer, IPv4, ISO-8601)
การดีบัก Capture Group แสดงช่วงตำแหน่ง [start, end) ครบถ้วน ช่องอาร์เรย์ $1–$99 และดิกชันนารี (?<name>...) ตรวจสอบผลลัพธ์ผ่าน/ไม่ผ่านจากชุดข้อมูลทดสอบทั้งกรณีที่ควรตรงและไม่ควรตรง
การแทนที่สตริงแบบสด ดูตัวอย่าง replace / replaceAll แบบเรียลไทม์ด้วย $1, $<name>, $& และ $$ ไม่ได้เน้นการทดสอบเทมเพลตแปลงข้อความ
การส่งออกโค้ดหลายภาษา ส่งออก Regex Literal และแพตเทิร์นตามมาตรฐาน ECMAScript / JavaScript สร้างโค้ดพร้อมใช้สำหรับ JavaScript, Python (re), Go (regexp) และ Rust (regex)
จุดเน้นด้านสถาปัตยกรรมเอนจิน กลไก Backtracking NFA ตามมาตรฐาน ECMA-262 และการตรวจจับความเสี่ยง ReDoS ความเข้ากันได้ข้ามเอนจินระหว่าง ECMA-262, Python re และเอนจินความเร็วเชิงเส้น RE2

ลำดับการทำงานที่แนะนำ

เริ่มต้นที่ เครื่องมือสร้างโค้ด Regex จากตัวอย่าง เมื่อคุณต้องการวางโครงสร้างกฎตรวจสอบความถูกต้องของข้อมูลที่มีรูปแบบชัดเจน เช่น หมายเลขเวอร์ชัน SemVer, รหัส UUID ตามมาตรฐาน RFC 9562 หรือ URL Slug สำหรับระบบที่พัฒนาด้วยหลายภาษา และเมื่อนำแพตเทิร์นไปใช้งานจริงบนระบบ Frontend หรือไปป์ไลน์ Node.js แล้ว—หรือเมื่อใดก็ตามที่นิพจน์เกิดจับคู่ข้อมูลขอบเขตพิเศษในล็อกระบบงานจริงพลาดไป—ให้นำนิพจน์และตัวอย่างล็อกดิบมาวางใน เครื่องมือทดสอบและดีบัก Regex แห่งนี้เพื่อตรวจสอบช่วงอักขระของการจับคู่แต่ละรายการ การเปลี่ยนแปลงค่า lastIndex ตามแฟล็ก และเทมเพลตการแทนที่ข้อความ

คำถามที่พบบ่อย

คำถามที่พบบ่อยและคู่มือทางเทคนิค เครื่องมือทดสอบและดีบัก Regex

รวมทุกสิ่งที่คุณควรรู้เกี่ยวกับการใช้งาน เว็บทดสอบ regex ออนไลน์ฟรีของ Utiliome

ทำไม Regex ที่เปิดแฟล็ก global จึงคืนค่า true และ false สลับกันเมื่อเรียกใช้ RegExp.prototype.test() ใน JavaScript?

เมื่อมีการตั้งค่าแฟล็ก global (g) หรือ sticky (y) บนออบเจ็กต์ RegExp ใน JavaScript การเรียกใช้ .test() หรือ .exec() จะอัปเดตพร็อพเพอร์ตี้ lastIndex ของอินสแตนซ์นั้นให้ชี้ไปยังตำแหน่งถัดจากสตริงย่อยที่เพิ่งจับคู่ได้ทันที การเรียก .test() ครั้งถัดไปจึงเริ่มสแกนต่อจากตำแหน่ง lastIndex แทนที่จะเริ่มที่ดัชนี 0 และเมื่อสแกนไปจนสุดสตริงโดยไม่พบการจับคู่เพิ่มเติม เมธอดจะคืนค่า false พร้อมรีเซ็ต lastIndex กลับไปเป็น 0 หากต้องการตรวจสอบค่าความจริงแบบไม่เก็บสถานะ ให้เอาแฟล็ก g ออก หรือกำหนดค่า regex.lastIndex = 0 ด้วยตนเองทุกครั้ง

กลุ่มจับคู่ตามลำดับเลข (Indexed Capture Group), กลุ่มแบบไม่จับค่า (Non-capturing Group) และกลุ่มจับคู่แบบตั้งชื่อ (Named Capture Group) ต่างกันอย่างไร?

วงเล็บมาตรฐาน (...) จะบันทึกสตริงย่อยที่จับคู่ได้ลงในช่องเก็บตามลำดับโดยเริ่มนับจาก 1 ($1, $2) และในอาร์เรย์ที่ได้จากเมธอด exec() ส่วนกลุ่มแบบไม่จับค่า (?:...) ใช้สำหรับรวมโทเค็นเพื่อกำหนดจำนวนซ้ำหรือระบุทางเลือกโดยไม่บันทึกเป็นผลลัพธ์ย่อยและไม่ทำให้ลำดับ $n ของกลุ่มถัดไปเลื่อนออกไป ขณะที่กลุ่มจับคู่แบบตั้งชื่อ (?<name>...) จะบันทึกข้อมูลลงทั้งในช่องลำดับตัวเลขปกติและในพร็อพเพอร์ตี้ match.groups.name (ซึ่งอ้างอิงในสตริงแทนที่ได้ด้วย $<name>) ช่วยป้องกันปัญหาดัชนีคลาดเคลื่อนเมื่อมีการแก้ไขแพตเทิร์นในภายหลัง

ฉันควรเปิดใช้งานแฟล็ก Unicode (u) ใน Regular Expression ของ ECMAScript เมื่อใด?

ควรเปิดแฟล็ก u ทุกครั้งที่ต้องจับคู่ข้อความของผู้ใช้ที่ไม่ใช่รหัส ASCII, อีโมจิ, ตัวอักษรภาพ CJK ส่วนขยาย หรือหมวดหมู่อักขระ Unicode หากไม่เปิดแฟล็ก u JavaScript จะประมวลผลสตริงเป็นหน่วยรหัส UTF-16 ขนาด 16 บิต ซึ่งทำให้ . หรือคลาสแบบปฏิเสธอย่าง [^x] หั่นคู่ตัวแทน (Surrogate Pair) ขนาด 4 ไบต์ที่มีรหัสสูงกว่า U+FFFF แยกออกจากกันจนอักขระเสียหาย การเปิดแฟล็ก u จะเปลี่ยนไปจับคู่ตามจุดรหัส Unicode ขนาด 21 บิตแบบเต็มรูปแบบ, เปิดใช้งานการระบุคุณสมบัติผ่าน \p{...} เช่น \p{Letter} และ \p{Number} รวมถึงบังคับตรวจสอบไวยากรณ์อย่างเข้มงวดเมื่อพบการใช้อักขระหลีกที่ไม่รู้จัก

โทเค็นสำหรับแทนที่ข้อความอย่าง $&, $1 และ $<name> ทำงานอย่างไรในหน้าต่างดูตัวอย่างการแทนที่แบบสด?

หน้าต่างดูตัวอย่างการแทนที่ข้อความใช้ขั้นตอนวิธี GetSubstitution ตามมาตรฐาน ECMA-262 ซึ่งเป็นตัวเดียวกับที่ใช้ใน String.prototype.replace() และ replaceAll() โดยโทเค็น $& จะแทรกสตริงย่อยทั้งหมดที่จับคู่ได้, $1 ถึง $99 จะแทรกข้อมูลจากกลุ่มจับคู่ตามลำดับตัวเลขที่ตรงกัน, $<name> จะแทรกข้อความที่จับได้จากกลุ่ม (?<name>...), $' จะแทรกข้อความทั้งหมดที่อยู่หลังจุดที่จับคู่ได้, เครื่องหมายดอลลาร์ตามด้วย Backtick จะแทรกข้อความทั้งหมดที่อยู่ก่อนหน้าจุดที่จับคู่ได้ และ $$ จะแสดงผลเป็นอักขระ $ จริงหนึ่งตัว

อะไรคือสาเหตุของปัญหา Catastrophic Backtracking (ReDoS) และฉันจะเขียนแพตเทิร์นที่มีช่องโหว่ใหม่ให้ปลอดภัยได้อย่างไร?

ปัญหา Catastrophic Backtracking เกิดขึ้นในเอนจินแบบ Backtracking NFA เมื่อตัวระบุจำนวนที่ซ้อนกันหรือทับซ้อนกัน เช่น (a+)+b หรือ ^([a-zA-Z0-9]+\s?)*$ สามารถแบ่งสตริงอินพุตชุดเดียวกันได้ถึง O(2^n) รูปแบบก่อนที่จะตรวจสอบพบว่าล้มเหลวที่อักขระตัวสุดท้าย คุณสามารถกำจัดความกำกวมนี้ได้โดยแทนที่การใช้ .* แบบ Greedy ด้วยคลาสอักขระแบบปฏิเสธ ([^,\r\n]*), คลี่โครงสร้างตัวคั่นที่เป็นทางเลือกออกเป็น ^[a-zA-Z0-9]+(?:\s[a-zA-Z0-9]+)*$ และจำกัดขอบเขตของตัวระบุจำนวนแบบปลายเปิดให้ชัดเจน ({1,64}) หากต้องการสร้างแพตเทิร์นที่ทำงานในเวลาเชิงเส้นและเข้ากันได้กับเอนจิน RE2 ตั้งแต่ต้น สามารถใช้ เครื่องมือสร้างโค้ด Regex จากตัวอย่าง ได้