🤔 Есть ли в свифте множественное наследование?

В Swift нет множественного наследования классов, но можно использовать множественное наследование через протоколы.

🚩Почему нет множественного наследования классов?

Swift запрещает множественное наследование классов, потому что оно может привести к конфликтам и алмазной проблеме (diamond problem).
Допустим, в языке с поддержкой множественного наследования у нас есть два родительских класса с одинаковым методом:

class A {
public:
    void greet() { cout << "Hello from A"; }
};

class B {
public:
    void greet() { cout << "Hello from B"; }
};

// C наследуется от A и B
class C : public A, public B {};

C obj;
obj.greet(); // Какой метод вызвать? A или B?

🚩Как обойти ограничение? Используем протоколы!

В Swift можно реализовать множественное наследование через протоколы, поскольку класс может соответствовать нескольким протоколам одновременно.

protocol Flyable {
    func fly()
}

protocol Swimmable {
    func swim()
}

class Animal {}

class Duck: Animal, Flyable, Swimmable {
    func fly() {
        print("Утка летит")
    }
    
    func swim() {
        print("Утка плывёт")
    }
}

let duck = Duck()
duck.fly()   // Утка летит
duck.swim()  // Утка плывёт

🚩Что делать, если нужен код по умолчанию?

Если хочется, чтобы протокол предоставлял реализацию по умолчанию (почти как родительский класс), можно использовать extension:

protocol Walker {
    func walk()
}

extension Walker {
    func walk() {
        print("Иду вперёд")
    }
}

class Person: Walker {}

let human = Person()
human.walk() // "Иду вперёд" (метод взят из extension)

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

🤔 Что известно про UICollectionViewCompositionalLayout (composition layout)?

Это мощный способ построения гибких layout'ов без сложного наследования от UICollectionViewLayout. Используется иерархия: Item → Group → Section → Layout. Позволяет создать сложные, адаптивные, горизонтальные/вертикальные списки, карусели и пр.

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

🤔 Где могут располагаться стеки помимо структуры

В программировании стек (stack) — это структура данных и область памяти, используемая для хранения временных данных. В зависимости от контекста, стек может существовать в нескольких местах.

🟠Стек вызовов (Call Stack)
Это главная область памяти в оперативной памяти (RAM), где хранятся:
- Локальные переменные функций.
- Адреса возврата после завершения функции.
- Контекст выполнения программы.

func functionA() {
    functionB()
}

func functionB() {
    print("Вызов B")
}

functionA()

func infiniteRecursion() {
    infiniteRecursion() // ❌ Бесконечный вызов
}

🟠Стек в структуре данных (например, `Array`)
В Swift можно реализовать стек вручную, используя массив (Array).

struct Stack<T> {
    private var elements: [T] = []

    mutating func push(_ item: T) {
        elements.append(item)
    }

    mutating func pop() -> T? {
        return elements.popLast()
    }
}

var stack = Stack<Int>()
stack.push(10)
stack.push(20)
print(stack.pop()!) // 20

🟠Потоковый стек (Thread Stack)
Каждый поток (Thread) в многопоточном программировании получает свой стек.

DispatchQueue.global().async {
    print("Фоновый поток")
}
print("Главный поток")

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

func createPerson() {
    let person = "Иван" // Создаётся в стеке
    print(person)
}

createPerson() // Переменная person удаляется при выходе из функции

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

🤔 За что отвечает "L" в "SOLID"?

"L" в SOLID — это принцип Лисков (Liskov Substitution Principle), который гласит, что объект дочернего класса должен корректно работать там, где используется объект родительского класса. Это помогает создавать устойчивые и легко расширяемые архитектуры.

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

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

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

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

🟠Примитивные типы данных
Представляют целые числа. 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"

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

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

1. Это механизм синхронизации, который ограничивает доступ к ресурсу только одному потоку в определённый момент времени.
2. Он блокирует другие потоки до завершения работы текущего.
3. Используется для предотвращения race condition при работе с общими данными.

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

🤔 Если обозначить внутри метода 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
    }
}

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

🤔 Как управлять зависимостями?

