Swift Arrays: The Basics Part 1

// An array of strings representing user messages
let messages = ["Hello!", "How are you?", "I'm learning SwiftUI", "Arrays are powerful!"]

// Accessing the first message
let firstMessage = messages[0] // "Hello!"

// Array - ordered, allows duplicates
let favoriteColors = ["Blue", "Red", "Green", "Blue"]

// Set - unordered, unique elements only
let uniqueColors: Set = ["Blue", "Red", "Green"]

// Dictionary - key-value pairs
let colorCodes = ["Blue": "#0000FF", "Red": "#FF0000", "Green": "#00FF00"]

struct ContentView: View {
    // Array of items for a simple to-do list app
    @State private var tasks = ["Learn SwiftUI", "Master Arrays", "Build an App"]

    var body: some View {
        List {
            ForEach(tasks, id: \.self) { task in
                Text(task)
            }
        }
    }
}

// Array literal - most common and readable
let fruitNames = ["Apple", "Banana", "Cherry", "Dragon Fruit"]

// Array with repeated values
let fiveZeros = Array(repeating: 0, count: 5) // [0, 0, 0, 0, 0]

// Creating an array from another sequence
let countdownArray = Array(1...5) // [1, 2, 3, 4, 5]

// Using the Array initializer with a closure
let squaredNumbers = Array(1...5).map { $0 * $0 } // [1, 4, 9, 16, 25]

// Creating from a collection of elements
let vowels = Array("AEIOU") // ["A", "E", "I", "O", "U"]

// Type inference - Swift infers [String]
let cities = ["New York", "London", "Tokyo"]

// Explicit typing with shorthand syntax
let countries: [String] = ["USA", "UK", "Japan"]

// Explicit typing with generic syntax
let continents: Array<String> = ["North America", "Europe", "Asia"]

// When type inference can't work (empty arrays)
let emptyNumbers: [Int] = []

// For arrays of custom types
struct User {
    let name: String
    let age: Int
}

let users: [User] = [
    User(name: "Alice", age: 28),
    User(name: "Bob", age: 34)
]

// Creating an empty array
var downloads: [String] = []

// Alternative empty array syntax
var uploads = [String]()

// Creating with a capacity hint for performance
var largeArray = [Int](minimumCapacity: 10000)

// Arrays with default values
var scores = Array(repeating: 0, count: 10) // Ten zeros

// Using nil as a default for optionals
var optionalNames: [String?] = Array(repeating: nil, count: 5)

// Checking if an array is empty (important for conditional UI)
if downloads.isEmpty {
    print("No downloads yet")
}

// Default value when accessing potentially empty arrays
let firstDownload = downloads.first ?? "No downloads"

// Creating an array of weekdays
let weekdays = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"]

// Accessing the first day (index 0)
let firstDay = weekdays[0] // "Monday"

// Accessing the third day (index 2)
let middleDay = weekdays[2] // "Wednesday"

// Accessing the last day using count - 1
let lastDay = weekdays[weekdays.count - 1] // "Friday"

// Accessing a range of elements
let midWeek = weekdays[1...3] // ["Tuesday", "Wednesday", "Thursday"]

// Instead of direct subscript for potentially out-of-bounds indices:
// let item = myArray[index] // Could crash!

// Using a conditional check before access
let colors = ["Red", "Green", "Blue"]
let index = 5

if index < colors.count {
    let color = colors[index]
    print(color)
} else {
    print("Index out of range")
}

// Using optional binding with indices
if let firstColor = colors.indices.contains(0) ? colors[0] : nil {
    print("First color is \(firstColor)")
}

// Using the element(at:) method available via extension
extension Array {
    func element(at index: Index) -> Element? {
        return indices.contains(index) ? self[index] : nil
    }
}

if let thirdColor = colors.element(at: 2) {
    print("Third color is \(thirdColor)")
}

// Checking range containment
let requestedIndex = 3
if colors.indices.contains(requestedIndex) {
    print(colors[requestedIndex])
} else {
    print("Index \(requestedIndex) out of range")
}

let numbers = [10, 20, 30, 40, 50]

// Safely accessing first and last elements
let firstNumber = numbers.first // Optional(10)
let lastNumber = numbers.last   // Optional(50)

// Using with optional binding for safety
if let first = numbers.first {
    print("The first number is \(first)")
}

