🤔 Где использовать структуры данных?

Структуры данных используются для эффективного хранения и управления данными в различных задачах.

🚩Основные структуры данных и их применение

🟠Массивы (Arrays)
Хранение элементов одного типа с доступом по индексу. Список товаров в корзине.

let shoppingCart = ["Apple", "Banana", "Orange"]   

🟠Словари (Dictionaries)
Хранение пар ключ-значение. Информация о пользователях по ID.

var userInfo = ["userID1": "John Doe"]   

🟠Множества (Sets)
Хранение уникальных элементов. Уникальные теги постов.

var uniqueTags: Set = ["swift", "programming"]   

🟠Стек (Stack)
Управление данными в стиле LIFO. Отмена последнего действия.

struct Stack<T> {
    private var elements: [T] = []
    mutating func push(_ element: T) { elements.append(element) }
    mutating func pop() -> T? { elements.popLast() }
}   

🟠Очередь (Queue)
Управление данными в стиле FIFO. Обработка запросов.

struct Queue<T> {
    private var elements: [T] = []
    mutating func enqueue(_ element: T) { elements.append(element) }
    mutating func dequeue() -> T? { elements.isEmpty ? nil : elements.removeFirst() }
}   

🟠Связанный список (Linked List)
Эффективное добавление и удаление элементов. Управление заказами.

class Node<T> { var value: T; var next: Node?; init(value: T) { self.value = value } }   

🟠Дерево (Tree)
Иерархическая структура данных. Файловая система.

class TreeNode<T> { var value: T; var children: [TreeNode] = [] }   

🟠Граф (Graph)
Моделирование сетей и связей. Социальные сети.

class Graph { var adjList: [String: [String]] = [:] }   

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

🤔 Какие бывают модификаторы доступа?

В Swift модификаторы доступа включают:
private (доступ только внутри текущего файла или типа),
fileprivate (доступ в пределах файла),
internal (доступ по умолчанию в модуле),
public (доступ в любом модуле),
open (доступ для наследования и изменения вне модуля).

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

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

🚩Различия между Set и Dictionary

🟠Set
Хранение уникальных элементов. Неупорядоченная коллекция. Быстрый поиск элементов.

var uniqueTags: Set = ["swift", "ios", "programming"]  

🟠Dictionary
Хранение пар ключ-значение. Неупорядоченная коллекция с ассоциативным доступом. Быстрый доступ к значениям по ключам.

var userInfo: [String: String] = ["userID1": "John Doe", "userID2": "Jane Smith"]  

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

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

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

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

🤔 MVM от MVP чем отличается?

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

🚩Основные различия между MVM и MVP

🟠MVP (Model-View-Presenter)
Компоненты
Model: Управляет данными и бизнес-логикой.
View: Отвечает за отображение данных и пользовательский интерфейс.
Presenter: Посредник между Model и View. Получает данные из Model и обновляет View.
Связь
View знает о Presenter и взаимодействует с ним.
Presenter знает о View и Model, взаимодействует с обоими.

protocol View: AnyObject {
    func updateUI()
}

protocol Presenter {
    func loadData()
}

class Model {
    var data: String = "Hello, MVP"
}

class MyPresenter: Presenter {
    private weak var view: View?
    private var model: Model

    init(view: View, model: Model) {
        self.view = view
        self.model = model
    }

    func loadData() {
        // Получение данных из модели
        view?.updateUI()
    }
}

class MyViewController: UIViewController, View {
    var presenter: Presenter!

    override func viewDidLoad() {
        super.viewDidLoad()
        presenter.loadData()
    }

    func updateUI() {
        // Обновление пользовательского интерфейса
    }
}

🟠MVM (Model-View-Model)
Компоненты
Model: Управляет данными и бизнес-логикой.
View: Отвечает за отображение данных и пользовательский интерфейс.
ViewModel: Абстракция, связывающая Model и View. Формирует данные для View и обрабатывает действия от View.
Связь
ViewModel знает о Model и может наблюдать за изменениями в ней. ViewModel предоставляет данные и команды для View. View знает только о ViewModel и не знает о Model напрямую.

class Model {
    var data: String = "Hello, MVM"
}

class ViewModel {
    private var model: Model

    var displayData: String {
        return model.data
    }

