📌 Что такое ассоциированный тип (associated type) ?

💬 Спрашивают в 45% собеседований

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

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

🤔 Пример:

protocol Container {
    associatedtype Item // Определение ассоциированного типа
    
    mutating func append(_ item: Item)
    var count: Int { get }
    subscript(i: Int) -> Item { get }
}

struct IntStack: Container {
    // конкретная реализация ассоциированного типа Item как Int
    typealias Item = Int

    // реализация требований протокола
    var items = [Item]()
    mutating func append(_ item: Item) {
        items.append(item)
    }
    var count: Int {
        return items.count
    }
    subscript(i: Int) -> Item {
        return items[i]
    }
}

В этом примере, протокол Container определяет требования для контейнерных типов, включая ассоциированный тип Item. Когда структура IntStack принимает протокол Container, она указывает, что ассоциированный тип Item будет представлен как Int. Это позволяет протоколу Container быть адаптивным и работать с любыми типами, сохраняя при этом строгую типизацию и безопасность типов, характерные для Swift.

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

🔥 ТОП ВОПРОСОВ С СОБЕСОВ

🔒 База собесов | 🔒 База тестовых

📌 Какие есть паттерны в объектном проектировании ?

💬 Спрашивают в 27%

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

Порождающие паттерны
Эти паттерны связаны с процессами создания объектов, делая систему независимой от способа создания, компоновки и представления объектов.

➕ Одиночка (Singleton): Обеспечивает создание только одного экземпляра класса и предоставляет глобальную точку доступа к этому экземпляру.

➕ Фабричный метод (Factory Method): Определяет интерфейс для создания объекта, но оставляет подклассам решение о том, какой класс инстанцировать.

➕ Абстрактная фабрика (Abstract Factory): Предоставляет интерфейс для создания семейств взаимосвязанных или взаимозависимых объектов без указания их конкретных классов.

➕ Прототип (Prototype): Позволяет копировать существующие объекты без делания кода зависимым от их классов.

➕ Строитель (Builder): Позволяет создавать сложные объекты пошагово, используя один и тот же процесс строительства для получения разных представлений.

Структурные паттерны описывают, как объединять объекты и классы в более крупные структуры.

➕ Адаптер (Adapter): Позволяет объектам с несовместимыми интерфейсами работать вместе.

➕ Мост (Bridge): Разделяет абстракцию и реализацию так, чтобы они могли изменяться независимо.

➕ Композит (Composite): Комбинирует объекты в древовидные структуры для представления иерархий "часть-целое".

➕ Декоратор (Decorator): Динамически добавляет объектам новые обязанности без изменения их реализации.

➕ Фасад (Facade): Предоставляет простой интерфейс к сложной системе классов, библиотеке или фреймворку.

➕ Прокси (Proxy): Предоставляет заместителя или заполнитель для другого объекта для контроля доступа к нему.

Поведенческие паттерны регулируют эффективное взаимодействие и распределение обязанностей между объектами.

➕ Наблюдатель (Observer): Создаёт механизм подписки, позволяющий одним объектам следить и реагировать на события, происходящие в других объектах.

➕ Стратегия (Strategy): Определяет семейство алгоритмов, инкапсулирует каждый из них и делает их взаимозаменяемыми.

➕ Состояние (State): Позволяет объекту изменять своё поведение в зависимости от своего состояния.

➕ Команда (Command): Превращает запросы в объекты, позволяя передавать их как аргументы при вызове методов, ставить их в очередь, логировать и т.д.

➕ Цепочка обязанностей (Chain of Responsibility): Позволяет передавать запросы последовательно по цепочке обработчиков. Каждый последующий обработчик решает, может ли он обработать запрос сам и следует ли передать запрос дальше по цепочке.

➕ Посредник (Mediator): Позволяет уменьшить взаимосвязь между классами, вынося межклассовые взаимодействия в класс-посредник.

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

🔥 ТОП ВОПРОСОВ С СОБЕСОВ

🔒 База собесов | 🔒 База тестовых

