🤔 Как загрузить что-то из интернета?

Чтобы загрузить данные (файл, JSON и т. д.), нужно:
1. Указать URL-адрес источника.
2. Отправить сетевой запрос.
3. Обработать полученный ответ.
4. Сохранить или использовать полученные данные.
В мобильной разработке обычно это делается асинхронно, чтобы не блокировать интерфейс.

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

🤔 Что происходит с классом при компиляции?

При компиляции в Swift класс проходит несколько стадий обработки:
Анализ синтаксиса и семантики – компилятор проверяет код на ошибки.
Генерация промежуточного представления (IR) – создаётся код на уровне LLVM IR.
Оптимизация – Swift применяет различные оптимизации, например, inlining, dead code elimination и другие.
Генерация машинного кода – итоговый код превращается в исполняемый машинный код, специфичный для платформы.

🚩Что конкретно происходит с классом?

В отличие от структур, классы в Swift являются ссылочными типами и хранятся в куче (heap). Это означает, что:
- При создании объекта выделяется память в куче.
- Swift автоматически использует ARC (Automatic Reference Counting) для управления памятью.
- Методы класса могут вызываться через виртуальную таблицу (vtable), если класс использует динамическую диспетчеризацию.

🚩Важные моменты

- Если класс final, компилятор может оптимизировать вызовы методов, убрав динамическую диспетчеризацию.
- Наследование делает вызовы методов менее предсказуемыми (они идут через vtable).
- В отличие от структур, классы не копируются при передаче в функцию, а передаётся ссылка.

class Animal {
    var name: String

    init(name: String) {
        self.name = name
    }

    func speak() {
        print("Some sound")
    }
}

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

let myDog = Dog(name: "Buddy")
myDog.speak()

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

🤔 С помощью какого типа реализован Optional в Swift?

Optional реализован как перечисление (enum) с двумя случаями: .some(value) и .none. Это позволяет безопасно работать с отсутствием значений.

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

🤔 Функция принимала дабл, а указываем функцию, то что было бы?

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

func printDouble(value: Double) {
    print("Значение: \(value)")
}

printDouble(value: printDouble) // Ошибка: Несовместимые типы

🚩Как исправить?

Если вы хотите передавать функцию в качестве аргумента, ее нужно объявить в параметрах как (Double) -> Void:

func processDouble(_ value: Double, action: (Double) -> Void) {
    action(value)
}

processDouble(42.0, action: printDouble) // Выведет: "Значение: 42.0"

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

🤔 Что такое deadlock?

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

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

🤔 Как сделать класс наблюдаемым (начиная с iOS 17)?

Начиная с iOS 17, Apple представила новый способ сделать класс наблюдаемым с помощью атрибута @Observable и свойства @Published. Этот подход упрощает создание наблюдаемых объектов и улучшает интеграцию с SwiftUI.

🚩Создание наблюдаемого класса с использованием @Observable

1⃣Импортируем необходимые модули

import SwiftUI

2⃣Создаем класс и добавляем атрибут @Observable

@Observable
class ViewModel {
    @Published var message: String = "Привет, мир!"
}

3⃣Используем наблюдаемый объект в SwiftUI
Теперь мы можем использовать наш наблюдаемый объект в SwiftUI, и представление будет автоматически обновляться при изменении свойств, помеченных как @Published.

struct ContentView: View {
    @StateObject private var viewModel = ViewModel()

    var body: some View {
        VStack {
            Text(viewModel.message)
            Button("Изменить сообщение") {
                viewModel.message = "Привет, SwiftUI!"
            }
        }
    }
}

🚩Пример с пояснением

Полный пример использования наблюдаемого класса в SwiftUI

import SwiftUI

@Observable
class ViewModel {
    @Published var message: String = "Привет, мир!"
}

struct ContentView: View {
    @StateObject private var viewModel = ViewModel()

    var body: some View {
        VStack {
            Text(viewModel.message)
            Button("Изменить сообщение") {
                viewModel.message = "Привет, SwiftUI!"
            }
        }
    }
}

Пример использования @EnvironmentObject

import SwiftUI

@Observable
class ViewModel {
    @Published var message: String = "Привет, мир!"
}

struct ParentView: View {
    @StateObject private var viewModel = ViewModel()

    var body: some View {
        ChildView()
            .environmentObject(viewModel)
    }
}

struct ChildView: View {
    @EnvironmentObject var viewModel: ViewModel

    var body: some View {
        VStack {
            Text(viewModel.message)
            Button("Изменить сообщение") {
                viewModel.message = "Привет, SwiftUI!"
            }
        }
    }
}

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

🤔 Почему self обязателен в escaping?

Потому что такие замыкания сохраняются в памяти, и указание self явно делает захват осознанным. Это предупреждает retain cycle и улучшает читаемость.

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

