可选值: Optional有两种状态:
1.有值 2.没有值, 没有值就是nil
//有值:
var optValue1: Int? = 9 // 9
//没有值:
var optValue2: Int? // nil
var optValue3: Int? = nil // nil
可选值可以利用if语句来进行判断
var optValue4: Int?
if optValue4 != nil
{
print(optValue4)
}else
{
print(optValue4) // nil
}
提取可选类型的值(强制解析)
会将optValue中的整型值强制拿出来赋值给变量result1, 换句话说就是告诉编译器optValue一定有值, 因为可选类型有两种状态有值和没有值, 所以需要告诉编译器到底有没有值
需要注意的是如果强制解析optValue, 但是optValue中没有值时会引发一个运行时错误
var optValue5: Int? = 9 // 9
var result1: Int = optValue5! // 9
print(result1) // 9\n
报错
var optValue6: Int?
// error : Execution was interrupted,reason:EXC_BAD_INSTRUCTION 运行时坏指令
// code=EXC_i386_INVOP subcode=0x0
var result2: Int = optValue6!
可选绑定:
为了更安全的解析可选类型的值, 一般情况下使用可选绑定
如果optValue没有值就不会做任何操作, 如果optValue有值会返回true并将optValue的值赋值给result执行大括号中的内容
var optValue: Int? = 9 // 9
if let result3 = optValue
{
print(result3) // 9\n
}
可选类型:
可选类型的本质其实就是一个枚举
None 没有值
Some 有值
格式: Optional<类型> 或 在类型后面加上?号
由于可选类型在Swift中随处可见
var opa: Optional // nil
opa = 1 // 1
var opb: Int? // nil
opb = 2 // 2
var nora: Int
nora = 10 // 10
基本类型变量, 在使用之前必须进行初始化, 否则报错
目的: 安全, 不管在什么时候访问都是有意义的
普通变量和可选类型的区别, 普通变量只有一种状态, 有值
注意:Swift的变量和C/OC的不一样, C/OC可以没有值, 是一个随机值
由于普通变量只有一种状态, 有局限性, 所以Swift设计了可选类型
print(opb) // "Optional(2)\n"
int *p;
NSLog("%d", *p); // Error : 会报错, 不安全
可选类型是安全的么? 是, 可以通过可选绑定判断后再使用
Swift的发明者完全是基于安全的考虑, 当我们使用基本类型时完全不用考虑是否有值
当我们使用可选类型时, 总会记得先判断再使用. 让程序员时刻了解哪些有值哪有没有值
var opc: Int? //nil
opc = 55 //55
if let c = opc{
print(opc!) //"55\n"
print(c) //"55\n"
}
Swift中的可选类型变量更贴近于OC中的普通变量
var data:NSData? = NSData(contentsOfFile: "xxx.xlsx") // nil
print(data) // nil
可选链: 通过可选类型的变量来调用相应的属性和方法
可选链的返回值是一个可选值
格式:
可选值?.属性
可选值?.方法
class Person {
var name: String
init(name:String){
self.name = name
}
func whoami() ->String{
print("my name is \(self.name)")
return name
}
}
var p0 : Person? // nil
var p1 : Person = Person(name: "solozyx") // Person
p1.name = "zs" // Person
p1.whoami() // "zs"
如何通过可选类型来调用对应的方法和属性
1.通过强制解包 但是强制解包非常危险, 如果可选类型没有值, 会引发运行时错误
// error : Execution was interrupted , reason:EXC_BAD_INSTRUCTION
// code=EXC_i386_INVOP , subcode=0x0
p0!.name = "ls"
p0!.whoami()
2.通过可选绑定, 代码繁琐
var per0:Person? = Person(name: "per0") //Person
if let per1 = per0 {
per1.whoami() // "per0"
per1.name = "per1" // Person
per1.whoami() // "per1"
}
3.通过可选链, 如果问号前面的变量没有值, 整个可选链会失效
更加简洁高效, 有利用使用可选类型
var person0:Person? // nil
var person1:Person = Person(name: "person1") // Person
person0 = person1 // Person
person0!.name // "person1"
person0!.name = "person0" // Person
person0!.name // "person0"
可选链的返回值会自动包装成一个可选值
因为可选链可能失效, 所以返回值可能有值也可能没有值, 要想表达有值或者没有值只能用可选值, 所以返回值会自动包装成一个可选值
print(p0?.name) // "nil\n"
print(p0?.whoami()) // "nil\n"
print(p1.name) // "zs\n"
var a:String? = p0?.name // nil
p0?.name = "ww" // nil
p0 // nil
var b:String = p1.name // "zs"
可选链调用下标索引
格式:
可选值?[]
struct Student {
var name:String = "solozyx"
var math:Double = 99.0
var chinese:Double = 99.0
var english:Double = 99.0
// 要想实现下标访问, 必须实现subscript方法
// 如果想要通过下标访问, 必须实现get方法
// 如果想要通过下表赋值, 必须实现set方法
subscript(course:String) ->Double?{
get{
switch course{
case "math":
return math
case "chinese":
return chinese
case "english":
return english
default:
return nil
}
}
set{
switch course{
case "math":
// 因为返回的是可选类型
math = newValue!
case "chinese":
chinese = newValue!
case "english":
english = newValue!
default:
print("not found")
}
}
}
}
var stu:Student? = Student() // Student
// 可选链调用下标索引不需要., 直接在问号后面写上[]即可
print(stu?["math"]) // "Optional(99.0)\n"
// 利用可选链赋值. 注意: 早起版本中不能利用可选链赋值
stu?.name = "ww" // ()
print(stu?.name) // "Optional("ww")\n"
// 利用可选链给下标赋值
stu?["math"] = 88 // ()
print(stu?["math"]) // "Optional(88.0)\n"
// 判断赋值操作是否成功, 可选链的赋值操作也有返回值
// 如果赋值成功会返回一个可选类型, 返回()?也就是Viod? 代表成功. 返回nil代表失败
//let res = stu?.name = "zl"
let res1: ()? = stu?.name = "zl" // () 代表可选链赋值成功
stu?.name // "zl"
let res2: Void? = stu?.name = "zz" // () 代表可选链赋值成功
stu?.name // "zz"
stu = nil // nil
let res: Void? = ( stu?.name = "zl" ) // nil 代表可选链赋值失败
var arr:Array? = [1, 2, 3, 4] //[1, 2, 3, 4]
print(arr?[1]) //"Optional(2)\n"
多层可选链:
单层:可选值?.属性
多层:可选值?.属性.属性?.属性 或者 可选值?.属性?.属性?.属性
class A {
var name:String = "solozyx"
}
class B{
var a1:A?
}
class C{
var b1:B = B()
}
class D{
var c1: C?
}
var a1 = A() // A
var b1 = B() // B
var c1 = C() // C
var d1 = D() // D
d1.c1 = c1 // D
// 由于D中的C是可选值, 所以需要在C后面加上?
d1.c1?.b1.a1 = a1 // () 代表可选链赋值成功
// 通过d直接获取a中的name
// 其实只需要在可选值后面加上问号即可, 如果可选值不存在, 那么后面的链失效
print(d1.c1?.b1.a1?.name) // "Optional("solozyx")\n"