🤔 Чем отличается dispatch_async от dispatch_sync?

dispatch_async — выполняет задачу асинхронно, не дожидаясь завершения, и позволяет продолжить выполнение кода.
dispatch_sync — запускает задачу синхронно и блокирует текущий поток до её окончания. Используется, когда важно дождаться результата, но может привести к зависанию, если применён неаккуратно.

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

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

В 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"
    }
}

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

🤔 Расскажи про capture list?

Capture list в замыканиях Swift используется для управления захватом переменных, предотвращая сильные ссылки ([weak self]) или обеспечивая их копирование ([x]). Это помогает управлять памятью и избегать утечек.

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

🤔 Надо ли отслеживать статус задачи в dispatchworkitem?

Да, отслеживание статуса задачи в DispatchWorkItem может быть полезным, но это зависит от требований приложения.

🟠Когда это полезно?
Если задача может быть отменена (cancel())
Если выполнение задачи можно приостановить или продолжить
Если нужно проверить завершение перед выполнением следующего действия*

let workItem = DispatchWorkItem {
    print("Задача выполняется")
}

// Запускаем задачу
DispatchQueue.global().async(execute: workItem)

// Отмена перед выполнением
workItem.cancel()

// Проверяем статус выполнения
if workItem.isCancelled {
    print("Задача отменена")
} else {
    print("Задача выполнена")
}

🟠Можно ли проверить, завершена ли задача?
В DispatchWorkItem нет метода проверки завершения.
Но можно вручную отслеживать завершение с помощью notify:

let workItem = DispatchWorkItem {
    print("Задача выполняется")
}

// Сообщаем о завершении
workItem.notify(queue: .main) {
    print("Задача завершена")
}

DispatchQueue.global().async(execute: workItem)

🟠Надо ли всегда отслеживать статус?
Если задача короткая и простая → НЕ ОБЯЗАТЕЛЬНО.
Если задача важная, может быть отменена или зависит от других задач → ЛУЧШЕ ОТСЛЕЖИВАТЬ.

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

🤔 Кто последний может обработать кнопку в иерархии вьюшек?

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

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

🤔 Что относится к типам данных?

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

🤔 Основные типы данных

🟠Примитивные типы данных
Представляют целые числа. Int, UIn

       let age: Int = 25
       

Представляют дробные числа. Float, Double

       let pi: Double = 3.14159
       

Представляют логические значения true или false. Bool

       let isActive: Bool = true
       

Представляют отдельные символы. Character

       let letter: Character = "A"
       

🟠Составные типы данных (Composite data types)
Представляют последовательности символов. String

       let greeting: String = "Hello, World!"
       

Представляют упорядоченные коллекции элементов одного типа. Array<T>

       let numbers: [Int] = [1, 2, 3, 4, 5]
       

Представляют коллекции пар ключ-значение. Dictionary<Key, Value>

       let user: [String: String] = ["name": "Alice", "age": "30"]
       

Представляют коллекции уникальных элементов. Set<T>

       let uniqueNumbers: Set<Int> = [1, 2, 3, 4, 5]
       

🟠Пользовательские типы данных (User-defined data types)
Представляют тип данных с набором связанных значений. enum

       enum CompassPoint {
           case north
           case south
           case east
           case west
       }
       

Представляют группы связанных значений. struct

       struct Person {
           var name: String
           var age: Int
       }
       let person = Person(name: "Alice", age: 30)
       

Представляют объекты с состоянием и поведением. class

       class Car {
           var model: String
           var year: Int
           
           init(model: String, year: Int) {
               self.model = model
               self.year = year
           }
       }
       let car = Car(model: "Tesla", year: 2021)
       

🟠Специальные типы данных
Представляют группы нескольких значений различных типов. (Type1, Type2, ...)

       let coordinates: (Int, Int) = (10, 20)
       

Представляют значение, которое может быть либо некоторым значением, либо nil. Optional<T>

       var optionalName: String? = "Alice"

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

🤔 Как переводил сущности с MVC на Clean Swift?