📌 Для каких сущностей работает copy on write ?

💬 Спрашивают в 27% собеседований

Механизм Copy-on-Write (CoW) используется для оптимизации производительности и использования памяти при копировании объектов. Этот механизм особенно полезен для неизменяемых (immutable) структур данных. CoW часто ассоциируется со стандартными коллекциями и собственными типами данных, реализованными как структуры (value types), такие как Array, String, Dictionary, и Set.

🤔 Принцип работы Copy-on-Write

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

🤔 Как это работает в Swift

Автоматически применяет механизм CoW к своим стандартным коллекциям, таким как Array, String, Dictionary, и Set. Это означает, что при передаче этих объектов в функции или при их копировании реальное дублирование данных происходит только в случае модификации одной из копий. Таким образом, если вы создаёте копию массива и не изменяете его, обе переменные будут указывать на одни и те же данные в памяти. Как только вы модифицируете одну из копий, Swift создаст реальную копию данных для этой копии, обеспечивая независимость данных между оригиналом и копией.

🤔 Пример:

var originalArray = [1, 2, 3]
var copiedArray = originalArray // На этом этапе данные не дублируются

copiedArray.append(4) // Теперь данные копируются, потому что copiedArray модифицируется

В этом примере до вызова append обе переменные, originalArray и copiedArray, ссылаются на один и тот же набор данных. Модификация copiedArray активирует механизм CoW, и Swift создаёт реальную копию данных для copiedArray.

🤔 Реализация CoW для собственных типов данных

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

Copy-on-Write — это механизм оптимизации, который позволяет отложить копирование данных до момента их реальной модификации. Это улучшает производительность и эффективность использования памяти, особенно при работе с большими структурами данных. Swift автоматически применяет CoW к своим стандартным коллекциям, таким как Array, String, Dictionary,и Set.

🔥 ТОП ВОПРОСОВ С СОБЕСОВ

🔒 База собесов | 🔒 База тестовых

📌 Что известно о MVVM ?

💬 Спрашивают в 27% собеседований

MVVM (Model-View-ViewModel) — это архитектурный паттерн, разработанный для упрощения создания пользовательского интерфейса, который был впервые представлен Microsoft для использования с Windows Presentation Foundation (WPF) и Silverlight. С тех пор он нашёл широкое применение в различных технологиях разработки программного обеспечения, включая разработку под iOS и Android. MVVM помогает разделить логику представления интерфейса (UI) от бизнес-логики и логики приложения, упрощая тестирование и поддержку.

🤔 Основные компоненты:

➕ Model (Модель): Содержит бизнес-логику и данные приложения. Модель отвечает за доступ к данным, их хранение, валидацию, обработку и т.д.

➕ View (Представление): Отображает данные (модель) пользователю и передаёт пользовательский ввод (например, нажатие кнопки) в ViewModel. В контексте iOS это могут быть UIViews и UIViewControllerы.

➕ ViewModel (Модель представления): Служит посредником между View и Model, предоставляя поток данных между ними. ViewModel обрабатывает всю логику представления, включая преобразование данных из Model для отображения в View. Она также обрабатывает все действия пользователей, переданные из View, и может вызывать изменения в Model.

🤔 Особенности и преимущества:

➕ Разделение ответственности: Чётко разделяет логику представления от бизнес-логики, что облегчает тестирование и поддержку кода.

➕ Упрощение тестирования: Благодаря изоляции бизнес-логики и логики представления, ViewModel можно тестировать независимо от пользовательского интерфейса и логики работы с данными.

➕ Привязка данных (Data Binding): Часто использует механизмы привязки данных, чтобы обеспечить автоматическое обновление View при изменении данных в ViewModel и наоборот. Это уменьшает количество шаблонного кода для обновления интерфейса.

➕ Улучшение поддерживаемости: Изменения в пользовательском интерфейсе или бизнес-логике оказывают меньшее влияние на другие аспекты приложения, что упрощает внесение изменений.

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

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

