Swift学习之可选类型(Optional)

一，概述

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

　　首先我们先看下Objective-C与Swift语言对于可选nil的不同理解:

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

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

二，处理可选类型

申明可选常量或变量

class Person {
    ///存储属性
    var name:String;
    var age:Int
    ///初始化
    init(name:String,age:Int) {
        self.name = name
        self.age  = age
    }
}

let status:Int? = 1  // 申明可选Int类型的常量,初始值为1
var defaultAddress:String? = "Apple"  // 申明可选String类型的变量,初始值为"Apple"
var student:Person? // 申明可选Person(自定义的类)的变量，初始值为nil

注意：

Int?与Int不相同，Int?表示可选的Int类型，可以赋值为nil，而Int不可以赋值为nil
在类型和 ?之间没有空格
Swfit语言定义后缀？作为命名类型Optional的简写，换句话说，以下两种声明是相等的：
```
var optionalInteger: Int?
var optionalInteger: Optional<Int>
```

使用"!"强制解析获取可选类型的值(不建议直接使用)

一旦确定可选值包含值，可以通过在可选值名称的末尾添加感叹号（!）来访问其内部值。这被称为强制解包一个可选的值。

class Person {
    ///存储属性
    var name:String
    var age:Int
    ///初始化
    init(name:String,age:Int) {
        self.name = name
        self.age  = age
    }
}

let status:Int? = 1
var defaultAddress:String? = "Apple"
var student:Person?

var tempAddress:String = defaultAddress! ///使用！进行强制解析
print(tempAddress)

叹号(!)表示"我知道一定有值，请使用它",但是当你判断错误，可选值为nil时使用(!)进行强制解析，会有运行错误。所以在使用强制解包之前，一定要确保一个可选值不为 nil。

class Person {
    ///存储属性
    var name:String
    var age:Int
    ///初始化
    init(name:String,age:Int) {
        self.name = name
        self.age  = age
    }
}

let status:Int? = 1

var defaultAddress:String? = "Apple"
if defaultAddress != nil { //!= 或 == 可以判断是否为nil
    print(defaultAddress!); ///确定了有值，再做赋值
} else {
    print("值为nil,请做异常处理")
}

var student:Person?

使用可选绑定获取可选类型的值(建议的用法)
- 使用可选绑定，摆脱了频繁的判断是否为nil在赋值，但是使用可选绑定（optional binding）来判断可选类型是否包含值，如果包含就把值赋给一个临时常量或者变量。可选绑定可以用在if和while语句中来对可选类型的值进行判断并把值赋给一个常量或者变量
```
class Person {
    ///存储属性
    var name:String
    var age:Int
    ///初始化
    init(name:String,age:Int) {
        self.name = name
        self.age  = age
    }
}

let status:Int? = 1

var defaultAddress:String? = "Apple"
if let tempAddress = defaultAddress {
    print(tempAddress) ////如果defaultAddress有值的话，就会赋值给tempAddress，然后使用
} else {
    print("字符串为nil")
}

var student:Person?
```
  如果转换成功，那么 tempAddress 常量可以在 if 语句的第一个分支中使用。它已经被初始化为包含在非可选的值中，所以没有必要使用 ! 后缀来访问它的值。
  你可以使用可选绑定的常量和变量。如果你想在 if 语句的第一个分支内操作 tempAddress 的值，你可以写 if var tempAddress，使得可选值作为一个变量而非常量。
  
  你可以根据需要在单个 if 语句中包含尽可能多的可选绑定和布尔条件，并用逗号分隔。如果可选绑定中的任何值为 nil，或者任何布尔条件的计算结果为 false，则整个 if 语句的条件被认为是错误的。以下 if 语句是等价的：
```
class Person {
    ///存储属性
    var name:String
    var age:Int
    ///初始化
    init(name:String,age:Int) {
        self.name = name
        self.age  = age
    }
}

let status:Int? = 1

var defaultAddress:String? = "Apple"
if let tempAddress = defaultAddress, let tempStatus = status {
    print(tempAddress) ////如果defaultAddress有值的话，就会赋值给tempAddress，然后使用
    print(tempStatus)
} else {
    print("字符串为nil")
}

var student:Person?
```

隐式解析可选类型(用于申明时肯定有初始值，但后面可能为nil)

有时从程序的结构中可以清楚的看到，在第一次设置值之后，可选值将始终有一个值。在这些情况下，每次访问时都不需要检查和解包可选值，因为可以安全地假定所有的时间都有一个值。

这些可选值被定义为隐式解包可选值。你写一个隐式解包的可选值，在你想要的可选类型之后放置一个感叹号（String!）而不是一个问号（String?）
隐式解包可选值的背后是普通可选值，但也可以像非可选值一样使用，而不必在每次访问时解包可选值。

let possibleString: String? = "An optional string."
let forcedString: String = possibleString! // 需要感叹号

let assumedString: String! = "An implicitly unwrapped optional string."
let implicitString: String = assumedString // 不需要感叹号