В Clean Swift (VIP) сущности делятся на Interactor, Presenter и ViewController. Сущность из MVC преобразуется в модель запроса/ответа (Request/Response), ViewModel и передаётся по цепочке: VC → Interactor → Presenter → View.

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

🤔 Чем опасна утечка памяти?

Утечка памяти (memory leak) – это ситуация, когда память остаётся выделенной, но больше не используется программой и не освобождается.

class Person {
    var pet: Pet? 
    deinit { print("Person удалён") }
}

class Pet {
    var owner: Person?
    deinit { print("Pet удалён") }
}

var person: Person? = Person()
var pet: Pet? = Pet()

person?.pet = pet
pet?.owner = person

person = nil
pet = nil

🚩Как избежать утечек памяти?

🟠Использовать `weak` или `unowned` ссылки
Слабые (weak) или безвладельческие (unowned) ссылки не увеличивают счётчик ссылок, что разрывает цикл.

class Person {
    var pet: Pet?
    deinit { print("Person удалён") }
}

class Pet {
    weak var owner: Person? // Слабая ссылка
    deinit { print("Pet удалён") }
}

var person: Person? = Person()
var pet: Pet? = Pet()

person?.pet = pet
pet?.owner = person

person = nil  // "Person удалён"
pet = nil     // "Pet удалён"

🟠Использовать `unowned`, если объект всегда будет существовать
unowned похож на weak, но он не может быть `nil`.

class Owner {
    var car: Car?
    deinit { print("Owner удалён") }
}

class Car {
    unowned var owner: Owner // Безвладельческая ссылка
    init(owner: Owner) { self.owner = owner }
    deinit { print("Car удалён") }
}

var owner: Owner? = Owner()
owner?.car = Car(owner: owner!)

owner = nil // "Owner удалён", "Car удалён"

🟠Разрывать циклы в замыканиях (`[weak self]`)
Замыкания захватывают объекты, создавая циклические ссылки.
Проблема: self удерживается замыканием

class ViewController {
    var closure: (() -> Void)?
    
    func setup() {
        closure = {
            print(self) // Удерживает self, создавая цикл!
        }
    }

    deinit { print("ViewController удалён") }
}

var vc: ViewController? = ViewController()
vc?.setup()
vc = nil // ❌ "ViewController" НЕ удалится

🚩Как найти утечки памяти?

🟠Использовать `Instrument – Leaks` в Xcode
- Открываем Xcode > Product > Profile.
- Выбираем Leaks.
- Запускаем приложение и проверяем, остаются ли объекты в памяти.

🟠Проверить `deinit`
Если метод deinit не вызывается – значит, объект утёк в память.

class Test {
    deinit { print("Test удалён") }
}

var obj: Test? = Test()
obj = nil // Должно напечатать "Test удалён"

🟠Включить `Malloc Stack Logging`
- В Xcode открываем "Debug Memory Graph" (нажимая значок в Debugger).
- Смотрим, какие объекты остались в памяти.

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

🤔 Что такое Auto Layout?

Auto Layout — это система в iOS и macOS, которая автоматически рассчитывает размеры и положение элементов интерфейса на основе ограничений (constraints). Это позволяет адаптировать интерфейс под различные размеры экранов и ориентации устройств. Auto Layout поддерживает как верстку в коде, так и визуальное редактирование в Interface Builder. С помощью системы Auto Layout можно создавать интерфейсы, которые динамически изменяются в зависимости от контекста.

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

🤔 Расскажи про классы

Классы — это ссылочные типы в Swift, которые позволяют создавать объекты с общими свойствами и методами. Они поддерживают наследование, работают с ARC (Automatic Reference Counting) и хранятся в куче (heap).

🚩Основные характеристики классов

🟠Ссылочный тип
Когда вы присваиваете класс другой переменной, копируется не сам объект, а ссылка на него. Изменения, сделанные через одну ссылку, затронут и другие.

🟠Хранятся в куче
В отличие от структур, которые хранятся в стеке, классы создают объекты в куче. Это позволяет передавать объекты между функциями без копирования.

