Penjana Corak Regex

Bina ungkapan biasa secara visual daripada blok token dan resipi pembangun yang disahkan.

Tiada muat naikTanpa daftarHasil segera
13 Resipi RFC & Pembangun DisahkanPembina Peraturan & Pengkuantiti VisualCoretan JS · Python · Go · Rust
Jana Regex
Enjin luar talian sediaRuang kerja pelayar 100% peribadi • Tanpa muat naik awan
100% Peribadi • Tanpa Muat Naik Fail ke Pelayan

Mengapa Guna Penjana Corak Regex Percuma Utiliome?

Dibina khas untuk privasi ketat, pelaksanaan serta-merta, dan tanpa kerumitan. Tiada langganan atau pendaftaran akaun.

Blok Token Visual Boleh Gubah

Bina ungkapan biasa yang mudah dibaca langkah demi langkah dengan merangkaikan sauh (anchors), kelas aksara, pengkuantiti bersempadan, kumpulan bukan penangkap ((?:...)) dan tangkapan bernama ((?<name>...)).

Resipi Pembangun Selaras RFC

Muatkan praset yang disahkan untuk e-mel RFC 5322 praktikal, alamat IPv4/IPv6 bersempadan, cap masa ISO-8601 / RFC 3339, tag SemVer 2.0.0, UUID RFC 9562, URL, slug URL dan warna heks CSS.

Coretan Kod Pelbagai Bahasa

Eksport kod sedia dikompil untuk JavaScript (RegExp), Python (rentetan mentah re.compile), Go (literal mentah regexp.MustCompile) dan Rust (regex::Regex), dengan menyesuaikan sintaks kumpulan bernama secara automatik.

Pengesahan Fixture Segera & Privasi

Sahkan rentetan sampel positif dan negatif secara langsung semasa anda melaraskan blok. Setiap penyesuaian resipi, pusingan pengesahan dan eksport kod berjalan 100% di sebelah klien tanpa sebarang panggilan rangkaian.

Utiliome berbanding Alat Awan Tradisional

Bandingkan enjin WebAssembly tempatan kami dengan alat awan lama.

Ciri Utiliome (Penyemak Imbas Tempatan) Penukar Awan Lama
Blok Token Visual Boleh Gubah Bina ungkapan biasa yang mudah dibaca langkah demi langkah dengan merangkaikan sauh (anchors), kelas aksara, pengkuantiti bersempadan, kumpulan bukan penangkap ((?:...)) dan tangkapan bernama ((?<name>...)). Pilihan terhad tanpa penyesuaian lanjutan
Resipi Pembangun Selaras RFC Muatkan praset yang disahkan untuk e-mel RFC 5322 praktikal, alamat IPv4/IPv6 bersempadan, cap masa ISO-8601 / RFC 3339, tag SemVer 2.0.0, UUID RFC 9562, URL, slug URL dan warna heks CSS. Memerlukan alat luaran atau pemprosesan manual
Privasi & Pemprosesan Data 100% setempat dalam pelayar (sifar muat naik pelayan) Memuat naik data ke pelayan awan pihak ketiga
Harga & Keperluan Akaun 100% percuma selamanya tanpa pendaftaran Memerlukan pendaftaran akaun atau langganan berbayar
Cara ia berfungsi

Cara Menggunakan Penjana Corak Regex dalam 3 Langkah Mudah

Pemasangan perisian tidak diperlukan. Semuanya berjalan terus dalam penyemak imbas anda.

1

Pilih Resipi Disahkan atau Tambah Blok Token

Pilih praset yang diuji mengikut RFC (e-mel, IPv4/IPv6, tarikh ISO-8601, SemVer, UUID, URL, slug atau warna heks) atau tambahkan sauh, set aksara, literal dan pengkuantiti secara visual.

2

Konfigurasikan Sauh, Kumpulan dan Rentetan Ujian

Tukar antara pengesahan rentetan tepat (^...$) dengan pemadanan subrentetan, tetapkan pembalut bernama ((?<name>...)) atau bukan penangkap ((?:...)), dan semak fixture ujian positif serta negatif.