// Handling empty arrays gracefully
let emptyArray: [String] = []
let firstItem = emptyArray.first // nil
let lastItem = emptyArray.last   // nil

// Using first(where:) to find elements by condition
let firstEven = numbers.first(where: { $0 % 2 == 0 }) // Optional(10)
let firstLarge = numbers.first(where: { $0 > 30 })    // Optional(40)

// Combining with default values using nil coalescing
let firstOrDefault = numbers.first ?? 0
let lastOrDefault = emptyArray.last ?? "No items"

// In SwiftUI context
struct HeaderView: View {
    let items: [String]

    var body: some View {
        if let firstItem = items.first {
            Text("First item: \(firstItem)")
        } else {
            Text("No items available")
        }
    }
}

// Starting with a base array
var fruits = ["Apple", "Banana"]

// Append: Adding a single element to the end (O(1) amortized)
fruits.append("Cherry")
// fruits is now ["Apple", "Banana", "Cherry"]

// Insert: Adding an element at a specific position (O(n))
fruits.insert("Apricot", at: 1)
// fruits is now ["Apple", "Apricot", "Banana", "Cherry"]

// Adding multiple elements with +=
fruits += ["Dragon Fruit", "Elderberry"]
// fruits is now ["Apple", "Apricot", "Banana", "Cherry", "Dragon Fruit", "Elderberry"]

// Append contents of another collection
let moreFruits = ["Fig", "Grape"]
fruits.append(contentsOf: moreFruits)
// fruits is now ["Apple", "Apricot", "Banana", "Cherry", "Dragon Fruit", "Elderberry", "Fig", "Grape"]

// In SwiftUI context with @State
struct TaskListView: View {
    @State private var tasks = ["Learn Swift", "Practice Arrays"]
    @State private var newTask = ""

    var body: some View {
        VStack {
            List {
                ForEach(tasks, id: \.self) { task in
                    Text(task)
                }
            }

            HStack {
                TextField("New task", text: $newTask)
                Button("Add") {
                    if !newTask.isEmpty {
                        tasks.append(newTask)
                        newTask = ""
                    }
                }
            }
            .padding()
        }
    }
}

// Starting with a populated array
var planets = ["Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune", "Pluto"]

// Remove at specific index
let removed = planets.remove(at: 8) // Removes and returns "Pluto"
// planets is now ["Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"]

// Remove first and last elements
let first = planets.removeFirst() // Removes and returns "Mercury"
let last = planets.removeLast()   // Removes and returns "Neptune"
// planets is now ["Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus"]

// Remove all elements (keeping capacity)
var tempArray = ["One", "Two", "Three"]
tempArray.removeAll(keepingCapacity: true) // Empty but maintains internal storage
// Useful when you'll refill the array soon

// Remove elements that satisfy a condition
planets.removeAll(where: { $0.starts(with: "V") })
// planets is now ["Earth", "Mars", "Jupiter", "Saturn", "Uranus"]

// In SwiftUI with onDelete modifier
struct RemovableListView: View {
    @State private var items = ["Item 1", "Item 2", "Item 3", "Item 4"]

    var body: some View {
        List {
            ForEach(items, id: \.self) { item in
                Text(item)
            }
            .onDelete(perform: removeItems)
        }
    }

    func removeItems(at offsets: IndexSet) {
        items.remove(atOffsets: offsets)
    }
}

// Starting with a simple array
var scores = [75, 80, 85, 90]

// Update a single element with subscript
scores[2] = 95
// scores is now [75, 80, 95, 90]

// Update multiple elements with range subscript
scores[0...1] = [70, 85]
// scores is now [70, 85, 95, 90]

// Replace a subrange with a collection of different size
scores.replaceSubrange(1...2, with: [82, 88, 92])
// scores is now [70, 82, 88, 92, 90]

// Transform elements with map
scores = scores.map { score in
    min(score + 5, 100) // Add 5 points to each score, capped at 100
}
// scores is now [75, 87, 93, 97, 95]

// In-place modification with swapAt
scores.swapAt(0, 4) // Swap first and last elements
// scores is now [95, 87, 93, 97, 75]

// In SwiftUI context with @State
struct EditableListView: View {
    @State private var tasks = ["Learn Swift", "Master Arrays", "Build App"]
    @State private var editingIndex: Int?
    @State private var editText = ""

