DEV Community: Barış Bideratan

Laravel'de Real-Time Facades Nedir? Nasıl Çalışır?

Barış Bideratan — Sun, 09 Nov 2025 11:40:50 +0000

Laravel, servis container yapısıyla dependency injection (bağımlılık enjeksiyonu) kullanımını kolaylaştırır. Ancak bazı durumlarda her servisi container üzerinden almak ya da özel bir Facade sınıfı oluşturmak gereksiz gelebilir. İşte Real-Time Facades bu noktada devreye giriyor.

Kısaca özetlemek gerekirse:

Real-Time Facades, herhangi bir sınıfı veya interface'i, özel bir Facade sınıfı yazmadan Facade gibi kullanmanı sağlar.

Facade Nedir?

Laravel’de Facade, container içindeki bir servise statik gibi görünen bir arabirim sunar.
Örneğin Cache::get() ya da Log::info() çağrıları aslında arka planda container içinden çözümlenir.

Ama her Facade için ayrı bir sınıf yazmak gerekir.
Örneğin App\Facades\MyService gibi.
Real-Time Facades ise bu işi senin yerine yapar.

Normal Kullanım vs Real-Time Facade

Önce klasik bir örnek üzerinden gidelim.

Klasik yöntem:

namespace App\Models;

use App\Services\Publisher;
use Illuminate\Database\Eloquent\Model;

class Podcast extends Model
{
    public function publish(Publisher $publisher)
    {
        $this->update(['published_at' => now()]);

        $publisher->publish($this);
    }
}

Burada Publisher sınıfını method parametresi olarak alıyoruz.
Gayet güzel ama her çağrıda bu parametreyi geçirmek gerekiyor.

Real-Time Facade ile:

namespace App\Models;

use Facades\App\Services\Publisher;
use Illuminate\Database\Eloquent\Model;

class Podcast extends Model
{
    public function publish()
    {
        $this->update(['published_at' => now()]);

        Publisher::publish($this);
    }
}

Bak farkı fark ettin mi?

Artık Publisher servisini parametre olarak geçmedik.
use Facades\App\Services\Publisher; yazarak Laravel’e “bu sınıfı facade gibi kullan” dedik.
Yani Publisher::publish() dediğimizde Laravel container’dan otomatik olarak App\Services\Publisher örneğini çözüp metodu çalıştırıyor.

Gerçekten “Statik” mi Çalışıyor?

Hayır.
Publisher::publish() statik gibi görünse de aslında container’dan dinamik olarak çözülüyor.
Bu sayede test ederken mock oluşturabiliyorsun:

Publisher::shouldReceive('publish')
    ->once()
    ->with($podcast);

Yani hem facade rahatlığını hem test edilebilirliği koruyorsun.

Gerçek Hayattan Bir Örnek

Diyelim ki bir Notifier servisin var:

namespace App\Services;

class Notifier
{
    public function sendEmail($to, $subject)
    {
        // E-posta gönderme işlemi
    }
}

Klasik kullanım:

$notifier = app(\App\Services\Notifier::class);
$notifier->sendEmail('test@example.com', 'Merhaba!');

Real-Time Facade ile:

use Facades\App\Services\Notifier;

Notifier::sendEmail('test@example.com', 'Merhaba!');

Tek satırla aynı işi yaptık.
Kod hem okunabilir hem sade.

Ne Zaman Kullanmalı?

Real-Time Facades harika bir kolaylık ama her yerde kullanmak doğru değil.

Kullan:
✅ Basit servis çağrılarında
✅ Model içindeki küçük yardımcı işlemlerde
✅ Hızlı prototip geliştirme aşamalarında

Kullanma:
❌ Büyük veya karmaşık servislerde
❌ Kodun bağımlılıklarını açık görmek istiyorsan
❌ Fazla mock işlemiyle test yazıyorsan

Kısacası, tıpkı kahve gibi:
Azı lezzet, fazlası çarpıntı. ☕

Özet

use Facades\ ile başlayan bir import yaptığında Laravel otomatik olarak Real-Time Facade oluşturur.
Arka planda container çözümlemesi yapılır, yani dependency injection hâlâ geçerlidir.
Testlerde shouldReceive() kullanarak mock oluşturabilirsin.
Kodun sadeleşir ama “nereden geliyor bu servis?” sorusu bazen bulanıklaşabilir.

APK Dosyalarını Düzenleme ve Yeniden İmzalama: Adım Adım Kılavuz

Barış Bideratan — Tue, 04 Feb 2025 07:08:58 +0000

Selamlar,

Bu makalede, bir Android APK dosyasını nasıl decompile edip, kodları inceleyip düzenleyebileceğinizi, ardından yeniden build, optimize ve imzalama işlemleriyle crack hazırlığınızı nasıl tamamlayacağınızı adım adım anlatacağım. Her bir adımı dikkatle uygulayarak süreci başarıyla tamamlayabilirsiniz. Bir sonraki makalemde de Frida ile javascript kullanarak neler yapabileceğinizi anlatacağım :)

1. APK Dosyasını Çıkarın (Extract)

İlk adımda, apktool kullanarak APK dosyasını extract etmeniz gerekiyor. Bu işlem, APK içeriğini smali dosyalarına ve kaynak dosyalara ayırarak düzenleme yapmanızı sağlar.

apktool d <path>

Burada <path> kısmına düzenlemek istediğiniz APK dosyasının yolunu yazmalısınız.

2. Kodları İnceleyin

Extract işleminin ardından, jadx aracı ile APK dosyasını açıp kodları inceleyin. Jadx, byte kodu okunabilir Java koduna çevirerek uygulamanın mantığını anlamanızı sağlar.

İpucu: Hangi kodlarda değişiklik yapmanız gerektiğine karar verirken, bu aracı kullanarak detaylı bir analiz yapabilirsiniz.

3. Smali Kodlarda Gerekli Değişiklikleri Yapın

Jadx ile incelediğiniz kodlarda emin olduğunuz kısımları belirleyin. Ardından, apktool ile extract ettiğiniz smali dosyaları arasında bu kod satırlarını bulun ve gerekli değişiklikleri uygulayın.

Dikkat: Smali kodlar üzerinde yapacağınız değişiklikler, uygulamanın çalışma mantığını etkileyebileceğinden, dikkatli ve özenli olun.

