Regex Desen Oluşturucu

Token blokları ve doğrulanmış geliştirici şablonlarıyla görsel olarak düzenli ifadeler oluşturun.

Yükleme yokKayıt gerekmezAnında sonuç
13 Doğrulanmış RFC ve Geliştirici ŞablonuGörsel Kural ve Niceleyici OluşturucuJS · Python · Go · Rust Kod Parçacıkları
Regex Oluştur
Çevrimdışı motor hazır%100 gizli tarayıcı içi çalışma alanı • Sıfır bulut yüklemesi
%100 Gizli • Sıfır Sunucu Dosya Yüklemesi

Neden Ücretsiz Utiliome Regex Desen Oluşturucu Kullanmalısınız?

Kesin gizlilik, anında işlem ve sıfır engelleme için sıfırdan tasarlandı. Abonelik, ödeme duvarı veya üyelik gerekmez.

Birleştirilebilir Görsel Token Blokları

Çapaları (anchors), karakter sınıflarını, sınırlı nicelik belirleyicileri (quantifiers), yakalamayan grupları ((?:...)) ve adlandırılmış yakalama gruplarını ((?<name>...)) adım adım zincirleyerek okunabilir düzenli ifadeler oluşturun.

RFC Uyumlu Geliştirici Şablonları

Pratik RFC 5322 e-posta adresleri, sınırlandırılmış IPv4/IPv6 adresleri, ISO-8601 / RFC 3339 zaman damgaları, SemVer 2.0.0 etiketleri, RFC 9562 UUID'leri, URL'ler, URL slug'ları ve CSS hex renk kodları için doğrulanmış hazır şablonları yükleyin.

Çok Dilli Kod Parçacıkları

Adlandırılmış grup sözdizimini otomatik olarak uyarlayarak JavaScript (RegExp), Python (re.compile ham dizeleri), Go (regexp.MustCompile ham değişmezleri) ve Rust (regex::Regex) için derlemeye hazır kodları dışa aktarın.

Anında Test Verisi Doğrulaması ve Gizlilik

Blokları düzenlerken pozitif ve negatif örnek dizeleri canlı olarak doğrulayın. Her şablon özelleştirmesi, doğrulama adımı ve kod dışa aktarımı sıfır ağ isteğiyle %100 istemci tarafında çalışır.

Utiliome ve Geleneksel Bulut Alternatifleri

Yerel WebAssembly motorumuzu eski bulut araçlarıyla karşılaştırın.

Özellik Utiliome (Yerel Tarayıcı) Eski Bulut Dönüştürücüler
Birleştirilebilir Görsel Token Blokları Çapaları (anchors), karakter sınıflarını, sınırlı nicelik belirleyicileri (quantifiers), yakalamayan grupları ((?:...)) ve adlandırılmış yakalama gruplarını ((?<name>...)) adım adım zincirleyerek okunabilir düzenli ifadeler oluşturun. Gelişmiş özelleştirme olmadan sınırlı seçenekler
RFC Uyumlu Geliştirici Şablonları Pratik RFC 5322 e-posta adresleri, sınırlandırılmış IPv4/IPv6 adresleri, ISO-8601 / RFC 3339 zaman damgaları, SemVer 2.0.0 etiketleri, RFC 9562 UUID'leri, URL'ler, URL slug'ları ve CSS hex renk kodları için doğrulanmış hazır şablonları yükleyin. Harici araçlar veya manuel işlem gerektirir
Gizlilik ve Veri İşleme %100 tarayıcı içi yerel işleme (sunucuya yükleme yok) Verileri üçüncü taraf bulut sunucularına yükler
Fiyatlandırma ve Hesap Şartı Kayıt olmadan sonsuza dek %100 ücretsiz Hesap kaydı veya ücretli abonelik zorunluluğu
Nasıl çalışır

Regex Desen Oluşturucu: 3 Kolay Adımda Kullanım

Yazılım kurulumu gerekmez. Her şey doğrudan web tarayıcınızın içinde çalışır.

1

Doğrulanmış Bir Şablon Seçin veya Token Blokları Ekleyin