    var body: some View {
        List {
            ForEach(Array(tasks.enumerated()), id: \.element) { index, task in
                if editingIndex == index {
                    TextField("Edit task", text: $editText)
                        .onSubmit {
                            tasks[index] = editText
                            editingIndex = nil
                        }
                } else {
                    Text(task)
                        .onTapGesture {
                            editingIndex = index
                            editText = task
                        }
                }
            }
        }
    }
}

let planets = ["Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"]

// Using count
print("There are \(planets.count) planets in our solar system")
// Output: "There are 8 planets in our solar system"

// Checking if there are enough elements for a specific operation
if planets.count >= 3 {
    let innerPlanets = Array(planets[0..<3])
    print("Inner planets: \(innerPlanets)")
}

// Using isEmpty (more efficient than count == 0)
let emptyArray = [String]()
if emptyArray.isEmpty {
    print("No elements to process")
}

// In SwiftUI context
struct PlanetListView: View {
    let planets: [String]

    var body: some View {
        VStack {
            if planets.isEmpty {
                Text("No planets to display")
                    .foregroundColor(.secondary)
            } else {
                Text("Displaying \(planets.count) planets")
                    .font(.headline)

                List(planets, id: \.self) { planet in
                    Text(planet)
                }
            }
        }
    }
}

// Creating an array with reserved capacity
var userIDs = [Int]()
userIDs.reserveCapacity(10000) // Pre-allocates space for 10,000 elements

// This prevents multiple reallocations when adding many elements
for i in 1...10000 {
    userIDs.append(i)
    // Without reserveCapacity, this would cause multiple reallocations
    // as the array grows, which is expensive
}

// Example of measuring the performance difference
func measureArrayGrowth() {
    // Without reserved capacity
    var standardArray = [Int]()
    let startTime1 = CFAbsoluteTimeGetCurrent()
    for i in 1...100000 {
        standardArray.append(i)
    }
    let duration1 = CFAbsoluteTimeGetCurrent() - startTime1

    // With reserved capacity
    var optimizedArray = [Int]()
    optimizedArray.reserveCapacity(100000)
    let startTime2 = CFAbsoluteTimeGetCurrent()
    for i in 1...100000 {
        optimizedArray.append(i)
    }
    let duration2 = CFAbsoluteTimeGetCurrent() - startTime2

    print("Standard: \(duration1) seconds")
    print("Optimized: \(duration2) seconds")
    print("Performance improvement: \(duration1/duration2)x")
}

// When to use in real applications
struct DataImporter {
    func importLargeDataSet(from url: URL) async throws -> [Record] {
        // If we know approximately how many records to expect
        let approximateCount = try await getRecordCount(from: url)

        var records = [Record]()
        records.reserveCapacity(approximateCount)

        // Then populate the array
        // This will be more efficient than letting it grow organically
        return records
    }

    // Placeholder methods
    func getRecordCount(from url: URL) async throws -> Int { return 10000 }
}

struct Record {
    let id: Int
    let data: String
}

let letters = ["A", "B", "C", "D", "E"]

// Basic index usage
let start = letters.startIndex // 0
let end = letters.endIndex     // 5 (one past the last valid index)

// Accessing elements with these indices
let firstLetter = letters[start]            // "A"
let lastLetter = letters[letters.index(before: end)] // "E"

// Iterating using indices
var index = letters.startIndex
while index < letters.endIndex {
    print("Letter at index \(index): \(letters[index])")
    index = letters.index(after: index)
}

// Finding the middle element
let middleIndex = letters.index(letters.startIndex, offsetBy: letters.count / 2)
let middleLetter = letters[middleIndex] // "C"

// Safe index advancement
func safeAdvance<T>(in collection: T, from index: T.Index, by distance: Int) -> T.Index? 
    where T: Collection {
    let targetIndex = collection.index(index, offsetBy: distance, limitedBy: collection.endIndex)
    return targetIndex
}

// Using this safe advancement
if let advancedIndex = safeAdvance(in: letters, from: letters.startIndex, by: 3) {
    print("Safely advanced to: \(letters[advancedIndex])") // "D"
}

// Building a generic function that works with any Collection
func firstAndLast<T>(of collection: T) -> (first: T.Element, last: T.Element)? where T: Collection {
    guard !collection.isEmpty else { return nil }
    let first = collection[collection.startIndex]
    let last = collection[collection.index(before: collection.endIndex)]
    return (first, last)
}

