Ios swift可选泛型类型和嵌套可选展开

我有这段代码

class MyObject<T> {

    func start(_ value: T?) {
        if let value = value {
            doSomething(value)
        }
    }

    func doSomething(_ value: T) {
        print(value)
    }
}

MyObject<String>().start("some")
// prints "some"

MyObject<String?>().start(nil)
// doesn't print anything

类MyObject{
函数启动（u值：T？）{
如果let value=value{
剂量（值）
}
}
func剂量测定法（u值：T）{
打印（值）
}
}
MyObject（）.start（“一些”）
//打印“一些”
MyObject（）.start（无）
//没有打印任何东西

我需要为传递给

start（）

的每个有效值调用

doSomething（）

。当

T

已经是可选类型，如

String？

，则

nil

是有效值

---

我是否需要在

MyObject

的扩展中编写两个版本的

start（）

，条件是

T

？怎么做呢？

由于let value=value在第二次输入时失败，因此需要单独处理该情况

func start(_ value: T?) {
    if let value = value {
        doSomething(value)
    }
    else
    {
        print("nil input")
    }
}

---

由于let value=value在第二次输入时失败，因此需要单独处理该情况

func start(_ value: T?) {
    if let value = value {
        doSomething(value)
    }
    else
    {
        print("nil input")
    }
}

---

如果值为nil，则展开时，该值将不会输入if语句。相反，您可以这样做：

class MyObject<T> {

    func start(_ value: T?) {
        if let value = value {
            doSomething(value)
        } else {
            print("nil")
        }
    }

    func doSomething(_ value: T) {
        print(value)
    }
}

类MyObject{
函数启动（u值：T？）{
如果let value=value{
剂量（值）
}否则{
打印（“无”）
}
}
func剂量测定法（u值：T）{
打印（值）
}
}

如果值为零，则展开时，该值将不会输入if语句。相反，您可以这样做：

class MyObject<T> {

    func start(_ value: T?) {
        if let value = value {
            doSomething(value)
        } else {
            print("nil")
        }
    }

    func doSomething(_ value: T) {
        print(value)
    }
}

类MyObject{
函数启动（u值：T？）{
如果let value=value{
剂量（值）
}否则{
打印（“无”）
}
}
func剂量测定法（u值：T）{
打印（值）
}
}

Swift中的可选项只是一个具有两种情况的通用枚举：

enum Optional<T> {
    case some(T)
    case none
}

这意味着，如果像

start（nil）

那样调用它，整个对象当然将为nil，而

if let

将失败。 但是，您可以用这种方式调用该函数

MyObject<String?>().start(Optional.some(Optional.none))
MyObject<String?>().start(.some(.none)) // -> shorter version with type inference

MyObject（）.start（可选的.some（可选的.none））
MyObject（）.start（.some（.none））/>具有类型推断的较短版本

基本上现在外部可选存在，展开工作正常，但是内部可选的是

nil

---

但是我仍然不明白为什么您需要这样做

在Swift中可选的只是一个有两种情况的通用枚举：

enum Optional<T> {
    case some(T)
    case none
}

这意味着，如果像

start（nil）

那样调用它，整个对象当然将为nil，而

if let

将失败。 但是，您可以用这种方式调用该函数

MyObject<String?>().start(Optional.some(Optional.none))
MyObject<String?>().start(.some(.none)) // -> shorter version with type inference

MyObject（）.start（可选的.some（可选的.none））
MyObject（）.start（.some（.none））/>具有类型推断的较短版本

基本上现在外部可选存在，展开工作正常，但是内部可选的是

nil

---

但是我仍然不明白为什么您需要这样做

您可以让您的

启动

函数采用非可选的

t

，并且总是调用

doSomething

，而不是先尝试打开它。这只允许您在

T

本身是可选类型时调用

start（nil）

：

class MyObject<T> {

    func start(_ value: T) {
        doSomething(value)
    }

    func doSomething(_ value: T) {
        print(value)
    }
}

MyObject<String>().start("some")
// prints "some"

MyObject<String?>().start(nil)
// prints "nil"

或

let string:string？=无
MyObject（）.start（字符串）

---

然后它将打印“nil”

您可以让您的

启动

函数使用非可选的

T

，并且总是调用

doSomething

，而不是先尝试打开它。这只允许您在

T

本身是可选类型时调用

start（nil）

：

class MyObject<T> {

    func start(_ value: T) {
        doSomething(value)
    }

    func doSomething(_ value: T) {
        print(value)
    }
}

MyObject<String>().start("some")
// prints "some"

MyObject<String?>().start(nil)
// prints "nil"

或

let string:string？=无
MyObject（）.start（字符串）

---

然后它会打印“无”

谢谢您的时间！然而，我的意思是，我需要为传递给

-start:

的每个有效值调用

doSomething:

。当

T==String？

时，“nil”是一个有效值。

-start:

方法中的解决方法不适合我的需要。感谢您抽出时间！然而，我的意思是，我需要为传递给

-start:

的每个有效值调用

doSomething:

。当

T==String？

时，“nil”是一个有效值。

-start:

方法中的变通方法不适合我的需要。为什么需要这样的方法？为什么需要这样的方法？