4. Değişikliklerden Sonra Build İşlemi

Yaptığınız düzenlemeler sonrasında, extract ettiğiniz dosyaların root dizininde iken yeniden build almanız gerekmektedir. Bunun için apktool’un build komutunu kullanın:

apktool b

Bu komut, düzenlenmiş dosyalarınızı yeniden derleyerek yeni bir APK oluşturur.

5. İmzalama İçin Key Oluşturun

Yeni build aldığınız APK’yı imzalayabilmek için öncelikle bir imzalama key’ine ihtiyacınız var. Bunun için keytool kullanarak aşağıdaki komutla key oluşturabilirsiniz:

keytool -genkey -v -keystore DOSYAADI.keystore -alias alias_name -keyalg RSA -keysize 2048 -validity 10000

Açıklama:
- DOSYAADI.keystore: Oluşturulacak keystore dosyasının adı.
- alias_name: Key’in alias adı.
- -keyalg RSA -keysize 2048: RSA algoritması ile 2048 bit büyüklüğünde key oluşturma.
- -validity 10000: Key’in geçerlilik süresi (gün olarak).

6. APK Dosyasını Zipalign ile Optimize Edin

Build işleminden sonra, APK dosyasını zipalign aracı ile optimize ederek hizalamaları düzenleyin. Bu işlem, APK performansını artırır ve yükleme sırasında hata olasılığını azaltır.

zipalign -v 4 original.apk original_zipaligned.apk

Not:
- original.apk: Orijinal build edilmiş APK dosyası.
- original_zipaligned.apk: Zipalign işlemi sonrası oluşacak optimize edilmiş APK dosyası.

7. APK Dosyasını İmzalama

Son adım olarak, uber-apk-signer aracını kullanarak APK dosyasını imzalayın. İmzalama, uygulamanın güvenliği açısından önemlidir ve imzasız APK’lar yüklenmeyebilir.

java -jar uber-apk-signer-1.3.0.jar --skipZipAlign --apks ./

Açıklama:
- --skipZipAlign: Zaten zipalign işlemini tamamladıysanız, tekrar yapmamak için bu parametreyi kullanabilirsiniz.
- --apks ./: İmzalanacak APK dosyasının bulunduğu dizini belirtir.

Sonuç

Yukarıdaki adımları sırasıyla takip ederek APK dosyasını extract ettiniz, kodları incelediniz, gerekli düzenlemeleri yaptınız, yeniden build aldınız, optimize ettiniz ve son olarak imzaladınız. Artık crack işleminiz için hazırlıklar tamam; hayırlı olsun, crack hazır :)

Unutmayın, bu tür işlemler sadece eğitim amaçlıdır. Gerçek bir ürün üzerinde asla denemeyin!

~/Android/Sdk

$ ---- apktool b && cd dist && zipalign -p -f 4 Obsidian-V1.3.objection.apk Obsidian-V1.3.objection_zipaligned.apk && java -jar uber-apk-signer-1.3.0.jar --skipZipAlign --apks ./

PHP’de Early Return: Kodunuzu Temizleyen Basit Bir Yaklaşım

Barış Bideratan — Thu, 09 Jan 2025 09:15:14 +0000

Merhaba Arkadaşlar!

Bugün sizlere yazdığımız kodları daha temiz ve okunabilir hale getiren bir yaklaşımdan bahsedeceğim: Early Return (Erken Dönüş). PHP'de bu yaklaşımı kullanarak hem kod yazma deneyiminizi iyileştirebilir hem de projelerinizin daha bakımı kolay bir hale gelmesini sağlayabilirsiniz.

Early Return Nedir?

Early return, fonksiyonların başında belirli bir koşul karşılandığında veya karşılanmadığında fonksiyonu erken sonlandırmak için kullandığımız bir tekniktir. Bu yöntem, kod içinde gereksiz iç içe bloklardan kurtulmamıza yardımcı olur ve yazım sürecini daha akıcı hale getirir.

Kısaca, bir “guard clause” olarak da adlandırılan bu teknik, “Eğer bu durum karşılanmıyorsa, şu anda dön” mantığıyla çalışır.

Neden Early Return Kullanmalıyız?

Kod yazarken hepimizin amacı daha okunabilir, anlaşılır ve bakımı kolay yapılar oluşturmaktır. Early return tam olarak bunu sağlar:

Okunabilirlik Artar: Kodunuz, gereksiz iç içe bloklardan kurtulduğu için daha temiz ve kolay anlaşılabilir hale gelir.
Hata Kontrolü Daha Kolay Olur: Hata durumlarını hemen kontrol edip ele almak, kodun ilerleyen kısımlarında yanlışların birikmesini önler.
Bakım Kolaylığı: Projenize yeni biri katıldığında veya siz bir süre sonra kodunuza geri döndünüzde, early return kullanan yapılar daha kolay çözülür.
Performans: Gereksiz şekilde fonksiyonun ilerleyen kısımlarını çalıştırmak yerine, önceden dönülerek zamandan tasarruf edilir.

Early Return Nasıl Kullanılır?

Hadi bir senaryo üzerinden early return'i inceleyelim.

Klasik Yaklaşım

Bir kullanıcının yaşını kontrol ettiğimizi düşünelim:

function checkAge($age) {
    if ($age >= 18) {
        echo "Giriş yapabilirsiniz.";
    } else {
        echo "Yaş sınırına uygun değilsiniz.";
    }
}

Bu kod işlevsel gibi görünse de, bir "else" bloğu barındırdığı için okunabilirliği bir miktar düşürebilir. Kod ilerledikçe iç içe geçen blokların arttığını hayal edin.

Early Return ile

Aynı senaryoyu early return kullanarak yazalım:

function checkAge($age) {
    if ($age < 18) {
        echo "Yaş sınırına uygun değilsiniz.";
        return;
    }

    echo "Giriş yapabilirsiniz.";
}

Şimdi bu kodun farklılıklarına bakalım:

Hata durumunu başta kontrol ettik ve hemen geri döndük.
Fonksiyonun geri kalanı yalın ve anlaşılır oldu.
else bloğunu ortadan kaldırdık.

Daha Karmaşık Bir Örnek

Bir kullanıcının sisteme giriş yapması gereken bir senaryoyu düşünelim:

