import UIKit
import PlaygroundSupport
/// 可选值： Optional
/// Mark： 可选值的由来
/// 在编程语言中有一些特定的值来代表特定的含义：比如：EOF（对-1 的#define）代表文件的结束，null代表空
///这些特定的值用来表示函数没有返回真实的值。这些值被称为“岗哨值”
///岗哨值是有缺陷的
/// 1、这个特定值未被定义，只能通过文档查看， 2、很容易引起其他问题。例如下面代码
//NSString * someString = "hello"
//if ([someString rangeOfString:@"swift"].location != NSNotFound) {
// // 如果someString为空，那么location为0， 而NSNotFound 被定义为NSIntegerMax，这样if内语句将被执行
// print("xxxxx")
//}
//3、如果一个函数的返回值一定不为空，那么只能通过文档才能知道，从函数本身是看不出来的
// Mark: 通过可选值解决上述问题
//使用swift枚举中含有“关联值”特性(有些语言中被称为标签联合或可辨识联合)
//将若干种不同的可能类型保存在内存的同一空间中，并使用一个标签来区分到底被持有的是什么类型
//enum Optional<Wrapped> {
// case none
// case some(Wrapped)
//}
///获取关联值的唯一方法： 通过switch 或者 if case 进行模式匹配。除非显式进行捷豹，否则不可能意外使用Optional中的值
///因为可选值在swift中非常基础，所以有更简单的写法：Optional<Index> 可以写作： Index?；
///可选值遵循 ExpressibleByNilLiteral协议，可以用nil代替.none；
///非可选值在需要时可自动升级为可选值： return .some(index) 可以写作：return index
///可选值的本质就是普通的枚举值
var array = ["one", "two", "three"]
switch array.firstIndex(of: "four") {
case .some(let idx):
array.remove(at: idx)
default:
break
}
//简化写法
switch array.firstIndex(of: "four") {
case let idx?: //?作为匹配模式后缀
array.remove(at: idx)
case nil:
break //nil 匹配.none
}
// Mark: if let 可选绑定
if let idx = array.firstIndex(of: "two") {
array.remove(at: idx)
}
// if 可以绑定多个值，而且后面绑定的值可以基于之前解包成功的值进行操作
let urlString = "https://www.objc.io/logo.png"
if let url = URL(string: urlString),
let data = try? Data(contentsOf: url),
let image = UIImage(data: data) {
let view = UIImageView(image: image)
PlaygroundPage.current.liveView = view
}
//if 可以有用Bool值限定和可选绑定混用
if let url = URL(string: urlString),
url.pathExtension == "png",
let data = try? Data(contentsOf: url),
let image = UIImage(data: data) {
let view = UIImageView(image: image)
PlaygroundPage.current.liveView = view
}
// Mark: while let 可选值绑定
//while let line = readLine(), !line.isEmpty {
// print(line)
//}
// Mark: while 配合Iterater使用： for x in seq 要求 seq遵循Sequence协议，该协议提供makeIterator方法创建迭代器，迭代器next方法负责返回序列中的值，当序列值耗尽时，返回nil
let numers = [1, 2, 3]
var iterator = numers.makeIterator()
while let i = iterator.next() {
print(i, terminator:" ")
}
for i in 0..<10 where i % 2 == 0 {
print(i, terminator: " ")
}
var iterator2 = numers.makeIterator()
while let i = iterator2.next() {
if i % 2 == 0 {
print(i, terminator: " ")
}
}
// while 和 for是有区别的 ： for 等价于 while let ，而while就是while
var functions:[() ->Int] = []
for i in 0..<3 {
functions.append({i}) //每次迭代都是不同的变量，虽然名字一样，但是已经不是原来的变量，相当于 let i1, let i2, let i3(解释上面 for 等价于 while let)
}
print("***")
for f in functions {
print("\(f())", terminator: "") // 在其他语言中：因为闭包会捕获局部变量，虽然每次存储闭包时，i的值不一样，但是所有的闭包捕获的是同一个局部变量，所以当闭包执行时，打印的都是2（i的最后一个值）
// swift当中每次append的时候都是不同的i变量
}
// Mark: 双重可选值: 可选值被另外一个可选值包装
let stringNumbers = ["1", "2", "three"]
let maybeInts = stringNumbers.map{ Int($0) } // Optional(1), Optinal(2), nil //maybeInts是一个类型为Optional<Int>的数组，因为Int.init(String)可能失败
//mabeInts中最后一个元素是nili
for maybeInt in maybeInts {
//得到两个Int？ 和 一个nil
print(maybeInt, terminator: " ")
}
print()
//iterator3.next() 返回的是Optonal<Optonal<Int>> 或者说是 Int??
var iterator3 = maybeInts.makeIterator()
while let maybeInt = iterator3.next() { //while let 会进行第一层解包（最外层），所以最后一个值是.some(nil)
print(maybeInt, terminator: " ")
}
print()
//for写法：使用case来进行模式匹配
// 方式 1
for case let i? in maybeInts { // i? 是 .some(i)的简写
print(i, terminator: " ")
}
print()
// 方式 2
for case .some(let i) in maybeInts {
print(i, terminator: " ")
}
print()
// 方式 3
for case let .some(i) in maybeInts {
print(i, terminator: " ")
}
//for let x in maybeInts { //不存在这种写法: 因为 for x in maybeInts 就已经表达了这个意思， 不过可以用 for var x in mybeInts
// print(x)
//}
// Mark: 基于case模式匹配的规则应用到for，if，while中
let j = 5
if case 0..<10 = j { // 0 到9 任意一个值等于j
print("\(j)在范围内")
}
//Mark: 重载case模式匹配
//因为case匹配可以通过重载~=运算符来进行扩展，所以可以将if case 和 for case 进行有趣的扩展
struct Pattern {
let s: String
init(_ s: String) {
self.s = s
}
}
func ~=(pattern: Pattern, value: String) -> Bool {
return value.range(of: pattern.s) != nil
}
let s = "Simon Swift"
if case Pattern("Swfit") = s {
print("\(String(reflecting: s)) contains \"Swift\"")
}
//恶作剧代码
//func ~=<T, U>(_: T,_: U) -> Bool { return true}
// 除了 let意外， var也可以搭配 for ， while， if 等使用。用法同 let一样
// Mark： 解包后的作用域
// if语句中的解包变量只能在if作用域中使用，不能再外面使用
if let firstElement = array.first {
print(firstElement)
}
//外面无法使用firstElement
//swift延时初始化能力
extension String {
var fileExtension: String? {
let period: String.Index //定义局部变量且未初始化
if let idx = lastIndex(of: ".") {
period = idx //初始化
} else {
return nil
}
let extStart = index(after: period)
return String(self[extStart...])
}
}
// Mark： guard。 等价于 if not let
//guard let x = ... else { ...} . guard的唯一要求是： 在else中必须离开作用域，既return， 或 在循环中使用break，continue
///一个函数的返回值如果是Never的话，这就意味着告诉编译器这个函数不会返回。通常有两种函数会这样做： 一类是 fatalError,另一个是dispatchMain那样在整个生命周期的函数。
/// 编译器会使用这个信息进行控制流诊断。比如guard语句的else语句路径必须退出当前域或者调用一个不会反悔的函数
///Never 又被叫做无人类型。这种类型没有有效值，因此也不能够被构建。它的唯一作用就是给编译器提供信号。一个返回值被声明为无人类型的函数将永远不能正常返回。
///在swift中，无人类型由一个不包含任意成员的enum来实现的
public enum Never{}
// Mark: Never用法
//关闭编译器提示错误
func unimplemented() -> Never {
fatalError("编译器先闭嘴，我还没写完呢，不要给我提示错误")
}
/// Mark: Swift 各种“无”类型： nil, Never，Void。 Void标识空元组
public typealias Void = ()
///Swift对“东西不存在”(nil)，“存在且为空”(Void) i以及 “不可能发生”(Never)定义的非常清楚
// Mark: 可选链： swift中可以通过“可选链” 实现“对nil发送消息什么都不会发生”
// delegate?.callBack 。 swift会强制要求你声明的消息的接受者可能为nil
let str: String? = "Never say never"
// 为什么在第一个uppercase()后加问号，而后面的不需要？ 因为可选链是一个“展平”操作，str?.uppercase()返回一个可选值，如果再调用?.lowercased()将返回一个可选值的可选值。而我们要的是一个可选值，所以后面的不用加，可选特性已经在前面捕获了
let result = str?.uppercased().lowercased()
//如果返回值是可选值的话，那么后面仍然需要添加问号来表示正在链接这个可选值
extension Int {
var half: Int? {
guard self < -1 || self > 1 else { return nil }
return self / 2
}
}
20.half?.half?.half //Optional(2) 编译器会展平结果类型，结果是Int？ 而不是Int???
let dictOfArray = ["nine": [0, 2, 3, 4]]
dictOfArray["nine"]?[3]
let dictOfFunctions: [String:(Int, Int) -> Int] = [
"add":(+),
"substract": (-)
]
dictOfFunctions["add"]?(1,2)
// Mark: 通过可选链进行赋值
struct Person {
var name: String
var age: Int
}
var optionalLisa: Person? = Person(name: "Lisa Simpson", age: 8)
if optionalLisa != nil {
optionalLisa!.age += 1
}
if var lisa = optionalLisa {
lisa.age += 1 //此时optionalLisa的值不会改变，因为Person是值类型，可选绑定会创建一个副本，即使lisa的值改变，也不会影响optionalLisa的值 。如果Person是类的话，是可以的
}
//使用可选值赋值
optionalLisa?.age += 1
// Mark: 可选值可以直接赋值
var a: Int? = 5
a? = 10
// Mark: nil合并运算符： ??
//在解包一个可选值时，如果是nil，可以用一个默认值来替换它
let stringteger = "1"
let number = Int(stringteger) ?? 0
// lhs ?? rhs 等价于 lhs!=nil? lhs:rhs
let array1 = [1, 2, 3]
!array.isEmpty ? array1[0] : 0
// 可以通过 ?? 完成合并操作
array1.first ?? 0
//使用可选值确保满足某个条件
array1.count > 5 ? array1[5] : 0
extension Array {
subscript(guarded idx: Int) -> Element? {
guard (startIndex..<endIndex).contains(idx) else { return nil }
return self[idx]
}
}
array1[guarded: 5] ?? 0
//多个可选值合并
let i: Int? = nil
let l: Int? = nil
let k: Int? = 45
i ?? l ?? k ?? 0 // 42
// Mark:字符串插值使用可选值
let bodyTemperature: Double? = 37.0
let bloodGlucose: Double? = nil
print(bodyTemperature) //警告：表达式隐式强制从 “Double?”转换为Any
print("Blood glucose leve:\(bloodGlucose)") //警告： 字符串榨汁将使用调试时的可选值描述
// ?? 表达式要求两侧的类型必须匹配： Int？的默认值必须是Int， Double？的默认值必须是Double
// Mark: 自定义运算符
infix operator ???: NilCoalescingPrecedence
public func ???<T>(optional: T?, defaltValue: @autoclosure() -> String) -> String { //@autoclosure()标注确保只有当需要时，才对第二个表达式求值
switch optional {
case let value?:
return String(describing: value)
case nil:
return defaltValue()
}
}
print("Body temperature:\(bodyTemperature ??? "a/n")")
// Mark： 可选值map
//可选值拥有map功能，当有值时则调用闭包。 区别于结合中的map，可选值map只操作一个值
let characters:[Character] = ["a", "b", "c"]
let firstChar = characters.first.map{String($0)}
// Mark: 可选值map原理
extension Optional {
func map<U>(transform:(Wrapped) -> U) -> U? {
if let value = self {
return transform(value)
}
return nil
}
}
// 实现不接受初始值的reduce方法
extension Array {
func reduce(_ nextPartialReult:(Element, Element) ->Element) -> Element? {
guard let fst = first else { return nil }
return dropFirst().reduce(fst, nextPartialReult)
}
}
// 不使用gaurd实现reduce
extension Array {
func reduce_alt(_ nextPartialResult: (Element, Element) -> Element) -> Element? {
return first.map {
dropFirst().reduce($0, nextPartialResult)
}
}
}
// Mark: 可选值flatMap ： 将多层可选值展平
let stringNumbers2 = ["1", "2", "3", "foo"]
let x = stringNumbers2.first.map{Int($0)} //Optional(Optional(1)) // first 返回值是可选值，Int(String)返回值也是可选值，所以x 为Int??
//flatMap把结果展平为Int?
let y = stringNumbers2.first.flatMap{Int($0)} //Optional(1)
//flatMap 等价于 if let
extension Optional {
func flatMap<U>(transform:(Wrapped) -> U?) -> U? {
if let value = self, let transformed = transform(value) {
return transformed
}
return nil
}
}
//Mark: 使用可选值过滤 nil
let numbers1 = ["1", "2", "3", "foo"]
var sum1 = 0
for case .some(let i) in numbers1.map({Int($0)}) {
sum1 += i
}
print(sum1)
let sum2 = numbers1.map({Int($0)}).reduce(0){$0 + ($1 ?? 0)}
print(sum2)
//因为现在还无法定义一个只作用于可选值序列的Sequence扩展，所以定义为全局函数
func flatten<S: Sequence, T>(source: S) -> [T] where S.Element == T? {
let filtered = source.lazy.filter {$0 != nil}
return filtered.map{$0!}
}
extension Sequence {
func flatMap<U>(transform:(Element) -> U?) -> [U] {
return flatten(source: self.lazy.map(transform))
}
}
// Mark: 可选值判等
//可选值判等重载==运算符
func ==<T: Equatable>(lhs: T?, rhs: T?) -> Bool {
switch (lhs, rhs) {
case (nil, nil):
return true
case let (x?, y?):
return x == y
case (nil,_?),(_?,nil):
return false
}
}
let regex = "^Hello"
if regex.first == Optional("^") {
//如果使用非可选值和可选值匹配时，swfit会将非可选值”升级“为可选值，所以这段代码不可取。理想状态时：regex.fist == "^"，这种写法比较简单
}
//推导： 为了实现非可选值和可选值判等的简单写法，我们需要以下三个函数
// func ==<T: Equatable>(lhs: T?, rhs: T?) -> Bool
// func ==<T: Equatable>(lhs: T, rhs: T?) -> Bool
// func ==<T: Equatable>(lhs: T?, rhs: T) -> Bool
//事实上只需要一种，因为Swift包含隐士转换，比如map函数返回值是可选的，但是我们不用写成这样： return Optional(1), 而是直接写 return 1
// Mark: 注意"字典"赋值nil时操作
var dictWithNils: [String: Int?] = [
"one" : 1,
"two" : 2,
"three" : 3,
"foure" : 4,
"none" : nil
]
dictWithNils["one"] = nil //会移除键
print(dictWithNils)
dictWithNils["two"] = Optional(nil) //会移除键
print(dictWithNils)
dictWithNils["three"] = .some(nil) //不会移除键
print(dictWithNils)
dictWithNils["foure"]? = nil //不会移除键 //因为是用的可选链，如果键不存在，后面赋值不会执行，也不会插入
print(dictWithNils)
dictWithNils["five"] = Optional(5)
print(dictWithNils)
// Mark: Equalable 和 ==
//Equalble是协议， == 是操作符
// Mark: 强制解包
//当结果不可能为nil时使用强制解包
func flatten2<S: Sequence, T>(source: S) -> [T] where S.Element == T? {
let filtered = source.lazy.filter {$0 != nil}
return filtered.map{$0!} //因为上一句已经保证了每个元素不可能为nil
}
// Mark: 改进强制解包错误信息： 定义!!操作符
infix operator !!
func !!<T>(Wrapped: T?, failureText: @autoclosure() -> String) -> T {
if let x = Wrapped { return x }
fatalError(failureText())
}
//let ss = "foo"
//let yyy = Int(ss) !! "失败鸟"
// Mark: 在调试版本中进行断言
//一般在发布版本中会把”解包失败“替换成空值或默认值，而在测试中一般通过断言，让程序崩溃
// 实现疑问感叹号（!?）操作符，对解包失败进行断言，切在发布版本总替换成默认值
infix operator !?
func !?<T: ExpressibleByIntegerLiteral>(wrapped: T?, failureText: @autoclosure() -> String) -> T {
assert(wrapped != nil, failureText())
return wrapped ?? 0
}
let sss = "20"
let iii = Int(sss) !? "Expecting integer,got\(s)"
// 对字面量转换协议进行重载，可以覆盖不少能够有默认值的类型
func !?<T: ExpressibleByArrayLiteral> (wrapped: T?, failureText: @autoclosure() -> String) -> T {
assert(wrapped != nil, failureText())
return wrapped ?? []
}
func !?<T: ExpressibleByStringLiteral>(wrapped: T?, failureText: @autoclosure() -> String) -> T {
assert(wrapped != nil, failureText())
return wrapped ?? ""
}
// Mark: 隐式解包
//隐式解包的可选值看上去像非可选值，但本质还是可选值。你可以像可选值一样使用它
var ssss: String! = "Hello"
ssss?.isEmpty
if let x = ssss {print(x)}
网友评论