拆包和解包的原因:
其实所谓的 nil 就是 Optional.None, 非 nil 就是Optional.Some, 然后会通过Some(T)包装(wrap)原始值,这也是为什么在使用 Optional 的时候要拆包(从 enum 里取出来原始值)的原因, 也是 PlayGround 会把 Optional 值显示为类似 {Some "hello world"}的原因.
1.swift ?和 !的区别
1.1 Swift语言使用var定义变量,但和别的语言不同,Swift里不会自动给变量赋初始值,也就是说变量不会有默认值,所以要求使用变量之前必须要对其初始化。如果在使用变量之前不进行初始化就会报错:
1 var stringValue : String 2 //error: variable 'stringValue' used before being initialized 3 //let hashValue = stringValue.hashValue 4 let hashValue = stringValue.hashValue
若在一个视图控制器中 class xxxController
1 class AdjustFontViewController: UIViewController{ //报错error: Class 'xxxx' has no initializers 2 //Fix-it Stored property 'stringValue' without initial value prevents synthesized initalizers 3 4 var stringValue: String 5 6 } 7 8 // 修改为: 9 // 当我们不知道变量的值时,可以将改变量设置为可选类型 10 var stringValue: String? 11 12 13 14 // 表明str是可选类型(是string类型或者nil类型) 15 var value: String?="hello world" 16 //value = value?.uppercaseString 17 18 // 拆包 19 if let unwrappedStr = value{ 20 print("拆包:(unwrappedStr.uppercaseString)") //如果value(有值,将值复制给常量unwrappedStr) 21 } 22 else 23 { 24 print("value是nil") //str不赋初始值时 25 } 26 27 // 确定value有存在的值(如果str没有被赋实际意义的值,强制拆包将造成应用程序崩溃) 28 print(" 拆包:(str!.uppercaseString)") 29 30 31 32 // 两种拆包方式 33 // 1.隐性拆包 34 var str1:String! = "hello world" //已经确定变量str1是有值的(如果未赋值,应用程序将崩溃) 35 str1 = str1.lowercaseString 36 print("拆包:(str1)") 37 38 print(str) 39 40 // 2.显性拆包 41 var str2:String?="Hello World" 42 let lowerStr2 = str2?.lowercaseString//lowerStr2是可选的,如果有值,则值为“hello world”否则为nil 43 44 45 46 47
1.2 上面了解到的是普通值,接下来Optional值要上场了。
Optional其实是个enum,里面有None和Some两种类型。其实所谓的nil就是Optional.None, 非nil就是Optional.Some, 然后会通过Some(T)包装(wrap)原始值,这也是为什么在使用Optional的时候要拆包(从enum里取出来原始值)的原因, 也是PlayGround会把Optional值显示为类似{Some "hello world"}的原因,这里是enum Optional的定义:
1 enum Optional<T> : LogicValue, Reflectable { 2 case None 3 case Some(T) 4 init() 5 init(_ some: T) 6 7 /// Allow use in a Boolean context. 8 func getLogicValue() -> Bool 9 10 /// Haskell's fmap, which was mis-named 11 func map<U>(f: (T) -> U) -> U? 12 func getMirror() -> Mirror 13 }
1.2.1 ?的几种使用场景:
a. 声明 Optional 值为可选变量
b. 用在对 Optional 值操作中,用来判断是否能响应后面 的操作
c. 用于安全调用 protocol 的 optional 方法
d. 使用 as? 向下转型(Downcast)
a. Optional 可选值
定义变量时,如果指定是可选的,表示该变量可以有一个指定类型的值,也可以是 nil
定义变量时,在类型后面添加一个 ?,表示该变量是可选的
变量可选项的默认值是 nil
1 //n1 = nil //编译错误 2 3 //let str: String = nil //编译错误 4 5 6 var n2 : Int? = 10 7 8 print("-----n2=(String(describing: n2))") 9 10 n2 = nil 11 12 print("-----n2=(String(describing: n2))") 13 14 15 let str: String! = nil 16 17 print("-----str=(str)") 18
常量可选项没有默认值,主要用于在构造函数中给常量设置初始数值
声明为Optional只需要在类型后面紧跟一个?即可,strValue 是 Optional 的 String。如:
1 var strValue: String? //?相当于下面这种写法的语法糖 2 var strValue: Optional<Int>
一旦声明为Optional的,如果不显式的赋值就会有个默认值nil。判断一个Optional的值是否有值,可以用if来判断:
if strValue { //do sth with strValue }
1.2.2 显示拆包和隐式拆包
a. 使用问号(?)声明的可选类型,在拆包时需要使用感叹号(!),这种拆包方式称为“显式拆包”;
b. 使用感叹号(!)声明的可选类型,在拆包时可以不使用感叹号(!),这种表示方式称为“隐式拆包”。
1 2 3 4 // 在可选类型的问号(?)或感叹号(!)究竟有什么区别呢?这与可选类型的“拆包”(unwrapping)有关,拆包是将可选类型变成普通类型,如果我们直接打印非空的可选类型值,代码如下: 5 6 var n3: Int? = 10 7 8 print(n3) //输出是:Optional(10) 9 10 //print(n3 + 10) //发生编译错误,加 !可以编译过 11 12 13 14 /* 15 16 如果 Optional 值是 nil,不允许参与计算 17 18 只有解包(unwrap)后才能参与计算 19 20 在变量后添加一个 !,可以强行解包 21 22 */ 23 24 var n4: Int? = 10 25 26 print(n4! + 100) //显式拆包 27 28 29 30 var n5: Int! = 10 31 32 print(n5 + 200) //隐式拆包 33 34
1.3 ??运算符
1 /* 2 3 ?? 运算符可以用于判断 变量/常量 的数值是否是 nil,如果是则使用后面的值替代 4 5 在使用 Swift 开发时,?? 能够简化代码的编写 6 7 */ 8 9 10 let num: Int? = nil 11 12 13 let r1 = (num ?? 0) + 10 14 15 print(r1)
1.4 拆包判断
单个可选项判断
1 let url = NSURL(string: "http://www.baidu.com") 2 3 4 5 //: 方法1: 强行解包 - 缺陷,如果 url 为空,运行时会崩溃 6 7 let request = NSURLRequest(URL: url!) 8 9 10 11 //: 方法2: 首先判断 - 代码中仍然需要使用 `!` 强行解包 12 13 if url != nil { 14 15 let request = NSURLRequest(URL: url!)} 16 17 18 19 //: 方法3: 使用 `if let`,这种方式,表明一旦进入if 分支,u 就不在是可选项 20 21 if let u = url where u.host == "www.baidu.com" { 22 23 let request = NSURLRequest(URL: u) 24 25 }
1.4.2 可选项条件判断
1> 初学 swift 一不小心就会让 if 的嵌套层次很深,让代码变得很丑陋
1 if let u == url 2 3 { 4 5 if u.host == "www.baidu.com" { 6 7 let request = NSURLRequest(URL: u) 8 9 }
2> 使用 where 关键字
注意:if let 不能与使用 &&、|| 等条件判断。如果要增加条件,可以使用 where 子句,where 子句没有智能提示
1 if let u = url where u.host == "www.baidu.com" { 2 3 let request = NSURLRequest(URL: u) 4 5 }
1 let hashValue = strValue?.hashValue
strValue是Optional的字符串,如果strValue是nil,则hashValue也为nil,如果strValue不为nil,hashValue就是strValue字符串的哈希值
到这里我们看到了?的两种使用场景:
声明Optional值变量
用在对Optional值操作中,用来判断是否能响应后面的操作
另外,对于Optional值,不能直接进行操作,否则会报错:
1 //error: 'String?' does not have a member named 'hashValue' 2 //let hashValue = strValue.hashValue 3 // ^ ~~~~~~~~~
上面提到Optional值需要拆包(unwrap)后才能得到原来值,然后才能对其操作,那怎么来拆包呢?拆包提到了几种方法,一种是Optional Binding, 比如:
1 if let str = strValue { 2 let hashValue = str.hashValue 3 }
1 func demo4() { 2 3 let urlString = "http://www.baidu.com/中文" 4 5 // 注意:构造函数如果有 `?` 表示不一定能够创建出对象 6 7 let url = NSURL(string: urlString) 8 9 print(url) 10 11 12 13 // 注意:如果参数中,没有 ? 表示必须要有值,如果为 nil,就崩! 14 15 if url != nil { 16 17 let request = NSURLRequest(URL: url!) 18 19 print(request) 20 21 } 22 23 }
1.2 加感叹号
1.2.1 ! 使用的场景
a. 强制对 Optional 值进行拆包(unwrap)
b. 声明 Implicitly Unwrapped Optionals 值,一般用于类中的属性
例子,strValue是Optional的String:
1 1 let hashValue = strValue!.hashValue //这里的!表示“我确定这里的的strValue一定是非nil的,尽情调用吧”
{}里的strValue一定是非nil的,所以就能直接加上!,强制拆包(unwrap)并执行后面的操作。 当然如果不加判断,strValue不小心为nil的话,就会出错,crash掉。
1 myLabel!.text = "text" 2 myLabel!.frame = CGRectMake(0, 0, 10, 10)
对于这种类型的值,我们可以直接这么声明:var myLabel: UILabel! ,这种是特殊的Optional,称为Implicitly Unwrapped Optionals, 直译就是隐式拆包的Optional,就等于说你每次对这种类型的值操作时,都会自动在操作前补上一个!进行拆包,然后在执行后面的操作,当然如果该值是nil,也一样会报错crash掉。
1 var myLabel: UILabel! //!相当于下面这种写法的语法糖 2 var myLabel: ImplicitlyUnwrappedOptional<UILabel>
拓展:对 !应用还有 as
那么!大概也有两种使用场景
1.强制对Optional值进行拆包(unwrap)
2.声明Implicitly Unwrapped Optionals值,一般用于类中的属性
- 还没有人评论,欢迎说说您的想法!