3

Salin Regex Mentah atau Kod Pelbagai Bahasa

Eksport corak mentah atau salin coretan kod idiomatik JavaScript, Python, Go atau Rust dengan pelepasan (escaping) rentetan mentah dan sintaks tangkapan khusus enjin yang telah diterapkan.

Menggubah Corak Produksi daripada Blok Token Visual kepada Kod Pelbagai Bahasa

Jawapan Pantas: Rangkaikan blok token bersauh secara berurutan, tetapkan nama medan semantik melalui kumpulan tangkapan bernama ((?<name>...)), sahkan terhadap fixture kes pinggir positif dan negatif, serta eksport coretan rentetan mentah idiomatik yang disesuaikan untuk JavaScript, Python, Go dan Rust.

Menulis ungkapan biasa yang padat secara manual daripada ingatan sering menimbulkan kecacatan halus—seperti titik tanpa lepasan (. yang memadankan sebarang aksara dan bukannya titik literal .), sauh mula/tamat yang tertinggal, atau pepijat sifar pendahulu (leading zero). Menggunakan penggubahan token visual, andaikan anda memerlukan pengesah Semantic Versioning 2.0.0 (SemVer) yang ketat yang menerima awalan pilihan v dan mengekstrak pengecam metadata major, minor, patch, prerelease serta build.

Setiap peraturan struktur dipetakan dengan kemas kepada urutan blok token yang eksplisit:

{
  "anchoring": "exact_line (^...$)",
  "blocks": [
    { "type": "literal", "value": "v", "quantifier": "optional (?)" },
    { "type": "named_capture", "name": "major", "pattern": "0|[1-9]\\d*" },
    { "type": "literal", "value": "." },
    { "type": "named_capture", "name": "minor", "pattern": "0|[1-9]\\d*" },
    { "type": "literal", "value": "." },
    { "type": "named_capture", "name": "patch", "pattern": "0|[1-9]\\d*" },
    {
      "type": "non_capturing",
      "pattern": "-(?<prerelease>[0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*)",
      "quantifier": "optional (?)"
    },
    {
      "type": "non_capturing",
      "pattern": "\\+(?<build>[0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*)",
      "quantifier": "optional (?)"
    }
  ]
}

Perhatikan bagaimana 0|[1-9]\d* menguatkuasakan SemVer 2.0.0 Seksyen 2 dengan membenarkan 0 sambil menolak sifar pendahulu seperti 01, dan bagaimana pembalut bukan penangkap (?:...)? mengawal pembatas - dan + tanpa mencipta kumpulan bernombor tambahan. Mengesahkan terhadap fixture positif dan negatif serta mengeksport kod pelbagai bahasa akan menghasilkan pengisytiharan tepat mengikut enjin secara automatik:

