SOLID Prensipleri

SOLID prensipleri, genellikle yazılım mühendisliği ve yazılım geliştirme süreçlerinde kullanılır. Bu prensipler, kodun daha okunabilir, esnek, sürdürülebilir ve genellikle daha kaliteli olmasını sağlamak için tasarlanmıştır. Bu prensipler şunlardır:

Single Responsibility Principle (Tek Sorumluluk Prensibi):

Bir sınıfın sadece tek bir sorumluluğu olmalıdır. Bu, sınıfın tek bir işlevi yerine getirmesi ve sadece o işlevle ilgili veri ve yöntemlere sahip olması gerektiği anlamına gelir. Bu prensip, kodun daha modüler ve anlaşılır olmasını sağlar.

class Car {
    constructor(make, model) {
        this.make = make;
        this.model = model;
    }

    start() {
        console.log("Car started");
    }

    stop() {
        console.log("Car stopped");
    }
}

Open-Closed Principle (Açık-Kapalı Prensibi):

Bir sınıf, yeni işlevler eklemeye açık olmalı, ancak değişikliklere kapalı olmalıdır. Bu, yeni özellikler eklerken mevcut kodun değiştirilmesine gerek kalmaması gerektiği anlamına gelir. Bu prensip, kodun daha esnek ve sürdürülebilir olmasını sağlar.

class Shape {
    area() {
        throw new Error("Not implemented");
    }
}

class Circle extends Shape {
    constructor(radius) {
        super();
        this.radius = radius;
    }

    area() {
        return Math.PI * this.radius * this.radius;
    }
}

Liskov Substitution Principle (Liskov İkame Prensibi):

Bir alt sınıf, üst sınıfının yerini alabilmelidir. Bu, alt sınıfın, üst sınıfın tüm özelliklerini ve davranışlarını desteklemesi gerektiği anlamına gelir. Bu prensip, kodun daha güvenilir ve test edilebilir olmasını sağlar.

class Bird {
    fly() {
        console.log("Bird is flying");
    }
}

class Duck extends Bird {
    quack() {
        console.log("Duck is quacking");
    }
}

Interface Segregation Principle (Arayüz Segregasyonu Prensibi):

Bir arayüz, sadece bir işlevi yerine getirmelidir. Büyük ve karmaşık arayüzler yerine, her biri tek bir işlevi tanımlayan küçük ve özelleşmiş arayüzler kullanmak daha iyidir. Bu prensip, kodun daha az bağlı ve daha yeniden kullanılabilir olmasını sağlar.

class Printer {
    print() {
        throw new Error("Not implemented");
    }
}

class Scanner {
    scan() {
        throw new Error("Not implemented");
    }
}

class Photocopier {
    print() {
        console.log("Photocopier is printing");
    }

    scan() {
        console.log("Photocopier is scanning");
    }
}

Dependency Inversion Principle (Bağımlılık Ters Çevirme Prensibi):

Sınıflar, somut nesnelere değil, soyut arayüzlere bağımlı olmalıdır. Bu, sınıfların birbirine doğrudan bağlı olmamasını ve daha gevşek bir şekilde bağlanmasını sağlar. Bu prensip, kodun daha test edilebilir ve değiştirilebilir olmasını sağlar.

class Logger {
    log(message) {
        console.log(message);
    }
}

class UserManager {
    constructor(logger) {
        this.logger = logger;
    }

    addUser(user) {
        this.logger.log(`User added: ${user}`);
    }
}

SOLID prensipleri, her yazılımcının bilmesi ve uygulaması gereken temel prensiplerdir. Bu prensiplere uymak, daha sağlam, sürdürülebilir ve esnek yazılımlar geliştirmeye yardımcı olur.

Eğer bu yazı size faydalı olduysa, alkış butonuna tıklayarak teşekkür edebilirsiniz. Ayrıca beni takip ederek yeni yazılarımdan haberdar olabilirsiniz. Bir sonraki yazıda görüşmek üzere!

Eğer iletişime geçmek isterseniz tıklayınız.✨🤝