Через менеджеры зависимостей:
- CocoaPods, Carthage, Swift Package Manager — позволяют подключать внешние библиотеки, управлять их версиями, следить за обновлениями. Также возможна ручная интеграция, но она менее гибкая и масштабируемая.

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

🤔 Что такое барьеры?

Барьер (Barrier) – это механизм синхронизации потоков, который позволяет контролировать порядок выполнения операций** в многопоточной среде.

🚩Барьеры памяти (Memory Barriers)

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

#include <stdatomic.h>

atomic_int sharedValue = 0;

void updateValue() {
    atomic_store_explicit(&sharedValue, 10, memory_order_release);
}

void readValue() {
    int value = atomic_load_explicit(&sharedValue, memory_order_acquire);
}

🚩Барьеры в GCD (`dispatch_barrier`)

Используются в Grand Central Dispatch (GCD)** для контроля порядка выполнения задач в DispatchQueue.
- Позволяет блокировать очередь на время выполнения задачи.
- Все задачи до барьера выполняются параллельно.
- Барьер ждёт завершения всех предыдущих задач, выполняется эксклюзивно, затем разрешает следующие задачи.

let queue = DispatchQueue(label: "com.example.concurrent", attributes: .concurrent)

queue.async {
    print("Задача 1")
}
queue.async {
    print("Задача 2")
}

// БАРЬЕРНАЯ ОПЕРАЦИЯ
queue.async(flags: .barrier) {
    print("🔴 Барьер: все предыдущие задачи завершены, выполняюсь один!")
}

queue.async {
    print("Задача 3")
}

🚩Барьеры в OpenMP (Параллельные вычисления)

В OpenMP (#pragma omp barrier) ждёт завершения всех потоков перед выполнением следующего кода.

#pragma omp parallel
{
    printf("До барьера\n");
    #pragma omp barrier
    printf("После барьера\n");
}

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

🤔 Какие ещё бывают type?

– Int, Double, String, Bool — базовые типы,
– struct, class, enum, tuple,
– Optional,
– Protocol,
– Function,
– Any, AnyObject, Never.

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

🤔 Расскажи жизненный цикл vue контроллера

В iOS жизненный цикл UIViewController определяет последовательность вызовов методов, происходящих во время создания, отображения, скрытия и уничтожения контроллера.

🚩Подробное объяснение стадий

🟠Создание (Initialization)
На этом этапе создаётся экземпляр UIViewController, но его view ещё не загружено.
- Можно переопределить init() или init(coder:), если контроллер создаётся из Storyboard.
- Можно передавать данные через инициализатор.

class MyViewController: UIViewController {
    var titleText: String
    
    init(titleText: String) {
        self.titleText = titleText
        super.init(nibName: nil, bundle: nil)
    }
    
    required init?(coder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }
}

🟠Загрузка View (Loading)
Когда контроллеру нужно отобразить свой view, вызывается loadView() (если представление создаётся программно) и viewDidLoad() (если загружается из Storyboard или XIB).
loadView() – создаёт view программно (обычно не переопределяется).
viewDidLoad() – вызывается один раз после загрузки view.

override func viewDidLoad() {
    super.viewDidLoad()
    view.backgroundColor = .white
    print("viewDidLoad - View загружено в память")
}

🟠Отображение на экране (Appearing & Disappearing)
Когда UIViewController добавляется в иерархию UIWindow и становится видимым, вызываются следующие методы:
viewWillAppear(_:) – вызывается перед появлением на экране.
viewDidAppear(_:) – вызывается после появления на экране.
viewWillDisappear(_:) – вызывается перед скрытием.
viewDidDisappear(_:) – вызывается после скрытия.

override func viewWillAppear(_ animated: Bool) {
    super.viewWillAppear(animated)
    print("viewWillAppear - View скоро появится на экране")
}

override func viewDidAppear(_ animated: Bool) {
    super.viewDidAppear(animated)
    print("viewDidAppear - View уже на экране")
}

🟠Удаление из памяти (Deallocation)
Когда UIViewController больше не нужен, вызывается deinit(), а его view может быть выгружено с вызовом viewDidUnload() (но сейчас это редко используется).

deinit {
    print("deinit - Контроллер удалён из памяти")
}

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

🤔 Что такое Notification Center?

Это механизм публикации и подписки на события в iOS.
- Позволяет компонентам приложения обмениваться данными без прямых ссылок.
- Работает по принципу наблюдателя: объект отправляет уведомление, а подписчики получают его.
- Используется для глобального взаимодействия между модулями (например, обновление UI после фоновой загрузки данных).

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

🤔 Как работают 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)")
    }
}

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