如果隐式解包可选值为 nil，并且你尝试访问其包装的值，则会触发运行时错误。
你仍然可以对隐式解包可选值使用强制解包和可选绑定。

var mobileNumber: Int64! = 13912345678 // 第一次申明有初始值
print("您的电话号码是\(mobileNumber)") // 不需要使用!强制解析
// 打印内容:**您的电话号码是****Optional(13912345678)**
// 还是不建议直接强制解析，因为实际项目中可能中间已经对该值做了改变，若为nil则会运行错误导致APP崩溃
if let number = mobileNumber { // 建议的做法
   print("您的电话号码是\(number)")
// 打印内容:**您的电话号码是****13912345678**
} else {
   print("您没有记录电话号码")
}

空合运算符(用于判断变量或常量是否为nil)

// 空合运算符：a ?? b 判断a是否为nil，若a不为nil对a解封，否则返回b的值
var status: Int? // 申明可选Int类型的变量status，初始值为nil
status ?? 0 // 因为status为nil，则返回0
// ?? 即为以下if else的缩写
func testOption() -> Int {
  let status: Int? = 1
  if status == nil {
    return 0
  } else {
    return status!
  }
}

函数/方法返回类型为可选类型

A:返回值为可选类型的值(如Int?、String?、(Int, String)?、[Int]?、[Int: String]?等)

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

let possibleValue = returnPossibleValue(value: true) // 要用可选绑定判断再使用，因为possibleValue为String？可选类型
if let value = possibleValue {
   print(value)
} else {
   print("none value")
}

B:返回值为可选类型的类(如URL?、自定义Person?等)

///自定义类
class SomeClass {
///存储属性
var someValue:Int
init?(someValue:Int) {
self.someValue = someValue
}
}

///方法
func returnPossibleClass(value:Bool) -> SomeClass? {
if value {
return SomeClass(someValue: 1) //返回的为nil
} else {
return SomeClass(someValue: 2) //返回的SomeClass？实例，不为nil
}
}

C:返回值为可选类型的闭包(如(()-> (void))? )

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")
}

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

A:可选类型在类中的运用

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

let someClass = PossibleClass(someValue: 4) // 实例化对象时不需要对possibleValue初始化，someClass实例中：someValue为4，possibleValue为nil

注意：类中所有属性都需要有默认值。属性可以在申明时赋予初始值，也可以在构造方法中赋予初始值；子类继承父类时，必须先给自身属性先初始化后再继承父类构造方法初始化。一般的，出于安全的因素，子类的属性都赋予初始值或直接定义为可选类型。

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

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

调用默认的逐一构造器
说明：从上图可看出实例化,PossibleStruct会调用默认逐一构造器，其中possibleValue可传String类型的值或nil

可选类型在构造器中的运用

概念：可失败构造器是一个类、结构体或枚举类型的对象，在构造过程中有可能失败；这里所指的“失败”是指，如给构造器传入无效的参数值，或缺少某种所需的外部资源，又或是不满足某种必要的条件等。

A:结构体的可失败构造器

struct PossibleStructInit {
  let someValue: String
  init?(someValue: String) { // 可失败构造器
    if someValue.isEmpty { return nil } // 如果实例化为空串，则返回nil(即实例化失败)
    self.someValue = someValue
  }
}

let oneStruct = PossibleStructInit(someValue: "abc") // abc不是空串，oneStruct为PossibleStructInit？可选类型
if let one = oneStruct { // 使用if let可选绑定判断
   print(one.someValue)
} else {
   print("none value")
}
// 结果打印 abc

let twoStruct = PossibleStructInit(someValue: "") // 传参为空串
if let two = twoStruct {
   print(two.someValue)
} else {
   print("none value")
}
// 结果打印 none value

B:枚举的可失败构造器

enum PossibleEnmuInit {
case East, West, South, North // 不带原始值，带原始值也可以使用可失败构造器
  init?(director: Character) {
    switch director {
      case "E":
         self = .East
      case "W":
         self = .West
      case "S":
         self = .South
      case "N":
         self = .North
      default:
         return nil // 如果实例化时不是E/W/S/N字符，则返回nil(即实例化失败)
    }
  }
}

let oneEnmu = PossibleEnmuInit(director: "E") // 传值E，返回PossibleEnmuInit?可选类型
if let one = oneEnmu { // 使用可选绑定判断
   print(one)
} else {
   print("none value")
}
// 结果打印 East

let twoEnmu = PossibleEnmuInit(director: "A") // 传值A，返回PossibleEnmuInit?可选类型
if let two = twoEnmu { // 使用可选绑定判断
   print(two)
} else {
   print("none value")
}
// 结果打印 none value

C:类的可失败构造器

class Product {
  let name: String
  init?(name: String) { 
    if name.isEmpty { return nil }
    self.name = name
  }
}

class CartItem: Product {
  let quantity: Int
  init?(name: String, quantity: Int) {
    if quantity < 1 { return nil } // 实例化时如果quantity小于1，则立即终止构造过程
    self.quantity = quantity
    super.init(name: name) // 如果name为空串，则立即终止构造过程
  }
}

