Swift | Вопросы собесов

🤔 Почему Swift не может сам сгенерировать memberwise инициализатор для классов? 1. Классы поддерживают наследование, что делает сложным автоматическое создание инициализатора, учитывающего все поля, включая родительские. 2. Инициализация в классах может включать дополнительные логики, которые сложно определить на этапе компиляции. 3. Структуры, в отличие от классов, не имеют этих ограничений, поэтому memberwise инициализатор создаётся автоматически. Ставь 👍 если знал ответ, 🔥 если нет Забирай 📚 Базу знаний

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

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

🤔 В чём разница между Int и UInt? - Int — это знаковое целое число, может быть как положительным, так и отрицательным. - UInt — беззнаковое, только положительные значения (включая 0). Использовать UInt нужно аккуратно: операции с Int и UInt напрямую не работают — нужно приводить типы. Ставь 👍 если знал ответ, 🔥 если нет Забирай 📚 Базу знаний

🤔 Чем отличается 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? // Теперь утечки памяти не будет
}{}
    

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

🤔 Какие есть антипаттерны? Популярные антипаттерны: - God Object (всё в одном классе); - Spaghetti Code (плохая структура, трудно сопровождать); - Lava Flow (мертвый, но используемый код); - Shotgun Surgery (изменение одного места требует правок в десятке других); - Hard Coding (вшивание значений вместо конфигурации). Ставь 👍 если знал ответ, 🔥 если нет Забирай 📚 Базу знаний

🤔 Что нужно сделать, чтобы кастомная структура стала ключом в dictionary? В Swift ключи в словаре (Dictionary) должны быть уникальными и сравниваться между собой. Поэтому, если вы хотите использовать*свою структуру в качестве ключа, она должна соответствовать протоколу Hashable. 🚩Что нужно? Структура должна соответствовать Hashable Должен быть реализован hash(into:) или использовать Equatable + Hashable автоматически Свойства структуры должны быть Hashable (если String, Int, Double – все ок) 🚩Пример кастомной структуры в `Dictionary`

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

// Теперь можно использовать `Person` как ключ
var peopleAges: [Person: Int] = [
    Person(id: 1, name: "Alice"): 25,
    Person(id: 2, name: "Bob"): 30
]

// Доступ по ключу
let alice = Person(id: 1, name: "Alice")
print(peopleAges[alice] ?? "Не найдено") // 25{}
    

🚩Ручная реализация `hash(into:)` Если нужно кастомное хеширование, можно реализовать hash(into:):

    
        struct Person: Hashable {
    let id: Int
    let name: String

    func hash(into hasher: inout Hasher) {
        hasher.combine(id)   // Используем только id для хеша
    }
}{}
    

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

🤔 Может ли value type передаваться по ссылке? По умолчанию значимые типы (value types) — это структуры, перечисления, кортежи. Они передаются по значению, то есть создаётся копия. Но если обернуть value type в inout, использовать UnsafeMutablePointer или ссылочный контейнер (например, класс), то можно добиться передачи по ссылке. Однако это скорее обходное поведение, а не правило. Ставь 👍 если знал ответ, 🔥 если нет Забирай 📚 Базу знаний

🤔 Какие паттерны знаешь? Паттерны проектирования – это готовые решения частых задач, улучшающие структуру кода, его поддержку и масштабируемость. 🚩Порождающие паттерны (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{}
    

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

🤔 Что известно о типовых приёмах рефакторинга? Часто используются приёмы: выделение метода, перемещение логики в отдельный класс или слой, замена условных операторов полиморфизмом, переименование для ясности, инверсия зависимости. Главная цель — улучшить читаемость, переиспользуемость и снизить связанность компонентов. Ставь 👍 если знал ответ, 🔥 если нет Забирай 📚 Базу знаний

🤔 Какие есть инструменты для работы с потоками? В 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)
}{}
    

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