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

По хорошей архитектуре — в 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 особенно полезна в приложениях с богатой моделью данных, связями и сложной логикой.

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

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

Внедрение зависимостей (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()

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

🤔 Как получить текущее значение frame при редактировании анимации на определённой секунде?

Во время анимации значение frame напрямую не обновляется, но можно получить его через presentation layer: view.layer.presentation()?.frame. Это позволяет узнать промежуточное положение вью на текущем кадре анимации.

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

🤔 Что такое 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()

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

🤔 В чём отличие ссылочных типов и типов значения?

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

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

🤔 В каком методе жизненного цикла можно поставить отступы к vue?

Если вы хотите задать отступы (margins, padding) для UIView в жизненном цикле UIViewController, то важно выбрать правильный момент, когда размеры view уже определены.

🚩Пример установки отступов в `viewDidLayoutSubviews()`

class MyViewController: UIViewController {
    let myView = UIView()

    override func viewDidLoad() {
        super.viewDidLoad()
        myView.backgroundColor = .red
        view.addSubview(myView)
    }

    override func viewDidLayoutSubviews() {
        super.viewDidLayoutSubviews()
        
        // Установка отступов (margins)
        myView.frame = view.bounds.insetBy(dx: 20, dy: 50)
    }
}

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

🤔 Как интерфейс связывается с конкретной реализацией?

Интерфейс связывается с реализацией через Dependency Injection, где зависимости передаются через конструктор, метод или поле. Для этого используются DI-контейнеры или Service Locator. Это позволяет использовать интерфейсы для абстрагирования деталей реализации. Реализация выбирается на этапе исполнения.

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

🤔 Что такое gitflow?

В основе Git Flow – несколько веток с разными ролями, чтобы команда могла параллельно разрабатывать новые фичи, исправлять баги и выпускать релизы.

🚩Как работает Git Flow?

🟠Основные ветки (`main` и `develop`)
- main – содержит только стабильные версии.
- develop – основная ветка разработки, в неё вливаются все новые фичи.

🟠Разработка новых фич (feature branches)
- Каждая новая фича создаётся в отдельной ветке feature/*.
- После завершения сливается в develop.

git checkout develop
git checkout -b feature/new-cool-feature
# Разработка...
git checkout develop
git merge feature/new-cool-feature
git branch -d feature/new-cool-feature

🟠Подготовка к релизу (release branches)
- Когда код стабилен, создаётся ветка release/* от develop.
- Здесь можно тестировать и исправлять баги.
- После финального теста сливается в main и develop.

git checkout develop
git checkout -b release/1.0
# Фиксим баги, тестируем...
git checkout main
git merge release/1.0
git tag -a v1.0 -m "Release 1.0"
git checkout develop
git merge release/1.0
git branch -d release/1.0

🟠Горячие фиксы (hotfix branches)
- Если критический баг в main, создаём hotfix/*.
- После исправления вливаем в main и в develop.

git checkout main
git checkout -b hotfix/urgent-bugfix
# Фиксим баг...
git checkout main
git merge hotfix/urgent-bugfix
git checkout develop
git merge hotfix/urgent-bugfix
git branch -d hotfix/urgent-bugfix

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

🤔 Как решить проблему переиспользования ячеек?

Правильно реализовать логику обновления ячеек:
- Использовать prepareForReuse для сброса состояния.
- Чётко отделить асинхронные вызовы.
- Избегать сохранения состояния между разными экземплярами данных.

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

🤔 Что может быть ключом и значением для dictionary?

Словарь (Dictionary) представляет собой коллекцию пар ключ-значение, где каждый ключ должен быть уникальным. Чтобы использовать какой-либо тип в качестве ключа словаря, этот тип должен соответствовать протоколу Hashable. Это требование обусловлено тем, что Swift использует хеш-таблицу для хранения элементов словаря, что обеспечивает быстрый доступ к его элементам.

🚩Ключи

Должны быть уникальными: Каждый ключ в словаре должен быть уникальным. При попытке добавить в словарь элемент с ключом, который уже существует в словаре, старое значение будет заменено на новое.
Должны соответствовать протоколу Hashable: Это означает, что тип ключа должен иметь способность быть правильно хешированным. Большинство базовых типов Swift (например, String, Int, Double и др.) уже соответствуют Hashable, поэтому их можно использовать в качестве ключей без дополнительных усилий.

🚩Значения

Могут быть любого типа: Значения в словаре могут быть любого типа, и они не обязаны соответствовать протоколу Hashable.
Могут повторяться: Разные ключи могут иметь одинаковые значения.

var personAge: [String: Int] = ["John": 30, "Sara": 25]

🚩Собственные типы в качестве ключей

Вы также можете использовать собственные пользовательские типы в качестве ключей словаря, но для этого ваш тип должен соответствовать протоколу Hashable. Это включает в себя реализацию требуемых методов для сравнения на равенство (==) и хеширования (hash(into:)).

struct Person: Hashable {
    var name: String
    var id: Int
}

var peopleDictionary: [Person: String] = [Person(name: "John", id: 1): "Engineer"]

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

🤔 Как исправить мельтешение картинок по ячейкам?

Проблема возникает из-за переиспользования ячеек и асинхронной загрузки изображений. Нужно:
- Сбрасывать содержимое ячейки перед повторным использованием.
- Проверять, соответствует ли картинка текущей ячейке после загрузки.
- Использовать кэш изображений.

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

🤔 Какие можно выделить главные принципы ООП?

Объектно-ориентированное программирование (ООП) — это парадигма, основанная на концепции "объектов", которые могут содержать данные в виде полей (часто называемых атрибутами или свойствами) и код в виде процедур (часто называемых методами). ООП фокусируется на использовании объектов для моделирования реального мира (или абстракций), облегчая разработку и поддержку сложных программ. Существует четыре основных принципа:

🟠Инкапсуляция
Механизм ООП, который объединяет данные (атрибуты) и код (методы), манипулирующий этими данными, внутри одного объекта и скрывает детали реализации от внешнего использования. Это позволяет защитить внутреннее состояние объекта от прямого доступа извне и обеспечить контролируемый интерфейс для работы с этим объектом.

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

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

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

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

🤔 Как устроен ARC?

Automatic Reference Counting — это механизм управления памятью в Swift. Он автоматически отслеживает количество ссылок на объект и освобождает память, когда счётчик становится равным нулю.

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