В ООП существует множество паттернов, которые помогают решать различные задачи проектирования и разработки ПО. Паттерны проектирования представляют собой проверенные решения типовых проблем, с которыми сталкиваются разработчики. Они способствуют написанию более чистого, понятного и масштабируемого кода. Основные категории паттернов включают в себя порождающие, структурные и поведенческие паттерны.
Порождающие паттерны
Эти паттерны связаны с процессами создания объектов, делая систему независимой от способа создания, компоновки и представления объектов.
Структурные паттерны описывают, как объединять объекты и классы в более крупные структуры.
Поведенческие паттерны регулируют эффективное взаимодействие и распределение обязанностей между объектами.
Эти паттерны не только помогают решать типичные задачи проектирования, но и способствуют созданию более читаемого, удобного для поддержки и масштабируемого кода.
Please open Telegram to view this post
VIEW IN TELEGRAM
❤1
Anonymous Quiz
5%
`?`
94%
`!`
0%
`*`
0%
`&`
Механизм Copy-on-Write (CoW) используется для оптимизации производительности и использования памяти при копировании объектов. Этот механизм особенно полезен для неизменяемых (immutable) структур данных. CoW часто ассоциируется со стандартными коллекциями и собственными типами данных, реализованными как структуры (value types), такие как
Array, String, Dictionary, и Set.Работает так, что копия объекта создаётся только в тот момент, когда происходит попытка модификации. До этого момента все копии объекта фактически ссылаются на одни и те же данные в памяти. Это позволяет сэкономить как время, так и память, поскольку избегается ненужное дублирование данных, когда оно не требуется.
Автоматически применяет механизм 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 в своих типах необходимо вручную проверять, является ли экземпляр типа уникальной ссылкой, и копировать данные при необходимости, обычно используя методы для работы с памятью, такие как
isKnownUniquelyReferenced().Copy-on-Write — это механизм оптимизации, который позволяет отложить копирование данных до момента их реальной модификации. Это улучшает производительность и эффективность использования памяти, особенно при работе с большими структурами данных. Swift автоматически применяет CoW к своим стандартным коллекциям, таким как
Array, String, Dictionary,и Set.Please open Telegram to view this post
VIEW IN TELEGRAM
Anonymous Quiz
74%
enum Name: String { case A = "Apple", B = "Banana" }
16%
enum Name { case A = "Apple", case B = "Banana" }
4%
enum Name(String) { case A = "Apple", case B = "Banana" }
5%
type enum Name: String { case A = "Apple", case B = "Banana" }
MVVM (Model-View-ViewModel) — это архитектурный паттерн, разработанный для упрощения создания пользовательского интерфейса, который был впервые представлен Microsoft для использования с Windows Presentation Foundation (WPF) и Silverlight. С тех пор он нашёл широкое применение в различных технологиях разработки программного обеспечения, включая разработку под iOS и Android. MVVM помогает разделить логику представления интерфейса (UI) от бизнес-логики и логики приложения, упрощая тестирование и поддержку.
MVVM может быть реализован с использованием различных фреймворков и технологий, таких как RxSwift или Combine, которые предоставляют мощные инструменты для реализации привязки данных и управления потоками данных. Это позволяет разработчикам создавать реактивные приложения, где View автоматически обновляется в ответ на изменения данных, обеспечивая более плавный и интуитивно понятный пользовательский опыт.
MVVM не только способствует созданию более чистого и организованного кода, но и облегчает сотрудничество в командах, позволяя разработчикам интерфейса и логики приложения работать более независимо.
Please open Telegram to view this post
VIEW IN TELEGRAM
Anonymous Quiz
2%
protocol MyProtocol { mandatory func myMethod() }
14%
protocol MyProtocol { required func myMethod() }
82%
protocol MyProtocol { func myMethod() }
1%
define protocol MyProtocol { func myMethod() }
Жизненный цикл приложения определяет ключевые состояния, через которые проходит приложение в процессе его запуска, работы и завершения. Основные состояния управляются классом
UIApplication и его делегатом UIApplicationDelegate, который предоставляет разработчикам набор методов для реагирования на переходы между этими состояниями. Вот основные этапы жизненного цикла:Приложение ещё не было запущено или было завершено.
Приложение запущено, но не получает события. Это может произойти в моменты временного перерыва, например, во время перехода из одного состояния в другое, или когда система ожидает ответа от пользователя или приложения.
Приложение активно и получает события. Это основное рабочее состояние приложения, когда пользователь взаимодействует с его интерфейсом.
Приложение находится в фоновом режиме и может выполнять код. Приложение переходит в это состояние из активного состояния, когда пользователь переключается на другое приложение или на главный экран. Приложения могут запросить дополнительное время для завершения задач в фоновом режиме.
Приложение находится в фоновом режиме, но не выполняет код. Операционная система может автоматически перевести приложение из фонового состояния в приостановленное для освобождения ресурсов. Приложение остается в памяти, но любые активные задачи, потоки или таймеры останавливаются.
Методы AppDelegate для управления жизненным циклом
Разработчики могут реагировать на изменения в жизненном цикле, используя методы делегата
UIApplicationDelegate, такие как:application(_:didFinishLaunchingWithOptions:) — вызывается, когда приложение завершает запуск.➕ applicationDidBecomeActive(_:) — вызывается, когда приложение становится активным.applicationWillResignActive(_:) — вызывается, когда приложение переходит из активного состояния в неактивное.applicationDidEnterBackground(_:) — вызывается, когда приложение переходит в фоновый режим.applicationWillEnterForeground(_:) — вызывается перед переходом приложения из фонового режима в активный.applicationWillTerminate(_:) — вызывается перед тем, как приложение будет завершено.Понимание жизненного цикла приложения критически важно для разработки стабильных и эффективных приложений на iOS, поскольку оно позволяет корректно управлять ресурсами, сохранять и восстанавливать состояние приложения и реагировать на действия пользователя и системы.
Please open Telegram to view this post
VIEW IN TELEGRAM
Anonymous Quiz
1%
let array = [Int]()
95%
var array = [Int]()
1%
const array = [Int]()
3%
array<int> = []
Опционалы — это особенность языка, позволяющая обрабатывать ситуации, когда значение может отсутствовать. Может содержать либо значение соответствующего типа, либо
nil, указывая на отсутствие значения. Это позволяет безопасно работать с данными, которые могут быть не предоставлены, избегая при этом ошибок выполнения, связанных с обращением к переменным, не имеющим фактического значения.Их использование помогает предотвратить ситуации, когда программа пытается обратиться к значению, которое не было задано, что может привести к сбою программы. Они требуют явного развертывания для доступа к их содержимому, что заставляет осознанно обрабатывать случаи, когда значение отсутствует.
var optionalInt: Int? = nil
В этом случае переменная
optionalInt объявлена как опциональная Int. Изначально она не содержит значения, что обозначается как nil.Предлагается несколько способов работы с опционалами, включая:
!) для доступа к значению опционала. Этот метод опасен, так как может привести к ошибке времени выполнения, если опционал содержит nil.let someValue: Int? = 5
let unwrappedValue: Int = someValue! // Принудительное развертывание
if let unwrappedValue = someValue {
print(unwrappedValue) // Безопасное использование unwrappedValue
}nil.let defaultValue = someValue ?? 0 // Использует 0, если someValue содержит nil
Использование опционалов является ключевым для обеспечения безопасности типов и предотвращения распространенных ошибок, связанных с обращением к неинициализированным или отсутствующим значениям.
Please open Telegram to view this post
VIEW IN TELEGRAM
Anonymous Quiz
48%
`?`
4%
`!`
47%
`??`
1%
`&`
🤔1
MVC (Model-View-Controller) и MVVM (Model-View-ViewModel) — это два популярных архитектурных паттерна, используемых в разработке ПО для организации кода и разделения ответственности между компонентами системы. Оба паттерна направлены на упрощение разработки и поддержки приложений, но они делают это по-разному.
Выбор между MVC и MVVM зависит от конкретного проекта, предпочтений команды и требований к архитектуре приложения. MVVM часто предпочтителен для приложений с сложным пользовательским интерфейсом и динамическими данными из-за его гибкости и упрощения тестирования.
Please open Telegram to view this post
VIEW IN TELEGRAM
🔥2
Anonymous Quiz
95%
print()
2%
println()
0%
echo()
2%
console.log()
👾1
Цикл удержания (Retain Cycle) — это проблема управления памятью, которая возникает в языках программирования с автоматическим подсчётом ссылок (например, в Swift и Objective-C), когда два объекта хранят сильные (strong) ссылки друг на друга. Это приводит к тому, что объекты не освобождаются автоматически после того, как становятся ненужными, потому что счетчик ссылок на каждый из них остаётся больше нуля. В результате память, которую занимают эти объекты, утекает, что может привести к избыточному расходу памяти и в конечном итоге к снижению производительности или даже к аварийному завершению работы приложения.
Представьте себе два объекта
A и B. Объект A имеет сильную ссылку на объект B, а объект B в свою очередь имеет сильную ссылку на объект A. В такой ситуации, даже если внешние ссылки на эти объекты будут удалены, они всё равно не будут освобождены из-за взаимных сильных ссылок, которые поддерживают счетчик ссылок каждого из объектов больше нуля.weak и unowned ссылки не увеличивают счетчик ссылок объекта, на который они указывают, что предотвращает возникновение цикла удержания.nil. Swift автоматически обнуляет слабую ссылку, когда объект, на который она указывает, освобождается.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.Please open Telegram to view this post
VIEW IN TELEGRAM
Anonymous Quiz
11%
var
84%
let
3%
const
1%
static
Responder chain (цепочка обработчиков событий) — это концепция, используемая для обработки событий, таких как касания, жесты, нажатия клавиш и другие пользовательские действия. Она представляет собой последовательность объектов (responders), которые могут реагировать на эти события. Цепочка обработчиков позволяет событию быть переданным от одного объекта к другому, пока не будет найден подходящий обработчик события или пока цепочка не будет завершена.
ViewController этого представления. Затем ViewController может обработать событие или передать его дальше по цепочке.ViewControllers не обработал событие, оно может быть передано объекту приложения (UIApplication) и, в конечном счёте, его делегату (AppDelegate), где оно может быть обработано или проигнорировано.Представим ситуацию, когда пользователь нажимает на кнопку, но код обработки события нажатия отсутствует в классе этой кнопки. В таком случае событие будет передано родительскому представлению кнопки. Если и родительское представление не обрабатывает это событие, оно продолжит передаваться вверх по иерархии представлений, пока не найдет подходящий обработчик или не достигнет конца цепочки.
Responder chain позволяет создавать гибкую архитектуру обработки событий, где события могут быть обработаны на разных уровнях приложения. Это обеспечивает большую модульность и разделение ответственности между компонентами приложения. Кроме того, это упрощает добавление новых типов обработчиков событий, не нарушая существующую логику приложения.
Responder chain — это система для передачи и обработки событий, которая обеспечивает последовательную передачу событий от одного объекта к другому в пределах иерархии приложения, пока событие не будет обработано или не достигнет конца цепочки. Это ключевой механизм для обработки пользовательского ввода и других событий в приложениях для платформ Apple.
Please open Telegram to view this post
VIEW IN TELEGRAM
Anonymous Quiz
92%
final class
6%
static class
1%
closed class
2%
sealed class
Жизненный цикл объекта — это период с момента его создания до момента уничтожения. Управление жизненным циклом объекта важно для эффективного использования памяти и предотвращения утечек памяти, особенно в языках программирования, где управление памятью выполняется автоматически через механизм подсчёта ссылок (reference counting).
deinit.Управление памятью объектов осуществляется через подсчёт ссылок (ARC — Automatic Reference Counting). ARC автоматически отслеживает, сколько активных ссылок указывает на каждый объект. Когда количество ссылок на объект уменьшается до нуля, Swift понимает, что объект больше не нужен, и автоматически уничтожает его, освобождая занимаемую память.
Понимание жизненного цикла объекта помогает избегать утечек памяти, неправильного управления ресурсами и других ошибок, связанных с управлением памятью. Например, утечки памяти могут произойти, если два объекта ссылаются друг на друга сильными ссылками, и их счётчики ссылок никогда не достигнут нуля, что препятствует ARC корректно уничтожить объекты.
Please open Telegram to view this post
VIEW IN TELEGRAM
👍1
Anonymous Quiz
96%
String
3%
Text
0%
Str
1%
Char
Асинхронность и многопоточность — это два разных подхода к параллельному выполнению задач, но они используются для разных целей и имеют разные механизмы.
Асинхронность
Асинхронность (asynchronous) позволяет программе выполнять другие операции, не дожидаясь завершения длительной задачи. Асинхронные операции не блокируют основной поток выполнения программы.
Основные характеристики асинхронности:
Пример на Swift с использованием async/await:
func fetchData() async -> String {
// Длительная операция
return "Данные получены"
}
func processData() {
Task {
let data = await fetchData()
print(data)
}
}
processData()Здесь
fetchData выполняется асинхронно, и основной поток не блокируется.Многопоточность
Многопоточность (multithreading) позволяет программе выполнять несколько потоков (threads) одновременно. Каждый поток может выполнять свою задачу параллельно с другими потоками.
Основные характеристики многопоточности:
Пример на Swift с использованием GCD:
DispatchQueue.global(qos: .background).async {
// Длительная операция
let data = "Данные получены"
DispatchQueue.main.async {
// Обновление UI на главном потоке
print(data)
}
}Здесь длительная операция выполняется в фоновом потоке, а результат обновляет UI на главном потоке.
Асинхронность и многопоточность служат для выполнения задач параллельно, но асинхронность не блокирует основной поток, а многопоточность позволяет выполнять несколько потоков одновременно. Асинхронность проще в управлении и часто используется для операций ввода-вывода, в то время как многопоточность используется для интенсивных вычислительных задач.
В двух фразах: Асинхронность позволяет выполнять задачи без блокировки основного потока и проста в управлении. Многопоточность позволяет параллельно выполнять несколько потоков, но требует сложной синхронизации.
Please open Telegram to view this post
VIEW IN TELEGRAM
👍1
Anonymous Quiz
92%
DispatchQueue.main.async {}
5%
DispatchQueue.global().async {}
0%
3%
Async.runOnMain {}
SwiftUI — это фреймворк от Apple для создания пользовательских интерфейсов для всех платформ Apple, включая iOS, macOS, watchOS и tvOS. SwiftUI был представлен на WWDC 2019 и является современным и декларативным способом создания UI.
Основные преимущества SwiftUI
В SwiftUI разработчики описывают, что UI должен делать и как он должен выглядеть, а не как это должно быть достигнуто. Этот подход позволяет писать меньше кода и делать его более читаемым и понятным.
struct ContentView: View {
var body: some View {
Text("Hello, World!")
.padding()
}
}
Xcode позволяет разработчикам видеть изменения в реальном времени благодаря интерактивным превью. Это значительно ускоряет процесс разработки, так как нет необходимости постоянно запускать приложение на устройстве или симуляторе.
struct ContentView_Previews: PreviewProvider {
static var previews: some View {
ContentView()
}
}
SwiftUI позволяет использовать один и тот же код для создания интерфейсов на всех платформах Apple. Это упрощает поддержку и развитие приложений.
struct ContentView: View {
var body: some View {
VStack {
Text("Welcome to SwiftUI")
Button(action: {
print("Button tapped")
}) {
Text("Tap me")
}
}
}
}
SwiftUI предоставляет простые и мощные механизмы для управления состоянием и данными. Например, с помощью
@State можно легко обновлять интерфейс при изменении данных. struct ContentView: View {
@State private var counter = 0
var body: some View {
VStack {
Text("Counter: \(counter)")
Button(action: {
counter += 1
}) {
Text("Increment")
}
}
}
}
SwiftUI можно легко интегрировать с существующими проектами, написанными на UIKit или AppKit. Это позволяет постепенно мигрировать на SwiftUI, не переписывая все приложение сразу.
struct UIKitButtonView: UIViewRepresentable {
func makeUIView(context: Context) -> UIButton {
let button = UIButton(type: .system)
button.setTitle("Press me", for: .normal)
return button
}
func updateUIView(_ uiView: UIButton, context: Context) {}
}
SwiftUI — это мощный инструмент для создания интерфейсов, который предлагает декларативный подход, унифицированный фреймворк для всех платформ Apple, интерактивные превью, удобную работу с состояниями и простую интеграцию с существующими фреймворками.
В двух фразах: SwiftUI — это фреймворк для создания интерфейсов с декларативным подходом и поддержкой всех платформ Apple. Он упрощает разработку благодаря интерактивным превью и удобной работе с состояниями.
Please open Telegram to view this post
VIEW IN TELEGRAM