Мобильный трудоголик on Telegram: “🔢 Generics и Protocols: пишем код на Swift проф…”

🔢 Generics и Protocols: пишем код на Swift профессионально.

Если вы пишете на Swift, но не используете Generics и Protocols на полную, то вы теряете главные преимущества языка. Эти инструменты превращают код из простого набора инструкций в гибкую и безопасную систему.

1️⃣ Generics: пишем код один раз, используем везде.

Дженерики — это параметрический полиморфизм. Проще говоря, мы пишем функцию или тип один раз, а работаем с разными типами данных.

Простой пример:


func swapValues<T>(_ a: inout T, _ b: inout T) {
  let temp = a
  a = b
  b = temp
}

var x = 10
var y = 20
swapValues(&x, &y) // Работает с Int

var s1 = "Hello"
var s2 = "World" 
swapValues(&s1, &s2) // Работает с String

Ограничения generic-ов:


// Проблема: нельзя складывать любой тип данных
func sum<T>(_ a: T, _ b: T) -> T {
  return a + b // Ошибка: Binary operator '+' cannot be applied
}

// Решение: сообщаем компилятору что T должен быть числом
func sum<T: Numeric>(_ a: T, _ b: T) -> T {
  return a + b // Работает с любыми числами
}

Пример с протоколом:


protocol Identifiable {
  var id: Int { get }
}

struct User: Identifiable {
  let id: Int
  let name: String
}

class DataService<T: Identifiable> {
  private var storage: [Int: T] = [:]

  func save(_ item: T) {
    storage[item.id] = item
  }
}

Использование where для сложных ограничений:


func process<T>(_ value: T) where T: Identifiable, T: Equatable {
  // value имеет и id, и может сравниваться
}

2️⃣ Protocols: контракты для ваших типов.

Протоколы определяют требования, которым должны соответствовать типы. Это как чертеж для класса или структуры.

Простой пример:


protocol Drawable {
  func draw()
}

struct Circle: Drawable {
  func draw() {
    print("Рисуем круг")
  }
}

struct Square: Drawable {
  func draw() {
    print("Рисуем квадрат")
  }
}

let shapes: [Drawable] = [Circle(), Square()]
shapes.forEach { $0.draw() }

Расширения протоколов:


extension Drawable {
  // Теперь можно использовать реализацию по умолчанию
  func draw() {
    print("Рисуем что-то")
  }
}

3️⃣ Associated Types: протоколы как дженерики.

Иногда нужно, чтобы протокол работал с разными типами данных, но мы заранее не знаем, с какими именно. Для этого используют associatedtype — это как заглушка для типа, которую заполнят при реализации.

Простой пример:


protocol Storage {
  associatedtype Item
  var items: [Item] { get set }
  func add(_ item: Item)
}

class StringStorage: Storage {
  typealias Item = String  // Задаем тип
  var items: [String] = []

  func add(_ item: String) {
    items.append(item)
  }
}

class IntStorage: Storage {
  var items: [Int] = []  // Компилятор сам определит тип

  func add(_ item: Int) {
    items.append(item)
  }
}

Пример с ограничениями:


protocol ComparableStorage {
  associatedtype Item: Comparable  // Только сравниваемые типы
  func isFirstItemGreater() -> Bool
}

class NumberStorage: ComparableStorage {
  var items: [Int] = [5, 2, 8]

  func isFirstItemGreater() -> Bool {
    return items[0] > items[1]  // Можем сравнивать
  }
}

Что дает associatedtype:

🔹 Гибкость: один протокол для разных типов.
🔹 Безопасность: компилятор следит за типами.
🔹 Четкость: ясно, какие данные ожидаются.

Главное: associatedtype делает протоколы по-настоящему универсальными, позволяя им работать с любыми типами данных, сохраняя при этом полную типобезопасность.

⚠️ Как начать использовать Generics и Protocols эффективно:

🔸 Найдите повторяющийся код: где вы копируете логику для разных типов.
🔸 Определите общее поведение: что общего у ваших объектов.
🔸 Выносите в протоколы: создайте контракты для похожих объектов.
🔸 Добавляйте generics: делайте код универсальным.

💡 Вывод:

Generics и Protocols это не просто синтаксис, а способ мышления. Они превращают Swift из просто языка в инструмент для создания надежных и масштабируемых систем.

➡️ Подписаться на канал
Мобильный трудоголик