🔥 ТОП ВОПРОСОВ С СОБЕСОВ

🔒 База собесов | 🔒 База тестовых

📌 Каков жизненный цикл приложения ?

💬 Спрашивают в 27% собеседований

Жизненный цикл приложения определяет ключевые состояния, через которые проходит приложение в процессе его запуска, работы и завершения. Основные состояния управляются классом UIApplication и его делегатом UIApplicationDelegate, который предоставляет разработчикам набор методов для реагирования на переходы между этими состояниями. Вот основные этапы жизненного цикла:

1️⃣ Не запущено (Not Running)

Приложение ещё не было запущено или было завершено.

2️⃣ Неактивное состояние (Inactive)

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

3️⃣ Активное состояние (Active)
Приложение активно и получает события. Это основное рабочее состояние приложения, когда пользователь взаимодействует с его интерфейсом.

4️⃣ Фоновое состояние (Background)

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

5️⃣ Приостановлено (Suspended)

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

Методы AppDelegate для управления жизненным циклом

Разработчики могут реагировать на изменения в жизненном цикле, используя методы делегата UIApplicationDelegate, такие как:

➕ application(_:didFinishLaunchingWithOptions:) — вызывается, когда приложение завершает запуск.

➕ applicationDidBecomeActive(_:) — вызывается, когда приложение становится активным.

➕ applicationWillResignActive(_:) — вызывается, когда приложение переходит из активного состояния в неактивное.

➕ applicationDidEnterBackground(_:) — вызывается, когда приложение переходит в фоновый режим.

➕ applicationWillEnterForeground(_:) — вызывается перед переходом приложения из фонового режима в активный.

➕ applicationWillTerminate(_:) — вызывается перед тем, как приложение будет завершено.

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

🔥 ТОП ВОПРОСОВ С СОБЕСОВ

🔒 База собесов | 🔒 База тестовых

📌 Что такое "Опционалы" ?

💬 Спрашивают в 45% собеседований

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

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

🤔 Пример:

var optionalInt: Int? = nil

В этом случае переменная optionalInt объявлена как опциональная Int. Изначально она не содержит значения, что обозначается как nil.

Предлагается несколько способов работы с опционалами, включая:

1️⃣ Принудительное развертывание: Использование восклицательного знака (!) для доступа к значению опционала. Этот метод опасен, так как может привести к ошибке времени выполнения, если опционал содержит nil.

let someValue: Int? = 5
let unwrappedValue: Int = someValue! // Принудительное развертывание

2️⃣ Опциональное связывание: Позволяет безопасно проверить и извлечь значение опционала, если оно существует.

if let unwrappedValue = someValue {
    print(unwrappedValue) // Безопасное использование unwrappedValue
}

3️⃣ Оператор объединения с nil (nil-coalescing operator): Позволяет предоставить значение по умолчанию для опционала в случае, если в нем содержится nil.

let defaultValue = someValue ?? 0 // Использует 0, если someValue содержит nil

Использование опционалов является ключевым для обеспечения безопасности типов и предотвращения распространенных ошибок, связанных с обращением к неинициализированным или отсутствующим значениям.

🔥 ТОП ВОПРОСОВ С СОБЕСОВ

🔒 База собесов | 🔒 База тестовых

📌 В чем разница между MVC и MVVM ?

💬 Спрашивают в 27% собеседований

MVC (Model-View-Controller) и MVVM (Model-View-ViewModel) — это два популярных архитектурных паттерна, используемых в разработке ПО для организации кода и разделения ответственности между компонентами системы. Оба паттерна направлены на упрощение разработки и поддержки приложений, но они делают это по-разному.

🤔 MVC (Model-View-Controller) Компоненты:

➕ Model: Отвечает за данные и бизнес-логику приложения. Модель не знает о контроллерах и видах, обращаясь к ним через делегаты или нотификации.

➕ View: Отображает данные (модель) пользователю и отправляет действия пользователя контроллеру. View не содержит бизнес-логику обработки данных.