🤔 Как заставить оператор поддерживать функцию типа t?

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

🟠Что значит "функция типа T"?
Функция в Swift — это тоже тип данных.

func add(_ a: Int, _ b: Int) -> Int {
    return a + b
}

Тип этой функции

(Int, Int) -> Int

🟠Пример: оператор `+` для функций
Допустим, у нас есть две функции, и мы хотим, чтобы оператор + создавал новую функцию, объединяя их поведение.

import Foundation

// Функция типа (Int) -> Int
func double(_ x: Int) -> Int {
    return x * 2
}

func increment(_ x: Int) -> Int {
    return x + 1
}

// Перегружаем оператор + для функций (Int) -> Int
func + (lhs: @escaping (Int) -> Int, rhs: @escaping (Int) -> Int) -> (Int) -> Int {
    return { x in rhs(lhs(x)) } // Сначала вызываем первую, затем вторую
}

// Используем оператор
let combinedFunction = double + increment

print(combinedFunction(3)) // (3 * 2) + 1 = 7

🟠Пример: оператор `*` для функций
Можно сделать оператор *, который применяет функцию несколько раз.

// Перегружаем оператор * для дублирования применения функции
func * (lhs: @escaping (Int) -> Int, rhs: Int) -> (Int) -> Int {
    return { x in
        var result = x
        for _ in 0..<rhs {
            result = lhs(result)
        }
        return result
    }
}

// Используем оператор
let tripleDouble = double * 3

print(tripleDouble(2)) // (2 * 2) * 2 * 2 = 16

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

🤔 Как value и reference типы хранятся в памяти?

Value-типы хранятся в стеке, создаются копии при передаче. Reference-типы хранятся в куче, передаются по ссылке. Управление памятью для reference-типа осуществляется через ARC. Value-типы быстрее в простых задачах, reference — гибче при сложных связях.
Вот подробные ответы на все вопросы, которые касаются управления памятью, навигации, работы потоков и асинхронности в iOS, а также концепций ARC и утечек:

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

🤔 Зачем сделан сайт тейбл?

Сайт UITableView (Table View) в iOS используется для отображения списков данных в виде таблицы. Это один из наиболее часто используемых компонентов пользовательского интерфейса в приложениях iOS, так как позволяет организовывать и представлять большие объемы информации в удобном для пользователя формате.

🚩Плюсы

➕Отображение больших объемов данных:
UITableView позволяет отображать большие списки данных, которые могут быть прокручиваемыми. Это особенно полезно для отображения динамически загружаемых данных, таких как ленты новостей, списки контактов, каталоги товаров и т.д.

➕Упрощение управления и обновления данных:
UITableView предоставляет методы для добавления, удаления и обновления строк данных, что упрощает управление динамическими списками. Он также поддерживает анимацию изменений, что улучшает пользовательский опыт.

➕Кастомизация ячеек:
UITableView позволяет использовать кастомные ячейки для отображения данных, предоставляя гибкость в создании пользовательского интерфейса. Это можно сделать путем создания пользовательских классов ячеек и настройки их внешнего вида.

➕Разделение данных на секции:
UITableView поддерживает разделение данных на секции с заголовками и подзаголовками, что упрощает организацию и навигацию по спискам данных.

🚩Основные компоненты `UITableView`

🟠Ячейки (Cells):
Основной элемент, используемый для отображения строки данных. Ячейки могут быть стандартными или кастомными.

🟠Секции (Sections):
UITableView может содержать несколько секций, каждая из которых может содержать несколько строк. Секции могут иметь заголовки и подзаголовки.

🟠Перезагрузка данных (Reloading Data):
UITableView предоставляет методы для обновления данных, такие как reloadData(), которые перезагружают всю таблицу, и методы для обновления отдельных строк или секций с анимацией.

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

🤔 Как работает UITableView?

- Использует реиспользуемые ячейки (dequeueReusableCell) для оптимизации памяти.
- Работает с делегатами (UITableViewDelegate) и источниками данных (UITableViewDataSource) для динамического обновления контента.
- Поддерживает разделы, перетаскивание, редактирование.
- Может быть обновлен с анимацией (reloadData, performBatchUpdates).

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

🤔 Если обозначить внутри метода Synchronized , что будет монитору?

Это высокоуровневый механизм синхронизации, который объединяет взаимное исключение (mutex) и условные переменные (condition variables) для управления доступом к объектам в многопоточной среде.

🚩Как работает

🟠Взаимное исключение (Mutual Exclusion)
Только один поток может выполнить защищенный блок кода в любой момент времени.
🟠Условные переменные (Condition Variables)
Позволяют потокам ожидать определенных условий, а другим потокам уведомлять их о наступлении этих условий.

🚩Примеры

