Regex Kapsamlı Rehber (Regular Expressions Guide)

Metin eşleştirme, doğrulama ve dönüştürme için pratik regex referans rehberi.

Ne zaman Regex kullanmalıyım?

✅ Kullan: Form validation, metin arama, find/replace, log analizi, veri çekme (scraping), input doğrulama

⚠️ Dikkat: Karmaşık regex ifadeleri bakımı zor, okunabilirliği düşük -- yorum satırları ve named group kullan

❌ Gereksiz: Tam bir HTML/XML parser yerine regex kullanmak, basit string işlemleri için (includes, startsWith yeterli)

Temel Syntax (Basic Syntax)

Literal Karakterler

Regex'te çoğu karakter kendisini temsil eder (literal match):

hello    -> "hello" metnini birebir eslestirir
abc123   -> "abc123" metnini birebir eslestirir

Metacharacter (Özel Karakterler)

Aşağıdaki karakterlerin regex'te özel anlamları vardır:

Karakter	Anlamı
.	Herhangi bir karakter (newline hariç)
^	Satır başı
$	Satır sonu
*	0 veya daha fazla tekrar
+	1 veya daha fazla tekrar
?	0 veya 1 tekrar (opsiyonel)
|	VEYA (alternation)
()	Gruplama
[]	Karakter sınıfı
{}	Tekrar sayısı belirtme
\	Kaçış karakteri

Kaçış Karakteri (Escaping)

Özel karakterleri literal olarak eşleştirebilmek için \ kullanılır:

