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的代码影响非常大，因为标准库里一些函数和变量名字都改了，一下列举一部分方便大家理解这个改动：

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

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

3、标准库里的静态的属性和枚举的变量名都变成小写的了 ``` 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

```

4、一些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.
 }
```

5、还有几个改动函数名字的我一并列举了： 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,3,4,4]
这是第一种，没有Optional的flatMap

(1...10)
.flatMap { n in n % 2 == 0 ? n/2 : nil }
// [1,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(*,message="use toOpaque() -> UnsafePointer<Void> instead")

Swift3.0新特性和改动

猜你在找的Swift相关文章