WWDC2015 -- What's New in Sw

2016-02-23 本文已影响103人嘻嘻zhy

标签（空格分隔）： WWDC

Swift2的目标

希望Swift语言核心的特性和行为以及它的工具变好。
编写优秀的和安全的代码
富有表现力的库与API

五个在Swift中新特性

Fundamentals
Pattern Matching
Availability Checking
Protocal Extensions
Error Handling

Fundamentals

enum  Animals{
case Dog,Car,Dragon
}
let a = Animals.Dragon
print(a)

枚举携带更多信息，而且可以打印出来。

enum Either<T1,T2>{
case First(T1)
case Second(T2)
}

可以用相关值关联方式创建数组。

enum Tree<T> {
  case Leaf(T)
indirect case Node(Tree, Tree) 
}

递归支持。

do {
  ...
  ...
}while()

repeat {
  let a = Animals.Troll
  ...
}while()

用repeat-while代替了do-while，从字面上意义更加明确。也避免与异常处理混淆。

Swift 1:

   viewAnimationOptions = .Repeat | .CurveEaseIn | .TransitionCurlUp
   viewAnimationOptions = nil
   if viewAnimationOptions & .TransitionCurlUp != nil {

Swift2:

   viewAnimationOptions = [.Repeat, .CurveEaseIn, .TransitionCurlUp]
   viewAnimationOptions = []
   if viewAnimationOptions.contains(.TransitionCurlUp) {

对于选项设置，用集合代替了位操作符。变得简单又强大。

struct MyFontStyle : OptionSetType {
    let rawValue : Int
    static let Bold = MyFontStyle(rawValue: 1)
    static let Italic = MyFontStyle(rawValue: 2)
    static let Underline  = MyFontStyle(rawValue: 4)
    static let Strikethrough = MyFontStyle(rawValue: 8)
}
var myFont :MyFontStyle = MyFontStyle()
myFont = []
myFont = [.Underline]
myFont = [.Bold, .Italic]
if myFont.contains(.Strikethrough) {
}

注意这里的rawValue为数值相加。

func save(name: String, encrypt: Bool) { ... }

class Widget {
func save(name: String, encrypt: Bool) { ... } 
···
}
save("thing", encrypt: false)
widget.save("thing", encrypt: false)

将方法与函数统一为单一的函数声明。
统一了函数参数标签。

func save(name: String, encrypt: Bool) {  }
save("123", encrypt: false)

func save(name name: String, encrypt: Bool) {  }
save(name: "123", encrypt: true)

func save(name: String, _ encrypt: Bool) {  }
save("123", true)

命名方式对使用方式的影响。

struct MyCoordinates {
    var points : [CGPoint]
    func updatePoint() {
        points[42].x = 19
    }
}

编译器更新，能够对以前不能识别的错误进行诊断。


var abc= ···

let size = abc 

var indices = abc
indices.sort()

对三种情况进行提示。

不会被修改的变量使用了var提示使用let。
从来没有被使用的变量。
方法的返回值没有被使用。

//SDK Improvements

class func requestHeaderFieldsWithCookies(cookies: [AnyObject]!)
     -> [NSObject : AnyObject]!
     
//现在为
class func requestHeaderFieldsWithCookies(cookies: [AnyObject] )
     -> [NSObject : AnyObject]
     
//使用时
class func requestHeaderFieldsWithCookies(cookies: [NSHTTPCookie]) 
-> [String: String]

采纳了新的特性与更好的规则：

Nullability修饰。
Objective-C 类型集合。
NS_ENUM, NS_OPTIONS, instancetype, @property, etc。

 @testable
 import MyApp

Swift1中如果需要测试，需要将内容设置为public，但其实很多内容不应该被public。现在在测试中这么写，就能解决问题。

/**：
 
 ##可以使用MarkDown方式进行注释
 
 ####真的可以
 
 - 1
 - 2
 - 3
  
 >print（"Hello World"）
  
 */
class Hello {
}

可以用MarkDown的方式进行注释。这是一个伟大的，著名的，非常受欢迎，可爱的语法。

可以将Swift1自动转化为Swift2

Pattern Matching

func prepareForSegue(segue: UIStoryboardSegue, sender: AnyObject?) {
    if let dest = segue.destinationViewController as? BlogViewController
...
    } 
}

if-let 语句使用。

func prepareForSegue(segue: UIStoryboardSegue, sender: AnyObject?) {
    if let dest = segue.destinationViewController as? BlogViewController{
if let blogIndex = tableView.indexPathForSelectedRow()?.row { if segue.identifier == blogSegueIdentifier {
                dest.blogName = swiftBlogs[blogIndex]
                ...
                ...
             }
        }
    }
}

如果嵌套太多会对结构产生如同金字塔一样的灾难。

func prepareForSegue(segue: UIStoryboardSegue, sender: AnyObject?) {
    if let dest = segue.destinationViewController as? BlogViewController
if let blogIndex = tableView.indexPathForSelectedRow()?.row { if segue.identifier == blogSegueIdentifier {
                dest.blogName = swiftBlogs[blogIndex]
                ...
                ...
            } 
        }
    }
}