if let result = firstAndLast(of: letters) {
    print("First: \(result.first), Last: \(result.last)") // "First: A, Last: E"
}

// Starting with an unsorted array
var scores = [89, 76, 95, 64, 82]

// In-place sorting (mutates the original array)
scores.sort()
print("Sorted scores: \(scores)") 
// Output: [64, 76, 82, 89, 95]

// Sorting in descending order
scores.sort(by: >)
print("Descending scores: \(scores)") 
// Output: [95, 89, 82, 76, 64]

// Non-mutating sort returns a new array
let ages = [32, 25, 47, 19, 36]
let sortedAges = ages.sorted()
print("Original ages: \(ages)") // Unchanged: [32, 25, 47, 19, 36]
print("Sorted ages: \(sortedAges)") // [19, 25, 32, 36, 47]

// Complex sorting with custom logic
struct Student {
    let name: String
    let grade: Int
}

let students = [
    Student(name: "Alice", grade: 94),
    Student(name: "Bob", grade: 87),
    Student(name: "Charlie", grade: 94),
    Student(name: "Diana", grade: 91)
]

// Sort by grade descending, then by name ascending for ties
let rankedStudents = students.sorted { 
    if $0.grade != $1.grade {
        return $0.grade > $1.grade  // Higher grades first
    } else {
        return $0.name < $1.name    // Alphabetical for same grade
    }
}

// Filtering elements
let passingStudents = students.filter { $0.grade >= 90 }
print("Number of students with A grade: \(passingStudents.count)") // 3

// Combining operations
let topStudentNames = students
    .filter { $0.grade > 90 }
    .sorted { $0.grade > $1.grade }
    .map { $0.name }

// In SwiftUI context
struct StudentListView: View {
    let students: [Student]
    @State private var sortByGrade = true
    @State private var showOnlyTopStudents = false

    var filteredAndSortedStudents: [Student] {
        var result = students

        // Apply filter if needed
        if showOnlyTopStudents {
            result = result.filter { $0.grade >= 90 }
        }

        // Apply sorting
        result = result.sorted { 
            if sortByGrade {
                return $0.grade > $1.grade
            } else {
                return $0.name < $1.name
            }
        }

        return result
    }

    var body: some View {
        List {
            ForEach(filteredAndSortedStudents, id: \.name) { student in
                HStack {
                    Text(student.name)
                    Spacer()
                    Text("\(student.grade)")
                        .fontWeight(.bold)
                }
            }
        }
        .toolbar {
            ToolbarItem(placement: .navigationBarTrailing) {
                Button(sortByGrade ? "Sort by Name" : "Sort by Grade") {
                    sortByGrade.toggle()
                }
            }
            ToolbarItem(placement: .navigationBarLeading) {
                Toggle("Top Only", isOn: $showOnlyTopStudents)
            }
        }
    }
}

// Basic mapping - transform each element
let numbers = [1, 2, 3, 4, 5]
let squared = numbers.map { $0 * $0 }
print(squared) // [1, 4, 9, 16, 25]

// Mapping with more complex transformations
let names = ["john", "alice", "bob", "carol"]
let formattedNames = names.map { $0.prefix(1).uppercased() + $0.dropFirst() }
print(formattedNames) // ["John", "Alice", "Bob", "Carol"]

// Using compactMap to handle optionals and filter nils
let inputStrings = ["42", "seven", "99", "3.14", "63"]
let parsedIntegers = inputStrings.compactMap { Int($0) }
print(parsedIntegers) // [42, 99, 63] - "seven" and "3.14" are filtered out

// Practical example with optional data
struct User {
    let id: Int
    let email: String?
}

let users = [
    User(id: 1, email: "user1@example.com"),
    User(id: 2, email: nil),
    User(id: 3, email: "user3@example.com"),
    User(id: 4, email: nil)
]

let validEmails = users.compactMap { $0.email }
print("Valid email count: \(validEmails.count)") // 2

// Using flatMap with nested arrays
let nestedArrays = [[1, 2], [3, 4, 5], [6]]
let flattened = nestedArrays.flatMap { $0 }
print(flattened) // [1, 2, 3, 4, 5, 6]

// Practical flatMap example with complex data
struct Department {
    let name: String
    let employees: [String]
}

