Çerezler
Bu web sitesi sizlere daha iyi hizmet verebilmek için çerezleri kullanır.
Bu, sayfanın ana içeriğidir. Geniş ekranlarda bile belirli bir genişliği aşmayarak okunabilirliği artırır.
... diğer içerikler ...
Hepimizin hayatında en az bir kere duyduğu, belki de kendi kendine sorduğu bir soru var: "Ben matematikte doğuştan kötüyüm, değil mi?" Bu cümle, genellikle matematiğe karşı hissedilen bir çaresizliğin, bir kabullenişin ifadesidir. Ancak bir SEO yazarı ve gazeteci olarak, bu konuda edindiğim bilgilerle size bambaşka bir pencere açmak istiyorum. Gerçekten de bazı insanlar matematikte doğuştan mı başarısızdır, yoksa bu sadece yaygın bir yanılsama mı?
Gelin, bu konuyu bilimsel veriler, uzman görüşleri ve psikolojinin ışığında derinlemesine inceleyelim. Çünkü matematik, sandığımızdan çok daha esnek, öğrenilebilir ve herkesin erişebileceği bir alandır.
Toplumda sıkça karşılaştığımız bir inanç vardır: Bazı insanların "matematik beyni" ile doğduğu, bazılarının ise bu yetenekten yoksun olduğu. Bu durum, genellikle çocukluktan itibaren "sayısalcı" veya "sözelci" gibi etiketlemelerle pekiştirilir. Ancak modern bilim, bu katı ayrımın pek de doğru olmadığını gösteriyor. Beynimiz, düşündüğümüzden çok daha esnektir ve hayat boyu öğrenmeye açıktır.
Araştırmalar, matematiğin sadece sol beynin işi olmadığını, aslında beynin birçok farklı bölgesinin etkileşim içinde çalıştığını ortaya koyuyor. Mantık, problem çözme, uzamsal düşünme, hatta yaratıcılık bile matematiksel süreçlerde rol oynar. Yani, "matematik beyni" diye tekil bir yapıdan bahsetmek yerine, matematiksel düşünmenin karmaşık ve çok yönlü bir beceri olduğunu anlamak daha doğru olacaktır.
Stanford Üniversitesi'nden psikolog Carol Dweck'in çalışmaları, "zihin yapısı" kavramının öğrenme üzerindeki etkisini çarpıcı bir şekilde ortaya koymuştur. Dweck, iki ana zihin yapısından bahseder:
Sabit Zihin Yapısı (Fixed Mindset): Bireylerin yeteneklerinin doğuştan geldiğine ve değiştirilemez olduğuna inandığı durumdur. "Matematikte kötüyüm, çünkü bu benim kaderim" düşüncesi bu kategoriye girer. Bu inanca sahip kişiler, zorluklarla karşılaştıklarında kolayca pes etme eğilimindedirler.
Büyüme Zihin Yapısı (Growth Mindset): Bireylerin yeteneklerinin çaba, pratik ve doğru stratejilerle geliştirilebileceğine inandığı durumdur. "Matematikte şu an zorlanıyorum, ama daha çok çalışarak ve farklı yöntemler deneyerek öğrenebilirim" düşüncesi bu zihin yapısının temelidir. Bu kişiler, hataları öğrenme fırsatı olarak görür ve azimle yola devam ederler.
Matematikteki başarısızlığın büyük bir kısmı, aslında sabit zihin yapısının bir sonucudur. Eğer kendimize "yapamam" dersek, beynimiz de bu inancı pekiştirir ve gerçekten yapamayız. Oysa büyüme zihin yapısını benimsemek, matematiksel potansiyelimizi ortaya çıkarmanın ilk ve en önemli adımıdır.
Matematik öğrenme deneyimimiz, büyük ölçüde bize nasıl öğretildiğiyle de şekillenir. Geleneksel ezbere dayalı, formül odaklı öğretim yöntemleri, birçok öğrencinin matematiğin soyut dünyasında kaybolmasına neden olabilir. Oysa modern eğitim yaklaşımları, matematiği daha somut, anlamlı ve etkileşimli hale getirmeyi hedefler.
Öğretmenlerin sabrı, konuyu farklı açılardan açıklama yeteneği ve öğrencilerin bireysel öğrenme stillerine dikkat etmesi, matematik başarısı üzerinde kritik bir etkiye sahiptir. Bazı öğrenciler görsel öğrenirken, bazıları işitsel, bazıları ise yaparak-yaşayarak öğrenir. Tek tip bir öğretim metodunun herkes için geçerli olmadığını anlamak, matematik eğitiminde devrim niteliğinde bir adımdır.
Matematik kaygısı, birçok insanın matematiksel görevler karşısında hissettiği gerginlik, endişe ve korku durumudur. Bu kaygı, sınav anında zihnin donmasına, basit hatalar yapmaya ve hatta matematiksel kavramları anlama yeteneğinin körelmesine neden olabilir. Matematik kaygısı, genellikle geçmişteki olumsuz deneyimler, öğretmenin veya ebeveynlerin olumsuz yaklaşımları veya toplumsal baskılar sonucunda ortaya çıkar.
İlginçtir ki, matematik kaygısı yaşayan bireylerin çoğu, aslında matematiksel yetenekten yoksun değildir. Aksine, zeki ve potansiyeli yüksek öğrencilerde bile görülebilir. Kaygı, bilişsel kaynakları tüketerek problem çözme becerisini engeller. Bu durum, "matematikte kötüyüm" algısını pekiştiren bir kısır döngü yaratır.
Ebeveynlerin veya çevrenin matematiğe karşı tutumu, çocukların matematiğe bakış açısını derinden etkiler. "Ben de matematikte iyi değildim zaten" gibi ifadeler, farkında olmadan çocuklara matematiğin zor ve başa çıkılamaz bir ders olduğu mesajını verir. Bu tür olumsuz mesajlar, çocukların matematiğe karşı önyargılı yaklaşmasına ve daha başlamadan pes etmesine neden olabilir.
Araştırmalar, ebeveynlerin çocuklarının matematik ödevlerine yardımcı olurken gösterdikleri kaygının bile çocuklara geçebileceğini gösteriyor. Destekleyici, olumlu ve sabırlı bir çevre, matematik öğreniminde mucizeler yaratabilir.
Yukarıda bahsettiğimiz tüm faktörler, matematiksel başarısızlığın büyük bir kısmını açıklasa da, çok nadir de olsa gerçek bir öğrenme güçlüğü olan "diskalkuli"den bahsetmek gerekir. Diskaluli, matematiksel kavramları anlama, sayıları işleme ve aritmetik işlemleri yapmada ciddi ve kalıcı zorluklarla karakterize edilen nörolojik bir durumdur.
Diskaluli tanısı konmuş bireyler, temel sayı hissi (number sense) ve matematiksel muhakeme yeteneğinde belirgin eksiklikler yaşarlar. Ancak unutulmamalıdır ki, diskalkuli matematiksel zorluk yaşayan nüfusun çok küçük bir yüzdesini oluşturur. Matematikte zorlanan çoğu kişi, diskalkuli değil, yukarıda saydığımız öğrenme, zihin yapısı veya kaygı temelli sorunlar yaşamaktadır. Doğru destek ve stratejilerle bu zorlukların üstesinden gelmek mümkündür.
Matematik de bir dil öğrenmek veya bir enstrüman çalmak gibidir. Düzenli pratik, tekrar ve sabır gerektirir. İlk başta zor gelen kavramlar, üzerine gidildikçe, farklı örneklerle tekrarlandıkça zihnimizde yer edinir ve kalıcı hale gelir.
Beynimizdeki sinir ağları, yeni bilgiler öğrendikçe güçlenir ve yeni bağlantılar kurar. Bu duruma nöroplastisite denir. Yani, matematiksel beceriler, tıpkı bir kas gibi, kullanıldıkça ve zorlandıkça gelişir. Yanlış yapmak, öğrenme sürecinin doğal bir parçasıdır. Önemli olan, yanlışlardan ders çıkarıp denemeye devam etmektir.
Eğer siz de kendinizi "matematikte kötüyüm" diyenlerden biri olarak görüyorsanız, umutsuzluğa kapılmayın. İşte size birkaç öneri:
Zihin Yapınızı Değiştirin: Sabit zihin yapısından büyüme zihin yapısına geçmeye çalışın. "Yapamam" yerine "Henüz yapamıyorum, ama öğrenebilirim" deyin.
Küçük Adımlarla Başlayın: Kendinizi bunaltacak büyük hedefler koymak yerine, temel kavramları anlamaya odaklanın. Küçük başarılar, motivasyonunuzu artıracaktır.
Yardım Almaktan Çekinmeyin: Anlamadığınız bir konu olduğunda öğretmenlerinizden, arkadaşlarınızdan veya özel ders verenlerden yardım isteyin. Utanmak yerine, meraklı olun.
Farklı Kaynakları Deneyin: Sadece ders kitabıyla sınırlı kalmayın. İnternetteki eğitim videoları, interaktif uygulamalar veya farklı anlatım tarzına sahip kitaplar size yeni kapılar açabilir.
Matematikle Aranızdaki Kaygıyı Azaltın: Meditasyon, derin nefes alma egzersizleri gibi tekniklerle sınav kaygınızı yönetmeyi öğrenin. Başarıya giden yolda sakin bir zihin şarttır.
Pratik Yapın, Tekrar Edin: Düzenli olarak problem çözün. Başarısız olsanız bile, bu bir öğrenme fırsatıdır. Yanlışlarınızdan ders çıkarın.
Matematiğin Günlük Hayattaki Yerini Görün: Matematik sadece formüllerden ibaret değildir. Mutfakta, alışverişte, spor yaparken veya oyun oynarken bile matematikle iç içeyiz. Bu bağlantıları görmek, matematiği daha anlamlı hale getirecektir.
Sonuç olarak, "matematikte doğuştan kötü olmak" kavramı, modern bilimin ve psikolojinin ışığında geçerliliğini büyük ölçüde yitirmiştir. Yeteneklerimiz sabit değildir; zihin yapımız, aldığımız eğitim, yaşadığımız kaygılar ve çevremizin etkisiyle şekillenir. Matematik, tıpkı diğer tüm beceriler gibi, çaba, doğru stratejiler ve inançla geliştirilebilir bir alandır. Kendinize bu şansı verin ve matematiğin büyülü dünyasını yeniden keşfedin!
JavaScript'te Setler, benzersiz değerlerden oluşan bir koleksiyonu depolamak için kullanılan özel bir nesne türüdür.
Bu veri yapısı, tekrar eden öğelerin otomatik olarak elenmesini sağlayarak veri yönetimi ve manipülasyonunda önemli avantajlar sunar.
Bu makale, JavaScript Setlerinin temel kullanımını, sözdizimini ve pratik uygulamalarını detaylı bir şekilde açıklayacaktır.
Bir Set oluşturmak için new Set() kurucusu kullanılır.
Değerler, Set'in kurucusuna bir iterable (örneğin bir dizi) olarak geçirilebilir veya daha sonra add() metodu ile eklenebilir.
// Boş bir Set oluşturma
const mySet = new Set();
// Başlangıç değerleri ile Set oluşturma
const initialSet = new Set([1, 2, 3, 2, 4]); // initialSet: {1, 2, 3, 4}
// Metotlar
mySet.add(value); // Bir değer ekler
mySet.delete(value); // Bir değeri siler
mySet.has(value); // Bir değerin varlığını kontrol eder
mySet.clear(); // Set'teki tüm öğeleri siler
mySet.size; // Set'teki öğe sayısını döndürürnew Set([iterable]): Yeni bir Set nesnesi oluşturur. İsteğe bağlı olarak, iterable bir nesne (örneğin bir dizi) alabilir. Bu iterable içindeki tüm öğeler Set'e eklenir. Tekrar eden değerler otomatik olarak göz ardı edilir.
Set.prototype.add(value): Set'e yeni bir değer ekler. Eğer değer zaten Set'te mevcutsa, Set değişmez. Zincirleme çağrılara izin vermek için Set nesnesini döndürür.
Set.prototype.delete(value): Set'ten belirli bir değeri siler. Eğer değer Set'te mevcutsa true, aksi takdirde false döndürür.
Set.prototype.has(value): Belirli bir değerin Set'te olup olmadığını kontrol eder. Varsa true, yoksa false döndürür.
Set.prototype.clear(): Set'teki tüm öğeleri siler ve Set'i boşaltır.
Set.prototype.size: Set'teki benzersiz öğelerin sayısını döndüren bir erişimci özelliğidir.
Set.prototype.forEach(callbackFn[, thisArg]): Set'teki her öğe için bir callback fonksiyonu yürütür. Dizilerdeki forEach metoduna benzer.
Set.prototype.values(), Set.prototype.keys(), Set.prototype.entries(): Set'teki değerleri, anahtarları (Set'lerde anahtarlar ve değerler aynıdır) veya anahtar/değer çiftlerini ([value, value] formatında) içeren yeni bir Iterator nesnesi döndürür.
Aşağıdaki örnekler, JavaScript Setlerinin çeşitli kullanım senaryolarını göstermektedir.
Bir dizideki yinelenen öğeleri kaldırmak ve yalnızca benzersiz değerleri elde etmek için Setleri kullanmak oldukça etkilidir.
const numbers = [1, 2, 3, 4, 2, 1, 5, 6, 3];
const uniqueNumbers = new Set(numbers);
console.log(uniqueNumbers); // Set(6) {1, 2, 3, 4, 5, 6}
// Set'i tekrar bir diziye dönüştürme
const uniqueNumbersArray = [...uniqueNumbers];
console.log(uniqueNumbersArray); // [1, 2, 3, 4, 5, 6]Bir öğenin bir koleksiyonda olup olmadığını hızlıca kontrol etmek için has() metodunu kullanabilirsiniz.
const fruits = new Set(['elma', 'armut', 'muz']);
console.log(fruits.has('elma')); // true
console.log(fruits.has('çilek')); // false
fruits.add('çilek');
console.log(fruits.has('çilek')); // trueSet öğeleri üzerinde döngü yapmak için forEach() metodunu veya for...of döngüsünü kullanabilirsiniz.
const colors = new Set(['kırmızı', 'mavi', 'yeşil']);
// forEach ile iterasyon
colors.forEach(color => {
console.log(color);
});
// Çıktı:
// kırmızı
// mavi
// yeşil
// for...of ile iterasyon
for (const color of colors) {
console.log(color);
}
// Çıktı:
// kırmızı
// mavi
// yeşilDeğer Karşılaştırması: Setler, değerleri karşılaştırırken aynı algoritmayı kullanır. Bu, NaN değerlerinin Set içinde benzersiz olarak ele alındığı anlamına gelir (NaN === NaN false olmasına rağmen, Set içinde sadece bir adet NaN bulunabilir). Obje referansları için, farklı referanslara sahip aynı içeriğe sahip objeler farklı kabul edilir.
Sırasız Yapı: Setler, öğeleri eklenme sırasına göre depolasa da, Setin birincil amacı benzersiz öğeleri tutmaktır, belirli bir sırayı garanti etmek değildir. Bazı durumlarda iterasyon sırası ekleme sırasına denk gelebilir, ancak buna güvenilmemelidir.
Performans: Bir öğenin Set'te varlığını kontrol etmek (has() metodu) genellikle O(1) zaman karmaşıklığına sahiptir, bu da büyük veri kümeleri için dizilerdeki aramalara göre daha verimli olabilir.
Zayıf Referanslar: Eğer objeler için zayıf referanslara ihtiyacınız varsa (yani objeye başka referans kalmadığında otomatik olarak belleğin serbest bırakılmasını istiyorsanız), WeakSet kullanmanız gerekebilir. Ancak WeakSet sadece objeleri depolayabilir ve iterable değildir.
Anahtar-Değer Çiftleri İçin Setler: Eğer benzersiz anahtar-değer çiftleri depolamanız gerekiyorsa, Map nesnesi daha uygun bir seçenek olabilir.
Veritabanı yönetim sistemlerinde (DBMS) mevcut kayıtların üzerinde değişiklik yapmak, veri bütünlüğünü sağlamak ve dinamik uygulamalar geliştirmek için temel bir gerekliliktir. SQL (Yapısal Sorgu Dili) bu ihtiyacı karşılamak üzere güçlü bir komut olan UPDATE ifadesini sunar. Bu makale, SQL UPDATE komutunun sözdizimini, kullanımını ve pratik örneklerini detaylı bir şekilde ele alarak, veritabanlarınızdaki bilgileri güvenli ve etkili bir şekilde nasıl güncelleyeceğinizi açıklamaktadır.
SQL UPDATE komutunun temel yapısı aşağıdaki gibidir:
UPDATE tablo_adı
SET sütun1 = değer1, sütun2 = değer2, ...
WHERE koşul;Yukarıdaki sözdizimi, belirli bir tablodaki bir veya daha fazla satırın bir veya daha fazla sütunundaki verileri değiştirmek için kullanılır.
UPDATE tablo_adı: Güncellemek istediğiniz tablonun adını belirtir. Bu kısım, işlemin hangi veritabanı nesnesi üzerinde yapılacağını tanımlar.
SET sütun1 = değer1, sütun2 = değer2, ...: Güncellenecek sütunları ve bu sütunlara atanacak yeni değerleri belirtir. Birden fazla sütunu güncellemek için sütun-değer çiftleri virgüllerle ayrılır. Atanan değerler sabit bir değer, başka bir sütunun değeri, bir ifade veya bir alt sorgunun sonucu olabilir.
WHERE koşul: Bu anahtar kelime ve ardından gelen koşul, hangi satırların güncelleneceğini belirler. Yalnızca belirtilen koşulu sağlayan satırlar güncellenir. Eğer WHERE koşulu kullanılmazsa, tablodaki tüm satırlar SET ifadesinde belirtilen değerlerle güncellenir. Bu, genellikle istenmeyen ve dikkatli olunması gereken bir durumdur.
Aşağıdaki örnekler, UPDATE komutunun farklı senaryolarda nasıl kullanılabileceğini göstermektedir. Örneklerde Müşteriler ve Ürünler adında iki tablo varsayılmaktadır.
Belirli bir müşteri ID'sine sahip müşterinin e-posta adresini güncelleyelim:
UPDATE Müşteriler
SET E_posta = 'yeni.eposta@example.com'
WHERE MüşteriID = 101;Bu sorgu, MüşteriID'si 101 olan kaydın E_posta sütununu yeni.eposta@example.com olarak değiştirir.
Belirli bir ürünün fiyatını ve stok miktarını aynı anda güncelleyelim:
UPDATE Ürünler
SET Fiyat = 29.99, StokMiktarı = 150
WHERE ÜrünID = 205;ÜrünID'si 205 olan ürünün hem Fiyat hem de StokMiktarı sütunları güncellenir.
Belirli bir kategorideki tüm ürünlerin fiyatını %10 artıralım:
UPDATE Ürünler
SET Fiyat = Fiyat * 1.10
WHERE Kategori = 'Elektronik';Bu örnek, mevcut Fiyat değerini kullanarak yeni bir değer hesaplar ve atar.
Eğer WHERE koşulu kullanılmazsa, tablodaki tüm satırlar güncellenir. Örneğin, tüm ürünlerin durumunu 'Pasif' olarak ayarlamak için:
UPDATE Ürünler
SET Durum = 'Pasif';Bu sorgu, Ürünler tablosundaki her ürünün Durum sütununu 'Pasif' olarak ayarlar. Bu tür bir işlem yapmadan önce daima veritabanı yedeği almanız ve işlemin etkilerini tam olarak anladığınızdan emin olmanız şiddetle tavsiye edilir.
WHERE koşulunun gücü ve tehlikesi: WHERE koşulu olmadan yapılan bir UPDATE işlemi, tablonuzdaki tüm verileri geri dönülemez bir şekilde değiştirebilir. Her zaman önce SELECT sorgusu ile güncellenecek satırları kontrol edin.
TRANSACTION kullanımı: Büyük veya kritik UPDATE işlemleri yaparken BEGIN TRANSACTION, COMMIT ve ROLLBACK komutlarını kullanmak iyi bir uygulamadır. Bu, bir hata durumunda değişiklikleri geri almanıza olanak tanır.
Yedekleme: Herhangi bir büyük veri değişikliği yapmadan önce daima veritabanınızın yedeğini alın. Bu, beklenmedik sorunlar karşısında verilerinizi kurtarmanızı sağlar.
Performans: Çok büyük tablolarda UPDATE işlemleri performans sorunlarına yol açabilir. İndekslerin doğru kullanılması ve işlem büyüklüğünün optimize edilmesi önemlidir.
SQL Injection: Kullanıcı girdileri ile dinamik UPDATE sorguları oluştururken SQL Injection saldırılarına karşı dikkatli olun. Güvenli parametreli sorgular (prepared statements) kullanmak bu tür riskleri azaltır.
Python programlama dilinde listeler, birden fazla öğeyi tek bir değişken altında depolamak için kullanılan temel ve çok yönlü veri yapılarından biridir. Sıralı, değiştirilebilir (mutable) ve farklı veri tiplerindeki öğeleri barındırabilen koleksiyonlardır. Veri yönetimi, algoritma geliştirme ve birçok programlama görevinde kritik bir rol oynarlar. Bu kılavuz, Python listelerinin oluşturulmasından karmaşık manipülasyonlarına kadar tüm yönlerini adım adım ele alacaktır.
Python'da bir liste, köşeli parantezler [] içine virgülle ayrılmış öğeler yerleştirilerek oluşturulur.
liste_adi = [eleman1, eleman2, eleman3, ...]liste_adi: Oluşturulan listeyi referans alan değişkendir. Geçerli bir Python tanımlayıcısı olmalıdır.
=: Atama operatörüdür. Sağdaki liste değerini soldaki değişkene atar.
[]: Köşeli parantezler, bir liste veri yapısının başlangıcını ve sonunu işaret eder. Python yorumlayıcısı, bu parantezlerin içindeki öğeleri bir liste olarak tanır.
eleman1, eleman2, eleman3, ...: Listede saklanacak öğelerdir. Bu öğeler, tam sayılar, ondalık sayılar, dizeler, boolean değerler, hatta başka listeler veya özel nesneler dahil olmak üzere herhangi bir Python veri tipinde olabilir. Öğeler birbirlerinden virgül , ile ayrılır.
Listeler sıralıdır, yani öğelerin eklenme sırası korunur ve bir dizin (index) numarası ile erişilebilirler. İlk öğenin dizini 0'dır. Ayrıca, listeler değiştirilebilirdir, yani oluşturulduktan sonra öğeleri eklenebilir, çıkarılabilir veya güncellenebilir.
Aşağıdaki örnekler, Python listelerinin temel kullanım senaryolarını göstermektedir.
Boş bir liste veya farklı veri tiplerini içeren bir liste oluşturabilirsiniz.
# Boş bir liste oluşturma
bos_liste = []
print(f"Boş Liste: {bos_liste}")
# Tam sayılar içeren bir liste
sayilar = [1, 2, 3, 4, 5]
print(f"Sayılar Listesi: {sayilar}")
# Dizeler içeren bir liste
meyveler = ["elma", "armut", "kiraz"]
print(f"Meyveler Listesi: {meyveler}")
# Farklı veri tiplerini içeren bir liste
karisik_liste = [10, "Python", True, 3.14]
print(f"Karışık Liste: {karisik_liste}")
# İç içe liste (nested list)
ic_ice_liste = [[1, 2], ["a", "b"]]
print(f"İç İçe Liste: {ic_ice_liste}")Listelerdeki öğelere dizin numaraları (index) kullanılarak erişilir. Dizinler 0'dan başlar. Negatif dizinler listenin sonundan itibaren saymaya başlar (-1 son öğeyi temsil eder).
my_list = ["a", "b", "c", "d", "e"]
# İlk öğeye erişim
print(f"İlk öğe: {my_list[0]}") # Çıktı: a
# Üçüncü öğeye erişim
print(f"Üçüncü öğe: {my_list[2]}") # Çıktı: c
# Son öğeye erişim (negatif dizin)
print(f"Son öğe: {my_list[-1]}") # Çıktı: e
# Sondan ikinci öğeye erişim
print(f"Sondan ikinci öğe: {my_list[-2]}") # Çıktı: dListeler değiştirilebilir olduğu için, belirli bir dizindeki öğeyi güncelleyebilirsiniz.
sayilar = [10, 20, 30, 40]
print(f"Orijinal liste: {sayilar}")
# İlk öğeyi değiştirme
sayilar[0] = 5
print(f"Değiştirilen ilk öğe sonrası: {sayilar}") # Çıktı: [5, 20, 30, 40]
# Son öğeyi değiştirme
sayilar[-1] = 50
print(f"Değiştirilen son öğe sonrası: {sayilar}") # Çıktı: [5, 20, 30, 50]append() metodu listenin sonuna, insert() metodu ise belirtilen bir dizine öğe ekler.
meyveler = ["elma", "armut"]
# listenin sonuna öğe ekleme
meyveler.append("muz")
print(f"Append sonrası: {meyveler}") # Çıktı: ['elma', 'armut', 'muz']
# Belirli bir dizine öğe ekleme (dizin 1'e 'kiraz' ekle)
meyveler.insert(1, "kiraz")
print(f"Insert sonrası: {meyveler}") # Çıktı: ['elma', 'kiraz', 'armut', 'muz']remove() metodu belirtilen değeri, pop() metodu belirtilen dizindeki öğeyi (veya son öğeyi), del anahtar kelimesi ise belirtilen dizindeki öğeyi veya dilimi siler.
renkler = ["kırmızı", "yeşil", "mavi", "sarı"]
# Değere göre silme
renkler.remove("yeşil")
print(f"Remove 'yeşil' sonrası: {renkler}") # Çıktı: ['kırmızı', 'mavi', 'sarı']
# Dizin 1'deki öğeyi silme (pop varsayılan olarak son öğeyi siler)
silinen_renk = renkler.pop(1)
print(f"Pop sonrası: {renkler}, Silinen: {silinen_renk}") # Çıktı: ['kırmızı', 'sarı'], Silinen: mavi
# 'del' anahtar kelimesi ile dizin 0'daki öğeyi silme
del renkler[0]
print(f"Del sonrası: {renkler}") # Çıktı: ['sarı']
# Tüm listeyi silme
# del renkler
# print(renkler) # Hata verecektir, çünkü liste artık mevcut değil.
# Listeyi temizleme (içindeki tüm öğeleri siler, liste objesi kalır)
sayilar = [1, 2, 3]
sayilar.clear()
print(f"Clear sonrası: {sayilar}") # Çıktı: []Listenin bir bölümünü (dilimini) almak için dilimleme işlemi kullanılır. Sözdizimi liste[baslangic:bitis:adim] şeklindedir.
alfabe = ["a", "b", "c", "d", "e", "f", "g"]
# İlk üç öğeyi al
print(f"İlk üç: {alfabe[0:3]}") # Çıktı: ['a', 'b', 'c']
print(f"İlk üç (kısa): {alfabe[:3]}") # Çıktı: ['a', 'b', 'c']
# İkinci dizinden sona kadar
print(f"İkinci dizinden sona: {alfabe[1:]}") # Çıktı: ['b', 'c', 'd', 'e', 'f', 'g']
# Üçüncü dizinden beşinci dizine kadar (beşinci dahil değil)
print(f"Üçüncüden beşe: {alfabe[2:5]}") # Çıktı: ['c', 'd', 'e']
# Tüm listeyi kopyalama
kopyalanmis_alfabe = alfabe[:]
print(f"Kopyalanmış: {kopyalanmis_alfabe}") # Çıktı: ['a', 'b', 'c', 'd', 'e', 'f', 'g']
# Her ikinci öğeyi al
print(f"Her ikinci: {alfabe[::2]}") # Çıktı: ['a', 'c', 'e', 'g']
# Listeyi ters çevir
print(f"Ters çevrilmiş: {alfabe[::-1]}") # Çıktı: ['g', 'f', 'e', 'd', 'c', 'b', 'a']Listeler üzerinde çeşitli temel operasyonlar gerçekleştirebilirsiniz.
liste1 = [1, 2, 3]
liste2 = [4, 5, 6]
# Listeleri birleştirme (concatenation)
birlesik_liste = liste1 + liste2
print(f"Birleşik liste: {birlesik_liste}") # Çıktı: [1, 2, 3, 4, 5, 6]
# Bir listeyi tekrarlama
tekrarlanan_liste = liste1 * 3
print(f"Tekrarlanan liste: {tekrarlanan_liste}") # Çıktı: [1, 2, 3, 1, 2, 3, 1, 2, 3]
# Liste uzunluğunu bulma
print(f"Liste1 uzunluğu: {len(liste1)}") # Çıktı: 3
# Bir öğenin listede olup olmadığını kontrol etme
print(f"2 listede mi? {'2' in liste1}") # Çıktı: False (int 2, str '2' değil)
print(f"2 listede mi? {2 in liste1}") # Çıktı: True
print(f"7 listede mi? {7 not in liste2}") # Çıktı: TrueDeğiştirilebilirlik (Mutability): Listeler değiştirilebilir veri yapılarıdır. Bu, içeriklerinin oluşturulduktan sonra değiştirilebileceği anlamına gelir. Bu özellik, listelerin esnekliğini artırır ancak aynı zamanda dikkatli kullanılmasını gerektirir, özellikle liste kopyalama ve referans verme durumlarında.
Heterojen Öğeler: Bir Python listesi, farklı veri tiplerindeki (örneğin, tam sayı, dize, boolean, hatta başka bir liste) öğeleri aynı anda barındırabilir.
Sıralı Yapı ve Dizinleme: Listelerdeki öğeler belirli bir sırayı korur ve bu sıraya dizin numaraları (0'dan başlayarak) aracılığıyla erişilebilir. Dizin dışı bir öğeye erişim denemesi IndexError hatasına yol açar.
Kopyalama Davranışı: Bir listeyi basit bir atama (örneğin, yeni_liste = eski_liste) ile kopyalamak, yeni bir liste oluşturmaz, yalnızca orijinal listenin referansını kopyalar. Bu, her iki değişkenin de aynı listeyi işaret ettiği anlamına gelir. Bağımsız bir kopya oluşturmak için .copy() metodu veya dilimleme [:] kullanılmalıdır (örn. yeni_liste = eski_liste.copy()).
Yüksek Performanslı İşlemler: Büyük listelerde sık sık ekleme/çıkarma işlemleri yapılıyorsa, performans sorunları yaşanabilir. Bu tür senaryolarda, collections.deque gibi alternatif veri yapıları daha uygun olabilir.
PHP programlamada, bir uygulamanın çalışma zamanında beklenmedik durumlarla karşılaşması yaygın bir senaryodur. Bu tür durumlar, programın normal akışını bozarak hatalara veya istenmeyen davranışlara yol açabilir. PHP'de bu tür durumları zarif ve kontrollü bir şekilde yönetmek için istisnalar (exceptions) mekanizması kullanılır. İstisnalar, hata koşullarını temsil eden nesnelerdir ve programın hatayı yakalamasına, işlemesine ve uygun bir yanıt vermesine olanak tanır. Bu kılavuz, PHP dilinde istisnaların temel sözdizimini, detaylı kullanımını ve pratik örneklerini adım adım açıklamaktadır.
PHP'de istisna yönetimi, try, catch ve isteğe bağlı olarak finally blokları kullanılarak gerçekleştirilir. Bu yapı, potansiyel olarak istisna fırlatabilecek kodun yürütülmesini izlemek ve fırlatılan istisnaları ele almak için tasarlanmıştır.
İstisna yönetimi yapısının her bir bileşeni belirli bir amaca hizmet eder:
try Bloğu: Potansiyel olarak bir istisna fırlatabilecek kodun bulunduğu alandır. Program bu blok içindeki kodun yürütülmesini izler. Eğer try bloğu içinde bir istisna fırlatılırsa, PHP normal akışı durdurur ve fırlatılan istisnayı yakalayabilecek uygun bir catch bloğu arar.
catch Bloğu: Bir try bloğunda fırlatılan istisnaları yakalamak ve işlemek için kullanılır. Her catch bloğu, yakalamak istediği istisna tipini (sınıfını) belirtir. PHP, fırlatılan istisna nesnesinin tipiyle eşleşen ilk catch bloğunu yürütür. Bir istisna yakalandığında, catch bloğu içindeki kod çalıştırılır ve bu, hatanın ele alınmasını sağlar. Birden fazla catch bloğu kullanarak farklı istisna tiplerini ayrı ayrı ele alabilirsiniz.
finally Bloğu: PHP 5.5'ten itibaren kullanılabilen bu blok, try ve catch blokları tamamlandıktan sonra, bir istisna fırlatılsın veya fırlatılmasın, her zaman yürütülecek kodu içerir. Bu, veritabanı bağlantılarını kapatma, dosya tanıtıcılarını serbest bırakma gibi temizleme (cleanup) işlemleri için son derece kullanışlıdır ve kaynak sızıntılarını önlemeye yardımcı olur.
throw Anahtar Kelimesi: Bir istisna fırlatmak için kullanılır. Bir Exception sınıfının veya ondan türetilmiş bir sınıfın nesnesiyle birlikte kullanılır. Örneğin: throw new Exception("Hata mesajı");
Exception Sınıfı: PHP'de tüm yerleşik ve özel istisnaların türediği temel sınıftır. Kendi özel istisna sınıflarınızı oluştururken genellikle bu sınıftan türetirsiniz.
Aşağıdaki örnekler, istisna yönetiminin farklı senaryolarda nasıl kullanılabileceğini göstermektedir.
Örnek 1: Temel İstisna Yakalama
";
echo bolmeIslemi(5, 0) . "
"; // Bu satırda istisna fırlatılacak
echo bolmeIslemi(20, 4) . "
"; // Bu satır çalışmayacak
} catch (Exception $e) {
echo "Hata yakalandı: " . $e->getMessage() . "
";
}
echo "Program devam ediyor.
";
?>Bu örnekte, bolmeIslemi fonksiyonu sıfıra bölme durumunda bir istisna fırlatır. try bloğu içinde bu istisna yakalanır ve hata mesajı ekrana yazdırılır. İstisna fırlatıldıktan sonra try bloğundaki diğer kodların çalışmadığına dikkat edin.
Örnek 2: Çoklu catch Blokları ve Özel İstisnalar
Kendi özel istisna sınıflarınızı tanımlayarak daha spesifik hata durumlarını ele alabilirsiniz. Özel istisna sınıfları genellikle Exception sınıfından türetilir.
getMessage() . "
";
} catch (VeritabaniBaglantiHatasiException $e) {
echo "Veritabanı hatası yakalandı: " . $e->getMessage() . "
";
} catch (Exception $e) { // Diğer tüm istisnaları yakalamak için
echo "Genel bir hata yakalandı: " . $e->getMessage() . "
";
} finally {
echo "İşlem tamamlandı, kaynaklar serbest bırakılıyor (finally bloğu).
";
}
?>Bu örnek, farklı hata türlerini ele almak için birden çok catch bloğunun nasıl kullanılacağını gösterir. finally bloğu ise, istisna fırlatılsa da fırlatılmasa da her zaman çalışarak temizleme işlemleri için bir garanti sağlar.
Örnek 3: İstisnaları Yeniden Fırlatma (Re-throwing Exceptions)
Bazen bir istisnayı yakalayıp belirli bir işlem yaptıktan sonra, daha yüksek bir seviyede ele alınması için yeniden fırlatmak isteyebilirsiniz.
getMessage());
// İstisnayı daha yüksek bir seviyede yakalanmak üzere yeniden fırlat
throw new Exception("Dosya işlemi sırasında bir sorun oluştu.", 0, $e);
}
}
try {
$data = dosyaOku("olmayan_dosya.txt");
echo "Dosya içeriği: " . $data . "
";
} catch (Exception $e) {
echo "Uygulama seviyesinde hata: " . $e->getMessage() . "
";
if ($e->getPrevious()) {
echo "Önceki hata: " . $e->getPrevious()->getMessage() . "
";
}
}
?>Bu örnekte, dosyaOku fonksiyonu bir istisna yakalar, loglar ve ardından daha genel bir istisna mesajıyla yeniden fırlatır. Yeniden fırlatılan istisnaya orijinal istisna, getPrevious() metodu ile erişilebilir.
Spesifik catch Blokları Önce Gelmeli: Birden fazla catch bloğu kullanırken, daha spesifik istisna sınıflarını (GecersizParametreException gibi) genel Exception sınıfından önce yerleştirin. Aksi takdirde, daha genel olan blok tüm istisnaları yakalar ve spesifik bloklara asla ulaşılamaz.
İstisnaları Yutmaktan Kaçının: Bir istisnayı yakalayıp hiçbir işlem yapmadan (boş bir catch bloğu) bırakmak, hataların gizlenmesine ve hata ayıklamanın zorlaşmasına neden olur. Her zaman yakalanan istisnayı loglayın, kullanıcıya anlamlı bir mesaj gösterin veya uygun şekilde ele alın.
Sadece Hata Durumları İçin Kullanın: İstisnalar, programın normal akışının bir parçası olmayan, beklenmedik hata durumları için tasarlanmıştır. Kontrol akışını yönlendirmek için istisnaları kullanmaktan kaçının (örneğin, bir döngüyü kırmak için).
Throwable Arayüzü: PHP 7'den itibaren, hem Exception hem de Error sınıflarının uyguladığı Throwable arayüzü tanıtılmıştır. Bu, hem istisnaları hem de ciddi hataları (örneğin, bellek tükenmesi) tek bir catch (Throwable $e) bloğu ile yakalamanıza olanak tanır.
Standart İstisna Sınıfları: PHP, InvalidArgumentException, RuntimeException, PDOException gibi birçok yerleşik istisna sınıfı sağlar. Uygulamanızda bu standart sınıfları veya bunlardan türettiğiniz özel sınıfları kullanmak iyi bir pratiktir.
Map nesnesi, JavaScript'te anahtar-değer çiftlerini saklamak için kullanılan güçlü bir veri yapısıdır. Geleneksel nesnelerin (Object) sınırlamalarını aşarak, anahtar olarak herhangi bir veri türünü (nesneler, fonksiyonlar, ilkel değerler) kullanılmasına olanak tanır ve elemanların eklenme sırasını korur. Bu özellikler, Map'i belirli senaryolarda Object'e göre daha esnek ve verimli bir alternatif haline getirir.
Map nesnesi, new Map() yapıcı fonksiyonu kullanılarak oluşturulur. Anahtar-değer çiftleri eklemek, almak ve yönetmek için çeşitli yöntemler sunar.
Yeni bir Map oluşturma:
const myMap = new Map();Başlangıç değerleri ile Map oluşturma:
const initialMap = new Map([
['anahtar1', 'değer1'],
['anahtar2', 'değer2']
]);Bir anahtar-değer çifti ekleme:
myMap.set('ad', 'Alice');Bir anahtarın değerini alma:
const ad = myMap.get('ad'); // 'Alice'Bir anahtarın varlığını kontrol etme:
const varMi = myMap.has('ad'); // trueBir anahtar-değer çiftini silme:
myMap.delete('ad');Map'teki eleman sayısını alma:
const boyut = myMap.size;Tüm anahtar-değer çiftlerini temizleme:
myMap.clear();Map nesnesi, JavaScript'teki geleneksel Object'lere göre bazı önemli avantajlar sunar ve farklı kullanım senaryolarına hitap eder.
Anahtar Türleri: Geleneksel nesnelerde anahtarlar yalnızca string veya Symbol olabilirken, Map nesneleri anahtar olarak herhangi bir veri türünü (nesneler, fonksiyonlar, diziler, ilkel değerler vb.) kabul edebilir. Bu, özellikle DOM elemanları veya diğer nesneleri doğrudan anahtar olarak kullanmak istediğinizde büyük bir avantaj sağlar.
Eleman Sırası: Map nesneleri, anahtar-değer çiftlerinin eklenme sırasını korur. Bu, üzerinde iterasyon yaparken elemanların hangi sırayla eklendiğini bilmek veya bu sırayı kullanmak istediğinizde önemlidir. Geleneksel nesnelerde özelliklerin sırası garanti edilmez (ancak ES2015'ten sonra bazı durumlarda kısmen garanti edilmeye başlanmıştır, yine de Map kadar güçlü değildir).
Boyut: Map nesnesinin size özelliği, içerdiği anahtar-değer çiftlerinin sayısını doğrudan ve verimli bir şekilde verir. Geleneksel nesnelerde bu bilgiye ulaşmak için genellikle Object.keys(obj).length gibi yöntemler kullanmak gerekir ki bu da her seferinde yeni bir dizi oluşturmayı gerektirir.
Performans: Sık sık anahtar-değer çiftlerinin eklenip silindiği senaryolarda, Map genellikle geleneksel nesnelere göre daha iyi performans sergileyebilir. Özellikle anahtar sayısı arttıkça bu fark daha belirgin hale gelebilir.
Iterasyon: Map nesneleri doğrudan iterable'dır. Bu, for...of döngüleri ile kolayca anahtarlar, değerler veya anahtar-değer çiftleri üzerinde döngü yapmanızı sağlar. map.keys(), map.values() ve map.entries() yöntemleri, ilgili iterable nesneleri döndürür.
Bir Map'e aynı anahtarla yeni bir değer atandığında, mevcut değerin üzerine yazılır. Bu, anahtarların benzersiz olmasını sağlar.
Aşağıdaki örnekler, Map nesnesinin çeşitli kullanım senaryolarını göstermektedir.
Bu örnek, bir Map oluşturmayı, eleman eklemeyi, eleman almayı, varlığını kontrol etmeyi ve silmeyi gösterir.
const kullaniciBilgileri = new Map();
// Eleman ekleme
kullaniciBilgileri.set('id', 101);
kullaniciBilgileri.set('ad', 'Veli');
kullaniciBilgileri.set('soyad', 'Demir');
kullaniciBilgileri.set('aktif', true);
console.log('Kullanıcı Adı:', kullaniciBilgileri.get('ad')); // Çıktı: Kullanıcı Adı: Veli
console.log('ID mevcut mu?', kullaniciBilgileri.has('id')); // Çıktı: ID mevcut mu? true
console.log('Email mevcut mu?', kullaniciBilgileri.has('email')); // Çıktı: Email mevcut mu? false
// Bir elemanı silme
kullaniciBilgileri.delete('aktif');
console.log('Aktif durumu silindi mi?', !kullaniciBilgileri.has('aktif')); // Çıktı: Aktif durumu silindi mi? true
console.log('Map boyutu:', kullaniciBilgileri.size); // Çıktı: Map boyutu: 3
// Tüm elemanları temizleme
kullaniciBilgileri.clear();
console.log('Map temizlendikten sonra boyut:', kullaniciBilgileri.size); // Çıktı: Map temizlendikten sonra boyut: 0Map'in en güçlü yönlerinden biri, anahtar olarak nesneleri kullanabilmesidir. Bu örnek, iki farklı nesneyi anahtar olarak nasıl kullanacağımızı gösterir.
const kullanici1 = { id: 1, ad: 'Ayşe' };
const kullanici2 = { id: 2, ad: 'Fatma' };
const kullaniciRolleri = new Map();
kullaniciRolleri.set(kullanici1, 'Yönetici');
kullaniciRolleri.set(kullanici2, 'Editör');
console.log(kullaniciRolleri.get(kullanici1)); // Çıktı: Yönetici
console.log(kullaniciRolleri.get(kullanici2)); // Çıktı: Editör
// Yeni bir nesne oluşturup aynı değerlere sahip olsa bile farklı bir anahtar olarak kabul edilir.
const kullanici3 = { id: 1, ad: 'Ayşe' };
console.log(kullaniciRolleri.get(kullanici3)); // Çıktı: undefined (çünkü bellekte farklı bir referanstır)Map nesneleri, for...of döngüsü ile kolayca iterate edilebilir. Bu örnek, anahtarlar, değerler ve anahtar-değer çiftleri üzerinde nasıl döngü yapılacağını gösterir.
const urunFiyatlari = new Map([
['Laptop', 12000],
['Klavye', 500],
['Fare', 250]
]);
console.log('--- Anahtar-Değer Çiftleri ---');
for (const [urun, fiyat] of urunFiyatlari) {
console.log(`${urun}: ${fiyat} TL`);
}
// Çıktı:
// Laptop: 12000 TL
// Klavye: 500 TL
// Fare: 250 TL
console.log('\n--- Sadece Anahtarlar ---');
for (const urun of urunFiyatlari.keys()) {
console.log(urun);
}
// Çıktı:
// Laptop
// Klavye
// Fare
console.log('\n--- Sadece Değerler ---');
for (const fiyat of urunFiyatlari.values()) {
console.log(fiyat);
}
// Çıktı:
// 12000
// 500
// 250Map ve dizi arasında kolayca dönüşüm yapabilirsiniz.
// Diziden Map oluşturma
const diziVeri = [['a', 1], ['b', 2], ['c', 3]];
const harita = new Map(diziVeri);
console.log('Diziden Oluşturulan Map:', harita); // Çıktı: Diziden Oluşturulan Map: Map(3) { 'a' => 1, 'b' => 2, 'c' => 3 }
// Map'i diziye dönüştürme (entries olarak)
const haritaDizi = Array.from(harita);
console.log('Map\'in Diziye Dönüştürülmüş Hali (entries):', haritaDizi); // Çıktı: Map'in Diziye Dönüştürülmüş Hali (entries): [ [ 'a', 1 ], [ 'b', 2 ], [ 'c', 3 ] ]
// Sadece anahtarları diziye dönüştürme
const anahtarlarDizi = [...harita.keys()];
console.log('Map Anahtarları Dizi Olarak:', anahtarlarDizi); // Çıktı: Map Anahtarları Dizi Olarak: [ 'a', 'b', 'c' ]
// Sadece değerleri diziye dönüştürme
const degerlerDizi = [...harita.values()];
console.log('Map Değerleri Dizi Olarak:', degerlerDizi); // Çıktı: Map Değerleri Dizi Olarak: [ 1, 2, 3 ]Anahtar Karşılaştırması: Map'teki anahtarlar, SameValueZero algoritması kullanılarak karşılaştırılır. Bu, === operatörüne benzer ancak NaN değerinin kendisine eşit kabul edilmesi gibi bazı farklılıklar içerir (NaN === NaN false dönerken, Map içinde NaN anahtarı NaN ile eşleşir).
Map vs. Object: Ne zaman hangisini kullanacağınızı iyi belirleyin. Eğer anahtarlarınız yalnızca string veya Symbol ise ve eleman sırası önemli değilse, basit bir Object yeterli olabilir. Ancak anahtarlarınız farklı veri tiplerinde olacaksa, eleman sırasını korumanız gerekiyorsa veya sık sık eleman ekleyip siliyorsanız, Map genellikle daha iyi bir seçimdir.
Serileştirme: Map nesneleri doğrudan JSON.stringify() ile serileştirilemez. Bir Map'i JSON formatına dönüştürmek için önce onu bir diziye veya düz bir nesneye dönüştürmeniz gerekir.
WeakMap: JavaScript ayrıca WeakMap adında bir veri yapısı sunar. WeakMap, yalnızca nesneleri anahtar olarak kabul eder ve anahtarların "zayıf" referanslarını tutar. Bu, anahtar nesneye başka hiçbir referans kalmadığında çöp toplayıcının anahtarı ve ilgili değeri otomatik olarak silmesine olanak tanır. Bellek yönetimi açısından önemlidir, ancak Map'ten farklı bir kullanım senaryosu vardır.
DELETE ifadesi, bir tablodan bir veya daha fazla satırı kalıcı olarak kaldırmak için kullanılır. Bu makale, DELETE ifadesinin sözdizimini, kullanımını ve dikkat edilmesi gereken önemli noktaları detaylı bir şekilde ele alacaktır.DELETE ifadesinin temel sözdizimi aşağıdaki gibidir:
DELETE FROM tablo_adi
WHERE kosul;Tüm satırları silmek için WHERE koşulu atlanabilir:
DELETE FROM tablo_adi;DELETE ifadesinin bileşenleri şunlardır:
DELETE FROM: Bu anahtar kelimeler, belirtilen tablodan satır silme işlemini başlatır.
tablo_adi: Verilerin silineceği tablonun adıdır. Bu, işlemin hedefidir.
WHERE kosul: İsteğe bağlı bir koşuldur. Bu koşul belirtilirse, yalnızca koşulu karşılayan satırlar silinir. Eğer WHERE koşulu belirtilmezse, tablodaki tüm satırlar silinir. Bu durum geri alınamaz olduğundan büyük dikkat gerektirir. Koşul, bir veya daha fazla sütun üzerinde mantıksal operatörler (=, <>, <, >, <=, >=, LIKE, IN, BETWEEN vb.) kullanılarak tanımlanır.
Aşağıdaki örnekler, DELETE ifadesinin çeşitli senaryolarda nasıl kullanılacağını göstermektedir. Örneklerde, Calisanlar adında bir tablonun var olduğu varsayılmaktadır.
Örnek 1: Belirli Bir Satırı Silme
Calisanlar tablosundan CalisanID'si 101 olan çalışanı silmek için:
DELETE FROM Calisanlar
WHERE CalisanID = 101;Örnek 2: Birden Fazla Satırı Koşula Göre Silme
Calisanlar tablosundan 'Pazarlama' departmanında çalışan tüm personeli silmek için:
DELETE FROM Calisanlar
WHERE Departman = 'Pazarlama';Örnek 3: Belirli Bir Tarihten Önceki Kayıtları Silme
Calisanlar tablosundan GirisTarihi 2020 yılından önce olan tüm çalışanları silmek için:
DELETE FROM Calisanlar
WHERE GirisTarihi < '2020-01-01';Örnek 4: Tüm Satırları Silme (WHERE koşulu olmadan)
Calisanlar tablosundaki tüm kayıtları silmek için:
DELETE FROM Calisanlar;Bu işlem, tablonun yapısını korurken tüm verileri kalıcı olarak kaldırır.
Yedekleme: DELETE işlemini gerçekleştirmeden önce her zaman veri tabanınızı yedekleyin. Yanlışlıkla yapılan silme işlemleri geri alınamaz sonuçlar doğurabilir.
WHERE Koşulunun Önemi: WHERE koşulunu dikkatlice yazın ve doğruluğundan emin olun. Koşulun yanlış olması, beklenenden daha fazla veya yanlış verilerin silinmesine yol açabilir.
TRUNCATE TABLE vs. DELETE: Tüm satırları silmek için DELETE FROM tablo_adi; yerine TRUNCATE TABLE tablo_adi; de kullanılabilir. Ancak bu iki komut arasında önemli farklar vardır:
DELETE, satır satır silme işlemi yapar ve her silinen satır için işlem günlüğü (transaction log) kaydı tutar. Bu nedenle daha yavaş olabilir ve geri alınabilir (ROLLBACK) bir işlem olabilir.
TRUNCATE TABLE, tabloyu yeniden oluşturarak daha hızlı bir şekilde tüm verileri siler. İşlem günlüğüne minimum kayıt yazar, bu yüzden daha performanslıdır. Ancak, bu işlem genellikle geri alınamaz (ROLLBACK edilemez).
İlişkisel Bütünlük (Referential Integrity): Bir tabloda silmeye çalıştığınız veriler başka bir tablonun dış anahtar (FOREIGN KEY) kısıtlamaları tarafından referans alınıyorsa, silme işlemi başarısız olabilir veya ilişkili verilerin de silinmesini (ON DELETE CASCADE) tetikleyebilir. Veri tabanı tasarımınızı ve kısıtlamalarınızı anlayın.
İşlem Kontrolü (Transaction Control): Özellikle kritik silme işlemleri için BEGIN TRANSACTION (veya START TRANSACTION), COMMIT ve ROLLBACK komutlarını kullanın. Bu, silme işlemini test etmenize ve gerekirse geri almanıza olanak tanır.
BEGIN TRANSACTION;
DELETE FROM Calisanlar
WHERE CalisanID = 101;
-- SELECT * FROM Calisanlar WHERE CalisanID = 101; -- Silinip silinmediğini kontrol et
-- COMMIT; -- Değişiklikleri kalıcı hale getir
-- ROLLBACK; -- Değişiklikleri geri al
Python programlama dilinde veri yapıları, programların veriyi düzenli ve etkin bir şekilde depolamasını ve işlemesini sağlar. Bu veri yapılarından biri olan tuple (demet), değiştirilemez (immutable) ve sıralı (ordered) bir koleksiyon türüdür. Listeler gibi diğer sıralı koleksiyonların aksine, bir tuple oluşturulduktan sonra elemanları değiştirilemez, eklenemez veya silinemez. Bu özelliği, tuple'ları sabit veri setlerini veya fonksiyonlardan birden fazla değer döndürmek gibi senaryolarda ideal bir seçim haline getirir.
Bir tuple, parantez () kullanılarak ve elemanları virgülle , ayrılarak oluşturulur. Elemanlar farklı veri tiplerinden olabilir.
# Boş bir tuple oluşturma
bos_tuple = ()
# Sayılardan oluşan bir tuple
sayi_tuple = (1, 2, 3, 4, 5)
# Farklı veri tiplerinden oluşan bir tuple
karisik_tuple = ("Python", 3.14, True, 100)
# Tek elemanlı tuple oluşturma (virgül kullanımı önemlidir)
tek_elemanli_tuple = (42,) # Virgül olmadan sadece parantez bir integer olur
# Parantez olmadan tuple oluşturma (tuple paketleme)
paketlenmis_tuple = 1, 2, "üç" # Bu da geçerli bir tuple oluşturur
Tuple'ların temel özellikleri ve kullanım mekanizmaları aşağıda açıklanmıştır:
Değiştirilemezlik (Immutability): Bir tuple'ın en belirgin özelliğidir. Oluşturulduktan sonra içindeki elemanlar ne değiştirilebilir ne de yeni elemanlar eklenebilir veya mevcutlar silinebilir. Bu özellik, veri bütünlüğünü sağlamak ve tuple'ları daha güvenli veri taşıyıcıları yapmak için önemlidir.
Sıralı (Ordered): Tuple elemanları belirli bir sıraya sahiptir ve bu sıra korunur. Elemanlara erişim indeks numaraları aracılığıyla yapılır.
İndekslenebilir (Indexable): Listeler gibi, tuple elemanlarına da sıfır tabanlı indekslerle erişilebilir. Dilimleme (slicing) işlemleri de desteklenir.
Farklı Veri Tipleri: Bir tuple, aynı anda farklı veri tiplerinden (integer, float, string, boolean vb.) elemanları barındırabilir.
Tuple Paketleme ve Açma (Packing/Unpacking): Python, birden fazla değeri bir tuple olarak "paketlemeye" ve bir tuple'daki değerleri birden fazla değişkene "açmaya" olanak tanır. Bu, özellikle fonksiyonlardan çoklu değer döndürmede veya değişkenleri hızlıca takas etmede kullanışlıdır.
Aşağıdaki örnekler, Python tuple'larının nasıl oluşturulduğunu, elemanlarına nasıl erişildiğini ve çeşitli senaryolarda nasıl kullanıldığını göstermektedir.
# Bir tuple oluşturma
koordinatlar = (10, 20)
print(f"Koordinatlar: {koordinatlar}")
# İndeks kullanarak elemanlara erişim
x_koordinati = koordinatlar[0]
y_koordinati = koordinatlar[1]
print(f"X Koordinatı: {x_koordinati}, Y Koordinatı: {y_koordinati}")
# Negatif indeksleme
son_eleman = koordinatlar[-1]
print(f"Son eleman: {son_eleman}")
# Dilimleme (Slicing)
ilk_iki = (1, 2, 3, 4, 5)[0:2]
print(f"İlk iki eleman: {ilk_iki}")
# Tuple Paketleme
bilgi = "Alice", 30, "Mühendis" # Otomatik olarak bir tuple oluşturulur
# Tuple Açma
isim, yas, meslek = bilgi
print(f"İsim: {isim}, Yaş: {yas}, Meslek: {meslek}")
# Değişkenleri takas etme
a = 5
b = 10
print(f"Takas öncesi: a={a}, b={b}")
a, b = b, a # Tuple paketleme ve açma ile hızlı takas
print(f"Takas sonrası: a={a}, b={b}")
def dikdortgen_bilgileri(uzunluk, genislik):
alan = uzunluk * genislik
cevre = 2 * (uzunluk + genislik)
return alan, cevre # Fonksiyon bir tuple döndürür
# Fonksiyonu çağırma ve döndürülen tuple'ı açma
alan_degeri, cevre_degeri = dikdortgen_bilgileri(5, 8)
print(f"Dikdörtgenin Alanı: {alan_degeri}, Çevresi: {cevre_degeri}")
Tuple'lar, değiştirilemez olmalarına rağmen, elemanları üzerinde bilgi edinmek için bazı dahili metotlara sahiptir: count() ve index().
my_tuple = (1, 2, 2, 3, 4, 2, 5)
# count() metodu: Belirli bir elemanın kaç kez geçtiğini sayar
iki_sayisi = my_tuple.count(2)
print(f"2 sayısı tuple içinde {iki_sayisi} kez geçiyor.")
# index() metodu: Belirli bir elemanın ilk geçtiği indeksi döndürür
# Eğer eleman bulunamazsa ValueError yükseltir
uc_indeksi = my_tuple.index(3)
print(f"3 elemanının ilk indeksi: {uc_indeksi}")
# Olmayan bir eleman için deneme
try:
altı_indeksi = my_tuple.index(6)
print(f"6 elemanının ilk indeksi: {altı_indeksi}")
except ValueError as e:
print(f"Hata: {e}")
Tek Elemanlı Tuple Oluşturma: Tek bir elemanı olan bir tuple oluştururken, elemandan sonra mutlaka bir virgül , eklemelisiniz. Örneğin, (42,) bir tuple'dır; (42) ise sadece bir tam sayıdır.
Performans: Tuples, listelere göre genellikle daha az bellek tüketir ve daha hızlı işlenir, çünkü değiştirilemez yapıları Python'ın optimizasyon yapmasına olanak tanır. Sabit veri setleri için tuple kullanmak performans avantajı sağlayabilir.
Hashable Olma: Yalnızca değiştirilemez (immutable) elemanlar içeren tuple'lar hashable'dır. Bu da onları Python sözlüklerinde anahtar olarak veya set'lerde eleman olarak kullanılabileceği anlamına gelir. Örneğin, (1, 2) bir sözlük anahtarı olabilirken, (1, [2, 3]) olamaz çünkü içindeki liste değiştirilemez değildir.
Değiştirilemezliğin Kapsamı: Tuple'lar kendileri değiştirilemez olsa da, eğer bir tuple mutable (değiştirilebilir) bir obje (örneğin bir liste) içeriyorsa, o mutable objenin içeriği değiştirilebilir. Tuple'ın referansı sabittir, ancak referans ettiği objenin içeriği değişebilir.
Kullanım Senaryoları: Tuples, özellikle aşağıdaki durumlarda tercih edilmelidir:
Fonksiyonlardan birden fazla değer döndürme.
Sabit koleksiyonları temsil etme (örneğin, haftanın günleri, renk kodları).
Sözlük anahtarı olarak kullanılacak verileri depolama.
Veri bütünlüğünün önemli olduğu durumlar.
![]()
![]()
src (Source - Kaynak): Bu nitelik, görüntünün dosya yolunu veya URL'sini belirtir. Tarayıcı, bu yoldan görüntüyü alır ve sayfada görüntüler. Mutlak (https:// ile başlayan) veya göreceli (aynı sunucudaki bir klasöre işaret eden) yollar kullanılabilir. Bu,
alt (Alternative Text - Alternatif Metin): Bu nitelik, resmin içeriğini veya işlevini tanımlayan metinsel bir açıklama sağlar. Resim yüklenemediğinde, ekran okuyucular tarafından erişilebilirlik için veya arama motorları tarafından içeriği anlamak için kullanılır. Erişilebilirlik ve SEO için kritik öneme sahiptir.
width (Genişlik): Görüntünün genişliğini piksel cinsinden (varsayılan) veya yüzde olarak belirtir. Yalnızca width="200" yazmak 200 piksel anlamına gelir.
height (Yükseklik): Görüntünün yüksekliğini piksel cinsinden (varsayılan) veya yüzde olarak belirtir. Yalnızca height="150" yazmak 150 piksel anlamına gelir.
loading: Tarayıcının görüntüyü nasıl yüklemesi gerektiğini belirten bir ipucu sunar. Değerleri "lazy" (görüntü görüntüleme alanına yaklaştığında yükle) veya "eager" (hemen yükle) olabilir. Performans optimizasyonu için önemlidir.
srcset: Farklı çözünürlük veya ekran boyutları için birden fazla görüntü kaynağı belirtmenizi sağlar. Tarayıcı, kullanıcının cihazına en uygun görüntüyü seçer. Duyarlı (responsive) tasarım için vazgeçilmezdir.
sizes: srcset ile birlikte kullanıldığında, tarayıcıya görüntünün farklı görüntüleme alanlarında ne kadar yer kaplayacağını bildirir. Bu, tarayıcının srcset'ten en uygun görüntüyü seçmesine yardımcı olur.
Aşağıdaki örnekler,
1. Temel Görüntü Ekleme (Göreli Yol):
Bu örnek, aynı dizindeki bir resmi sayfaya ekler.
2. Harici Bir Kaynaktan Görüntü Ekleme:
Bir CDN'den veya başka bir web sitesinden bir görüntü yükler.
3. Duyarlı (Responsive) Görüntü Kullanımı (srcset ve sizes ile):
Tarayıcının farklı ekran boyutlarına göre en uygun görüntüyü seçmesini sağlar.
4. Gecikmeli Yükleme (Lazy Loading):
Görüntünün yalnızca kullanıcı görüntüleme alanına yaklaştığında yüklenmesini sağlar, bu da sayfa performansını artırır.
5.
Bir resmi ve ilişkili başlığını semantik olarak gruplandırmak için kullanılır.
Akdeniz'de muhteşem bir günbatımı görüntüsü.
alt Niteliklerinin Önemi: Her alt niteliği içermelidir. Bu, hem erişilebilirlik (ekran okuyucular için) hem de SEO (arama motorlarının resim içeriğini anlaması için) açısından kritik öneme sahiptir. Dekoratif resimler için alt="" boş bırakılabilir, ancak yine de nitelik mevcut olmalıdır.
Dosya Biçimleri: Yaygın olarak kullanılan resim formatları JPEG (fotoğraflar için), PNG (saydamlık gerektiren görseller için) ve GIF (animasyonlar için) ve WebP (genel olarak daha iyi sıkıştırma ve performans için) ve SVG (vektörel grafikler için) şeklindedir.
Performans Optimizasyonu: Büyük boyutlu resimler sayfa yükleme süresini artırabilir. Resimleri web için optimize etmek (sıkıştırmak ve doğru boyutlandırmak) önemlidir. loading="lazy" kullanmak da performansı artırabilir.
Boyutlandırma (width ve height): Tarayıcının resim için ayrılacak alanı önceden bilmesi için width ve height niteliklerini her zaman kullanmak iyi bir uygulamadır. Bu, "Cumulative Layout Shift" (CLS) gibi görsel istikrarsızlık sorunlarını önlemeye yardımcı olur.
Duyarlı Tasarım: Modern web geliştirmede resimlerin farklı ekran boyutlarına ve çözünürlüklerine uyum sağlaması çok önemlidir. srcset ve sizes nitelikleri bu ihtiyacı karşılamak için tasarlanmıştır.
SELECT TOP ifadesi, bu ihtiyacı karşılamak üzere tasarlanmış güçlü bir araçtır ve sorgu sonuçlarını belirli bir limit dahilinde döndürmeyi sağlar. Bu özellik, performans optimizasyonundan kullanıcı arayüzü kısıtlamalarına kadar çeşitli senaryolarda kritik bir rol oynar.SELECT TOP ifadesinin genel sözdizimi aşağıdaki gibidir:
SELECT TOP sayı | yüzde [PERCENT]
FROM tablo_adı
WHERE koşul
ORDER BY sütun_adı [ASC|DESC];SELECT TOP ifadesinin her bir bileşeni belirli bir amaca hizmet eder:SELECT: Veritabanından veri çekmek için kullanılan temel SQL komutudur.
TOP sayı: Sorgu sonucundan kaç adet kaydın döndürüleceğini belirten bir tam sayıdır. Örneğin, TOP 10 ilk 10 kaydı döndürür.
TOP yüzde PERCENT: Sorgu sonucundan döndürülecek kayıtların toplam kayıt sayısına göre yüzdesini belirtir. Örneğin, TOP 5 PERCENT toplam kayıtların ilk %5'ini döndürür.
FROM tablo_adı: Verilerin çekileceği tablonun adını belirtir.
WHERE koşul: İsteğe bağlı bir yan tümcedir. Belirtilen koşulları karşılayan kayıtları filtrelemek için kullanılır. Eğer bir WHERE koşulu kullanılmazsa, TOP tüm tablodaki kayıtlar üzerinde işlem yapar.
ORDER BY sütun_adı [ASC|DESC]: İsteğe bağlı ancak kritik bir yan tümcedir. Kayıtların hangi kritere göre sıralanacağını ve dolayısıyla hangi "ilk" kayıtların seçileceğini belirler. ASC (artan) veya DESC (azalan) sıralama yönünü belirtir. Eğer ORDER BY kullanılmazsa, döndürülen "ilk" kayıtlar veritabanının fiziksel depolama sırasına göre veya sorgu planına göre belirlenir ki bu da tutarsız sonuçlara yol açabilir. TOP ile birlikte ORDER BY kullanımı, tutarlı ve anlamlı sonuçlar elde etmek için şiddetle tavsiye edilir.
ProductID, ProductName, Price ve StockQuantity gibi sütunlar bulunmaktadır.SELECT TOP 5 ProductName, Price
FROM Ürünler
ORDER BY Price DESC;SELECT TOP 10 PERCENT ProductName, StockQuantity
FROM Ürünler
ORDER BY StockQuantity ASC;CategoryID ve AddedDate sütunu olduğunu varsayalım. Koşul olarak CategoryID = 1 olan ürünleri filtreler, eklenme tarihine göre azalan sırada sıralar ve en yeni ilk 3 ürünü seçer.
SELECT TOP 3 ProductName, AddedDate
FROM Ürünler
WHERE CategoryID = 1
ORDER BY AddedDate DESC;Veritabanı Uyumluluğu: SELECT TOP ifadesi özellikle SQL Server ve MS Access gibi veritabanlarında yaygın olarak kullanılır. Diğer veritabanı sistemlerinde benzer işlevsellik farklı sözdizimleri ile sağlanır:
MySQL: LIMIT anahtar kelimesi (örneğin: SELECT sütunlar FROM tablo LIMIT 10;)
PostgreSQL: LIMIT anahtar kelimesi (örneğin: SELECT sütunlar FROM tablo LIMIT 10;)
Oracle: ROWNUM sözde sütunu (eski versiyonlar) veya FETCH FIRST N ROWS ONLY (Oracle 12c ve sonrası) kullanılır (örneğin: SELECT sütunlar FROM tablo FETCH FIRST 10 ROWS ONLY;)
ORDER BY Kullanımının Önemi: TOP ifadesi ile birlikte ORDER BY kullanmamak, veritabanının kayıtları fiziksel olarak nasıl depoladığına veya sorgu planına bağlı olarak rastgele veya tutarsız sonuçlar almanıza neden olabilir. Tutarlı ve öngörülebilir sonuçlar için mutlaka ORDER BY kullanın.
Performans: Büyük tablolarda TOP ifadesini kullanmak, sorgunun performansını artırabilir çünkü veritabanının tüm kayıtları işlemesi yerine yalnızca belirli sayıda kaydı işlemesini sağlar. Ancak, karmaşık WHERE ve ORDER BY yan tümceleriyle birleştiğinde performans üzerinde ek yükler oluşabilir.
Eşit Değerler (TIES): Bazı veritabanı sistemlerinde (örneğin SQL Server), TOP N WITH TIES sözdizimi ile, sıralama kriterine göre son kaydın aynı değere sahip olduğu ek kayıtları da dahil edebilirsiniz. Bu, TOP limitine ulaşılsa bile, son sıradaki değerle eşleşen tüm kayıtların döndürülmesini sağlar.
Python programlama dilinde, verileri etkili bir şekilde depolamak ve yönetmek için çeşitli yerleşik veri yapıları bulunmaktadır. Bu yapılardan biri olan set, benzersiz elemanlardan oluşan, sırasız ve değiştirilebilir bir koleksiyondur. set'ler, özellikle bir koleksiyondaki yinelenen değerleri kaldırmak, üyelik testleri yapmak veya iki set arasındaki matematiksel küme işlemlerini (birleşim, kesişim, fark vb.) gerçekleştirmek için son derece kullanışlıdır. Bu makale, Python set'lerinin temel kullanımını, sözdizimini ve pratik uygulamalarını detaylandıracaktır.
set'ler, süslü parantezler {} kullanılarak veya set() yapıcı fonksiyonu aracılığıyla oluşturulabilir. Boş bir set oluşturmak için set() fonksiyonu kullanılmalıdır, çünkü {} boş bir sözlük (dict) oluşturur.
Bir set oluşturmanın iki ana yolu vardır:
Literaller Kullanarak: Virgülle ayrılmış elemanları süslü parantezler içine alarak bir set oluşturabilirsiniz. Örnek: {"elma", "muz", "kiraz"}. Bu yöntem, başlangıçta elemanları olan bir set oluşturmak için idealdir.
set() Yapıcı Fonksiyonunu Kullanarak: Bir iterable (örneğin, liste, tuple, string) bir set'e dönüştürmek için set() fonksiyonunu kullanabilirsiniz. Örnek: set(["elma", "muz"]). Boş bir set oluşturmak için yalnızca set() kullanılmalıdır. {} kullanımı boş bir sözlük oluşturur.
set'lerin temel özellikleri şunlardır:
Benzersiz Elemanlar: Bir set yalnızca benzersiz elemanlar içerebilir. Yinelenen elemanlar eklenmeye çalışıldığında, set bunları otomatik olarak görmezden gelir.
Sırasız: set elemanlarının belirli bir sırası yoktur. Her çalıştırmada elemanların sırası değişebilir ve indeksleme yoluyla elemanlara erişilemez.
Değiştirilebilir (Mutable): Bir set oluşturulduktan sonra eleman ekleyebilir veya silebilirsiniz. Ancak set'in kendisi değiştirilebilirken, elemanları hashable olmalıdır. Yani, set elemanları listeler veya başka set'ler gibi değiştirilebilir nesneler olamaz.
1. set Oluşturma ve Yinelenen Elemanları Kaldırma:
# Süslü parantezlerle set oluşturma
meyveler = {"elma", "muz", "kiraz", "elma"}
print(f"Meyveler seti: {meyveler}")
# set() fonksiyonu ile liste üzerinden set oluşturma
sayilar_listesi = [1, 2, 2, 3, 4, 4, 5]
sayilar_seti = set(sayilar_listesi)
print(f"Sayılar seti: {sayilar_seti}")
# Boş set oluşturma
bos_set = set()
print(f"Boş set: {bos_set}")
# Hata: {} boş bir sözlük oluşturur
bos_sozluk = {}
print(f"Boş süslü parantez: {type(bos_sozluk)}")
2. set Elemanlarına Ekleme ve Silme:
renkler = {"kırmızı", "mavi"}
print(f"Orijinal renkler seti: {renkler}")
# add() metodu ile eleman ekleme
renkler.add("yeşil")
print(f"add() sonrası: {renkler}")
# Mevcut bir elemanı tekrar ekleme (değişiklik olmaz)
renkler.add("kırmızı")
print(f"Tekrar add() sonrası: {renkler}")
# update() metodu ile birden fazla eleman ekleme (iterable kullanarak)
renkler.update(["sarı", "mor", "mavi"])
print(f"update() sonrası: {renkler}")
# remove() metodu ile eleman silme (eleman yoksa KeyError verir)
renkler.remove("mavi")
print(f"remove() sonrası: {renkler}")
# discard() metodu ile eleman silme (eleman yoksa hata vermez)
renkler.discard("turuncu")
print(f"discard() sonrası (olmayan eleman): {renkler}")
# pop() metodu ile rastgele bir eleman silme ve döndürme
silinen_renk = renkler.pop()
print(f"pop() ile silinen: {silinen_renk}, Kalan renkler: {renkler}")
# clear() metodu ile tüm elemanları silme
renkler.clear()
print(f"clear() sonrası: {renkler}")
3. set Üzerinde Küme İşlemleri:
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
# Birleşim (Union): | operatörü veya union() metodu
birlesim = set1 | set2
print(f"Birleşim: {birlesim}") # veya set1.union(set2)
# Kesişim (Intersection): & operatörü veya intersection() metodu
kesisim = set1 & set2
print(f"Kesişim: {kesisim}") # veya set1.intersection(set2)
# Fark (Difference): - operatörü veya difference() metodu
fark1 = set1 - set2 # set1'de olup set2'de olmayanlar
print(f"Set1 - Set2 farkı: {fark1}") # veya set1.difference(set2)
fark2 = set2 - set1 # set2'de olup set1'de olmayanlar
print(f"Set2 - Set1 farkı: {fark2}") # veya set2.difference(set1)
# Simetrik Fark (Symmetric Difference): ^ operatörü veya symmetric_difference() metodu
# Her iki sette de olup kesişimde olmayanlar
simetrik_fark = set1 ^ set2
print(f"Simetrik Fark: {simetrik_fark}") # veya set1.symmetric_difference(set2)
# Alt Küme (Subset) ve Üst Küme (Superset) Testleri
set_a = {1, 2}
set_b = {1, 2, 3, 4}
print(f"Set A, Set B'nin alt kümesi mi? {set_a.issubset(set_b)}")
print(f"Set B, Set A'nın üst kümesi mi? {set_b.issuperset(set_a)}")
4. set Üyelik Testi:
harfler = {'a', 'b', 'c'}
print(f"'a' harfler setinde mi? {'a' in harfler}")
print(f"'d' harfler setinde mi? {'d' in harfler}")
Boş set Oluşturma: Boş bir set oluşturmak için mutlaka set() fonksiyonunu kullanın. {} boş bir sözlük oluşturur.
Sırasız Yapı: set'ler sırasızdır. Elemanların eklenme sırası korunmaz ve indeksleme (my_set[0] gibi) kullanılamaz.
Değiştirilemez Elemanlar: set elemanları hashable (değiştirilemez) olmalıdır. Bu nedenle, list'ler, dict'ler veya başka set'ler doğrudan bir set'in elemanı olamaz. Eğer değiştirilemez bir set'e ihtiyacınız varsa frozenset kullanabilirsiniz.
Performans: set'ler, elemanların benzersizliğini kontrol etmek ve üyelik testleri (in operatörü) için yüksek performans sunar, özellikle büyük veri kümelerinde.
Kullanım Alanları: Tekrarlanan elemanları kaldırma, veri temizleme, iki koleksiyon arasındaki ortak veya farklı elemanları bulma gibi senaryolarda set'ler oldukça etkilidir.
function generatorFunction(): Generator
{
yield $value;
// veya
yield $key => $value;
}
function generatorFunction(): Generator: Bu kısım, bir üreteç fonksiyonunun tanımlandığını belirtir. Fonksiyon adı herhangi bir geçerli PHP fonksiyon adı olabilir. PHP 7.0 ve sonrası için dönüş tipi ipucu olarak Generator kullanılabilir, bu fonksiyonun bir üreteç döndüreceğini açıkça belirtir.
yield $value;: Üreteçlerin kalbinde yer alan anahtar kelimedir. Bir fonksiyon içerisinde yield ifadesi kullanıldığında, PHP bu fonksiyonu otomatik olarak bir üreteç fonksiyonu olarak tanır. yield, fonksiyonun yürütülmesini duraklatır, belirtilen $value değerini çağırana geri döndürür ve fonksiyonun mevcut durumunu (yerel değişkenler, yürütme noktası vb.) korur. Bir sonraki değer istendiğinde, fonksiyon kaldığı yerden yürütülmeye devam eder.
yield $key => $value;: yield ifadesi, anahtar-değer çiftleri döndürmek için de kullanılabilir, tıpkı bir dizideki gibi. Bu, özellikle değerlerin belirli bir anahtarla ilişkilendirilmesi gereken durumlarda faydalıdır.
Bir üreteç fonksiyonu çağrıldığında, kodu hemen yürütülmez. Bunun yerine, bir Generator nesnesi döndürür. Fonksiyonun kodu ancak bu nesne üzerinde döngüye başlandığında (örneğin bir foreach döngüsü ile) adım adım yürütülür ve yield ifadeleri aracılığıyla değerler üretilir.
$i, 'ad' => 'Kullanıcı ' . $i, 'email' => 'kullanici' . $i . '@example.com'];
}
echo "Veritabanı bağlantısı kapatılıyor..." . PHP_EOL;
}
// Sadece 3 kayıt işleyelim
foreach (veritabaniKayitlari(3) as $kayit) {
echo "İşlenen kayıt ID: " . $kayit['id'] . ", Ad: " . $kayit['ad'] . PHP_EOL;
}
// Çıktı:
// Veritabanı bağlantısı açılıyor...
// Kayıt 1 çekiliyor...
// İşlenen kayıt ID: 1, Ad: Kullanıcı 1
// Kayıt 2 çekiliyor...
// İşlenen kayıt ID: 2, Ad: Kullanıcı 2
// Kayıt 3 çekiliyor...
// İşlenen kayıt ID: 3, Ad: Kullanıcı 3
// Veritabanı bağlantısı kapatılıyor...
?>Bellek Verimliliği: Üreteçlerin en büyük avantajı bellek verimliliğidir. Tüm veri setini belleğe yüklemek yerine, değerleri talep üzerine ürettikleri için büyük dosyaları veya veritabanı sonuçlarını işlerken çok daha az bellek kullanırlar.
Tek Kullanımlık Yapı: PHP'deki üreteçler, ileriye dönük (forward-only) yineleyicilerdir. Bir üreteç üzerinde döngü tamamlandığında, genellikle en başa dönüp tekrar yinelemek mümkün değildir. Eğer tekrar kullanım gerekiyorsa, üreteç fonksiyonunu tekrar çağırmanız gerekir.
yield from Kullanımı: PHP 7.0 ile birlikte gelen yield from ifadesi, bir üreteçten başka bir üretece veya Traversable nesneye yetki devretmeyi sağlar. Bu, birden fazla iç içe üreteci tek bir yerden yönetmek için kullanışlıdır.
İstisna Yönetimi: Üreteç fonksiyonları içinde istisnalar fırlatılabilir ve bunlar normal fonksiyonlarda olduğu gibi yakalanabilir. Üreteç, bir istisna fırlattığında veya sonlandığında, artık daha fazla değer üretmez.
Dönüş Değeri: PHP 7.0 ve sonrası ile üreteçler, return ifadesi ile bir nihai değer döndürebilir. Ancak bu değere doğrudan foreach döngüsü üzerinden erişilemez. Generator::getReturn() metodu ile erişilebilir ve genellikle yield from ile birlikte kullanılır.
Favicon, "favori simge" kelimelerinin kısaltması olup, bir web sitesini temsil eden küçük bir grafik simgesidir. Tarayıcı sekmelerinde, sık kullanılanlar listesinde, arama motoru sonuçlarında ve mobil cihazların ana ekranlarında görünerek web sitenizin markalaşmasında ve tanınabilirliğinde kritik bir rol oynar. Bu rehber, bir HTML belgesine favicon entegrasyonunun teknik detaylarını ve en iyi uygulamalarını adım adım açıklamaktadır.
Bir HTML belgesine favicon eklemek için, genellikle belgenin bölümüne bir etiketi yerleştirilir. Bu etiket, tarayıcıya favicon dosyasının nerede bulunduğunu ve hangi türde olduğunu bildirir.
Yukarıdaki sözdizimindeki her bir nitelik (attribute) belirli bir amaca hizmet eder:
: Bu etiket, mevcut belge ile harici bir kaynak arasındaki ilişkiyi belirtmek için kullanılır. Favicon durumunda, bu harici kaynak sitenizin simge dosyasıdır.
rel="icon": rel (ilişki) niteliği, bağlanan kaynağın geçerli belgeyle olan ilişkisini tanımlar. "icon" değeri, bağlanan URL'nin belge için bir simge olduğunu gösterir. Eski tarayıcılarla uyumluluk için bazen rel="shortcut icon" da kullanılır, ancak modern uygulamalarda rel="icon" yeterlidir.
type="image/x-icon": type niteliği, bağlanan dosyanın MIME türünü belirtir. Geleneksel favicon'lar için image/x-icon kullanılır. PNG formatındaki favicon'lar için image/png, GIF formatı için image/gif veya SVG için image/svg+xml gibi değerler de kullanılabilir.
href="/favicon.ico": href niteliği, favicon dosyasının URL'sini belirtir. Bu, bir mutlak URL (örn: https://www.example.com/favicon.ico) veya bir göreli URL (örn: /favicon.ico veya ./images/favicon.png) olabilir. Göreceli yollar genellikle daha esnektir.
Aşağıdaki örnekler, farklı senaryolarda favicon kullanımını göstermektedir.
Örnek 1: Geleneksel .ico Favicon Kullanımı
Bu, en yaygın ve geniş ölçüde desteklenen yöntemdir. Favicon dosyası genellikle web sitesinin kök dizininde bulunur.
Örnek 2: PNG Formatında Favicon Kullanımı
PNG formatı, daha iyi şeffaflık ve renk desteği sunar ve modern tarayıcılarda geniş çapta desteklenir. Dosya yolu, sitenizin dizin yapısına göre ayarlanmalıdır.
Örnek 3: Farklı Boyutlarda Favicon Sağlama
Birden fazla etiketi kullanarak, tarayıcının farklı cihazlar veya bağlamlar için en uygun simgeyi seçmesine olanak tanıyabilirsiniz. sizes niteliği, simgenin piksel cinsinden boyutlarını belirtir.
Konumlandırma: Favicon etiketi daima HTML belgesinin bölümünde yer almalıdır. Bu, tarayıcının sayfayı yüklemeden önce simgeyi keşfedip görüntülemesini sağlar.
Dosya Biçimleri: En yaygın ve uyumlu favicon biçimi .ico'dur. Ancak, .png ve .gif gibi diğer biçimler de modern tarayıcılar tarafından geniş ölçüde desteklenir. SVG formatı (image/svg+xml) ise ölçeklenebilirlik avantajı sunar ancak tüm tarayıcılarda tam destek henüz yaygın değildir.
Tarayıcı Önbelleği: Tarayıcılar favicon'ları agresif bir şekilde önbelleğe alır. Bir favicon'u güncellediğinizde, değişikliklerin hemen görünmeyebileceğini unutmayın. Tarayıcı önbelleğini temizlemek veya yeni bir dosya adı (örn: favicon-v2.ico) kullanmak sorunu çözebilir.
Yol Belirtimi: Favicon dosyasının yolunu (href niteliği) doğru bir şekilde belirttiğinizden emin olun. Yanlış bir yol, simgenin yüklenmemesine neden olur.
Varsayılan Davranış: Eğer herhangi bir etiketi belirtilmezse, çoğu tarayıcı otomatik olarak web sitesinin kök dizininde favicon.ico adında bir dosya arar.
Çoklu Favicon'lar: Birden fazla etiketi kullanarak farklı boyutlarda veya formatlarda simgeler sağlayabilirsiniz. Tarayıcı, kullanıcının cihazına ve tarayıcı ayarlarına en uygun olanı otomatik olarak seçecektir.
Cascading Style Sheets (CSS), web sayfalarının görsel sunumunu kontrol eden temel bir dildir. Bu kapsamda, bir web sayfasının okunabilirliğini ve estetiğini doğrudan etkileyen yazı tiplerinin (fonts) yönetimi kritik bir rol oynar. CSS, geliştiricilere yazı tiplerini tanımlama, boyutlandırma, ağırlıklandırma ve stillendirme konusunda geniş bir kontrol mekanizması sunar. Bu makale, CSS dilinde yazı tipi özelliklerinin kullanımı, sözdizimi ve pratik uygulamaları üzerine odaklanmaktadır.
CSS'te yazı tipi özelliklerini tanımlamak için birden fazla bireysel özellik kullanılabileceği gibi, tüm bu özellikleri tek bir deklarasyonda birleştiren bir kısayol (shorthand) özelliği olan font da mevcuttur. Bireysel özellikler şunlardır:
font-family: Yazı tipinin adını veya genel bir ailesini belirtir.
font-size: Yazı tipinin boyutunu ayarlar.
font-weight: Yazı tipinin kalınlığını (ağırlığını) belirler.
font-style: Yazı tipinin stilini (normal, italik, eğik) belirler.
line-height: Satır yüksekliğini ayarlar.
font-variant: Yazı tipinin küçük harf varyantlarını (örneğin, küçük büyük harfler) etkinleştirir.
font-stretch: Yazı tipinin genişliğini ayarlar (yalnızca belirli yazı tiplerinde desteklenir).
Kısayol font özelliği ise aşağıdaki sırayla değerleri kabul eder:
font: / ;
Her bir yazı tipi özelliğinin işlevi ve kabul ettiği değerler aşağıda detaylandırılmıştır:
font-family
Bu özellik, elementin içeriği için tercih edilen yazı tipini veya yazı tipi ailesini belirtir. Birden fazla yazı tipi belirterek bir yedekleme (fallback) zinciri oluşturmak önemlidir. Tarayıcı, listedeki ilk mevcut yazı tipini kullanacaktır.
p {
font-family: "Helvetica Neue", Helvetica, Arial, sans-serif;
}
Genel yazı tipi aileleri (serif, sans-serif, monospace, cursive, fantasy) her zaman listenin sonunda yer almalıdır.
font-size
Yazı tipinin boyutunu belirler. Çeşitli birimler kullanılabilir:
Mutlak Boyutlar: xx-small, x-small, small, medium, large, x-large, xx-large. Kullanıcının varsayılan yazı tipi boyutuna göre değişir.
Göreceli Boyutlar: smaller, larger. Ebeveyn elementin yazı tipi boyutuna göre ayarlama yapar.
Uzunluk Birimleri: px (piksel), em (ebeveynin yazı tipi boyutuna göre), rem (kök elementin yazı tipi boyutuna göre), vw (viewport genişliğine göre), vh (viewport yüksekliğine göre). Esneklik ve erişilebilirlik için em ve rem tercih edilir.
Yüzde: %. Ebeveyn elementin yazı tipi boyutuna göre yüzde cinsinden belirtir.
h1 {
font-size: 2.5rem; /* Kök elementin font boyutunun 2.5 katı */
}
p {
font-size: 16px; /* Sabit piksel boyutu */
}
font-weight
Yazı tipinin kalınlığını (ağırlığını) ayarlar. Kabul ettiği değerler şunlardır:
Anahtar Kelimeler: normal (genellikle 400), bold (genellikle 700).
Sayısal Değerler: 100'den 900'e kadar, 100'ün katları şeklinde. Tüm yazı tipleri bu aralıktaki her ağırlığı desteklemeyebilir.
Göreceli Değerler: lighter, bolder. Ebeveyn elementin ağırlığına göre.
strong {
font-weight: bold;
}
.heading-light {
font-weight: 300;
}
font-style
Yazı tipinin stilini belirler. Yaygın değerler:
normal: Normal metin.
italic: İtalik metin. Yazı tipinin gerçek italik versiyonu varsa kullanılır.
oblique: Eğik metin. Yazı tipinin gerçek italik versiyonu yoksa, normal metin eğik bir şekilde taklit edilir.
em {
font-style: italic;
}
line-height
Metin satırları arasındaki dikey boşluğu ayarlar. Değerler:
Sayısal Değer: Örnek: 1.5. Elementin font-size değerinin 1.5 katı anlamına gelir. En çok tercih edilen yöntemdir.
Uzunluk Birimi: Örnek: 20px, 1.2em.
Yüzde: Örnek: 150%. Elementin font-size değerinin yüzdesi.
normal: Tarayıcının varsayılan değeri.
p {
line-height: 1.6; /* Font boyutunun 1.6 katı */
}
font-variant
Yazı tipinin küçük büyük harf (small-caps) gibi özel varyantlarını belirler. En yaygın değeri small-caps'dir.
.caps-text {
font-variant: small-caps;
}
Aşağıdaki örnekler, farklı yazı tipi özelliklerinin CSS'te nasıl kullanıldığını göstermektedir.
Örnek 1: Temel Yazı Tipi Tanımlaması
/* HTML */
Bu paragraf, temel yazı tipi özellikleriyle stilize edilmiştir.
/* CSS */
.basic-text {
font-family: Georgia, serif;
font-size: 18px;
font-weight: normal;
font-style: normal;
line-height: 1.5;
color: #333;
}
Örnek 2: Kısayol font Özelliği Kullanımı
/* HTML */
Kısayol ile Stilize Edilmiş Başlık
/* CSS */
.shorthand-heading {
/* font-style | font-variant | font-weight | font-size/line-height | font-family */
font: italic small-caps bold 2em/1.2 "Times New Roman", Times, serif;
color: #0056b3;
}
Örnek 3: Web Fontu Entegrasyonu (Google Fonts)
Harici bir kaynaktan yazı tipi kullanmak için önce bu yazı tipini projenize dahil etmeniz gerekir. Aşağıdaki örnekte Google Fonts'tan 'Roboto' yazı tipinin nasıl kullanılacağı gösterilmiştir.
/* HTML (head bölümüne eklenir) */
Bu metin, harici bir web fontu olan Roboto ile stilize edilmiştir.
/* CSS */
.webfont-text {
font-family: 'Roboto', sans-serif;
font-size: 1.2rem;
font-weight: 400;
line-height: 1.7;
color: #555;
}
Yedekleme Yazı Tipleri: font-family özelliğinde her zaman genel bir yazı tipi ailesiyle (serif, sans-serif, monospace) biten bir yedekleme zinciri kullanın. Bu, kullanıcının sisteminde belirtilen ilk yazı tipi bulunamazsa, tarayıcının benzer bir alternatif bulmasını sağlar.
Erişilebilirlik ve Esneklik: Yazı tipi boyutları için piksel (px) yerine em veya rem gibi göreceli birimler kullanmak, kullanıcının tarayıcı ayarlarını veya cihazının ekran boyutunu dikkate alarak daha iyi bir erişilebilirlik ve duyarlılık sağlar.
Kısayol Özelliği Sırası: font kısayol özelliğini kullanırken, font-size ve line-height değerlerinin / ile ayrılması ve font-family'nin her zaman en sonda yer alması gerektiğini unutmayın. Diğer özellikler (font-style, font-variant, font-weight) herhangi bir sırayla belirtilebilir ancak genellikle yukarıda belirtilen sıra tercih edilir.
Web Font Performansı: Harici web fontları kullanırken, web sitesinin yükleme süresini etkileyebilecekleri için font dosya boyutlarını optimize etmeye dikkat edin. Yalnızca ihtiyacınız olan ağırlıkları ve stilleri yükleyin.
Desteklenmeyen Ağırlıklar/Stiller: Bir yazı tipi belirli bir ağırlığı (örneğin, 300 veya 900) veya stili (örneğin, italik) desteklemiyorsa, tarayıcı mevcut en yakın ağırlığı veya stili kullanır veya bir taklit (fake bold/italic) oluşturabilir. En iyi sonuçlar için, kullanmayı planladığınız tüm ağırlık ve stillerin yazı tipi dosyasında mevcut olduğundan emin olun.
Sabah uyandığınızda hissettiğiniz o enerji patlaması, ya da aniden bastıran hüzün... Belki de geceleri bir türlü uyuyamama haliniz ya da hiç beklemediğiniz bir anda hissettiğiniz yoğun açlık hissi. Tüm bunların arkasında ne var biliyor musunuz? Minik ama güçlü kimyasal haberciler: Hormonlar!
Hayatımızın her anını, her tepkimizi, her düşüncemizi sessizce yöneten bu moleküller, vücudumuzun gizli orkestra şefleri gibi çalışır. Karmaşık bir senfoni misali, her biri kendi görevini mükemmel bir zamanlamayla yerine getirir. Peki, bu görünmez yöneticiler hayatımızı tam olarak nasıl kontrol ediyor ve biz bu dengeyi nasıl koruyabiliriz?
Hormonlar, endokrin bezleri (tiroid, hipofiz, pankreas, böbrek üstü bezleri gibi) tarafından üretilen ve kan dolaşımına salınan kimyasal maddelerdir. Kan yoluyla vücudun farklı bölgelerindeki hedef hücrelere ulaşarak belirli mesajlar iletirler. Bu mesajlar, hücrelerin ne yapması gerektiğini söyler ve vücudun fonksiyonlarını düzenler.
Bir tür içsel iletişim ağı gibi düşünebilirsiniz. Büyümeden metabolizmaya, ruh halinden uyku düzenine, üremeden strese kadar pek çok hayati fonksiyonda rol oynarlar. Bu minik moleküllerin doğru miktarda ve doğru zamanda salgılanması, bedenimizin ve zihnimizin sağlıklı kalması için kritik öneme sahiptir.
Hayatımızdaki en belirgin etkilerden biri stresle başa çıkma şeklimizdir. Kortizol ve adrenalin (epinefrin), acil durumlarda devreye giren 'savaş ya da kaç' hormonlarıdır. Bir tehlike algıladığımızda (bu gerçek bir tehdit de olabilir, sadece zihnimizde yarattığımız bir kaygı da), vücudumuz bu hormonları hızla salgılamaya başlar.
Adrenalin, kalp atış hızımızı artırır, kanı kaslarımıza pompalar ve ani bir enerji patlaması sağlar. Kortizol ise kan şekerimizi yükselterek anlık enerji ihtiyacımızı karşılar ve iltihabı baskılamaya yardımcı olur. Bu sayede hızlı tepki vermemizi ve kendimizi korumamızı sağlarlar. Ancak modern yaşamda kronik stres, bu hormonların sürekli yüksek seyretmesine neden olabilir. Bu durum, bağışıklık sistemini zayıflatabilir, uyku sorunlarına, kilo alımına, yüksek tansiyona ve hatta hafıza problemlerine yol açabilir.
Hayatımızı kontrol eden sadece stres değil, aynı zamanda mutluluğumuz, motivasyonumuz ve sosyal bağlarımız da hormonlarla iç içedir. Serotonin, dopamin, oksitosin ve endorfin gibi hormonlar, genellikle 'mutluluk hormonları' olarak bilinir ve ruh halimizi derinden etkiler.
Serotonin: Ruh halimizi, uyku düzenimizi, iştahımızı ve sindirimimizi etkileyen önemli bir nörotransmitter ve hormondur. Düşük serotonin seviyeleri depresyon, anksiyete ve uyku bozukluklarıyla ilişkilendirilir. Güneş ışığına maruz kalmak, egzersiz yapmak ve triptofan içeren besinler (örneğin hindi, yumurta, peynir) tüketmek serotonin üretimini destekleyebilir.
Dopamin: Ödül ve motivasyon sistemiyle bağlantılıdır. Yeni bir şey öğrendiğimizde, bir hedefimize ulaştığımızda veya bir başarı elde ettiğimizde salgılanır, bize haz ve tatmin duygusu verir. Bu 'iyi hissettiren' hormon, bizi harekete geçmeye ve hedeflerimize ulaşmaya teşvik eder. Bağımlılıklarla da ilişkili olduğu bilinir.
Oksitosin: "Aşk hormonu" veya "bağlanma hormonu" olarak da bilinir. Sarılma, dokunma, sosyal bağ kurma ve cinsel yakınlık anlarında salgılanır. Güven duygusunu, empatiyi ve bağlılığı artırır. Annelerde doğum ve emzirme sırasında salgılanarak anne-bebek arasındaki bağı güçlendirir. Sosyal etkileşim ve sevgi dolu ilişkiler oksitosin seviyelerini yükseltir.
Endorfin: Vücudun doğal ağrı kesicisidir. Stres veya ağrıya tepki olarak salgılanır, aynı zamanda egzersiz yaparken (özellikle uzun süreli), kahkaha atarken veya baharatlı yiyecekler yerken de salgılanarak bize öfori ve rahatlama hissi verir. 'Koşucu yüksekliği' olarak bilinen durumun arkasındaki ana faktörlerden biridir.
Uykumuz da hormonların sıkı kontrolü altında. Melatonin, beynimizdeki epifiz bezi tarafından salgılanan bir hormondur ve vücudumuzun sirkadiyen ritmini, yani uyku-uyanıklık döngüsünü düzenler. Karanlıkta salgılanmaya başlar ve bize uyku vaktinin geldiğini haber verirken, gündüz ışığı ise melatonin üretimini baskılar.
Modern yaşamda, ekranlara maruz kalma, düzensiz uyku saatleri veya vardiyalı çalışma gibi faktörler melatonin döngümüzü bozabilir. Bu da uyku kalitemizi doğrudan etkiler, uykuya dalmakta zorlanma, yorgunluk ve genel olarak zayıf bir uyku düzeni ile sonuçlanabilir.
Enerjimiz, kilomuz ve genel vücut işleyişimiz de hormonların marifetidir. Tiroid hormonları (T3 ve T4) ve insülin bu süreçte kilit rol oynar.
Tiroid Hormonları (T3, T4): Boynumuzda bulunan tiroid bezi tarafından üretilir ve metabolizma hızımızı belirler. Vücudun enerji üretimini, sıcaklığını, kalp atış hızını ve organların çalışma hızını etkiler. Tiroid hormonlarının fazlalığı (hipertiroidi) kilo kaybı, çarpıntı ve anksiyeteye; eksikliği (hipotiroidi) ise kilo alımı, yorgunluk ve depresyona yol açabilir.
İnsülin: Pankreas tarafından salgılanan insülin, kan şekerini düzenler. Yemek yedikten sonra kan şekerimiz yükseldiğinde, insülin salgılanır ve hücrelerin glikozu enerji olarak kullanabilmesi için bir anahtar görevi görür. İnsülin direnci veya yetersiz insülin üretimi, tip 2 diyabet gibi ciddi sağlık sorunlarına neden olabilir.
Cinsiyetimiz, gelişimimiz, üreme sağlığımız ve hatta bazı davranışlarımız da bu hormonların eseridir. Östrojen ve testosteron, temel üreme hormonlarıdır ve hem kadınlarda hem de erkeklerde farklı oranlarda bulunarak çok çeşitli fonksiyonları etkiler.
Östrojen: Kadınlarda temel üreme hormonu olup, adet döngüsü, gebelik, kemik sağlığı, cilt elastikiyeti ve ruh hali üzerinde etkilidir. Ergenlik döneminde ikincil cinsel özelliklerin gelişimini sağlar. Menopoz döneminde östrojen seviyelerinin düşmesi, sıcak basmaları, kemik yoğunluğunda azalma ve ruh hali değişimleri gibi semptomlara yol açabilir. Erkeklerde de az miktarda bulunur ve bazı fizyolojik süreçlerde rol oynar.
Testosteron: Erkeklerde temel üreme hormonu olup, kas kütlesi, kemik yoğunluğu, sperm üretimi, libido ve enerji seviyeleri üzerinde etkilidir. Ergenlik döneminde ses kalınlaşması, sakal çıkması gibi ikincil cinsel özelliklerin gelişimini sağlar. Düşük testosteron seviyeleri erkeklerde yorgunluk, libido kaybı ve kas kaybına neden olabilir. Kadınlarda da az miktarda bulunarak enerji, libido ve kemik sağlığına katkıda bulunur.
Adı üzerinde, büyümemizi sağlayan bir hormondur. Hipofiz bezi tarafından salgılanan büyüme hormonu, çocuklukta boy uzamasını, kas ve kemik gelişimini destekler. Yetişkinlikte ise doku onarımı, metabolizma, kas kütlesinin korunması ve genel vücut kompozisyonu üzerinde etkilidir.
Özellikle derin uyku evrelerinde salgılanımı artar, bu yüzden kaliteli ve yeterli uyku büyüme hormonu seviyeleri için çok önemlidir. Yaşlandıkça büyüme hormonu seviyeleri doğal olarak düşer, bu da kas kütlesi kaybı ve iyileşme sürelerinin uzaması gibi etkilerle ilişkilendirilir.
Peki ya bu hassas denge bozulursa? Hormonlarımızın birinin bile fazla ya da az salgılanması, vücudumuzda domino etkisi yaratarak çok çeşitli sağlık sorunlarına yol açabilir. Hormonal dengesizlikler, yaşam kalitemizi önemli ölçüde etkileyebilir.
Örneğin, tiroid hormonlarının aşırı veya yetersiz salınımı, ani kilo değişiklikleri, yorgunluk veya kalp sorunlarına neden olabilir. Kadınlarda adet düzensizlikleri, polikistik over sendromu (PCOS), kısırlık gibi durumlar hormonal dengesizliklerle yakından ilişkilidir. Erkeklerde düşük testosteron seviyeleri ise enerji düşüklüğü, libido kaybı, kas kütlesi azalması gibi sorunlara yol açabilir. Ruh halindeki ani değişimler, anksiyete, depresyon, hafıza sorunları ve hatta cilt problemleri de hormonal dalgalanmaların bir sonucu olabilir.
Bu nedenle, vücudumuzun gönderdiği sinyallere dikkat etmek ve olası hormonal dengesizlik belirtilerinde bir uzmana danışmak büyük önem taşır.
Hormonların hayatımızdaki bu denli kritik rolünü anladıktan sonra, "Bu kadar önemli bir sistemin sağlıklı çalışması için neler yapabiliriz?" sorusu akla geliyor. İyi haber şu ki, yaşam tarzı seçimlerimizle hormon dengemizi büyük ölçüde destekleyebiliriz:
Dengeli ve Besleyici Beslenme: İşlenmiş gıdalardan, aşırı şekerden ve sağlıksız yağlardan uzak durmak hormonlar için temeldir. Yeterli protein, lif, sağlıklı yağlar (omega-3 gibi) ve bol miktarda sebze-meyve tüketmek, hormon üretimi ve dengesi için gerekli yapı taşlarını sağlar.
Düzenli Egzersiz: Haftada en az 150 dakika orta yoğunlukta veya 75 dakika yüksek yoğunlukta egzersiz yapmak, hem stres hormonlarını dengelemeye yardımcı olur hem de mutluluk hormonlarının salgılanmasını teşvik eder. Özellikle direnç egzersizleri ve kardiyo, insülin duyarlılığını artırarak metabolik sağlığı destekler.
Kaliteli ve Yeterli Uyku: En az 7-9 saat kesintisiz ve kaliteli uyku, melatonin, büyüme hormonu, kortizol ve diğer birçok hormonun düzenli salgılanması için hayati öneme sahiptir. Yatak odanızı karanlık, serin ve sessiz tutmaya özen gösterin.
Stres Yönetimi Teknikleri: Meditasyon, yoga, derin nefes egzersizleri, doğada vakit geçirmek, hobiler edinmek veya sevdiklerinizle zaman geçirmek gibi aktiviteler, kortizol seviyelerini düşürmeye ve genel ruh halinizi iyileştirmeye yardımcı olabilir.
Yeterli Su Tüketimi: Vücudun tüm kimyasal süreçleri ve hormonların taşınması için su olmazsa olmazdır. Günde en az 8-10 bardak su içmeye özen gösterin.
Toksinlerden Uzak Durma: Bazı kimyasallar (örneğin plastiklerdeki BPA, fitalatlar ve bazı pestisitler) hormon taklitçisi görevi görerek endokrin sistemimizi bozabilir. Mümkün olduğunca doğal ve organik ürünler kullanmaya, plastik kullanımını azaltmaya çalışın.
Gerekirse Uzman Desteği: Hormonal dengesizlik belirtileri yaşıyorsanız, bir doktor veya endokrinoloji uzmanına danışmak, doğru teşhis ve tedavi için en doğru adımdır.
Unutmayın, hormonlarınızın sağlıklı çalışması, genel sağlığınız, enerji seviyeniz ve yaşam kaliteniz için kritik öneme sahiptir. Vücudunuzun bu gizli orkestra şeflerine iyi bakın, onlar da size harika bir yaşam senfonisi sunsun.
JavaScript, web uygulamalarının dinamik etkileşimini sağlayan güçlü bir dil olmakla birlikte, karmaşık matematiksel hesaplamalar için de sağlam bir temel sunar. Bu bağlamda, JavaScript'in yerleşik Math nesnesi, standart matematiksel işlevleri ve sabitleri programcıların kullanımına sunarak, sayısal işlemlerin kolay ve verimli bir şekilde gerçekleştirilmesini sağlar. Bir sınıf olmamasına rağmen, Math nesnesi tüm özelliklerini ve metotlarını statik olarak sunar; bu da onun doğrudan erişilebilir olduğu ve örneklendirilmesinin gerekmediği anlamına gelir. Bu makalede, Math nesnesinin temel kullanımından gelişmiş uygulamalarına kadar uzanan çeşitli yönlerini inceleyeceğiz.
JavaScript'teki Math nesnesi, doğrudan erişilebilen statik metotlar ve özellikler içerir. Bu, Math nesnesini oluşturmanıza gerek olmadığı anlamına gelir; tüm metotlarına ve özelliklerine doğrudan Math. önekiyle erişilebilir.
Genel kullanım yapısı aşağıdaki gibidir:
Math.propertyName;
Math.methodName(arg1, arg2, ...);
Math nesnesi bir yapıcıya (constructor) sahip değildir ve tüm metotları ile özellikleri statiktir. Bu, new Math() şeklinde bir kullanımın geçersiz olduğu ve hata döndüreceği anlamına gelir. Bunun yerine, Math.PI gibi bir sabite veya Math.random() gibi bir metoda doğrudan erişilir.
Aşağıda, Math nesnesinin sıkça kullanılan bazı metotları ve özellikleri detaylı olarak açıklanmıştır:
Math.PI: Bir dairenin çevresinin çapına oranı olan pi (π) sayısının değerini döndürür.
Math.abs(x): Bir sayının mutlak değerini döndürür.
Math.round(x): Bir sayıyı en yakın tam sayıya yuvarlar. .5 durumunda yukarı yuvarlar.
Math.floor(x): Bir sayıyı her zaman aşağıya, en yakın tam sayıya yuvarlar.
Math.ceil(x): Bir sayıyı her zaman yukarıya, en yakın tam sayıya yuvarlar.
Math.random(): 0 (dahil) ile 1 (hariç) arasında rastgele bir ondalık sayı döndürür.
Math.max(x1, x2, ..., xn): Verilen sayılar arasındaki en büyük değeri döndürür.
Math.min(x1, x2, ..., xn): Verilen sayılar arasındaki en küçük değeri döndürür.
Math.pow(x, y): x sayısının y kuvvetini döndürür (xy).
Math.sqrt(x): Bir sayının karekökünü döndürür.
Math.sin(x), Math.cos(x), Math.tan(x): Trigonometrik sinüs, kosinüs ve tanjant değerlerini radyan cinsinden verilen bir açı için döndürür.
Aşağıdaki örnekler, Math nesnesinin farklı metotlarının pratik uygulamalarını göstermektedir.
Örnek 1: Temel Yuvarlama İşlemleri ve Pi Sabiti Kullanımı
// Pi (π) değerini alma
const piValue = Math.PI;
console.log("Pi değeri:", piValue); // Çıktı: Pi değeri: 3.141592653589793
// Sayı yuvarlama örnekleri
let num1 = 4.7;
let num2 = 4.3;
let num3 = 4.5;
let num4 = -4.7;
console.log("Math.round(4.7):", Math.round(num1)); // Çıktı: 5
console.log("Math.round(4.3):", Math.round(num2)); // Çıktı: 4
console.log("Math.round(4.5):", Math.round(num3)); // Çıktı: 5
console.log("Math.floor(4.7):", Math.floor(num1)); // Çıktı: 4
console.log("Math.ceil(4.3):", Math.ceil(num2)); // Çıktı: 5
console.log("Math.abs(-4.7):", Math.abs(num4)); // Çıktı: 4.7Örnek 2: Rastgele Sayı Üretimi
Math.random() metodu 0 (dahil) ile 1 (hariç) arasında bir sayı üretir. Belirli bir aralıkta rastgele tam sayı üretmek için bu metot Math.floor() ile birlikte kullanılabilir.
// 0 ile 1 arasında rastgele ondalık sayı
const randomDecimal = Math.random();
console.log("Rastgele ondalık:", randomDecimal); // Örn: 0.123456789
// 1 ile 10 arasında rastgele tam sayı (1 ve 10 dahil)
function getRandomInt(min, max) {
min = Math.ceil(min);
max = Math.floor(max);
return Math.floor(Math.random() * (max - min + 1)) + min;
}
const randomNum = getRandomInt(1, 10);
console.log("1-10 arası rastgele tam sayı:", randomNum); // Örn: 7Örnek 3: Üs Alma ve Karekök Hesaplama
// Üs alma (2^3 = 8)
const powerResult = Math.pow(2, 3);
console.log("2 üzeri 3:", powerResult); // Çıktı: 8
// Karekök alma (karekök 81 = 9)
const sqrtResult = Math.sqrt(81);
console.log("81'in karekökü:", sqrtResult); // Çıktı: 9Örnek 4: En Büyük ve En Küçük Değeri Bulma
const numbers = [10, 5, 20, 8, 15];
// Array'deki en büyük ve en küçük değeri bulmak için spread operatörü (...) kullanılır.
const maxVal = Math.max(...numbers);
const minVal = Math.min(...numbers);
console.log("En büyük değer:", maxVal); // Çıktı: 20
console.log("En küçük değer:", minVal); // Çıktı: 5
// Doğrudan sayılarla da kullanılabilir
console.log("max(1, 5, 2, 9):", Math.max(1, 5, 2, 9)); // Çıktı: 9Statik Nesne: Math bir nesne olmasına rağmen, bir yapıcıya sahip değildir ve doğrudan new Math() ile örneklendirilemez. Tüm metotları ve özellikleri statiktir ve doğrudan Math.metotAdı() veya Math.özellikAdı şeklinde çağrılır.
Radyan Kullanımı: Trigonometrik fonksiyonlar (Math.sin(), Math.cos(), Math.tan()) açıları derece yerine radyan cinsinden bekler. Dereceyi radyana çevirmek için derece * (Math.PI / 180) formülünü kullanabilirsiniz.
Math.random() Aralığı: Math.random() her zaman 0 (dahil) ile 1 (hariç) arasında bir değer döndürür. Belirli bir aralıkta (min, max) tam sayı elde etmek için genellikle Math.floor(Math.random() * (max - min + 1)) + min formülü kullanılır.
Floating-Point Hassasiyeti: JavaScript, diğer programlama dillerinde olduğu gibi, kayan noktalı sayılarla (floating-point numbers) çalışırken hassasiyet sorunları yaşayabilir. Bu durum, özellikle ondalık sayılarla yapılan karmaşık hesaplamalarda beklenmedik sonuçlara yol açabilir. Örneğin, 0.1 + 0.2 doğrudan 0.3 yerine 0.30000000000000004 sonucunu verebilir.
Type Coercion: Math metotları, kendisine geçirilen argümanları otomatik olarak sayısal tiplere dönüştürmeye çalışır. Geçersiz bir değer (örneğin, bir string) geçirildiğinde NaN (Not-a-Number) döndürebilir.
SQL (Structured Query Language), veritabanlarındaki büyük veri kümelerini yönetmek ve analiz etmek için temel bir araçtır. Bu analizin kritik bir parçası, veri gruplarını özetlemeye ve tek bir anlamlı değer döndürmeye yarayan Aggregate Functions (Toplama Fonksiyonları) olarak bilinen özel işlevlerdir. Bu fonksiyonlar, bir sütundaki tüm değerlerin toplamını, ortalamasını, en büyük veya en küçük değerini veya toplam satır sayısını hesaplamak gibi işlemleri gerçekleştirmek için kullanılır. Bu makale, SQL Aggregate Functions'ın temel prensiplerini, sözdizimini, pratik kullanım örneklerini ve önemli notları kapsamlı bir şekilde açıklamaktadır.
SQL Aggregate Functions, genellikle SELECT ifadesi içinde, isteğe bağlı olarak GROUP BY, WHERE ve HAVING yan tümceleriyle birlikte kullanılır. Genel sözdizimi aşağıdaki gibidir:
SELECT
kolon_adı_1,
AGGREGATE_FUNCTION(kolon_adı_2) AS takma_ad
FROM
tablo_adı
WHERE
koşul_filtreleme_satırlar
GROUP BY
kolon_adı_1
HAVING
koşul_filtreleme_gruplar
ORDER BY
kolon_adı_1;Yukarıdaki sözdizimindeki her bir bileşen, agrega fonksiyonlarının nasıl çalıştığını anlamak için hayati öneme sahiptir:
SELECT: Sorgunuzdan döndürülecek sütunları belirtir. Agrega fonksiyonları bu bölümde kullanılır ve genellikle bir AS anahtar kelimesi ile bir takma ad (alias) atanır.
AGGREGATE_FUNCTION(kolon_adı_2): Veriler üzerinde işlem yapacak olan toplama fonksiyonudur. En yaygın kullanılanlar şunlardır:
COUNT(): Belirli bir sütundaki veya tüm satırlardaki eleman sayısını döndürür. COUNT(*) tüm satırları sayar, COUNT(kolon_adı) NULL olmayan değerleri sayar, COUNT(DISTINCT kolon_adı) ise benzersiz NULL olmayan değerleri sayar.
SUM(): Belirli bir sayısal sütundaki tüm değerlerin toplamını hesaplar.
AVG(): Belirli bir sayısal sütundaki tüm değerlerin ortalamasını hesaplar.
MIN(): Belirli bir sütundaki en küçük değeri döndürür.
MAX(): Belirli bir sütundaki en büyük değeri döndürür.
FROM tablo_adı: Verilerin çekileceği tablonun adını belirtir.
WHERE koşul_filtreleme_satırlar: Agrega işlemi yapılmadan önce satırları filtrelemek için kullanılır. Bu yan tümce, gruplama yapılmadan önceki bireysel satırlara uygulanır.
GROUP BY kolon_adı_1: Satırları bir veya daha fazla sütuna göre gruplar. Agrega fonksiyonu daha sonra her grup için ayrı ayrı uygulanır ve her gruptan tek bir özet satırı döndürülür. SELECT listesinde agrega fonksiyonu dışında kalan her sütunun GROUP BY listesinde de yer alması gerekir.
HAVING koşul_filtreleme_gruplar: GROUP BY ile oluşturulan grupları filtrelemek için kullanılır. WHERE yan tümcesinin aksine, HAVING ifadesi agrega fonksiyonlarının sonuçlarına dayalı filtreleme yapabilir.
ORDER BY kolon_adı_1: Sonuç kümesini belirli bir sütuna veya agrega sonucuna göre sıralar.
Aşağıdaki örnekler için, bir şirketin satış verilerini içeren Satislar adlı bir tablo ve çalışan bilgilerini içeren Calisanlar adlı bir tablo kullanıldığını varsayalım.
Satislar Tablo Yapısı:
CREATE TABLE Satislar (
SatisID INT PRIMARY KEY,
UrunID INT,
MusteriID INT,
SatisTarihi DATE,
Miktar DECIMAL(10, 2),
Adet INT
);
INSERT INTO Satislar (SatisID, UrunID, MusteriID, SatisTarihi, Miktar, Adet) VALUES
(1, 101, 1, '2023-01-15', 150.75, 2),
(2, 102, 2, '2023-01-15', 200.00, 1),
(3, 101, 1, '2023-01-16', 75.50, 1),
(4, 103, 3, '2023-01-16', 300.25, 3),
(5, 102, 1, '2023-01-17', 120.00, 1),
(6, 101, 4, '2023-01-17', 50.00, 1),
(7, 104, 2, '2023-01-18', 450.00, 2),
(8, 101, NULL, '2023-01-18', 100.00, 1);
Calisanlar Tablo Yapısı:
CREATE TABLE Calisanlar (
CalisanID INT PRIMARY KEY,
Ad VARCHAR(50),
Soyad VARCHAR(50),
Departman VARCHAR(50),
Maas DECIMAL(10, 2)
);
INSERT INTO Calisanlar (CalisanID, Ad, Soyad, Departman, Maas) VALUES
(1, 'Ayşe', 'Yılmaz', 'IT', 60000.00),
(2, 'Can', 'Demir', 'Satış', 55000.00),
(3, 'Elif', 'Kaya', 'IT', 62000.00),
(4, 'Mert', 'Arslan', 'Pazarlama', 58000.00),
(5, 'Zeynep', 'Şahin', 'Satış', 59000.00),
(6, 'Deniz', 'Çelik', 'Pazarlama', 57000.00);
COUNT(*))Bu sorgu, Satislar tablosundaki toplam satış kaydını döndürür.
SELECT
COUNT(*) AS ToplamSatisSayisi
FROM
Satislar;COUNT(kolon_adı))MusteriID değeri olan (yani NULL olmayan) satışların sayısını bulur.
SELECT
COUNT(MusteriID) AS MusteriliSatisSayisi
FROM
Satislar;COUNT(DISTINCT kolon_adı))Kaç farklı müşterinin satış yaptığını gösterir.
SELECT
COUNT(DISTINCT MusteriID) AS BenzersizMusteriSayisi
FROM
Satislar;SUM())Tüm satışların toplam miktarını döndürür.
SELECT
SUM(Miktar) AS ToplamSatisMiktari
FROM
Satislar;AVG())Tüm satışların ortalama miktarını döndürür.
SELECT
AVG(Miktar) AS OrtalamaSatisMiktari
FROM
Satislar;MAX(), MIN())En yüksek ve en düşük satış miktarını aynı sorguda bulur.
SELECT
MAX(Miktar) AS EnYuksekSatisMiktari,
MIN(Miktar) AS EnDusukSatisMiktari
FROM
Satislar;GROUP BY)Bu sorgu, her bir UrunID için toplam satış miktarını ve satılan toplam adedi hesaplar.
SELECT
UrunID,
SUM(Miktar) AS ToplamMiktar,
SUM(Adet) AS ToplamAdet
FROM
Satislar
GROUP BY
UrunID
ORDER BY
UrunID;HAVING)Sadece toplam satış miktarı 200'den büyük olan ürünleri listeler.
SELECT
UrunID,
SUM(Miktar) AS ToplamMiktar
FROM
Satislar
GROUP BY
UrunID
HAVING
SUM(Miktar) > 200
ORDER BY
ToplamMiktar DESC;GROUP BY ve Farklı Fonksiyonlar)Her departmandaki ortalama maaşı ve çalışan sayısını gösterir.
SELECT
Departman,
AVG(Maas) AS OrtalamaMaas,
COUNT(CalisanID) AS CalisanSayisi
FROM
Calisanlar
GROUP BY
Departman
HAVING
COUNT(CalisanID) > 1 -- Birden fazla çalışanı olan departmanlar
ORDER BY
OrtalamaMaas DESC;NULL Değerler: SUM(), AVG(), MIN(), MAX() gibi çoğu agrega fonksiyonu, hesaplamalarında NULL değerleri göz ardı eder. COUNT(kolon_adı) da yalnızca NULL olmayan değerleri sayarken, COUNT(*) NULL değerleri içeren satırları da sayar.
WHERE vs. HAVING: WHERE yan tümcesi, gruplama yapılmadan önce bireysel satırları filtreler. HAVING yan tümcesi ise, GROUP BY işlemi uygulandıktan sonra oluşan grupları filtrelemek için kullanılır ve agrega fonksiyonlarının sonuçlarını kullanabilir.
GROUP BY Kısıtlamaları: SELECT ifadesinde agrega fonksiyonu kullanmıyorsanız ve GROUP BY kullanıyorsanız, SELECT listesindeki tüm sütunların GROUP BY listesinde de yer alması gerekir (veya agrega fonksiyonları içinde olmaları gerekir). Aksi takdirde, SQL veritabanı hangi değerin her grup için döndürüleceğini bilemez ve bir hata verir.
DISTINCT Anahtar Kelimesi: COUNT(DISTINCT kolon_adı), SUM(DISTINCT kolon_adı), AVG(DISTINCT kolon_adı) gibi kullanımlar, yalnızca belirtilen sütundaki benzersiz değerler üzerinde işlem yapar. Örneğin, SUM(DISTINCT Miktar), aynı miktara sahip birden fazla satış olsa bile her miktarı yalnızca bir kez toplar.
Performans: Büyük veri kümelerinde agrega fonksiyonlarının kullanımı, özellikle GROUP BY ve ORDER BY ile birleştiğinde performans üzerinde etkili olabilir. Uygun indeksleme, sorgu performansını artırmada önemli rol oynar.
PHP 8.0 ile birlikte dile eklenen öznitelikler (attributes), kodunuza yapısal meta veriler eklemenin modern ve deklaratif bir yolunu sunar. Bu özellik, daha önce genellikle DocBlock yorumları aracılığıyla sağlanan bilgilerin, doğrudan dilin kendisi tarafından tanınabilen ve yansıma (reflection) API'si aracılığıyla erişilebilen bir formatta tanımlanmasına olanak tanır. Öznitelikler, sınıflara, yöntemlere, özelliklere, fonksiyonlara ve hatta parametrelere atanabilir, bu da framework'ler, ORM'ler, validasyon sistemleri ve diğer kod analiz araçları için güçlü ve tip güvenli bir mekanizma sağlar.
PHP'de bir öznitelik, köşeli parantezler (#[ ve ]) içine alınmış bir isim ve isteğe bağlı olarak parametreler ile tanımlanır. Bu isim, aslında bir PHP sınıfının adıdır ve bu sınıfın bir örneği, özniteliğin uygulandığı elemanla ilişkilendirilir.
Bir özniteliğin kendisi, #[Attribute] özniteliği ile işaretlenmiş basit bir PHP sınıfıdır. Bu işaretleme, PHP motoruna ilgili sınıfın bir öznitelik olarak kullanılabileceğini bildirir.
Öznitelik Sınıfı Tanımlama: Bir öznitelik oluşturmak için, #[Attribute] özniteliğini kullanarak bir sınıf tanımlamanız gerekir. Bu sınıf, özniteliğin davranışını veya içerdiği verileri belirler.
message = $message;
}
}
Hedef Kısıtlamaları: #[Attribute] özniteliğine parametreler geçirilerek, özniteliğin hangi türdeki elemanlara (sınıf, yöntem, özellik vb.) uygulanabileceği kısıtlanabilir. Bu, Attribute::TARGET_CLASS, Attribute::TARGET_METHOD, Attribute::TARGET_PROPERTY, Attribute::TARGET_FUNCTION, Attribute::TARGET_PARAMETER ve Attribute::TARGET_ALL gibi sabitlerle yapılır.
Tekrarlanabilir Öznitelikler: Varsayılan olarak, bir elemana aynı öznitelikten yalnızca bir tane uygulanabilir. Ancak, Attribute::IS_REPEATABLE sabiti kullanılarak bir özniteliğin birden çok kez uygulanmasına izin verilebilir.
name = $name;
}
}
Parametreler: Öznitelik sınıfları, constructor'ları aracılığıyla parametre alabilirler. Bu parametreler, özniteliği uygularken doğrudan parantez içinde belirtilir ve özniteliğin davranışını özelleştirmek için kullanılır.
Aşağıdaki örnekler, PHP özniteliklerinin nasıl tanımlandığını ve yansıma API'si (Reflection API) kullanılarak nasıl okunduğunu göstermektedir.
Örnek 1: Basit Bir Yönlendirme (Routing) Özniteliği
Bu örnek, bir web uygulamasında yöntemleri belirli URL yollarına bağlamak için kullanılabilecek basit bir #[Route] özniteliği tanımlar ve ardından bu özniteliği yansıma ile okur.
path = $path;
$this->methods = $methods;
}
}
class ApiController
{
#[Route("/api/users", "GET")]
public function getUsers(): array
{
return ['John Doe', 'Jane Smith'];
}
#[Route("/api/users/{id}", "GET")]
public function getUser(int $id): string
{
return "User ID: {$id}";
}
}
// Öznitelikleri yansıma ile okuma
$reflector = new ReflectionClass(ApiController::class);
foreach ($reflector->getMethods() as $method) {
echo "Metot: " . $method->getName() . "
";
foreach ($method->getAttributes(Route::class) as $attribute) {
$route = $attribute->newInstance(); // Öznitelik sınıfının bir örneğini oluşturur
echo " Yol: " . $route->path . ", Metotlar: " . implode(", ", $route->methods) . "
";
}
}
/* Çıktı:
Metot: getUsers
Yol: /api/users, Metotlar: GET
Metot: getUser
Yol: /api/users/{id}, Metotlar: GET
*/
Örnek 2: Validasyon (Doğrulama) Özniteliği ve Hedef Kısıtlaması
Bu örnek, bir özelliğin minimum ve maksimum değerler arasında olmasını gerektiren bir #[Range] özniteliği tanımlar ve bu özniteliği yalnızca özelliklere uygulanacak şekilde kısıtlar.
min = $min;
$this->max = $max;
}
}
class Product
{
#[Range(min: 0, max: 100)]
public int $stock;
#[Range(min: 1, max: 999)]
public float $price;
public function __construct(int $stock, float $price)
{
$this->stock = $stock;
$this->price = $price;
}
}
// Öznitelikleri yansıma ile okuma
$reflector = new ReflectionClass(Product::class);
foreach ($reflector->getProperties() as $property) {
echo "Özellik: " . $property->getName() . "
";
foreach ($property->getAttributes(Range::class) as $attribute) {
$range = $attribute->newInstance();
echo " Min: " . $range->min . ", Max: " . $range->max . "
";
}
}
/* Çıktı:
Özellik: stock
Min: 0, Max: 100
Özellik: price
Min: 1, Max: 999
*/
Örnek 3: Tekrarlanabilir Öznitelikler
Bu örnek, bir sınıfın birden fazla etiketle işaretlenmesine olanak tanıyan tekrarlanabilir bir #[Tag] özniteliği tanımlar.
name = $name;
}
}
#[Tag("Veritabanı")]
#[Tag("ORM")]
#[Tag("PHP 8")]
class UserRepository
{
// ...
}
// Öznitelikleri yansıma ile okuma
$reflector = new ReflectionClass(UserRepository::class);
echo "Sınıf: " . $reflector->getName() . "
";
foreach ($reflector->getAttributes(Tag::class) as $attribute) {
$tag = $attribute->newInstance();
echo " Etiket: " . $tag->name . "
";
}
/* Çıktı:
Sınıf: UserRepository
Etiket: Veritabanı
Etiket: ORM
Etiket: PHP 8
*/
Performans Avantajı: Öznitelikler, DocBlock yorumlarının aksine, PHP'nin derleme aşamasında işlenir. Bu, çalışma zamanında ek bir ayrıştırma (parsing) yükü oluşturmadıkları anlamına gelir ve performans açısından DocBlock tabanlı çözümlerden daha verimlidir.
Kullanım Alanları: Öznitelikler, framework'lerde (örneğin, yönlendirme, ORM eşlemesi), validasyon kuralı tanımlarında, seri hale getirme (serialization) işlemlerinde, kod üretimi (code generation) araçlarında ve IDE entegrasyonlarında yaygın olarak kullanılır.
Yansıma API'si (Reflection API): Özniteliklere erişim yalnızca PHP'nin Yansıma API'si aracılığıyla mümkündür. ReflectionClass::getAttributes(), ReflectionMethod::getAttributes() gibi yöntemler, uygulanan öznitelikleri almanızı sağlar.
Ad Alanları (Namespaces): Öznitelik sınıflarını kullanırken, tıpkı diğer sınıflarda olduğu gibi ad alanlarını (namespaces) doğru bir şekilde belirtmeli veya use ifadesiyle içe aktarmalısınız.
PHP Sürümü: Öznitelikler özelliği sadece PHP 8.0 ve sonraki sürümlerde mevcuttur. Daha önceki PHP sürümlerinde kullanılmaya çalışıldığında ayrıştırma hatasına neden olur.
Constructor Bağımsız Değişkenleri: Öznitelik sınıflarının constructor'ları, tip ipuçları (type hints) ile tanımlanan bağımsız değişkenleri kabul edebilir. Bu, özniteliğe geçirilen değerlerin tip güvenliğini sağlar.
Sözdizimi Esnekliği: Öznitelikler, tek bir satırda veya birden fazla satıra yayılarak tanımlanabilir, bu da kod okunabilirliğini artırır.
Web belgelerinin temel bileşenlerinden biri olan HTML sayfa başlığı, kullanıcı deneyimi ve arama motoru optimizasyonu (SEO) açısından kritik bir öneme sahiptir. Bir web sayfasının başlığını tanımlayan bu bileşen, tarayıcı sekmelerinde, arama motoru sonuç sayfalarında (SERP'ler) ve yer imlerinde görünen metindir. Bu makale,
Başlık Metni:
Yukarıdaki örnekte, sayfanın "Hakkımızda" bölümü olduğu ve "Şirketinizin Adı" adlı bir kuruluşa ait olduğu net bir şekilde belirtilmiştir. Bu, kullanıcıların ve arama motorlarının sayfanın içeriğini kolayca anlamasına yardımcı olur.
Örnek 2: Blog Yazısı İçin Dinamik Başlık Yapısı
Bir blog veya dinamik içerik platformu için başlıklar genellikle içeriğin kendisinden türetilir. Aşağıdaki yapı, bir blog yazısının başlığını ve genel blog adını birleştirerek nasıl bir
Burada, makale başlığı (`HTML5'te Yeni Özellikler: Detaylı İnceleme`) ve blog adı (`Teknik Blog`) birleştirilerek hem bilgilendirici hem de marka bilinirliği sağlayan bir başlık oluşturulmuştur. Bu yaklaşım, dinamik olarak oluşturulan sayfalarda yaygın olarak kullanılır.
Tekillik: Her web sayfası için Adınızı Girin (GET)
Şimdi de islem.php dosyasında bu veriyi işleyelim:
Merhaba, " . $ad . "!";
} else {
echo "Lütfen adınızı girin.
";
}
?>$_POST KullanımıBu örnek, bir form aracılığıyla HTTP POST metodu ile gönderilen kullanıcı adını ve şifresini nasıl işleyeceğimizi gösterir. Yine bir HTML formu ile başlayalım:
POST Örneği
Giriş Yap (POST)
Şimdi de giris.php dosyasında bu veriyi işleyelim:
Hoş geldiniz, " . $kullanici_adi . "!";
} else {
echo "Kullanıcı adı veya şifre yanlış.
";
}
} else {
echo "Lütfen kullanıcı adı ve şifrenizi girin.
";
}
?>$_SESSION KullanımıBu örnek, oturum değişkenlerini kullanarak kullanıcı girişini simüle eder ve kullanıcının adını oturumda saklar.
Oturum başlatıldı ve 'kullanici_adi' Mehmet olarak ayarlandı.";
echo "";
?>
Oturumdaki kullanıcı adı: " . htmlspecialchars($_SESSION['kullanici_adi']) . "";
} else {
echo "Oturumda 'kullanici_adi' bulunamadı.
";
}
echo "";
?>
Oturum sonlandırıldı.";
echo "";
?>$_SERVER KullanımıBu örnek, $_SERVER değişkeni aracılığıyla sunucu ve istek bilgilerine nasıl erişileceğini gösterir.
Sunucu Bilgileri";
echo "İstek Metodu: " . $_SERVER['REQUEST_METHOD'] . "
";
echo "Sunucu Adı: " . $_SERVER['SERVER_NAME'] . "
";
echo "Sunucu Yazılımı: " . $_SERVER['SERVER_SOFTWARE'] . "
";
echo "İstek URI: " . $_SERVER['REQUEST_URI'] . "
";
echo "Kullanıcının IP Adresi: " . $_SERVER['REMOTE_ADDR'] . "
";
// Tüm _SERVER değişkenlerini görmek için:
// echo "";
// print_r($_SERVER);
// echo "
";
?>Veri Doğrulama ve Filtreleme: Kullanıcıdan gelen tüm girişler ($_GET, $_POST, $_COOKIE vb.), herhangi bir işlem yapılmadan veya veritabanına kaydedilmeden önce mutlaka doğrulanmalı ve filtrelenmelidir. Bu, SQL enjeksiyonu, XSS (Cross-Site Scripting) ve diğer güvenlik açıklarına karşı kritik bir önlemdir. PHP'nin htmlspecialchars(), strip_tags(), filter_var() gibi fonksiyonları bu amaçla kullanılabilir.
$_REQUEST Kullanımından Kaçınma: Değişken önceliği ayarları nedeniyle $_REQUEST kullanımı, beklenmedik sonuçlara yol açabilir. Mümkün olduğunca spesifik olarak $_GET veya $_POST kullanılması daha güvenli ve öngörülebilirdir.
isset() ile Kontrol: Öntanımlı değişkenlerdeki bir anahtara erişmeden önce, o anahtarın gerçekten var olup olmadığını isset() fonksiyonu ile kontrol etmek iyi bir uygulamadır. Bu, "Undefined index" uyarılarını ve potansiyel hataları önler.
Oturum Güvenliği: Oturum güvenliği için session_start() her sayfanın başında çağrılmalı ve oturum kimliği sabitleme (session fixation) ve oturum kaçırma (session hijacking) gibi risklere karşı dikkatli olunmalıdır. Oturum verileri hassas bilgiler içeriyorsa, ek şifreleme veya token mekanizmaları düşünülebilir.
Dosya Yükleme Güvenliği: $_FILES ile dosya yüklerken, yüklenen dosya türü, boyutu ve içeriği mutlaka doğrulanmalıdır. Kötü amaçlı dosyaların sunucuya yüklenmesini önlemek için sıkı kontroller uygulanmalıdır.
Ortam Değişkenleri ve Hassas Bilgiler: $_ENV ve $_SERVER gibi değişkenler hassas sunucu veya sistem yapılandırma bilgilerini içerebilir. Bu bilgilerin yanlışlıkla son kullanıcıya gösterilmemesine dikkat edilmelidir.
HTML, web içeriğini yapılandırmak için çeşitli etiketler sunar. Bu etiketler arasında, bilgiyi düzenli ve okunabilir bir formatta sunmak için listeler temel bir rol oynar. Listeler, birbiriyle ilişkili öğeleri gruplamak, adımları sıralamak veya terimleri tanımlamak için kullanılır. Bu kılavuz, HTML'de sırasız, sıralı ve tanımlama listelerinin nasıl oluşturulacağını, temel sözdiziminden pratik kullanım örneklerine kadar adım adım ele alacaktır.
HTML, üç ana liste türünü destekler:
Sırasız Listeler (Unordered Lists): Öğeler arasında belirli bir sıralamanın önemli olmadığı durumlarda kullanılır ve genellikle madde işaretleriyle gösterilir.
Sıralı Listeler (Ordered Lists): Öğelerin belirli bir sıraya göre sunulması gerektiğinde kullanılır ve genellikle sayılar veya harflerle gösterilir.
Tanımlama Listeleri (Description Lists): Terim ve açıklamaların eşleştirildiği listelerdir.
Her üç liste türünde de, her bir liste öğesi (liste öğesi) etiketi ile temsil edilir. Tanımlama listeleri için ise (tanımlama terimi) ve (tanımlama açıklaması) etiketleri kullanılır.
type niteliği ile bu davranış değiştirilebilir (örneğin, type="a" küçük harfler, type="I" büyük Roma rakamları).
: Hem
: Tanımlama listesinde bir terimi (definition term) tanımlar.
: Tanımlama listesinde etiketiyle tanımlanan terimin açıklamasını (definition description) sağlar.
Aşağıdaki örnekler, farklı liste türlerinin ve iç içe listelerin nasıl oluşturulacağını göstermektedir.
Sırasız Liste:
Elma
Muz
Çilek
Sıralı Liste:
Birinci Adım
İkinci Adım
Üçüncü Adım
Sıralı Liste (Harf Tipi):
Giriş
Gelişme
Sonuç
Tanımlama Listesi:
HTML
HyperText Markup Language'ın kısaltmasıdır.
CSS
Cascading Style Sheets'in kısaltmasıdır.
İç İçe Listeler:
Kahvaltı
Öğle Yemeği
Salata
Ana Yemek
Tatlı
Akşam Yemeği
Erişilebilirlik: Listelerin doğru semantik etiketlerle kullanılması, ekran okuyucular gibi yardımcı teknolojilerin içeriği doğru bir şekilde yorumlaması için kritik öneme sahiptir.
Stil Uygulama: Listelerin varsayılan görünümü CSS ile tamamen özelleştirilebilir. list-style-type, list-style-image ve list-style-position gibi CSS özellikleri kullanılarak madde işaretleri veya numaralandırma stilleri değiştirilebilir.
İç İçe Kullanım: Listeler iç içe yerleştirilebilir. Bir liste öğesinin () içine başka bir veya diğer uygun blok seviyesi etiketlerle sarmalanmalıdır.
Tanımlama Listesi Kullanımı:
Doğru Etiket Seçimi: İçeriğinizin doğasına uygun liste türünü seçmek önemlidir. Sıranın önemli olduğu yerlerde
CSS, web sayfalarında listelerin görünümünü kontrol etmek için güçlü araçlar sunar. Bu makale, sıralı (ordered) ve sırasız (unordered) listelerin varsayılan stillerini nasıl değiştireceğinizi, özel işaretleyiciler (marker) atayacağınızı ve liste öğeleri arasındaki boşlukları nasıl yöneteceğinizi detaylı bir şekilde açıklayacaktır. Amacımız, listelerinizi web tasarımınıza mükemmel bir şekilde entegre etmek için gerekli tüm bilgileri sağlamaktır.
CSS'te listelerle çalışırken en sık kullanılan özellikler list-style-type, list-style-position ve list-style-image'dir. Bu özellikler genellikle list-style kısayol özelliği ile birleştirilebilir.
ul {
list-style-type: disc; /* veya square, circle, none, decimal, lower-alpha vb. */
list-style-position: inside; /* veya outside */
list-style-image: url('marker.png'); /* özel bir görsel kullanmak için */
}
/* Kısayol (shorthand) kullanımı */
li {
list-style: square inside url('marker.png');
}
CSS listelerinin görünümünü kontrol eden temel özellikler şunlardır:
list-style-type: Liste işaretleyicisinin (marker) türünü belirler. Sırasız listeler için disc (varsayılan), circle, square, none gibi değerler alabilir. Sıralı listeler için decimal (varsayılan), decimal-leading-zero, lower-alpha, upper-alpha, lower-roman, upper-roman gibi değerler kullanılabilir. none değeri, işaretleyiciyi tamamen kaldırır.
list-style-position: Liste işaretleyicisinin liste öğesi kutusunun içinde mi yoksa dışında mı konumlanacağını belirler. outside (varsayılan) değeri, işaretleyiciyi öğe kutusunun solunda, metinle hizalı olarak konumlandırır. inside değeri ise işaretleyiciyi öğe kutusunun içine, metnin bir parçasıymış gibi yerleştirir.
list-style-image: Varsayılan işaretleyici yerine özel bir görsel kullanmanızı sağlar. Değer olarak bir görselin URL'sini alır, örneğin url('resim.svg'). Eğer görsel yüklenemezse veya bu özellik belirtilmezse, list-style-type özelliği devreye girer.
list-style: Yukarıdaki üç özelliği tek bir kısayol özelliğiyle birleştirmek için kullanılır. Değerler herhangi bir sırada yazılabilir, ancak list-style-image özelliği varsa list-style-type'ın yerine geçer (görsel yüklenemezse geri dönüş olarak kullanılır). Örnek: list-style: square inside url('marker.png');
Aşağıdaki örnekler, farklı list-style özelliklerinin nasıl uygulandığını göstermektedir.
Bu örnekte, sırasız bir listenin (circle) olarak ayarlayacağız ve metin hizalamasını değiştireceğiz.
/* HTML */
- Öğe Bir
- Öğe İki
- Öğe Üç
/* CSS */
.liste-daire {
list-style-type: circle;
list-style-position: inside;
padding-left: 0; /* Tarayıcı varsayılan padding'ini sıfırlama */
}
Bu örnek, bir listenin işaretleyicisi olarak özel bir görselin nasıl kullanılacağını gösterir. list-style-image özelliği ile bir görsel belirtilirken, görselin yüklenmemesi durumunda bir geri dönüş olarak list-style-type da tanımlanabilir.
/* HTML */
- Görsel İşaretli Öğe Bir
- Görsel İşaretli Öğe İki
/* CSS */
.liste-gorsel {
list-style-image: url('https://via.placeholder.com/15x15/0000FF/FFFFFF?text=%2B'); /* Mavi bir artı işareti görseli */
list-style-type: square; /* Görsel yüklenmezse kare göster */
padding-left: 20px; /* Görsel için yeterli boşluk */
}
Sıralı listeler (
/* HTML */
- İlk Adım
- İkinci Adım
- Üçüncü Adım
- Bölüm I
- Bölüm II
/* CSS */
.liste-harf {
list-style-type: lower-alpha;
}
.liste-roma {
list-style-type: upper-roman;
}
Varsayılan Boşluklar: Tarayıcılar padding ve margin değerleri uygular. Bu boşlukları kontrol etmek için padding-left: 0; ve margin: 0; gibi CSS kurallarını kullanmanız gerekebilir.
list-style: none; Kullanımı: İşaretleyicileri tamamen kaldırmak için list-style-type: none; veya kısayol olarak list-style: none; kullanın. Bu genellikle özel işaretleyiciler oluşturmak veya listeleri menü gibi farklı bir amaçla stilize etmek için yapılır.
Erişilebilirlik: Görsel işaretleyicileri kaldırdığınızda, liste öğelerini okunabilir ve erişilebilir tutmak için alternatif görsel ipuçları veya anlamsal yapıları korumaya dikkat edin.
Özel İşaretleyiciler ve Kontrol: list-style-image özelliği, işaretleyicinin boyutunu veya konumunu doğrudan kontrol etme konusunda sınırlıdır. Daha gelişmiş kontrol için, işaretleyiciyi ::before sözde-elemanı (pseudo-element) ile oluşturup content özelliği ve diğer CSS özellikleriyle stilize etmek daha esnek bir yaklaşımdır.
Kısayol Özelliği: list-style kısayol özelliği, okunabilirliği artırır ve daha az kod yazmanızı sağlar. Ancak, değerlerin sırası önemli değildir, tarayıcı bunları doğru şekilde ayrıştırır. Yine de, standart bir sıra (type position image) izlemek iyi bir uygulamadır.
Modern web uygulamalarının karmaşıklığı, beklenmedik durumların veya hataların ortaya çıkma olasılığını artırmaktadır. JavaScript, bu tür durumları yönetmek için yerleşik bir mekanizma sunar: Error nesnesi. Bu nesne, çalışma zamanı hatalarını temsil etmek, onları yakalamak ve uygun şekilde ele almak için kritik bir araçtır. Uygulama kararlılığını ve kullanıcı deneyimini sağlamak adına Error nesnesinin etkin kullanımı, her JavaScript geliştiricisinin sahip olması gereken temel bir yetkinliktir.
JavaScript'te bir hata nesnesi oluşturmak için Error yapıcısını (constructor) kullanırız. Bu, programatik olarak bir hata durumunu belirtmenin en yaygın yoludur.
new Error([message[, fileName[, lineNumber]]])Error yapıcısının aldığı parametreler ve Error nesnesinin temel özellikleri aşağıda detaylandırılmıştır:
message: Hatanın kısa ve açıklayıcı bir metinle ifade edildiği bir String değeridir. Hata nesnesinin temel içeriğini oluşturur.
fileName (İsteğe Bağlı): Hatanın meydana geldiği dosyanın yolunu belirten bir String değeridir. Genellikle hata yakalama mekanizmaları tarafından otomatik olarak doldurulur.
lineNumber (İsteğe Bağlı): Hatanın meydana geldiği dosyadaki satır numarasını belirten bir Number değeridir. Bu da genellikle otomatik olarak atanır.
Error nesnesinin kendisi, bu parametrelere ek olarak iki önemli özelliğe sahiptir:
name: Hata türünün adını belirten bir String değeridir (örneğin, 'Error', 'TypeError', 'ReferenceError'). Özel hata türleri oluşturulduğunda bu özellik özelleştirilebilir.
stack: Hatanın çağrı yığınını (call stack) gösteren bir String değeridir. Hatanın nerede ve nasıl oluştuğunu anlamak için son derece faydalıdır.
Aşağıdaki örnekler, Error nesnesinin JavaScript uygulamalarında nasıl kullanılabileceğini göstermektedir.
Örnek 1: Temel Hata Fırlatma ve Yakalama
Bir fonksiyonun belirli bir koşulu karşılamadığı durumlarda programın akışını durdurmak ve bir hata durumu bildirmek için throw new Error() kullanılır. try...catch bloğu ile bu hatalar yakalanabilir.
function bolmeIslemi(sayi1, sayi2) {
if (sayi2 === 0) {
throw new Error("Sıfıra bölme hatası: Bölen sıfır olamaz.");
}
return sayi1 / sayi2;
}
try {
console.log(bolmeIslemi(10, 2)); // Çıktı: 5
console.log(bolmeIslemi(10, 0)); // Bu satır bir hata fırlatacak
} catch (e) {
console.error("Bir hata oluştu:", e.message);
console.error("Hata adı:", e.name);
console.error("Hata yığını:", e.stack);
}Örnek 2: Özel Hata Türü Oluşturma
Uygulamaya özgü hata durumlarını daha spesifik bir şekilde yönetmek için Error nesnesinden türetilmiş özel hata sınıfları oluşturulabilir. Bu, hata türlerinin daha kolay ayırt edilmesini ve işlenmesini sağlar.
class GecersizGirdiHatasi extends Error {
constructor(message) {
super(message);
this.name = "GecersizGirdiHatasi"; // Hatanın adını özelleştiriyoruz
}
}
function veriIsle(veri) {
if (typeof veri !== 'number' || veri < 0) {
throw new GecersizGirdiHatasi("Girdi pozitif bir sayı olmalıdır.");
}
return veri * 2;
}
try {
console.log(veriIsle(5)); // Çıktı: 10
console.log(veriIsle(-3)); // Bu satır özel bir hata fırlatacak
} catch (e) {
if (e instanceof GecersizGirdiHatasi) {
console.error("Geçersiz girdi hatası yakalandı:", e.message);
} else {
console.error("Beklenmeyen bir hata oluştu:", e.message);
}
}Örnek 3: try...catch...finally Kullanımı
try...catch...finally yapısı, hata oluşsa da oluşmasa da belirli kod bloklarının çalıştırılmasını garanti eder. Bu, kaynakları temizlemek veya bazı işlemleri tamamlamak için kullanışlıdır.
function dosyaOku(dosyaAdi) {
let dosyaAcik = false;
try {
console.log(`${dosyaAdi} dosyası açılıyor...`);
dosyaAcik = true;
// Simulate an error
if (dosyaAdi === "hatali.txt") {
throw new Error("Dosya okunamadı: Erişim reddedildi.");
}
console.log(`${dosyaAdi} dosya içeriği işleniyor.`);
return "Dosya içeriği...";
} catch (e) {
console.error("Hata:", e.message);
return null;
} finally {
if (dosyaAcik) {
console.log(`${dosyaAdi} dosyası kapatılıyor.`);
}
}
}
console.log(dosyaOku("veri.txt"));
console.log("\n--- Yeni İşlem ---\n");
console.log(dosyaOku("hatali.txt"));Spesifik Hata Türleri Kullanımı: JavaScript, TypeError, ReferenceError, RangeError gibi çeşitli yerleşik hata türleri sunar. Mümkün olduğunca hatanın doğasına uygun spesifik hata türlerini kullanmaya özen gösterin. Bu, hata ayıklamayı ve hata işleme mantığını basitleştirir.
Hataları Bastırmayın: Bir try...catch bloğunda hatayı yakalayıp hiçbir işlem yapmamak (boş bırakmak), uygulamanızdaki sorunların gizlenmesine neden olur. Hataları her zaman uygun bir şekilde günlüğe kaydedin veya kullanıcıya bildirin.
finally Bloğunun Önemi: Kaynakları (dosya bağlantıları, ağ istekleri vb.) serbest bırakmak veya belirli bir işlemi tamamlamak için finally bloğunu kullanın. Bu blok, hata oluşsa da oluşmasa da her zaman çalıştırılır.
Geniş Kapsamlı try...catch Bloklarından Kaçının: Tüm uygulamanızı tek bir try...catch bloğuna sarmak, hangi hatanın nerede meydana geldiğini anlamayı zorlaştırır. Hata yakalama bloklarınızı, hata potansiyeli olan belirli işlevlere veya kod parçalarına odaklayın.
Üretim Ortamında Hata İzleme: Canlı sistemlerde oluşan hataları izlemek için Sentry, Bugsnag gibi üçüncü taraf hata izleme hizmetlerini kullanmayı düşünün. Bu hizmetler, hata raporlarını toplar, analiz eder ve geliştiricilere anında bildirimler gönderir.
SQL (Yapısal Sorgulama Dili), veritabanlarından bilgi almayı ve manipüle etmeyi sağlayan güçlü bir dildir. Bu dilin temel bileşenlerinden biri olan SUM() fonksiyonu, sayısal bir sütundaki değerlerin toplamını hesaplamak için kullanılan bir toplama (aggregate) fonksiyonudur. Raporlama, finansal analiz veya genel veri özetleri oluştururken, belirli bir kriteri karşılayan tüm kayıtların toplam değerini bulmak hayati öneme sahiptir. Bu kılavuz, SUM() fonksiyonunun sözdiziminden başlayarak, çeşitli kullanım senaryolarını örneklerle açıklayacak ve bu güçlü fonksiyonu verimli bir şekilde kullanmanıza yardımcı olacak pratik bilgiler sunacaktır.
SUM() fonksiyonunun temel sözdizimi aşağıdaki gibidir:
SELECT SUM(sutun_adi)
FROM tablo_adi
WHERE kosul;İsteğe bağlı olarak, yalnızca benzersiz değerlerin toplamını almak için DISTINCT anahtar kelimesi kullanılabilir:
SELECT SUM(DISTINCT sutun_adi)
FROM tablo_adi
WHERE kosul;SUM() fonksiyonu, belirtilen bir sayısal ifadenin veya sütunun değerlerini toplar. Fonksiyonun bileşenleri şunlardır:
SUM(): Bu, toplama işlemini gerçekleştiren ana fonksiyondur.
sutun_adi veya expression: Toplanacak değerleri içeren sayısal bir sütun adını veya sayısal bir değer döndüren herhangi bir ifadeyi (örneğin, Miktar * BirimFiyat) temsil eder. Bu ifade, INT, DECIMAL, FLOAT gibi sayısal veri tiplerine sahip olmalıdır.
DISTINCT (isteğe bağlı): Eğer bu anahtar kelime kullanılırsa, SUM() fonksiyonu yalnızca belirtilen sütundaki veya ifadedeki benzersiz değerlerin toplamını hesaplar. Yinelenen değerler toplama dahil edilmez. Genellikle bu anahtar kelimeye ihtiyaç duyulmaz ve kullanımı performansı etkileyebilir.
FROM tablo_adi: Sorgunun hangi tablodan veri alacağını belirtir.
WHERE kosul (isteğe bağlı): Toplama işlemine dahil edilecek satırları filtrelemek için kullanılır. Yalnızca belirtilen koşulu sağlayan satırlar toplanır.
SUM() fonksiyonu, varsayılan olarak NULL değerleri toplama işlemine dahil etmez. Yani, bir sütunda NULL değeri varsa, bu değer göz ardı edilir ve toplam etkilenmez.
Aşağıdaki örneklerde, bir satış tablosu olan Satislar'ı kullanacağız. Bu tablo, SatisID, UrunID, Miktar, BirimFiyat, SatisTarihi ve MusteriID sütunlarını içermektedir.
Tüm satış kayıtlarındaki ürünlerin toplam miktarını bulmak için basit bir SUM() kullanımı:
SELECT SUM(Miktar) AS ToplamMiktar
FROM Satislar;Açıklama: Bu sorgu, Satislar tablosundaki tüm Miktar değerlerini toplar ve sonucu ToplamMiktar adıyla döndürür.
GROUP BY ifadesiyle birlikte SUM() kullanarak her bir ürün için ayrı ayrı toplam satış miktarını hesaplayabiliriz:
SELECT UrunID, SUM(Miktar) AS UrunToplamMiktar
FROM Satislar
GROUP BY UrunID;Açıklama: Sorgu, UrunID'ye göre gruplandırma yapar ve her bir UrunID için ilgili satış miktarlarının toplamını hesaplar.
WHERE koşulu ile belirli bir tarihten sonraki satışların toplam gelirini (miktar * birim fiyat) hesaplayabiliriz:
SELECT SUM(Miktar * BirimFiyat) AS ToplamGelir
FROM Satislar
WHERE SatisTarihi > '2023-01-16';Açıklama: Bu sorgu, 16 Ocak 2023 tarihinden sonra gerçekleşen satışların her biri için Miktar ile BirimFiyat'ı çarparak geliri bulur ve bu gelirlerin toplamını ToplamGelir olarak döndürür.
Eğer sadece benzersiz satış miktarlarının toplamını almak istiyorsanız, DISTINCT anahtar kelimesini kullanabilirsiniz:
SELECT SUM(DISTINCT Miktar) AS FarkliMiktarToplami
FROM Satislar;Açıklama: Bu sorgu, Satislar tablosundaki Miktar sütununda tekrar eden değerleri bir kez sayarak, yalnızca farklı Miktar değerlerinin toplamını hesaplar.
GROUP BY ile birlikte HAVING kullanarak, belirli bir eşiğin üzerindeki toplam gelire sahip ürünleri filtreleyebiliriz:
SELECT UrunID, SUM(Miktar * BirimFiyat) AS UrunToplamGelir
FROM Satislar
GROUP BY UrunID
HAVING SUM(Miktar * BirimFiyat) > 200;Açıklama: Bu örnek, her bir UrunID için toplam geliri hesaplar ve yalnızca toplam geliri 200'den fazla olan ürünleri listeler.
NULL Değerler: SUM() fonksiyonu, NULL değerleri otomatik olarak göz ardı eder. Eğer NULL değerleri sıfır olarak dahil etmek isterseniz, COALESCE() veya ISNULL() gibi fonksiyonları kullanmalısınız (örneğin, SUM(COALESCE(sutun_adi, 0))).
Sayısal Olmayan Veri Tipleri: SUM() yalnızca sayısal veri tipleriyle çalışır. Sayısal olmayan bir sütun üzerinde kullanılırsa hata verecektir. Gerekirse, veri tipini uygun bir sayısal türe dönüştürmek için CAST() veya CONVERT() gibi fonksiyonları kullanın.
GROUP BY ile Kullanım: SUM() fonksiyonunun gücü genellikle GROUP BY ifadesiyle birleştiğinde ortaya çıkar. Bu kombinasyon, verileri belirli kategorilere göre gruplandırarak her grup için ayrı ayrı toplamları hesaplamanıza olanak tanır.
HAVING ile Filtreleme: GROUP BY kullanıldığında, gruplar üzerinde filtreleme yapmak için WHERE yerine HAVING ifadesi kullanılır. WHERE, gruplama yapılmadan önce satırları filtrelerken, HAVING gruplama yapıldıktan ve toplama fonksiyonları uygulandıktan sonra grupları filtreler.
Performans: Büyük veri kümelerinde SUM() kullanımı, özellikle DISTINCT anahtar kelimesiyle veya karmaşık ifadelerle birleştiğinde performans üzerinde etki yaratabilir. İndeksleme, sorgu optimizasyonu ve uygun veri tipi seçimi gibi faktörler performansı artırabilir.
Merhaba gökyüzü tutkunları! Sonbaharın serin gecelerinde bizi bekleyen muhteşem bir görsel şölen var: Orionid Meteor Yağmuru! Bu, sadece bir göktaşı yağmurundan çok daha fazlası; tarihin en ünlü kuyruklu yıldızlarından Halley'nin bize bıraktığı büyüleyici bir miras. Hazırsanız, bu eşsiz olayı ne zaman ve nasıl izleyeceğinize dair tüm detaylara dalalım ve evrenin sunduğu bu harika hediyeyi kaçırmamanız için ipuçlarımı sizinle paylaşayım.
Peki, Orionidler tam olarak nedir? Göktaşı yağmurları, Dünya'nın uzayda seyreden bir kuyruklu yıldızın veya asteroidin yörüngesinde bıraktığı toz ve kaya parçacıkları bulutundan geçtiğinde meydana gelir. Bu minik parçacıklar, gezegenimizin atmosferine saniyede yaklaşık 66 kilometre gibi inanılmaz bir hızla girer. Atmosferdeki hava molekülleriyle sürtünme sonucu yanarak parlamaya başlarlar ve biz de onlara "kayan yıldız" veya "meteor" deriz. Orionidler, adını gökyüzünde ışınsal olarak yayılıyor gibi göründükleri Orion Takımyıldızı'ndan alır. Bu takımyıldız, meteorların çıkış noktası gibi görünse de, aslında tüm gökyüzünde görülebilirler.
Orionidlerin özel olmasının en büyük nedeni, onların kaynağının Halley Kuyruklu Yıldızı olmasıdır. Bu ünlü kuyruklu yıldız, her 75-76 yılda bir Dünya'nın yakınından geçer ve yörüngesinde geride milyonlarca küçük parçacık bırakır. Dünya, bu parçacıkların içinden her yıl Ekim ayında geçtiğinde, Halley'nin mirası olan Orionidleri gökyüzünde izleme şansı buluruz. Bu, aslında çok eski bir gök olayıdır ve binlerce yıldır insanları büyülemeye devam etmektedir. Halley'nin bıraktığı bu izler, bize tarihin derinliklerinden gelen bir mesaj niteliğindedir.
En önemli soru: Ne zaman? Orionid meteor yağmuru genellikle 2 Ekim ile 7 Kasım tarihleri arasında aktif olur. Ancak, asıl görsel şölen, yani en yoğun dönemi, 20-21 Ekim gecesi civarında gerçekleşir. Bu gecelerde, hava koşulları uygun olduğunda ve ışık kirliliğinden uzak bir noktadaysanız, saatte 10 ila 20 kadar meteor görme şansınız olabilir. Hatta bazı yıllar bu sayı daha da artabilir! Bu tarihleri takvimlerinize işaretlemeyi unutmayın.
Bu yıl, yani 2024'te, Orionidlerin zirvesi yine 20-21 Ekim gecesine denk geliyor. Genellikle gece yarısından sonra, sabaha karşı 02:00 ile şafak sökene kadar olan saatler, meteor izlemek için en ideal zaman dilimidir. Bu saatlerde, Dünya'nın dönüşü sayesinde meteor parçacıklarıyla daha doğrudan bir çarpışma yaşarız ve bu da görünen meteor sayısını artırır. Ay'ın durumu da gözlem kalitesini doğrudan etkiler ve bu yılki gözlemler için Ay'ın durumu oldukça önemli bir faktör olacak.
Peki, Ay'ın durumu nasıl olacak? 2024'te Orionidlerin zirve yaptığı 20-21 Ekim gecesi, Ay'ın evresi son dördün evresine yakın olacak. Bu, Ay'ın gökyüzünde oldukça parlak olacağı ve dolayısıyla daha sönük meteorları görmemizi zorlaştıracağı anlamına geliyor. Ancak umutsuzluğa kapılmayın! Ay battıktan sonraki saatler veya Ay'ın parlaklığının en az olduğu anlar, yine de gözlem için harika fırsatlar sunabilir. Ay ışığından en az etkilenecek bir gözlem noktası seçmek veya Ay'ı görüş alanınızın dışında tutacak bir yere bakmak, bu durumu avantaja çevirmenize yardımcı olacaktır. Unutmayın, en parlak meteorlar Ay ışığında bile görülebilir!
Şimdi gelelim bu muhteşem şöleni nasıl en iyi şekilde izleyeceğinize. Özel bir ekipmana ihtiyacınız yok, sadece sabır ve doğru bir hazırlık yeterli:
Karanlık Bir Yer Bulun: Şehir ışıklarından uzakta, mümkün olduğunca karanlık bir yer seçmek en önemlisidir. Büyük şehirlerin ışık kirliliği, sönük meteorları görmenizi engelleyecektir. Parklar, kırsal alanlar, dağ evleri veya yüksek tepeler ideal olabilir. Işık kirliliği ne kadar az olursa, o kadar çok meteor görme şansınız artar.
Ay'ın Durumunu Kontrol Edin: Gözlem yapacağınız gecenin Ay takvimini kontrol edin. Eğer Ay parlaksa, Ay batana kadar beklemek veya Ay'ın doğrudan görüş açınızda olmadığı, gökyüzünün daha karanlık bir kısmına bakmak faydalı olabilir.
Gözlerinizi Karanlığa Alıştırın: Gözlerinizin karanlığa alışması yaklaşık 20-30 dakika sürer ve bu süre zarfında ışığa maruz kalmaktan kaçınmak çok önemlidir. Bu süre zarfında telefonunuza veya diğer ışık kaynaklarına bakmaktan kaçının. Eğer bir ışığa ihtiyacınız olursa, kırmızı ışıklı bir fener kullanın; kırmızı ışık, gözlerinizin karanlığa adaptasyonunu bozmaz.
Rahat Edin: Gözlem yaparken yere uzanmak veya rahat bir kamp sandalyesine oturmak, boynunuzu ağrıtmadan gökyüzünü daha uzun süre izlemenizi sağlar. Battaniye, uyku tulumu gibi sıcak tutacak şeyleri yanınıza almayı unutmayın, zira sonbahar geceleri oldukça serin olabilir ve üşümek gözlem keyfinizi kaçırabilir.
Sabırlı Olun: Meteorlar düzenli aralıklarla gelmez. Bazen birkaç dakika boyunca hiçbir şey göremeyebilirsiniz, sonra aniden birkaç tane arka arkaya geçebilir. Bu yüzden sabırlı olmak ve gökyüzünü sürekli taramak önemlidir. Unutmayın, her bir meteor, Halley'nin bize gönderdiği özel bir selamdır.
Orionidlerin "ışıma noktası" (radyantı) Orion Takımyıldızı'nda olsa da, meteorları gökyüzünün herhangi bir yerinde görebilirsiniz. Aslında, radyanttan uzaklaşan meteorlar, Dünya atmosferine daha eğik bir açıyla girdikleri için daha uzun ve etkileyici izler bırakır. Bu yüzden tüm gökyüzünü kapsayacak şekilde geniş bir görüş açısına sahip olmaya çalışın. Başınızı gökyüzünün en karanlık ve bulutsuz kısmına çevirin ve sadece bekleyin. Gözleriniz sürekli hareket halinde olsun ve gökyüzünü yavaşça tarayın.
Orionidler, saatte yaklaşık 10 ila 20 meteor görme potansiyeli sunar (Zenithal Hourly Rate - ZHR). ZHR, ideal koşullarda, yani tamamen karanlık bir gökyüzünde, radyantın tam tepede olduğu ve görüş alanını hiçbir şeyin engellemediği varsayılarak hesaplanan teorik bir sayıdır. Gerçekte, şehir ışıklarından veya Ay ışığından etkilenen bir yerdeyseniz bu sayı daha düşük olabilir. Ancak göreceğiniz her bir meteor, Halley'nin mirasının bir parçası olduğu için paha biçilmezdir ve size evrenin büyüklüğünü hatırlatacaktır.
Orionidler, çok hızlı meteorlar olmalarıyla bilinirler; yaklaşık 66 km/s hızla Dünya atmosferine girerler. Bu inanılmaz hız, onların genellikle parlak ve hızlı izler bırakmalarına neden olur. Bazen atmosferde daha büyük parçacıkların yanmasıyla oluşan parlak fireball'lar (ateş topları) bile görebilirsiniz. Bu ateş topları, gökyüzünde birkaç saniye boyunca parlayarak gözlemcileri büyüleyebilir ve ardında uzun, dumanlı bir iz bırakabilir. Onları gördüğünüz an, gerçekten unutulmaz bir deneyim yaşayacaksın!
Halley Kuyruklu Yıldızı, insanlık tarihinde en çok bilinen ve gözlemlenen kuyruklu yıldızlardan biridir. Antik çağlardan beri pek çok kültür tarafından gözlemlenmiş ve kaydedilmiştir. Düzenli aralıklarla geri dönüşü, astronom Edmund Halley'ye yörüngesini hesaplama ve geri dönüşünü tahmin etme imkanı sunmuş, bu da onu bilimsel tahminlerin ilk büyük başarılarından biri haline getirmiştir. Kuyruklu yıldızın kendisini bir sonraki görüşümüz 2061 yılı civarında olacak. Ancak her yıl Ekim ayında Orionid meteor yağmuru sayesinde, onun uzayda bıraktığı izleri takip ederek bu tarihi gök cismine bir selam gönderebiliyoruz. Bu, aslında geçmişle bugünü, insanlık tarihiyle kozmik zamanı birleştiren eşsiz bir kozmik bağdır.
Eğer bu anı ölümsüzleştirmek istersen, birkaç ipucu senin için:
Geniş Açılı Lens: Gökyüzünün geniş bir bölümünü yakalamak ve daha fazla meteor yakalama şansını artırmak için geniş açılı (14-24mm) bir lens kullanın.
Tripod: Uzun pozlama çekimleri için fotoğraf makinenizin sabit kalması şarttır. Sağlam bir tripod olmazsa olmazdır.
Manuel Ayarlar: Yüksek ISO (1600-6400 arası, kameranızın gürültü performansına göre), düşük f-stop değeri (f/2.8 veya daha düşük) ve 15-30 saniye arası pozlama süresi deneyin. Yüksek ISO, kameranızın ışığa daha duyarlı olmasını sağlarken, düşük f-stop daha fazla ışık girmesine olanak tanır. Uzun pozlama ise meteorların izlerini yakalamak için gereklidir.
Odaklama: Lensi manuel moda alıp sonsuzluğa odaklayın. Karanlıkta bunu yapmak zor olabilir, bu yüzden önceden pratik yapın veya uzak bir ışık kaynağına odaklayarak ayarlarınızı yapın.
Gece gözlemi yaparken güvenliğiniz ve konforunuz çok önemlidir. Unutmayın, keyifli bir deneyim için iyi hazırlanmak şart:
Sıcak Giyinin: Sonbahar geceleri aldatıcı olabilir. Kat kat giyinmek, termal içlikler, kalın çoraplar, şapka, eldiven ve su geçirmez bir dış katman, soğuktan korunmanızı sağlar.
Yanınıza İçercek ve Yiyecek Alın: Termos içinde sıcak çay veya kahve gibi içecekler ve atıştırmalıklar, uzun gözlem seanslarında enerjinizi yüksek tutar ve içten ısınmanıza yardımcı olur.
Güvenli Bir Yer Seçin: Mümkünse yalnız gitmek yerine arkadaşlarla gitmek veya bildiğiniz, güvenli, erişimi kolay bir alanı tercih etmek her zaman daha iyidir. Yeni bir yere gidiyorsanız, gündüz keşfetmekte fayda var.
Çevreye Duyarlı Olun: Gözlem yaparken doğaya zarar vermemeye özen gösterin, çöplerinizi yanınızda götürün ve ses kirliliği yaratmaktan kaçının.
Orionidler, sadece gökyüzündeki anlık ışık izleri değildir; onlar aynı zamanda bilim, tarih ve insanlığın evrenle olan derin bağının bir yansımasıdır. Halley'nin bize bıraktığı bu minik parçacıklar, her yıl bizi evrenin derinliklerine, kozmik bir dansa davet eder. Bu, şehir hayatının gürültüsünden ve karmaşasından uzaklaşıp, evrenin sonsuzluğunu ve kendi küçüklüğümüzü hissetmek için harika bir fırsattır. Bir an durup, milyarlarca yıl önceki bir kuyruklu yıldızın kalıntılarını izlemek, gerçekten büyüleyici ve düşündürücü bir deneyimdir. Gezegenimizin bu kozmik toz bulutundan geçerken yaşadığımız bu anlık karşılaşmalar, bize evrenin dinamik ve sürekli değişen doğasını hatırlatır.
Unutmayın, en iyi gözlem için ihtiyacınız olan tek şey karanlık bir gökyüzü, sabır ve biraz şans. Hava durumu tahminlerini takip edin, en uygun geceyi seçin ve bu muhteşem gökyüzü şöleninin tadını çıkarın. Belki de bir dilek tutmak için mükemmel bir an yakalarsınız! Gökyüzünüz açık, geceniz yıldızlarla dolsun!
Python programlama dilinde while döngüsü, belirli bir koşul doğru olduğu sürece bir kod bloğunu tekrar tekrar yürütmek için kullanılır. Bu döngü yapısı, bir işlemin ne zaman duracağının belirli bir sayı yerine bir koşula bağlı olduğu senaryolarda oldukça etkilidir. Kullanıcı girdisi beklenmesi, bir veri yapısındaki öğelerin işlenmesi veya bir oyun döngüsünün sürdürülmesi gibi durumlarda program akışını kontrol etmek için vazgeçilmez bir araçtır.
Bir while döngüsünün genel yapısı aşağıdaki gibidir:
while koşul:
# Koşul doğru olduğu sürece yürütülecek kod bloğu
# Döngü değişkenini güncelleyen ifadeler
else:
# Koşul yanlış olduğunda (ve break kullanılmadığında) yürütülecek kod bloğu
Bu yapıda:
while: Döngüyü başlatan anahtar kelimedir.
koşul: Her iterasyonun başında değerlendirilen bir boolean ifadedir. Bu koşul True olduğu sürece döngü devam eder.
: (İki nokta üst üste): Koşul ifadesinden sonra gelir ve döngü bloğunun başladığını belirtir.
Girintili Kod Bloğu: Koşul doğru olduğunda yürütülecek olan bir veya daha fazla satırdan oluşur. Python'da girinti (indentation) kod bloklarını tanımlamak için kullanılır.
else (İsteğe Bağlı): while döngüsüyle birlikte kullanılabilen isteğe bağlı bir bloktur. Döngü koşulu False olduğunda ve döngü break ifadesiyle sonlandırılmadığında yürütülür.
Aşağıdaki örnekler, while döngüsünün çeşitli kullanım senaryolarını göstermektedir.
Örnek 1: Basit Bir Sayıcı Döngüsü
Bu örnekte, bir değişkenin değeri belirli bir sayıya ulaşana kadar döngüyü sürdürüyoruz.
sayac = 0
while sayac < 5:
print(f"Sayı: {sayac}")
sayac += 1 # Sayacı her döngüde bir artırıyoruz
print("Döngü tamamlandı.")
Açıklama: sayac değişkeni 0'dan başlar ve her iterasyonda 1 artırılır. sayac < 5 koşulu False olana kadar döngü devam eder. Koşul False olduğunda döngüden çıkılır ve "Döngü tamamlandı." mesajı yazdırılır.
Örnek 2: break İfadesiyle Döngüyü Sonlandırma
break ifadesi, döngü koşulu hala True olsa bile döngüden hemen çıkmak için kullanılır.
i = 1
while True: # Sonsuz döngü başlatıyoruz
print(f"i'nin değeri: {i}")
if i == 3:
print("3'e ulaşıldı, döngüden çıkılıyor.")
break # Döngüyü sonlandır
i += 1
print("Döngü dışı.")
Açıklama: while True ile teorik olarak sonsuz bir döngü başlatılır. Ancak, i değişkeni 3 olduğunda break ifadesi çalışır ve döngü anında sonlanır. Bu, belirli bir iç koşul karşılandığında döngüden çıkmak için kullanışlıdır.
Örnek 3: continue İfadesiyle İterasyonu Atlatma
continue ifadesi, mevcut iterasyonun geri kalanını atlayarak döngünün bir sonraki iterasyonuna geçmek için kullanılır.
j = 0
while j < 5:
j += 1
if j == 3:
print(f"{j} atlanıyor...")
continue # Bu iterasyonun geri kalanını atla
print(f"j'nin değeri: {j}")
print("Döngü tamamlandı.")
Açıklama: j 3 olduğunda, "3 atlanıyor..." mesajı yazdırılır ve continue ifadesi çalışarak print(f"j'nin değeri: {j}") satırını atlar. Döngü bir sonraki iterasyondan devam eder.
Örnek 4: else Bloğu Kullanımı
else bloğu, döngü koşulu False olduğunda ve döngü break ile sonlandırılmadığında yürütülür.
k = 0
while k < 3:
print(f"k'nin değeri: {k}")
k += 1
else:
print("While döngüsü doğal yollarla tamamlandı.")
Açıklama: Bu örnekte döngü k 3 olana kadar devam eder. Koşul False olduğunda else bloğu yürütülür. Eğer break ifadesi ile döngüden çıkılsaydı, else bloğu çalışmazdı.
Sonsuz Döngülerden Kaçının: while döngüsünde koşulun her zaman True kalması veya hiçbir zaman False olmaması durumunda sonsuz bir döngü oluşur. Bu, programınızın kilitlenmesine neden olabilir. Koşulu etkileyecek bir ifadeyi (örneğin, bir sayacı artıran veya bir kullanıcı girdisi alan) döngü içinde bulundurduğunuzdan emin olun.
Koşulu Güncelleyin: Döngü koşulunun sonunda False değerini almasını sağlayacak bir mekanizma mutlaka olmalıdır. Aksi takdirde sonsuz döngü oluşur.
break ve continue Dikkatli Kullanın: Bu ifadeler güçlüdür ve döngü akışını değiştirirler. Kodun okunabilirliğini azaltmamak için gerektiğinde ve anlaşılır bir şekilde kullanılmalıdır.
else Bloğunun Davranışı: else bloğu, yalnızca while döngüsü koşulunun False olmasıyla doğal bir şekilde sona erdiğinde yürütülür. Eğer döngü bir break ifadesiyle kesilirse, else bloğu yürütülmez.
for vs. while: Belirli bir öğe dizisi üzerinde (örneğin bir liste veya dize) yineleme yapmanız gerektiğinde genellikle for döngüsü daha uygundur. while döngüsü ise, döngünün kaç kez çalışacağını önceden bilmediğiniz, belirli bir koşulun karşılanmasını beklediğiniz durumlarda tercih edilir.
Modern yazılım geliştirmede, beklenmedik durumları ve hataları etkili bir şekilde yönetmek, uygulamanın sağlamlığı ve sürdürülebilirliği için kritik öneme sahiptir. PHP, bu tür durumları ele almak için güçlü bir istisna yönetimi mekanizması sunar. Bu mekanizma, programın normal akışını bozmadan, hata koşullarının yakalanmasını ve uygun şekilde işlenmesini sağlar. PHP'deki öntanımlı istisnalar, çeşitli hata senaryoları için standartlaştırılmış çözümler sunarak geliştiricilerin daha temiz, okunaklı ve bakımı kolay kod yazmasına yardımcı olur.
PHP'de istisnaları kullanmanın temel yapısı, bir kod bloğunu hata açısından izlemek için try, yakalanan istisnayı işlemek için catch ve isteğe bağlı olarak, try ve catch bloklarının yürütülmesinden sonra her zaman çalıştırılacak kodu tanımlamak için finally anahtar kelimelerinden oluşur.
İstisna yönetiminin temel bileşenleri ve öntanımlı istisna sınıfları şunlardır:
try Bloğu: İstisna fırlatma potansiyeli olan kod, bu bloğun içine yerleştirilir. Eğer bu blok içinde bir istisna fırlatılırsa, normal akış kesilir ve kontrol uygun catch bloğuna geçer.
catch Bloğu: Bir try bloğu içinde fırlatılan bir istisnayı yakalamak için kullanılır. catch anahtar kelimesi, parantez içinde yakalanacak istisna türünü (sınıfını) ve bu istisnayı temsil edecek bir değişkeni (genellikle $e) alır. PHP, istisna hiyerarşisinde fırlatılan istisnayla eşleşen ilk catch bloğunu çalıştırır. Genel Exception sınıfı en genel istisna türüdür ve tüm istisnaları yakalar. Daha spesifik istisnalar için, bu sınıfın alt sınıfları kullanılmalıdır.
finally Bloğu (PHP 5.5+): Bu blok içindeki kod, try ve catch bloklarının yürütülmesinden sonra her zaman çalışır, bir istisna fırlatılsa da fırlatılmasa da. Kaynakları serbest bırakmak veya temizlik işlemleri yapmak için idealdir.
throw Anahtar Kelimesi: Manuel olarak bir istisna fırlatmak için kullanılır. Bir istisna fırlatıldığında, programın normal akışı durur ve kontrol, fırlatılan istisnayı yakalamaya uygun bir catch bloğu arar.
Exception Sınıfı: PHP'deki tüm istisna sınıflarının temelidir. Kendi özel istisna sınıflarınızı oluştururken bu sınıftan türetebilirsiniz. Exception sınıfı; hata mesajı, hata kodu, dosya adı ve satır numarası gibi önemli bilgilere erişim sağlayan metotlara sahiptir.
Öntanımlı İstisna Sınıfları: PHP, çeşitli senaryolar için bir dizi öntanımlı istisna sınıfı sunar. Bunlar, Exception sınıfının alt sınıflarıdır ve belirli hata koşullarını daha spesifik olarak ele almanızı sağlar. Örnekler arasında şunlar bulunur:
InvalidArgumentException: Bir fonksiyona veya metoda geçersiz bir argüman iletildiğinde fırlatılır.
LengthException: Bir değerin uzunluğu uygun olmadığında fırlatılır (örn. bir string'in veya dizinin).
OutOfRangeException: İstenen değerin geçerli bir aralık dışında olduğunu belirtir.
RuntimeException: Çalışma zamanında ortaya çıkan hatalar için genel bir istisnadır. Diğer, daha spesifik RuntimeException alt sınıfları da mevcuttur (örn. BadFunctionCallException, BadMethodCallException).
TypeError: Bir fonksiyona veya metoda yanlış türde bir argüman iletildiğinde fırlatılır (PHP 7+).
Aşağıdaki örnekler, öntanımlı istisnaların PHP uygulamalarında nasıl kullanılabileceğini göstermektedir.
Örnek 1: Temel try-catch kullanımı
";
echo "10 / 0 = " . bol(10, 0) . "
"; // Bu satır bir istisna fırlatır
echo "Bu satır asla çalışmayacak.
";
} catch (InvalidArgumentException $e) {
echo "Bir hata yakalandı: " . $e->getMessage() . "
";
echo "Hata kodu: " . $e->getCode() . "
";
echo "Hata dosyası: " . $e->getFile() . " satır " . $e->getLine() . "
";
} finally {
echo "Bölme işlemi denemesi tamamlandı.
";
}
echo "Program devam ediyor.
";
?>Bu örnekte, bol fonksiyonu sıfıra bölme durumunda bir InvalidArgumentException fırlatır. try bloğu bu fonksiyonu çağırır ve istisna oluştuğunda kontrol catch bloğuna geçer. finally bloğu ise istisna fırlatılsa da fırlatılmasa da çalışır.
Örnek 2: Birden Fazla catch Bloğu ile Spesifik İstisnaları Yakalama
2) {
throw new OutOfRangeException("Mod değeri 0 ile 2 arasında olmalıdır.");
}
switch ($mod) {
case 0: return strtoupper($veri);
case 1: return strtolower($veri);
case 2: return strrev($veri);
}
return $veri; // Bu satıra asla ulaşılmamalı
}
try {
echo islemYap("Merhaba", 1) . "
";
echo islemYap("", 0) . "
"; // InvalidArgumentException fırlatır
echo islemYap("Dunya", 5) . "
"; // Bu satıra ulaşılamaz
} catch (InvalidArgumentException $e) {
echo "Geçersiz argüman hatası: " . $e->getMessage() . "
";
} catch (OutOfRangeException $e) {
echo "Aralık dışı hata: " . $e->getMessage() . "
";
} catch (Exception $e) { // Tüm diğer istisnaları yakalar
echo "Genel bir hata oluştu: " . $e->getMessage() . "
";
} finally {
echo "İşlem denemesi sona erdi.
";
}
?>Bu örnek, farklı istisna türlerini yakalamak için birden fazla catch bloğunun nasıl kullanılacağını gösterir. PHP, istisna hiyerarşisinde en spesifik olandan en genele doğru sıralama yapılmasını önerir. Bu şekilde, önce InvalidArgumentException ve OutOfRangeException gibi özel durumlar yakalanır, ardından Exception ile diğer tüm istisnalar ele alınır.
Spesifik İstisnaları Yakalayın: Mümkün olduğunca spesifik istisna sınıflarını yakalayın (örn. InvalidArgumentException yerine Exception kullanmak yerine). Bu, hata koşullarını daha doğru bir şekilde tanımlamanıza ve işlemenize olanak tanır.
İstisna Hiyerarşisi: Birden fazla catch bloğu kullanırken, en spesifik istisnaları önce, en genel istisnayı (Exception) ise en sona yerleştirin. Aksi takdirde, genel istisna bloğu tüm istisnaları yakalayabilir ve daha spesifik bloklara asla ulaşılamaz.
finally Bloğunu Kullanın: Kaynakları serbest bırakmak (örn. dosya tanıtıcıları, veritabanı bağlantıları) veya temizlik işlemleri yapmak için finally bloğunu kullanın. Bu, kodun hem başarıyla tamamlandığı hem de bir istisna fırlatıldığı durumlarda tutarlılık sağlar.
Kendi İstisna Sınıflarınızı Oluşturun: PHP'nin öntanımlı istisnaları çoğu durumu kapsasa da, uygulamanıza özgü hata durumları için Exception sınıfından türeyen kendi istisna sınıflarınızı oluşturmanız, kodunuzu daha anlamlı ve yönetilebilir hale getirebilir.
Hata Mesajlarını Açık Tutun: İstisnaları fırlatırken, sorunun ne olduğunu ve nasıl düzeltilebileceğini açıklayan net ve bilgilendirici hata mesajları sağlayın. Bu, hata ayıklama sürecini büyük ölçüde hızlandırır.
İstisnaları Yutmaktan Kaçının: Bir istisnayı yakalayıp hiçbir şey yapmamak (boş bir catch bloğu) yaygın bir hatadır. Bu, hataların göz ardı edilmesine ve uygulamanızda gizli sorunlara yol açabilir. Her zaman yakaladığınız bir istisnayı işleyin (örn. loglayın, kullanıcıya bildirin veya yeniden fırlatın).
JavaScript, web sayfalarını etkileşimli hale getirmek için kullanıcı eylemlerine veya tarayıcı olaylarına tepki verme yeteneği sağlar. Bu tepkiler, 'olaylar' (events) aracılığıyla yönetilir. Bir kullanıcı bir düğmeye tıkladığında, bir form gönderdiğinde veya fare imlecini bir öğenin üzerine getirdiğinde, JavaScript bu olayları dinleyebilir ve tanımlanan işlevleri çalıştırabilir. Bu makale, JavaScript olaylarının temel kullanımını, sözdizimini ve pratik uygulamalarını detaylandıracaktır.
JavaScript'te bir DOM öğesine olay dinleyicisi eklemenin en yaygın ve önerilen yolu EventTarget.addEventListener() metodunu kullanmaktır. Bu metod, belirli bir olay türü gerçekleştiğinde çalıştırılacak bir işlevi (handler) kaydeder.
target.addEventListener(event, listener, [options]);
EventTarget.addEventListener() metodu üç ana argüman alır:
target: Olay dinleyicisinin ekleneceği DOM öğesidir. Örneğin, bir düğme, bir metin alanı veya belge kendisi olabilir.
event: Dinlenecek olayın adını belirten bir stringdir. Örnekler arasında 'click', 'mouseover', 'keydown', 'submit' bulunur. Olay adları büyük/küçük harfe duyarlıdır ve genellikle küçük harfle yazılır.
listener: Belirtilen olay gerçekleştiğinde çağrılacak olan işlevdir (callback fonksiyonu). Bu işlev, olayın kendisi hakkında bilgi içeren bir Event nesnesini argüman olarak alabilir.
options (isteğe bağlı): Olay dinleyicisinin davranışını yapılandıran bir nesnedir. En yaygın seçenekler şunlardır:
capture: Bir boolean değeridir. true ise, olay yakalama (capturing) aşamasında, false ise olay kabarcıklanma (bubbling) aşamasında tetiklenir. Varsayılan değer false'tur.
once: Bir boolean değeridir. true ise, olay dinleyicisi olay bir kez tetiklendikten sonra otomatik olarak kaldırılır. Varsayılan değer false'tur.
passive: Bir boolean değeridir. true ise, dinleyicinin event.preventDefault() çağrısı yapmayacağını belirtir. Bu, özellikle kaydırma (scrolling) olaylarında performansı artırabilir. Varsayılan değer false'tur.
Aşağıdaki örnekler, JavaScript olaylarının çeşitli kullanım senaryolarını göstermektedir.
Bir HTML düğmesine tıklandığında konsola bir mesaj yazdıran basit bir örnek.
Bir metin giriş alanındaki değer her değiştiğinde bu değişikliği yakalayan bir örnek.
Girilen Değer:
Bir öğenin üzerine fare imleci geldiğinde ve ayrıldığında farklı işlevleri çalıştıran bir örnek.
Fareyi Üzerime Getir
Dinleyiciyi Kaldırma: Performans ve bellek sızıntılarını önlemek için, özellikle tek seferlik olaylarda veya bileşenler kaldırıldığında EventTarget.removeEventListener() metodunu kullanarak olay dinleyicilerini kaldırmak önemlidir. addEventListener ile aynı argümanlar kullanılmalıdır (aynı fonksiyon referansı dahil).
Olay Nesnesi: Olay dinleyici fonksiyonuna otomatik olarak geçirilen Event nesnesi, olayın türü (event.type), hedefi (event.target), tuş bilgisi (event.key, event.keyCode) gibi değerli bilgiler içerir.
event.preventDefault(): Bazı olayların varsayılan tarayıcı davranışları vardır (örneğin, bir bağlantıya tıklamak sizi başka bir sayfaya götürür veya bir form göndermek sayfayı yeniler). Bu varsayılan davranışları durdurmak için olay nesnesi üzerindeki event.preventDefault() metodunu kullanabilirsiniz.
Olay Kabarcıklanması ve Yakalama: Olaylar, DOM ağacında yukarı (kabarcıklanma) veya aşağı (yakalama) doğru yayılır. addEventListener metodunun üçüncü argümanı (veya options nesnesindeki capture özelliği) bu davranışı kontrol etmenizi sağlar. Çoğu durumda, varsayılan kabarcıklanma davranışı yeterlidir.
this Anahtar Kelimesi: Bir olay dinleyicisi içinde this anahtar kelimesi, olayın gerçekleştiği DOM öğesini (event.currentTarget) ifade eder. Ancak, arrow fonksiyonlar kullanıldığında this, tanımlandığı kapsayıcı kapsamı korur.
SQL (Yapısal Sorgu Dili), veritabanlarından bilgi almak ve manipüle etmek için kullanılan standart bir dildir. Bu güçlü dilin temel bileşenlerinden biri olan AVG() fonksiyonu, belirli bir sayısal sütundaki değerlerin ortalamasını hesaplamak için kullanılır. Veri analizi ve raporlama süreçlerinde vazgeçilmez bir araç olan AVG(), büyük veri kümelerinden anlamlı istatistikler çıkarmayı sağlar. Bu makalede, AVG() fonksiyonunun sözdizimini, detaylı kullanımını ve pratik örneklerini inceleyeceğiz.
AVG() fonksiyonunun genel sözdizimi aşağıdaki gibidir:
SELECT AVG(sütun_adı)
FROM tablo_adı
WHERE koşul;Alternatif olarak, tüm benzersiz değerlerin ortalamasını almak için DISTINCT anahtar kelimesi ile birlikte kullanılabilir:
SELECT AVG(DISTINCT sütun_adı)
FROM tablo_adı
WHERE koşul;SELECT: Sorgunun anahtar kelimesidir ve veritabanından veri almak için kullanılır.
AVG(): Ortalamayı hesaplamak için kullanılan SQL toplama (aggregate) fonksiyonudur.
sütun_adı: Ortalaması alınacak sayısal sütunun adıdır. Bu sütun INTEGER, DECIMAL veya FLOAT gibi sayısal bir veri tipine sahip olmalıdır.
FROM tablo_adı: Verilerin çekileceği tablonun adını belirtir.
WHERE koşul: İsteğe bağlı bir yan tümcedir. Belirtilen koşulları karşılayan satırlar üzerinde ortalama hesaplaması yapılmasını sağlar. Bu olmadan, tüm tablodaki ilgili sütunun ortalaması hesaplanır.
DISTINCT: İsteğe bağlı bir anahtar kelimedir. Eğer kullanılırsa, AVG() fonksiyonu yalnızca belirtilen sütundaki benzersiz değerlerin ortalamasını hesaplar. Tekrar eden değerler hesaplamaya dahil edilmez.
Aşağıdaki örneklerde, bir Urunler tablosunun olduğu varsayılmaktadır. Bu tabloda UrunID (INTEGER), UrunAdi (VARCHAR), Fiyat (DECIMAL) ve StokAdedi (INTEGER) gibi sütunlar bulunmaktadır.
Örnek 1: Tüm Ürünlerin Ortalama Fiyatını Hesaplama
Bu sorgu, Urunler tablosundaki tüm ürünlerin ortalama fiyatını döndürecektir.
SELECT AVG(Fiyat) AS OrtalamaFiyat
FROM Urunler;Örnek 2: Belirli Bir Koşula Göre Ortalama Fiyatı Hesaplama
Bu örnek, fiyatı 50 TL'den yüksek olan ürünlerin ortalama fiyatını bulur.
SELECT AVG(Fiyat) AS YuksekFiyatliOrtalama
FROM Urunler
WHERE Fiyat > 50.00;Örnek 3: Farklı Ürün Kategorilerine Göre Ortalama Fiyatı Hesaplama
Eğer Urunler tablosunda bir Kategori sütunu olsaydı, her kategori için ortalama fiyatı aşağıdaki gibi hesaplayabilirdik. (Bu örnekte Urunler tablosuna Kategori sütununun eklendiği varsayılmıştır.)
SELECT Kategori, AVG(Fiyat) AS KategoriOrtalamaFiyat
FROM Urunler
GROUP BY Kategori;Örnek 4: Benzersiz Stok Adetlerinin Ortalamasını Hesaplama
Bu sorgu, StokAdedi sütunundaki benzersiz değerlerin ortalamasını hesaplar. Eğer aynı stok adedine sahip birden fazla ürün varsa, bu değer yalnızca bir kez hesaba katılır.
SELECT AVG(DISTINCT StokAdedi) AS BenzersizStokOrtalamasi
FROM Urunler;NULL Değerler: AVG() fonksiyonu, hesaplamalarına NULL değerleri dahil etmez. Yani, bir sütunda NULL değerler varsa, bunlar ortalama hesaplamasından otomatik olarak çıkarılır.
Sayısal Olmayan Sütunlar: AVG() fonksiyonu yalnızca sayısal veri tipleriyle çalışır. Sayısal olmayan bir sütun üzerinde kullanılmaya çalışılırsa hata döndürebilir veya beklenmeyen sonuçlar üretebilir.
GROUP BY ile Kullanım: AVG() genellikle GROUP BY yan tümcesiyle birlikte kullanılır. Bu, verileri belirli gruplara ayırarak her grup için ayrı ayrı ortalama hesaplamaları yapılmasına olanak tanır.
DISTINCT Kullanımı: DISTINCT anahtar kelimesi, yalnızca benzersiz değerlerin ortalamasını almak istediğinizde faydalıdır. Ancak, bu kullanımı sorgu performansını etkileyebilir, bu nedenle dikkatli kullanılmalıdır.
Sıfıra Bölme Hatası: Eğer ortalaması alınacak hiçbir satır yoksa (örneğin, WHERE koşulu hiçbir satırı eşleştirmiyorsa), AVG() fonksiyonu bazı veritabanı sistemlerinde NULL döndürebilirken, bazılarında sıfıra bölme hatasına benzer bir durumla karşılaşılabilir. Genellikle NULL döndürmesi beklenen davranıştır.
Python, okunabilirliği ve sadeliği ile bilinen güçlü bir programlama dilidir. Birçok programlama görevinde tekrarlayan işlemler, döngüler aracılığıyla etkin bir şekilde gerçekleştirilir. Python'da, belirli bir dizi (liste, demet, dize, küme, sözlük veya diğer yinelenebilir nesneler) üzerinde yineleme yapmak için for döngüsü kullanılır. Bu makale, Python'daki for döngüsünün temel yapısını, kullanımını ve pratik örneklerini detaylı bir şekilde açıklamaktadır.
Python'da for döngüsünün genel sözdizimi aşağıdaki gibidir:
for eleman in yinelenebilir_nesne:
# Döngü bloğu
# Her yinelemede çalışacak kod buraya yazılır
# 'eleman' değişkeni her adımda yinelenebilir_nesnenin bir sonraki öğesini alır
Yukarıdaki sözdiziminde yer alan her bir bileşenin işlevi şöyledir:
for: Python'da bir döngü başlatmak için kullanılan anahtar kelimedir.
eleman: Her yinelemede, yinelenebilir_nesne'den alınan mevcut öğeyi temsil eden bir değişkendir. Bu değişkenin adı isteğe bağlıdır ve genellikle döngü içinde işlenecek öğenin anlamını yansıtır.
in: eleman değişkeninin hangi yinelenebilir_nesne içinde aranacağını belirtmek için kullanılan bir anahtar kelimedir.
yinelenebilir_nesne: Üzerinde yineleme yapılacak olan bir koleksiyon veya dizidir. Bu, bir list, tuple, string, set, dictionary veya özel olarak yinelenebilir hale getirilmiş herhangi bir nesne olabilir.
: (İki nokta üst üste): for döngüsü başlığının sonunu işaret eder ve döngü bloğunun başladığını belirtir.
Döngü bloğu (girintili kod): for döngüsünün her adımında çalıştırılacak kod satırlarıdır. Python'da kod blokları girintileme ile tanımlanır. Tüm döngü bloğu aynı seviyede girintili olmalıdır.
Aşağıdaki örnekler, for döngüsünün farklı senaryolarda nasıl kullanılabileceğini göstermektedir.
Örnek 1: Liste Öğeleri Üzerinde Yineleme
Bir liste içindeki her bir sayıyı ekrana yazdırma.
sayilar = [1, 2, 3, 4, 5]
for sayi in sayilar:
print(sayi)
Çıktı:
1
2
3
4
5
Örnek 2: Bir Dize Üzerinde Yineleme
Bir dizedeki her karakteri tek tek yazdırma.
kelime = "Python"
for karakter in kelime:
print(karakter)
Çıktı:
P
y
t
h
o
n
Örnek 3: range() Fonksiyonu ile Belirli Sayıda Yineleme
range() fonksiyonu, belirli bir aralıkta sayı dizileri oluşturmak için kullanılır ve for döngüleriyle sıkça tercih edilir.
# 0'dan 4'e kadar (5 dahil değil) sayılar
for i in range(5):
print(i)
Çıktı:
0
1
2
3
4
Örnek 4: Sözlük Öğeleri Üzerinde Yineleme
Bir sözlüğün anahtarları, değerleri veya hem anahtarları hem de değerleri üzerinde yineleme yapılabilir.
ayarlar = {"kullanici": "admin", "dil": "Türkçe", "tema": "koyu"}
print("Sözlük Anahtarları:")
for anahtar in ayarlar: # Varsayılan olarak anahtarları yineler
print(anahtar)
print("\nSözlük Değerleri:")
for deger in ayarlar.values():
print(deger)
print("\nSözlük Öğeleri (Anahtar-Değer çiftleri):")
for anahtar, deger in ayarlar.items():
print(f"{anahtar}: {deger}")
Çıktı:
Sözlük Anahtarları:
kullanici
dil
tema
Sözlük Değerleri:
admin
Türkçe
koyu
Sözlük Öğeleri (Anahtar-Değer çiftleri):
kullanici: admin
dil: Türkçe
tema: koyu
Örnek 5: enumerate() Fonksiyonu ile İndeks ve Değere Erişim
Bazen bir koleksiyonun öğeleri üzerinde yinelerken hem öğenin kendisine hem de indeksine ihtiyaç duyulur. enumerate() fonksiyonu bu durumu kolaylaştırır.
meyveler = ["elma", "muz", "çilek"]
for indeks, meyve in enumerate(meyveler):
print(f"{indeks}: {meyve}")
Çıktı:
0: elma
1: muz
2: çilek
Girintileme Önemlidir: Python'da kod blokları girintileme ile tanımlanır. for döngüsünün altına yazılan tüm kod satırlarının aynı girinti seviyesinde olması gerektiğini unutmayın. Yanlış girintileme IndentationError hatasına yol açacaktır.
Yinelenebilir Nesneler: for döngüsü sadece yinelenebilir (iterable) nesneler üzerinde çalışır. Sayılar veya boolean değerler gibi yinelenebilir olmayan nesneleri doğrudan for döngüsünde kullanamazsınız.
Döngü Kesme (break): Bir döngüyü belirli bir koşul sağlandığında tamamen sonlandırmak için break anahtar kelimesini kullanabilirsiniz.
Döngü Atlatma (continue): Bir döngünün mevcut yinelemesini atlayıp bir sonraki yinelemeye geçmek için continue anahtar kelimesini kullanabilirsiniz.
Performans: Büyük veri kümeleri üzerinde çalışırken, for döngüleri yerine list comprehension veya generator ifadelerini kullanmak performansı artırabilir. Ancak, temel kullanım için for döngüleri oldukça etkilidir.
Nesne yönelimli programlama (OOP) prensipleri, modern yazılım geliştirmede kodun yapısını, okunabilirliğini ve sürdürülebilirliğini sağlamak için kritik öneme sahiptir. PHP, bu prensipleri desteklemek adına arayüzler (interfaces) ve soyut sınıflar (abstract classes) gibi güçlü yapılar sunar. Bu yapılar, sınıflar arasında belirli davranış sözleşmeleri tanımlayarak veya ortak bir temel sağlayarak esnek ve genişletilebilir sistemler oluşturulmasına olanak tanır. Bu makale, PHP'deki arayüzlerin ve soyut sınıfların detaylı kullanımını, sözdizimini ve pratik örneklerini ele alacaktır.
PHP'de arayüzler ve soyut sınıflar, belirli anahtar kelimeler kullanılarak tanımlanır ve diğer sınıflar tarafından uygulanır veya miras alınır. Aşağıda temel sözdizimleri gösterilmektedir.
ozellik = $ozellik;
}
// Soyut metot: Gövdesi yoktur, alt sınıflar tarafından uygulanmalıdır.
abstract public function soyutMetot(): string;
// Somut metot: Gövdesi vardır, alt sınıflar tarafından miras alınır veya geçersiz kılınabilir.
public function somutMetot(): string {
return "Somut metot çalıştı: " . $this->ozellik;
}
}
// Arayüz Uygulayan Sınıf
class SomutSinifA implements ArayuzAdi {
public function metotBir(string $parametre): bool {
// Metot uygulamasını buraya yazın
return true;
}
public function metotIki(): void {
// Metot uygulamasını buraya yazın
}
}
// Soyut Sınıfı Miras Alan Sınıf
class SomutSinifB extends SoyutSinifAdi {
public function soyutMetot(): string {
return "Soyut metot SomutSinifB tarafından uygulandı: " . $this->ozellik;
}
}
?>
Arayüzler ve soyut sınıflar, farklı senaryolar için tasarlanmış olsalar da, her ikisi de soyutlama ve polimorfizm prensiplerini destekler.
Bir arayüz, bir sınıfın sahip olması gereken metotları tanımlayan bir "sözleşme" görevi görür. Arayüzler, bir sınıfın dış dünyaya hangi davranışları sergileyeceğini belirtir, ancak bu davranışların nasıl uygulanacağını belirtmez.
Tanım: Bir arayüz interface anahtar kelimesiyle tanımlanır. İçerisinde yalnızca metot imzaları ve sabitler bulunabilir.
Metotlar: Arayüzdeki tüm metotlar otomatik olarak public ve soyuttur (yani gövdeleri yoktur). Metot imzaları, parametre tiplerini ve dönüş tiplerini (PHP 7.0 ve sonrası) içerebilir.
Özellikler: Arayüzler herhangi bir özellik (member variable) tanımlayamaz.
Sabitler: Arayüzler sabitler tanımlayabilir. Bu sabitlere ArayuzAdi::SABIT_ADI şeklinde erişilebilir.
Uygulama: Bir sınıf, bir arayüzü implements anahtar kelimesiyle uygular. Bir sınıf birden fazla arayüzü uygulayabilir (örneğin: class MyClass implements InterfaceA, InterfaceB).
Zorunluluk: Bir arayüzü uygulayan sınıf, arayüzdeki tüm metotları belirtilen imzalarla (public olarak) uygulamak zorundadır. Aksi takdirde bir fatal hata oluşur.
Soyut sınıflar, bir veya daha fazla soyut metot içerebilen veya içermeyen, doğrudan örneği oluşturulamayan sınıflardır. Genellikle, bir grup ilgili sınıf için ortak bir temel (base class) sağlamak amacıyla kullanılırlar.
Tanım: Bir soyut sınıf abstract class anahtar kelimesiyle tanımlanır.
Örneklenme: Soyut sınıfların doğrudan bir örneği (objesi) oluşturulamaz. Yalnızca alt sınıfları (concrete classes) örneklenebilir.
Metotlar: Soyut sınıflar hem soyut metotlar (abstract public function metotAdi();) hem de somut metotlar (gövdesi olan metotlar) içerebilir. Soyut metotların gövdesi yoktur ve alt sınıflar tarafından uygulanması zorunludur. Somut metotlar ise alt sınıflar tarafından miras alınır ve isteğe bağlı olarak geçersiz kılınabilir.
Erişim Belirleyiciler: Soyut metotlar public veya protected olabilir ancak private olamaz. Alt sınıflar soyut metotları uygularken aynı veya daha az kısıtlayıcı bir erişim belirleyici kullanamazlar (yani protected soyut metot public olarak uygulanabilir ama private olarak uygulanamaz).
Özellikler: Soyut sınıflar özellikler (member variables) tanımlayabilir. Bu özellikler public, protected veya private olabilir.
Kalıtım: Bir sınıf, bir soyut sınıfı extends anahtar kelimesiyle miras alır. PHP tekli kalıtımı desteklediği için bir sınıf yalnızca bir soyut sınıfı miras alabilir.
Zorunluluk: Soyut bir sınıfı miras alan alt sınıf, soyut sınıftaki tüm soyut metotları uygulamak zorundadır. Aksi takdirde, alt sınıfın kendisi de soyut olarak tanımlanmalıdır.
Aşağıdaki örnekler, arayüzlerin ve soyut sınıfların gerçek dünya senaryolarında nasıl kullanılabileceğini göstermektedir.
Farklı loglama mekanizmalarını (dosyaya, veritabanına, konsola) destekleyen bir sistem düşünelim. Tüm loglama sınıflarının aynı log() metoduna sahip olmasını bir arayüz ile sağlayabiliriz.
filePath = $filePath;
}
public function log(string $message): void {
file_put_contents($this->filePath, date('Y-m-d H:i:s') . " - " . $message . PHP_EOL, FILE_APPEND);
echo "Dosyaya loglandı: " . $message . "
";
}
}
class DatabaseLogger implements Logger {
public function log(string $message): void {
// Veritabanına loglama işlemleri burada yapılır
echo "Veritabanına loglandı: " . $message . "
";
}
}
class ConsoleLogger implements Logger {
public function log(string $message): void {
echo "Konsola loglandı: " . $message . "
";
}
}
// Loglama işlemini gerçekleştiren bir fonksiyon
function processLog(Logger $logger, string $message): void {
$logger->log($message);
}
// Kullanım
$fileLogger = new FileLogger('application.log');
$dbLogger = new DatabaseLogger();
$consoleLogger = new ConsoleLogger();
processLog($fileLogger, "Uygulama başlatıldı.");
processLog($dbLogger, "Kullanıcı girişi başarılı.");
processLog($consoleLogger, "Hata oluştu.");
// Çıktı:
// Dosyaya loglandı: Uygulama başlatıldı.
// Veritabanına loglandı: Kullanıcı girişi başarılı.
// Konsola loglandı: Hata oluştu.
?>
Bu örnekte, Logger arayüzü, loglama yeteneğine sahip tüm sınıfların log() metodunu içermesi gerektiğini garanti eder. Bu sayede, processLog() fonksiyonu herhangi bir Logger tipindeki objeyi kabul edebilir, bu da esneklik ve kod tekrarı önleme sağlar.
Bir e-ticaret uygulamasında farklı ödeme geçitleri (Kredi Kartı, PayPal, Havale) olabilir. Bu geçitlerin hepsinin ortak bazı işlevleri (örneğin işlem ücreti hesaplama) ve kendine özgü işlevleri (ödeme onayı) bulunur. Ortak işlevleri soyut bir sınıfta toplayabiliriz.
transactionFeeRate = $rate;
}
// Ortak somut metot
public function calculateFee(float $amount): float {
return $amount * $this->transactionFeeRate;
}
// Soyut metot: Her alt sınıfın kendi ödeme işlemini tanımlaması gerekir
abstract public function processPayment(float $amount): bool;
// Soyut metot: Her alt sınıfın kendi geri ödeme işlemini tanımlaması gerekir
abstract public function refundPayment(string $transactionId): bool;
}
class CreditCardGateway extends PaymentGateway {
public function __construct() {
parent::__construct(0.025); // %2.5 işlem ücreti
}
public function processPayment(float $amount): bool {
echo "Kredi kartı ile " . $amount . " TL ödeme işlemi başlatıldı. Ücret: " . $this->calculateFee($amount) . " TL.
";
// Kredi kartı API'si ile ödeme mantığı
return true;
}
public function refundPayment(string $transactionId): bool {
echo "Kredi kartı işlemi " . $transactionId . " için geri ödeme yapıldı.
";
// Kredi kartı API'si ile geri ödeme mantığı
return true;
}
}
class PayPalGateway extends PaymentGateway {
public function __construct() {
parent::__construct(0.03); // %3 işlem ücreti
}
public function processPayment(float $amount): bool {
echo "PayPal ile " . $amount . " TL ödeme işlemi başlatıldı. Ücret: " . $this->calculateFee($amount) . " TL.
";
// PayPal API'si ile ödeme mantığı
return true;
}
public function refundPayment(string $transactionId): bool {
echo "PayPal işlemi " . $transactionId . " için geri ödeme yapıldı.
";
// PayPal API'si ile geri ödeme mantığı
return true;
}
}
// Kullanım
$creditCard = new CreditCardGateway();
$paypal = new PayPalGateway();
$creditCard->processPayment(100.00);
$paypal->processPayment(250.00);
$creditCard->refundPayment("CC12345");
$paypal->refundPayment("PP67890");
// Çıktı:
// Kredi kartı ile 100 TL ödeme işlemi başlatıldı. Ücret: 2.5 TL.
// PayPal ile 250 TL ödeme işlemi başlatıldı. Ücret: 7.5 TL.
// Kredi kartı işlemi CC12345 için geri ödeme yapıldı.
// PayPal işlemi PP67890 için geri ödeme yapıldı.
?>
Burada PaymentGateway soyut sınıfı, tüm ödeme geçitleri için ortak olan calculateFee() metodunu ve her geçidin kendi içinde uygulaması gereken processPayment() ve refundPayment() soyut metotlarını tanımlar. Bu, kod tekrarını azaltır ve ödeme geçidi eklemeyi standartlaştırır.
Bir soyut sınıfın bir arayüzü uygulaması ve bu soyut sınıfı miras alan somut sınıfların arayüzdeki metotları uygulaması da mümkündür. Bu, hem bir sözleşme sağlamak hem de belirli bir varsayılan uygulama veya ortak davranış seti sunmak için güçlü bir kombinasyondur.
sender = $sender;
}
// Soyut metot: Arayüzden miras alınır ve alt sınıflar tarafından uygulanmalıdır
abstract public function send(string $recipient, string $message): bool;
// Ortak bir somut metot: Tüm bildirim sistemlerinde bulunabilir
public function getSender(): string {
return $this->sender;
}
}
// Somut sınıf: E-posta ile bildirim gönderen bir sistem
class EmailNotifier extends AbstractNotifier {
public function send(string $recipient, string $message): bool {
echo "E-posta gönderiliyor: Kimden: " . $this->getSender() . ", Kime: " . $recipient . ", Mesaj: '" . $message . "'
";
// Gerçek e-posta gönderme mantığı buraya gelir
return true;
}
}
// Somut sınıf: SMS ile bildirim gönderen bir sistem
class SmsNotifier extends AbstractNotifier {
public function send(string $recipient, string $message): bool {
echo "SMS gönderiliyor: Kimden: " . $this->getSender() . ", Kime: " . $recipient . ", Mesaj: '" . $message . "'
";
// Gerçek SMS gönderme mantığı buraya gelir
return true;
}
}
// Kullanım
$emailNotifier = new EmailNotifier("info@example.com");
$smsNotifier = new SmsNotifier("5551234567");
$emailNotifier->send("john.doe@example.com", "Hesabınız başarıyla oluşturuldu.");
$smsNotifier->send("5559876543", "Siparişiniz yola çıktı.");
// Çıktı:
// E-posta gönderiliyor: Kimden: info@example.com, Kime: john.doe@example.com, Mesaj: 'Hesabınız başarıyla oluşturuldu.'
// SMS gönderiliyor: Kimden: 5551234567, Kime: 5559876543, Mesaj: 'Siparişiniz yola çıktı.'
?>
Bu örnekte, Notifier arayüzü tüm bildirim sistemlerinin send() metoduna sahip olmasını sağlayan bir sözleşme sunar. AbstractNotifier soyut sınıfı ise bu arayüzü uygulayarak send() metodunu soyut bırakır, ancak tüm bildirim sistemleri için ortak bir gönderen özelliği ve getSender() metodu sağlar. EmailNotifier ve SmsNotifier sınıfları, AbstractNotifier'ı miras alarak hem Notifier arayüzünün gereksinimlerini yerine getirir hem de ortak getSender() metodunu kullanır.
Amaç Farkı: Arayüzler "ne yapılması gerektiğini" tanımlayan sözleşmelerdir. Soyut sınıflar ise "kim olduğunu" ve "neyin ortak olduğunu" tanımlayan kısmi uygulamalardır.
Çoklu Uygulama vs. Tekli Kalıtım: Bir sınıf birden fazla arayüzü uygulayabilir (implements InterfaceA, InterfaceB), bu PHP'de çoklu kalıtımı simüle etmenin bir yoludur. Ancak bir sınıf yalnızca bir soyut sınıfı miras alabilir (extends AbstractClass).
Metot Erişim Belirleyicileri: Arayüz metotları her zaman public olmak zorundadır. Soyut sınıf metotları ise public veya protected olabilir, ancak private olamaz.
Özellikler (Properties): Arayüzler özellik tanımlayamaz. Soyut sınıflar ise özellik tanımlayabilir ve bu özellikler public, protected veya private olabilir.
Sabitler: Hem arayüzler hem de soyut sınıflar sabitler tanımlayabilir.
Yapıcı Metotlar (Constructors): Soyut sınıflar yapıcı metotlara sahip olabilir. Arayüzler ise PHP 8.1 öncesinde yapıcı metot tanımlayamazdı. PHP 8.1 ve sonrası için arayüzler de yapıcı metot tanımlayabilir, ancak bu metotlar yine soyut olmak zorundadır.
Soyut Metotların Uygulanması: Bir soyut sınıfı miras alan veya bir arayüzü uygulayan somut sınıf, tüm soyut metotları veya arayüz metotlarını uygulamak zorundadır. Aksi takdirde, bu alt sınıfın da soyut olarak tanımlanması gerekir.
Kullanım Seçimi: Eğer sadece bir davranış sözleşmesi tanımlamak ve sınıflar arasında hiçbir ortak kod paylaşımı yoksa arayüz kullanın. Eğer sınıflar arasında ortak kod ve özellikler paylaşılıyorsa ve bu sınıfların aynı "tip" olduğunu belirtmek istiyorsanız soyut sınıf kullanın. Her ikisi de gerektiğinde birlikte kullanılabilir.
JavaScript, web geliştirmenin temel taşlarından biri olmasının yanı sıra, Node.js ile sunucu tarafı uygulamalardan mobil uygulamalara (React Native) ve hatta masaüstü uygulamalarına (Electron) kadar geniş bir alanda kullanılan dinamik ve çok yönlü bir programlama dilidir. Bu kılavuz, JavaScript ile programlama yapmanın temel yapı taşlarını, sözdizimini ve yaygın kullanım senaryolarını adım adım açıklayarak, sağlam bir temel oluşturmanızı hedeflemektedir.
JavaScript kodları, tarayıcılarda veya Node.js gibi çalışma zamanı ortamlarında yorumlanan bir dizi ifade ve deyimden oluşur. Her JavaScript programı, değişken tanımlamaları, operatör kullanımları, kontrol akışı yapıları ve fonksiyon çağrılarının birleşimidir. Temel bir JavaScript programının genel yapısı aşağıdaki gibidir:
// Tek satırlık yorum
/*
* Çok satırlı yorum
*/
// Değişken tanımlamaları
let degiskenAdi = deger;
const sabitDeger = baskaDeger;
// İfadeler ve operatörler
let sonuc = degiskenAdi + 5;
// Kontrol akışı (koşullu ifadeler, döngüler)
if (sonuc > 10) {
// Koşul doğruysa çalışacak kod
} else {
// Koşul yanlışsa çalışacak kod
}
for (let i = 0; i < 5; i++) {
// Döngü içinde çalışacak kod
}
// Fonksiyon tanımlamaları ve çağrıları
function fonksiyonAdi(parametre1, parametre2) {
// Fonksiyonun yapacağı işlemler
return parametre1 + parametre2;
}
let toplam = fonksiyonAdi(10, 20);
Yukarıdaki sözdiziminde yer alan her bir bileşenin ne anlama geldiğini ve nasıl kullanıldığını detaylı olarak inceleyelim:
Değişkenler: JavaScript'te verileri depolamak için değişkenler kullanılır. Değişkenler, var, let veya const anahtar kelimeleriyle tanımlanır.
let: Blok kapsamlı bir değişken tanımlar. Değeri daha sonra değiştirilebilir.
const: Blok kapsamlı, sadece bir kez değer atanabilen sabit bir değişken tanımlar. Atandıktan sonra değeri değiştirilemez.
var: Fonksiyon kapsamlı bir değişken tanımlar. Modern JavaScript'te genellikle let ve const tercih edilir.
Veri Tipleri: JavaScript, farklı türde verileri işleyebilir. Başlıca veri tipleri şunlardır:
Primitive (İlkel) Tipler: string (metin), number (sayı), boolean (mantıksal doğru/yanlış), null (boş değer), undefined (tanımsız), symbol, bigint.
Reference (Referans) Tipler: object (nesneler, diziler, fonksiyonlar).
Operatörler: Değişkenler ve değerler üzerinde işlemler yapmak için kullanılır. Önemli operatör türleri şunlardır:
Aritmetik Operatörler: +, -, *, /, % (modül).
Atama Operatörleri: =, +=, -=, *=, /=.
Karşılaştırma Operatörleri: == (değer eşitliği), === (değer ve tip eşitliği), !=, !==, >, <, >=, <=.
Mantıksal Operatörler: && (VE), || (VEYA), ! (DEĞİL).
Kontrol Akışı: Programın hangi koşullarda hangi kod bloğunu çalıştıracağını belirler.
if...else if...else: Belirli koşullara göre farklı kod bloklarını çalıştırmak için kullanılır.
switch: Tek bir ifadenin birden çok olası değeri için farklı kod blokları tanımlar.
for, while, do...while: Belirli bir koşul karşılanana kadar veya belirli sayıda tekrarlamak için döngü yapıları.
Fonksiyonlar: Belirli bir görevi yerine getiren yeniden kullanılabilir kod bloklarıdır. Parametre alabilir ve bir değer döndürebilirler. function anahtar kelimesiyle veya ok fonksiyonu (arrow function) sözdizimiyle tanımlanabilirler.
Yukarıda açıklanan kavramları pekiştirmek için çeşitli kod örneklerini inceleyelim:
Örnek 1: Değişken Tanımlama ve Aritmetik İşlem
let fiyat = 150;
const KDV_ORANI = 0.18; // Sabit değer
let KDVtutari = fiyat * KDV_ORANI;
let toplamFiyat = fiyat + KDVtutari;
console.log("Ürün Fiyatı:", fiyat); // Çıktı: Ürün Fiyatı: 150
console.log("KDV Tutarı:", KDVtutari); // Çıktı: KDV Tutarı: 27
console.log("Toplam Fiyat:", toplamFiyat); // Çıktı: Toplam Fiyat: 177
Örnek 2: Koşullu İfade (if-else)
let kullaniciYasi = 20;
if (kullaniciYasi >= 18) {
console.log("Ehliyet başvurusunda bulunabilirsiniz.");
} else {
console.log("Ehliyet başvurusu için yaşınız uygun değil.");
}
let puan = 75;
let not;
if (puan >= 90) {
not = "A";
} else if (puan >= 80) {
not = "B";
} else if (puan >= 70) {
not = "C";
} else {
not = "D";
}
console.log("Öğrencinin Notu:", not); // Çıktı: Öğrencinin Notu: C
Örnek 3: Döngü Kullanımı (for)
let meyveler = ["elma", "armut", "muz", "çilek"];
for (let i = 0; i < meyveler.length; i++) {
console.log("Benim favori meyvem: " + meyveler[i]);
}
/* Çıktı:
Benim favori meyvem: elma
Benim favori meyvem: armut
Benim favori meyvem: muz
Benim favori meyvem: çilek
*/
Örnek 4: Fonksiyon Tanımlama ve Çağırma
// İki sayıyı toplayan bir fonksiyon
function topla(sayi1, sayi2) {
return sayi1 + sayi2;
}
let sonuc1 = topla(5, 7);
console.log("5 + 7 =", sonuc1); // Çıktı: 5 + 7 = 12
// İki sayıyı çarpan bir ok fonksiyonu
const carp = (sayi1, sayi2) => {
return sayi1 * sayi2;
};
let sonuc2 = carp(4, 6);
console.log("4 * 6 =", sonuc2); // Çıktı: 4 * 6 = 24
Noktalı Virgül (;) Kullanımı: JavaScript'te ifadelerin sonunda noktalı virgül kullanmak genellikle iyi bir pratiktir, ancak bazı durumlarda JavaScript motoru otomatik olarak ekleyebilir (Automatic Semicolon Insertion - ASI). Yine de belirsizliği önlemek ve kodunuzu daha okunur kılmak için manuel olarak eklenmesi önerilir.
let ve const Tercihi: Modern JavaScript'te değişken tanımlarken her zaman var yerine let veya const kullanın. Bu, kapsam (scoping) sorunlarını azaltır ve kodunuzu daha öngörülebilir hale getirir. Değeri değişmeyecekse const, değişecekse let kullanın.
Tip Zorlaması (Type Coercion): JavaScript, esnek bir dile sahip olduğundan, bazı durumlarda farklı veri tipleri arasında otomatik dönüşümler yapar. Örneğin, "5" + 2 ifadesi "52" sonucunu verirken, "5" - 2 ifadesi 3 sonucunu verir. Bu durum, beklenmedik hatalara yol açabileceği için dikkatli olunmalıdır. Kesin tip karşılaştırmaları için === (üç eşit) operatörünü kullanın.
Yorum Satırları: Kodunuzu açıklamak için yorum satırlarını kullanın. Tek satırlık yorumlar için //, çok satırlık yorumlar için /* ... */ kullanabilirsiniz. Bu, kodunuzun başkaları (ve gelecekteki siz) tarafından daha kolay anlaşılmasını sağlar.
Hata Ayıklama (Debugging): Kodunuzdaki hataları bulmak için console.log() fonksiyonunu sıkça kullanın. Bu, değişkenlerin değerlerini, fonksiyonların çağrılıp çağrılmadığını veya bir kod bloğuna girilip girilmediğini kontrol etmenize yardımcı olur.
SQL veritabanlarında, belirli bir desene uyan metin değerlerini aramak, veri filtreleme işlemlerinin temel bir parçasıdır. LIKE operatörü, bu tür desen tabanlı aramaları gerçekleştirmek için kullanılır. Bu operatör, tam eşleşme yerine kısmi eşleşmeleri veya belirli kalıpları içeren metinleri bulmak gerektiğinde devreye girer ve esnek sorgular oluşturmaya olanak tanır.
LIKE operatörünün genel sözdizimi aşağıdaki gibidir:
SELECT kolon_adi(lar)
FROM tablo_adi
WHERE kolon_adi LIKE desen;LIKE operatörü, WHERE yan tümcesi ile birlikte kullanılarak belirtilen bir sütundaki değerlerin belirli bir desene uyup uymadığını kontrol eder. Bu deseni tanımlamak için iki özel joker karakter (wildcard character) kullanılır:
% (Yüzde İşareti): Sıfır veya daha fazla karakter dizisini temsil eder. Örneğin, 'A%' ile başlayan tüm değerleri, '%A' ile biten tüm değerleri ve '%A%' ile A içeren tüm değerleri bulabilirsiniz.
_ (Alt Çizgi): Tek bir karakteri temsil eder. Örneğin, 'A_C', 'ABC', 'AEC' gibi üç karakterli ve ortasında herhangi bir karakter olan değerleri bulur.
Bu joker karakterler, arama desenini oluşturmak için birleştirilebilir.
Aşağıdaki örnekler, LIKE operatörünün farklı senaryolarda nasıl kullanıldığını göstermektedir. Bu örneklerde, bir Urunler tablosunun UrunAdi sütununda arama yaptığımızı varsayalım.
Örnek 1: Belirli Bir Harf Dizisiyle Başlayan Değerler
'Bilgisayar' kelimesiyle başlayan tüm ürün adlarını bulmak için:
SELECT UrunAdi
FROM Urunler
WHERE UrunAdi LIKE 'Bilgisayar%';Örnek 2: Belirli Bir Harf Dizisiyle Biten Değerler
'Mouse' kelimesiyle biten tüm ürün adlarını bulmak için:
SELECT UrunAdi
FROM Urunler
WHERE UrunAdi LIKE '%Mouse';Örnek 3: Belirli Bir Harf Dizisi İçeren Değerler
Ürün adında 'USB' ifadesi geçen tüm ürünleri bulmak için:
SELECT UrunAdi
FROM Urunler
WHERE UrunAdi LIKE '%USB%';Örnek 4: Belirli Bir Karakter Deseniyle Eşleşen Değerler
İkinci harfi 'a' olan ve toplamda en az üç karakterli ürün adlarını bulmak için:
SELECT UrunAdi
FROM Urunler
WHERE UrunAdi LIKE '_a%';Örnek 5: NOT LIKE Kullanımı
Belirli bir desene uymayan değerleri dışlamak için NOT LIKE operatörü kullanılır. Örneğin, 'Telefon' kelimesiyle başlamayan tüm ürün adlarını bulmak için:
SELECT UrunAdi
FROM Urunler
WHERE UrunAdi NOT LIKE 'Telefon%';Büyük/Küçük Harf Duyarlılığı: LIKE operatörünün büyük/küçük harf duyarlılığı, kullanılan veritabanı sistemine (örneğin, PostgreSQL, MySQL, SQL Server) ve sütunun harmanlama (collation) ayarlarına bağlıdır. Bazı sistemler varsayılan olarak duyarsızken, bazıları duyarlı olabilir veya harmanlama ayarları ile bu durum değiştirilebilir. Büyük/küçük harf duyarlılığından bağımsız arama yapmak için genellikle LOWER() veya UPPER() fonksiyonları ile birlikte kullanılır: WHERE LOWER(kolon_adi) LIKE LOWER('%desen%').
Performans: Özellikle '%' ile başlayan desenler (örneğin, LIKE '%desen') indeks kullanımını zorlaştırabilir ve büyük tablolarda sorgu performansını olumsuz etkileyebilir. Mümkünse, deseni bir harf veya karakter dizisiyle başlatmak (LIKE 'desen%') daha performanslı olabilir.
Kaçış Karakterleri (Escape Characters): Eğer aradığınız desende % veya _ gibi joker karakterler varsa ve bunları literal olarak aramak istiyorsanız, bir kaçış karakteri (escape character) kullanmanız gerekir. Çoğu SQL veritabanı, LIKE '%50\_%' ESCAPE '\' gibi bir sözdizimine izin verir, bu da '50_' ifadesini içeren değerleri arar.
Regular Expressions (Regex): Daha karmaşık desen eşleştirme ihtiyaçları için, birçok veritabanı REGEXP veya RLIKE gibi düzenli ifade operatörlerini destekler. Bu operatörler, LIKE operatörüne göre çok daha güçlü ve esnek desen eşleştirme yetenekleri sunar.
Python'da fonksiyonlar, belirli bir görevi yerine getiren, yeniden kullanılabilir kod bloklarıdır. Bu yapısal elemanlar, kodun modülerliğini artırır, okunabilirliği iyileştirir ve aynı kod bloğunu birden fazla kez yazma ihtiyacını ortadan kaldırarak geliştirme sürecini hızlandırır. Fonksiyonlar, karmaşık problemleri daha küçük, yönetilebilir parçalara ayırmak için temel bir araçtır ve her programlama dilinde olduğu gibi Python'da da etkin kod yazımının vazgeçilmez bir parçasıdır.
Python'da bir fonksiyon tanımlamanın temel sözdizimi aşağıdaki gibidir:
def fonksiyon_adi(parametre1, parametre2=varsayilan_deger):
"""
Bu bir docstring'dir. Fonksiyonun ne iş yaptığını açıklar.
"""
# Fonksiyon gövdesi (işlemlerin yapıldığı yer)
if kosul:
islem1
else:
islem2
return deger
def: Python'da bir fonksiyon tanımlamak için kullanılan anahtar kelimedir. Her fonksiyon tanımı bu kelime ile başlar.
fonksiyon_adi: Fonksiyonunuza verdiğiniz isimdir. Fonksiyon isimleri, işlevlerini yansıtmalı ve snake_case (küçük harflerle ve kelimeler arasına alt çizgi konularak) kuralına uygun olmalıdır. Örneğin: veri_isleme, toplama_yap.
(parametre1, parametre2=varsayilan_deger): Fonksiyonun dışarıdan alacağı giriş değerlerini (argümanları) temsil eden parametre listesidir. Parantezler boş bırakılabilir (parametre almayan fonksiyonlar için), veya virgülle ayrılmış bir ya da daha fazla parametre içerebilir. Parametrelere varsayılan değerler atanabilir; bu durumda, fonksiyon çağrılırken bu parametreler için bir değer sağlanmazsa varsayılan değer kullanılır.
: (İki Nokta Üst Üste): Fonksiyon başlığının sonuna gelir ve fonksiyon gövdesinin başladığını belirtir.
"""Docstring""": Fonksiyonun hemen altında üç tırnak (tek veya çift) içinde yer alan isteğe bağlı bir dizedir. Bu, fonksiyonun ne işe yaradığını, aldığı parametreleri ve döndürdüğü değeri açıklayan bir belgeleme metnidir. Kodun anlaşılırlığını büyük ölçüde artırır ve help() fonksiyonu ile erişilebilir.
# Fonksiyon gövdesi: Fonksiyonun ana mantığını ve çalıştıracağı komutları içeren bloktur. Bu bloktaki tüm satırlar, def anahtar kelimesi ile aynı hizada başlayan satıra göre girintili (genellikle 4 boşluk) olmalıdır. Python'da girintileme, kod bloklarını tanımlamak için kullanılır ve sözdiziminin önemli bir parçasıdır.
return deger: Fonksiyonun çalışmasını sonlandıran ve çağıran yere bir değer döndüren anahtar kelimedir. Bir return ifadesi kullanıldığında, fonksiyonun yürütülmesi durur ve belirtilen değer geri döndürülür. Eğer bir return ifadesi kullanılmazsa veya boş bir return kullanılırsa, Python otomatik olarak None değerini döndürür.
Aşağıdaki örnekler, fonksiyonların Python'da nasıl tanımlandığını ve kullanıldığını göstermektedir.
Örnek 1: Parametre almayan ve değer döndürmeyen basit bir fonksiyon.
def selamla():
"""
Kullanıcıyı selamlayan basit bir fonksiyon.
"""
print("Merhaba, Python dünyasına hoş geldiniz!")
# Fonksiyonu çağırma
selamla()
Örnek 2: Parametre alan ve değer döndüren bir fonksiyon.
def topla(sayi1, sayi2):
"""
İki sayıyı toplayıp sonucu döndüren fonksiyon.
Args:
sayi1 (int/float): Toplanacak birinci sayı.
sayi2 (int/float): Toplanacak ikinci sayı.
Returns:
int/float: İki sayının toplamı.
"""
sonuc = sayi1 + sayi2
return sonuc
# Fonksiyonu çağırma ve döndürülen değeri kullanma
toplam_sonucu = topla(10, 5)
print(f"10 ve 5'in toplamı: {toplam_sonucu}")
farkli_toplam = topla(2.5, 7.3)
print(f"2.5 ve 7.3'ün toplamı: {farkli_toplam}")
Örnek 3: Varsayılan parametre değeri olan bir fonksiyon.
def hesapla_indirim(fiyat, indirim_orani=0.10):
"""
Belirtilen fiyata indirim uygulayarak yeni fiyatı döndüren fonksiyon.
Args:
fiyat (float): Ürünün orijinal fiyatı.
indirim_orani (float, optional): Uygulanacak indirim oranı. Varsayılan %10'dur.
Returns:
float: İndirimli fiyat.
"""
indirim_miktari = fiyat * indirim_orani
indirimli_fiyat = fiyat - indirim_miktari
return indirimli_fiyat
# Fonksiyonu varsayılan indirim oranıyla çağırma
urun_fiyati_1 = 100
yeni_fiyat_1 = hesapla_indirim(urun_fiyati_1)
print(f"100 TL'lik ürünün %10 indirimli fiyatı: {yeni_fiyat_1}")
# Fonksiyonu özel bir indirim oranıyla çağırma
urun_fiyati_2 = 250
yeni_fiyat_2 = hesapla_indirim(urun_fiyati_2, 0.25) # %25 indirim
print(f"250 TL'lik ürünün %25 indirimli fiyatı: {yeni_fiyat_2}")
Girintileme (Indentation): Python'da kod blokları (fonksiyon gövdeleri, döngüler, koşullu ifadeler) girintileme ile tanımlanır. Yanlış girintileme IndentationError hatasına yol açar.
return Anahtar Kelimesi: Bir fonksiyonun bir değer döndürmesini sağlar. Eğer bir fonksiyon return ifadesi içermiyorsa, otomatik olarak None döndürür. print() fonksiyonu ekrana çıktı verirken, return bir değeri fonksiyonun çağrıldığı yere geri verir.
Değişken Kapsamı (Scope): Fonksiyon içinde tanımlanan değişkenler yereldir ve yalnızca o fonksiyon içinde erişilebilirler. Fonksiyon dışında tanımlanan değişkenler ise globaldir ve fonksiyon içinde de erişilebilirler (ancak global anahtar kelimesi kullanılmadan doğrudan değiştirilemezler).
Fonksiyon İsimlendirme Kuralları: Fonksiyon isimleri genellikle küçük harflerle ve kelimeler arasına alt çizgi konularak yazılır (snake_case). Fonksiyonun amacını açıkça belirtmelidir.
Docstring Kullanımı: Her fonksiyon için açıklayıcı bir docstring yazmak iyi bir programlama pratiğidir. Bu, kodunuzu başkaları (veya gelecekteki siz) için daha anlaşılır hale getirir. help(fonksiyon_adi) komutu ile bu belgelere erişebilirsiniz.
Fonksiyon Çağırma: Bir fonksiyonu çalıştırmak için adını ve ardından parantezleri () kullanmanız gerekir (örneğin, selamla()). Parantezler olmadan sadece fonksiyon adını yazmak, fonksiyonun kendisine bir referans verir, onu çalıştırmaz.
PHP 8 ile tanıtılan öznitelikler (attributes), kodunuza yapısal, meta verisel bilgiler eklemenin modern ve deklaratif bir yolunu sunar. Bu özellik, docblock yorumlarının sunduğu sınırlı yeteneklerin ötesine geçerek, sınıflara, yöntemlere, özelliklere, fonksiyonlara, sabitlere ve parametrelere doğrudan programatik meta veriler eklemenize olanak tanır. PHP çekirdeği tarafından sunulan ön tanımlı öznitelikler, geliştiricilere sıkça karşılaşılan senaryolarda kodlarını daha net, güvenli ve yönetilebilir hale getirme imkanı sağlar. Bu makale, PHP'de ön tanımlı özniteliklerin temel kullanımını ve pratik uygulamalarını detaylandıracaktır.
Ön tanımlı öznitelikler, hedeflenen kod öğesinin hemen üzerine, #[ ile başlayıp ] ile biten bir yapı içinde yerleştirilir. Her öznitelik, bir sınıf gibi davranır ve isteğe bağlı olarak parametreler alabilir. Birden fazla öznitelik aynı öğeye uygulanabilir ve bunlar virgül ile ayrılarak aynı #[...] bloğunda veya ayrı bloklarda belirtilebilir.
Genel sözdizimi aşağıdaki gibidir:
Sözdiziminde yer alan ana bileşenler ve anlamları şunlardır:
#[ ve ]: Öznitelik bloğunu tanımlayan sınırlayıcılardır. Tüm öznitelikler bu işaretler arasına yerleştirilmelidir.
AttributeAdi: Uygulanacak özniteliğin adıdır. Bu isim, genellikle PHP çekirdeği veya kütüphaneler tarafından sağlanan ön tanımlı bir öznitelik sınıfının adıdır. Örneğin, #[Deprecated] veya #[Override].
(parametre1: deger1, parametre2: deger2): Bazı öznitelikler, davranışlarını özelleştirmek için parametreler alabilir. Bu parametreler, öznitelik sınıfının kurucusuna (constructor) geçirilen argümanlardır. Parametreler adlandırılmış argümanlar olarak veya konumlarına göre verilebilir. Ön tanımlı özniteliklerde genellikle adlandırılmış argümanlar tercih edilir.
Hedef Konum: Öznitelikler bir sınıfın, bir sınıf özelliğinin (property), bir sınıf metodunun, bir fonksiyonun, bir sınıf sabitinin veya bir metodun/fonksiyonun parametresinin hemen üzerine yerleştirilmelidir.
PHP'nin çekirdeği tarafından sunulan bazı önemli ön tanımlı öznitelikler şunlardır:
#[AllowDynamicProperties]: PHP 8.2'den itibaren dinamik özelliklerin bildirilmemiş sınıflarda kullanılması önerilmez ve ileride hata fırlatabilir. Bu öznitelik, bir sınıfa dinamik özellikler eklenmesine izin verildiğini açıkça belirtir ve bir uyarının (DeprecationWarning) önüne geçer.
#[Override]: PHP 8.3 ile tanıtılan bu öznitelik, bir metodun üst sınıftaki veya uyguladığı arayüzdeki bir metodu geçersiz kıldığını (override ettiğini) açıkça işaretler. Eğer üst sınıfta veya arayüzde böyle bir metod yoksa, çalışma zamanında bir hata fırlatılır. Bu, yazım hatalarını veya refactoring sonrası oluşabilecek hataları engellemeye yardımcı olur.
#[Deprecated]: Bu öznitelik, bir kod öğesinin (sınıf, metot, özellik vb.) kullanımının artık önerilmediğini ve gelecekte kaldırılabileceğini belirtir. Bu, geliştiricilere eski API'leri kullanmaktan kaçınmaları için bir uyarı sağlar.
Örnek 1: #[AllowDynamicProperties] Kullanımı
Bu örnek, bir sınıfa dinamik özellikler eklenmesine izin vermek için #[AllowDynamicProperties] özniteliğinin nasıl kullanılacağını göstermektedir. PHP 8.2 ve sonraki sürümlerde, bu öznitelik olmadan dinamik özellikler kullanıldığında bir öneri (deprecate) uyarısı alırsınız.
$value) {
$this->$key = $value; // Dinamik özellik ataması
}
}
public function getAyari(string $key)
{
return $this->$key ?? null;
}
}
$ayarlar = new Ayarlar(['veritabani' => 'mysql', 'host' => 'localhost']);
echo $ayarlar->getAyari('veritabani'); // Çıktı: mysql
// Dinamik olarak yeni bir özellik eklemek
$ayarlar->cache = true;
echo "
";
echo "Önbellek aktif mi? " . ($ayarlar->cache ? "Evet" : "Hayır");
Yukarıdaki kodda, Ayarlar sınıfı #[AllowDynamicProperties] ile işaretlendiği için, constructor içinde döngü ile veya sonradan dışarıdan dinamik özellikler eklenmesi herhangi bir uyarıya neden olmaz.
Örnek 2: #[Override] Kullanımı
Bu örnek, bir alt sınıfın üst sınıftaki bir metodu doğru bir şekilde geçersiz kıldığını doğrulamak için #[Override] özniteliğinin nasıl kullanılacağını göstermektedir.
ad = $ad;
$this->fiyat = $fiyat;
}
#[Override]
public function getFiyat(): float
{
return $this->fiyat;
}
#[Override]
public function getAd(): string
{
return $this->ad;
}
// Eğer burada yanlışlıkla `getFiyat` yerine `getFiyatX` yazsaydık
// ve #[Override] kullansaydık, PHP çalışma zamanında hata verirdi.
// #[Override]
// public function getFiyatX(): float
// {
// return $this->fiyat;
// }
}
$kitap = new Kitap("PHP Başlangıç Rehberi", 49.99);
echo "Ürün Adı: " . $kitap->getAd() . "
";
echo "Fiyat: " . $kitap->getFiyat();
Yukarıdaki örnekte, Kitap sınıfındaki getFiyat() ve getAd() metotları #[Override] ile işaretlenmiştir. Bu, bu metotların TemelUrun sınıfındaki karşılık gelen metotları geçersiz kıldığını açıkça belirtir. Eğer TemelUrun sınıfında böyle bir metot olmasaydı veya yazım hatası yapılsaydı, PHP bir hata fırlatırdı.
Örnek 3: #[Deprecated] Kullanımı
Bu örnek, bir metodun artık kullanılmaması gerektiğini belirtmek için #[Deprecated] özniteliğinin nasıl kullanılacağını gösterir.
eskiIslem() . "
"; // Bu satır bir "Deprecated" uyarısı verir
echo $obj->yeniIslem();
eskiIslem() metodunu çağırdığınızda, PHP bir "Deprecated" uyarısı verir. Bu uyarı, geliştiricilere bu metodun kullanımından kaçınmaları ve yerine yeniIslem() metodunu kullanmaları gerektiğini bildirir. reason parametresi, uyarının içeriğini özelleştirmek için kullanılır.
Versiyon Uyumluluğu: Öznitelikler PHP 8.0 ve sonraki sürümlerde mevcuttur. #[Override] ise PHP 8.3 ile eklenmiştir. Kullanacağınız özniteliklerin PHP versiyonunuza uygun olduğundan emin olun.
Okunabilirlik ve Bakım: Öznitelikler, kodun amacını ve davranışını daha açık bir şekilde ifade ederek okunabilirliği artırır ve gelecekteki bakımı kolaylaştırır.
Hata Yakalama: #[Override] gibi öznitelikler, derleme zamanında (veya PHP'nin çalışma zamanı öncesi kontrolünde) hataları yakalayarak geliştirme sürecinde potansiyel sorunları erkenden tespit etmenizi sağlar.
Performans Etkisi: Özniteliklerin doğrudan çalışma zamanı performansına önemli bir etkisi yoktur. Genellikle yansıma (reflection) API'leri aracılığıyla okunur ve işlenirler.
Kendi Özniteliklerinizi Tanımlama: PHP, ön tanımlı özniteliklerin yanı sıra kendi özel özniteliklerinizi tanımlamanıza da olanak tanır. Bu, framework'ler ve kütüphaneler için güçlü bir meta programlama aracıdır.
HTML (HyperText Markup Language), web sayfalarının iskeletini oluşturan temel işaretleme dilidir. Bu yapının içinde, elementlere belirli özellikler atamak ve onları gruplandırmak için class niteliği kritik bir rol oynar. class niteliği, bir veya daha fazla HTML elementine stil vermek, JavaScript ile manipüle etmek veya belirli elementleri mantıksal olarak gruplandırmak amacıyla kullanılır. Bu makalede, class niteliğinin temel sözdizimi, detaylı açıklaması ve pratik kullanım örnekleri adım adım incelenecektir.
class niteliği, neredeyse tüm HTML elementlerinde kullanılabilir ve bir elemente bir veya daha fazla sınıf adı atamak için kullanılır. Genel sözdizimi aşağıdaki gibidir:
İçerik Yukarıdaki sözdiziminde yer alan her bir bileşen, class niteliğinin işlevselliğini anlamak için önemlidir:
Sınıf adları, büyük/küçük harf duyarlıdır ve genellikle bir harfle başlamalıdır. Rakamlar, kısa çizgiler ( Aşağıdaki örnekler, Örnek 1: CSS ile Stil Uygulama Bu paragraf kırmızı renkte olacaktır. Bu paragraf mavi renkte olacaktır. Örnek 2: Birden Fazla Sınıf Kullanımı Bu bir uyarı mesajıdır ve orta boyutta gösterilecektir. Örnek 3: JavaScript ile Etkileşim Bu kutucuk JavaScript ile kontrol ediliyor. Büyük/Küçük Harf Duyarlılığı: Sınıf adları büyük/küçük harf duyarlıdır. Örneğin, Anlamlı Adlandırma: Sınıf adlarını, elementin görünümünden ziyade işlevini veya içeriğini yansıtacak şekilde seçmeye çalışın (örn. Boşlukla Ayırma: Bir elemente birden fazla sınıf atamak için sınıf adlarını boşluk karakteriyle ayırın (örn. ID ile Farkı: Performans: Çok fazla sınıf kullanmak veya çok karmaşık CSS seçiciler oluşturmak, özellikle büyük projelerde performans sorunlarına yol açabilir. Temiz ve optimize edilmiş CSS kuralları kullanmaya özen gösterin., ,
, gibi herhangi bir HTML elementini temsil eder. Neredeyse tüm görsel HTML elementleri bu niteliği destekler.
class: Bu, HTML'de önceden tanımlanmış bir niteliktir (attribute). Bir elemente bir veya daha fazla sınıf atamak için kullanılır."sınıf_adı_1 sınıf_adı_2 ...": Bu, elemente atanan sınıf adlarını içeren bir değerdir. Bir elemente birden fazla sınıf atamak mümkündür. Her sınıf adı, boşluk karakteri ile ayrılmalıdır. Örneğin, "menu-item aktif" değeri, elemente hem menu-item hem de aktif sınıflarını atar.
-) ve alt çizgiler (_) içerebilirler. Sınıf adlarının anlamlı ve açıklayıcı olması, kodun okunabilirliğini ve sürdürülebilirliğini artırır.
Pratik Kullanım Örnekleri
class niteliğinin farklı kullanım senaryolarını göstermektedir:
Bu örnekte, iki farklı etiketine farklı sınıflar atanmış ve bu sınıflara CSS aracılığıyla farklı stiller uygulanmıştır. Bu, aynı türdeki elementleri farklı görsel özelliklerle sunmak için yaygın bir yöntemdir.
Bir elemente birden fazla sınıf atayarak, o elementin hem uyarı hem de orta-boyut sınıflarının tanımladığı stilleri alması sağlanır. Bu, CSS kurallarını daha modüler hale getirmeye yardımcı olur.
.uyarı {
border: 1px solid orange;
background-color: #fff3cd;
padding: 10px;
}
.orta-boyut {
font-size: 1.2em;
}
JavaScript, class niteliğini kullanarak belirli elementleri seçebilir ve üzerlerinde dinamik işlemler yapabilir. Aşağıdaki örnekte, gizle-goster sınıfına sahip bir butona tıklandığında, kutucuk sınıfına sahip bir elementinin görünürlüğü değiştirilebilir.
document.querySelector('.gizle-goster').addEventListener('click', function() {
document.querySelector('.kutucuk').classList.toggle('gizli');
});
// style.css (Örnek)
.gizli {
display: none;
}Önemli Notlar
.myClass ve .myclass CSS'te farklı olarak ele alınır..error-message yerine .red-text).class="btn btn-primary").id niteliği bir sayfada yalnızca bir kez kullanılabilirken, class niteliği birden çok elementte tekrar tekrar kullanılabilir. id daha spesifik bir element seçimi için, class ise grup seçimi için idealdir.
9
0
CSS'de max-width özelliği, bir elemanın genişliğinin belirli bir değeri asla aşmamasını sağlamak için kullanılır. Bu özellik, özellikle duyarlı web tasarımlarında, içeriğin farklı ekran boyutlarına uyum sağlaması ve taşma sorunlarını önlemesi açısından kritik bir rol oynar. Bir elemanın doğal genişliği ne olursa olsun, max-width tanımlanan değeri bir üst sınır olarak kabul eder ve elemanın genişliğinin bu sınırı geçmesine izin vermez. Bu sayede, elemanlar mevcut alanlarına dinamik olarak uyum sağlayabilirken, aşırı genişlemesi engellenir.
max-width özelliğinin temel sözdizimi aşağıdaki gibidir:
selector {
max-width: value;
}Yukarıdaki sözdiziminde yer alan bileşenler ve value için kullanılabilecek değerler aşağıda açıklanmıştır:
selector: Bu, CSS kuralının uygulanacağı HTML elemanını veya eleman grubunu hedefleyen bir CSS seçicisidir. Örneğin, .container, img veya #main-content olabilir.
max-width: Uygulanacak CSS özelliğidir.
value: Elemanın genişliğinin aşamayacağı maksimum değeri belirler. Aşağıdaki değer tiplerini alabilir:
length: Piksel (px), yüzde (%), em, rem, vw (viewport width) gibi mutlak veya göreceli uzunluk birimleri kullanılabilir. Örneğin, 600px, 80%, 50em.
none: Bu, max-width özelliğinin varsayılan değeridir. Elemanın maksimum genişlik sınırı yoktur; genişliği doğal içeriğine veya tanımlanmış width özelliğine göre belirlenir.
initial: Özelliği, tarayıcının varsayılan değerine ayarlar (genellikle none).
inherit: Elemanın max-width değerini doğrudan ebeveyn elemanından miras almasını sağlar.
Aşağıdaki örnekler, max-width özelliğinin farklı senaryolarda nasıl kullanılabileceğini göstermektedir.
Bu örnek, bir görselin kapsayıcısının genişliğini aşmamasını ve böylece duyarlı bir şekilde boyutlanmasını sağlar.
/* CSS Kodu */
.image-container {
width: 100%; /* Kapsayıcı tam genişlikte */
max-width: 800px; /* Kapsayıcının maksimum genişliği */
margin: 0 auto; /* Ortalamak için */
}
.image-container img {
max-width: 100%; /* Resim kapsayıcısının genişliğini aşmaz */
height: auto; /* Oranları korur */
display: block; /* Alt boşluğu kaldırmak için */
}Yukarıdaki CSS, Bir web sayfasının ana içerik alanının çok genişlemesini engelleyerek okunabilirliği artırmak için kullanılır. Bu, sayfanın ana içeriğidir. Geniş ekranlarda bile belirli bir genişliği aşmayarak okunabilirliği artırır. ... diğer içerikler ... Bu örnekte, Geniş form alanlarının küçük ekranlarda taşmasını önlerken, büyük ekranlarda da aşırı genişlemesini engeller. Burada, metin giriş alanları ve .image-container sınıfına sahip bir elemanının maksimum 800px genişliğe sahip olmasını sağlar. İçindeki 800px'ten daha geniş olmamasını garanti eder.
Örnek 2: İçerik Kapsayıcısını Sınırlama
/* CSS Kodu */
.main-content {
width: 90%; /* Kapsayıcı %90 genişlikte */
max-width: 1200px; /* Maksimum 1200 piksel genişlik */
margin: 0 auto; /* Ortalamak için */
padding: 20px;
background-color: #f0f0f0;
}.main-content sınıfına sahip eleman, ekran genişliğinin %90'ını kaplar, ancak asla 1200px'i aşmaz. Bu, içeriğin geniş ekranlarda bile çok yayılmamasını sağlayarak kullanıcı için daha rahat bir okuma deneyimi sunar.
Örnek 3: Form Elemanları İçin Kullanım
/* CSS Kodu */
input[type="text"],
textarea {
width: 100%; /* Eleman kapsayıcısının genişliğini doldurur */
max-width: 400px; /* Maksimum 400 piksel genişlik */
padding: 8px;
margin-bottom: 10px;
border: 1px solid #ccc;
box-sizing: border-box; /* Padding ve border'ı genişliğe dahil eder */
}