在swift1.2中引入复合条件语句，这使得代码显得比较自然。
可以检查多个自选和布尔条件合适的嵌入。虽然比之前好但是这并没有解决早期存在的问题。


func process(json: AnyObject) -> Either<Person,String> {
    guard let name = json["name"] as? String else {
        return .Second("missing name")
    }
     guard let year = json["year"] as? Int else{
        return .Second("missing year")
    }
    let person = processPerson(name, year)
    return .First(person)
}

//可以合并书写
func process(json: AnyObject) -> Either<Person,String> {
    guard let name = json["name"] as? String,
          let year = json["year"] as? Int else {
        return .Second(“bad input”)
    }
    let person = processPerson(name, year)
    return .First(person)
}

引入了新的Guard语句，使用Guard-else，将许多工作在Guard语句中声明，同时检查多个语句，更加简洁，也是更好提前结束的方式。

enum Animals{
    
    
    case Dog(Int) ,Car(String),Dragon(Float)
}

func myDog()->Animals
{
    return Animals.Dog(5)
}
switch Dog() {
case .Dog(let value)  where value != 42:
    print(value)
······
default: break
    
}
//可以只对一个条件判断
if case .Dog(let value) = myDog() where value != 42 {
    print(value)
}

使用switch的时候我们需要详细的描述各种条件，但是如果只需要等于一种case进行判断，可以缩写。

//以前的方式
for value in mySequence {
    if value != "" {
        doThing(value)
    }
}
//新的方式1
for value in mySequence where value != "" {
    doThing(value)
}
//新的方式2
for case .MyEnumCase(let value) in enumValues {
    doThing(value)
}

为了快速的循环做了两件事。

加入内联能力。
更强大的条件匹配。

API Availability Checking

在不抛弃用户的情况下利用新的能力
简单而且丰富的检查
通过语言静态的实现

@IBOutlet var dropButton: NSButton!
override func awakeFromNib() {
  dropButton.springLoaded = true
}

springLoaded这个API是在MAC OS 10.10.3中后出现，如果程序中这么写，如果使用的系统环境低于10.10.3就会出错。

@IBOutlet var dropButton: NSButton!
override func awakeFromNib() {
  if dropButton.respondsToSelector("setSpringLoaded") {
      dropButton.springLoaded = true
  }
}

用respondsToSelector去检查方法是一种很常见的解决方式，但是这种方式并不够好，是棘手的、容易出错的模式。比如我忘记方法的名称或者拼写错误。

error: springLoaded is only available on Mac OS X 10.10.3 or later

在Swift2中，编译器会更具你的minimum deployment target去判断是否能够使用所有的API。上面就是判断的结果。

@IBOutlet var dropButton: NSButton!
override func awakeFromNib() {
    if #available(OSX 10.10.3, *) {
        dropButton.springLoaded = true
    }
}

加入了新的#available判断条件，可以直接根据运行环境判断是否使用。

Protocal Extensions

在标准库中更多持久化的方法使用
新的有效的设计模式

extension Array{
func countIf(match: Element ->Bool) -> Int {
        var n = 0
        for value in self {
            if match(value) { n++ }
        }
        return n
    }
}

扩展是一个非常强大的功能，迅速。可以采取任意类型的数组，并添加我自己的方法。当我添加一个扩展，我真的增加了新的功能，感觉只是作为第一类，只是作为核心的类型的任何类型的设计师可能已经添加了。


func countIf(match: <CollectionType>){collection:T,match: T.Generator.Element->Bool) -> Int {
    var n = 0
    for value in self {
        if match(value) { n++ }
    }
return n }

该方法是一个全局函数。

这是一个额外的语法，可能会被忽略使用。
在Array方法实现时并不会显示在数组中的任何功能列表中。

extension CollectionType {
func countIf(match: Element -> Bool) -> Int {
        var n = 0
        for value in self {
            if match(value) { n++ }
        }
return n }
}

在Swift2中，我们可以直接对协议进行扩展，这样所有支持协议的类都能使用该方法。

let numbers = [1,2,3,4]

//swift1
let x = filter(map(numbers) { $0 * 3 }) { $0 >= 0 }

//swift2
let x = numbers.map { $0 * 3 }.filter { $0 >= 0 }

全局的泛型方法变为函数。

Error Handling

在Swift上很很大提升空间的地方

安全性
可读性
编写性

共同的问题

太容易忽视错误
重复的，有错误倾向的模式
很难去思考隐晦的行为

错误的种类

琐碎的小错误
逻辑错误
可以被知道细节可以被发现的错误

func preflight() {
    url.checkResourceIsReachable()
    resetState()
}

这个方法中url.checkResourceIsReachable()可能会失败。如果使用NSError呢会怎样？

func preflight(inout error: NSError?) -> Bool {
    if url.checkResourceIsReachableAndReturnError(&error) {
        return false
    }
    resetState()
    return true
}

原本只有两行简单的代码现在拓展了很多内容，有了if语句的嵌套，并且有许多格外的参数。
在没有编译器帮助的情况下，手动操作加上返回条件。
只能在返回false的时候会发生错误，而我只是想知道错误的方式。

