Swift中如何实现根据变量返回不同结构体的‘Dummy’结构体？

你的代码报错是因为直接在结构体的顶层定义中写switch执行逻辑，这不符合Swift语法——结构体的顶层只能包含声明（属性、方法、初始化器、嵌套类型等），不能直接放可执行语句，所以编译器提示“Expected declaration”。

下面是正确的实现方案：

步骤1：定义基础类型 #

先明确时间枚举和两个目标结构体：

// 时间枚举
enum TimeOfDay {
    case morning, afternoon
}

// 目标结构体A
struct StructA {
    let greeting = "下午好！"
}

// 目标结构体B
struct StructB {
    let greeting = "上午好！"
}

步骤2：通过协议统一返回类型 #

因为StructA和StructB是不同类型，需要用协议来统一返回值的类型：

// 定义协议，让两个结构体遵循
protocol Greetable {
    var greeting: String { get }
}

// 扩展结构体遵循协议
extension StructA: Greetable {}
extension StructB: Greetable {}

步骤3：实现工厂逻辑 #

你需要的是一个工厂逻辑（而非动态改变类型的结构体），可以用以下几种方式实现：

方式1：静态工厂结构体 #

用结构体封装创建逻辑，更符合代码组织习惯：

struct TimeStructFactory {
    static func create(for time: TimeOfDay) -> Greetable {
        switch time {
        case .morning:
            return StructB()
        case .afternoon:
            return StructA()
        }
    }
}

// 使用示例
let morningGreeting = TimeStructFactory.create(for: .morning)
print(morningGreeting.greeting) // 输出：上午好！

let afternoonGreeting = TimeStructFactory.create(for: .afternoon)
print(afternoonGreeting.greeting) // 输出：下午好！

方式2：全局工厂函数 #

如果不需要封装，也可以直接写全局函数：

func createGreetable(for time: TimeOfDay) -> Greetable {
    switch time {
    case .morning:
        return StructB()
    case .afternoon:
        return StructA()
    }
}

方式3：用枚举封装不同实例 #

如果需要明确区分返回的是哪种结构体，可以用枚举关联值：

enum TimeGreeting {
    case morning(StructB)
    case afternoon(StructA)
    
    init(time: TimeOfDay) {
        switch time {
        case .morning:
            self = .morning(StructB())
        case .afternoon:
            self = .afternoon(StructA())
        }
    }
}

// 使用示例
let greeting = TimeGreeting(time: .afternoon)
switch greeting {
case .morning(let b):
    print(b.greeting)
case .afternoon(let a):
    print(a.greeting)
}

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