Weather Lookup Tool

Parse simulated JSON weather data with Codable, safely unwrapping every optional field.

CodableOptionalsClosures

Overview

Real weather APIs never guarantee every field will be present — a sensor might not report humidity, a "feels like" figure might be omitted in mild conditions, and an alerts list only shows up when there is actually something to warn about. That is precisely the shape Codable is built for: a WeatherResponse struct where the genuinely optional fields are typed as Optionals, so Swift's JSONDecoder automatically treats a missing JSON key as nil for those fields, with no manual key-checking required.

By the end of this tutorial you will have a console application that decodes simulated JSON weather payloads into a Codable struct with JSONDecoder, wrapped in a do/catch block so a malformed payload is reported rather than silently ignored, and a closure-based formatter that safely unwraps every optional field before ever printing it — no force-unwraps, and no field that could crash the program if the data behind it happens to be absent.

What You'll Build

A WeatherResponse: Codable struct matching a realistic simulated JSON payload.
Optional fields (feelsLike, humidity, alerts) that decode to nil when the JSON omits them.
A dictionary of simulated raw JSON strings standing in for a real weather API.
A fetchWeather(for:) function using JSONDecoder().decode(...) inside a do/catch.
A closure-based formatWeather value that unwraps every optional with map and ?? before display.
A readLine()-driven lookup loop tying it all together.

Prerequisites

Structs — stored properties and Codable conformance basics.
Optionals — Optional<T> fields, if let, map on an Optional, and nil-coalescing with ??.
Closures — declaring a closure with an explicit type and calling it like a function.
Error handling — do/catch and the try keyword around a throwing call.
Dictionaries — [String: String] and subscript lookup returning an Optional.

Project Structure

The program lives in a single file, main.swift. WeatherResponse is the Codable model matching the shape of the (simulated) API payload. simulatedResponses is a [String: String] dictionary standing in for a real network call — a genuine app would replace it with a URLSession.shared.dataTask request, but the decoding, error handling, and formatting logic below would not need to change at all, since all of it only depends on already having a Data value to decode. fetchWeather(for:) turns a city name into an Optional WeatherResponse, and formatWeather is a standalone closure responsible for turning that struct into safe, human-readable text.

Step 1: Define the WeatherResponse Codable Struct

Every stored property here is itself Codable — String, Double, Int, [String], and Optionals of Codable types are all automatically Codable — so Swift can synthesize the entire encoding and decoding implementation with no manual CodingKeys or init(from:) needed. feelsLike, humidity, and alerts are Optionals specifically because a real weather provider does not always include them in every response.

// Codable is a compiler-synthesized conformance: because every stored
// property below is itself Codable (String, Double, Int, [String], and
// Optionals of Codable types), Swift generates the JSON encoding/decoding
// logic automatically — no manual keys or init(from:) needed.
struct WeatherResponse: Codable {
    let city: String
    let temperature: Double
    let condition: String
    let feelsLike: Double?    // Optional: some providers omit "feels like" entirely for certain conditions
    let humidity: Int?        // Optional: not every sensor reports humidity
    let alerts: [String]?     // Optional array: omitted entirely from the payload when there are no active alerts
}

Step 2: Simulate a JSON API Response

A real app would fetch this data over the network; here the payloads are inlined as Swift multi-line strings so the project can be run and understood with no network access or API key required. Notice that Delhi's payload omits feelsLike and alerts entirely, and Bengaluru's omits humidity and alerts — JSONDecoder handles a missing key for an Optional property by decoding it as nil automatically, with no extra configuration needed.

// A real app would fetch this over the network with URLSession; here the
// payloads are inlined as Swift multi-line strings so the project can be run
// and understood without any network access or API key.
let simulatedResponses: [String: String] = [
    "mumbai": """
    {"city": "Mumbai", "temperature": 31.5, "condition": "Humid", "feelsLike": 36.0, "humidity": 78, "alerts": ["Heavy rain expected"]}
    """,
    "delhi": """
    {"city": "Delhi", "temperature": 24.0, "condition": "Clear", "humidity": 40}
    """,
    "bengaluru": """
    {"city": "Bengaluru", "temperature": 22.5, "condition": "Cloudy", "feelsLike": 22.0}
    """
]

