🤔 Протокол только для класса: protocol: class?

В Swift протокол можно ограничить только для классов, указав : AnyObject (раньше использовалось : class). Это значит, что только ссылочные типы (классы) могут соответствовать такому протоколу. Структуры и перечисления не смогут реализовать его. Это особенно важно при использовании weak или unowned ссылок, так как они применимы только к объектам.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Как работают push нотификации?

Это сообщения, которые отправляются приложением пользователю даже тогда, когда само приложение не активно. Это эффективный способ удержания пользователей и предоставления им важной информации.

🚩Как работают push-уведомления

1⃣Регистрация устройства
Когда приложение устанавливается и запускается на устройстве, оно регистрируется для получения push-уведомлений. Для этого приложение отправляет запрос к Apple Push Notification Service (APNs) с запросом на получение уникального токена устройства (device token).

2⃣Получение токена устройства
APNs генерирует уникальный токен для устройства и отправляет его обратно приложению. Приложение затем передает этот токен на свой сервер.

3⃣Отправка уведомления на сервер
Когда необходимо отправить push-уведомление, сервер приложения формирует сообщение, включающее содержимое уведомления и токен устройства, и отправляет его на APNs.

4⃣Доставка уведомления
APNs принимает сообщение от сервера, определяет устройство по токену и отправляет уведомление на это устройство.

5⃣Получение уведомления на устройстве
Когда устройство получает уведомление, операционная система отображает его пользователю. Если пользователь взаимодействует с уведомлением, приложение может выполнить определенные действия, такие как открытие конкретного экрана.

🚩Пример кода для регистрации устройства

В AppDelegate

import UIKit
import UserNotifications

@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {

    var window: UIWindow?

    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        // Запрос разрешения на отправку уведомлений
        UNUserNotificationCenter.current().requestAuthorization(options: [.alert, .sound, .badge]) { granted, error in
            if granted {
                DispatchQueue.main.async {
                    UIApplication.shared.registerForRemoteNotifications()
                }
            }
        }
        return true
    }

    func application(_ application: UIApplication, didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
        // Преобразуем токен в строку
        let tokenParts = deviceToken.map { data in String(format: "%02.2hhx", data) }
        let token = tokenParts.joined()
        print("Device Token: \(token)")

        // Отправляем токен на сервер
        // serverAPI.registerDeviceToken(token)
    }

    func application(_ application: UIApplication, didFailToRegisterForRemoteNotificationsWithError error: Error) {
        print("Failed to register: \(error)")
    }
}

Ставь 👍 и забирай 📚 Базу знаний

🤔 Как можно предотвратить цикл Retain Cycle?

Использовать слабые (weak) или безвладельные (unowned) ссылки в замыканиях и свойствах между объектами, особенно когда один объект владеет другим, и наоборот. Также помогает осознание, кто должен владеть кем и соблюдение архитектурных границ.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Что должны реализовывать переменные содержащиеся в протоколе?

В Swift переменные (свойства), объявленные в протоколе, должны указывать:

🟠Только для чтения (`get`)
Если свойство объявлено как { get }, класс или структура, реализующая протокол, должна предоставить как минимум геттер

protocol Animal {
    var name: String { get }  // Только чтение
}

struct Dog: Animal {
    let name = "Барсик"  // Реализуем только get
}

let dog = Dog()
print(dog.name) // "Барсик"

Можно также использовать вычисляемое свойство:

struct Cat: Animal {
    var name: String { 
        return "Мурзик" 
    }
}

🟠Для чтения и записи (`get set`)
Если свойство { get set }, класс или структура обязательно должны предоставить и get, и set.

protocol Vehicle {
    var speed: Int { get set }  // Чтение и запись
}

class Car: Vehicle {
    var speed: Int = 100  // Реализуем и get, и set
}

let car = Car()
car.speed = 120  // Можно изменить значение
print(car.speed) // 120

Вычисляемое свойство тоже подойдёт, если оно имеет get и set:

class Bike: Vehicle {
    private var internalSpeed = 50
    
    var speed: Int {
        get { return internalSpeed }
        set { internalSpeed = newValue }
    }
}

🟠Статические свойства (`static`)
Если свойство должно быть общим для всех экземпляров (не индивидуальным), то оно объявляется static.

protocol Config {
    static var appVersion: String { get }
}

struct AppSettings: Config {
    static let appVersion = "1.0.0"
}

print(AppSettings.appVersion) // "1.0.0"

Класс может использовать class var, если свойство можно переопределять в подклассах:

class AppInfo: Config {
    class var appVersion: String {
        return "2.0.0"
    }
}

