DEV Community: Harsh Prajapat

appdelegate lifecycle in swift ios

Harsh Prajapat — Mon, 29 Jun 2026 19:16:05 +0000

appdelegate lifecycle in swift ios

The UIApplicationDelegate (AppDelegate) is the root object of a UIKit-based iOS application, responsible for handling process-level lifecycle events and responding to system-level notifications.

Starting with iOS 13, Apple split lifecycle responsibilities: AppDelegate handles process-level events (like launch and termination), while SceneDelegate handles UI-level lifecycle events (like active or background states for multiple windows).

🔄 The 5 Core Execution States

Not Running: The app has either not been launched or was completely terminated by the user/system.

Inactive: The app is running in the foreground but is not receiving user interaction events (e.g., interrupted by a phone call or pulling down Notification Center).

Active: The app is running in the foreground, visible, and fully accepting user inputs.

Background: The app is out of view but executing code in the background (e.g., playing audio, tracking location)

Suspended: The app remains in device memory but does not execute any code. The system can purge it anytime without notice if memory runs low.

🛠️ Key AppDelegate Lifecycle Methods

Initializing and Launching

application(_:willFinishLaunchingWithOptions:)

When: The launch process begins. It is the first code executed from your delegate.

Purpose: Use this for initial application setups before state restoration occurs.

application(_:didFinishLaunchingWithOptions:)

When: The launch process is almost complete and the app is about to run.

Purpose: Initialize global SDKs (e.g., Firebase), set up third-party analytics, and configure app-wide styling.

Transitioning (iOS 12 & Earlier or Apps Without Scenes)

applicationWillResignActive(_:)

When: Moving from Active to Inactive.

Purpose: Pause ongoing timers, lower video frame rates, or pause gameplay.

applicationDidEnterBackground(_:)

When: Moving from Inactive to Background.

Purpose: Release shared resources, write user data to disk, and reduce memory footprint to prevent suspension purging

applicationWillEnterForeground(_:)

When: Transitioning from Background to Inactive state (on its way to becoming active).

Purpose: Undo changes made when entering the background (e.g., load data from network).

applicationDidBecomeActive(_:)

When: The app becomes fully Active.

Purpose: Refresh the UI, restart paused animations, and resume game states.

Termination

applicationWillTerminate(_:)

When: The app is about to be purged from memory entirely.

Purpose: Save final, critical database states and clear cache files. Note: This method is not called if the app is already in a suspended state when killed.

🧬 SwiftUI and Modern Alternatives

If you are developing a modern application using the SwiftUI App Lifecycle, there is no AppDelegate file by default.

ScenePhase Modifier: You can monitor state transitions directly in your main @main struct using the scenePhase environment property (supporting .active, .inactive, and .background).

@UIApplicationDelegateAdaptor: If you still require old AppDelegate capabilities (like registering for remote APNS push notifications), you can inject a custom delegate class into your SwiftUI struct using the @UIApplicationDelegateAdaptor property wrapper.

In SwiftUI, lifecycle management

Core View Visibility Modifiers
.onAppear(perform:)
.onDisappear(perform:)
Asynchronous Operations
.task(priority:_:)
.task(id:)
State & Reactive Data Triggers
init() (The Constructor)
onChange(of:perform:)
onReceive(_:perform:)
Application-Wide Lifecycle (ScenePhase)

To manage the high-level application states (equivalent to AppDelegate lifecycle events), SwiftUI utilizes scenes and the environment state.

.active: The app is in the foreground and interacting with the user.

.inactive: The app is visible but temporarily interrupted (e.g., control center open, taking a phone call).

.background: The app is completely hidden and suspended.

what asynchronous task

An asynchronous task is an operation that runs in the background. It allows a computer or program to start the task and immediately move on to other work without waiting for that first task to finish.

How it works

Think of ordering food at a fast-food restaurant.

Synchronous (Waiting): You order a burger, and the cashier waits at the register, doing nothing else, until your food is ready to hand to you.

Asynchronous (Not waiting): You order your burger, the cashier gives you a token, and you sit down to read a book while the kitchen cooks. The cashier immediately takes the next person's order.

Why we use it

Asynchronous tasks keep applications fast and responsive. If a computer had to stop and wait for a large file to download or a website to load, the whole program would freeze. Instead, it sends the download to the background and lets you keep clicking and typing.

Common examples

Downloading files: You click "download," and you can still scroll through a webpage while the file loads in the background.

Loading websites: Your app asks the internet for new data, but your screen does not freeze; it shows a loading spinner until the data arrives.

Sending emails: An app sends a confirmation email in the background after you buy something, so you don't have to sit and stare at a loading screen.

Swift Concurrency?

Harsh Prajapat — Sat, 27 Jun 2026 21:29:27 +0000

1. What is Swift Concurrency?
Swift Concurrency is Apple's modern asynchronous programming model introduced in Swift 5.5.

Swift concurrency is a built-in language model that allows apps to perform multiple tasks simultaneously—such as running background calculations or fetching network data—without blocking the main user interface.

Features:

async/await
Task
TaskGroup
Actor
Structured Concurrency

Benefits:

Cleaner code
Better readability
Thread-safe programming
Less callback nesting

2. What is async?
Marks a function that can suspend execution.

func fetchUsers() async -> [User] {
    return []
}

// Call using:
let users = await fetchUsers()

3. What is await?
await waits for an async operation to complete.

let data = await apiService.fetchData()

It suspends the current task, not the thread.

Interview Point:

await does not block the thread.
It suspends the task.

4. Difference Between Async and Sync?

Sync

let data = service.fetchData()
print(data)

Execution waits.

Async

let data = await service.fetchData()

Task suspends and thread is free for other work.

5. What is a Task?

A unit of asynchronous work.

Task {
    let users = await fetchUsers()
}

Creates a new concurrent task.

Q: Does Task {} run on the main thread?

A: Not always. Task {} inherits the current actor context. If it's created inside a @MainActor context, it executes on the Main Actor. Otherwise, Swift Concurrency schedules it on an appropriate thread, and there is no guarantee it will run on the main thread.

Task {} inherits the current actor context. If created inside @MainActor, it runs on MainActor. Otherwise, there is no guarantee which thread executes the task.

@MainActor
class MyViewModel {
    func updateUI() {
        Task {
            print(Thread.isMainThread) // true
        }
    }
}

or

class MyViewModel {
    @MainActor
    func updateUI() {
        Task {
            print(Thread.isMainThread) // true
        }
    }
}

✅ Task {} inherits the @MainActor context.

The task starts on the Main Actor, so UI updates are safe.

Example:

@MainActor
func loadData() {
    Task {
        // Main Actor
        title = "Loading..."
    }
}

func fetchData() {
    Task {
        // Not guaranteed Main Thread
        let data = await api.fetch()
    }
}

A common interview follow-up:

Task {
    print(Thread.isMainThread) // true

    let data = await api.fetch()

    print(Thread.isMainThread) // may be true or false
}

After an await, the task is guaranteed to resume on the same actor (if actor-isolated), but not necessarily on the same physical thread. Actor ≠ Thread. This distinction is very important in Swift Concurrency interviews.

func loadData() async {
    print("fetch...")
}

Task {
    await loadData()
}

From this code alone, we cannot determine whether it runs on the main thread.

Scenario 1: Created from MainActor

@MainActor
func buttonTapped() {

    Task {
        await loadData()
    }
}

Here Task {} inherits @MainActor.

Read Blog

Harsh Prajapat — Fri, 26 Jun 2026 17:37:28 +0000

To run a reverse for loop in Swift, the cleanest and most common approach is to use the .reversed() method on a range or a collection.

1. Reverse Loop Over a Number Range

To count downwards between two numbers, wrap your range in parentheses and append .reversed():

// Counts down from 5 to 1 inclusive
for index in (1...5).reversed() {
    print(index) 
}
// Output: 5, 4, 3, 2, 1

// Counts down from 4 to 0 (excludes the upper bound 5)
for index in (0..<5).reversed() {
    print(index)
}
// Output: 4, 3, 2, 1, 0

2. Reverse Loop Over an Array

let items = ["Apple", "Banana", "Cherry"]

for item in items.reversed() {
    print(item)
}
// Output: Cherry, Banana, Apple

3. Reverse Loop with Index and Value

If you need both the index and the element while going backward, combine .reversed() with .enumerated().

let names = ["Alex", "Brian", "Chris"]

for (index, name) in names.reversed().enumerated() {
    print("Index \(index) contains \(name)")
}
// Output: 
// Index 2 contains Chris
// Index 1 contains Brian
// Index 0 contains Alex

4. Reverse Loop with Custom Step Sizes (stride)

// Inclusive stride
for index in stride(from: 10, through: 0, by: -2) {
    print(index)
}
// Output: 10, 8, 6, 4, 2, 0

What is compile time and runtime error

The core difference is that compile-time errors prevent your program from building, while runtime errors occur while the program is executing.

Compile-Time Error:

During code compilation (before running).
Prevent an executable from being created.

Runtime Error:

During program execution.
Program crashes or behaves unpredictably.

A generic function in Swift allows you to write flexible, reusable code that can work with any data type while maintaining complete type safety. Instead of duplicating logic for Int, String, or Double, you use a placeholder type (conventionally named T) inside angle brackets ().

Basic Syntax

// Defining a generic function with a placeholder type T
func printValue<T>(_ value: T) {
    print("The value is: \(value)")
}

// Swift automatically infers the concrete type at runtime
printValue(42)        // T becomes Int
printValue("Hello")   // T becomes String
printValue(3.14)      // T becomes Double

In Swift, the Comparable protocol is used to define a natural relational order for instances of a type. Conforming to Comparable allows you to use relational operators like <, >, <=, and >=, and unlocks standard library capabilities like sorting an array with a parameterless .sorted() method.

func findLargest(_ a: T, _ b: T) -> T {
return a > b ? a : b
}

let highestScore = findLargest(85, 92) // Works with Int
let alphabetLast = findLargest("apple", "banana")

print(highestScore) // 85
print(alphabetLast) // banana

In Swift, subscripts are shortcuts used to access or modify member elements of a collection, list, or sequence without explicitly calling a method. They allow you to use bracket notation like instance[index] directly on your custom classes, structures, and enumerations.

Subscript declarations resemble a mix of instance methods and computed properties. They are defined using the subscript keyword, taking input parameters and specifying a return type.

struct SimpleList {
    var items: [String]

    // Read-and-Write Subscript
    subscript(index: Int) -> String {
        get {
            return items[index]
        }
        set(newValue) {
            items[index] = newValue
        }
    }
}

struct Multiplier {
    let factor: Int

    // Read-only shortcut
    subscript(number: Int) -> Int {
        return number * factor
    }
}

let threeTimes = Multiplier(factor: 3)
print(threeTimes[6]) // Prints 18

Safe Array Access

extension Array {
subscript(safe index: Int) -> Element? {
return indices.contains(index) ? self[index] : nil
}
}

let names = ["Alice", "Bob"]
print(names[safe: 5]) // Prints nil (No runtime crash!)

why Functional Programming swift explain

Functional Programming (FP) in Swift is a paradigm that treats computation as the evaluation of mathematical functions, heavily emphasizing immutability and preventing state changes. Swift is designed from the ground up as a multi-paradigm language, meaning it natively blends Object-Oriented Programming (OOP) with powerful, built-in features for Functional Programming.

Implementing functional patterns in Swift eliminates hidden side effects, ensures inherent thread safety, and dramatically simplifies unit testing.

Core Concepts of Functional Swift

Immutability & Value Types

let over var: Using let guarantees that data cannot be modified after creation, removing unexpected state changes.

Value Types (Structs and Enums): Unlike classes (which are reference types), structs are passed by value. When passed to a function, Swift copies the data, ensuring other parts of the app cannot accidentally overwrite it.

First-Class and Higher-Order Functions

Functions that accept or return other functions are known as Higher-Order Functions. The Swift Standard Library natively includes several higher-order tools to process data without using manual loops:

map: Transforms every item in a collection.
filter: Extracts items matching specific conditions.
reduce: Combines all elements into a single value.

let numbers = [1, 2, 3, 4, 5]

// Declarative functional chain vs. Imperial "for" loop
let doubledEvens = numbers
    .filter { $0 % 2 == 0 }  // Filters out odd numbers
    .map { $0 * 2 }

can we use lazy let in swift instead of lazy var

No, you cannot use lazy let in Swift. Swift strictly requires you to use lazy var

The Swift compiler will throw a compile-time error if you attempt to use lazy let.

Why Swift Doesn't Allow lazy let

If your goal is to make sure a lazy property cannot be modified by other parts of your code after it initializes, you can use the private(set) modifier.

class DataManager {
    // Read-only to the outside world, but mutates internally on first access
    private(set) lazy var expensiveData: [String] = {
        print("Loading heavy data...")
        return ["Data 1", "Data 2", "Data 3"]
    }()
}

let manager = DataManager()
// 1. Works perfectly and triggers initialization
print(manager.expensiveData) 

// 2. Compiler Error: Cannot assign to property: 'expensiveData' setter is inaccessible
manager.expensiveData = ["New Data"]

in unowned can we use let or var both swift

The choice between let and var purely depends on whether you want the reference itself to be mutable (re-assignable) or immutable (constant). This is a major structural advantage over weak, which must always be declared as a var because Automated Reference Counting (ARC) dynamically zeroes it out to nil when the referenced instance deallocates.

Using unowned let

Use unowned let when the reference is assigned exactly once during initialization and never changes.

It creates an immutable binding between an object and its non-strong dependency.

class Customer {
    let name: String
    init(name: String) { self.name = name }
}

class CreditCard {
    let number: UInt64
    // The owner never changes, but we don't want a strong reference cycle
    unowned let owner: Customer 

    init(number: UInt64, owner: Customer) {
        self.number = number
        self.owner = owner
    }
}

throw vs throws in swift ios

In Swift, throws is used in a function's declaration to signal that it can potentially fail, while throw is the action keyword used inside the function to execute and raise a specific error.

throws

Declares that a method, closure, or property can encounter and propagate a failure.

**Example

func check(id: Int) throws -> Bool**

throw

Triggers the actual failure, immediately halting execution and passing the error out.

**Example

throw NetworkError.timeout**

Implementation Example

To use error handling in iOS development, you must first define an enum that conforms to Swift's standard Error protocol.

// 1. Define your error types
enum ValidationError: Error {
    case emptyUsername
    case textTooShort
}

// 2. Use 'throws' in the signature to designate a throwing function
func validate(username: String) throws -> Bool {
    guard !username.isEmpty else {
        // 3. Use 'throw' to explicitly raise the error state
        throw ValidationError.emptyUsername 
    }

    guard username.count >= 3 else {
        throw ValidationError.textTooShort
    }

    return true
}

H*ow to Call a Throwing Function*

When a function is marked with throws, the Swift compiler prevents you from executing it normally. You must handle it using a do-catch block combined with the try keyword:

do {
    let isValid = try validate(username: "Al")
    print("Success: \(isValid)")
} catch ValidationError.emptyUsername {
    print("Please enter a username.")
} catch ValidationError.textTooShort {
    print("Username must be at least 3 characters.")
} catch {
    print("An unknown error occurred: \(error).")
}

In Swift, a standard parameter is a read-only copy. An inout parameter allows a function to modify the original variable directly.

Without inout (Copy)

var score = 10

func addBonus(points: Int) {
    // points is a copy. 
    // Changing it here does not affect 'score'.
    points += 5 
}

addBonus(points: score)
print(score) // Output: 10

With inout (Reference)

To use inout:

You must declare the original variable using var (not let).
You must add the inout keyword before the parameter type.
You must put an ampersand (&) before the variable name when you call the function.

var score = 10

// 1. Mark the parameter as inout
func addBonus(points: inout Int) {
    // 2. Modifying it updates the original variable
    points += 5 
}

// 3. Put & before the variable when calling
addBonus(points: &score)
print(score) // Output: 15

in swift can we Inheritance with Structures

No, structures in Swift do not support inheritance. In Swift, inheritance is a feature exclusive to classes. A struct cannot inherit from another struct or class, nor can it serve as a base type for another structure to inherit from.

Instead of classical inheritance, Swift relies heavily on Protocol-Oriented Programming and Composition to share behavior among structures

AssociatedType

protocol Container {

    associatedtype Item

    mutating func add(_ item: Item)

    func getItem() -> Item
}

struct IntContainer: Container {

    var value = 0

    mutating func add(_ item: Int) {
        value = item
    }

    func getItem() -> Int {
        value
    }
}

var container = IntContainer()

container.add(100)

print(container.getItem())

भगवान कृष्ण का अत्यंत शक्तिशाली और प्रसिद्ध मंत्र है।

Harsh Prajapat — Wed, 24 Jun 2026 21:24:39 +0000

कृष्णाय वासुदेवाय हरये परमात्मने (Krishnaya Vasudevaya Mantra) भगवान कृष्ण का अत्यंत शक्तिशाली और प्रसिद्ध मंत्र है। इसके जाप से मानसिक शांति मिलती है और सभी प्रकार के कष्ट, रोग एवं बाधाएं दूर होती हैं।

मंत्र (Mantra in Hindi)

"ॐ कृष्णाय वासुदेवाय हरये परमात्मने।प्रणतः क्लेशनाशाय गोविंदाय नमो नमः।।"

मंत्र का अर्थ (Meaning)

कृष्णाय वासुदेवाय: वासुदेव के पुत्र भगवान श्रीकृष्ण को
हरये परमात्मने: हरि और परमपिता परमात्मा को
प्रणतः क्लेशनाशाय: (उनकी शरण में आए) सभी भक्तों के दुखों और कष्टों का नाश करने वाले को
गोविंदाय नमो नमः: हे गोविंद, आपको बार-बार नमस्कार है

इस मंत्र का उच्चारण आप किसी भी समय कर सकते हैं, लेकिन सुबह जल्दी उठकर या पूजा के दौरान 108 बार इसका जाप करना सबसे उत्तम माना जाता है। इसके बारे में अधिक जानकारी व सुनने के लिए आप हरे कृष्ण मंदिर का लेख पढ़ सकते हैं।

TodoListView

Harsh Prajapat — Mon, 22 Jun 2026 14:41:10 +0000

import SwiftUI

struct TodoListView: View {

    @StateObject private var viewModel: TodoListViewModel

    init(viewModel: TodoListViewModel) {
        _viewModel = StateObject(
            wrappedValue: viewModel
        )
    }

    var body: some View {

        NavigationStack {

            Group {

                if viewModel.isLoading {

                    ProgressView()

                } else {

                    List(viewModel.todos) { todo in

                        HStack {

                            Image(
                                systemName: todo.completed
                                ? "checkmark.circle.fill"
                                : "circle"
                            )

                            Text(todo.title)
                        }
                    }
                }
            }
            .navigationTitle("Todos")
            .task {
                viewModel.loadTodos()
            }
            .alert(
                "Error",
                isPresented: .constant(
                    viewModel.errorMessage != nil
                )
            ) {
                Button("OK") {}
            } message: {
                Text(viewModel.errorMessage ?? "")
            }
        }
    }
}

@main
struct TodoAppApp: App {
    let persistenceController = PersistenceController.shared
    private let container = AppContainer()

    var body: some Scene {
        WindowGroup {
            TodoListView(
                viewModel: TodoListViewModel(
                    repository: container.todoRepository
                )
            )
            .environment(\.managedObjectContext, persistenceController.container.viewContext)
        }
    }
}

aync call

Harsh Prajapat — Mon, 22 Jun 2026 14:39:04 +0000

import Foundation
import SwiftUI
import Combine

struct Post: Codable, Identifiable {
    let id: Int
    let msg: String
}

enum APIError: LocalizedError {
    case invalidURL
    case invalidResponse
    case decodingFailed

    var errorMsg: String? {
        switch self {
        case .invalidURL:
            return ""
        case .invalidResponse:
            return ""
        case .decodingFailed:
            return ""
        }
    }
}

protocol APIServiceProtocol {
    func fetchPost() async throws -> [Post]
}

final class APIService: APIServiceProtocol {

    func fetchPost() async throws -> [Post] {

        guard let url = URL(string: "") else {
            throw APIError.invalidURL
        }

        let (data, res) = try await URLSession.shared.data(from: url)

        guard let res = res as? HTTPURLResponse, res.statusCode == 200 else {
            throw APIError.invalidResponse
        }

        do {
            return try JSONDecoder().decode([Post].self, from: data)
        } catch {
            throw APIError.decodingFailed
        }
    }
}

protocol PostRepositoryProtocol {
    func fetchPost() async throws -> [Post]
}

final class PostRepository: PostRepositoryProtocol {

    private let apiService: APIServiceProtocol

    init(apiService: APIServiceProtocol) {
        self.apiService = apiService
    }

    func fetchPost() async throws -> [Post] {
        try await apiService.fetchPost()
    }
}

// test

protocol Storage {
    func save(_ item: String)
}

struct UserStorage: Storage {
    func save(_ item: String) {

    }
}

protocol Work {

    associatedtype Item

    func save(_ item: Item)
}

struct WorkStorage: Work {
    func save(_ item: User) {

    }
    typealias Item = User
}

Swiftui api call and image downloading

Harsh Prajapat — Mon, 22 Jun 2026 14:36:28 +0000

import Foundation

struct Photo: Codable, Identifiable {
    let id: Int
    let title: String
    let url: String
}

import Foundation
import UIKit

final class APIService {

    static let shared = APIService()

    private init() {}

    func fetchPhotos() async throws -> [Photo] {

        let url = URL(
            string: "https://jsonplaceholder.typicode.com/photos?_limit=20"
        )!

        let (data, _) = try await URLSession.shared.data(from: url)

        return try JSONDecoder().decode([Photo].self, from: data)
    }

    func downloadImage(from urlString: String) async -> UIImage? {

        guard let url = URL(string: urlString) else {
            return nil
        }

        do {
            let (data, _) = try await URLSession.shared.data(from: url)
            return UIImage(data: data)
        } catch {
            return nil
        }
    }
}

import SwiftUI
import Combine

@MainActor
final class PhotoListViewModel: ObservableObject {

    @Published var photos: [Photo] = []
    @Published var isLoading = false

    func fetchPhotos() async {

        isLoading = true

        do {
            photos = try await APIService.shared.fetchPhotos()
        } catch {
            print(error.localizedDescription)
        }

        isLoading = false
    }
}

import SwiftUI
import Combine

@MainActor
final class ImageLoader: ObservableObject {

    @Published var image: UIImage?

    func load(url: String) {

        Task {

            let downloadedImage =
            await APIService.shared.downloadImage(from: url)

            self.image = downloadedImage
        }
    }
}

import SwiftUI
import Combine

struct PhotoRow: View {

    let photo: Photo

    @StateObject private var loader = ImageLoader()

    var body: some View {

        HStack {

            Group {

                if let image = loader.image {

                    Image(uiImage: image)
                        .resizable()

                } else {

                    ProgressView()
                }
            }
            .frame(width: 80, height: 80)

            Text(photo.title)
                .font(.headline)
        }
        .onAppear {
            loader.load(url: photo.url)
        }
    }
}

import SwiftUI

struct PhotoListView: View {

    @StateObject private var vm = PhotoListViewModel()

    var body: some View {

        NavigationView {

            List(vm.photos) { photo in

                PhotoRow(photo: photo)
            }
            .navigationTitle("Photos")
            .task {
                await vm.fetchPhotos()
            }
        }
    }
}

An unowned reference

Harsh Prajapat — Tue, 02 Jun 2026 08:25:44 +0000

class NetworkManager {
    var data = "Payload"

    func fetchData(completion: @escaping () -> Void) {
        // Simulating an action where this manager instance is guaranteed to be alive
        DispatchQueue.global().async {
            completion()
        }
    }

    func startTasks() {
        fetchData { [unowned self] in
            // No optional unwrapping or 'self?' required
            print("Successfully processed \(self.data)") 
        }
    }
}

Prep

Harsh Prajapat — Sat, 30 May 2026 07:34:10 +0000

var names = ["iOS Development Swift", "android Development Kotlin"]
var words = [String]()
var myword = ""

for str in names {
    let word = str.split(separator: " ")
    for char in word {
        print(char)
    }
}

// iOS
// Development
// Swift
// android
// Development
// Kotlin

var arr = [2, 8, 4, 9, 3]

var max = arr[0]

for num in arr {
    if num > max {
        max = num
    }
}

print(max) // 9

var arr = [2, 8, 4, 9, 3]

var min = arr[0]

for num in arr {
    if num < min {
        min = num
    }
}

print(min) // 2

var arr = [2, 8, 4, 9, 3]

var max = arr[0]
var secondMax = arr[0]

for num in arr {
    if num > max {
        secondMax = max
        max = num
    } else if num > secondMax && num != max {
        secondMax = num
    }
}

print(max) // 9
print(secondMax) // 8

var name = "hey harsh"
var word = ""
var result = ""

for s in name {
    if s == " " {
        result = word + " " + result
        word = ""
    } else {
        word = String(s) + word
    }
}

result = word + " " + result
print(result) // hsrah yeh

**Add two numbers closure swift**

let addNumbers: (Int, Int) -> Int = { num1, num2 in 
    num1 + num2 
}

**Shorthand Argument Syntax**

let addNumbers: (Int, Int) -> Int = { $0 + $1 }

**To declare a generic function, place the placeholder type immediately after the function name:**

func functionName<T>(parameter: T) -> T {
    return parameter
}

Reversed Int number

var number = 12345
var reversed = 0

while number > 0 {
    let digit = number % 10
    reversed = reversed * 10 + digit
    number /= 10
}

print(reversed) // 54321

For Int (without built-in reverse methods)

func reverseInt(_ number: Int) -> Int {
    var num = number
    var reversed = 0

    while num > 0 {
        let digit = num % 10
        reversed = reversed * 10 + digit
        num /= 10
    }

    return reversed
}

print(reverseInt(12345))
// 54321

**For String

Since String is not an array, create a separate generic-friendly extension:**

func reverseString(_ str: String) -> String {
    var result = ""

    for char in str {
        result = String(char) + result
    }

    return result
}

print(reverseString("Hello"))
// olleH

**More Generic Version (Reverse Any Array)

If the interviewer wants a true generic solution that works for arrays of any type:**

func reverseArray<T>(_ array: [T]) -> [T] {
    var result: [T] = []

    var index = array.count - 1

    while index >= 0 {
        result.append(array[index])

        if index == 0 { break }
        index -= 1
    }

    return result
}

print(reverseArray([1, 2, 3, 4, 5]))
// [5, 4, 3, 2, 1]

print(reverseArray(["A", "B", "C"]))
// ["C", "B", "A"]

var arr = [1, 2, 3, 4, 5]
var result: [Int] = []
var index = arr.count - 1

while index >= 0 {
    result.append(arr[index])
    if index == 0 { break }
    index -= 1
}
print(result) // [5, 4, 3, 2, 1]

some solution

var scoreOne = 10
var scoreTwo = 20

func swapScores(a: inout Int, b: inout Int) {
    let temp = a
    a = b
    b = temp
}

func swapValues<T>(
    _ a: inout T,
    _ b: inout T) {

    let temp = a
    a = b
    b = temp
}

swapValues(&scoreOne, &scoreTwo)

print(scoreOne)
print(scoreTwo)

var firstName = "Harsh"
var lastName = "Kumar"

var fullName:String {
    firstName + lastName
}
print(fullName)

let numbers = [21, 34, 89, 34, 11]
let result = numbers.map({ String($0) })
print(result)

// Missing number
let arr = [1, 2, 4, 5]
let res = arr

for i in 1...arr.count {
    if !res.contains(i) {
        print("Missing number: \(i)")
    }
}

// Sorting array ascending order
var myArr = [11, 34, 23, 12, 15]
var temp = 0

for i in 0..<myArr.count {
    for j in i+1..<myArr.count {
        if myArr[i] > myArr[j] {
            temp = myArr[i]
            myArr[i] = myArr[j]
            myArr[j] = temp
        }
    }
}
print("Sorted array: \(myArr)")

// Reversed Array
let myArrTest = [2, 9, 3, 1, 6]
var counter = myArrTest.count
var reversedArray = [Int]()

for _ in 0..<counter {
    let revNumber = myArrTest[counter - 1]
    reversedArray.append(revNumber)
    counter -= 1
}

print("ReversedArray: \(reversedArray)")

Reversed function: with any data type

func printValue<T>(_ value: T) {
    let rev = "\(value)"
    var res = ""

    for s in rev {
        res = "\(s)" + res
    }

    print(res)
}

printValue(21)
printValue("Hey")
printValue(12345)

volwel count1

let text = "Hello Swift Programming"

var volwelDict: [Character: Int] = [
"a" : 0,
"e" : 0,
"i" : 0,
"o" : 0,
"u" : 0
]

for char in text.lowercased() {
if volwelDict[char] != nil {
volwelDict[char]! += 1
}
}
print(volwelDict)

volwel count2

let text = "Hello Swift Programming"
let volwels = ["a", "e", "i", "o" , "u"]

for s in text.lowercased() {
if volwels.contains("(s)") {
print(s)
}
}

SOLID Principles in iOS (Swift)

Harsh Prajapat — Fri, 29 May 2026 18:59:12 +0000

SOLID Principles in iOS (Swift) — Explained with Simple Examples

SOLID is a set of 5 design principles used to write clean, scalable, reusable, and maintainable code in iOS apps.

These principles are very important in:

UIKit
SwiftUI
MVVM
Clean Architecture
Large-scale apps

S — Single Responsibility Principle (SRP) Meaning

A class should have only one reason to change.

A class should do only one job.

❌ Bad Example

class UserManager {

    func fetchUser() {
        print("Fetch user from API")
    }

    func saveUserToDatabase() {
        print("Save user in DB")
    }

    func sendEmail() {
        print("Send email to user")
    }
}

2. O — Open/Closed Principle (OCP)

The Open/Closed Principle (OCP) states that software entities (classes, modules, and functions) should be open for extension, but closed for modification. This means you should be able to add new functionality or behaviors without altering the existing, tested source code.

W*hy is OCP important?*

Prevents Bugs: Touching working, tested code always carries the risk of introducing unintended bugs.

Maintainability: Codebases become much easier to manage, scale, and test as they grow.

Given multiple sentences, extract all words into one vector

var names = ["iOS Developer", "Android Developer", ".NET Developer"]

let sentence = "Swift is fun to learn"
let words = sentence.split(separator: " ")
print(words)

// ["Swift", "is", "fun", "to", "learn"]

for str in names {
    let words = str.split(separator: " ")
    for char in words {
        print(char)
    }
}

// iOS
// Developer
// Android
// Developer
// .NET
// Developer

Coding interviews asked programs

Harsh Prajapat — Sun, 24 May 2026 10:02:57 +0000

Program to demonstrate max & min

var arr = [2, 8, 4, 9, 3]
var max = arr[0]
var min = arr[0]

for i in 0..<arr.count {
    if arr[i] > max {
        max = arr[i]
    }

    if arr[i] < min {
        min = arr[i]
    }
}

print(max) // 9
print(min) // 2

Program to demonstrate Second Largest

var arr = [2, 8, 4, 9, 3]
var max = arr[0]
var secondLarget = arr[0]

for i in 0..<arr.count {
    if arr[i] > max {
        secondLarget = max
        max = arr[i]
    } else if arr[i] > secondLarget && arr[i] != max {
        secondLarget =  arr[i]
    }
}

print(max) // 9
print(secondLarget) // 8

✅ Swift: Find Two Numbers That Sum to a Target

- Using loop

let arr = [2, 7, 11, 15]
let target = 9

for i in 0..<arr.count {
    for j in i+1..<arr.count {
        if arr[i] + arr[j] == target {
            print("Pair: (\(arr[i]), \(arr[j]))")
        }
    }
}

Output: Pair: (2, 7)

Program to demonstrate duplicates values program

let arr = [2, 7, 3, 8, 2, 9, 8, 3]
var duplicates = Set<Int>()

for i in 0..<arr.count {
    for j in i+1..<arr.count {
        if arr[i] == arr[j] {
            duplicates.insert(arr[i])
        }
    }
}
print("duplicates: \(duplicates) & count: \(duplicates.count)")
// duplicates: [2, 3, 8] & count: 3

Program to demonstrate PrintNumberTriangle

func printNumberTriangle(rows: Int) {
    for i in 1...rows {
        var line = ""
        for j in 1...i {
            line += "\(j) "
        }
        print(line.trimmingCharacters(in: .whitespaces))
    }
}
printNumberTriangle(rows: 5)

**Output:**
1
1 2
1 2 3
1 2 3 4
1 2 3 4 5

Coding

Harsh Prajapat — Mon, 18 May 2026 17:27:27 +0000

Reverse program

let name = "hey harsh"
var rev = ""

for c in name {
    rev = String(c) + rev
}

print(rev) // hsrah yeh

Remove duplicates

let numbers = [1, 2, 3, 2, 4, 1, 5]
var uniqueNumbers = [Int]()

for num in numbers {
   if !uniqueNumbers.contains(num) {
        uniqueNumbers.append(num)
    }
}
print(uniqueNumbers) // [1, 2, 3, 4, 5]

write program for this "harsh hey" to "hey harsh" without use any function use loop

var str = "harsh hey"
var firstWord = ""
var secondWord = ""
var foundSpace = false

for char in str {

    if char == " " {
        foundSpace = true
        continue
    }

    if foundSpace == false {
        firstWord += String(char)
    } else {
        secondWord += String(char)
    }
}
print(secondWord + " " + firstWord)

var str = "harsh hey"
var word = ""
var result = ""

for char in str {

    if char == " " {
        result = word + " " + result
        word = ""
    } else {
        word += String(char)
    }
}
result = word + " " + result
print(result) // hey harsh

Sorting program - ascending (Arranging data from smallest to largest.)

var arr = [4, 2, 6, 1, 3]
var temp  = 0

for i in 0..<arr.count {
    for j in 0..<arr.count {
        if arr[i] < arr[j] {
         temp = arr[i]
         arr[i] = arr[j]
         arr[j] = temp   
        }
    }
}

// Ascending order
print(arr) // [1, 2, 3, 4, 6]

var arr = [4, 2, 6, 1, 3]
var temp  = 0

for i in 0..<arr.count {
    for j in i+1..<arr.count {
        if arr[i] > arr[j] {
         temp = arr[i]
         arr[i] = arr[j]
         arr[j] = temp   
        }
    }
}

// Ascending order
print(arr) // [1, 2, 3, 4, 6]

var numbers = [64, 34, 25, 12, 22, 11, 90]
var temp = 0

for i in 0..<numbers.count {
    for j in i+1..<numbers.count {
        if numbers[i] > numbers[j] {
            temp = numbers[i]
            numbers[i] = numbers[j]
            numbers[j] = temp
        }
    }
}

print(numbers) // [11, 12, 22, 25, 34, 64, 90]

Missing Number

let arr = [1, 3, 4, 5]
let result = arr

for i in 1...arr.count - 1 {
    if !result.contains(i) {
        print(i) // 2
    }
}

let arr = [0, 1, 3, 4]
let result = arr

for i in 0..<arr.count {
    if !result.contains(i) {
        print(i) // 2
    }
}