Implementarea principiilor SOLID în Swift

SOLID este un set de principii care vă pot ajuta să scrieți cod care poate fi întreținut, scalabil și
testabil.

SOLID înseamnă:

Principiul responsabilității unice (SRP)

Principiul deschis-închis (OCP)
Principiul substituției Liskov (LSP)
Principiul de segregare a interfeței (ISP)
Principiul inversării dependenței (DIP)

Principiul responsabilității unice (SRP)

Principiul responsabilității unice (SRP) prevede că o clasă ar trebui să aibă un singur motiv
pentru a se schimba. Cu alte cuvinte, o clasă ar trebui să aibă o singură responsabilitate.
Ex:
class User {
let authenticator = Authenticator()
let userDataRetriever = UserDataRetriever()

func authenticate() {
authenticator.authenticate()
}

func getUserData() -> UserData {

return userDataRetriever.getUserData()
}
}

Principiul deschis-închis (OCP)

Principiul Open-Closed (OCP) prevede că o clasă ar trebui să fie deschisă pentru extindere, dar
închisă pentru modificare. Cu alte cuvinte, ar trebui să puteți adăuga o nouă funcționalitate unei
clase fără a modifica codul existent.
EX:
protocol Discount {
func calculateDiscountedPrice(originalPrice: Double) -> Double
}

class Product {
var price: Double = 0.0

func calculatePrice(discount: Discount) -> Double {

let originalPrice = price
let discountedPrice =
discount.calculateDiscountedPrice(originalPrice: originalPrice)
return discountedPrice
}
}

class PercentageDiscount: Discount {

let percentage: Double

init(percentage: Double) {
self.percentage = percentage
}

func calculateDiscountedPrice(originalPrice: Double) -> Double {

let discountedPrice = originalPrice - (originalPrice * (percentage /
100))
return discountedPrice
}
}
let product = Product()
product.price = 100.0

let discount = PercentageDiscount(percentage: 20.0)

let discountedPrice = product.calculatePrice(discount: discount)

print(discountedPrice) // Output: 80.0

Principiul substituției Liskov (LSP)

Principiul de substituție Liskov (LSP) afirmă că o clasă derivată ar trebui să fie înlocuibilă cu clasa sa de
bază fără a afecta corectitudinea programului. Cu alte cuvinte, dacă aveți o referință la o clasă de bază, ar
trebui să puteți înlocui o clasă derivată fără a întrerupe programul.
class Rectangle {
var width: Double
var height: Double

init(width: Double, height: Double) {

self.width = width
 self.height = height
}

func calculateArea() -> Double {

return width * height
}
}
class Square: Rectangle {
override var width: Double {
didSet {
height = width
}
}

override var height: Double {

didSet {
width = height
}
}

init(side: Double) {
super.init(width: side, height: side)
}
}
func printArea(rectangle: Rectangle) {
let area = rectangle.calculateArea()
print("Area: \(area)")
}

let square = Square(side: 10.0)

printArea(rectangle: square)

Principiul de segregare a interfeței (ISP)

Principiul de segregare a interfeței (ISP) prevede că o clasă nu trebuie forțată să depindă de metodele pe
care nu le folosește. Cu alte cuvinte, ar trebui să separați interfețele mari în unele mai mici și mai
specifice.
protocol Scanner {
func scan ()
}

protocol Printer {
func print ()
}

class ScannerPrinter : Scanner , Printer {

 func scan () {
// ...
}

func print () {
// ...
}
}

Principiul inversării dependenței (DIP)

Principiul inversării dependenței (DIP) afirmă că modulele de nivel înalt nu ar trebui să depindă de
modulele de nivel scăzut. În schimb, ambele ar trebui să depindă de abstracții. Cu alte cuvinte, ar trebui
să depindeți de interfețe, nu de implementări.

protocol DataFetching {
func fetchData ( de la url : URL ) -> Date ?
}

class DataFetcher : DataFetching {

func fetchData ( de la url : URL ) -> Date ? {
// ...
}
}

clasa DataManager {
let dataFetcher: DataFetching

init ( dataFetcher : DataFetching ) {

self .dataFetcher =dataFetcher
}

func getData () -> Data ? {

let url = URL (șir: „https://example.com/data.json” ) !
let data = dataFetcher.fetchData(from: url)
return data
}
}

let dataFetcher = DataFetcher ()

let dataManager = DataManager (dataFetcher: dataFetcher)
let data = dataManager.getData()