Ставь 👍 и забирай 📚 Базу знаний

🤔 Что такое автоматический подсчет ссылок?

Это механизм управления памятью, который автоматически освобождает объекты, когда на них больше нет ссылок.
1. Счётчик ссылок увеличивается при создании ссылки и уменьшается при её удалении.
2. Когда счётчик достигает нуля, память освобождается.
3. ARC предотвращает утечки памяти, но требует избегать циклических ссылок с помощью weak и unowned.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Зачем нужны свойства "Content Hugging Priority"?

Свойства "Content Hugging Priority" и "Content Compression Resistance Priority" играют ключевую роль в системе Auto Layout. Эти свойства помогают определить, как вьюшки (views) должны быть отформатированы и как они реагируют на изменения в доступном пространстве в интерфейсе пользователя. Рассмотрим подробнее, что означает каждое из этих свойств и как они используются в разработке интерфейсов.

🚩Content Hugging Priority

Определяет, насколько сильно вьюшка должна "обнимать" своё содержимое. Это свойство указывает на желательность вьюшки быть как можно ближе к своим внутренним размерам, основанным на своем содержимом.

🚩Content Compression Resistance Priority

Определяет, насколько сильно вьюшка должна противостоять сжатию размеров меньше, чем размеры её содержимого.

Ставь 👍 и забирай 📚 Базу знаний

🤔 Что такое escaping closure?

Escaping closure — это замыкание, которое используется после выхода из функции, в которую его передали.
Например, если замыкание сохраняется в свойстве или передаётся асинхронно. Его нужно отметить @escaping, чтобы компилятор знал, что оно будет жить дольше тела функции.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Расскажи про кодирование и декодирование в user defaults

UserDefaults — это хранилище для сохранения простых данных (строки, числа, массивы). Но если нужно сохранить сложные объекты, их сначала кодируют в `Data` (Codable), а затем сохраняют.

🟠Сохранение и загрузка простых данных
Для примитивных типов (строки, числа, массивы, словари) UserDefaults работает без кодирования:

let defaults = UserDefaults.standard

// Сохранение
defaults.set("Иван", forKey: "username")
defaults.set(25, forKey: "age")

// Чтение
let name = defaults.string(forKey: "username") ?? "Нет имени"
let age = defaults.integer(forKey: "age")

print(name, age) // Иван 25

🟠Сохранение сложных объектов (Codable)
Если нужно сохранить свой объект, сначала его нужно закодировать в Data.

struct User: Codable {
    let name: String
    let age: Int
}

Сохранение в UserDefaults

let user = User(name: "Иван", age: 25)
let defaults = UserDefaults.standard

if let encoded = try? JSONEncoder().encode(user) {
    defaults.set(encoded, forKey: "user")
}

Загрузка из UserDefaults

if let savedData = defaults.data(forKey: "user"),
   let savedUser = try? JSONDecoder().decode(User.self, from: savedData) {
    print(savedUser.name, savedUser.age) // Иван 25
}

🟠Удаление данных из `UserDefaults`
Чтобы удалить ключ:

defaults.removeObject(forKey: "user")

🟠Сохранение массива объектов
Можно сохранить массив объектов, просто закодировав его:

let users = [
    User(name: "Иван", age: 25),
    User(name: "Анна", age: 30)
]

if let encoded = try? JSONEncoder().encode(users) {
    defaults.set(encoded, forKey: "users")
}

// Читаем массив обратно
if let savedData = defaults.data(forKey: "users"),
   let savedUsers = try? JSONDecoder().decode([User].self, from: savedData) {
    print(savedUsers) // [{name: Иван, age: 25}, {name: Анна, age: 30}]
}

Ставь 👍 и забирай 📚 Базу знаний

🤔 Есть ли event emitter в колбеках?

В чистых колбеках механизма EventEmitter нет, но его можно интегрировать, например, через библиотеку Node.js. EventEmitter используется для обработки событий, позволяя подписываться на них и обрабатывать асинхронный код. Колбеки могут быть связаны с событиями через вызов функций обратного вызова. Это полезно для построения асинхронной архитектуры.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Чем отличается garbage collector и подсчет ссылок?

Garbage Collector (GC) и Automatic Reference Counting (ARC) – это два разных подхода к управлению памятью в программировании. Они решают одну задачу: автоматическое освобождение неиспользуемой памяти, но делают это по-разному.

🚩Garbage Collector (GC)

