Swift可选类型(Optional)的介绍和使用场景
原文地址:
https://www.jianshu.com/p/f2e25f78f5a2
可选类型(Optional)的介绍
可选类型(Optional)是Swift新添的对象。它允许变量或常量中没有值(被设为nil),主要是为了解决对象变量或常量为空的情况。
Objective-C与Swift语言对于nil的不同理解:
- Objective-C中的nil:表示缺少一个合法的对象,是指向不存在对象的指针,对结构体、枚举等类型不起作用(会返回NSNotFound)
- Swift中的nil:表示任意类型的值缺失,是一个确定的值,要么是该类型的一个值要么什么都没有(即为nil)
总结为OC中的nil表示没有值,而Swift中的nil表示变量值为空。
可选类型需要在类型后面加一个问号(?)。一个典型的例子是String类有一个toInt方法,该方法会将字符串转换为Int类型。不过这里就有一个问题,字符串中可能包含非数字的字符,这时就会转换失败。如果在其他语言中,不添加错误捕捉,可能会抛出异常,而在Swift中,如果转换失败,就直接返回nil。表示没有返回Int类型的值。这里的toInt方法返回的就是一个可选类型。
var numStr:String = "123"
var value:Int? = numStr.toInt(); // value必须定义为可选的Int类型,否则无法成功编译
println(value)
不过每次使用value变量时都进行判断很麻烦,所以,Swift添加了一个用于确定可选类型变量一定有值的感叹号(!)。当对value第一次判断后,如果能确认该变量已经被赋了值,后面就可以直接在value后加感叹号使用该变量了。
如果在可选类型变量(常量)后面加感叹号,当变量(常量)为nil时,程序会中断,并在终端输出如下的信息。
fatal error: unexpectedly found nil while unwrapping an Optional value
所以在可选变量(常量)后面加感叹号时,要确保该变量(常量)中一定有值。
注意在使用可选类型变量(常量)时,如果使用问号(?)来定义,并且单独使用这些变量和常量,后面是可以不加感叹号(!)的。但要让这些变量和常量和其他的值通过操作符进行操作,那就必须要加感叹号了。
使用场景:
1.申明可选常量或变量
let status: Int? = 1 // 申明可选Int类型的常量,初始值为1
var defaultAddress: String? = "江苏南京" // 申明可选String类型的变量,初始值为"江苏南京"
var student: Person? // 申明可选Person(自定义的类)的变量,初始值为nil
注意:Int?与Int不相同,Int?表示可选的Int类型,可以赋值为nil,而Int不可以赋值为nil
2.使用”!”强制解析获取可选类型的值(不建议直接使用)
var defaultAddress: String? = "江苏南京"
if defaultAddress != nil { // !=或==可以用来判断是否为nil
print("您的地址是\(defaultAddress!)") // 使用!强制解析
} else {
print("对不起,您不存在地址信息")
}
var student: Person?
print("学生为\(student!)") // XCode会提示运行错误,因为student初始值为nil,强制解析不行
3.使用可选绑定获取可选类型的值(建议的用法)
var defaultAddress: String? = "江苏南京"
if let address = defaultAddress { // 如果defaultAddress有值或类型转换成功,则将值赋值给address直接使用
print("您的地址是\(address)") // 使用address代替defaultAddress,且不需要加!强制解析
} else {
print("对不起,您不存在地址信息")
}
4.隐式解析可选类型(用于申明时肯定有初始值,但后面可能为nil)
var mobileNumber: Int64! = 13912345678 // 第一次申明有初始值
print("您的电话号码是\(mobileNumber)") // 不需要使用!强制解析
// 打印内容:**您的电话号码是****Optional(13912345678)**
// 还是不建议直接强制解析,因为实际项目中可能中间已经对该值做了改变,若为nil则会运行错误导致APP崩溃
if let number = mobileNumber { // 建议的做法
print("您的电话号码是\(number)")
// 打印内容:**您的电话号码是****13912345678**
} else {
print("您没有记录电话号码")
}
5.空合运算符(用于判断变量或常量是否为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!
}
}
6.函数/方法返回类型为可选类型
- 返回值为可选类型的值(如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")
}
- 返回值为可选类型的类(如URL?、自定义Person?等)
class SomeClass {
var someValue: Int
init?(someValue: Int) { // 可失败构造器
if someValue == 1 { return nil }
self.someValue = someValue
}
}
func returnPossibleClass(value: Bool) -> SomeClass? { // 返回的类实例可能为nil
if value {
return SomeClass(someValue: 1) // 返回的为nil
} else {
return SomeClass(someValue: 2) // 返回的SomeClass?实例,不为nil
}
}
- 返回值为可选类型的闭包(如(()-> (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")
}
7.可选类型在类或结构体中的运用
- 可选类型在类中的运用:
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
注意:类中所有属性都需要有默认值。属性可以在申明时赋予初始值,也可以在构造方法中赋予初始值;子类继承父类时,必须先给自身属性先初始化后再继承父类构造方法初始化。一般的,出于安全的因素,子类的属性都赋予初始值或直接定义为可选类型。
- 可选类型在结构体中的运用
struct PossibleStruct {
var someValue: Int
var possibleValue: String? // 可选存储属性,默认值为nil
// 结构体中可以自定义一个init构造器对属性初始化,也可以不自定义
}
let someStruct = PossibleStruct(someValue: 4, possibleValue: nil)
possibleValue可传String类型的值或nil
8.可选类型在构造器中的运用
概念:可失败构造器是 一个类、结构体或枚举类型的对象,在构造过程中有可能失败;这里所指的“失败”是指,如给构造器传入无效的参数值,或缺少某种所需的外部资源,又或是不满足某种必要的条件等。
- 结构体的可失败构造器
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
- 枚举的可失败构造器
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
- 类的可失败构造器
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”
9.可选类型在可选链中的运用
概念:可选链为一种可以在当前值可能为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
10.可选类型在错误处理中的运用
概念:错误处理即为响应错误一级从错误中恢复的过程
- 一般的错误处理写法(一般使用于需要对不同的返回结果较为清晰的捕捉并做相应的处理)
// 操作错误处理枚举
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数据类型错误
- 错误处理(try!)(不建议使用,可能会导致App崩溃)
let photo = try! loadImage(atPath: "./Resources/John Appleseed.jpg")
// 上述语句中在执行loadImage方法时如果执行失败,使用try!来禁用错误传递,会有运行错误导致App崩溃
- 错误处理(try?)(一般使用于不需要对错误进行过多的处理)
func someThrowingFunction() throws -> Int {
// ...
}
let x = try? someThrowingFunction() // x可能正常返回一个Int类型的值也有可能抛出一个错误异常,使用时对x用if let可选绑定判断
11.可选类型在类型转换中的运用
类型转换在向上转型时一般不会出现失败,例如从子类向父类转型,直接用as即可
类型转换在向下转型时可能会出现失败,例如从父类向子类转型,要使用as?转型,使用时需要可选绑定后再用.值得注意的是:从Any转成Int为向下转型,Swift从安全因素考虑,会直接返回nil,所以在日常项目中若遇到从父类向子类转型时,一定要使用可选绑定,如以下代码
class SuperClass {
// 这是一个父类
}
class SubClass: SuperClass {
// 这是一个子类
}
let superClass = SuperClass()
if let someClass = superClass as? SubClass {
// 如果转换成功,则用someClass使用即可
} else {
// 转换失败
}
12.其他、调用公共库时注意API的返回值
var score: [String: Int] = ["语文": 87, "数学": 99, "英语": 61]
let removedValue = score.removeValue(forKey: "物理") // 返回nil
从以上代码中可看出,removeValue方法会返回被删除key对应的Value值,发现不存在key为“物理”,即返回nil(removedValue常量值)
上一篇: Java 8 之 Optional类
下一篇: Java 8 Optional 类
推荐阅读
-
MySQL数据库的使用优势、数据库类型、常用的属性约束和常用存储引擎介绍
-
Redis的使用--基本数据类型的操作命令和应用场景
-
长连接和短连接的定义,优缺点以及使用场景介绍
-
Redis全方位详解--数据类型使用场景和redis分布式锁的正确姿势
-
Java中的引用类型和使用场景详细
-
Swift可选类型(Optional)的介绍和使用场景
-
javascript Optional chaining:可选链操作符(?.)的介绍与使用
-
Redis的使用--基本数据类型的操作命令和应用场景
-
MySQL数据库的使用优势、数据库类型、常用的属性约束和常用存储引擎介绍
-
JavaScript的String类型replace()方法介绍和使用replace()方法实现简单html模板替换功能...