    init(model: Model) {
        self.model = model
    }

    func updateModelData(newData: String) {
        model.data = newData
    }
}

class MyViewController: UIViewController {
    var viewModel: ViewModel!

    override func viewDidLoad() {
        super.viewDidLoad()
        // Обновление пользовательского интерфейса с использованием viewModel
        print(viewModel.displayData)
    }
}

🚩Основные различия

🟠Связь компонентов:
MVP: View взаимодействует с Presenter, а Presenter взаимодействует с View и Model.
MVM: View взаимодействует только с ViewModel, а ViewModel взаимодействует с Model.

🟠Зависимости
MVP: View и Presenter имеют двустороннюю зависимость, что может усложнить управление зависимостями.
MVM: ViewModel не зависит от View, что улучшает тестируемость и упрощает архитектуру.

🟠Тестируемость
MVP: Тестирование Presenter может быть сложным из-за зависимости от View.
MVM: ViewModel легко тестируется независимо от View.

🟠Применение:
MVP: Чаще используется в Android-разработке.
MVM: Популярен в iOS-разработке и при использовании SwiftUI.

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

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

Наследование в Swift позволяет классу (подклассу) унаследовать свойства, методы и инициализаторы от другого класса (суперкласса). Подклассы могут переопределять (override) поведение суперкласса, добавлять новые свойства и методы, но не могут наследовать структуры, перечисления или протоколы.

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

🤔 Почему надо выбрать именно эту архитектуру?

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

🚩Выбор MVP (Model-View-Presenter)

🟠Четкое разделение обязанностей
MVP разделяет логику интерфейса пользователя и бизнес-логику, что делает код более модульным и управляемым.
🟠Улучшенная тестируемость
Легче тестировать Presenter отдельно от View, что улучшает покрытие тестами и упрощает отладку.
🟠Ясность в работе с View
Presenter управляет всей логикой взаимодействия с View, что делает структуру кода понятной и предсказуемой.
🟠Универсальность
MVP хорошо подходит для проектов с сложной логикой UI, где требуется много взаимодействий между пользовательским интерфейсом и бизнес-логикой.

🚩Выбор MVVM (Model-View-ViewModel)

🟠Односторонняя связь
ViewModel не знает о View, что уменьшает связанность и улучшает тестируемость.
🟠Поддержка привязок (data binding)
MVVM особенно хорошо работает с фреймворками, поддерживающими привязки данных, такими как SwiftUI или RxSwift. Это упрощает синхронизацию данных между View и ViewModel.
🟠Упрощенная логика UI
ViewModel формирует данные для View, что упрощает логику представления и делает код более чистым.
🟠Легкость в тестировании
ViewModel легко тестируется, поскольку не зависит от конкретной реализации View, что улучшает модульное тестирование.

🚩Примеры выбора архитектуры

🟠SwiftUI
Использование MVVM в SwiftUI позволяет легко управлять состоянием приложения и автоматически обновлять интерфейс при изменении данных.
🟠RxSwift
MVVM отлично сочетается с реактивным программированием, предоставляя мощные возможности для управления асинхронными операциями.

import SwiftUI

class Model {
    var data: String = "Hello, MVVM"
}

class ViewModel: ObservableObject {
    @Published var displayData: String = ""
    private var model: Model

    init(model: Model) {
        self.model = model
        self.displayData = model.data
    }

    func updateData(newData: String) {
        model.data = newData
        self.displayData = newData
    }
}

struct ContentView: View {
    @ObservedObject var viewModel: ViewModel

    var body: some View {
        Text(viewModel.displayData)
    }
}

🟠UIKit
MVP используется для четкого разделения логики представления и бизнес-логики в сложных проектах на UIKit.

protocol View: AnyObject {
    func updateUI(with data: String)
}

class Model {
    var data: String = "Hello, MVP"
}

class Presenter {
    private weak var view: View?
    private var model: Model

    init(view: View, model: Model) {
        self.view = view
        self.model = model
    }

    func loadData() {
        view?.updateUI(with: model.data)
    }
}

class ViewController: UIViewController, View {
    private var presenter: Presenter!

    override func viewDidLoad() {
        super.viewDidLoad()
        presenter = Presenter(view: self, model: Model())
        presenter.loadData()
    }

