Swift 可选类型

iOS 136 2018-11-02 11:45

对于使用Objective-C开发iOS的程序员来说,对象是否为nil在编写程序的过程中程序员不太关心,直接使用就可以,在一些需要判断的地方在判断,当转为Swift开发时,首先头疼的问题就是可选类型,到底何时使用?,何时使用!总是拿不太准,下面就详细的讲解一下

Swift 可选类型-JEESNS

一、什么是可选类型

可选类型伴随着Swift诞生,在原有的Objective-C语言中不存在,究其原因,是因为Swift是类型安全的语言,而OC则是弱类型语言,OC中 str字符串既可以是nil,也可以是字符串,而Swift中,这两种状态是不能同时存在的。
OC和Swift对于nil的解释也是不太一样的

1.Objective-C中的nil:表示缺少一个合法的对象,是指向不存在对象的指针,对结构体、枚举等类型不起作用(会返回NSNotFound)
2.Swift中的nil:表示任意类型的值缺失,是一个确定的值,要么是该类型的一个值要么什么都没有(即为nil)

在Swift中Optional(可选类型)是一个含有两种情况的枚举,None 和 Some(T),用来表示可能有或可能没有值。任何类型都可以明确声明为(或者隐式转换)可选类型。当声明一个可选类型的时候,要确保用括号给 ? 操作符一个合适的范围。

1.1可选类型的声明
var optionalStr: String? = "swift语言可选类型"//声明可选类型字符串,并赋初值
var opStu:Student? //声明可选opStu对象,赋初值nil

注意:在类型和 ?之间没有空格

1.2 强制解析(拆包)

当你确定自定义的可选类型一定有值时,可以使用操作符(!)进行强制解析,拿到数据,叹号表示"我知道一定有值,请使用它",但是当你判断错误,可选值为nil时使用(!)进行强制解析,会有运行错误。

var myStr:String? = nil
myStr="强制解析,一定有值"
if myStr != nil {
    print(myStr!)//使用!进行强制解析
}else{
    print("字符串为nil")
}

运行结果

强制解析,一定有值
1.3 自动解析

在最初的声明时使用?修饰,当你希望它自动解析是可以用!代替?来修饰,这样在变量使用时就不需要加!来强制拆包,它会自动解析。

var myStr:String! //使用!修饰
myStr="自动解析"
if myStr != nil {
    print(myStr)
}else{
    print("字符串为nil")
}

运行结果

自动解析
1.4 可选绑定

A.使用可选绑定,摆脱了频繁的判断是否为nil在赋值,但是使用可选绑定(optional binding)来判断可选类型是否包含值,如果包含就把值赋给一个临时常量或者变量。可选绑定可以用在if和while语句中来对可选类型的值进行判断并把值赋给一个常量或者变量。
格式:

if let tempStr = someOptional{
    tempStr//如果someOptiona有值的话,就会赋值给tempStr,然后使用
}
var myStr:String?
myStr="可选绑定"
if  let tempStr = myStr {
    print(tempStr)
}else{
    print("字符串为nil")
}

运行结果

可选绑定

B.在可选类型判断中还有guard let的用法,guard名为守卫的意思。guard let和if let刚好相反,guard let守护一定有值。如果没有,直接返回

let name: String? = "张三"
let age: Int? = 10

guard let nameNew = name,
      let ageNew = age
else {
        print("姓名 或 年龄 为nil")
        return
}

print("姓名 或 年龄 为\(name),\(age)")//运行到这里是一定有值的
1.5 as! 与 as? 的类型转换

在写Swift代码时总是拿不准到底使用哪个,有时会根据编辑器的提示去Fix,但是这样不能很好的解决问题。
1.as!使用场合

向下转型(Downcasting)时使用。由于是强制类型转换,如果转换失败会报 runtime 运行错误。就是说强制从父类转换成子类

class Animal {}
class Cat: Animal {}
let animal :Animal  = Cat()
let cat = animal as! Cat

2.as?使用场合