🟠Automatic Reference Counting (ARC)
Swift использует ARC для управления памятью. Объект удаляется из памяти, когда на него больше нет ссылок.

🟠Наследование
В отличие от структур, классы могут наследовать свойства и методы от других классов. Поддерживают переопределение методов (override).

🟠Идентичность объектов
Два объекта класса можно сравнивать по ссылке (===), а не только по значению (==).

class Animal {
    var name: String
    
    init(name: String) {
        self.name = name
    }
    
    func speak() {
        print("Some sound")
    }
}

class Dog: Animal {
    override func speak() {
        print("Woof!")
    }
}

let dog1 = Dog(name: "Buddy")
let dog2 = dog1  // Копируется ссылка, а не объект

dog2.name = "Charlie"

print(dog1.name)  // "Charlie", так как dog1 и dog2 указывают на один объект

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

🤔 Какие есть нюансы в работе с closures?

Ключевые нюансы: захват значений (в т.ч. возможные retain cycles), необходимость указывать [weak self], использование замыканий в качестве обратных вызовов и обработчиков. Также важно понимать отличия между escaping и non-escaping closures — то есть тех, которые выходят за пределы области вызова.

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

🤔 Как устроена память?

Память устройства можно представить в виде нескольких уровней, каждый из которых имеет свою скорость доступа, размер и назначение:

🟠Регистры процессора
Это самая быстрая память, непосредственно встроенная в процессор. Регистры хранят те данные, с которыми процессор работает в данный момент времени.

🟠Кэш-память
Она находится непосредственно на процессоре или рядом с ним. Кэш-память используется для временного хранения копий часто используемых данных из основной памяти для ускорения доступа к ним. Кэш-память делится на несколько уровней (L1, L2, и иногда L3), где L1 — самый быстрый и обычно самый маленький.

🟠Оперативная память (ОЗУ)
Здесь хранятся данные и программы, с которыми компьютер работает в данный момент. Доступ к ОЗУ быстрый, но оно является временным хранилищем: при выключении устройства данные в ОЗУ теряются.

🟠Постоянная память (ПЗУ, SSD, HDD)
Это память для долговременного хранения данных. Она сохраняет информацию даже при выключении питания. HDD (жесткие диски) использовались ранее и работают на принципе магнитного записывания данных, в то время как SSD (твердотельные накопители) работают на основе флеш-памяти и обеспечивают более быстрый доступ к данным.

🟠Виртуальная память
Это техника, которая позволяет операционной системе использовать часть жесткого диска (или SSD) как дополнительную оперативную память. Когда ОЗУ заполнено, операционная система может перемещать редко используемые данные из ОЗУ на диск в специальный файл подкачки (swap file), освобождая ОЗУ для других задач.

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

🤔 Что дают параметры Auto Layout?

Auto Layout управляет позиционированием и размером элементов UI независимо от размера экрана. Параметры позволяют задать зависимости между элементами, адаптивность интерфейса, привязку к краям, отступы, пропорции.

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

🤔 Где фреймы наиболее яркий пример использования?

Фреймы (frames) в iOS-разработке используются для задания размеров и расположения элементов интерфейса (UIView) вручную.

🟠Кастомные анимации
Когда нужно анимировать движение элемента, проще всего работать с его frame, так как он напрямую управляет origin (координаты) и size (размеры).

UIView.animate(withDuration: 0.5) {
    self.button.frame.origin.x += 100
}

🟠Ручная верстка (без Auto Layout)
Если вы не используете Auto Layout или хотите задать положение элементов программно, frame позволяет точно указать размеры и координаты.

let button = UIButton(type: .system)
button.frame = CGRect(x: 50, y: 100, width: 200, height: 50)
button.setTitle("Нажми меня", for: .normal)
view.addSubview(button)

🟠Оптимизация производительности
При динамической подгрузке ячеек в UITableView или UICollectionView можно вручную вычислять frame для ускорения работы, вместо использования Auto Layout, который может замедлить скроллинг.

🟠Работа с Core Graphics и CALayer
При рисовании или настройке слоев CALayer используется frame, чтобы точно определить размеры слоя.