    func updateUI(with data: String) {
        // Обновление интерфейса
        print(data)
    }
}

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

🤔 Что под капотом стэка?

Под капотом стек организован как непрерывный блок памяти, управляемый указателем вершины. Операции добавления и удаления происходят за константное время O(1), а память автоматически освобождается при удалении элементов. Стек обычно используется для хранения вызовов функций, локальных переменных и управления потоком выполнения.

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

🤔 Какие есть типы ссылок?

В программировании существуют различные типы ссылок, которые определяют, как объекты управляются и удерживаются в памяти.

🟠Сильные ссылки (Strong References)
По умолчанию в Swift все ссылки являются сильными. Сильная ссылка удерживает объект в памяти до тех пор, пока существует хотя бы одна сильная ссылка на него. Для стандартного владения объектами.

class Person {
    var name: String
    init(name: String) {
        self.name = name
    }
}

var person1: Person? = Person(name: "Alice")
var person2 = person1  // person2 также является сильной ссылкой на тот же объект  

🟠Слабые ссылки (Weak References)
Слабая ссылка не удерживает объект в памяти. Если все сильные ссылки на объект удаляются, объект освобождается, и слабая ссылка автоматически становится nil. Для предотвращения циклов удержания, особенно в делегатах и замыканиях.

class Person {
    var name: String
    init(name: String) {
        self.name = name
    }
}

class Apartment {
    weak var tenant: Person?
}

var alice: Person? = Person(name: "Alice")
var apt = Apartment()
apt.tenant = alice  // Слабая ссылка на alice  

🟠Неактивные ссылки (Unowned References)
Неактивная ссылка, как и слабая, не удерживает объект в памяти, но в отличие от слабой ссылки, она не может быть nil. Используется, когда объект гарантированно существует на протяжении всего жизненного цикла. Для циклических зависимостей, где одна сторона всегда будет существовать.

class Person {
    var name: String
    init(name: String) {
        self.name = name
    }
}

class Apartment {
    unowned var tenant: Person
    init(tenant: Person) {
        self.tenant = tenant
    }
}

var alice: Person? = Person(name: "Alice")
var apt = Apartment(tenant: alice!)  // Неактивная ссылка на alice  

🟠Автономные ссылки (Unmanaged References)
Предоставляют прямой доступ к объекту без автоматического управления памятью. Используется редко и требует ручного управления памятью. Для специфических задач, где необходим контроль над управлением памятью.

import Foundation

let unmanagedReference = Unmanaged.passRetained(NSObject())
let retainedObject = unmanagedReference.takeRetainedValue()  

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

🤔 За счёт чего стек быстрее кучи?

Стек быстрее кучи, потому что операции в стеке, такие как добавление и удаление, имеют фиксированную сложность O(1), благодаря строгому порядку (LIFO). Стек управляется автоматически, без необходимости выделения и освобождения памяти вручную. Куча, напротив, требует больше времени из-за динамического управления памятью и возможных операций фрагментации.

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

🤔 Какие способы layout'а вам знакомы?

В iOS-разработке существует несколько способов создания и управления макетами (layouts) пользовательского интерфейса.

🟠Interface Builder (IB)
Визуальный редактор, встроенный в Xcode, который позволяет разрабатывать пользовательский интерфейс с помощью перетаскивания элементов. Удобный графический интерфейс, быстрый просмотр изменений, поддержка Auto Layout. Меньшая гибкость по сравнению с программным кодом. Создание и настройка интерфейса с помощью storyboard или xib файлов.

🟠Auto Layout
Система ограничений (constraints), которая позволяет определять правила расположения и размеров элементов интерфейса. Адаптивные интерфейсы для различных устройств и ориентаций, мощные инструменты для сложных макетов. Может быть сложно освоить, особенно для сложных макетов.

let button = UIButton()
button.translatesAutoresizingMaskIntoConstraints = false
view.addSubview(button)
NSLayoutConstraint.activate([
    button.centerXAnchor.constraint(equalTo: view.centerXAnchor),
    button.centerYAnchor.constraint(equalTo: view.centerYAnchor)
])  