Step 3: Decode JSON With JSONDecoder and do/catch

decoder.decode(WeatherResponse.self, from:) is a throwing function — it can fail if the JSON does not actually match WeatherResponse's shape — so the call is wrapped in try inside a do/catch block rather than using try?, specifically so a genuine parsing failure can be logged with catch's error value instead of silently collapsing into the same nil an unknown city would also produce.

func fetchWeather(for city: String) -> WeatherResponse? {
    guard let json = simulatedResponses[city.lowercased()] else {
        return nil   // Unknown city: nothing to decode at all
    }
    guard let data = json.data(using: .utf8) else {
        return nil   // Defensive: only fails if the string somehow isn't valid UTF-8
    }
    do {
        let decoder = JSONDecoder()
        return try decoder.decode(WeatherResponse.self, from: data)   // Throws if the JSON doesn't match WeatherResponse
    } catch {
        // A real API could send malformed data; surface the failure instead of
        // silently treating a bad payload the same as an unknown city.
        print("Failed to parse weather data for \(city): \(error)")
        return nil
    }
}

Example Usage

Click Run to see what this code prints.

Step 4: Build a Closure-Based Formatter That Unwraps Every Optional

formatWeather is stored in a let as a closure value with an explicit (WeatherResponse) -> String type, not written as a free function — that makes the formatting strategy itself a value that could later be swapped for a different one (a metric-vs-imperial formatter, for instance) without touching the code that calls it. Inside it, Optional.map runs its closure only when there is a real value and leaves nil as nil, and the trailing ?? supplies the fallback text for that nil case — together they unwrap every optional field with no force-unwraps anywhere in the function.

// A closure stored in a let, not a free function — this makes the
// formatting strategy a value that could be swapped out (e.g. a metric vs.
// imperial formatter) without touching the code that calls it.
let formatWeather: (WeatherResponse) -> String = { weather in
    var lines: [String] = []
    lines.append("Weather for \(weather.city): \(weather.condition), \(weather.temperature)°C")

    // map on an Optional runs the closure only if there is a value, leaving
    // nil as nil — then ?? supplies the fallback text for the nil case, so
    // every branch is handled without a single force-unwrap anywhere.
    let feelsLikeText = weather.feelsLike.map { "\($0)°C" } ?? "not reported"
    lines.append("Feels like: \(feelsLikeText)")

    let humidityText = weather.humidity.map { "\($0)%" } ?? "not reported"
    lines.append("Humidity: \(humidityText)")

    if let alerts = weather.alerts, !alerts.isEmpty {
        lines.append("Alerts: \(alerts.joined(separator: ", "))")
    } else {
        lines.append("Alerts: none")
    }

    return lines.joined(separator: "\n")
}

Step 5: Build the Lookup Loop

The loop is deliberately simple: read a city name, check for the "exit" sentinel, and otherwise hand the input to fetchWeather(for:). If that returns a real WeatherResponse, formatWeather from Step 4 renders it; if it returns nil — either because the city is not in simulatedResponses or because decoding failed — the loop prints a plain "not found" message instead of ever touching a field on a value that might not exist.

var running = true

while running {
    print("""

    ===== WEATHER LOOKUP TOOL =====
    Enter a city (Mumbai, Delhi, Bengaluru) or "exit" to quit:
    """)
    print("> ", terminator: "")
    guard let input = readLine(), !input.isEmpty else {
        print("Please enter a city name.")
        continue
    }

    if input.lowercased() == "exit" {
        print("Goodbye!")
        running = false
        continue
    }

    if let weather = fetchWeather(for: input) {
        print(formatWeather(weather))   // Reuses the closure from Step 4 to render the result
    } else {
        print("No weather data found for \(input).")
    }
}