➕ Controller: Служит посредником между моделью и видом, обрабатывая пользовательский ввод и обновляя модель или вид.

🤔 Особенности:

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

🤔 MVVM (Model-View-ViewModel) Компоненты:

➕ Model: Содержит данные и бизнес-логику.

➕ View: Отображает визуальные элементы и генерирует события пользовательского ввода. View также может непосредственно обращаться к ViewModel через привязку данных (data binding).

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

🤔 Особенности:

➕ Слабая связь между View и ViewModel, что упрощает тестирование и поддержку.

➕ Использование привязки данных сокращает объём шаблонного кода для обновления интерфейса.

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

➕ Связность: В MVVM меньше связности между отображением и логикой представления, благодаря использованию ViewModel и механизмов привязки данных. В MVC виды и контроллеры тесно связаны.

➕ Разделение ответственности: MVVM позволяет лучше разделить логику отображения от бизнес-логики, переместив большую часть логики отображения из View в ViewModel. В MVC контроллеры могут стать перегруженными, поскольку в них содержится и логика управления данными, и логика управления представлениями.

➕ Тестирование: MVVM облегчает тестирование логики представления благодаря слабой связности и отделению ViewModel от View. В MVC тестирование может быть усложнено из-за сильной связности между контроллерами и видами.

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

🔥 ТОП ВОПРОСОВ С СОБЕСОВ

🔒 База собесов | 🔒 База тестовых

📌 Что такое Retain Cycle ?

💬 Спрашивают в 27% собеседований

Цикл удержания (Retain Cycle) — это проблема управления памятью, которая возникает в языках программирования с автоматическим подсчётом ссылок (например, в Swift и Objective-C), когда два объекта хранят сильные (strong) ссылки друг на друга. Это приводит к тому, что объекты не освобождаются автоматически после того, как становятся ненужными, потому что счетчик ссылок на каждый из них остаётся больше нуля. В результате память, которую занимают эти объекты, утекает, что может привести к избыточному расходу памяти и в конечном итоге к снижению производительности или даже к аварийному завершению работы приложения.

🤔 Как оно возникает

Представьте себе два объекта A и B. Объект A имеет сильную ссылку на объект B, а объект B в свою очередь имеет сильную ссылку на объект A. В такой ситуации, даже если внешние ссылки на эти объекты будут удалены, они всё равно не будут освобождены из-за взаимных сильных ссылок, которые поддерживают счетчик ссылок каждого из объектов больше нуля.

🤔 Как избежать этого

1️⃣ Использование слабых (weak) или некрепких (unowned) ссылок: Одним из решений является использование слабых или некрепких ссылок для одного из взаимосвязанных объектов.weak и unowned ссылки не увеличивают счетчик ссылок объекта, на который они указывают, что предотвращает возникновение цикла удержания.

➕ Слабые ссылки (`weak`): Используются, когда ссылка может быть nil. Swift автоматически обнуляет слабую ссылку, когда объект, на который она указывает, освобождается.

➕ Некрепкие ссылки (`unowned`): Используются, когда гарантировано, что ссылка всегда будет указывать на объект, и вы хотите избежать цикла удержания. В отличие от слабой ссылки, некрепкая ссылка не обнуляется автоматически и может привести к ошибке времени выполнения, если объект будет освобождён.

2️⃣Изменение архитектуры приложения: Иногда стоит пересмотреть взаимодействие между объектами в вашем приложении, чтобы избежать необходимости создания взаимосильных ссылок.

🤔 Пример:

class Parent {
    var child: Child?
}

class Child {
    weak var parent: Parent?
}

var parent: Parent? = Parent()
var child: Child? = Child()

parent?.child = child
child?.parent = parent

// Разрыв ссылок
parent = nil
child = nil

В этом примере parent имеет сильную ссылку на child, но child имеет слабую ссылку на parent. Это предотвращает возникновение цикла удержания, и объекты могут быть корректно освобождены из памяти.