function loginUser($user) {
    if (!$user) {
        echo "Kullanıcı bulunamadı.";
        return;
    }

    if (!$user->isActive) {
        echo "Kullanıcı aktif değil.";
        return;
    }

    echo "Hoş geldiniz, {$user->name}!";
}

Burada farklı durumları teker teker kontrol edip her durumda fonksiyondan erken çıkıyoruz. Bu, iç içe bloklardan kurtulmamıza yardımcı oluyor. Özellikle fonksiyonlarınızda birden fazla kontrol noktaları varsa, bu yaklaşımı kullanmanızı şiddetle tavsiye ederim.

Unutmayın, kod yazarken amacımız sadece çalışan bir sistem değil, aynı zamanda kolay anlaşılabilir bir sistem oluşturmaktır. Siz de early return'i projelerinizde denemeyi unutmayın!

Görüşlerinizi yorumlarda bekliyorum! 😊

PHP'de Metotlar Arası Takip: Hangi Metottan Geldim?

Barış Bideratan — Thu, 19 Dec 2024 07:52:08 +0000

Herkese selamlar! 👋

PHP projelerimizde bazen bir metottan başka bir metodu çağırırken, çağrıyı yapan metodu öğrenmek isteyebiliriz. "Ama neden?" diye sorabilirsiniz. Gelin önce böyle bir duruma neden ihtiyaç duyabileceğimizden bahsedelim.

Neden Hangi Metottan Geldiğini Bilmek İsteyelim?

Diyelim ki bir web uygulaması geliştiriyorsunuz ve birden fazla metot, aynı işlevi yerine getiren ortak bir metodu çağırıyor. Ancak bu ortak metodun davranışını, çağıran metoda göre farklılaştırmak istiyorsunuz. Mesela bir loglama işlemi yapacaksınız ve hangi metottan çağrıldığını bilmek, loglarınıza anlam katacak. Ancak, ek parametreler göndermek istemiyorsunuz; kodunuz sade ve temiz kalsın istiyorsunuz.

İşte tam bu noktada PHP'nin güçlü araçlarından biri olan debug_backtrace yardımımıza koşuyor.

Gerçek Bir Örnek Üzerinden Anlatım

Haydi bir senaryo üzerinden bu işi nasıl yapabileceğimizi görelim. Elimizde şöyle bir Laravel controller'ı olsun:

namespace App\Http\Controllers;

use Illuminate\Http\Request;

class ExampleController extends Controller
{
    public function a()
    {
        return $this->c();
    }

    public function b()
    {
        return $this->c();
    }

    public function c()
    {
        // Çağrının geldiği metodu tespit et
        $trace = debug_backtrace();
        $caller = $trace[1]['function']; // Bir önceki çağrıyı al

        return response()->json([
            'called_from' => $caller,
        ]);
    }
}

Kodun Açıklaması

a() ve b() metotları, ortak olan c() metodunu çağırıyor.
c() metodunda debug_backtrace() fonksiyonunu kullanıyoruz.
debug_backtrace()[1] ile bir önceki çağrının detaylarını alıyoruz.
['function'] anahtarı, çağrıyı yapan metot adını döndürüyor.

Çalışma Sonucu

Eğer tarayıcıda a() metodunu çağırırsanız:

{
  "called_from": "a"
}

b() metodunu çağırırsanız:

{
  "called_from": "b"
}

Bu kadar basit ve etkili! 👌

Nerelerde Kullanabiliriz?

Loglama: Çağrıyı hangi metottan yaptığınızı bilmek, loglarınızı anlamlı hale getirebilir.
Dinamik Davranışlar: Aynı metodu farklı davranışlar sergilemesi için özelleştirmek istediğinizde, çağıran metodu bilmek işinizi kolaylaştırır.
Hata Ayıklama: Uygulama içinde metotların çağrı yığınını görmek, hataları daha hızlı çözmenizi sağlar.

Dikkat Edilmesi Gerekenler

debug_backtrace her ne kadar güçlü bir araç olsa da, bazı durumlarda performans üzerinde etkisi olabilir. Çok sık çağrılan metotlarda kullanıyorsanız dikkatli olun. Ayrıca, bu yöntemi yalnızca gerçekten gerekli olduğunda tercih edin. Aksi halde kodunuz gereksiz karmaşık hale gelebilir.

Sonuç

Metotlar arası takip yapmak gerektiğinde, debug_backtrace tam bir hayat kurtarıcıdır. Ekstra parametrelerle kodu şişirmeden, temiz ve sade bir şekilde çözüm sunar.

Umarım bu yazı sizin için faydalı olmuştur! Eklemek istedikleriniz varsa, yorumlarda buluşalım. 😊

🚀

Laravel'de .env Dosyasında Bir Değişkeni Diğerine Referans Verme

Barış Bideratan — Fri, 27 Sep 2024 20:35:34 +0000

Laravel projelerinde yapılandırma ayarları genellikle .env dosyasında tanımlanır. Çoğu zaman, bu dosya içerisinde bir değişkeni diğer bir değişkene referans etmek isteyebilirsiniz. Bu gibi durumlarda Laravel, ${} string şablonunu kullanmanıza olanak tanır. Böylece önceden tanımladığınız bir değişkeni başka bir değişken içerisinde çağırabilirsiniz.

Nasıl Yapılır?

.env dosyasında bir değişkeni diğerine referans vermek için şu yöntemi kullanabilirsiniz:

APP_NAME=Netsper
DASHBOARD_TITLE="${APP_NAME} Dashboard"

Bu yapılandırma ile, DASHBOARD_TITLE değişkeni artık "Netsper Dashboard" değerine sahip olacaktır. İlk değişken olan APP_NAME değerini doğrudan kullanarak yeni bir string oluşturmuş oldunuz.

Bu basit ancak etkili yöntemi projelerinizde rahatlıkla kullanabilirsiniz!

Laravel Migration: Metin Veri Tipleri Arasındaki Farklar

Barış Bideratan — Wed, 12 Jun 2024 10:17:47 +0000

Herkese selamlar! Bu makalede text, longText, mediumText, ve tinyText veri tiplerini ve bunların kullanımını inceleyeceğiz.