RFC testlerinden geçmiş hazır bir şablon (e-posta, IPv4/IPv6, ISO-8601 tarihi, SemVer, UUID, URL, slug veya hex renk kodu) seçin ya da görsel olarak çapalar, karakter kümeleri, sabit metinler ve nicelik belirleyiciler ekleyin.

2

Çapaları, Grupları ve Örnek Dizeleri Yapılandırın

Tam dize doğrulaması (^...$) ile alt dize eşleştirme arasında geçiş yapın, adlandırılmış ((?<name>...)) veya yakalamayan ((?:...)) sarmalayıcılar atayın ve pozitif ile negatif doğrulama örneklerini kontrol edin.

3

Ham Regex İfadesini veya Çok Dilli Kodu Kopyalayın

Ham deseni dışa aktarın ya da ham dize (raw string) kaçış karakterleri ve motora özgü yakalama sözdizimi uygulanmış idiomatik JavaScript, Python, Go veya Rust kod parçacıklarını kopyalayın.

Görsel Token Bloklarından Çok Dilli Koda Üretim Düzeyinde Desen Oluşturma

Hızlı Cevap: Çapalanmış token bloklarını sırayla zincirleyin, adlandırılmış yakalama grupları ((?<name>...)) aracılığıyla anlamsal alan adları atayın, pozitif ve negatif uç durum verileriyle doğrulama yapın ve JavaScript, Python, Go ile Rust'a uyarlanmış idiomatik ham dize kod parçacıklarını dışa aktarın.

Karmaşık düzenli ifadeleri ezberden elle yazmak; kaçış karakteri eklenmemiş noktalar (sabit . yerine herhangi bir karakterle eşleşen .), unutulmuş başlangıç/bitiş çapaları veya baştaki sıfır hataları gibi fark edilmesi güç kusurlara sıkça yol açar. Görsel token birleştirme yaklaşımıyla, isteğe bağlı bir v önekini kabul eden ve major, minor, patch, prerelease ile build üstveri tanımlayıcılarını ayıklayan katı bir Semantic Versioning 2.0.0 (SemVer) doğrulayıcısına ihtiyacınız olduğunu varsayalım.

Her yapısal kural, açık bir token blokları dizisiyle doğrudan eşleşir:

{
  "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 (?)"
    }
  ]
}

0|[1-9]\d* ifadesinin tek başına 0 değerine izin verirken 01 gibi baştaki sıfırları reddederek SemVer 2.0.0 Bölüm 2 kurallarını nasıl uyguladığına ve yakalamayan (?:...)? sarmalayıcılarının fazladan numaralandırılmış gruplar oluşturmadan - ile + ayırıcılarını nasıl koruduğuna dikkat edin. Pozitif ve negatif örnek verilerle doğrulama yapıp çok dilli kodu dışa aktardığınızda, her regex motoruna uygun bildirimler otomatik olarak üretilir:

# Sentezlenen ECMAScript / Rust Deseni
^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-]+)*))?$

# Pozitif Örnekler (Eşleşir)
1.0.0
v2.14.3-rc.1+build.5114f85

# Negatif Örnekler (Reddedilir: sayısal sürüm çekirdeğinde baştaki sıfır)
v01.2.0
1.02.3