显然checkResourceIsReachableAndReturnError能出错。
显然preflight方法能够出错。
所有的控制流都清晰。（并不需要知道所有的情况）

func preflight() throws {
    try url.checkResourceIsReachable()
    resetState()
}

在可能出错的语句前加上try。
抛出异常，但没有处理异常。
如果需要处理异常呢？

func preflight() -> Bool {
    do {
        try url.checkResourceIsReachable()
        resetState()
        return true
    } catch let error {
        return false
    } 
}

使用do-catch语句处理,将错误储存为error。


func preflight() -> Bool {
    do {
        try url.checkResourceIsReachable()
        resetState()
        return true
    } catch NSURLError.FileDoesNotExist {
        return true
    } catch let error {
        return false
    } 
}

可以对于指定的错误进行处理。


func preflight() {
    try! url.checkResourceIsReachable()
    resetState()
}

如果遇到很严重的致命错误，抛出后程序会崩溃，可以使用try！，这样虽然进行了处理实际上没有抛出错误。

ErrorType is a protocol in the Swift standard library
我们能够用枚举创建自己的错误类型准守协议

enum DataError : ErrorType {
    case MissingName
    case MissingYear
    // add more later
}

func processPerson(json: AnyObject) -> Either<Person,String> {
  guard let name = json["name"] as? String {
    return .Second("missing name")
  }
  guard let year = json["year"] as? Int {
    return .Second("missing year")
}
  return .First(Person(name, year))
}

可以改为

func processPerson(json: AnyObject) -> Either<Person,String> {
  guard let name = json["name"] as? String {
    throw DataError.MissingName
  }
  guard let year = json["year"] as? Int {
    throw DataError.MissingYear
}
  return .First(Person(name, year))
}

并且修改返回值，因为不需要再使用Either了。

func processPerson(json: AnyObject) throws -> Person {
  guard let name = json["name"] as? String {
    throw DataError.MissingName
  }
  guard let year = json["year"] as? Int {
    throw DataError.MissingYear
}
  return Person(name, year)
}


func processSale(json: AnyObject) throws {
  delegate?.didBeginReadingSale()
  guard let buyerJSON = json["buyer"] as? NSDictionary {
    throw DataError.MissingBuyer
  }
  let buyer = try processPerson(buyerJSON)
  guard let price = json["price"] as? Int {
    throw DataError.MissingPrice
  }
  delegate?.didEndReadingSale()
  return Sale(buyer, price)
}

我在这个方法中我需要加上个代理，在开始与结束的时候处理。
但是如果出现错误以及异常，会在delegate?.didEndReadingSale()执行之前就需要跳出。

func processSale(json: AnyObject) throws {
  delegate?.didBeginReadingSale()
  guard let buyerJSON = json["buyer"] as? NSDictionary {
    delegate?.didEndReadingSale()
    throw DataError.MissingBuyer
  }
  let buyer : Person
  do {
buyer = try processPerson(buyerJSON) } catch { 
    delegate?.didEndReadingSale()
throw error }
  guard let price = json["price"] as? Int {
    delegate?.didEndReadingSale()
 throw DataError.MissingPrice
   return Sale(buyer, price)
}

需要在每一个跳出方法的地方添加上delegate。
繁琐而且容易出错。

func processSale(json: AnyObject) throws {
  delegate?.didBeginReadingSale()
  defer { delegate?.didEndReadingSale() }
  guard let buyerJSON = json["buyer"] as? NSDictionary {
    throw DataError.MissingBuyer
  }
  let buyer = try processPerson(buyerJSON)
  guard let price = json["price"] as? Int {
    throw DataError.MissingPrice
  }
  return Sale(buyer, price)
}

这时候我们只需要将需要执行的代码放入defer中，只要在方法结束时就会自动触发defer执行。

『Exception handling』schemes

任何都能被抛出。
性能与异常非常相关，并且成反比。

Swift的错误处理更加平衡

Not table-based unwinding。
与if判断语句的性能相近。

Swift用Cocoa API的错误处理设计非常优雅。
能够自动识别在Cocoa中常见的约定。

//Swift1
extension NSIncrementalStore {
func loadMetadata(error: NSErrorPointer) -> Bool
}
//Swift 2:
 extension NSIncrementalStore {
   func loadMetadata() throws
}

//Swift 1:
extension NSData {
class func bookmarkDataWithContentsOfURL(bookmarkFileURL: NSURL, 
-> NSData? }
//Swift 2:
extension NSData {
class func bookmarkDataWithContentsOfURL(bookmarkFileURL: NSURL) throws
-> NSData }

例如，方法有一个NSError参数并返回bool类型。
自动添加throw方法并取消bool返回值。
同样，如果它返回一个可选的结果，我们认识到，返回值为零表示无效的东西，它不再返回一个可选的结果，归入错误处理。
正是在这2个非常简单的规则，我们发现绝大多数的在系统中的API与新的Swift错误处理模型结合变得【无缝】而且【美观】，我们认为在Swift中这是一个伟大的新的方式来处理错误。