Java, Kotlin, C#, Python, JavaScript
- GC периодически просматривает всю память приложения и ищет объекты, на которые больше нет ссылок.
- Когда такие объекты находятся, они удаляются, а память освобождается.
- Это автоматический процесс, который запускается по мере необходимости.

🚩Подсчет ссылок (ARC - Automatic Reference Counting)

Где используется: Swift, Objective-C
- Каждый объект имеет счетчик ссылок (reference count).
- Когда переменная создает ссылку на объект, счетчик увеличивается.
- Когда переменная перестает ссылаться на объект, счетчик уменьшается.
- Когда счетчик достигает нуля, объект удаляется из памяти сразу же.

class Person {
    var pet: Pet?
}

class Pet {
    var owner: Person?
}

let person = Person()
let pet = Pet()

person.pet = pet
pet.owner = person // Теперь оба объекта держат друг друга, и ARC их не удалит

Решение – использовать weak:

class Pet {
    weak var owner: Person? // Теперь утечки памяти не будет
}

Ставь 👍 и забирай 📚 Базу знаний

🤔 Что известно про invaileble оптимизацию?

Вероятно, имелось в виду "invalidatable optimization" — это оптимизация, при которой фреймворк (например, Auto Layout или layout system) может отменить кэш или результаты предыдущих вычислений, если данные изменились. Также это может быть связано с invalidateLayout() в UICollectionViewLayout.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 В каких моментах жизненного цикла лучше поместить подписку?

Подписку на уведомления (NotificationCenter), KVO или Combine в жизненном цикле UIViewController лучше размещать в методах, где гарантируется её актуальность и корректное удаление.

🟠Подписка в `viewDidLoad()`
Подписка на события обычно происходит в `viewDidLoad()`, так как этот метод вызывается один раз при создании контроллера.

override func viewDidLoad() {
    super.viewDidLoad()

    NotificationCenter.default.addObserver(
        self, 
        selector: #selector(handleNotification), 
        name: .someNotification, 
        object: nil
    )
}

@objc func handleNotification(_ notification: Notification) {
    print("Получено уведомление")
}

🟠Подписка в `viewWillAppear()` – если уведомления нужны только при отображении экрана
Если подписка должна работать только когда экран на экране, используем viewWillAppear().

var cancellable: AnyCancellable?

override func viewWillAppear(_ animated: Bool) {
    super.viewWillAppear(animated)

    cancellable = NotificationCenter.default.publisher(for: .someNotification)
        .sink { _ in
            print("Событие получено")
        }
}

🟠`viewWillDisappear()` – отписка от событий
Когда контроллер скрывается, подписки можно удалить, чтобы избежать ненужных вызовов.
Удаление подписки на NotificationCenter:

override func viewWillDisappear(_ animated: Bool) {
    super.viewWillDisappear(animated)
    
    NotificationCenter.default.removeObserver(self, name: .someNotification, object: nil)
}

Удаление Combine подписки (cancellable)

override func viewWillDisappear(_ animated: Bool) {
    super.viewWillDisappear(animated)
    
    cancellable?.cancel()
    cancellable = nil
}

🟠`deinit` – отписка, если подписка создаётся в `viewDidLoad()`
Если подписка работает на протяжении всего жизненного цикла контроллера, её можно удалить в `deinit`.

deinit {
    NotificationCenter.default.removeObserver(self)
}

Ставь 👍 и забирай 📚 Базу знаний

🤔 Где хранится бизнес-логика?

По хорошей архитектуре — в Interactor (Clean Swift) или Model/Service Layer. Она не должна находиться во ViewController, чтобы сохранить читаемость и переиспользуемость.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Какой путь проделывает ивент , когда пользователь нажимает на приложение?

Когда пользователь нажимает на иконку приложения на домашнем экране, iOS проходит несколько этапов перед тем, как приложение становится активным.


🚩Разберём путь события подробнее

🟠Пользователь нажимает на иконку (SpringBoard)
iOS-устройства управляются системой SpringBoard – это оболочка, отвечающая за домашний экран, иконки, фоновые процессы.
Когда пользователь тапает на иконку приложения, SpringBoard отправляет событие UIApplicationLaunchOptionsKey в систему.

🟠iOS загружает процесс приложения
Если приложение не запущено:
- iOS создаёт новый процесс и выделяет память.
- Загружаются зависимости (библиотеки, фреймворки).
- Создаётся объект UIApplication.

🟠Вызывается `application(_:didFinishLaunchingWithOptions:)`
Здесь приложение инициализируется и загружается основной UI.
Метод в AppDelegate:

func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
    print("Приложение запущено")
    return true
}

Ставь 👍 и забирай 📚 Базу знаний