Laravel'de text, longText, mediumText ve tinyText veri tiplerinin farklarını anlamak, veritabanı tasarımınızı optimize etmenize ve doğru veri tipini seçerek performansı artırmanıza yardımcı olur.

Text Veri Tipleri

1. `text`

text veri tipi, orta boyutlu metin verilerini saklamak için kullanılır. 65,535 karaktere kadar veri saklayabilir.

Schema::create('posts', function (Blueprint $table) {
    $table->id();
    $table->text('content');
    $table->timestamps();
});

Bu tip genellikle blog yazıları, açıklamalar veya kullanıcı girdileri gibi orta boyutlu metinler için uygundur.

2. `longText`

longText, büyük miktarda metin verisi saklamak için kullanılır ve 4,294,967,295 karaktere kadar veri saklayabilir.

Schema::create('articles', function (Blueprint $table) {
    $table->id();
    $table->longText('body');
    $table->timestamps();
});

Bu tip, büyük belgeler, uzun makaleler veya HTML içeriklerinin saklanması için idealdir.

3. `mediumText`

mediumText veri tipi, text ve longText arasında bir yerdedir ve 16,777,215 karaktere kadar veri saklayabilir.

Schema::create('comments', function (Blueprint $table) {
    $table->id();
    $table->mediumText('message');
    $table->timestamps();
});

Bu tip, orta boyutlu ile büyük boyutlu metinler arasında yer alan veriler için uygundur, örneğin kullanıcı yorumları veya detaylı açıklamalar.

4. `tinyText`

tinyText veri tipi, çok küçük boyutlu metin verilerini saklamak için kullanılır ve 255 karaktere kadar veri saklayabilir.

Schema::create('tags', function (Blueprint $table) {
    $table->id();
    $table->tinyText('name');
    $table->timestamps();
});

Bu tip, kısa etiketler, açıklamalar veya çok kısa metinler için uygundur.

Metin Veri Tiplerinin Seçimi

Hangi veri tipini kullanmanız gerektiğine karar verirken, saklayacağınız metin verisinin boyutunu ve kullanım amacını göz önünde bulundurmalısınız:

text: Orta boyutlu metinler (blog yazıları, açıklamalar).
longText: Çok büyük metinler (büyük belgeler, HTML içerikleri).
mediumText: Orta ile büyük boyutlu metinler (detaylı kullanıcı yorumları).
tinyText: Çok küçük metinler (etiketler, kısa açıklamalar).

Laravel'de Carbon Kütüphanesini Yerelleştirme

Barış Bideratan — Tue, 11 Jun 2024 08:38:44 +0000

Carbon, yerelleştirme için setLocale metodunu kullanır. Uygulamanızın servis sağlayıcısında veya bir middleware içinde bu ayarı yapabilirsiniz.

AppServiceProvider içine yerleştirerek Carbon'un yerelleştirme ayarlarını yapabilirsiniz:

namespace App\Providers;

use Illuminate\Support\ServiceProvider;
use Carbon\Carbon;

class AppServiceProvider extends ServiceProvider
{
    public function boot()
    {
        Carbon::setLocale(config('app.locale'));
    }
}

Bu örnekte, Laravel'in varsayılan dil ayarı olan app.locale değeri kullanılarak Carbon'un dili ayarlanır. config/app.php dosyasında locale ayarının tr olarak ayarlandığından emin olun:

'locale' => 'tr',

Yerelleştirilmiş Tarih ve Saat Formatlarını Kullanma

Carbon, yerelleştirilmiş formatlarda tarih ve saat görüntülemek için çeşitli metodlar sunar:

$now = Carbon::now();
echo $now->isoFormat('LLLL'); // Örneğin, "Çarşamba, 15 Haziran 2024 14:23" gibi bir çıktı verir.

veya

$now = Carbon::now();
echo $now->translatedFormat('m/d/Y h:i a');

Gördüğünüz gibi Laravel'de Carbon kütüphanesini yerelleştirmek oldukça basit. AppServiceProvider içinde Carbon'un dilini ayarlayarak ve Laravel'in yerelleştirme dosyalarını yapılandırarak tarih ve saat bilgilerini istediğiniz dilde görüntüleyebilirsiniz. Bu sayede, uygulamanızın kullanıcıları kendi dillerinde daha anlaşılır ve kullanıcı dostu bir deneyim yaşarlar.

PHP 8.1 ile Gelen Enum'lar: Kodunuzu Daha Güvenli ve Anlaşılır Hale Getirin

Barış Bideratan — Tue, 11 Jun 2024 07:19:19 +0000

PHP 8.1'in tanıtılmasıyla birlikte birçok yeni özellik ve iyileştirme geldi. Bu özelliklerden biri de enum'lar. Bu yazıda, enum'ların ne olduğunu, PHP'de nasıl kullanıldığını ve yazılım geliştirme sürecinizde neden bu kadar önemli olduklarını detaylı bir şekilde inceleyeceğiz.

Enum Nedir?

Enum (enumeration), belirli bir sabit değerler kümesini tanımlayan bir veri türüdür. Enum'lar, özellikle bir değişkenin belirli, sabit bir grup değerden birini alması gerektiğinde kullanılır. Bu, kodun okunabilirliğini ve bakımını kolaylaştırır ve hataları azaltır.

PHP'de Enum'lar

PHP 8.1 ile birlikte gelen enum'lar, aşağıdaki şekilde tanımlanabilir:

<?php
enum Status {
    case Pending;
    case Approved;
    case Rejected;
}

// Kullanım
$status = Status::Pending;

if ($status === Status::Approved) {
    echo "Status is approved.";
}
?>

Enum'ların Temel Amacı Nedir?

Enum'ların temel amacı, belirli bir grup değeri daha güvenli ve anlaşılır bir şekilde yönetmektir. Bu, kodun okunabilirliğini ve bakımını kolaylaştırır ve hataları azaltır. Özellikle belirli bir değişkenin sadece belirli değerler alması gerektiğinde kullanışlıdır.

Enum Kullanım Senaryoları

Durum Yönetimi: Sipariş durumları, kullanıcı hesap durumları gibi.
Hata Kodları: Belirli hata türlerini tanımlamak için.
Rol Yönetimi: Kullanıcı rolleri (Admin, User, Guest) gibi.
Ödeme Yöntemleri: Kredi kartı, banka havalesi, PayPal gibi ödeme yöntemlerini tanımlamak için.

