Swift允许未初始化声明变量吗？非可选未初始化常量编译通过原因咨询

Great question—this trips up a lot of folks who assume Swift requires all non-optional constants to be initialized the second they’re declared. Let’s break down what’s going on here.

First, Swift’s initialization rule isn’t "initialize at declaration" #

Swift’s safety model doesn’t force you to assign a value to a non-optional let constant right when you declare it. Instead, it enforces a smarter rule: a non-optional constant must be assigned exactly once before it’s first used, across every possible code path.

The compiler runs static analysis to verify this. If it can prove that no matter what happens in your code, the constant will have a value before you try to read it, it’ll let the code compile.

Why your code compiled but crashed #

In your incomplete example:

let hourOfDay = 12; 
let timeOfDay: String; 
if hourOfDay < 6 { 
    timeOfDay = "Early morning" 
} else if ho // (incomplete condition)

The cut-off else if is likely the culprit. Since the code ends mid-condition, the compiler couldn’t fully analyze all possible paths—it might have missed that there’s a scenario where timeOfDay never gets assigned.

In a complete, valid version where every possible path sets a value for timeOfDay (like adding a final else clause), the code would compile and run without issues. But because your code has an uncovered path that the compiler didn’t catch (thanks to being incomplete), it let you compile—but when the runtime hits that unassigned path, it crashes (since Swift can’t let you access an uninitialized non-optional value).

A quick example of valid delayed initialization #

This code is totally legal because every possible code path assigns timeOfDay exactly once:

let hourOfDay = 12
let timeOfDay: String

if hourOfDay < 6 {
    timeOfDay = "Early morning"
} else if hourOfDay < 12 {
    timeOfDay = "Morning"
} else if hourOfDay < 18 {
    timeOfDay = "Afternoon"
} else {
    timeOfDay = "Evening"
}

print(timeOfDay) // Works perfectly

Why this design makes sense #

This rule gives you flexibility: you can declare a constant first, then assign its value based on conditional logic, while still keeping the safety of Swift’s type system (no unexpected nil values). The compiler just needs to verify you won’t accidentally use the constant before it’s ready.

内容的提问来源于stack exchange，提问作者Martin Muldoon