🤔 Какую проблему решает реактивное программирование?

Реактивное программирование упрощает обработку асинхронных потоков данных, таких как события пользовательского интерфейса, API-запросы или изменения состояния. Основные проблемы, которые оно решает:
1. Управление сложными зависимостями между событиями.
2. Обработка потоков данных без блокировки.
3. Упрощение цепочек вызовов через декларативный стиль.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Какие проблемы можно получить , если оставить контекст?

Если оставить контекст в замыкании, не принимая во внимание возможные проблемы, это может привести к нескольким серьезным проблемам, особенно в многопоточном и асинхронном программировании.

🚩Проблемы

🟠Утечки памяти (Retain Cycles)
Одной из самых распространенных проблем является утечка памяти из-за циклов удержания (retain cycles). Это происходит, когда два или более объекта удерживают ссылки друг на друга, препятствуя освобождению памяти. В этом примере closure захватывает self, что создает цикл удержания: MyClass держит сильную ссылку на closure, а closure держит сильную ссылку на self.

class MyClass {
    var value: Int = 0
    var closure: (() -> Void)?

    func setupClosure() {
        closure = {
            self.value += 1
        }
    }
}

let instance = MyClass()
instance.setupClosure()

🟠Непредсказуемое поведение и условия гонки (Race Conditions)
Когда замыкания захватывают изменяемый контекст, это может привести к условиям гонки и непредсказуемому поведению, особенно при работе в многопоточном окружении. Если метод increment вызывается из разных потоков, это может привести к условиям гонки и некорректному изменению значения count.

class Counter {
    var count = 0

    func increment() {
        DispatchQueue.global().async {
            self.count += 1
        }
    }
}

let counter = Counter()
counter.increment()

🟠Задержки в освобождении ресурсов
Если замыкания захватывают тяжелые ресурсы (например, файлы, сети), это может привести к задержкам в их освобождении, что может негативно сказаться на производительности приложения. Если FileHandler освобождается, но замыкание все еще захватывает file, это может привести к задержке в освобождении файлового дескриптора.

class FileHandler {
    var file: File?

    func processFile() {
        DispatchQueue.global().async {
            self.file?.read()
        }
    }
}

🟠Потеря захваченных данных
Когда используется слабая ссылка (weak), замыкание может обнаружить, что захваченный объект освобожден, что приводит к тому, что слабая ссылка становится nil. Это требует дополнительных проверок и обработки.

class MyClass {
    var value: Int = 0
    var closure: (() -> Void)?

    func setupClosure() {
        closure = { [weak self] in
            guard let strongSelf = self else { return }
            strongSelf.value += 1
        }
    }
}

Ставь 👍 и забирай 📚 Базу знаний

🤔 Какие есть ключевые различия в работе с HTTP-запросами и WebSocket?

HTTP — это запрос-ответ, однонаправленный протокол. WebSocket — двунаправленный, позволяет клиенту и серверу обмениваться данными в реальном времени без повторных соединений. HTTP хорош для REST API, WebSocket — для чатов, игр, стриминга.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Что такое мьютекс (mutex)?

Мьютекс (от англ. "mutex" - mutual exclusion, взаимное исключение) — это механизм синхронизации, используемый в многопоточном программировании для предотвращения одновременного доступа нескольких потоков к общим ресурсам, таким как переменные, структуры данных или файлы. Он помогает избежать состояния гонки (race condition), когда результат выполнения программы зависит от неопределённого порядка доступа потоков к ресурсу.

🚩Основные концепции мьютекса

🟠Взаимное исключение
Мьютекс обеспечивает доступ к общему ресурсу только одному потоку в каждый момент времени. Когда один поток захватывает мьютекс, другие потоки должны ждать, пока мьютекс не будет освобождён.

🟠Захват и освобождение
Поток захватывает мьютекс перед доступом к общему ресурсу и освобождает его после завершения работы с этим ресурсом. Если мьютекс уже захвачен другим потоком, текущий поток будет блокирован до тех пор, пока мьютекс не будет освобождён.

🚩Пример использования мьютекса в Swift

import Foundation

class SafeCounter {
    private var value = 0
    private let lock = NSLock()

    func increment() {
        lock.lock()        // Захват мьютекса
        value += 1
        lock.unlock()      // Освобождение мьютекса
    }

    func getValue() -> Int {
        lock.lock()        // Захват мьютекса
        let currentValue = value
        lock.unlock()      // Освобождение мьютекса
        return currentValue
    }
}

let counter = SafeCounter()
DispatchQueue.global().async {
    for _ in 0..<1000 {
        counter.increment()
    }
}