Enum Tanımlamadığımızda Olabilecek Problemler

Enum'lar kullanılmadığında, belirli bir grup sabit değeri yönetmek için genellikle sabitler veya stringler kullanılır. Bu, aşağıdaki problemlere yol açabilir:

Hata Yapma Riski: Bir string ya da sabit yanlış yazıldığında (örneğin, 'approved' yerine 'aproved'), hata ayıklamak zor olabilir.
Kod Okunabilirliği: Sabitler veya stringler kullanıldığında, kodun okunabilirliği ve anlaşılabilirliği azalabilir.
Bakım Zorluğu: Değerlerde bir değişiklik gerektiğinde (örneğin, 'pending' yerine 'awaiting'), tüm kod tabanını güncellemek zor olabilir.

PHP'de Enum İle İlgili İleri Düzey Özellikler

PHP'de enum'lar, sadece sabit değerlerin bir koleksiyonunu tanımlamakla kalmaz, aynı zamanda enum sınıflarına metotlar da ekleyebilirsiniz:

<?php
enum Status {
    case Pending;
    case Approved;
    case Rejected;

    public function getLabel(): string {
        return match($this) {
            self::Pending => 'Pending',
            self::Approved => 'Approved',
            self::Rejected => 'Rejected',
        };
    }
}

// Kullanım
$status = Status::Pending;
echo $status->getLabel(); // Output: Pending
?>

Enum'ların Avantajları

Güvenlik: Hataları ve yanlış değerleri önler.
Okunabilirlik: Kodun daha anlaşılır ve okunabilir olmasını sağlar.
Bakım Kolaylığı: Değerlerin yönetimini ve güncellenmesini kolaylaştırır.
Tutarlılık: Değerlerin tutarlı bir şekilde kullanılmasını sağlar.

Özetleyelim

PHP 8.1 ile birlikte gelen enum'lar, kodunuzun güvenliğini, okunabilirliğini ve bakımını büyük ölçüde artırır. Belirli sabit değerlerin kullanıldığı her yerde enum'ları tercih ederek kodunuzu daha sağlam ve anlaşılır hale getirebilirsiniz. Özellikle durum yönetimi, hata kodları ve rol yönetimi gibi alanlarda enum'ların gücünden faydalanmak, yazılım geliştirme sürecinizi daha verimli hale getirecektir.

#2 PHP’de Final Sınıflar ve Readonly Sınıflar: Readonly Class

Barış Bideratan — Tue, 11 Jun 2024 07:15:59 +0000

Readonly sınıflar, PHP 8.2 ile birlikte tanıtılan bir özelliktir. Readonly sınıflar, sınıfın tüm özelliklerinin (properties) yalnızca okunabilir olduğu ve yalnızca sınıfın oluşturulması (instantiation) sırasında atanabileceği anlamına gelir. Bu sınıflar, veri tutarlılığını sağlamak ve nesnelerin durumlarının değiştirilmesini önlemek için kullanılır.

Readonly Sınıflar Nedir?

Readonly sınıflar, tüm özelliklerin readonly olduğu sınıflardır. Bu, sınıfın tüm özelliklerinin sadece okunabilir olduğu ve oluşturulduktan sonra değiştirilemeyeceği anlamına gelir.

Readonly Sınıf Tanımlaması

Readonly sınıflar şu şekilde tanımlanır:

<?php
readonly class Point {
    public function __construct(
        public int $x,
        public int $y,
    ) {}
}

$point = new Point(10, 20);

// Özelliklere atama yapılabilir:
echo $point->x; // 10
echo $point->y; // 20

// Ancak özellikler değiştirilemez:
$point->x = 30; // Hata: Cannot modify readonly property Point::$x
?>

Neden Readonly Sınıflara İhtiyaç Duyarız?

Veri Tutarlılığı: Readonly sınıflar, bir nesnenin durumunun değişmesini önleyerek veri tutarlılığını sağlar. Bu, özellikle kritik sistemlerde ve önemli verilerin manipülasyonunun istenmediği durumlarda önemlidir.
Güvenlik: Readonly sınıflar, nesnelerin durumunun değiştirilememesi gereken durumlarda güvenliği artırır. Bu, hatalı veya kötü niyetli kodun veri üzerinde değişiklik yapmasını önler.
Kolay Anlaşılabilirlik: Readonly sınıflar, sınıfın kullanımını daha anlaşılır hale getirir. Bir sınıfın tüm özelliklerinin yalnızca okunabilir olduğunu bilmek, kodun nasıl çalıştığını anlamayı kolaylaştırır.
Yan Etkiyi Azaltma: Nesnelerin durumunun değiştirilememesi, yan etkileri azaltır ve kodun daha tahmin edilebilir olmasını sağlar. Bu, özellikle fonksiyonel programlamada ve yan etkilerin minimumda tutulması gereken durumlarda faydalıdır.

Örnek Kullanım Senaryoları

Koordinatlar veya Noktalar: Coğrafi koordinatlar gibi değişmemesi gereken verileri tutmak için kullanılabilir.
Konfigürasyon Verileri: Uygulamanın çalışma süresince değişmemesi gereken konfigürasyon ayarlarını tutmak için kullanılabilir.
Kimlik Bilgileri: Kullanıcı kimlik bilgileri gibi, değiştirilemez olması gereken verileri saklamak için kullanılabilir.

Readonly Sınıfların Alternatifleri

Readonly sınıflar kullanılmadan önce, benzer işlevselliği sağlamak için getter metotları ve özel setter metotları kullanılırdı. Ancak bu yöntemler, readonly sınıflar kadar doğrudan ve anlaşılır değildir.

<?php
class Point {
    private int $x;
    private int $y;

    public function __construct(int $x, int $y) {
        $this->x = $x;
        $this->y = $y;
    }

    public function getX(): int {
        return $this->x;
    }

    public function getY(): int {
        return $this->y;
    }
}

$point = new Point(10, 20);

// Özelliklere atama yapılabilir:
echo $point->getX(); // 10
echo $point->getY(); // 20

// Ancak özellikler değiştirilemez:
$point->x = 30; // Hata: Cannot access private property Point::$x
?>

