Swift3.0新特性和改动

前两天的WWDC 2016上苹果发了：Swift 3.0 Preview 1 Released!，此次更新了44个特性。有增删一些语法得，有改动的，本身从Swift2和Xcode6开始学习Swift一直很喜欢这门语言。也老是看别人的东西，此次也是第一次主动尝试翻译一些文章，但愿翻译点东西方便别人学习Swift。持续更新。

英文原版的Github连接点这里

下面正式开始逐条翻译：

SE-0002: Removing currying func declaration syntax 移除了currying func，（译者注：这个概念JavaScript和scala也有，scala里叫："柯里化"我刚看到这个单词还觉得是纳闷，怎么和库里名字同样。这是比较广泛的一个概念，我本身也不是十分清楚，可是有例子，例子仍是比较容易理解）。移除的缘由官方解释说它增长了语言的复杂性，因此移除了。具体请看下面的例子。

如下是对比代码：

// 以前能够这么写:
  func curried(x: Int)(y: String) -> Float {
    return Float(x) + Float(y)!
  }

  // 如今能够改成:（译者注：实际上是改为改了用闭包实现）
  func curried(x: Int) -> (String) -> Float {
    return {(y: String) -> Float in
      return Float(x) + Float(y)!
    }
  }

SE-0003: Removing var from Function Parameters 移除了声明函数的时候用var修饰形参，以区别在函数形参中var和inout。 关于这条改动苹果官方说这个改动和刚开始的时候提的建议是不一致的，早先是要从这个refutable patterns（这个功能还不了解）移除var的，可是在mutation patterns里这种东西用的不少了，苹果官方决定不改这部分，而是把它从函数声明中移除了。

如下是对比代码：

func doSomethingWithVar(var i: Int) {
  i = 2 // 此时i改变了可是调用者的值并无改变
}

func doSomethingWithInout(inout i: Int) {
  i = 2 // 这种用inout修饰的会把i的值会写给调用者
}

// 下面的栗子可能更清楚一些
var x = 1
print(x) // 1

doSomething**WithVar**(x)
print(x) // 1

doSomething**WithInout**(&x)
print(x) // 2

函数形参中用inout修饰的参数若是改动会回写给调用者，而var不会

SE-0004: Remove the ++ and -- operators 移除了++和--，官方的说法是：这是从C中带来的，开发人员当时就这么写了，后来也没有人留意这个状况。可是如今他们注意到一些问题，请看下面的例子。

对比例子以下：

let a = ++x  // pre-increment  - +1以后再返回
let b = x++  // post-increment - +1以前就返回
let c = --x  // pre-decrement  - -1以后再返回
let d = x--  // post-decrement - -1以前就返回

苹果的官方解释说：你们总这么用，可是不多有人真正关注到++在以前和以后的区别，容易弄混淆，因此移除了。固然这种操做符也是有好处的原文有对比有点和缺点。

SE-0005: Better Translation of Objective-C APIs Into Swift 这条主要是说将类C语言（原文是：“Clang”，包括OC，C和C++）的函数，方法，类型，属性的名字导入转换成Swift语言的时候更Swift一些。由于OC的设计语言的原则和Swift是不同的，苹果会使用一些简单的语言分析二者的不一样，而后导入成Swift语言的时候将OC的代码的命名改的更Swift一些。

SE-0006: Apply API Guidelines to the Standard Library 这条对如今的代码影响比较大 Swift API Design Guidelines：Swift API的设计原则已经做为Swift3的一部分在开发了，由于Swift标准库多是程序里用到的最多的API了。因此Swift标准库API应该是遵照Swift API设计原则，因此开发人员review了整个Swift标准库，作了一些改进使得他们更符合Swift API设计原则。

这条改动对2.x的代码影响很是大，由于标准库里一些函数和变量名字都改了，一下列举一部分方便你们理解这个改动：

一、不少地方用到的generator改为了iterator，还有一个都是数组中的sort() => sorted(), sortInPlace() => sort() 二、不少协议中的的后缀Type都被移除了，好比： ``` 减号表示移除，加号是新增的 -public protocol SequenceType { ... } +public protocol Sequence { ... }

-public protocol CollectionType : ... { ... }
+public protocol Collection : ... { ... }
```

三、标准库里的静态的属性和枚举的变量名都变成小写的了 ``` public struct Float { - public static var NaN: Float + public static var nan: Float }

public enum FloatingPointClassification {
    - case QuietNaN
    + case quietNaN

    - case NegativeSubnormal
    + case negativeSubnormal

    - case NegativeZero
    + case negativeZero

```

四、一些Collection，Sequence，iterator适配器的初始化方法被移除了，推荐相关类的方法和算法函数来代替。就是移除了一些类的init()方法，推荐用其余的方法，其中推荐方法的返回值和参数都没变。

```
public struct LazyFilterIterator<Base : IteratorProtocol> : ... {
    - public init(
    - _ base: Base,
    - whereElementsSatisfy predicate: (Base.Element) -> Bool
    )
 }
// init 移除了，调用 `.lazy.filter` 代替.

 public struct RangeIterator<Element : ForwardIndex> : ... {
    - public init(_ bounds: Range<Element>)
    // init移除了，用 'generate()' 这个方法代替.
 }

 public struct ReverseCollection<Base : ...> : ... {
    - public init(_ base: Base)
    // Use the 'reverse()' method on the collection.
 }
```