🟠Programmatic Layout
Создание и настройка элементов интерфейса полностью через код, без использования Interface Builder. Полный контроль над процессом создания интерфейса, легко управлять версиями. Требует больше времени и усилий для настройки, особенно для сложных макетов.

let label = UILabel(frame: CGRect(x: 50, y: 50, width: 200, height: 50))
label.text = "Hello, World!"
view.addSubview(label)  

🟠Stack Views
Компоненты интерфейса, которые автоматически располагают и масштабируют свои подвиды (subviews) в вертикальном или горизонтальном направлении. Упрощает создание и управление сложными макетами, поддержка Auto Layout.: Ограниченная гибкость для некоторых типов макетов.

let stackView = UIStackView(arrangedSubviews: [label, button])
stackView.axis = .vertical
stackView.spacing = 10
stackView.translatesAutoresizingMaskIntoConstraints = false
view.addSubview(stackView)
NSLayoutConstraint.activate([
    stackView.centerXAnchor.constraint(equalTo: view.centerXAnchor),
    stackView.centerYAnchor.constraint(equalTo: view.centerYAnchor)
])  

🟠SwiftUI
Новый декларативный фреймворк для создания пользовательских интерфейсов, представленный Apple в 2019 году. Декларативный синтаксис, простой в использовании, интеграция с Swift, поддержка различных платформ (iOS, macOS, watchOS, tvOS). Требует iOS 13 и выше, меньшая поддержка старых устройств.

import SwiftUI

struct ContentView: View {
    var body: some View {
        VStack {
            Text("Hello, World!")
            Button(action: {
                print("Button tapped")
            }) {
                Text("Tap me")
            }
        }
    }
}  

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

🤔 Какую структуру имеет диспетчеризация?

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

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

🤔 Какие плюсы и минусы layout'а?