let borderLayer = CALayer()
borderLayer.frame = CGRect(x: 0, y: 0, width: 100, height: 100)
borderLayer.borderWidth = 2
borderLayer.borderColor = UIColor.red.cgColor
view.layer.addSublayer(borderLayer)

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

🤔 Как включить статическую диспетчеризацию?

Статическая диспетчеризация включается автоматически при работе с struct, enum, final class, или при вызове private методов. Она компилируется напрямую без использования vtable, что повышает производительность.

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

🤔 Какие знаешь способы внедрения зависимостей?

Внедрение зависимостей (Dependency Injection, DI) в iOS-приложениях позволяет сделать код более модульным, тестируемым и поддерживаемым. Рассмотрим основные способы внедрения зависимостей в Swift.

🟠Внедрение через инициализатор (Initializer Injection)
Это самый распространенный и рекомендуемый способ. Зависимости передаются в объект через его инициализатор.

protocol NetworkServiceProtocol {
    func fetchData()
}

class NetworkService: NetworkServiceProtocol {
    func fetchData() {
        print("Данные загружены")
    }
}

// Класс, которому нужна зависимость
class ViewModel {
    private let networkService: NetworkServiceProtocol

    init(networkService: NetworkServiceProtocol) {
        self.networkService = networkService
    }

    func loadData() {
        networkService.fetchData()
    }
}

// Использование
let networkService = NetworkService()
let viewModel = ViewModel(networkService: networkService)
viewModel.loadData()

🟠Внедрение через свойства (Property Injection)
Зависимость передается через свойство класса.

class ViewModel {
    var networkService: NetworkServiceProtocol?

    func loadData() {
        networkService?.fetchData()
    }
}

// Использование
let viewModel = ViewModel()
viewModel.networkService = NetworkService()
viewModel.loadData()

🟠Внедрение через метод (Method Injection)
Зависимость передается непосредственно в метод, который её использует.

class ViewModel {
    func loadData(with networkService: NetworkServiceProtocol) {
        networkService.fetchData()
    }
}

// Использование
let viewModel = ViewModel()
let networkService = NetworkService()
viewModel.loadData(with: networkService)

🟠Использование Service Locator (Антипаттерн)
Класс сам запрашивает зависимость у глобального локатора.

class ServiceLocator {
    static let shared = ServiceLocator()
    
    private var services: [String: Any] = [:]

    func register<T>(_ service: T) {
        let key = String(describing: T.self)
        services[key] = service
    }

    func resolve<T>() -> T? {
        let key = String(describing: T.self)
        return services[key] as? T
    }
}

// Регистрация зависимостей
let locator = ServiceLocator.shared
locator.register(NetworkService() as NetworkServiceProtocol)

// Использование
class ViewModel {
    func loadData() {
        let networkService: NetworkServiceProtocol? = ServiceLocator.shared.resolve()
        networkService?.fetchData()
    }
}

🟠Использование DI-контейнеров (например, Swinject)
Специальные библиотеки помогают управлять зависимостями.

import Swinject

let container = Container()
container.register(NetworkServiceProtocol.self) { _ in NetworkService() }

class ViewModel {
    private let networkService: NetworkServiceProtocol

    init(networkService: NetworkServiceProtocol) {
        self.networkService = networkService
    }

    func loadData() {
        networkService.fetchData()
    }
}

// Разрешение зависимости через контейнер
let networkService = container.resolve(NetworkServiceProtocol.self)!
let viewModel = ViewModel(networkService: networkService)
viewModel.loadData()

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

🤔 Как обновлять коллекции?

Для UICollectionView и UITableView можно использовать:
- reloadData() (перезагружает всё);
- performBatchUpdates() (для анимации и вставок);
- DiffableDataSource (современный подход с snapshot);
- reloadItems(at:), insertItems(at:), deleteItems(at:).

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

🤔 Что такое runLoop?

RunLoop — это фундаментальный механизм в iOS и macOS, который управляет циклом обработки событий в приложении. Он отслеживает и обрабатывает входящие события, такие как нажатия клавиш, касания экрана, таймеры и сетевые запросы, и поддерживает приложение в активном состоянии, пока оно не завершится.