五、还有几个改动函数名字的我一并列举了： reverse() => reversed() enumerate() => enumerated() SequenceType.minElement() => .min(), .maxElement() => .max() SE-0007: Remove C-style for-loops with conditions and incrementers 这条是说：把 for-loops 移除了，也就是这种for(val i = 0 ; i < 10 ; i++)，推荐使用for in 文中说了一些历史缘由，以及for-loops的好处和坏处，但总之是移除了。

SE-0008: Add a Lazy flatMap for Sequences of Optionals 这条是说：Swift标准库里有两个flatMap来构造一个新的序列(Sequence 数组和集合的统称)一种是调用的序列里都是肯定值不带Optional的，另一种是带Optional的。可是能够处理Optional类型的序列的flatMap没有提供一个lazy方法，此次加上了。有点绕，具体看下面的栗子：

-------------------------------Swift 3.0以前-----------------------------
```
[1, 2, 3]
.flatMap { n in n..<5 } 
// [1, 2, 3, 4, 2, 3, 4, 3, 4]
这是第一种，没有Optional的flatMap

(1...10)
.flatMap { n in n % 2 == 0 ? n/2 : nil }
// [1, 2, 3, 4, 5]
这是第二种，模拟出来的nil带Optional的flatMap，可是只有第一种有lazy的，第二种不带。
```

-------------------------------Swift 3.0以后-----------------------------
增长了第二种flatMap的lazy实现（这种实现实际上是一个开发者提出来的，详情[输入连接说明](http://thread.gmane.org/gmane.comp.lang.swift.evolution/9365)），具体实现以下（原文里有好几种可用的实现方法）：
```
// 基本上采用了那位网友的实现方法，用了一个map-filter-map链解决问题的。
extension LazySequenceType {
  @warn_unused_result
  public func flatMap<T>(transform: Elements.Generator.Element -> T?)
    -> LazyMapSequence<LazyFilterSequence<LazyMapSequence<Elements, T?>>, T> {
      return self
        .map(transform)
        .filter { opt in opt != nil }
        .map { notNil in notNil! } // filter后仍是Optinal类型的，显式的解包一下。
  }
}
```

SE-00016: Add initializers to Int and UInt to convert from UnsafePointer and UnsafeMutablePointer 这条是说：原来UnsafePointer 和 UnsafeMutablePointer这两个类里面有init方法将其转换成Int和Uint，可是Int和Uint里却没有与之对应的转换成UnsafePointer 和 UnsafeMutablePointer的init方法。这条对现有的代码无任何影响。 代码入下：

```
// 这些实现是基于ptrtoint_Word的内置函数
extension UInt {
  init<T>(bitPattern: UnsafePointer<T>) {
    self = UInt(Builtin.ptrtoint_Word(bitPattern._rawValue))
  }

  init<T>(bitPattern: UnsafeMutablePointer<T>) {
    self = UInt(Builtin.ptrtoint_Word(bitPattern._rawValue))
  }

  init(bitPattern: OpaquePointer) {
    self = UInt(Builtin.ptrtoint_Word(bitPattern._rawValue))
  }
}

extension Int {
  init<T>(bitPattern: UnsafePointer<T>) {
    self = Int(Builtin.ptrtoint_Word(bitPattern._rawValue))
  }

  init<T>(bitPattern: UnsafeMutablePointer<T>) {
    self = Int(Builtin.ptrtoint_Word(bitPattern._rawValue))
  }

  init(bitPattern: OpaquePointer) {
    self = Int(Builtin.ptrtoint_Word(bitPattern._rawValue))
  }
}
```

这俩类我么有用过，对C也不太熟悉，你们仍是看具体例子吧。可是苹果的开发人员对此有个解释为啥要加这么个方法：目前Swift缺少执行复杂的指针操做的能力，像检查指针的范围，给指针打标签，指针作XOR操做。做为一门系统编程语言，Swift应该可以能简明直接的解决这些问题。另一些C语言的函数把intptr_t 和 uintptr_t做为参数，可是Swift并不能直接调用这些函数，用户须要用C语言对调用进行封装。基于这些Swift决定增长以上init方法。

SE-00016: Change Unmanaged to use UnsafePointer 使用Unmanaged的地方要改为用UnsafePointer了，这个改动也是和C语言api相关。

受影响的是如下两个方法，这两个方法是(这俩是将COpaquePointer和Unmanaged互相转换的):

static func fromOpaque(value: COpaquePointer) -> Unmanaged<Instance>
func toOpaque() -> COpaquePointer

对现有的代码的影响比较小：现存的用COpaquePointer调用Unmanaged的方法须要改为用UnsafePointer。 COpaquePointer类型的变量能够用一个可用的属性来保留，以帮助转换。具体用法入下：

@available(*, unavailable, message="use fromOpaque(value: UnsafeMutablePointer<Void>) instead")
@available(*, unavailable, message="use toOpaque() -> UnsafePointer<Void> instead")