let company = [
    Department(name: "Engineering", employees: ["Alice", "Bob", "Charlie"]),
    Department(name: "Marketing", employees: ["Diana", "Eve"]),
    Department(name: "HR", employees: ["Frank"])
]

// Get all employees across departments
let allEmployees = company.flatMap { $0.employees }
print("Total employees: \(allEmployees.count)") // 6

// Combining transformations for powerful data processing
let employeeEmails = company.flatMap { dept in
    dept.employees.map { employee in
        "\(employee.lowercased())@company.com"
    }
}

// In SwiftUI context
struct CompanyDirectoryView: View {
    let departments: [Department]
    @State private var searchText = ""

    var filteredEmployees: [String] {
        let allEmployees = departments.flatMap { $0.employees }
        if searchText.isEmpty {
            return allEmployees
        } else {
            return allEmployees.filter { $0.lowercased().contains(searchText.lowercased()) }
        }
    }

    var body: some View {
        VStack {
            TextField("Search employees", text: $searchText)
                .padding()

            List(filteredEmployees, id: \.self) { employee in
                Text(employee)
            }
        }
    }
}

// Basic element checking
let fruits = ["Apple", "Banana", "Cherry", "Durian", "Elderberry"]

// Simple presence check
let hasBanana = fruits.contains("Banana") // true
let hasWatermelon = fruits.contains("Watermelon") // false

// Finding position of elements
if let cherryIndex = fruits.firstIndex(of: "Cherry") {
    print("Cherry is at position \(cherryIndex)") // "Cherry is at position 2"
}

// Finding element with custom condition
let numbers = [10, 15, 23, 32, 45, 50, 67]

// First number greater than 30
if let firstLargeNumber = numbers.first(where: { $0 > 30 }) {
    print("First number > 30: \(firstLargeNumber)") // 32
}

// Index of first even number
if let firstEvenIndex = numbers.firstIndex(where: { $0 % 2 == 0 }) {
    print("First even number is at index \(firstEvenIndex)") // "First even number is at index 0" (10)
}

// More complex example with custom types
struct Product {
    let id: String
    let name: String
    let price: Double
    let category: String
}

let inventory = [
    Product(id: "P001", name: "Laptop", price: 1299.99, category: "Electronics"),
    Product(id: "P002", name: "Desk Chair", price: 249.50, category: "Furniture"),
    Product(id: "P003", name: "Coffee Maker", price: 89.99, category: "Kitchen"),
    Product(id: "P004", name: "Tablet", price: 499.99, category: "Electronics"),
    Product(id: "P005", name: "Bookshelf", price: 175.00, category: "Furniture")
]

// Check if we have any kitchen products
let hasKitchenItems = inventory.contains { $0.category == "Kitchen" } // true

// Find the cheapest electronic
if let cheapestElectronic = inventory
    .filter({ $0.category == "Electronics" })
    .min(by: { $0.price < $1.price }) {
    print("Cheapest electronic: \(cheapestElectronic.name) at $\(cheapestElectronic.price)")
    // "Cheapest electronic: Tablet at $499.99"
}

// Find product by ID
func findProduct(withID id: String) -> Product? {
    return inventory.first { $0.id == id }
}

if let product = findProduct(withID: "P003") {
    print("Found: \(product.name)")
} else {
    print("Product not found")
}

// In SwiftUI context - Selecting items in a list
struct ProductListView: View {
    let products: [Product]
    @State private var selectedProductID: String?

    var body: some View {
        List {
            ForEach(products, id: \.id) { product in
                ProductRow(product: product, isSelected: product.id == selectedProductID)
                    .onTapGesture {
                        selectedProductID = product.id
                    }
            }
        }
        .overlay {
            if !products.contains(where: { $0.category == "Electronics" }) {
                Text("No electronics products available")
                    .foregroundColor(.secondary)
            }
        }
    }
}

struct ProductRow: View {
    let product: Product
    let isSelected: Bool

    var body: some View {
        HStack {
            VStack(alignment: .leading) {
                Text(product.name)
                    .fontWeight(isSelected ? .bold : .regular)
                Text(product.category)
                    .font(.caption)
            }
            Spacer()
            Text("$\(product.price, specifier: "%.2f")")
        }
        .padding(.vertical, 4)
        .background(isSelected ? Color.blue.opacity(0.1) : Color.clear)
    }
}