as? 和 as! 操作符的转换规则完全一样。但 as? 如果转换不成功的时候便会返回一个 nil 对象。成功的话返回可选类型值(optional),需要我们拆包使用。由于 as? 在转换失败的时候也不会出现错误,所以对于如果能确保100%会成功的转换则可使用 as!,否则使用 as?

let animal:Animal = Cat()

if let cat = animal as? Cat{
    print("cat is not nil")
} else {
    print("cat is nil")
}

二、可选类型的使用场景

2.1 函数或方法的返回类型为可选类型

在方法中返回值如Int?、String?、(Int, String)?、[Int]?、[Int: String]?等

func returnOptionValue(value: Bool) -> String? { // 返回类型为可选String类型
    if value {
        return "返回类型是可选类型值" // 如果为真,返回Int类型的值1
    } else {
        return nil //返回nil
    }
}

let optionValue = returnOptionValue(value: true) // 要用可选绑定判断再使用,因为returnOptionValue为String?可选类型
if let value = optionValue {
    print(value)
} else {
    print("none value")
}

运行结果

返回类型是可选类型值

返回类型为闭包可选

func returnOptionalFunc(value: Bool) -> (() -> (Void))? { // 返回类型为可选类型的闭包
    if value {
        return { () in
            print("返回类型是可选类型闭包")
        }
    } else {
        return nil
    }
}

let possibleFunc = returnOptionalFunc(value: true) // 要用可选绑定判断再使用,因为possibleFunc 为可选类型的闭包,类型为() -> (Void)
if let aFunc = possibleFunc {
    print(aFunc())  // 注意增加()调用闭包,因为没有参数则是空括号
} else {
    print("none func")
}

运行结果

返回类型是可选类型闭包
2.2 可选类型在类或结构体中的运用

可选类型在类中的使用

class PossibleClass {
    var someValue: Int
    var possibleValue: String? // 可选存储属性,默认值为nil
    init(someValue: Int) { // 构造方法中可以不对possibleValue属性初始化
        self.someValue = someValue
    }
}

let someClass = PossibleClass(someValue: 4)

可选类型在结构体中的运用

struct PossibleStruct {
    var someValue: Int
    var possibleValue: String? // 可选存储属性,默认值为nil
    // 结构体中可以自定义一个init构造器对属性初始化,也可以不自定义
}

let someStruct = PossibleStruct(someValue: 4, possibleValue: nil)
2.3 可选类型在构造器中使用
class PossibleStructInit {
    let someValue: String
    init?(someValue: String) { // 可失败构造器
        if someValue.isEmpty { return nil } // 如果实例化为空串,则返回nil(即实例化失败)
        self.someValue = someValue
    }
}

let oneStruct = PossibleStructInit(someValue: "构造器中使用") // abc不是空串,oneStruct为PossibleStructInit?可选类型
if let one = oneStruct { // 使用if let可选绑定判断
    print(one.someValue)
} else {
    print("none value")
}
//输入结果为:构造器中使用

let twoStruct = PossibleStructInit(someValue: "") // 传参为空串
if let two = twoStruct {
    print(two.someValue)
} else {
    print("none value")
}
//输入结果为:none value
2.4 可选类型在错误处理中使用(try!与try?)

1.try?会将错误转换为可选值,当调用try?+函数或方法语句时候,如果函数或方法抛出错误,程序不会发崩溃,而返回一个nil,如果没有抛出错误则返回可选值。
2.使用try!可以打破错误传播链条。错误抛出后传播给它的调用者,这样就形成了一个传播链条,但有的时候确实不想让错误传播下去,可以使用try!语句

let photo = try! loadImage(atPath: "./Resources/John Appleseed.jpg")
// 上述语句中在执行loadImage方法时如果执行失败,使用try!来禁用错误传递,会有运行错误导致App崩溃
func someThrowingFunction() throws -> Int {
    // ...
}

let x = try? someThrowingFunction() // x可能正常返回一个Int类型的值也有可能抛出一个错误异常,使用时对x用if let可选绑定判断
文章评论