# Corak ECMAScript / Rust yang Disintesis
^v?(?<major>0|[1-9]\d*)\.(?<minor>0|[1-9]\d*)\.(?<patch>0|[1-9]\d*)(?:-(?<prerelease>[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+(?<build>[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?$

# Fixture Positif (Padan)
1.0.0
v2.14.3-rc.1+build.5114f85

# Fixture Negatif (Tolak: sifar pendahulu dalam teras versi angka)
v01.2.0
1.02.3

# Python (rentetan mentah re.compile + sintaks kumpulan bernama (?P<name>...))
SEMVER_RE = re.compile(r"^v?(?P<major>0|[1-9]\d*)\.(?P<minor>0|[1-9]\d*)\.(?P<patch>0|[1-9]\d*)(?:-(?P<prerelease>[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+(?P<build>[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?$")

# Go (literal mentah backtick RE2 regexp.MustCompile + sintaks (?P<name>...))
var semverRe = regexp.MustCompile(`^v?(?P<major>0|[1-9]\d*)\.(?P<minor>0|[1-9]\d*)\.(?P<patch>0|[1-9]\d*)(?:-(?P<prerelease>[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+(?P<build>[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?$`)

Memandangkan penjana ini mengelakkan rujukan balik (backreferences) dan tinjauan keliling (lookarounds) dalam resipi standard, ungkapan yang dieksport dapat dikompil tanpa pengubahsuaian dalam masa jalan RE2 masa linear (Go dan Rust) serta enjin jejak balik (JavaScript dan Python).

Kemudahalihan Enjin Regex Merentas Bahasa, Nuansa Pengesahan RFC dan Peraturan Pelepasan

Jawapan Pantas: Masa jalan ungkapan biasa terbahagi kepada NFA jejak balik (JavaScript RegExp, Python re) dan enjin Thompson NFA / DFA masa linear (Go regexp, Rust regex). Corak mudah alih mengelakkan lookaround dan rujukan balik, menggunakan literal rentetan mentah asli, serta menguatkuasakan sempadan oktet dan nibble RFC yang tepat.

NFA Jejak Balik lwn Automata Masa Linear (Go RE2 dan Rust `regex`)

Enjin ungkapan biasa produksi terbahagi kepada dua model pelaksanaan yang berbeza:

  1. NFA Jejak Balik (JavaScript RegExp, Python re): Meneroka cabang penyelangan secara rekursif, membolehkan rujukan balik (\1, \k<name>) dan penegasan lookahead/lookbehind sembarangan ((?=...), (?!...), (?<=...), (?<!...)), dengan kos potensi masa jalan kes terburuk eksponen pada corak yang kabur.
  2. Thompson NFA / Lazy DFA (Go regexp, Rust regex): Memajukan semua keadaan automata aktif secara serentak bagi setiap bait/titik kod input, menjamin kerumitan masa kes terburuk O(m * n) dalam saiz corak m dan panjang input n. Untuk mengekalkan sempadan keadaan terhingga, Go regexp dan Rust regex mengecualikan rujukan balik dan lookaround secara reka bentuk.

Sintaks kumpulan tangkapan bernama juga berbeza mengikut pustaka standard: ECMAScript memerlukan (?<name>...); Python re dan Go regexp memerlukan (?P<name>...); Rust regex (1.9+) menerima kedua-dua (?<name>...) dan (?P<name>...).

Pelepasan Rentetan Mentah Bahasa Hos

Menyematkan corak di dalam rentetan petikan berganda biasa menyebabkan pengkompil hos mentafsir pelepasan garis condong ke belakang (backslash) terlebih dahulu, memaksa \d+\.\d+ digandakan menjadi "\\d+\\.\\d+" dan berisiko menyebabkan kerosakan senyap (contohnya, "\b" bertukar menjadi ruang undur ASCII 0x08 dan bukannya sempadan perkataan). Coretan yang dieksport menggunakan bentuk literal mentah asli setiap bahasa:

  • JavaScript: Tatatanda literal /pattern/flags (hanya melepaskan garis condong ke hadapan yang belum dilepaskan sebagai \/), atau new RegExp(String.raw..., flags) untuk pembinaan dinamik.
  • Python: Literal rentetan mentah re.compile(r"...") (ambil perhatian bahawa rentetan mentah Python tidak boleh berakhir dengan bilangan garis condong ke belakang yang ganjil).
  • Go: regexp.MustCompile dengan literal backtick mentah, menggantikan \x60 jika aksara backtick literal perlu dipadankan.
  • Rust: regex::Regex::new(r"...") atau literal mentah ber-hash r#"..."# apabila corak itu sendiri mengandungi tanda petikan berganda.

Sempadan Ketepatan RFC dalam Resipi Pembangun

  • IPv4 & IPv6 (RFC 4291 / RFC 5952): Corak naif \d{1,3}(?:\.\d{1,3}){3} menerima oktet tidak sah sehingga 999. Pengesahan IPv4 yang ketat mengehadkan setiap oktet perpuluhan melalui (?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d), manakala resipi IPv6 mengambil kira pemampatan sifar :: kemunculan tunggal dan ekor yang dipetakan ke IPv4 (::ffff:192.0.2.128).
  • UUID (RFC 9562, menggantikan RFC 4122): Susun atur heks berkanun 8-4-4-4-12 iaitu ^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$ mengehadkan nibble versi (1–8, merangkumi UUIDv7 dan UUIDv8) serta bit varian IETF (8, 9, a, b), dengan kelonggaran pilihan untuk nilai sentinel Nil (00000000-...) dan Max (ffffffff-...).
  • Tarikh ISO-8601 / RFC 3339 & E-mel Praktikal: Ungkapan leksikal menguatkuasakan bulan bersempadan (0[1-9]|1[0-2]), hari (0[1-9]|[12]\d|3[01]), jam ([01]\d|2[0-3]), dan ofset zon waktu (Z|[+-](?:[01]\d|2[0-3]):[0-5]\d), sambil menyerahkan aritmetik tahun lompat kalendar (seperti menolak 30 Februari) dan pengesahan peti mel SMTP kepada logik penghurai hiliran.

Penjana Corak Regex lwn Penguji Regex: Yang Mana Satu Anda Perlukan?

Jawapan Pantas: Gunakan Penjana Corak Regex apabila membina ungkapan biasa baharu secara visual daripada blok token, menyesuaikan praset RFC yang disahkan, atau mengeksport kod dengan pelepasan yang betul untuk JavaScript, Python, Go dan Rust. Gunakan Penguji & Penyahpepijat Regex apabila memeriksa ofset padanan, kamus tangkapan dan penggantian rentetan secara langsung.

Memilih antara kedua-dua alat ini bergantung pada sama ada anda sedang mengarang ungkapan atau mendiagnosis ungkapan sedia ada. Penjana Corak Regex menumpukan pada sintesis berstruktur, penyesuaian resipi RFC dan penjanaan kod merentas bahasa. Sebaik sahaja anda mempunyai ungkapan dan perlu memeriksa setiap ofset padanan merentasi muatan berbilang baris, menogol bendera ECMAScript berkeadaan (stateful), atau melihat pratonton penggantian rentetan $<name>, buka Penguji & Penyahpepijat Regex.

Keupayaan Penjana Corak Regex Penguji & Penyahpepijat Regex
Tugas Kejuruteraan Utama Bina corak baharu secara visual atau sesuaikan resipi RFC yang disahkan Nyahpepijat corak sedia ada, ofset padanan, bendera dan penggantian
Pemasangan Corak Blok token boleh gubah (sauh, kelas, pengkuantiti, kumpulan bernama) Penyuntingan ungkapan biasa bentuk bebas secara terus
Pustaka Resipi Disahkan Praset terbina dalam untuk E-mel, IPv4/IPv6, ISO-8601, SemVer, UUID, URL, Slug, Heks Menumpukan pada corak sembarangan yang dibekalkan pengguna dan muatan log
Eksport Kod Pelbagai Bahasa Coretan sedia disalin untuk JavaScript, Python, Go dan Rust Output literal regex JavaScript / ECMAScript
Pemeriksaan Tangkapan & Ofset Pengesahan fixture positif dan negatif secara segera Rentang [start, end) setiap padanan, tangkapan $1–$99, dan kamus (?<name>...)
Pratonton Penggantian Langsung Tidak direka bentuk untuk pratonton penggantian rentetan Pratonton replace / replaceAll masa nyata ($1, $<name>, $&, $$)

Aliran Kerja yang Disyorkan

Susun ungkapan asas anda atau muatkan praset RFC di sini dalam Penjana Corak Regex untuk mendapatkan struktur pengumpulan yang kemas, sempadan pengkuantiti masa linear, dan kod templat dengan pelepasan yang betul untuk bahasa bahagian belakang (backend) atau bahagian hadapan (frontend) anda. Apabila anda perlu menguji cara corak tersebut berinteraksi dengan fail log berbilang baris, keadaan lastIndex, pasangan pengganti (surrogate pairs) Unicode, atau templat replaceAll, serahkan corak tersebut kepada Penguji & Penyahpepijat Regex.

FAQ

Soalan Lazim dan Panduan Teknikal Penjana Corak Regex

Semua yang anda perlu tahu tentang penggunaan penjana regex dalam talian percuma Utiliome.

Mengapakah sintaks regex yang dijana berbeza antara JavaScript, Python, Go dan Rust?

Walaupun kelas aksara teras dan pengkuantiti sepadan merentas bahasa, sintaks tangkapan bernama dan kekangan automata berbeza. JavaScript memerlukan (?<name>...), manakala modul re Python dan pakej regexp Go memerlukan (?P<name>...) (krait regex Rust menyokong kedua-dua bentuk). Selain itu, Go dan Rust mengompil corak ke dalam mesin keadaan Thompson NFA / DFA masa linear yang sengaja meninggalkan rujukan balik (\1) dan lookaround ((?=...), (?<=...)), manakala enjin jejak balik JavaScript dan Python menyokongnya.

Patutkah saya mengesahkan alamat e-mel dengan ungkapan biasa tatabahasa RFC 5322 penuh?

Tidak. Tatabahasa RFC 5322 literal merangkumi beberapa kilobait untuk membenarkan ruang putih berpetik yang lapuk, ulasan bersarang dan domain literal IP yang ditolak oleh penukar mel moden, tanpa membuktikan sama ada peti mel benar-benar boleh menerima mel. Perkhidmatan produksi menggandingkan corak struktur yang ringkas (^[a-zA-Z0-9.!#$%&'*+/=?^_\x60{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+$) dengan had panjang bait RFC 5321 (64 oktet bahagian tempatan, 254 oktet jumlah alamat) dan penghantaran e-mel pengesahan.

Bagaimanakah literal rentetan mentah mencegah pepijat pelepasan berganda garis condong ke belakang merentas bahasa?

Dalam rentetan berpetik standard, pengkompil hos memproses pelepasan garis condong ke belakang sebelum menghantar rentetan kepada pengkompil regex, yang memerlukan \d+\s+ digandakan menjadi "\\d+\\s+" dan menukar "\b" menjadi aksara ruang undur ASCII dan bukannya sempadan perkataan. Literal mentah asli memintas penyahlepasan garis condong ke belakang hos: gunakan literal /\d+\s+/ dalam JavaScript, r"\d+\s+" dalam Python, literal backtick dalam Go, dan r"\d+\s+" atau r#"..."# dalam Rust.

Apakah perbezaan antara pengesahan rentetan tepat dengan pengekstrakan subrentetan?

Pengesahan tepat membalut keseluruhan ungkapan dalam sauh mula dan tamat (^...$, atau \A...\z dalam Python, Go dan Rust di mana $ dalam Python re juga boleh memadan sejurus sebelum \n di hujung). Tanpa sauh, ungkapan tarikh seperti \d{4}-\d{2}-\d{2} berfungsi sebagai carian subrentetan dan berjaya pada input salah format seperti foo-2026-11-01-bar. Pastikan penyauhan tepat didayakan untuk pengesahan muatan API dan borang, atau uji rentang pengekstrakan tanpa sauh dalam Penguji & Penyahpepijat Regex.

Bagaimanakah resipi UUID RFC 9562 membezakan UUID yang sah daripada rentetan heks 36 aksara sembarangan?

RFC 9562 (menggantikan RFC 4122) mengekodkan nombor versi 4-bit pada nibble tinggi kumpulan ketiga ([1-8] untuk UUIDv1 hingga UUIDv8) dan varian IETF pada nibble tinggi kumpulan keempat ([89abAB], mewakili perduaan 10xx). Jika pangkalan data anda turut menyimpan Nil UUID semua sifar (00000000-0000-0000-0000-000000000000) atau Max UUID semua satu (ffffffff-ffff-ffff-ffff-ffffffffffff), dayakan varian heks longgar atau tambahkan cabang penyelangan eksplisit.