Каждый способ создания макетов (layout'а) в iOS-разработке имеет свои преимущества и недостатки.

🚩Interface Builder (IB)

➕Визуальное редактирование
Удобный графический интерфейс для быстрой настройки и визуального просмотра изменений.
➕Интеграция с Auto Layout
Простая настройка ограничений (constraints) для адаптивного интерфейса.
➕Быстрое прототипирование
Возможность быстрого создания и изменения макетов без написания кода.
➖Меньшая гибкость
Ограниченные возможности для создания сложных и динамических макетов.
➖Конфликты при совместной работе
Трудности при слиянии изменений в storyboard или xib файлах в больших командах.
➖Производительность
Более медленное время загрузки по сравнению с программными подходами.

🚩Auto Layout

➕Адаптивность
Поддержка различных устройств и ориентаций экрана.
➕Мощные инструменты
Возможность создания сложных и адаптивных макетов с помощью ограничений.
➕Интеграция с Interface Builder
Упрощенная настройка ограничений через визуальный интерфейс.
➖Крутая кривая обучения
Может быть сложно освоить, особенно для новичков.
➖Управление сложными макетами
Требует тщательного планирования и может стать сложным при работе с большим количеством ограничений.

🚩Programmatic Layout

➕Полный контроль
Возможность точной настройки макета с помощью кода.
➕Гибкость
Легкость создания динамических и условных макетов.
➕Управление версиями
Легче управлять изменениями в коде по сравнению с визуальными файлами.
➖Большая трудоемкость
Требует больше времени и усилий для настройки, особенно для сложных макетов.
➖Меньшая наглядность
Отсутствие визуального редактора может затруднить представление конечного результата.

🚩Stack Views

➕Упрощение макетов
Легкость создания и управления сложными макетами с минимальными усилиями.
➕Интеграция с Auto Layout
Автоматическое управление ограничениями для вложенных элементов.
➕Адаптивность
Поддержка различных ориентаций и размеров экранов.
➖Ограниченная гибкость
Менее гибкие по сравнению с чистым Auto Layout или программными подходами.
➖Поддержка
Не всегда подходят для всех типов макетов, особенно для более сложных компоновок.

🚩SwiftUI

➕Декларативный синтаксис
Простота и понятность кода благодаря декларативному подходу.
➕Превью в реальном времени
Мгновенное обновление интерфейса при изменении кода.
➕Интеграция с Swift
Современные возможности языка и тесная интеграция с экосистемой Apple.
➕Кроссплатформенность
Поддержка различных платформ (iOS, macOS, watchOS, tvOS).
➖Требования к версии iOS
Поддержка только iOS 13 и выше, что может ограничить использование на старых устройствах.
➖Зрелость фреймворка
Некоторые функции еще находятся в стадии разработки, и могут быть ограничены возможности по сравнению с UIKit.

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

🤔 Расскажи об отличиях MVC от MVP?

MVC (Model-View-Controller) разделяет данные, пользовательский интерфейс и логику управления, где View напрямую взаимодействует с Controller. В MVP (Model-View-Presenter) Presenter управляет всей логикой и взаимодействием, а View становится пассивной, обрабатывая только отображение данных. MVP лучше подходит для тестирования, так как логика полностью изолирована в Presenter.

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

🤔 Зачем нужны сильные ссылки?

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

🚩Основные причины использования

🟠Удержание объектов в памяти
Сильные ссылки гарантируют, что объект остается в памяти, пока на него существует хотя бы одна сильная ссылка. Без сильных ссылок объекты могли бы быть автоматически удалены сборщиком мусора, даже если они все еще нужны.

class Person {
var name: String
init(name: String) {
self.name = name
}
}

var person1: Person? = Person(name: "Alice")
var person2 = person1  // person2 теперь также держит сильную ссылку на объект

🟠Управление жизненным циклом объектов
Сильные ссылки контролируют время жизни объектов, предотвращая их преждевременное удаление из памяти. Объекты остаются живыми, пока они нужны, и удаляются только тогда, когда все сильные ссылки на них удаляются.

var person1: Person? = Person(name: "Alice")
person1 = nil  // Объект "Alice" удаляется, если нет других сильных ссылок на него

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

class ViewController {
var button: UIButton?
init() {
button = UIButton()
}
}

var viewController: ViewController? = ViewController()

🚩Плюсы

➕Простота использования
Сильные ссылки являются стандартным способом управления памятью и не требуют дополнительного кода для их создания и управления.
➕Надежность
Они предотвращают утечки памяти, гарантируя, что объекты удаляются, когда на них больше нет ссылок.
➕Ясность кода
Сильные ссылки делают код более предсказуемым, так как объекты остаются в памяти, пока они нужны.

🚩Потенциальные проблемы

Если два объекта имеют сильные ссылки друг на друга, они никогда не будут освобождены, что приведет к утечкам памяти. Это решается использованием слабых (weak) или неактивных (unowned) ссылок.

class Person {
var name: String
var friend: Person?
init(name: String) {
self.name = name
}
}

var alice: Person? = Person(name: "Alice")
var bob: Person? = Person(name: "Bob")

alice?.friend = bob
bob?.friend = alice

// Объекты alice и bob никогда не будут освобождены из памяти

🚩Решение проблемы циклов сильных ссылок

Использование слабых (weak) или неактивных (unowned) ссылок для разрыва циклов сильных ссылок:

class Person {
var name: String
weak var friend: Person?
init(name: String) {
self.name = name
}
}

var alice: Person? = Person(name: "Alice")
var bob: Person? = Person(name: "Bob")

alice?.friend = bob
bob?.friend = alice

// Объекты alice и bob будут освобождены, когда на них не будет сильных ссылок

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

🤔Что такое cherrypick?

cherrypick — это команда Git, которая позволяет взять конкретные изменения из одного коммита и применить их в другой ветке. Это полезно для исправления ошибок или добавления небольших фич без полного слияния веток.

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

🤔 Зачем нужны слабые ссылки?

Слабые ссылки (weak references) играют важную роль в управлении памятью, особенно когда нужно предотвратить циклы сильных ссылок (retain cycles) и утечки памяти.

🚩Основные причины использования

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

class Person {
    var name: String
    weak var friend: Person?
    init(name: String) {
        self.name = name
    }
}

var alice: Person? = Person(name: "Alice")
var bob: Person? = Person(name: "Bob")

alice?.friend = bob
bob?.friend = alice

alice = nil  // Теперь объекты могут быть освобождены
bob = nil  

🟠Избежание утечек памяти
Утечки памяти происходят, когда объекты, которые больше не нужны, не освобождаются из памяти. Слабые ссылки помогают избежать этих утечек, обеспечивая правильное освобождение памяти. Делегаты часто объявляются как слабые ссылки, чтобы избежать утечек памяти.

protocol TaskDelegate: AnyObject {
    func taskDidFinish()
}

class Task {
    weak var delegate: TaskDelegate?
    func complete() {
        delegate?.taskDidFinish()
    }
}

class ViewController: TaskDelegate {
    var task = Task()
    init() {
        task.delegate = self
    }

    func taskDidFinish() {
        print("Task finished")
    }
}  

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

class Cache {
    weak var temporaryObject: SomeClass?
}

class SomeClass {
    // Код класса
}

var cache = Cache()
var object = SomeClass()
cache.temporaryObject = object
object = SomeClass()  // Старый объект удаляется, так как на него нет сильных ссылок  

🚩Плюсы и минусы

➕Предотвращение циклов ссылок
Основное преимущество слабых ссылок заключается в их способности разрывать циклы ссылок, предотвращая утечки памяти.
➕Обеспечение корректного управления памятью
Слабые ссылки позволяют объектам освобождаться из памяти, когда на них больше нет сильных ссылок, что улучшает управление ресурсами.
➕Гибкость и безопасность
Использование слабых ссылок обеспечивает более гибкое и безопасное управление зависимостями между объектами.
➖Сложности управления
Необходимо учитывать, что слабые ссылки могут стать nil в любой момент, поэтому требуется дополнительная проверка.
➖Понимание жизненного цикла объектов
Требуется хорошее понимание жизненного цикла объектов и управления памятью, чтобы правильно использовать слабые ссылки.

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

🤔 Чем отличается rebase от merge?

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

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

🤔 Message используется только при тестировании или еще когда-то?

В разработке и программировании в целом Message (или Message Passing) может использоваться в различных контекстах, не только при тестировании.

🚩Основные случаи использования

🟠Тестирование
Передача сообщений используется для имитации взаимодействий между объектами, проверки их поведения и создания мок-объектов. Использование XCTest для создания мок-объектов и проверки вызова методов.

class MockService: Service {
    var didCallMethod = false
    func someMethod() {
        didCallMethod = true
    }
}  

🟠Делегирование
Используется для передачи сообщений от одного объекта к другому, часто через протоколы. Это позволяет одному объекту уведомлять другой о произошедших событиях. Использование делегатов в UITableView.

protocol TableViewDelegate: AnyObject {
    func didSelectRow(at indexPath: IndexPath)
}

class TableView: UIView {
    weak var delegate: TableViewDelegate?
    // код для обработки выбора строки
}  

🟠Уведомления (Notifications)
Используется для передачи сообщений между различными частями приложения. Это позволяет объектам взаимодействовать, не зная друг о друге. Отправка и получение уведомлений.

NotificationCenter.default.post(name: .someNotification, object: nil)
  
NotificationCenter.default.addObserver(self, selector: #selector(handleNotification), name: .someNotification, object: nil)  

🟠Клоужеры (Closures)
Позволяют передавать логические блоки кода как аргументы функций или методов. Это часто используется для обратных вызовов. Использование клоужеров для асинхронных операций.

func fetchData(completion: @escaping (Result<Data, Error>) -> Void) {
    // код для получения данных
    completion(.success(data))
}  

🟠Межпроцессное взаимодействие (Inter-Process Communication, IPC)
Передача сообщений между различными процессами или приложениями, часто через специфические API и фреймворки. Использование XPC для общения между процессами.

let connection = NSXPCConnection(serviceName: "com.example.service")
connection.remoteObjectInterface = NSXPCInterface(with: ExampleProtocol.self)  

🟠Асинхронное программирование
Использование акторов и очередей для безопасной передачи сообщений между потоками. Использование DispatchQueue для выполнения задач асинхронно.

DispatchQueue.global().async {
    // Асинхронная задача
    DispatchQueue.main.async {
        // Обновление UI
    }
}  

🟠Веб-сервисы и сетевые запросы
Передача сообщений между клиентом и сервером с использованием протоколов HTTP, WebSocket и т.д. Использование URLSession для выполнения сетевых запросов.

let url = URL(string: "https://example.com/api")!
let task = URLSession.shared.dataTask(with: url) { data, response, error in
    // обработка ответа
}
task.resume()  

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