🚩Основные аспекты `RunLoop`

🟠Цикл обработки событий
RunLoop постоянно выполняет цикл, ожидая входящие события и обрабатывая их по мере поступления. Этот цикл состоит из нескольких этапов: ожидание события, обработка события и повтор цикла.

🟠Режимы (Modes)
RunLoop может работать в разных режимах, которые определяют, какие источники событий будут отслеживаться и обрабатываться. Основные режимы включают default и tracking (для событий отслеживания, таких как прокрутка). В каждой итерации RunLoop обрабатывает события только для текущего режима.

RunLoop.current.run(mode: .default, before: Date.distantFuture)     

🟠Источники событий (Event Sources)
RunLoop может отслеживать различные источники событий, такие как таймеры (Timer), порты (Port), ввод пользователей (такие как касания экрана и клики мыши), а также пользовательские источники (Input Source).

🟠Таймеры
RunLoop может управлять таймерами, которые выполняют задачи через определенные интервалы времени.

     let timer = Timer(timeInterval: 1.0, repeats: true) { _ in
         print("Timer fired!")
     }
     RunLoop.current.add(timer, forMode: .default)

🟠Обработка событий
RunLoop используется для обработки событий в основном потоке (main thread) приложения. Это особенно важно для поддержания отзывчивости пользовательского интерфейса, поскольку все взаимодействия с UI происходят в основном потоке.

🚩Пример использования `RunLoop`

import Foundation

class Example {
    var timer: Timer?

    func startRunLoop() {
        timer = Timer.scheduledTimer(timeInterval: 1.0, target: self, selector: #selector(timerFired), userInfo: nil, repeats: true)
        RunLoop.current.run()
    }

    @objc func timerFired() {
        print("Timer fired!")
    }
}

let example = Example()
example.startRunLoop()

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

🤔 Как меняется высота и ширина при скроллинге?

При прокрутке сам контейнер (UIScrollView) остаётся того же размера, но смещается contentOffset, чтобы показать другую часть контента. Размер контента задаётся через contentSize.

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

🤔 Какие есть инструменты для работы с потоками?

В Swift есть несколько инструментов для работы с многопоточностью и параллельным выполнением кода. Вот основные из них:

🟠GCD (Grand Central Dispatch) – главный инструмент для потоков
GCD – это низкоуровневая технология, позволяющая управлять задачами (тасками) в очередях (DispatchQueue).

DispatchQueue.global(qos: .background).async {
    print("Фоновый поток")
    
    DispatchQueue.main.async {
        print("Вернулись в главный поток")
    }
}

🟠OperationQueue – более удобный API для задач
OperationQueue – это более гибкая и объектно-ориентированная альтернатива GCD.

let queue = OperationQueue()
queue.maxConcurrentOperationCount = 2 // Ограничение на 2 задачи одновременно

queue.addOperation {
    print("Операция 1")
}

queue.addOperation {
    print("Операция 2")
}

🟠Actors – безопасная работа с потоками в Swift 5.5+
С actor можно работать с потоками без гонок данных, потому что все его свойства защищены от одновременного доступа.

actor Counter {
    private var value = 0
    
    func increment() {
        value += 1
    }

    func getValue() -> Int {
        return value
    }
}

let counter = Counter()

Task {
    await counter.increment()
    print(await counter.getValue()) // Потокобезопасный доступ
}

🟠Task & Async/Await (Swift 5.5+) – современный подход к асинхронности
С async/await код становится читаемым и удобным.

func fetchData() async -> String {
    try? await Task.sleep(nanoseconds: 1_000_000_000) // 1 секунда задержки
    return "Данные загружены"
}

Task {
    let result = await fetchData()
    print(result)
}

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

🤔 Как работает garbage collector?

Он периодически просматривает все объекты в памяти и определяет, какие из них больше не доступны из текущих переменных. Такие объекты помечаются как мусор и удаляются. В Swift такой механизм не используется — вместо него применяется ARC.

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