# Python (re.compile ham dize + (?P<name>...) adlandırılmış grup sözdizimi)
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 (RE2 regexp.MustCompile ters tırnaklı ham değişmez + (?P<name>...) sözdizimi)
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-]+)*))?$`)

Oluşturucu, standart şablonlarda geriye dönük referanslardan (backreferences) ve ileriye/geriye bakış ifadelerinden (lookarounds) kaçındığı için, dışa aktarılan desen hem doğrusal zamanlı RE2 çalışma zamanlarında (Go ve Rust) hem de geri izlemeli (backtracking) motorlarda (JavaScript ve Python) değişiklik gerektirmeden derlenir.

Diller Arası Regex Motoru Taşınabilirliği, RFC Doğrulama İncelikleri ve Kaçış Kuralları

Hızlı Cevap: Düzenli ifade çalışma zamanları, geri izlemeli NFA'lar (JavaScript RegExp, Python re) ve doğrusal zamanlı Thompson NFA / DFA motorları (Go regexp, Rust regex) olarak ikiye ayrılır. Taşınabilir desenler lookaround ve backreference yapılarından kaçınır, yerel ham dize değişmezlerini kullanır ve kesin RFC oktet ile nibble sınırlarını uygular.

Geri İzlemeli NFA'lar ve Doğrusal Zamanlı Otomatlar (Go RE2 ve Rust `regex`)

Üretim ortamlarında kullanılan düzenli ifade motorları iki farklı yürütme modeline ayrılır:

  1. Geri İzlemeli NFA (JavaScript RegExp, Python re): Alternatif dalları özyinelemeli olarak araştırır; geriye dönük referanslara (\1, \k<name>) ve isteğe bağlı ileriye/geriye bakış doğrulamalarına ((?=...), (?!...), (?<=...), (?<!...)) olanak tanır ancak belirsiz desenlerde en kötü durumda üstel çalışma süresine (ReDoS) yol açabilir.
  2. Thompson NFA / Tembel DFA (Go regexp, Rust regex): Her girdi baytı veya kod noktası için tüm etkin otomat durumlarını eşzamanlı olarak ilerleterek m desen boyutu ve n girdi uzunluğu üzerinden en kötü durumda O(m * n) zaman karmaşıklığını garanti eder. Sonlu durum sınırlarını korumak amacıyla Go regexp ve Rust regex, tasarım gereği geriye dönük referansları ve lookaround ifadelerini dışarıda bırakır.

Adlandırılmış yakalama grubu sözdizimi de standart kütüphaneye göre farklılık gösterir: ECMAScript (?<name>...) gerektirir; Python re ve Go regexp (?P<name>...) yapısını zorunlu kılar; Rust regex (1.9+) ise hem (?<name>...) hem de (?P<name>...) biçimlerini kabul eder.

Hedef Dilde Ham Dize (Raw String) Kaçış Karakterleri

Bir deseni sıradan çift tırnaklı bir dize içine gömmek, ana derleyicinin ters eğik çizgi kaçışlarını önceden yorumlamasına neden olur; bu durum \d+\.\d+ ifadesinin "\\d+\\.\\d+" şeklinde iki kez yazılmasını zorunlu kılar ve sessiz veri bozulmalarına (örneğin "\b" ifadesinin kelime sınırı yerine ASCII 0x08 geri silme karakterine dönüşmesine) yol açma riski taşır. Dışa aktarılan kod parçacıkları her dilin yerel ham dize (raw literal) biçimini kullanır:

  • JavaScript: /pattern/flags değişmez gösterimi (yalnızca kaçışsız ileri eğik çizgileri \/ olarak kaçırarak) veya dinamik oluşturma için new RegExp(String.raw..., flags).
  • Python: re.compile(r"...") ham dize değişmezleri (bir Python ham dizesinin tek sayıda ters eğik çizgiyle bitemeyeceğini unutmayın).
  • Go: Ters tırnaklı (backtick) ham değişmezlerle regexp.MustCompile; desenin kendisinde sabit bir ters tırnak eşleştirilmesi gerekiyorsa yerine \x60 kullanılır.
  • Rust: regex::Regex::new(r"...") veya desenin kendisi çift tırnak içerdiğinde r#"..."# diyezli ham değişmezleri.

Geliştirici Şablonlarında RFC Hassasiyet Sınırları

  • IPv4 ve IPv6 (RFC 4291 / RFC 5952): Basit bir \d{1,3}(?:\.\d{1,3}){3} ifadesi 999 değerine kadar geçersiz oktetleri kabul eder. Katı IPv4 doğrulaması her ondalık okteti (?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d) ile sınırlarken, IPv6 şablonları tek seferlik :: sıfır sıkıştırmasını ve IPv4 eşlemeli sonekleri (::ffff:192.0.2.128) hesaba katar.
  • UUID'ler (RFC 4122'nin yerini alan RFC 9562): Kanonik 8-4-4-4-12 onaltılık düzeni ^[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}$, sürüm nibble değerini (UUIDv7 ve UUIDv8'i kapsayacak şekilde 1–8) ve IETF varyant bitlerini (8, 9, a, b) kısıtlar; ayrıca Nil (00000000-...) ve Max (ffffffff-...) özel değerleri için isteğe bağlı esnetme sunar.
  • ISO-8601 / RFC 3339 Tarihleri ve Pratik E-postalar: Sözcüksel ifadeler sınırlandırılmış ayları (0[1-9]|1[0-2]), günleri (0[1-9]|[12]\d|3[01]), saatleri ([01]\d|2[0-3]) ve saat dilimi farklarını (Z|[+-](?:[01]\d|2[0-3]):[0-5]\d) zorunlu kılar; takvim artık yıl aritmetiğini (30 Şubat'ın reddedilmesi gibi) ve SMTP posta kutusu doğrulamasını ise sonraki ayrıştırıcı katmanına bırakır.

Regex Desen Oluşturucu ve Regex Test Aracı: Hangisine İhtiyacınız Var?

Hızlı Cevap: Token bloklarından görsel olarak yeni bir düzenli ifade oluştururken, doğrulanmış bir RFC şablonunu özelleştirirken veya JavaScript, Python, Go ve Rust için kaçış karakterleri uygulanmış kod dışa aktarırken Regex Desen Oluşturucu'yu kullanın. Eşleşme konumlarını (offset), yakalama sözlüklerini ve canlı metin değiştirmelerini incelerken Regex Test ve Hata Ayıklayıcı'yı tercih edin.

İki araç arasındaki seçim, bir ifadeyi inşa mı ettiğinize yoksa mevcut bir ifadeyi analiz mi ettiğinize bağlıdır. Regex Desen Oluşturucu yapılandırılmış senteze, RFC şablonu özelleştirmesine ve diller arası kod üretimine odaklanır. Elinizde hazır bir ifade olduğunda ve çok satırlı bir veri yükündeki her eşleşme konumunu incelemeniz, durum bilgili ECMAScript bayraklarını değiştirmeniz veya $<name> dize değiştirmelerini önizlemeniz gerektiğinde Regex Test ve Hata Ayıklayıcı aracını açın.

Özellik Regex Desen Oluşturucu Regex Test ve Hata Ayıklayıcı
Birincil Mühendislik Görevi Görsel olarak yeni desenler oluşturmak veya doğrulanmış RFC şablonlarını özelleştirmek Mevcut desenlerde hata ayıklamak, eşleşme konumlarını, bayrakları ve değiştirmeleri incelemek
Desen Oluşturma Birleştirilebilir token blokları (çapalar, sınıflar, nicelik belirleyiciler, adlandırılmış gruplar) Doğrudan serbest biçimli düzenli ifade düzenleme
Doğrulanmış Şablon Kütüphanesi E-posta, IPv4/IPv6, ISO-8601, SemVer, UUID, URL, Slug ve Hex için yerleşik şablonlar Kullanıcının sağladığı özel desenlere ve günlük (log) verilerine odaklı
Çok Dilli Kod Dışa Aktarımı JavaScript, Python, Go ve Rust için kopyalamaya hazır kod parçacıkları JavaScript / ECMAScript regex değişmezi (literal) çıktısı
Yakalama ve Konum İncelemesi Anında pozitif ve negatif örnek veri doğrulaması Eşleşme başına [start, end) aralıkları, $1–$99 yakalamaları ve (?<name>...) sözlüğü
Canlı Değiştirme Önizlemesi Dize değiştirme önizlemeleri için tasarlanmamıştır Gerçek zamanlı replace / replaceAll önizlemesi ($1, $<name>, $&, $$)

Önerilen İş Akışı

Temiz bir gruplama yapısı, doğrusal zamanlı nicelik belirleyici sınırları ve arka uç veya ön uç diliniz için doğru kaçış karakterleriyle hazırlanmış şablon kodu elde etmek üzere temel ifadenizi burada, Regex Desen Oluşturucu içinde birleştirin veya bir RFC şablonu yükleyin. Bu desenin çok satırlı günlük dosyalarıyla, lastIndex durumuyla, Unicode vekil çiftleriyle (surrogate pairs) veya replaceAll şablonlarıyla nasıl etkileşime girdiğini test etmeniz gerektiğinde deseni Regex Test ve Hata Ayıklayıcı aracına aktarın.

SSS

Regex Desen Oluşturucu SSS ve Teknik Rehber

Utiliome'un ücretsiz çevrimiçi regex oluşturucu aracı hakkında bilmeniz gereken her şey.

Üretilen regex sözdizimi neden JavaScript, Python, Go ve Rust arasında farklılık gösteriyor?

Temel karakter sınıfları ve nicelik belirleyiciler diller arasında aynı kalsa da adlandırılmış yakalama grubu sözdizimi ve otomat kısıtlamaları farklılaşır. JavaScript (?<name>...) yapısını gerektirirken, Python'un re modülü ve Go'nun regexp paketi (?P<name>...) sözdizimini zorunlu kılar (Rust'ın regex paketi her iki biçimi de destekler). Ek olarak Go ve Rust, desenleri geriye dönük referansları (\1) ve lookaround ifadelerini ((?=...), (?<=...)) bilinçli olarak hariç tutan doğrusal zamanlı Thompson NFA / DFA durum makinelerine derler; buna karşın JavaScript ve Python geri izlemeli motorları bu yapıları destekler.

E-posta adreslerini tam bir RFC 5322 dilbilgisi düzenli ifadesiyle mi doğrulamalıyım?

Hayır. Birebir RFC 5322 dilbilgisi, modern posta sunucularının reddettiği eski tırnak içi boşluklara, iç içe geçmiş yorumlara ve IP tabanlı alan adlarına izin vermek için birkaç kilobayt uzunluğuna ulaşır; üstelik bir posta kutusunun gerçekten e-posta alıp alamayacağını da kanıtlamaz. Üretim sistemleri, özlü bir yapısal deseni (^[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])?)+$), RFC 5321 bayt uzunluğu sınırlarıyla (64 oktet yerel kısım, toplam 254 oktet adres) ve doğrulama e-postası gönderimiyle birleştirir.

Ham dize değişmezleri (raw string literals) diller arasında çift ters eğik çizgi kaçış hatalarını nasıl önler?

Standart tırnaklı dizelerde ana derleyici, dizeyi regex derleyicisine iletmeden önce ters eğik çizgi kaçışlarını işler; bu da \d+\s+ ifadesinin "\\d+\\s+" olarak iki katına çıkarılmasını gerektirir ve "\b" ifadesini bir kelime sınırı yerine ASCII geri silme (backspace) karakterine dönüştürür. Yerel ham değişmezler, ana dilin ters eğik çizgi çözümlemesini devre dışı bırakır: JavaScript'te /\d+\s+/ değişmezlerini, Python'da r"\d+\s+" yapısını, Go'da ters tırnaklı (backtick) değişmezleri ve Rust'ta r"\d+\s+" veya r#"..."# biçimlerini kullanın.

Tam dize doğrulaması ile alt dize ayıklama arasındaki fark nedir?

Tam doğrulama, tüm ifadeyi başlangıç ve bitiş çapalarıyla (^...$ veya Python re içinde $ karakterinin sondaki \n öncesinde de eşleşebildiği durumlar için Python, Go ve Rust'ta \A...\z) sarar. Çapalar olmadan, \d{4}-\d{2}-\d{2} gibi bir tarih ifadesi alt dize araması gibi davranır ve foo-2026-11-01-bar gibi hatalı girdilerde başarılı sonuç döndürür. API yükü ve form doğrulaması için tam çapalamayı açık tutun veya çapasız ayıklama aralıklarını Regex Test ve Hata Ayıklayıcı içinde inceleyin.

RFC 9562 UUID şablonu, geçerli UUID'leri rastgele 36 karakterlik onaltılık dizelerden nasıl ayırt eder?

RFC 9562 (RFC 4122'nin yerini alan standart), 4 bitlik sürüm numarasını üçüncü grubun yüksek nibble değerinde (UUIDv1'den UUIDv8'e kadar [1-8]) ve IETF varyantını dördüncü grubun yüksek nibble değerinde (ikili 10xx değerini temsil eden [89abAB]) kodlar. Veritabanınız tamamı sıfırlardan oluşan Nil UUID (00000000-0000-0000-0000-000000000000) veya tamamı f karakterlerinden oluşan Max UUID (ffffffff-ffff-ffff-ffff-ffffffffffff) değerlerini de barındırıyorsa, esnetilmiş onaltılık varyantı etkinleştirin veya açık alternatif dallar ekleyin.