🤔 Чем отличается set от dictionary?

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

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

🤔 Перечислите все ленивые (lazy) контейнеры/вью?

В iOS существует несколько ленивых (lazy) контейнеров и вью, которые откладывают создание или загрузку элементов до момента их фактического использования.

🚩`lazy var` (ленивые свойства)
Обычное свойство инициализируется сразу, а lazy – только при первом вызове.

class Example {
    lazy var expensiveObject: Data = {
        print("Объект создан!")
        return Data()
    }()
}

let obj = Example()
print("Объект ещё не создан")
_ = obj.expensiveObject // Только теперь создастся

🚩`LazySequence` и `LazyCollection`

Если вы хотите избежать лишних вычислений, можно использовать ленивую последовательность:

let numbers = (1...1000).lazy.map { $0 * 2 } // Не вычисляется сразу!
print(numbers.first!) // Только теперь вычисляется первый элемент

🚩`LazyVStack`, `LazyHStack`, `LazyGrid` (SwiftUI)

В отличие от обычных VStack и HStack, ленивые версии создают элементы только при прокрутке.

ScrollView {
    LazyVStack {
        ForEach(0..<1000) { index in
            Text("Элемент \(index)")
        }
    }
}

🚩`UITableView` и `UICollectionView` (UIKit)

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

func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
    let cell = tableView.dequeueReusableCell(withIdentifier: "Cell", for: indexPath)
    cell.textLabel?.text = "Строка \(indexPath.row)"
    return cell
}

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

🤔 Как сделать свой словарь?

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

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

🤔 Что означает принцип open closed?

Принцип OCP (Open-Closed Principle) гласит:
"Программные сущности должны быть открыты для расширения, но закрыты для модификации."
Это значит, что код должен позволять добавлять новый функционал без изменения существующего кода.

🚩Почему это важно?

Меньше багов – изменения не ломают старый код.
Лучшая поддержка – новый функционал добавляется без переписывания старого.
Гибкость – можно расширять систему без изменения её базовой логики.

🚩Пример нарушения принципа OCP

Допустим, у нас есть класс, который рисует фигуры:

class ShapeDrawer {
    func draw(shape: String) {
        if shape == "circle" {
            print("Рисуем круг")
        } else if shape == "square" {
            print("Рисуем квадрат")
        }
    }
}

🚩Как исправить? Используем OCP!

Лучше использовать наследование или протоколы, чтобы расширять функциональность, не меняя существующий код:

protocol Drawable {
    func draw()
}

class Circle: Drawable {
    func draw() {
        print("Рисуем круг")
    }
}

class Square: Drawable {
    func draw() {
        print("Рисуем квадрат")
    }
}

class ShapeDrawer {
    func draw(shape: Drawable) {
        shape.draw()
    }
}

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

🤔 Что известно про Memory Graph (мемориграф)?

Memory Graph в Xcode показывает живые объекты и их связи. Это полезно для поиска retain cycles, обнаружения неосвобождённых контроллеров и анализа структуры объектов. Доступен во время отладки через Debug Navigator.

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

🤔 Что нужно сделать, чтобы кастомная структура стала ключом в 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 для хеша
    }
}

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

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

В Swift память управляется с помощью Automatic Reference Counting (ARC), который автоматически подсчитывает количество ссылок на объекты и освобождает память, когда объект больше не используется. Память делится на две части: стек (stack) и куча (heap). Стек используется для хранения локальных переменных и управления потоком выполнения, а куча — для динамически выделяемых объектов, таких как экземпляры классов. ARC работает с объектами на куче, автоматически освобождая память, когда счётчик ссылок становится равен нулю.

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