if let twoSocks = CartItem(name: "sock", quantity: 2) {
   print("Item: \(twoSocks.name), quantity: \(twoSocks.quantity)")
}
// 打印 "Item: sock, quantity: 2”

if let zeroShirts = CartItem(name: "shirt", quantity: 0) {
   print("Item: \(zeroShirts.name), quantity: \(zeroShirts.quantity)")
} else {
   print("Unable to initialize zero shirts")
}
// 打印 "Unable to initialize zero shirts”

可选类型在可选链中的运用

概念：可选链为一种可以在当前值可能为nil的可选值上请求和调用属性、方法及下标的方法。如果可选值有值，那么调用就会成功；如果可选值是nil，那么调用将返回nil。多个调用可以连接在一起形成一个调用链，如果其中任何一个节点为nil，整个调用链都会失败，即返回nil。

class Person { 
  var name: String
  var room: Room? // 不是每个人都买房，定义为可选类型
  init(name: String) {
     self.name = name
  }
}

class Room {
  var roomAddr: String
  var roomArea: Int
  init(roomAddr: String, roomArea: Int) {
    self.roomAddr = roomAddr
    self.roomArea = roomArea
  }
}

let xiaoming = Person(name: "xiaoming") // 此时xiaoming实例中属性：name为"xiaoming",room为nil
if let address = xiaoming.room?.roomAddr, let area = xiaoming.room?.roomArea { 
  // 使用?可选链式调用，如果含有值则返回该值(不需要手动强制解析),如果没有值则返回nil
  print("\(xiaoming.name)的房子地址在:\(address), 面积:\(area)")
} else {
  print("\(xiaoming.name)没有房子")
}
// 打印：xiaoming没有房子

xiaoming.room = Room(roomAddr: "南京雨花台区", roomArea: 95) // 定义xiaoming实例的room属性
// 再次调用以上可选绑定，打印 xiaoming的房子地址在:南京雨花台区, 面积:95

可选类型在错误处理中的运用

概念：错误处理即为响应错误一级从错误中恢复的过程

A:一般的错误处理写法（一般使用于需要对不同的返回结果较为清晰的捕捉并做相应的处理）

// 操作错误处理枚举
enum OperationError: Error {
   case ErrorOne
   case ErrorTwo(String) // 带关联值的枚举属性
   case ErrorOthers
}

// 错误处理抛出
func throwDriver(num: Int) throws {
  if num == 1 {
    throw OperationError.ErrorOne
  } else if num == 2 {
    throw OperationError.ErrorTwo("数据类型错误")
  } else {
    throw OperationError.ErrorOthers
  }
}

do {
  print("使用do-catch捕获错误")
try throwDriver(num: 2) // 使用try尝试请求
  print("未捕获到错误")
} catch OperationError.ErrorOne { // catch去捕捉是否又throw出来的错误
  print("捕捉到错误：ErrorOne")
} catch OperationError.ErrorTwo(let message) { // 可以使用let 获取枚举关联值
  print("捕捉到错误：ErrorTwo" + message)
} catch OperationError.ErrorOthers {
  print("捕捉到错误：ErrorOthers")
}
// 打印结果如下：
// 使用do-catch捕获错误
// 捕捉到错误：ErrorTwo数据类型错误

B:错误处理(try!)（不建议使用，可能会导致App崩溃）

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

C:错误处理(try?)（一般使用于不需要对错误进行过多的处理）

func someThrowingFunction() throws -> Int {
// ...
}
let x = try? someThrowingFunction() // x可能正常返回一个Int类型的值也有可能抛出一个错误异常，使用时对x用if let可选绑定判断

可选类型在类型转换中的运用

类型转换在向上转型时一般不会出现失败，例如从子类向父类转型，直接用as即可
类型转换在向下转型时可能会出现失败，例如从父类向子类转型，要使用as?转型，使用时需要可选绑定后再用

使用as?类型转换

值得注意的是：从Any转成Int为向下转型，Swift从安全因素考虑，会直接返回nil，所以在日常项目中若遇到从父类向子类转型时，一定要使用可选绑定，如以下代码：
```
class SuperClass {
// 这是一个父类
}

class SubClass: SuperClass {
// 这是一个子类
}

let superClass = SuperClass()
if let someClass = superClass as? SubClass {
  // 如果转换成功，则用someClass使用即可
} else {
  // 转换失败
}
```
其他、调用公共库时注意API的返回值
返回值类型
```
var score: [String: Int] = ["语文": 87, "数学": 99, "英语": 61]
let removedValue = score.removeValue(forKey: "物理") // 返回nil
```
注意：从以上代码中可看出，removeValue方法会返回被删除key对应的Value值，发现不存在key为“物理”，即返回nil(removedValue常量值)

posted on 2020-06-14 03:02 梁飞宇阅读(779) 评论(0) 收藏举报

刷新页面返回顶部

梁飞宇