#1 PHP’de Final Sınıflar ve Readonly Sınıflar: Final Class

Barış Bideratan — Tue, 11 Jun 2024 07:14:52 +0000

Final Sınıflar Nedir?

Final sınıflar, başka bir sınıf tarafından kalıtılamayan (inheritance) sınıflardır. Bir sınıfı final olarak tanımlamak, o sınıfın alt sınıflarının oluşturulmasını engeller. PHP'de bir sınıfı final anahtar kelimesiyle tanımlayarak bu sınırlamayı getirebilirsiniz.

Final Sınıf Tanımlaması

Final sınıflar şu şekilde tanımlanır:

<?php
final class FinalClass {
    public function sayHello() {
        echo "Hello from FinalClass!";
    }
}

// Hata: FinalClass'tan türetilemez
class AnotherClass extends FinalClass {
}

$finalClass = new FinalClass();
$finalClass->sayHello(); // "Hello from FinalClass!"
?>

Neden Final Sınıflara İhtiyaç Duyarız?

Tasarımın Korunması: Final sınıflar, bir sınıfın tasarımının korunmasını sağlar. Sınıfın davranışının değiştirilmesini veya genişletilmesini istemediğiniz durumlarda kullanılır.
Güvenlik: Özellikle güvenlik açısından kritik sınıfların veya hassas işlevlerin değiştirilememesi gerektiğinde kullanılır.
Performans: PHP'de final sınıflar, JVM (Java Virtual Machine) gibi dillerde olduğu kadar belirgin olmasa da, performans iyileştirmeleri sağlayabilir. Derleyici, final sınıfların kalıtılmayacağını bilerek optimizasyon yapabilir.

Örnek Kullanım Senaryoları

Utility Sınıflar: Helper veya utility fonksiyonları içeren sınıflar genellikle final olarak tanımlanır çünkü bu sınıfların kalıtılması genellikle mantıklı değildir.
Singleton Deseni: Singleton tasarım deseninde kullanılan sınıfın yalnızca bir kez örneklenmesini ve kalıtılmasını önlemek için final olarak tanımlanır.
Güvenlik Katmanları: Belirli bir güvenlik politikası uygulayan sınıflar, bu politikaların değiştirilememesi için final olarak tanımlanabilir.

Final Metotlar

Ayrıca, sınıfın kendisi olmasa da, belirli metotları final olarak tanımlayabilirsiniz. Bu, metodun alt sınıflar tarafından geçersiz kılınmasını (override) engeller.

<?php
class BaseClass {
    public final function sayHello() {
        echo "Hello from BaseClass!";
    }
}

class DerivedClass extends BaseClass {
    // Hata: final method BaseClass::sayHello cannot be overridden
    public function sayHello() {
        echo "Hello from DerivedClass!";
    }
}

$baseClass = new BaseClass();
$baseClass->sayHello(); // "Hello from BaseClass!"
?>

Laravel’de İlişkiler: `belongsToMany` ve `hasMany` Arasındaki Farklar

Barış Bideratan — Mon, 10 Jun 2024 08:50:46 +0000

Laravel, Eloquent ORM (Object-Relational Mapping) yapısı ile veritabanı işlemlerini oldukça kolaylaştırır. Bu yazıda, belongsToMany ve hasMany ilişkileri arasındaki farkları ele alacağız. Bu iki ilişki türünü anlamak, veritabanı modelleriniz arasında doğru bağlantıları kurmak için kritik öneme sahiptir.

`hasMany` İlişkisi

hasMany ilişkisi, bir modelin diğer birçok modele sahip olduğunu belirtir. Bu ilişki genellikle "bir-çok" (one-to-many) ilişkisidir. Örneğin, bir kullanıcının (User) birden fazla gönderisi (Post) olabilir.

Kullanıcı (User) ve Gönderiler (Posts) Örneği

Bir Kullanıcı modelinin birden fazla Gönderi modeli olabilir. Bu durumda, Kullanıcı modelinde hasMany fonksiyonunu tanımlarız.

// User modelinde
public function posts()
{
    return $this->hasMany(Post::class);
}

Burada, posts metodu, bu kullanıcının sahip olduğu gönderileri alır. Post modelinde ise, her gönderinin bir kullanıcıya ait olduğunu belirtiriz.

// Post modelinde
public function user()
{
    return $this->belongsTo(User::class);
}

Bu şekilde, her gönderinin bir kullanıcıya ait olduğunu belirten user metodunu tanımlamış oluruz. Bu ilişki, veritabanında genellikle şu şekilde temsil edilir: posts tablosunda bir user_id sütunu bulunur ve bu sütun, gönderinin hangi kullanıcıya ait olduğunu belirtir.

Özet:

hasMany: Bir modelin diğer birçok modele sahip olduğunu belirtir.
belongsTo: Bir modelin, belirli bir modele ait olduğunu belirtir.

`belongsToMany` İlişkisi

belongsToMany ilişkisi, birçok modelin diğer birçok modele ait olduğunu belirtir. Bu ilişki genellikle "çok-çok" (many-to-many) ilişkisidir. Bu tür ilişkilerde, her iki tablo da birbirine birçok kez bağlı olabilir ve bu bağlantıları temsil eden bir ara tablo (pivot table) kullanılır.

Öğrenciler (Students) ve Dersler (Courses) Örneği

Bir öğrenci birçok derse kaydolabilir ve bir ders birçok öğrenci tarafından alınabilir. Bu durumda, her iki modelde de belongsToMany fonksiyonunu tanımlarız.

// Student modelinde
public function courses()
{
    return $this->belongsToMany(Course::class);
}

Burada, courses metodu, öğrencinin kayıtlı olduğu dersleri alır. Benzer şekilde, Course modelinde, bu dersin kayıtlı olduğu öğrencileri belirtiriz.

// Course modelinde
public function students()
{
    return $this->belongsToMany(Student::class);
}

Bu tür ilişkilerde, ara tablo (pivot table) kullanılır. Bu tablo, her iki modelin ID’lerini içeren iki sütuna sahip olur. Örneğin, course_student adında bir ara tablo olabilir ve bu tablo student_id ve course_id sütunlarını içerir.

Özet:

belongsToMany: Birçok modelin diğer birçok modele ait olduğunu belirtir.
Ara tablo (pivot table) kullanılır.