Complete Code

Here is the full program assembled in the correct order, ready to save as main.swift and run with swift main.swift, or paste into a Swift Playground.

import Foundation

struct WeatherResponse: Codable {
    let city: String
    let temperature: Double
    let condition: String
    let feelsLike: Double?
    let humidity: Int?
    let alerts: [String]?
}

let simulatedResponses: [String: String] = [
    "mumbai": """
    {"city": "Mumbai", "temperature": 31.5, "condition": "Humid", "feelsLike": 36.0, "humidity": 78, "alerts": ["Heavy rain expected"]}
    """,
    "delhi": """
    {"city": "Delhi", "temperature": 24.0, "condition": "Clear", "humidity": 40}
    """,
    "bengaluru": """
    {"city": "Bengaluru", "temperature": 22.5, "condition": "Cloudy", "feelsLike": 22.0}
    """
]

func fetchWeather(for city: String) -> WeatherResponse? {
    guard let json = simulatedResponses[city.lowercased()] else {
        return nil
    }
    guard let data = json.data(using: .utf8) else {
        return nil
    }
    do {
        let decoder = JSONDecoder()
        return try decoder.decode(WeatherResponse.self, from: data)
    } catch {
        print("Failed to parse weather data for \(city): \(error)")
        return nil
    }
}

let formatWeather: (WeatherResponse) -> String = { weather in
    var lines: [String] = []
    lines.append("Weather for \(weather.city): \(weather.condition), \(weather.temperature)°C")

    let feelsLikeText = weather.feelsLike.map { "\($0)°C" } ?? "not reported"
    lines.append("Feels like: \(feelsLikeText)")

    let humidityText = weather.humidity.map { "\($0)%" } ?? "not reported"
    lines.append("Humidity: \(humidityText)")

    if let alerts = weather.alerts, !alerts.isEmpty {
        lines.append("Alerts: \(alerts.joined(separator: ", "))")
    } else {
        lines.append("Alerts: none")
    }

    return lines.joined(separator: "\n")
}

var running = true

while running {
    print("""

    ===== WEATHER LOOKUP TOOL =====
    Enter a city (Mumbai, Delhi, Bengaluru) or "exit" to quit:
    """)
    print("> ", terminator: "")
    guard let input = readLine(), !input.isEmpty else {
        print("Please enter a city name.")
        continue
    }

    if input.lowercased() == "exit" {
        print("Goodbye!")
        running = false
        continue
    }

    if let weather = fetchWeather(for: input) {
        print(formatWeather(weather))
    } else {
        print("No weather data found for \(input).")
    }
}

Sample Run

Click Run to see what this code prints.

Extend This Project

Swap the hardcoded dictionary for a real URLSession.shared.dataTask call against a live weather API.
Add a forecast: [DayForecast]? array to WeatherResponse and render a multi-day outlook.
Cache decoded WeatherResponse values in a [String: WeatherResponse] dictionary keyed by city to avoid re-decoding repeated lookups.
Add a second closure that converts temperature to Fahrenheit, and let the user choose a unit at startup.
Write unit tests with XCTest that feed known-good and deliberately malformed JSON into fetchWeather to confirm both paths behave correctly.

Summary

You built a weather lookup tool where Codable did the tedious work of turning JSON text into a typed Swift struct, and every field that could genuinely be missing was modeled as an Optional instead of assumed to always be present. The do/catch around JSONDecoder().decode(...) distinguished a real parsing failure from a simple "unknown city," and the closure-based formatter unwrapped every optional field with map and ?? instead of a single force-unwrap. That combination — Codable for parsing, Optionals for what might not exist, and closures for reusable formatting logic — is exactly how production Swift code handles data coming from outside the program, whether that is a real network response or, as here, a simulated one.