Please enable JavaScript.

Coggle requires JavaScript to display documents.

SwiftTips_新元素 (1.2前半部 (柯里化 (Currying) Swift 可以将方法柯里化 (Currying)，把接受多个参数的…

SwiftTips_新元素

1.2前半部

柯里化 (Currying)

Swift 可以将方法柯里化 (Currying)，把接受多个参数的方法进行一些变形，使其更加灵活的方法。Swift 是函数式语言。

func addTo(_ adder: Int) -> (Int) -> Int {
    return { num in
        return num + adder
    }
}

let addTwo = addTo(2)    // addTwo: Int -> Int”
let result = addTwo(6)

Sequence

Swift 的 for...in 可以用在所有实现了 Sequence 的类型上，实现 Sequence 你首先需要实现一个 IteratorProtocol
for...in 内部实现思路：
var iterator = arr.makeIterator()
while let obj = iterator.next() {
   print(obj)
}

escaping

Swift 中我们可以定义一个接受函数作为参数的函数，而在调用时，使用闭包的方式来传递这个参数是常见手段：
最简单的形式的闭包其实还默认隐藏了一个假设，block 的调用是同步行为。如果将 block 放到一个 Dispatch 中去，让它在返回后被调用的话，我们就需要在 block 的类型前加上 @escaping 标记来表明这个闭包是会“逃逸”出该方法的：
func doWorkAsync(block: @escaping ()->()) {
    DispatchQueue.main.async {
        block()
    }
}

由于需要确保闭包内的成员依然有效，如果在闭包内引用了 self 及其成员的话，Swift 将强制我们明确地写出 self;   [weak self]
（注意：如果你在协议或者父类中定义了一个接受 @escaping 为参数方法，那么在实现协议和类型或者是这个父类的子类中，对应的方法也必须被声明为 @escaping，否则两个方法会被认为拥有不同的函数签名）

命名空间

Swift 的命名空间是基于 module 而不是在代码中显式地指明，每个 module 代表了 Swift 中的一个命名空间。也就是说，同一个 target 里的类型名称还是不能相同的。在我们进行 app 开发时，默认添加到 app 的主 target 的内容都是处于同一个命名空间中的，我们可以通过创建 Cocoa (Touch) Framework 的 target 的方法来新建一个 module

另一种策略是使用类型嵌套的方法来指定访问的范围。常见做法是将名字重复的类型定义到不同的 struct 中，以此避免冲突。这样在不使用多个 module 的情况下也能取得隔离同样名字的类型的效果

方法嵌套

func makeIncrementor(addNumber: Int) -> ((inout Int) -> Void {
    func incrementor(inout variable: Int) -> Void {
        variable += addNumber;
    }
    return incrementor;
}

初始化方法顺序

某个类的子类中，初始化方法里语句顺序并不是随意的，需要保证在当前子类实例的成员初始化完成后才能调用父类的初始化方法：

一般来说，子类的初始化顺序是：
1.设置子类自己需要初始化的参数，
2.调用父类的相应的初始化方法，super.init()
3.对父类中的需要改变的成员进行设定

命名空间

Swift 的命名空间是基于 module 而不是在代码中显式地指明，每个 module 代表了 Swift 中的一个命名空间。也就是说，同一个 target 里的类型名称还是不能相同的。在我们进行 app 开发时，默认添加到 app 的主 target 的内容都是处于同一个命名空间中的，我们可以通过创建 Cocoa (Touch) Framework 的 target 的方法来新建一个 module

Designated，Convenience 和 Required

在 OC 中，init 方法是非常不安全的,Apple 也明确说明了不应该在 init 中使用属性来访问，但是这并不是编译器强制的，因此还是会有很多开发者犯这样的错误。

所以 Swift 有了严格的初始化方法。一方面，强化了 designated 初始化方法的地位。Swift 中不加修饰的 init 方法都需要在方法中保证所有非 Optional 的实例变量被赋值初始化，而在子类中也强制 (显式或者隐式地) 调用 super 版本的 designated 初始化，所以无论如何走何种路径，被初始化的对象总是可以完成完整的初始化的。

注意在 init 里可以对 let 的实例常量赋值，这是初始化方法的重要特点。在 Swift 中 let 声明的值是常量，无法被赋值，这对于构建线程安全的 API 十分有用。而因为 Swift 的 init 只可能被调用一次，因此在 init 中我们可以为常量进行赋值，而不会引起任何线程安全的问题。

convenience 的初始化方法是不能被子类重写或者是从子类中以 super 的方式被调用的。

希望子类中一定实现的 designated 初始化方法，可以添加 required 关键字限制，强制子类对这个方法重写实现。这样做的最大的好处是可以保证依赖于某个 designated 初始化方法的 convenience 一直可以被使用。

static 和 class

在 protocol 里定义一个类型域上的方法或者计算属性的话，应该用 static 定义,因为在struct 或 enum 中使用 static

结论：在任何时候使用 static 应该都是没有问题的

可变参数函数

可变参数函数指的是可以接受任意多个参数的函数，我们最熟悉的可能就是 NSString 的 -stringWithFormat: 方法了。
 Swift 写一个可变参数的函数只需要在声明参数时在类型后面加上 ... 就可以了。

func sum(input: Int...) -> Int {
  return input.reduce(0, +)
}
print(sum(input: 1,2,3,4,5))

限制:在同一个方法中只能有一个参数是可变的，比如可变参数都必须是同一种类型的等。对于后一个限制，当我们想要同时传入多个类型的参数时就需要做一些变通(使用Any类型)。

初始化返回 nil

Swift 中默认初始化方法是不能写 return 语句来返回值的，也就是说我们没有机会初始化一个 Optional 的值。
可能返回 nil 的 init 方法都加上了 ? 标记：
convenience init?(string URLString: String)

typealias

typealias 是用来为已经存在的类型重新定义名字的，使代码变得更加清晰。
typealias 是单一的，必须指定将某个特定的类型通过 typealias 赋值为新名字，不能将整个泛型类型进行重命名。
错误代码:
class Person<T> {}
typealias Worker = Person
typealias Worker = Person<T>

不过如果我们在别名中也引入泛型，是可以进行对应的：
// This is OK
typealias Worker<T> = Person<T>

另一个使用场景是某个类型同时实现多个协议的组合时。我们可以使用 & 符号连接几个协议，然后给它们一个新的更符合上下文的名字，来增强代码可读性:
protocol Cat { ... }
protocol Dog { ... }
typealias Pat = Cat & Dog”

func 的参数修饰

Swift 默认所有参数都是 let 的。这样不仅可以确保安全，也能在编译器的性能优化上更有作为。
func incrementor(variable: let Int) -> Int {

希望在方法内部直接修改输入的值
func incrementor(variable: inout Int) {

var luckyNumber = 7
incrementor(variable: &luckyNumber)

autoclosure

@autoclosure 做的事情就是把一句表达式自动地封装成一个闭包 (closure)
func logIfTrue(_ predicate: @autoclosure () -> Bool) {
    if predicate() {
        print("True")
    }
}
logIfTrue(2 > 1)调用，Swift 将会把 2 > 1 这个表达式自动转换为 () -> Bool
(@autoclosure 并不支持带有输入参数的写法，也就是说只有形如 () -> T 的参数才能使用这个特性进行简化。)

protocol 的方法声明为 mutating

Swift 的 protocol 不仅可以被 class 类型实现，也适用于 struct 和 enum。
mutating 关键字修饰是为了能在该方法中修改 struct 或是 enum 的变量
（因为这个原因，oc和swift混编的情况下，尽量声明class保持统一性）

多元组 (Tuple)

原始：
func swapMe1<T>( a: inout T, b: inout T) {”
  let temp = a
  a = b
  b = temp
}
元祖：
func swapMe2<T>( a: inout T, b: inout T) {”
   (a,b) = (b,a)
}

后半部

隐式解包 Optional

一切都是历史的错。因为 Objective-C 中 Cocoa 的所有类型变量都可以指向 nil 的，部分 Cocoa 的 API 中在参数或者返回时即使被声明为具体的类型，但是还是有可能在某些特定情况下是 nil，而同时也有另一部分 API 永远不会接收或者返回 nil。在 Objective-C 时，这两种情况并没有被加以区别，因为 Objective-C 里向 nil 发送消息并不会有什么不良影响。在将 Cocoa API 从 Objective-C 转为 Swift 的 module 声明的自动化工具里，是无法判定是否存在 nil 的可能的，因此也无法决定哪些类型应该是实际的类型，而哪些类型应该声明为 Optional。
我们的代码的其他部分，还是少用这样的隐式解包的 Optional 为好，很多时候多写一个 Optional Binding 就可以规避掉不少应用崩溃的风险。

模式匹配

Swift 的 switch 就是使用了 ~= 操作符进行模式匹配，case 指定的模式作为左参数输入，而等待匹配的被 switch 的元素作为操作符的右侧参数,只不过这个调用是由 Swift 隐式地完成的。
 switch 的几种常见用法吧：
 switch password {
     case "akfuv(3": print("密码通过")
     case nil: print("没值")
     case -1.0...1.0: print("区间内")
     case let x where x.hasPrefix("王"): print("\(x)是笔者本家")
     default:        print("验证失败")
}

lazy 修饰符和 lazy 方法

class ClassA {
    lazy var str: String = {
        let str = "Hello"
        return str
    }()
}
简化：
lazy var str: String = "Hello

default 参数

Swift 的方法是支持默认参数的，也就是说在声明方法时，可以给某个参数指定一个默认使用的值。在调用该方法时要是传入了这个参数，则使用传入的值，如果缺少这个输入参数，那么直接使用设定的默认值进行调用。

当我们指定一个编译时就能确定的常量来作为默认参数的取值时，这个取值是隐藏在方法实现内部，而不应该暴露给其他部分。

AnyClass，元类型和 .self

Swift 中，.self 可以用在类型后面取得类型本身，也可以用在某个实例后面取得这个实例本身。
class A {}
let typeA: AnyClass = A.self

.Type 表示的是某个类型的元类型，而在 Swift 中，除了 class，struct 和 enum 这三个类型外，我们还可以定义 protocol。对于 protocol 来说，有时候我们也会想取得协议的元类型。这时我们可以在某个 protocol 的名字后面使用 .Protocol 来获取，使用的方法和 .Type 是类似的。

final

final 关键字可以用在 class，func 或者 var 前面进行修饰，表示不允许对该内容进行继承或者重写操作。
一般来说，不希望被继承和重写会有这几种情况：
1.类或者方法的功能确实已经完备了
2.子类继承和修改是一件危险的事情
3.为了父类中某些代码一定会被执行
4.性能考虑(有限)

Optional

enum Optional<T> : _Reflectable, NilLiteralConvertible {

    case None
    case Some(T)
    //...
}

属性观察

Swift 中为我们提供了两个属性观察的方法，它们分别是 willSet 和 didSet。
初始化方法对属性的设定，以及在 willSet 和 didSet 中对属性的再次设定都不会再次触发属性观察的调用，可以放心使用。
想在一个属性定义中同时出现 set 和 willSet 或 didSet 是一件办不到的事情。

... 和 ..<

在 Swift 中，除了数字以外另一个实现了 Comparable 的基本类型就是 String。也就是说，我们可以通过 ... 或者 ..< 来连接两个字符串。
let interval = "a"..."z

Reflection 和 Mirror

熟悉 Java 的读者可能会知道反射 (Reflection)。这是一种在运行时检测、访问或者修改类型的行为的特性。
Objective-C 中我们不太会经常提及到 “反射” 这样的词语，因为 Objective-C 的运行时比一般的反射还要灵活和强大。可能很多读者已经习以为常的像是通过字符串生成类或者 selector，并且进而生成对象或者调用方法等，其实都是反射的具体的表现。