class ThreadSafeClass {
    private var internalState = 0
    private let queue = DispatchQueue(label: "com.example.threadSafeQueue")
    
    func increment() {
        queue.sync {
            internalState += 1
        }
    }
    
    func getState() -> Int {
        return queue.sync {
            internalState
        }
    }
}

С NSLock

class ThreadSafeClass {
    private var internalState = 0
    private let lock = NSLock()
    
    func increment() {
        lock.lock()
        internalState += 1
        lock.unlock()
    }
    
    func getState() -> Int {
        lock.lock()
        let state = internalState
        lock.unlock()
        return state
    }
}

С objc_sync_enter и objc_sync_exit

class ThreadSafeClass: NSObject {
    private var internalState = 0
    
    func increment() {
        objc_sync_enter(self)
        internalState += 1
        objc_sync_exit(self)
    }
    
    func getState() -> Int {
        objc_sync_enter(self)
        let state = internalState
        objc_sync_exit(self)
        return state
    }
}

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

🤔 В какой момент вызывается метод viewWillAppear?

viewWillAppear вызывается перед тем, как представление контроллера будет добавлено на экран. Это происходит каждый раз, когда представление становится видимым, но до его отображения.

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

🤔 Расскажи про букву D в solid

Принцип инверсии зависимостей (Dependency Inversion Principle, DIP) гласит:
Модули верхнего уровня не должны зависеть от модулей нижнего уровня. Оба должны зависеть от абстракций.
Абстракции не должны зависеть от деталей. Детали должны зависеть от абстракций.

🚩Плохой пример (Нарушение DIP)

class MySQLDatabase {
    func fetchData() -> String {
        return "Данные из MySQL"
    }
}

class DataManager {
    let database = MySQLDatabase() // Прямая зависимость от MySQL

    func getData() -> String {
        return database.fetchData()
    }
}

🚩Хороший пример (Используем DIP)

Вводим абстракцию (Протокол)

protocol Database {
    func fetchData() -> String
}

Реализуем конкретные базы данных

class MySQLDatabase: Database {
    func fetchData() -> String {
        return "Данные из MySQL"
    }
}

class PostgreSQLDatabase: Database {
    func fetchData() -> String {
        return "Данные из PostgreSQL"
    }
}

Используем абстракцию в DataManager

class DataManager {
    private let database: Database  // Зависимость от абстракции

    init(database: Database) {
        self.database = database
    }

    func getData() -> String {
        return database.fetchData()
    }
}

Использование

let mySQLDataManager = DataManager(database: MySQLDatabase())
print(mySQLDataManager.getData()) // "Данные из MySQL"

let postgreSQLDataManager = DataManager(database: PostgreSQLDatabase())
print(postgreSQLDataManager.getData()) // "Данные из PostgreSQL"

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

🤔 Что такое heap object?

Heap object (объект в куче) — это объект, созданный в динамической области памяти (куче). Он остаётся в памяти до тех пор, пока на него существуют ссылки, и освобождается автоматически (например, сборщиком мусора или ARC). Такие объекты используются для хранения данных с неопределённым временем жизни.

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

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

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

🚩Проблемы

🟠Утечки памяти (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
        }
    }
}

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

🤔 В какой момент проставляется retain/release при использовании ARC?

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

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

🤔 Почему по дефолту дабл, а не фолт?

В Swift (и во многих других языках программирования) по умолчанию числовой литерал с плавающей запятой интерпретируется как `Double`, а не Float.

🚩Основные причины:

🟠Бóльшая точность
Double имеет 64 бита, а Float – 32 бита. Это значит, что Double может хранить более точные значения, что особенно важно при математических вычислениях.

🟠Совместимость со стандартными API
Большинство API и стандартных библиотек Swift (например, sin(), cos(), pow()) работают именно с Double.
Например:

   let x = 3.14 // По умолчанию это Double
   let y = sin(x) // sin() принимает Double
   

🟠Производительность на современных процессорах
На современных 64-битных процессорах операции с Double выполняются так же быстро или даже быстрее, чем с Float, из-за оптимизаций в аппаратном обеспечении.

🟠Меньше неожиданных ошибок округления
Float может округлять числа с потерей точности, что может привести к неожиданным результатам.
Пример ошибки округления в Float:

   let a: Float = 0.1 + 0.2
   print(a == 0.3) // false 😱

🚩Как сделать `Float` вручную?
Если всё же нужен Float, надо указать это явно:

let number: Float = 3.14

или

let number = 3.14 as Float

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

🤔 Что такое порождающие паттерны?

Это паттерны, связанные с созданием объектов. Они управляют созданием экземпляров, чтобы сделать код более гибким, масштабируемым и независимым от конкретных классов. Примеры: Factory Method, Abstract Factory, Builder, Singleton, Prototype.

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

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

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

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