Цикл удержания — это ситуация, при которой два объекта ссылаются друг на друга сильными ссылками, предотвращая их освобождение и вызывая утечку памяти. Использование слабых (weak) или некрепких (unowned) ссылок помогает избежать этих циклов и обеспечивает корректное управление памятью в приложениях на Swift и Objective-C.

🔥 ТОП ВОПРОСОВ С СОБЕСОВ

🔒 База собесов | 🔒 База тестовых

📌 Как устроен responder chain ?

💬 Спрашивают в 27% собеседований

Responder chain (цепочка обработчиков событий) — это концепция, используемая для обработки событий, таких как касания, жесты, нажатия клавиш и другие пользовательские действия. Она представляет собой последовательность объектов (responders), которые могут реагировать на эти события. Цепочка обработчиков позволяет событию быть переданным от одного объекта к другому, пока не будет найден подходящий обработчик события или пока цепочка не будет завершена.

🤔 Как это работает

1️⃣ Начало цепочки: В контексте iOS приложения, цепочка обработчиков событий начинается с объекта, который первым получает событие. Например, в случае касания экрана это может быть конкретный элемент управления UI (например, кнопка), который распознает касание.

2️⃣ Передача события: Если этот объект (responder) не обрабатывает событие, оно передается дальше по цепочке. Обычно следующим в цепочке является родительский элемент в иерархии представлений, и так далее, вплоть до корневого представления.

3️⃣ ViewController и дальше: Если событие достигает корневого представления и оно не обрабатывается, оно передается объекту ViewController этого представления. Затем ViewController может обработать событие или передать его дальше по цепочке.

4️⃣ UIApplication и AppDelegate: Если ни один из ViewControllers не обработал событие, оно может быть передано объекту приложения (UIApplication) и, в конечном счёте, его делегату (AppDelegate), где оно может быть обработано или проигнорировано.

🤔 Пример

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

🤔 Зачем это нужно

Responder chain позволяет создавать гибкую архитектуру обработки событий, где события могут быть обработаны на разных уровнях приложения. Это обеспечивает большую модульность и разделение ответственности между компонентами приложения. Кроме того, это упрощает добавление новых типов обработчиков событий, не нарушая существующую логику приложения.

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

🔥 ТОП ВОПРОСОВ С СОБЕСОВ

🔒 База собесов | 🔒 База тестовых

📌 Что такое жизненный цикл объекта ?

💬 Спрашивают в 45% собеседований

Жизненный цикл объекта — это период с момента его создания до момента уничтожения. Управление жизненным циклом объекта важно для эффективного использования памяти и предотвращения утечек памяти, особенно в языках программирования, где управление памятью выполняется автоматически через механизм подсчёта ссылок (reference counting).

🤔 Создание объекта

1️⃣ Инициализация (Initialization): Объект создаётся в памяти. Это происходит при вызове инициализатора, который устанавливает начальное состояние всех свойств объекта. Инициализаторы могут быть определены с различными параметрами, позволяя создавать объекты с разными начальными значениями.

🤔 Использование объекта

2️⃣ Доступ и изменение состояния: После создания объекта его методы могут быть вызваны, а свойства — читаться или изменяться. Это активный период в жизненном цикле объекта, когда он выполняет полезную работу.

🤔 Уничтожение объекта

3️⃣ Деинициализация (Deinitialization): Непосредственно перед тем, как объект будет уничтожен, вызывается деинициализатор (если он определён). Это дает возможность освободить ресурсы или выполнить другие операции по очистке. Деинициализаторы не принимают никаких параметров и указываются с помощью ключевого слова deinit.

4️⃣ Освобождение памяти (Deallocation): Когда на объект больше нет активных ссылок (когда счётчик ссылок достигает нуля), память, занимаемая объектом, освобождается. Это означает, что объект удаляется из памяти, и ресурсы, которые он использовал, становятся доступными для других объектов или программ.

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

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

🔥 ТОП ВОПРОСОВ С СОБЕСОВ

🔒 База собесов | 🔒 База тестовых