DispatchQueue.global().async {
    for _ in 0..<1000 {
        counter.increment()
    }
}

// Подождём немного, чтобы дать потокам закончить работу
Thread.sleep(forTimeInterval: 1)
print("Final counter value: \(counter.getValue())")

🚩Плюсы и минусы

➕Безопасность данных
Мьютексы защищают общие ресурсы от одновременного доступа, предотвращая повреждение данных.

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

➖Мёртвые блокировки (Deadlocks)
Если мьютексы захватываются в неправильном порядке, это может привести к ситуации, когда два или более потока блокируют друг друга, ожидая освобождения мьютексов.

➖Производительность
Чрезмерное использование мьютексов может привести к снижению производительности из-за увеличения времени ожидания потоков.

Ставь 👍 и забирай 📚 Базу знаний

🤔 За счёт чего стек быстрее кучи?

Стек быстрее кучи, потому что операции в стеке, такие как добавление и удаление, имеют фиксированную сложность O(1), благодаря строгому порядку (LIFO). Стек управляется автоматически, без необходимости выделения и освобождения памяти вручную. Куча, напротив, требует больше времени из-за динамического управления памятью и возможных операций фрагментации.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Какие паттерны знаешь?

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

🚩Порождающие паттерны (Creational)

Помогают упростить создание объектов и сделать его гибким.
Определяет интерфейс для создания объекта, но поручает подклассам выбрать его тип.

protocol Button {
    func press()
}

class iOSButton: Button {
    func press() { print("iOS button pressed") }
}

class AndroidButton: Button {
    func press() { print("Android button pressed") }
}

class ButtonFactory {
    static func createButton(for os: String) -> Button {
        return os == "iOS" ? iOSButton() : AndroidButton()
    }
}

let button = ButtonFactory.createButton(for: "iOS")
button.press() // "iOS button pressed"

🟠Одиночка (Singleton)
Гарантирует, что у класса будет только один экземпляр.

class Database {
    static let shared = Database() // Единственный экземпляр
    private init() { }
    
    func query() { print("Запрос в базу данных") }
}

Database.shared.query()

🟠Строитель (Builder)
Позволяет пошагово создавать сложные объекты.

class Burger {
    var cheese = false
    var bacon = false
}

class BurgerBuilder {
    private var burger = Burger()

    func addCheese() -> Self {
        burger.cheese = true
        return self
    }

    func addBacon() -> Self {
        burger.bacon = true
        return self
    }

    func build() -> Burger {
        return burger
    }
}

let myBurger = BurgerBuilder().addCheese().addBacon().build()
print(myBurger.cheese) // true
print(myBurger.bacon)  // true

🚩Структурные паттерны (Structural)

Определяют удобные способы связи между объектами.

🟠Адаптер (Adapter)
Позволяет совместить несовместимые интерфейсы.

protocol EuropeanSocket {
    func provide220V()
}

class EuropeanPlug: EuropeanSocket {
    func provide220V() { print("220V подано") }
}

class USPlug {
    func provide110V() { print("110V подано") }
}

// Адаптер для американской вилки
class USAdapter: EuropeanSocket {
    private let usPlug: USPlug

    init(usPlug: USPlug) { self.usPlug = usPlug }

    func provide220V() {
        usPlug.provide110V()
        print("Адаптация до 220V")
    }
}

let adapter = USAdapter(usPlug: USPlug())
adapter.provide220V()
// "110V подано"
// "Адаптация до 220V"

🟠Декоратор (Decorator)
Динамически добавляет объекту новое поведение.

protocol Coffee {
    func cost() -> Int
}

class SimpleCoffee: Coffee {
    func cost() -> Int { return 100 }
}

// Декоратор "Молоко"
class MilkDecorator: Coffee {
    private let coffee: Coffee

    init(_ coffee: Coffee) { self.coffee = coffee }

    func cost() -> Int {
        return coffee.cost() + 30
    }
}

let coffee = MilkDecorator(SimpleCoffee())
print(coffee.cost()) // 130

Ставь 👍 и забирай 📚 Базу знаний

🤔 Что такое Core Data?

Core Data — это высокоуровневый фреймворк Apple для управления графами объектов и хранения данных. Он предоставляет разработчику:
- удобное описание моделей;
- автоматическую синхронизацию данных;
- механизмы сохранения в SQLite (или других форматах);
- поддержку undo, lazy loading, валидации и интеграции с UI.
Core Data особенно полезна в приложениях с богатой моделью данных, связями и сложной логикой.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний