DEV Community: Harsh Prajapat

iOS Interview Knowledge Prep

Harsh Prajapat — Wed, 12 Aug 2026 19:15:52 +0000

What semantics in swift

In Swift, "semantics" refers to how types behave when they are assigned to variables, passed to functions, or modified in memory. Swift relies heavily on three core data-handling behaviors: Value Semantics, Reference Semantics, and Move Semantics.

1. Value Semantics (The Default)

Value semantics mean that data is copied when it is assigned to a new variable or passed to a function. Each variable holds its own independent instance of the data, ensuring that changes to one variable never accidentally impact another.

Types: Structs (struct), enumerations (enum), and tuples (tuple).

Standard Library: Most core Swift types—like Int, String, Array, and Dictionary—are structs and exhibit value semantics.

Benefits: Provides excellent thread safety and highly predictable code behavior

💡 Optimization: Copy-on-Write (COW)

### 2. Reference Semantics

Reference semantics mean that variables do not hold the actual data directly; instead, they hold a pointer or reference to the shared instance stored elsewhere in memory (on the heap).

*** Types:** Classes (class), actors (actor), and closures.

*** Behavior:** If you assign a class instance to a new variable, both variables point to the exact same object. Mutating one will affect the other.

*** Benefits:** Supports inheritance, object identity, and sharing live application state.

class vs actor in swift

The primary difference is that actors provide built-in compile-time thread safety by serializing access to their mutable state, while classes do not protect against data races when accessed concurrently across multiple threads. Both are reference types allocated on the heap, but actors achieve this protection through a feature called actor isolation.

Key Differences Explained

1. Concurrency and Thread Safety

Classes: Multiple threads can modify a class instance at the same time. This causes data races, memory corruption, or crashes if you do not use manual synchronization like DispatchQueue or locks

Actors: Swift guarantees that only one task can execute inside an actor at any given time. It automatically serializes incoming calls to prevent simultaneous mutations.

2. Accessing State (await)

Classes: You can read and write to class properties instantly from anywhere in your code.

Actors: If you are outside the actor, you must use the await keyword to access its properties or methods. This suspends your code if the actor is busy executing another task.

3. Inheritance

Classes: Can inherit properties, methods, and initializers from a superclass.

Actors: Do not support subclassing or inheritance. They can only conform to protocols to share behavior.

Code Example: Non-Thread-Safe Class

class ClassCounter {
    var value = 0
    func increment() { value += 1 }
}

let classCounter = ClassCounter()
// Calling this from multiple threads simultaneously causes a data race
classCounter.increment()

Code Example: Thread-Safe Actor

class ClassCounter {
    var value = 0
    func increment() { value += 1 }
}

let classCounter = ClassCounter()
// Calling this from multiple threads simultaneously causes a data race
classCounter.increment()

GCD

In Swift, the term GCD can refer to two entirely different concepts: Grand Central Dispatch (for multi-threading) or the Greatest Common Divisor (the mathematical algorithm).

1. Grand Central Dispatch (Multi-Threading)
**
**Grand Central Dispatch (GCD) is Apple’s low-level framework used to handle asynchronous tasks and concurrent code execution using DispatchQueue.

Main Queue vs. Background Queue

The most common use case is sending a heavy task to a background thread to prevent the UI from freezing, then updating the user interface on the main thread.

import Foundation

// 1. Move heavy work to a background queue
DispatchQueue.global(qos: .userInitiated).async {
    // Example: Fetch data from a network or process an image
    let processedData = "Some heavy data results"

    // 2. Bounce back to the main queue to update the UI
    DispatchQueue.main.async {
        print("Update UI with: \(processedData)")
    }
}

Creating Custom Queues

You can create your own queues depending on how you want your tasks to execute:

Serial Queue: Executes tasks one at a time, in order.
Concurrent Queue: Executes multiple tasks at the same time.

// Serial Queue (default)
let serialQueue = DispatchQueue(label: "com.app.serialQueue")
serialQueue.async { print("Task 1") }
serialQueue.async { print("Task 2") } // Waits for Task 1 to finish

// Concurrent Queue
let concurrentQueue = DispatchQueue(label: "com.app.concurrentQueue", attributes: .concurrent)
concurrentQueue.async { print("Task A") }
concurrentQueue.async { print("Task B") } // Runs at the same time as Task A

Serial queue vs actor in swift

In Swift/iOS, Serial DispatchQueue and Actor both help protect shared mutable data, but they solve the problem at different levels.

Does serial Queue is thread safe

Yes, a serial queue is thread-safe for the tasks it executes because it guarantees that only one task runs at a time, preventing race conditions.

An actor is Swift's modern way of protecting mutable state from concurrent access.

1. Serial Queue

A serial queue executes one task at a time.

final class Counter {
    private var value = 0

    private let queue = DispatchQueue(label: "counter.queue")

    func increment() {
        queue.async {
            self.value += 1
        }
    }

    func getValue(completion: @escaping (Int) -> Void) {
        queue.async {
            completion(self.value)
        }
    }
}

Because the queue is serial:

Task 1 → finish
Task 2 → finish
Task 3 → finish

Only one task accesses value at a time.

When to use Serial Queue

Use it when:

Working with existing GCD-based code
You need precise queue control
You have legacy UIKit/iOS code
You need sync, async, .barrier, QoS, etc.
You are protecting a small resource

2. Actor

An actor is Swift's modern way of protecting mutable state from concurrent access.

actor Counter {
    private var value = 0

    func increment() {
        value += 1
    }

    func getValue() -> Int {
        return value
    }
}

Usage:

let counter = Counter()

Task {
    await counter.increment()

    let value = await counter.getValue()

    print(value)
}

Notice:

await counter.increment()

3. Main difference with example

Imagine you have a shared cache.

Serial Queue

final class ImageCache {
    private var cache: [String: UIImage] = [:]

    private let queue = DispatchQueue(
        label: "image.cache.queue"
    )

    func set(_ image: UIImage, for key: String) {
        queue.async {
            self.cache[key] = image
        }
    }

    func get(
        _ key: String,
        completion: @escaping (UIImage?) -> Void
    ) {
        queue.async {
            completion(self.cache[key])
        }
    }
}

You have to manually decide:

"Every access to cache must happen through queue."

Actor

actor ImageCache {
    private var cache: [String: UIImage] = [:]

    func set(_ image: UIImage, for key: String) {
        cache[key] = image
    }

    func get(_ key: String) -> UIImage? {
        cache[key]
    }
}

Usage:

let cache = ImageCache()

Task {
    await cache.set(image, for: "profile")

    let image = await cache.get("profile")
}

Swift understands that cache is actor-isolated.

Coding: Leet Code

Harsh Prajapat — Sun, 19 Jul 2026 18:13:18 +0000

Missing Number - Inner Loop

var arr = [3, 0, 1]
let res = arr

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

Missing Number - Hash Set

var arr = [3, 0, 1]
let set = Set(arr)

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

Missing Number - Better Solution: Sum Formula (O(n))

func missingNumber(_ nums: [Int]) -> Int {
    let n = nums.count
    let expectedSum = n * (n + 1) / 2
    let actualSum = nums.reduce(0, +)
    return expectedSum - actualSum
}

Unique Numbers

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

for num in nums {
    if !uniqueNumbers.contains(num) {
        uniqueNumbers.append(num)
    }
}

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

Contains Duplicate - Inner Loop

let arr = [1, 2, 3, 1]

for i in 0..<arr.count {
    for j in i+1..<arr.count {
        if arr[i] == arr[j] {
            print(arr[i]) // 1
        }
    }
}

Contains Duplicate - Better Solution: Hash Set

let nums = [1, 2, 3, 1]
var set = Set<Int>()

func containsDuplicate(_ arr: [Int]) -> Int {
    for num in arr {
        if set.contains(num) {
            return num
        }
        set.insert(num)
    }
    return -1
}

let res = containsDuplicate(nums)

print(res)

Sum of digit - Inner Loop

let nums = [3, 0, 1]
var sum = 0

for num in nums {
    sum = sum + num
}

print(sum) // 4

Sum of digit - High Order Function

let nums = [3, 0, 1]
let actualSum = nums.reduce(0, +)
print(actualSum)

Reverse Number

var number = 123
var reversed = 0

while number > 0 {
    let remainder = number % 10
    reversed = (reversed * 10) + remainder
    number /= 10
}

print(reversed) // 321

Two Sum - Inner 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("\(i), \(j)") // 0, 1
        }
    }
}

Two Sum - Hash Map

let arr = [2, 7, 11, 15]
let target = 9
var dict = [Int:Int]()

for (index, num) in arr.enumerated() {
    let complement = target - num

    if let prevIndex = dict[complement] {
        print("\(prevIndex), \(index)") // 0, 1
    }
    dict[num] = index
}

Merge Two Sorted Array - Inner Loop

let arr1 = [1, 2, 3]
let arr2 = [4, 5, 6]
var resultArray = [Int]()

for num in arr1 {
    resultArray.append(num)
}

for num in arr2 {
    resultArray.append(num)
}

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

Stack Implementation

class Stack {

    private var items: [Int] = []

    // Push
    func push(_ value: Int) {
        items.append(value)
    }

    // Pop
    func pop() -> Int? {
        return items.popLast()
    }

    // Top(Peek)
    func top() -> Int? {
        return items.last
    }

    // Check Empty
    func isEmpty() -> Bool {
        return items.isEmpty
    }

    // Size
    func size() -> Int {
        return items.count
    }
}

let stack = Stack()

stack.push(10)
stack.push(20)
stack.push(30)

print(stack.top()!)     // 30

print(stack.pop()!)     // 30

print(stack.top()!)     // 20

print(stack.size())     // 2

print(stack.isEmpty())

Strings: Reverse String

let name = "Hey! Swift"
var rev = ""

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

print(rev) // tfiwS !yeH

Strings: Reverse Word

let name = "Hey! Swift How are you?"
var rev = ""
var result = ""

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

result = rev + " " + result
print(result) // you?  are  How  Swift Hey!

Extract word from array

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

Max Number

let nums = [2, 8, 4, 9, 3]
var max = nums[0]

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

print(max) // 9

Min Number

let nums = [2, 8, 4, 9, 3]
var min = nums[0]

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

print(min) // 2

Second Largest Number

let nums = [8, 4, 9, 3]
var max = nums[0]
var secondMax = nums[1]

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

print(secondMax) // 8

Reverse Generic

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

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

    print(rev)
}

reverse("harsh") // hsrah
reverse("12345") // 54321
reverse("123.45") // 54.321

Remove Duplicate Letters

var name = "cbacdcbc"
let chars = Array(name)
var lastIndex = [Character: Int]()

for (i, ch) in chars.enumerated() {
    lastIndex[ch] = i
}

var stack = [Character]()
var visited = Set<Character>()

for (i, ch) in chars.enumerated() {
    if visited.contains(ch) {
        continue
    }

    while let last = stack.last, last > ch, lastIndex[last]! > i {
        stack.removeLast()
        visited.remove(last)
    }

    stack.append(ch)
    visited.insert(ch)
}

print(String(stack))

Find All Numbers Disappeared in an Array

func findDisappearedNumbers(_ nums: [Int]) -> [Int] {
    let res = Set(nums)
    var result = [Int]()

    for i in 1...nums.count {
        if !res.contains(i) {
            result.append(i)
        }
    }
    return result
}

Leetcode problems

Harsh Prajapat — Sun, 19 Jul 2026 11:21:14 +0000

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
    }
}

func missingNumber(_ nums: [Int]) -> Int {

   let result = nums

     for i in 0...nums.count {
        if !nums.contains(i) {
            return i
        }
     }

     return -1
 }

Best solution

let arr = [0,1]
let res = arr

for i in 0...arr.count {
    if !res.contains(i) {
        print(i)
    }
}

Better Solution 1: Sum Formula (O(n))

func missingNumber(_ nums: [Int]) -> Int {
    let n = nums.count
    let expectedSum = n * (n + 1) / 2
    let actualSum = nums.reduce(0, +)
    return expectedSum - actualSum
 }

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

Reverse generic function

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

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

    print(rev)
}

reverse("harsh")
reverse("12345")
reverse("123.45")

**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)
    }
}

Merge Sorted Arrays

var arr1 = [1,3,5]
var arr2 = [2,4,6]
var result = [Int]()

for num in arr1 {
    result.append(num)
}

for num in arr2 {
    result.append(num)
}

let res = sortedArray(data: result)
print(res)

func sortedArray(data: [Int]) -> [Int] {
    var temp = 0
    var arr: [Int] = data

    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
            }
        }
    }
    return arr
}
// [1,2,3,4,5,6]

Finding missing number [1,2,20]

let arr = [1,2,20]
let res = arr

let startIndex = arr[0]
let endIndex = arr[arr.count - 1]

for i in startIndex..<endIndex {
    if !res.contains(i) {
        print(i)
    }
}
// print...3...19