iOS App Development for Beginners: Swift and Xcode Complete Guide

import SwiftUI

struct ContentView: View {
    var body: some View {
        VStack {
            Image(systemName: "globe")
                .imageScale(.large)
                .foregroundStyle(.tint)
            Text("Hello, world!")
        }
        .padding()
    }
}

#Preview {
    ContentView()
}

var mutableValue = "I can change"
let constantValue = "I cannot change"  // Prefer let by default

var name: String = "Alice"     // Always has a value
var nickname: String? = nil    // Might be nil

// You must handle the nil case
if let actualNickname = nickname {
    print("Nickname is \(actualNickname)")
} else {
    print("No nickname set")
}

// Or use nil coalescing
let displayName = nickname ?? name  // "Alice"

// Struct (value type — copied when assigned)
struct Note {
    let id: UUID
    var title: String
    var content: String
    var createdAt: Date
    
    init(title: String, content: String) {
        self.id = UUID()
        self.title = title
        self.content = content
        self.createdAt = Date()
    }
}

// Class (reference type — shared when assigned)
class NoteManager: ObservableObject {
    @Published var notes: [Note] = []
}

import SwiftUI

// Data Model
struct Note: Identifiable, Codable {
    let id: UUID
    var title: String
    var content: String
    var createdAt: Date
    
    init(title: String = "", content: String = "") {
        self.id = UUID()
        self.title = title
        self.content = content
        self.createdAt = Date()
    }
}

// State Manager
@MainActor
class NotesViewModel: ObservableObject {
    @Published var notes: [Note] = []
    
    private let storageKey = "saved_notes"
    
    init() {
        loadNotes()
    }
    
    func addNote() {
        let note = Note(title: "New Note", content: "")
        notes.insert(note, at: 0)
        saveNotes()
    }
    
    func deleteNote(at offsets: IndexSet) {
        notes.remove(atOffsets: offsets)
        saveNotes()
    }
    
    func updateNote(_ note: Note) {
        guard let index = notes.firstIndex(where: { $0.id == note.id }) else { return }
        notes[index] = note
        saveNotes()
    }
    
    private func saveNotes() {
        if let encoded = try? JSONEncoder().encode(notes) {
            UserDefaults.standard.set(encoded, forKey: storageKey)
        }
    }
    
    private func loadNotes() {
        guard let data = UserDefaults.standard.data(forKey: storageKey),
              let decoded = try? JSONDecoder().decode([Note].self, from: data) else { return }
        notes = decoded
    }
}

// Notes List View
struct ContentView: View {
    @StateObject private var viewModel = NotesViewModel()
    
    var body: some View {
        NavigationStack {
            Group {
                if viewModel.notes.isEmpty {
                    ContentUnavailableView(
                        "No Notes",
                        systemImage: "note.text",
                        description: Text("Tap + to create your first note")
                    )
                } else {
                    List {
                        ForEach($viewModel.notes) { $note in
                            NavigationLink(destination: NoteDetailView(note: $note, onSave: viewModel.updateNote)) {
                                NoteRowView(note: note)
                            }
                        }
                        .onDelete(perform: viewModel.deleteNote)
                    }
                }
            }
            .navigationTitle("Quick Notes")
            .toolbar {
                ToolbarItem(placement: .navigationBarTrailing) {
                    Button(action: viewModel.addNote) {
                        Image(systemName: "square.and.pencil")
                    }
                }
                ToolbarItem(placement: .navigationBarLeading) {
                    EditButton()
                }
            }
        }
    }
}

// Note Row
struct NoteRowView: View {
    let note: Note
    
    var body: some View {
        VStack(alignment: .leading, spacing: 4) {
            Text(note.title.isEmpty ? "Untitled" : note.title)
                .font(.headline)
                .lineLimit(1)
            Text(note.content.isEmpty ? "No content" : note.content)
                .font(.subheadline)
                .foregroundStyle(.secondary)
                .lineLimit(2)
            Text(note.createdAt, style: .relative)
                .font(.caption)
                .foregroundStyle(.tertiary)
        }
        .padding(.vertical, 4)
    }
}

// Note Detail/Edit View
struct NoteDetailView: View {
    @Binding var note: Note
    let onSave: (Note) -> Void
    @Environment(\.dismiss) private var dismiss
    
    var body: some View {
        VStack(alignment: .leading, spacing: 0) {
            TextField("Title", text: $note.title)
                .font(.title2.bold())
                .padding(.horizontal)
                .padding(.top)
            
            Divider().padding(.vertical, 8)
            
            TextEditor(text: $note.content)
                .padding(.horizontal, 12)
        }
        .navigationBarTitleDisplayMode(.inline)
        .onDisappear {
            onSave(note)
        }
    }
}

struct MainView: View {
    @State private var path = NavigationPath()
    
    var body: some View {
        NavigationStack(path: $path) {
            List(items) { item in
                NavigationLink(value: item) {
                    Text(item.name)
                }
            }
            .navigationTitle("Items")
            .navigationDestination(for: Item.self) { item in
                ItemDetailView(item: item)
            }
        }
    }
}

struct Post: Codable {
    let id: Int
    let title: String
    let body: String
}

class PostsViewModel: ObservableObject {
    @Published var posts: [Post] = []
    @Published var isLoading = false
    @Published var errorMessage: String?
    
    func fetchPosts() async {
        isLoading = true
        errorMessage = nil
        
        do {
            let url = URL(string: "https://jsonplaceholder.typicode.com/posts")!
            let (data, _) = try await URLSession.shared.data(from: url)
            let decoded = try JSONDecoder().decode([Post].self, from: data)
            await MainActor.run {
                posts = decoded
                isLoading = false
            }
        } catch {
            await MainActor.run {
                errorMessage = error.localizedDescription
                isLoading = false
            }
        }
    }
}

// In your view:
.task {
    await viewModel.fetchPosts()
}