Örnek Projeler ve Kullanım Senaryoları

Blog Uygulaması: `User` ve `Post` İlişkisi

Bir blog uygulaması düşünelim. Her kullanıcının birçok gönderisi olabilir. Bu ilişkiyi hasMany ve belongsTo ilişkileri ile kurabiliriz.

User Modeli:

class User extends Model
{
    public function posts()
    {
        return $this->hasMany(Post::class);
    }
}

Post Modeli:

class Post extends Model
{
    public function user()
    {
        return $this->belongsTo(User::class);
    }
}

Eğitim Yönetim Sistemi: `Student` ve `Course` İlişkisi

Bir eğitim yönetim sistemi düşünelim. Öğrenciler birçok derse kayıt olabilir ve dersler birçok öğrenci tarafından alınabilir. Bu ilişkiyi belongsToMany ile kurabiliriz.

Student Modeli:

class Student extends Model
{
    public function courses()
    {
        return $this->belongsToMany(Course::class);
    }
}

Course Modeli:

class Course extends Model
{
    public function students()
    {
        return $this->belongsToMany(Student::class);
    }
}

Bu ilişkileri tanımladıktan sonra, veritabanında course_student adında bir ara tablo oluştururuz. Bu tablo, student_id ve course_id sütunlarını içerir.

Sonuç

Laravel’de ilişkileri anlamak, veritabanı modelleri arasında doğru bağlantıları kurabilmek için oldukça önemlidir. hasMany ilişkisi, bir modelin diğer birçok modele sahip olduğu durumlarda kullanılırken, belongsToMany ilişkisi, birçok modelin diğer birçok modele ait olduğu durumlarda kullanılır.

Laravel'de Eloquent ORM İlişkileri: Junior'a Yönelik Kapsamlı Rehber

Barış Bideratan — Mon, 10 Jun 2024 08:28:52 +0000

Laravel'de Eloquent ORM (Object-Relational Mapping), veritabanı ile çalışmayı oldukça kolay ve etkili hale getirir. Eloquent ORM, veritabanı tablolarımızı ve bu tablolar arasındaki ilişkileri kolayca tanımlamamıza ve yönetmemize olanak sağlar. Bu makalede, Eloquent ORM ilişkilerini ayrıntılı bir şekilde ele alacağız. "BelongsToMany", "HasMany" gibi ilişkilerin ne olduğunu, hangi durumlarda kullanıldığını ve nasıl kullanıldığını örnek kodlarla açıklayacağız.

Eloquent ORM İlişki Türleri

1. One-to-One (Bire Bir) İlişkisi

Bir bire bir ilişkisi, bir tablodaki bir kaydın başka bir tablodaki bir kayda bağlanmasıdır. Örneğin, bir kullanıcının yalnızca bir profili olabilir.

Örnek:

Bir User ve Profile tabloları olduğunu varsayalım. Her kullanıcının yalnızca bir profili vardır.

User Model:

class User extends Model
{
    public function profile()
    {
        return $this->hasOne(Profile::class);
    }
}

Profile Model:

class Profile extends Model
{
    public function user()
    {
        return $this->belongsTo(User::class);
    }
}

Bu ilişkide, users tablosu profiles tablosuyla bire bir ilişkilidir. User modelinde hasOne(Profile::class) yöntemi kullanılır çünkü bir kullanıcı sadece bir profile sahip olabilir. Profile modelinde belongsTo(User::class) yöntemi kullanılır çünkü bir profil bir kullanıcıya aittir.

2. One-to-Many (Bire Çok) İlişkisi

Bir bire çok ilişkisi, bir tablodaki bir kaydın başka bir tablodaki birden fazla kayda bağlanmasıdır. Örneğin, bir kullanıcının birden fazla blog gönderisi olabilir.

Örnek:

Bir User ve Post tabloları olduğunu varsayalım. Her kullanıcının birden fazla blog gönderisi olabilir.

User Model:

class User extends Model
{
    public function posts()
    {
        return $this->hasMany(Post::class);
    }
}

Post Model:

class Post extends Model
{
    public function user()
    {
        return $this->belongsTo(User::class);
    }
}

Bu ilişkide, users tablosu posts tablosuyla bire çok ilişkilidir. User modelinde hasMany(Post::class) yöntemi kullanılır çünkü bir kullanıcı birçok blog gönderisine sahip olabilir. Post modelinde belongsTo(User::class) yöntemi kullanılır çünkü bir blog gönderisi bir kullanıcıya aittir.

3. Many-to-Many (Çoktan Çoğa) İlişkisi

Bir çoktan çoğa ilişkisi, bir tablodaki birçok kaydın başka bir tablodaki birçok kayda bağlanmasıdır. Örneğin, bir öğrencinin birçok kursu olabilir ve bir kursun birçok öğrencisi olabilir.

Örnek:

Bir Student ve Course tabloları olduğunu varsayalım. Her öğrencinin birçok kursu olabilir ve her kursun birçok öğrencisi olabilir. Bu tür ilişkilerde genellikle ara bir tablo (pivot table) kullanılır.

Student Model:

class Student extends Model
{
    public function courses()
    {
        return $this->belongsToMany(Course::class);
    }
}

Course Model:

class Course extends Model
{
    public function students()
    {
        return $this->belongsToMany(Student::class);
    }
}

Ara tablo genellikle iki tablonun isimlerinin birleşiminden oluşur, örneğin course_student. Bu tablo, student_id ve course_id sütunlarını içerir.

Migration Örneği:

Schema::create('course_student', function (Blueprint $table) {
    $table->id();
    $table->foreignId('student_id')->constrained()->onDelete('cascade');
    $table->foreignId('course_id')->constrained()->onDelete('cascade');
    $table->timestamps();
});

4. Has Many Through (Dolaylı Bire Çok) İlişkisi

Dolaylı bire çok ilişkisi, bir modelin, bir başka model üzerinden ilişkili olduğu birçok modelin varlığı durumudur. Örneğin, bir ülkenin birçok şehri ve şehirlerin de birçok kullanıcısı olabilir.

Örnek:

Bir Country, City ve User tabloları olduğunu varsayalım. Her ülkenin birçok şehri ve her şehrin birçok kullanıcısı vardır.

Country Model:

