Skip to content

Penguji Regex Gratis — Debug & Cocokkan Pola Online

Uji pola regex secara langsung terhadap teks apa pun. Penyorotan kecocokan waktu nyata, grup tangkap, pratinjau ganti, pemisah, dan penjelas pola. Ekspresi reguler rasa JavaScript, 100% privat, tanpa daftar.

Tanpa Pelacakan Berjalan di Browser Gratis
Semua pengujian berjalan secara lokal di peramban Anda. Pola dan teks Anda tidak pernah meninggalkan perangkat ini.
Flag
    Kecocokan disorot
    Kecocokan & grup tangkap
    Ditinjau untuk fidelitas ECMA-262, kebenaran grup tangkap (dengan dan tanpa flag /d), paritas template penggantian dengan String.prototype.replace, ketahanan ReDoS melalui penganggaran wall-clock, dan aksesibilitas (peran ARIA, pengumuman kecocokan pembaca layar, penanganan RTL/LTR). — Tim Tooling Teks Go Tools · May 21, 2026

    Apa Itu Penguji Regex?

    Penguji regex (penguji ekspresi reguler) adalah alat yang memungkinkan Anda menulis pola regex, menempel sepotong teks uji, dan melihat persis apa yang dicocokkan oleh pola — dengan grup tangkap, pratinjau penggantian, dan rincian flag — tanpa mengompilasi ulang kode atau menjalankan skrip. Untuk developer, ia mempersingkat loop dari menit ke milidetik: ubah pola, perhatikan sorotan bergerak, kirim regex dengan percaya diri.

    Ekspresi reguler adalah bahasa ringkas untuk menggambarkan pola teks. `\d+` mencocokkan satu digit atau lebih. `[A-Za-z_]\w*` mencocokkan identifier tipikal. `(?\d{4})-(?\d{2})-(?\d{2})` mencocokkan tanggal ISO dan menamai setiap bagian. Ekspresi reguler adalah tulang punggung cari-dan-ganti di setiap editor kode, validasi di setiap formulir, parsing log di setiap stack observability, dan `grep`, `sed`, serta `awk` — alat Unix yang menjalankan separuh internet. Mereka juga terkenal sulit ditulis dengan benar: quantifier off-by-one atau escape yang hilang dapat mencocokkan substring yang salah, melewatkan kecocokan sepenuhnya, atau — kasus terburuk — memicu catastrophic backtracking yang menyandera inti CPU. Penguji regex yang baik menangkap masing-masing mode kegagalan ini sebelum mencapai produksi.

    Penguji ini menjalankan engine RegExp ECMA-262 native yang dikirimkan di setiap peramban modern — engine yang sama yang Anda panggil dari JavaScript, TypeScript, Node.js, Deno, atau Bun. Itu berarti: grup tangkap (bernomor dan bernama dengan `(?...)`), assertion lookahead dan lookbehind (`(?=...)`, `(?!...)`, `(?<=...)`, `(?

    Apa yang dimunculkan penguji di luar kecocokan mentah: panel Kecocokan & grup tangkap mendaftar setiap kecocokan dengan offset [start, end)-nya dan nilai setiap grup tangkap — informasi yang sama yang akan Anda dapatkan dari `String.prototype.matchAll` dengan flag /d, tetapi diatur untuk pemindaian visual. Tab Ganti menampilkan pratinjau substitusi langsung yang mendukung alfabet template $1 / $& / $` / $' / $$ / $ penuh — persis apa yang diterima String.replace JavaScript. Tab Pisah menerapkan String.split dengan regex dan menunjukkan setiap bagian. Tab Jelaskan men-tokenisasi pola dan menganotasi setiap potongan dalam bahasa Inggris sederhana, berguna untuk code review, mengajar, dan porting antar dialek.

    Untuk privasi: setiap operasi adalah lokal. Pola dan teks uji Anda tidak pernah meninggalkan halaman — mereka tidak dicatat, tidak dikirim ke layanan analitik, tidak disimpan di disk. Hanya preferensi UI Anda (tab aktif + flag mana yang biasanya Anda nyalakan) bertahan ke localStorage. Itu membuat alat ini aman untuk sampel log yang disunting, pola proprietary, konfigurasi internal, dan pola yang mengandung petunjuk tentang skema data Anda. Dibandingkan dengan penguji yang didukung server seperti regex101, cerita privasi dan latensi sangat lebih baik; trade-off-nya adalah dukungan rasa tunggal (hanya JavaScript).

    Jika Anda baru mengenal regex, dropdown Pola umum dilengkapi dengan pemula yang teruji-tempur: alamat email, URL, IPv4, UUID, hex color, tanggal ISO, nomor telepon AS, dan pola pangkas-spasi-putih-tertinggal. Muat salah satu, amati kecocokan terhadap teks sampel yang disediakan, lalu mutasi pola satu karakter pada satu waktu untuk merasakan bagaimana engine merespons. Padukan dengan alat Text Diff ketika Anda ingin membandingkan sebelum/sesudah pembersihan berbasis regex, dengan JSON Formatter ketika masukan atau output yang diharapkan adalah JSON, atau dengan encoder URL ketika string yang Anda cocokkan adalah URL-encoded.

    // The pattern you build in this tester drops straight into JavaScript.
// Example: extract every ISO date from a string with named groups.

const pattern = /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/g;
const text = 'shipped 2026-05-21, scheduled 2026-06-30';

for (const m of text.matchAll(pattern)) {
  console.log(m.groups.year, m.groups.month, m.groups.day);
  // → 2026 05 21
  // → 2026 06 30
}

// Same regex, used in a replace with $<name> templates:
text.replace(pattern, '$<day>/$<month>/$<year>');
// → 'shipped 21/05/2026, scheduled 30/06/2026'

// With the /d flag, every match carries [start, end] indices
// per capture group — the Matches panel uses this to paint offsets.
const p2 = /(?<year>\d{4})-(?<month>\d{2})/gd;
const m = [...text.matchAll(p2)][0];
m.indices.groups.year; // [8, 12]

    Fitur Utama

    Penyorotan Kecocokan Langsung

    Setiap kecocokan dalam teks uji Anda menyala saat pola Anda terurai. Warna bergantian membuat kecocokan berdekatan mudah dihitung secara visual, dan lencana jumlah di atas hasil memberi tahu Anda total yang tepat — tanpa tombol Jalankan, tanpa penundaan debounce di atas 200ms.

    Panel Samping Grup Tangkap

    Panel Kecocokan & grup tangkap di sebelah kanan mendaftar setiap kecocokan sebagai kartu dengan offset [start, end)-nya, teks kecocokan penuh, dan setiap grup tangkap posisional + bernama di dalamnya. Grup bernama melabeli dirinya sebagai $ sehingga Anda dapat membaca data dengan cara yang sama seperti Anda akan mengonsumsinya dalam kode.

    Pratinjau Ganti Langsung dengan $1 / $& / $

    Beralihlah ke tab Ganti untuk melihat substitusi Anda diterapkan secara waktu nyata. Alfabet penggantian ECMAScript penuh bekerja: $1..$N untuk posisional, $ untuk bernama, $& untuk seluruh kecocokan, $` dan $' untuk prefix/suffix, $$ untuk dolar literal. Panel masukan dan output berdampingan dengan salin satu-klik.

    Pisah dengan Batas Regex

    Tab Pisah memanggil String.prototype.split dengan regex Anda dan menampilkan setiap bagian sebagai daftar bernomor. Bagian kosong dirender dengan glif ⏎ sehingga Anda dapat melihat bagaimana engine menangani pembatas berdekatan — berguna untuk men-debug pembersihan masukan mirip-CSV.

    Penjelas Pola (Token-per-Token)

    Tab Jelaskan men-tokenisasi pola Anda menjadi chip yang diwarnai berdasarkan kelas (escape / quantifier / character class / grup / anchor / alternasi) dan menganotasi setiap chip dengan deskripsi satu baris. Baca regex Anda sendiri kembali ke diri Anda sebelum pengiriman; gunakan untuk code review atau mengajar.

    Aman-ReDoS (Timeout Wall-Clock)

    Setiap pemanggilan kecocokan dibungkus dalam anggaran 250 milidetik. Bentuk catastrophic-backtracking klasik seperti `(a+)+`, `(a|aa)+b`, dan quantifier bersarang dalam dibatalkan dengan bersih dengan peringatan Pola kehabisan waktu — halaman tetap responsif alih-alih mengunci tab. Deteksi tanpa sandbox sisi-server.

    Pustaka Pola Umum

    Pemula teruji-tempur untuk delapan pola yang paling sering dijangkau developer: email, URL, IPv4, UUID v4, hex color, tanggal ISO, nomor telepon AS, dan pangkas-spasi-putih-tertinggal. Masing-masing dimuat dengan sampel yang cocok sehingga Anda melihat regex bekerja sebelum Anda mengadaptasinya.

    Berbagi Permalink (Tanpa Unggah)

    Salin tautan mengkodekan pola + flag + teks sampel ke hash URL (#p=…&f=gim&t=…). Peramban tidak pernah mengirimkan fragmen URL dalam permintaan, sehingga tautan yang dibagikan mereproduksi state Anda di mesin penerima tanpa menyentuh server go-tools.org. Mandiri, ramah-audit.

    100% Privat, Hanya-Peramban

    Regex dan teks uji Anda tidak pernah meninggalkan perangkat Anda. Tanpa permintaan jaringan, tanpa pencatatan, tanpa analitik pada apa yang Anda ketik. Verifikasi di DevTools → Network: nol permintaan saat Anda mengetik. Aman untuk pola proprietary, log yang disunting, dan teks apa pun yang tidak akan Anda tempel ke regex101.

    Contoh Terkerjakan

    Ekstrak setiap alamat email dari sebuah paragraf

    [a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}
    /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g

    Tempel pola dengan flag /g aktif, jatuhkan sebuah paragraf ke teks uji, dan setiap email menyala dalam tampilan yang disorot. Panel Kecocokan & grup tangkap di sebelah kanan mendaftar setiap alamat dengan offset [start, end)-nya — berguna saat menyalurkan regex yang sama ke grep, sed, atau editor kode.

    Tangkap bagian tanggal dengan grup bernama

    (?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})
    /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/g

    Grup bernama ECMA-262 muncul di panel kanan sebagai $, $, $. Beralihlah ke tab Ganti dan coba $/$/$ untuk memformat ulang tanggal ISO menjadi DMY dalam sekali jalan — trik yang sama bekerja di setiap pemanggilan replace JS modern.

    Cari/ganti dengan referensi-balik $1

    (\w+) (\w+)
    Penggantian: $2, $1   →   Jack Doe → Doe, Jack

    Dua grup tangkap tanpa nama, template penggantian $2, $1, dan tab Ganti memberi Anda pratinjau langsung. $&, $`, $', $$, dan $ semuanya didukung — persis alfabet substitusi dari spesifikasi ECMAScript, sehingga apa yang Anda salin keluar berjalan tanpa perubahan di mesin JS mana pun.

    Lucuti spasi-putih tertinggal baris demi baris

    [ \t]+$
    /[ \t]+$/gm

    Gabungkan flag /g (global) dan /m (multiline) sehingga $ berlabuh di setiap akhir baris, bukan hanya akhir masukan. Tab Ganti dengan pratinjau penggantian kosong menampilkan diff bersih: tab dan spasi tertinggal lenyap, prosa tetap di tempatnya. Regex yang sama dengan flag /s (dotAll) mati membuat . tidak melintasi baris baru.

    Deteksi catastrophic backtracking dan selamat darinya

    (a+)+b
    Teks uji: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaac

    Quantifier + bersarang membentuk pola ReDoS klasik. Di penguji naif ini menggantung tab. Di sini penjaga wall-clock menyala setelah 250ms, banner Pola kehabisan waktu muncul, dan halaman tetap responsif. Berlabuhkan pola, beralih ke alternasi non-tumpang-tindih, atau gunakan idiom seperti-atomic — lalu uji ulang.

    Pisah baris mirip-CSV dengan pembatas campuran

    [,;|]\s*
    alpha, beta; gamma | delta → ["alpha", "beta", "gamma", "delta"]

    Beralihlah ke tab Pisah. Koma, titik koma, atau pipa apa pun (diikuti spasi-putih opsional) menjadi batas bagian. Berguna untuk membersihkan daftar tag yang ditempel, menormalkan masukan pengguna, atau memproses bidang log sebelum parser CSV sungguhan — lihat CSV ke JSON ketika datanya benar-benar RFC 4180.

    Cara Menggunakan Penguji Regex

    1. 1

      Ketik pola Anda di antara garis miring

      Jatuhkan ekspresi reguler ECMA-262 apa pun ke bidang /…/. Pola yang buruk disorot merah dengan pesan parser; pola yang valid melanjutkan ke pencocokan langsung.

    2. 2

      Aktifkan/matikan flag yang Anda butuhkan

      g (global), i (case-insensitive), m (multiline), s (dotAll), u (unicode), y (sticky), d (indeks). Setiap chip menyala ketika aktif; tampilan baca di kanan pola menunjukkan literal kanonik.

    3. 3

      Tempel teks uji Anda

      Kecocokan disorot dalam warna bergantian saat Anda mengetik. Panel Kecocokan & grup tangkap di sebelah kanan mendaftar setiap kecocokan dengan offset [start, end) dan nilai setiap grup tangkap (grup bernama dilabeli $).

    4. 4

      Beralih tab untuk Ganti, Pisah, atau Jelaskan

      Ganti pratinjau template substitusi berdampingan dengan masukan. Pisah mengiris di setiap batas kecocokan. Jelaskan memecah pola token-per-token dengan deskripsi berbahasa-sederhana per elemen.

    5. 5

      Salin literal atau bagikan permalink

      Salin /pattern/flags menjatuhkan literal regex kanonik ke clipboard Anda untuk penggunaan langsung di JavaScript / TypeScript / Node. Salin tautan mengkodekan state penuh ke hash URL (tanpa unggah) sehingga kolega dapat mereproduksinya secara lokal.

    Kesalahan Regex yang Umum

    Lupa flag /g dan hanya mendapat satu kecocokan

    Tanpa /g (atau /y), engine berhenti setelah kecocokan pertama. Metode match, matchAll, replace, dan split semuanya berperilaku berbeda di sekitar flag global. Aktifkan /g dan jalankan ulang; jumlah di atas hasil melompat dari 1 ke N.

    ✗ Salah 
    Pola: /\d+/  →  '1 22 333' menghasilkan hanya ['1']
    ✓ Benar 
    Pola: /\d+/g  →  '1 22 333' menghasilkan ['1', '22', '333']

    Quantifier serakah mengonsumsi terlalu banyak

    `.+` mengonsumsi sebanyak mungkin, jadi `<.+>` terhadap ` and ` menangkap ` and `, bukan ``. Gunakan quantifier malas (`.+?`), character class yang lebih restriktif (`[^>]+`), atau berlabuh dengan lookaround.

    ✗ Salah 
    Pola: /<.+>/  →  mencocokkan '<a> and <b>'
    ✓ Benar 
    Pola: /<[^>]+>/  →  mencocokkan '<a>' dan '<b>' secara terpisah

    Catastrophic backtracking dari quantifier bersarang

    `(a+)+b` terhadap string gagal yang panjang meledak secara eksponensial. Banner Pola kehabisan waktu menyala setelah 250ms; tulis ulang untuk menghapus penyarangan: `a+b` melakukan pekerjaan yang sama dalam waktu linear. Simulasi grup atomik `(?=(a+))\1b` adalah opsi lain.

    ✗ Salah 
    Pola: /(a+)+b/  pada 'aaaaaaaaaaaaaaaaaaaaac'  →  timeout
    ✓ Benar 
    Pola: /a+b/  pada masukan yang sama  →  instan 'tidak ada kecocokan'

    Anchor $ dan ^ tidak berperilaku seperti \A dan \Z Python

    Di JavaScript, `^` dan `$` berarti awal-baris / akhir-baris HANYA ketika /m aktif; jika tidak mereka berarti awal-string / akhir-string. `\A` dan `\Z` Python (yang selalu berarti batas string) tidak ada di JS. Aktifkan /m sesuai kebutuhan.

    ✗ Salah 
    Pola: /^Error/  pada log multi-baris tanpa /m  →  mencocokkan hanya baris pertama
    ✓ Benar 
    Pola: /^Error/m  pada masukan yang sama  →  mencocokkan setiap baris yang dimulai dengan Error

    Menggunakan $1 dalam string tetapi memanggil replace dengan fungsi

    `text.replace(re, '$1')` memperluas referensi-balik. `text.replace(re, () => '$1')` melewatkan string literal '$1' karena fungsi tidak melihat token template. Di dalam fungsi, grup tangkap tiba sebagai argumen posisional.

    ✗ Salah 
    text.replace(/(\w+)/, m => '$1')  →  menghasilkan literal '$1'
    ✓ Benar 
    text.replace(/(\w+)/, (_, g1) => g1.toUpperCase())  →  menggunakan tangkapan

    Karakter Unicode tidak cocok dengan \w atau .

    Default `\w` adalah `[A-Za-z0-9_]`. Untuk mencocokkan setiap huruf di setiap aksara, aktifkan /u dan beralih ke `\p{Letter}` (`\p{L}`). Titik juga berhenti di baris baru secara default — gunakan /s (dotAll) ketika Anda ingin karakter-apa-pun yang sejati.

    ✗ Salah 
    Pola: /\w+/  mencocokkan 'hello' tetapi tidak 'héllo' atau '你好'
    ✓ Benar 
    Pola: /\p{Letter}+/u  mencocokkan ketiganya

    Menempel pola PCRE; mendapat SyntaxError

    JavaScript tidak mendukung grup atomik `(?>...)`, quantifier posesif `a++`, modifier inline `(?i)`, conditional `(?(1)yes|no)`, atau `\A` / `\Z`. Error parser menamai konstruksi yang menyinggung — tulis ulang ke padanan yang didukung-JS (simulasi lookaround, toggle flag terpisah, alternasi).

    ✗ Salah 
    Pola: (?i)foo  →  SyntaxError: grup tidak valid
    ✓ Benar 
    Pola: foo dengan flag /i diaktifkan  →  efek yang sama

    Siapa yang Menggunakan Alat Ini

    Validasi Masukan Formulir Sebelum Pengiriman
    Konfirmasikan regex email / telepon / kode pos / username Anda mencocokkan apa yang Anda harapkan — dan menolak apa yang tidak — di seluruh kasus tepi (nama unicode, plus-aliasing, format internasional) sebelum validasi mencapai produksi dan memantulkan pengguna nyata.
    Ekstrak Data dari Log dan Config
    Bangun pola yang menarik ID permintaan, kode status, latensi, atau baris stack-trace dari irisan log sembarang. Grup bernama membuat data mendokumentasi-diri; panel Kecocokan menunjukkan offset sehingga Anda dapat menyalurkan regex yang sama ke `rg --replace` atau `grep -oE` setelahnya.
    Cari/Ganti Lintas Basis Kode
    Susun draf pola refactor (mis. `(\w+)\.apply\(null,\s*\[(.*?)\]\)` → `$1($2)`) di sini, pratinjau substitusi terhadap cuplikan representatif, lalu tempel regex yang divalidasi ke cari/ganti seluruh-proyek editor Anda dengan percaya diri.
    Periksa Kewarasan Pola yang Ditemukan Online
    Menempel regex dari StackOverflow atau blog? Jatuhkan ke tab Jelaskan — setiap token dianotasi dalam bahasa Inggris sederhana. Menangkap masalah halus (`.+?` di mana Anda menginginkan `.+`, anchor `^`/`$` yang hilang, quantifier yang tidak sengaja serakah) sebelum regex mendarat di kode Anda.
    Ajarkan Regex ke Rekan Tim
    Buka tab Jelaskan pada pola yang berfungsi dan telusuri token-per-token. Pengkodean warna (escape / quantifier / character class / grup / anchor / alternasi) memungkinkan pelajar melihat bentuk struktural regex, bukan hanya karakternya.
    Porting Pola Antar Bahasa
    Memiliki regex Python atau PCRE yang perlu Anda gunakan di JavaScript? Tempel di sini. Jika terurai, penjelas menunjukkan semantik setara-JS; jika tidak, error parser menamai konstruksi yang menyinggung (grup atomik, quantifier posesif, `(?i)` inline) sehingga Anda tahu persis apa yang harus ditulis ulang.
    Debug Regex Produksi yang Lambat
    Jika sebuah regex server diduga melakukan catastrophic backtracking, tempel ke penguji ini dengan sampel masukan. Penjaga wall-clock 250ms menyala pada kasus patologis, memberi Anda diagnosis langsung sebelum Anda menjangkau alat profiler — dan penjelas menunjuk pada akar masalah quantifier-bersarang.

    Catatan Engine & Algoritma

    Engine RegExp ECMA-262 (Peramban Native)
    Menggunakan `new RegExp(pattern, flags)` dan engine yang dikirimkan dengan V8 / JavaScriptCore / SpiderMonkey — semantik regex yang sama yang Anda dapatkan di JavaScript di mana saja. Pola yang divalidasi di sini berjalan tanpa perubahan di Node.js, Deno, Bun, dan setiap peramban modern.
    Iterasi Kecocokan via String.matchAll
    Iterasi global menggunakan `text.matchAll(regex)` alih-alih loop lastIndex manual, sehingga setiap kecocokan membawa grup tangkapnya, grup bernama, dan (dengan /d) indeks [start, end]. Kecocokan lebar-nol ditangani dengan kenaikan lastIndex +1 standar untuk menghindari infinite loop.
    Timeout Wall-Clock untuk Perlindungan ReDoS
    Anggaran 250 milidetik membungkus setiap pemanggilan match, replace, dan split. Engine masih dapat backtrack secara internal pada satu upaya kecocokan, tetapi iterasi luar bekerja sama dengan anggaran — pola patologis dibatalkan dengan `timedOut: true` dan UI memunculkan peringatan alih-alih mengunci tab.
    Reimplementasi Template Penggantian
    Tab Ganti mengurai $1..$N, $&, $`, $', $$, dan $ secara manual alih-alih mendelegasikan ke `String.replace`, sehingga pratinjau berperilaku identik lintas engine (Safari lama, Node lama) di mana template grup-bernama memiliki kasus tepi. Output adalah persis apa yang dihasilkan engine JavaScript saat ini.
    Tokenizer Pola untuk Penjelas
    Tab Jelaskan menjalankan tokenizer tulisan-tangan yang mengklasifikasikan setiap fragmen pola (escape / metakarakter / quantifier / character class / pembuka-grup / penutup-grup / anchor / alternasi). Konstruksi yang tidak dikenal jatuh ke `literal` dengan catatan generik sehingga penjelas tidak pernah secara diam-diam menjatuhkan konten.
    Permalink melalui Hash URL (Tidak Pernah Dikirim)
    State bagikan dikodekan dalam fragmen location.hash (`#p=…&f=…&t=…&tab=…`). Peramban tidak pernah mengirimkan fragmen dalam permintaan HTTP, sehingga server go-tools.org menerima nol data ketika permalink dibuka. Hidrasi terjadi sepenuhnya di perangkat penerima.

    Praktik Terbaik Regex

    Berlabuhkan Pola Saat Anda Bermaksud Begitu
    `^pola$` mencocokkan string tepat; `pola` mencocokkan di mana saja. Pilihan yang salah adalah bug paling umum dalam validasi formulir: `^` yang hilang membiarkan `attacker.com/` di depan lolos dari pemeriksaan domain; `$` yang hilang membiarkan sampah tertinggal lewat. Gunakan tab Cocok terhadap sampel yang sengaja rusak untuk mengonfirmasi apa yang ditolak.
    Pilih Grup Non-Tangkap untuk Struktur Murni
    `(?:foo|bar)+` dan `(foo|bar)+` secara fungsional identik, tetapi yang pertama tidak mengalokasikan grup tangkap. Jangkau `(?:…)` kapan pun grup hanya ada untuk quantifier atau alternasi — menjaga $1..$N bernomor Anda stabil dan menghemat sedikit pekerjaan engine.
    Gunakan Flag /u untuk Apa Pun di Luar ASCII
    Tanpa /u, titik dan `\w` memperlakukan karakter pasangan-surrogate (emoji, code point non-BMP) sebagai dua unit UTF-16. Dengan /u, mereka adalah satu code point masing-masing — apa yang akan dipersepsikan pengguna Anda. /u juga mengaktifkan `\p{Letter}` dan property escape lainnya. Default ke /u untuk pola baru kecuali Anda memiliki alasan khusus untuk tidak melakukannya.
    Beri Nama Grup Tangkap Anda
    `(?\d{4})-(?\d{2})` mendokumentasi-diri. Enam bulan kemudian ketika Anda membaca regex kembali, `m.groups.year` jelas adalah tahun — `m[1]` tidak. Template penggantian dengan $ juga bertahan dari penataan ulang grup: template posisional rusak begitu seseorang menambahkan grup lain.
    Uji Kasus Kegagalan, Bukan Hanya Sukses
    Penguji regex adalah untuk kegagalan. Konfirmasikan apa yang dicocokkan pola Anda, lalu sengaja mutasi teks uji untuk melihat apa yang tidak — spasi-putih di depan, spasi-putih tertinggal, bagian yang hilang, bagian ekstra, huruf yang salah, aksara campuran. Pola yang lulus masukan valid tetapi menerima sampah adalah bug yang pertama kali dipaparkan produksi.

    Pertanyaan yang Sering Diajukan

    Apakah regex atau teks uji saya dikirim ke server Anda?
    Tidak. Setiap operasi cocok, ganti, pisah, dan jelaskan berjalan dalam JavaScript di dalam peramban Anda menggunakan engine RegExp native. Pola dan teks Anda tidak diunggah, tidak dicatat, tidak disimpan di disk, tidak dikirim ke pihak ketiga mana pun. Hanya preferensi UI Anda (tab aktif + flag mana yang biasanya Anda nyalakan) yang disimpan ke localStorage sehingga halaman mengingatnya kunjungan berikutnya — tidak pernah pola atau teks uji. Anda dapat memverifikasi dengan membuka DevTools → Network: mengetik di salah satu kotak memicu nol permintaan. Hal ini membuat alat aman untuk pola proprietary, sampel log yang disunting, konfigurasi internal, dan apa pun yang tidak akan Anda tempel ke regex101.
    Rasa regex apa yang digunakan penguji ini — PCRE, Python, Java, JavaScript?
    ECMA-262 (JavaScript), dialek yang diimplementasikan oleh V8, JavaScriptCore, dan SpiderMonkey — engine yang sama yang Anda dapatkan dari `new RegExp(pattern, flags)` di peramban mana pun, Node.js, Deno, atau Bun. Itu berarti fitur yang didukung adalah: grup tangkap (bernomor + bernama dengan `(?...)`), lookahead `(?=...)` dan `(?!...)`, lookbehind `(?<=...)` dan `(?...)`, quantifier posesif `a++`, conditional `(?(1)yes|no)`, dan modifier inline `(?i)` akan melempar syntax error. `re.VERBOSE` Python tidak didukung di sini. Untuk regex Python/Java/Go, porting pola kembali ke engine native-nya — sebagian besar pola sederhana berpindah tanpa perubahan, dan penjelas di sini netral-rasa.
    Apa fungsi masing-masing flag g, i, m, s, u, y, d?
    g (global) — temukan setiap kecocokan, bukan hanya yang pertama; diperlukan untuk iterasi dengan .matchAll dan untuk replace global. i (case-insensitive) — A dan a mencocokkan karakter yang sama. m (multiline) — ^ dan $ berlabuh di setiap line break, bukan hanya awal/akhir seluruh masukan. s (dotAll) — . juga mencocokkan baris baru; tanpa /s sebuah titik berhenti di \n. u (unicode) — mengaktifkan escape \u{HHHH}, Unicode property escape (\p{Letter}), dan memperlakukan pola sebagai urutan code point Unicode alih-alih unit kode UTF-16. y (sticky) — melabuhkan setiap kecocokan di lastIndex, berguna untuk tokenizer. d (hasIndices, ES2022) — mengisi `.indices` dan `.indices.groups` dengan pasangan [start, end] untuk setiap tangkapan; penguji ini menggunakan /d di balik layar untuk menggambar batas grup. Aktifkan/matikan sebagai chip di atas teks uji; literal /pattern/flags kanonik ditampilkan di tampilan baca..
    Bagaimana cara menulis grup tangkap dan bagaimana cara merujuk kembali ke sana?
    Bungkus sub-pola dalam tanda kurung: `(\d{4})-(\d{2})-(\d{2})` memberi Anda tiga grup posisional, dapat diakses sebagai $1, $2, $3 dalam penggantian atau sebagai m.groups[0..2] di panel Kecocokan. Gunakan `(?...)` untuk grup bernama: `(?\d{4})-(?\d{2})` memungkinkan Anda menulis $/$ di template penggantian. Gunakan `(?:...)` untuk grup non-tangkap saat Anda hanya perlu pengelompokan untuk quantifier (`(?:foo|bar)+`) — ia tidak membuat referensi-balik, yang menjaga $1..$N bernomor Anda stabil. Di dalam pola yang sama, rujuk tangkapan sebelumnya dengan `\1`, `\2`, dll. — berguna untuk menemukan kata ganda seperti `\b(\w+)\s+\1\b`.
    Bagaimana cara kerja lookahead dan lookbehind, dan untuk apa keduanya bagus?
    Lookaround adalah assertion lebar-nol — mereka memeriksa bahwa sesuatu cocok (atau tidak) tanpa mengonsumsi karakter. `(?=foo)` (lookahead positif) berhasil jika `foo` mengikuti posisi saat ini; `(?!foo)` (lookahead negatif) berhasil jika `foo` TIDAK mengikuti. `(?<=foo)` dan `(?
    Mengapa regex saya menggantung peramban, dan apa itu catastrophic backtracking?
    Catastrophic backtracking terjadi ketika sebuah pola memiliki quantifier bersarang di atas alternatif yang tumpang tindih — bentuk klasiknya adalah `(a+)+`, `(a|aa)+`, `(\w*)*`, atau `(?:a|a?)+`. Pada masukan di mana kecocokan dapat gagal di karakter terakhir, engine mencoba jumlah eksponensial pemisahan grup sebelum menyerah. Pada `aaaaaaaaaaaaaaaaaaaaab` dengan pola `(a+)+b`, itu adalah 2^21 ≈ 2 juta backtrack sebelum jawabannya. Penguji ini membungkus setiap pemanggilan kecocokan dalam anggaran wall-clock 250ms — jika anggaran terlampaui, iterasi berhenti dan Anda melihat peringatan Pola kehabisan waktu. Perbaikan: berlabuhkan pola ke batasnya (`^...$`), pilih alternatif non-tumpang-tindih (`(a|b)` alih-alih `(a|aa)`), bongkar quantifier bersarang (`a+` alih-alih `(a+)+`), atau tulis ulang untuk menggunakan idiom mirip-posesif (`(?=(a+))\1` mensimulasikan `a++` di JS).
    Apa bedanya penguji regex ini dengan regex101.com?
    Tiga perbedaan. (1) Privasi: regex101 mengirim setiap penekanan tombol ke servernya untuk evaluasi backend dan menyimpan pola dalam tautan komunitas bersama; alat ini berjalan sepenuhnya di peramban Anda, tanpa panggilan jaringan. (2) Kecepatan: round-trip server pada setiap perubahan menambahkan 80-300ms; di sini kecocokan diperbarui dalam waktu kurang dari 10ms bahkan pada teks panjang. (3) Fokus rasa: regex101 mendukung PCRE, Python, Java, .NET, JavaScript, Rust, dan Go dengan UI flag-fitur; alat ini fokus pada ECMA-262 (JavaScript) — rasa yang dikirimkan setiap peramban, Node, Deno, dan Bun — dan penjelas plus permalink disetel ke rasa tunggal itu. Jika Anda memerlukan fitur khas PCRE, regex101 masih merupakan alat yang tepat; untuk pekerjaan JavaScript / TypeScript, ini lebih cepat dan lebih privat. Permalink di sini adalah hash URL (tanpa unggah), sehingga tautan yang dibagikan mereproduksi pola Anda secara lokal di mesin penerima.
    Bagaimana cara meng-escape karakter spesial seperti . | ( ) [ ] { } * + ? ^ $ \?
    Letakkan backslash di depan: `\.`, `\|`, `\(`, `\)`, `\[`, `\]`, `\{`, `\}`, `\*`, `\+`, `\?`, `\^`, `\$`, `\\`. Forward slash `/` tidak perlu di-escape dalam pola yang dilewatkan-string (hanya dalam literal regex JS di antara garis miring). Di dalam character class `[...]` sebagian besar metakarakter kehilangan arti spesialnya, sehingga `[.]`, `[*]`, `[+]` semuanya mencocokkan karakter literal — satu-satunya metakarakter yang tetap spesial adalah `]`, `\`, `^` (hanya di awal untuk negasi), dan `-` (rentang ketika di antara dua karakter). Saat ragu, tempel teks literal ke pola dan jalankan penjelas: setiap urutan escape mendapat deskripsi satu baris di panel rincian.
    Bisakah saya membagikan regex dengan kolega melalui tautan?
    Ya — dan tautan tidak berisi round-trip server. Klik Salin tautan di action bar: penguji mengkodekan pola, flag, teks uji, dan tab aktif Anda ke dalam hash URL (`#p=...&f=gim&t=...&tab=match`). Siapa pun yang membuka tautan menghidrasi halaman dengan state yang sama — secara lokal di mesin mereka. Karena data berada di fragmen hash, ia tidak pernah dikirim ke server go-tools.org (peramban tidak mengirimkan fragmen dalam permintaan) dan tidak dicatat dalam log akses kami. Panjang tautan tumbuh dengan ukuran teks, jadi untuk sampel >2KB, salin regex melalui Salin /pattern/flags dan tempel teks secara terpisah. Untuk ulasan regex kolaboratif tanpa membagikan teks sebenarnya, bagikan hanya pola dan flag — penerima menempelkan korpus mereka sendiri dan mendapatkan kecocokan yang sama.
    Apakah penguji mendukung Unicode, emoji, dan aksara non-Latin?
    Ya. Aktifkan flag /u untuk memilih penanganan Unicode penuh: \w mencocokkan karakter kata Latin (semantik default), tetapi dengan /u Anda dapat mencocokkan kategori yang lebih luas melalui Unicode property escape — `\p{Letter}` mencocokkan setiap huruf di setiap aksara, `\p{Script=Han}` mencocokkan ideograf Tionghoa, `\p{Emoji}` mencocokkan emoji, `\p{Number}` mencocokkan setiap digit/angka. Tanpa /u, emoji pasangan-surrogate seperti 👨‍💻 dilihat sebagai dua unit kode UTF-16 dan pola seperti `^.$` akan gagal mencocokkannya; dengan /u titik memperlakukan setiap code point grafem sebagai satu karakter. Untuk aksara RTL (Arab, Ibrani), pola bekerja tanpa penanganan khusus — arah adalah masalah waktu-render, bukan masalah engine regex. Konten CJK cocok dengan cara yang sama dengan Latin.
    Apa perbedaan antara .match, .matchAll, .replace, dan .split dengan regex?
    String.prototype.match mengembalikan kecocokan pertama (atau array semua kecocokan ketika /g disetel) tetapi kehilangan grup tangkap ketika /g aktif. String.prototype.matchAll memerlukan /g dan mengembalikan iterator array kecocokan DENGAN grup tangkap dan indeks — yang digunakan penguji ini secara internal. String.prototype.replace menerima template string ($1, $&, dll.) atau callback yang dipanggil per kecocokan dengan (match, ...groups, offset, string, namedGroups). String.prototype.split memisah di setiap kecocokan — berguna dengan /g tetapi flag global diabaikan untuk semantik split. Alat ini menampilkan match melalui tab Cocok, replace melalui Ganti, dan split melalui Pisah, sehingga Anda dapat melihat pratinjau setiap rasa tanpa meninggalkan halaman; literal /pattern/flags adalah satu klik jauhnya saat Anda siap menempel ke kode.
    Mengapa regex Python atau Java saya tidak bekerja di sini?
    Karena penguji ini menjalankan ECMA-262 (JavaScript) — sebagian besar pola di-port dengan bersih, segelintir tidak. Gotcha porting umum: (1) Flag inline Python `(?i)` dan `(?x)` tidak valid di JS — gunakan chip flag di atas. (2) `\A` dan `\Z` Python adalah `^` dan `$` di JS (dengan /m untuk anchor baris). (3) Conditional Java/Python `(?(name)yes|no)` tidak didukung di JS — tulis ulang dengan alternasi. (4) Quantifier posesif `a++` dan grup atomik `(?>...)` tidak tersedia di JS — simulasikan dengan `(?=(a+))\1`. (5) `(?P...)` Python adalah `(?...)` di JS. (6) `\h` untuk spasi-putih horizontal dan `\v` untuk vertikal tidak ada di JS — gunakan `[ \t]` dan `[\n\r]`. Untuk porting yang portabel, penjelas memecah apa yang dilakukan setiap token sehingga Anda dapat menukar sintaks yang tidak didukung dengan padanannya.
    Apakah ada ukuran teks maksimum atau jumlah kecocokan?
    Batas praktis: sekitar 200.000 karakter teks uji dan 500 kecocokan yang disorot ditampilkan sekaligus. Di atas 500 kecocokan, panel Kecocokan menampilkan banner Menampilkan 500 pertama; lencana jumlah masih melaporkan total sebenarnya. Anggaran wall-clock 250ms membatasi pola yang lepas kendali terlepas dari ukuran. Untuk file log multi-megabyte, jalankan regex dengan baris perintah `grep -oE` atau `rg` (ripgrep) — mereka stream dan tidak akan mencapai batas rendering UI. Untuk pemindaian satu kali pada teks besar, tempel irisan representatif ke penguji ini untuk memvalidasi pola, lalu jalankan pola yang divalidasi terhadap file lengkap di shell Anda.

    Alat Terkait

    Lihat semua alat →

    Bandingkan Teks & Text Diff

    Pemrosesan Teks

    Bandingkan dua teks langsung di browser. Tampilan berdampingan, sorotan per kata, ekspor diff terpadu, opsi abaikan kapitalisasi/spasi/baris kosong. 100 % di browser — tanpa upload.

    Alat Penghitung Kata & Karakter Gratis

    Pemrosesan Teks

    Hitung kata, karakter, kalimat, paragraf, dan waktu baca secara langsung. Penghitung kata waktu nyata dengan pemeriksaan batas Twitter, meta description, dan Instagram. Gratis, privat, tanpa daftar.

    Konverter Basis Bilangan — Biner, Hex, Desimal & Oktal

    Alat Konversi

    Konversi antara biner, hex, desimal, oktal, dan basis apa pun (2-36) secara instan. Presisi BigInt, output siap kode. Gratis, privat — tanpa pendaftaran.

    Decode & Encode Base64 Online — Konversi Instan di Browser

    Encoding & Pemformatan

    Decode dan encode Base64 online gratis. Konversi real-time dengan dukungan UTF-8 dan emoji. 100% privat di browser Anda. Tanpa pendaftaran.

    Generator Crontab & Pembuat Ekspresi Cron

    Tanggal & Waktu

    Bangun, validasi, dan dekode ekspresi cron di peramban Anda. Pratinjau langsung jadwal berikutnya dalam waktu lokal atau UTC. Sintaksis POSIX 5 kolom, preset, deskripsi bahasa biasa. Gratis, privat, tanpa daftar.

    Konverter CSV ke JSON

    Encoding & Pemformatan

    Konversi CSV ke JSON di browser. RFC 4180, infer tipe, baris header, aman big-int. 100% privat, tanpa unggah.