\.       -> Gercek nokta karakteri
\*       -> Gercek yildiz karakteri
\(       -> Gercek parantez karakteri
\\       -> Gercek backslash karakteri
\$       -> Gercek dolar isareti

Örnek:

Fiyat: \$9\.99     -> "Fiyat: $9.99" metnini eşleştirir
dosya\.txt          -> "dosya.txt" metnini eşleştirir

Karakter Sınıfları (Character Classes)

Köşe Parantez ile Tanımlama

[abc]        -> a, b veya c karakterlerinden biri
[a-z]        -> Kucuk harflerden biri
[A-Z]        -> Buyuk harflerden biri
[0-9]        -> Rakamlardan biri
[a-zA-Z]     -> Herhangi bir harf
[a-zA-Z0-9]  -> Harf veya rakam
[^abc]       -> a, b, c DISINDA herhangi bir karakter
[^0-9]       -> Rakam olmayan herhangi bir karakter

Kısayol Karakter Sınıfları (Shorthand Character Classes)

Kısayol	Karşılığı	Anlamı
\d	[0-9]	Rakam (digit)
\D	[^0-9]	Rakam olmayan
\w	[a-zA-Z0-9_]	Kelime karakteri (word)
\W	[^a-zA-Z0-9_]	Kelime karakteri olmayan
\s	[ \t\n\r\f]	Boşluk karakteri (whitespace)
\S	[^ \t\n\r\f]	Boşluk olmayan
.	[^\n]	Herhangi bir karakter (newline hariç)

Örnek:

\d{3}        -> Uc ardisik rakam: "123", "456"
\w+          -> Bir veya daha fazla kelime karakteri: "hello", "user_1"
\s+          -> Bir veya daha fazla bosluk

Quantifiers (Tekrar Belirteçleri)

Temel Quantifiers

Quantifier	Anlamı	Örnek	Eşleşen
*	0 veya daha fazla	ab*c	aç, abc, abbc, abbbc
+	1 veya daha fazla	ab+c	abc, abbc, abbbc
?	0 veya 1 (opsiyonel)	colou?r	color, colour
{n}	Tam n kez	\d{4}	2024, 1999
{n,}	En az n kez	\d{2,}	10, 100, 1000
{n,m}	n ile m arasi	\d{2,4}	10, 100, 1000

Greedy vs Lazy (Açgözlü vs Tembel)

Varsayılan olarak quantifier'lar greedy (açgözlü) çalışır, mümkün olan en uzun eşlemeyi yapar:

Greedy:  <.*>   -> "<div>icerik</div>" tamamini eslestirir
Lazy:    <.*?>  -> "<div>" ve "</div>" ayri ayri eslestirir

Lazy modu için quantifier'ın sonuna ? eklenir:

Greedy	Lazy	Davranış
*	*?	Mümkün olan en az tekrar
+	+?	En az 1, sonra mümkün olan en az
?	??	Mümkünse 0 tekrar
{n,m}	{n,m}?	n'e en yakın tekrar

# Ornek: HTML tag icerigini almak
Metin: <b>kalin</b> ve <i>italik</i>

Greedy:  <.+>     -> "<b>kalin</b> ve <i>italik</i>"  (tek esleme)
Lazy:    <.+?>    -> "<b>", "</b>", "<i>", "</i>"      (dort esleme)

Anchors (Çapa Karakterleri)

Anchors bir pozisyonu belirtir, karakter tüketmez:

Anchor	Anlamı	Örnek	Eşleşen
^	Satır/metin başı	^Merhaba	Satırda "Merhaba" ile başlayan
$	Satır/metin sonu	son$	"son" ile biten satırlar
\b	Kelime sınırı (word boundary)	\bcat\b	"cat" kelimesi, "category" değil
\B	Kelime sınırı olmayan	\Bcat\B	"concatenate" içindeki "cat"

# Kelime siniri ornekleri
\bJava\b     -> "Java" eslesir, "JavaScript" eslesmez
^\d+$        -> Sadece rakamlardan olusan satir
^$           -> Bos satir
\b\w{5}\b   -> Tam 5 harfli kelimeler

Groups ve Lookaround

Capturing Groups

Parantez () ile gruplama yapılır ve eşleşen kısım yakalanır:

(\d{2})/(\d{2})/(\d{4})
-> "15/03/2024" icin:
   Grup 1: "15" (gun)
   Grup 2: "03" (ay)
   Grup 3: "2024" (yil)

Backreference ile yakalanan gruba tekrar referans verilir:

(\w+)\s+\1   -> Tekrar eden kelimeler: "the the", "is is"

Non-Capturing Groups

(?:...) ile gruplama yapılır ama yakalama yapılmaz:

(?:https?|ftp)://    -> http://, https://, ftp:// eslesir, grup yakalanmaz

Performans açısından yakalamaya ihtiyaç yoksa non-capturing tercih edilmelidir.

Named Groups (İsimli Gruplar)

(?<isim>...) veya (?P<isim>...) ile gruplara isim verilir:

(?<yil>\d{4})-(?<ay>\d{2})-(?<gun>\d{2})
-> "2024-03-15" icin:
   yil: "2024"
   ay: "03"
   gun: "15"

Lookahead (İleri Bakış)

Eşlemenin sağındaki metni kontrol eder ama tüketmez:

# Positive Lookahead: (?=...)
\d+(?= TL)        -> "100 TL" icindeki "100" (TL'den once rakam)

# Negative Lookahead: (?!...)
\d+(?! TL)        -> "100 USD" icindeki "100" (TL ile bitmeyenler)

Lookbehind (Geri Bakış)

Eşlemenin solundaki metni kontrol eder ama tüketmez:

# Positive Lookbehind: (?<=...)
(?<=\$)\d+         -> "$50" icindeki "50" (dolar isaretinden sonra)

# Negative Lookbehind: (?<!...)
(?<!\$)\d+         -> "50 adet" icindeki "50" (dolar isareti olmayanlar)

Lookaround kombinasyonu:

(?<=<b>).*?(?=</b>)   -> <b> ve </b> arasindaki icerik

Flags (Bayraklar)

Flag	İsim	Anlamı
g	Global	Tüm eşleşmeleri bul (sadece ilkini değil)
i	Case-insensitive	Büyük/küçük harf ayrımı yapma
m	Multiline	^ ve $ her satır için geçerli olur
s	Dotall / Single-line	. newline karakterini de eşleştirir
u	Unicode	Unicode karakter desteği

/hello/gi        -> "Hello", "HELLO", "hello" hepsini bulur
/^satir$/m       -> Her satirin basinda ve sonunda kontrol yapar
/a.b/s           -> "a\nb" eslesir (. newline'i da kapsar)

Not: Flag desteği dile göre değişir. Örneğin Python'da re.DOTALL, re.IGNORECASE şeklinde kullanılır.

Pratik Örnekler Tablosu (Practical Examples Table)

Yaygın Doğrulama Pattern'leri (Common Validation Patterns)

Amaç	Pattern	Açıklama
E-posta	^[\w.+-]+@[\w-]+\.[\w.]+$	Basit e-posta doğrulama
URL	https?://[\w\-.]+(:\d+)?(/[\w\-./?%&=]*)?	HTTP/HTTPS URL eşleştirme
Telefon (TR)	^(\+90|0)?[5][0-9]{9}$	Türk cep telefonu formatı
Telefon (Genel)	^\+?[\d\s\-()]{7,15}$	Uluslararası telefon
IPv4	^(\d{1,3}\.){3}\d{1,3}$	Basit IP adresi (0-999 kabul eder)
IPv4 (Kesin)	^((25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(25[0-5]|2[0-4]\d|[01]?\d\d?)$	0-255 arası kesin IP
Tarih (GG/AA/YYYY)	^(0[1-9]|[12]\d|3[01])/(0[1-9]|1[0-2])/\d{4}$	Tarih formatı
Tarih (ISO)	^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$	YYYY-MM-DD
HTML Tag	<([a-z]+)([^>]*)>(.*?)</\1>	Basit HTML tag eşleştirme
Hex Renk	^#([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$	#FFF veya #FFFFFF
Şifre (Güçlü)	^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$	Min 8 kar, büyük/küçük harf, rakam, özel karakter
TC Kimlik No	^[1-9]\d{10}$	11 haneli, 0 ile başlamaz
IBAN (TR)	^TR\d{24}$	Türk IBAN formatı
Posta Kodu (TR)	^\d{5}$	5 haneli posta kodu

Dil Bazlı Kullanım (Language-Specific Usage)

JavaScript (RegExp)

// Literal tanimlama
const regex = /\d{3}-\d{4}/g;

// Constructor tanimlama
const regex2 = new RegExp('\\d{3}-\\d{4}', 'g');

// Test (boolean)
const isValid = /^\d+$/.test('12345');  // true

// Match (eslesen degerleri dondurur)
const result = 'Fiyat: 100 TL ve 200 TL'.match(/\d+/g);
// ["100", "200"]

// Exec (detayli bilgi, gruplar dahil)
const dateRegex = /(?<gun>\d{2})\/(?<ay>\d{2})\/(?<yil>\d{4})/;
const match = dateRegex.exec('15/03/2024');
// match.groups -> { gun: "15", ay: "03", yil: "2024" }

// Replace
const clean = 'Merhaba   Dunya'.replace(/\s+/g, ' ');
// "Merhaba Dunya"

// Replace with callback
const upper = 'merhaba dunya'.replace(/\b\w/g, c => c.toUpperCase());
// "Merhaba Dunya"

// matchAll (ES2020+)
const text = 'a1 b2 c3';
for (const m of text.matchAll(/([a-z])(\d)/g)) {
  console.log(`${m[1]} -> ${m[2]}`);
}
// a -> 1, b -> 2, c -> 3

Python (re modülü)

import re

# Match (satir basindan eslestirir)
result = re.match(r'^\d{3}', '123abc')
if result:
    print(result.group())  # "123"

# Search (ilk eslemeyi bulur)
result = re.search(r'\d+', 'abc 123 def 456')
print(result.group())  # "123"

# Findall (tum eslesmeleri listeler)
result = re.findall(r'\d+', 'abc 123 def 456')
print(result)  # ["123", "456"]

# Sub (replace)
result = re.sub(r'\s+', ' ', 'Merhaba   Dunya')
print(result)  # "Merhaba Dunya"

# Named groups
pattern = r'(?P<yil>\d{4})-(?P<ay>\d{2})-(?P<gun>\d{2})'
match = re.search(pattern, '2024-03-15')
print(match.group('yil'))  # "2024"

# Compile (tekrarli kullanimda performans)
email_re = re.compile(r'^[\w.+-]+@[\w-]+\.[\w.]+$')
print(email_re.match('test@ornek.com'))  # Match objesi

# Flags
result = re.findall(r'hello', 'Hello HELLO hello', re.IGNORECASE)
print(result)  # ["Hello", "HELLO", "hello"]

# Verbose mode (okunabilir regex)
pattern = re.compile(r'''
    ^(?P<protokol>https?)://   # Protokol
    (?P<domain>[\w.-]+)        # Domain adi
    (?::(?P<port>\d+))?        # Opsiyonel port
    (?P<path>/\S*)?$           # Opsiyonel path
''', re.VERBOSE)

PHP (preg fonksiyonları)

<?php
// preg_match (ilk esleme)
if (preg_match('/\d{3}/', '123abc', $matches)) {
    echo $matches[0]; // "123"
}

// preg_match_all (tum eslesmeler)
preg_match_all('/\d+/', 'abc 123 def 456', $matches);
print_r($matches[0]); // ["123", "456"]

// preg_replace
$result = preg_replace('/\s+/', ' ', 'Merhaba   Dunya');
echo $result; // "Merhaba Dunya"

// Named groups
$pattern = '/(?P<yil>\d{4})-(?P<ay>\d{2})-(?P<gun>\d{2})/';
if (preg_match($pattern, '2024-03-15', $m)) {
    echo $m['yil']; // "2024"
}

// preg_replace_callback
$result = preg_replace_callback('/\b\w/', function($m) {
    return strtoupper($m[0]);
}, 'merhaba dunya');
echo $result; // "Merhaba Dunya"

// preg_split
$parts = preg_split('/[\s,;]+/', 'a, b; c d');
print_r($parts); // ["a", "b", "c", "d"]

C# (System.Text.RegularExpressions)

using System.Text.RegularExpressions;

// IsMatch (boolean)
bool isValid = Regex.IsMatch("12345", @"^\d+$"); // true

// Match (ilk esleme)
Match match = Regex.Match("abc 123 def", @"\d+");
Console.WriteLine(match.Value); // "123"

// Matches (tum eslesmeler)
MatchCollection matches = Regex.Matches("abc 123 def 456", @"\d+");
foreach (Match m in matches) {
    Console.WriteLine(m.Value); // "123", "456"
}

// Replace
string result = Regex.Replace("Merhaba   Dunya", @"\s+", " ");
// "Merhaba Dunya"

// Named groups
var pattern = @"(?<yil>\d{4})-(?<ay>\d{2})-(?<gun>\d{2})";
Match dateMatch = Regex.Match("2024-03-15", pattern);
Console.WriteLine(dateMatch.Groups["yil"].Value); // "2024"

// Compiled regex (performans)
var compiledRegex = new Regex(@"\d+", RegexOptions.Compiled);
var allMatches = compiledRegex.Matches("a1 b2 c3");

// Replace with MatchEvaluator
string upper = Regex.Replace("merhaba dunya", @"\b\w", m =>
    m.Value.ToUpper());
// "Merhaba Dunya"

Tips ve En İyi Pratikler (Tips & Best Practices)

regex101.com Kullanın

regex101.com regex yazmak ve test etmek için en iyi araçtır:

• Canlı eşleme gösterimi
• Grup ve match detayları
• Açıklama (explanation) paneli
• Farklı dil motorları (PCRE, JavaScript, Python, Go)
• Pattern kütüphanesi

Catastrophic Backtracking

Yanlış yazılmış regex ifadeleri üst üzel (exponential) çalışma süresine neden olabilir:

# TEHLIKELI - catastrophic backtracking
(a+)+b           -> "aaaaaaaaaaaaaac" icin cok uzun sure calisir
(a|a)+b          -> Ayni sorun
(\w+)*@          -> Uzun input'larda takilir

# GUVENLI alternatifler
a+b              -> Gereksiz icleme (nesting) kaldirildi
\w+@             -> Basitlestirilmis

Önleme yöntemleri:

• İç içe tekrar belirteçlerinden kaçının: (a+)+ yerine a+
• Possessive quantifier kullanın (destekleyen dillerde): a++
• Atomic group kullanın: (?>a+)
• Input uzunluğunu sınırlayın

Named Groups Tercih Edin

Okunabilirliği artırır ve bakım kolaylaştırır:

# Kotu: sihirli indeksler
(\d{4})-(\d{2})-(\d{2})
# match[1], match[2], match[3] -- ne oldugu belirsiz

# Iyi: isimli gruplar
(?<yil>\d{4})-(?<ay>\d{2})-(?<gun>\d{2})
# match['yil'], match['ay'], match['gun'] -- amaci acik

Yorum Satırı Kullanın

Karmaşık regex ifadelerinde verbose/comment modu kullanın:

# Python re.VERBOSE ornegi
pattern = re.compile(r'''
    ^                     # Satir basi
    (?P<protokol>https?)  # http veya https
    ://                   # Ayirici
    (?P<domain>[\w.-]+)   # Domain adi
    (?::(?P<port>\d+))?   # Opsiyonel port
    (?P<path>/\S*)?       # Opsiyonel path
    $                     # Satir sonu
''', re.VERBOSE)

Genel Tavsiyeler (General Tips)

• Basit tutun: mümkünse birkaç küçük regex kullanın, tek dev regex yerine
• Önce test edin: regex101.com ile farklı input'larda test edin
• Edge case'leri düşünün: boş string, çok uzun input, özel karakterler
• Performansı ölçün: büyük metin dosyalarında benchmark yapın
• Alternatifleri değerlendirin: bazen split, includes, startsWith yeterlidir

İlgili Rehberler (Related Guides)

DevOps & Tools

• DevOps Genel Bakış
• Git Notları
• Docker Rehberi
• Kubernetes
• Nginx Rehberi
• Linux CLI
• Deployment & Hosting
• Ubuntu Rehberi
• VS Code Rehberi

Diğer Kategoriler (Other Categories)

• Backend Genel Bakış
• Frontend Genel Bakış
• Veritabanı Genel Bakış
• Teknoloji Genel Bakış