class Country extends Model
{
    public function users()
    {
        return $this->hasManyThrough(User::class, City::class);
    }
}

City Model:

class City extends Model
{
    public function country()
    {
        return $this->belongsTo(Country::class);
    }

    public function users()
    {
        return $this->hasMany(User::class);
    }
}

User Model:

class User extends Model
{
    public function city()
    {
        return $this->belongsTo(City::class);
    }
}

Bu ilişkide, countries tablosu users tablosuna cities tablosu üzerinden dolaylı olarak bağlıdır.

5. Polymorphic Relations (Çok Biçimli İlişkiler)

Çok biçimli ilişkiler, farklı modellerin aynı ilişkisel yapıyı paylaşmasına izin verir. Örneğin, hem Post hem de Video modellerinin yorumları olabilir.

Örnek:

Bir Post, Video ve Comment tabloları olduğunu varsayalım. Hem gönderilerin hem de videoların yorumları olabilir.

Post Model:

class Post extends Model
{
    public function comments()
    {
        return $this->morphMany(Comment::class, 'commentable');
    }
}

Video Model:

class Video extends Model
{
    public function comments()
    {
        return $this->morphMany(Comment::class, 'commentable');
    }
}

Comment Model:

class Comment extends Model
{
    public function commentable()
    {
        return $this->morphTo();
    }
}

comments tablosu, commentable_id ve commentable_type sütunlarını içerir. Bu sütunlar, hangi modelin yorumu olduğunu belirtir.

Özet

hasOne: Bir modelin başka bir modelle bire bir ilişkili olduğunu belirtir.
belongsTo: Bir modelin başka bir modelin bir parçası olduğunu belirtir.
hasMany: Bir modelin başka bir modelle bire çok ilişkili olduğunu belirtir.
belongsToMany: Bir modelin başka bir modelle çoktan çoğa ilişkili olduğunu belirtir.

Kullanım Senaryoları

hasOne: Bir kullanıcının yalnızca bir profili olduğunda.
belongsTo: Bir profilin yalnızca bir kullanıcısı olduğunda.
hasMany: Bir kullanıcının birden fazla blog gönderisi olduğunda.
belongsToMany: Bir öğrencinin birçok kursu ve bir kursun birçok öğrencisi olduğunda.

DEV Community: Barış Bideratan

Laravel'de Real-Time Facades Nedir? Nasıl Çalışır?

Facade Nedir?

Normal Kullanım vs Real-Time Facade

Klasik yöntem:

Real-Time Facade ile:

Gerçekten “Statik” mi Çalışıyor?

Gerçek Hayattan Bir Örnek

Klasik kullanım:

Real-Time Facade ile:

Ne Zaman Kullanmalı?

Özet

APK Dosyalarını Düzenleme ve Yeniden İmzalama: Adım Adım Kılavuz

1. APK Dosyasını Çıkarın (Extract)

2. Kodları İnceleyin

3. Smali Kodlarda Gerekli Değişiklikleri Yapın

4. Değişikliklerden Sonra Build İşlemi

5. İmzalama İçin Key Oluşturun

6. APK Dosyasını Zipalign ile Optimize Edin

7. APK Dosyasını İmzalama

Sonuç

PHP’de Early Return: Kodunuzu Temizleyen Basit Bir Yaklaşım

Early Return Nedir?

Neden Early Return Kullanmalıyız?

Early Return Nasıl Kullanılır?

Klasik Yaklaşım

Early Return ile

Daha Karmaşık Bir Örnek

PHP'de Metotlar Arası Takip: Hangi Metottan Geldim?

Neden Hangi Metottan Geldiğini Bilmek İsteyelim?

Gerçek Bir Örnek Üzerinden Anlatım

Kodun Açıklaması

Çalışma Sonucu

Nerelerde Kullanabiliriz?

Dikkat Edilmesi Gerekenler

Sonuç

Laravel'de .env Dosyasında Bir Değişkeni Diğerine Referans Verme

Nasıl Yapılır?

Laravel Migration: Metin Veri Tipleri Arasındaki Farklar

Text Veri Tipleri

1. text

2. longText

3. mediumText

4. tinyText

Metin Veri Tiplerinin Seçimi

Laravel'de Carbon Kütüphanesini Yerelleştirme

Yerelleştirilmiş Tarih ve Saat Formatlarını Kullanma

PHP 8.1 ile Gelen Enum'lar: Kodunuzu Daha Güvenli ve Anlaşılır Hale Getirin

Enum Nedir?

PHP'de Enum'lar

Enum'ların Temel Amacı Nedir?

Enum Kullanım Senaryoları

Enum Tanımlamadığımızda Olabilecek Problemler

PHP'de Enum İle İlgili İleri Düzey Özellikler

Enum'ların Avantajları

Özetleyelim

#2 PHP’de Final Sınıflar ve Readonly Sınıflar: Readonly Class

Readonly Sınıflar Nedir?

Readonly Sınıf Tanımlaması

Neden Readonly Sınıflara İhtiyaç Duyarız?

Örnek Kullanım Senaryoları

Readonly Sınıfların Alternatifleri

#1 PHP’de Final Sınıflar ve Readonly Sınıflar: Final Class

Final Sınıflar Nedir?

Final Sınıf Tanımlaması

Neden Final Sınıflara İhtiyaç Duyarız?

Örnek Kullanım Senaryoları

Final Metotlar

Laravel’de İlişkiler: `belongsToMany` ve `hasMany` Arasındaki Farklar

hasMany İlişkisi

Kullanıcı (User) ve Gönderiler (Posts) Örneği

Özet:

belongsToMany İlişkisi

Öğrenciler (Students) ve Dersler (Courses) Örneği

Özet:

Örnek Projeler ve Kullanım Senaryoları

Blog Uygulaması: User ve Post İlişkisi

Eğitim Yönetim Sistemi: Student ve Course İlişkisi

Sonuç

Laravel'de Eloquent ORM İlişkileri: Junior'a Yönelik Kapsamlı Rehber

1. `text`

2. `longText`

3. `mediumText`

4. `tinyText`

`hasMany` İlişkisi

`belongsToMany` İlişkisi

Blog Uygulaması: `User` ve `Post` İlişkisi

Eğitim Yönetim Sistemi: `Student` ve `Course` İlişkisi