Swift学习之路03-基础，闭包

基础变量

• let 常量 var变量
• 类型标注 var welcomeMessage: String

数值

• 一个十进制数字，没有前缀
• 一个二进制数,前缀是 0b
• 一个八进制数,前缀是 0o
• 一个十六进制数,前缀是 0x

let decimalInteger = 17 
let binaryInteger = 0b10001 
let octalInteger = 0o21 // 八进制的17
let hexadecimalInteger = 0x11 // 十六进制的17

元组

• 元组（tuples）把多个值组合成一个复合值。元组的值可以是任意类型，并不要求是相同类型

let http404Error = (404,"Not Fount")
//你也可以讲一个元组的内容分解（decompose）成单独的常亮
let (statusCode,statusMessage) = http404Error
print("The status code is (statusCode)")
print("The status message is (statusMessage)")
//如果你只需要一部分元组值，分解的时候可以把要忽略的部分用下划线（_）标记：
let (justTheStatusCode,_) = http404Error
print("The status code is (justTheStatusCode)")
//你也可以用下标表示
print("The status code is (http404Error.0)")
// 输出 "The status code is 404"
print("The status message is (http404Error.1)") // 输出 "The status message is Not Found"
//定义元组给每个元素定义名字
let http200Status = (statusCode: 200,description: "OK")
//通过元素名访问元素值
print("The status code is (http200Status.statusCode)")

可选类型

• 使用可选链（optionals）来处理值可能缺失的情况

//声明一个变量
var text: String
print(text) //报错因为text没用值所以会抱错
var text: String?
print(text) //打印nil

Swift的nil和Objectivie-C的nil并不一样。在OC中，nil代表一个指向不存在的对象的指针。在Swift中，nil不是指针——它是一个确定的值，用来表示值缺失。任何类型的可选状态都可以被设置为nil，不只是对象类型

当你确定可选类型确实包含值之后，你可以再可选的名字后面加一个感叹号（!）来获取值。这个惊叹号表示”我知道这个可选有值，请使用它。”这被称为可选值的强制解析

断言

• 在某些情况下，如果值缺失或者值并不满足特定条件，你的代码可能没办法执行。这时，你可以在你的代码中触发一个断言（assertion）来结束代码运行并通过调试来找到缺失的原因。

let age = -3
assert(age >= 3,"A person's age cannot be less than zero") //因为age < 0，所以断言会触发
assert(age >= 3) //断言也可以省略信息

注意
当代码使用优化编译的时候，断言将被禁用，例如Xcode中，使用默认的target Release配置选项来build时，断言将被禁用

函数

• 多重返回函数–返回一个元组
• 使用函数类型，在Swift中，使用函数类型就像使用其他类型一样。例如，你可以定义一个类型为函数的常亮或变量，并将适当的函数赋值给他

var mathFunction: (Int,Int) -> Int = addTwoInts
print("Result: (mathFunction(2,3))")

• 函数类型作为参数类型

func printMathResult(mathFunction: (Int,Int) -> Int,_ a: Int,_ b: Int) { print("Result: (mathFunction(a,b))") } printMathResult(addTwoInts,3,5) // prints "Result: 8"

• 函数类型作为返回类型(Function Types as Return Types)

func stepForward(input: Int) -> Int {
    return input + 1
}
func stepBackward(input: Int) -> Int {
    return input - 1
}

// 根据传入的bool值来返回指定的函数
func chooseStepFunction(backwards: Bool) -> (Int) -> Int {
    return backwards ? stepBackward : stepForward
}

var currentValue = 3
let moveNearerToZero = chooseStepFunction(currentValue > 0)
// moveNearerToZero now refers to the stepBackward() function

• 嵌套函数，嵌套函数可以定义在别的函数体中，默认情况下，嵌套函数对外界是不可见的，但是可以被他们的外围函数（enclosing function）调用。一个外围函数也可以返回它的某个嵌套函数，使得这个函数可以在其他域中被调用

func chooseStepFunction(backwards: Bool) -> (Int) -> Int {
    func stepForward(input: Int) -> Int { return input + 1 }
    func stepBackward(input: Int) -> Int { return input - 1 }
    return backwards ? stepBackward : stepForward
}
var currentValue = -4
let moveNearerToZero = chooseStepFunction(currentValue > 0)
// moveNearerToZero now refers to the nested stepForward() function
while currentValue != 0 {
    print("(currentValue)... ")
    currentValue = moveNearerToZero(currentValue)
}
print("zero!")
// -4...
// -3...
// -2...
// -1...
// zero!

闭包

• Swift 标准库提供了名为 sort 的方法,会根据您提供的用于排序的闭包函数将已知类型数组中的值进行排序。一 旦排序完成,sort( _ :) 方法会返回一个与原数组大小相同,包含同类型元素且元素已正确排序的新数组。原数组 不会被 sort( _ :) 方法修改。
  下面的闭包表达式示例使用 sort( _ :) 方法对一个 String 类型的数组进行字母逆序排序.

func compare(a: Int,b: Int) ->Bool {
    return a > b
}
var newArray = array.sort(compare)
var newArray = array.sort { (a,b) -> Bool in
    return a > b
}
print(newArray.description)

// 我自己写的sort方法
class SwiftClosure {
    // 定义一个闭包
    static func sort(array: Array<Int>,@noescape function:(a: Int,b: Int) -> Bool) -> Array<Int> {
        var newArray: Array<Int>
        newArray = []
        for i in 0...array.count - 1 {
            if newArray.count == 0 {
                newArray.append(array[i])
                continue
            }
            for j in 0...newArray.count - 1  {
                if function(a:array[i],b: newArray[j]) {
                    newArray.insert(array[i],atIndex: j)
                    break
                } else {
                    newArray.append(array[i])
                    break
                }
            }
        }
        return newArray
    }
}

//  外部调用
    override func viewDidLoad() {
        super.viewDidLoad()
        // Do any additional setup after loading the view,typically from a nib.
        var array:[Int] = [5,5,2,6,1]
        array = SwiftClosure.sort(array) { (a,b) -> Bool in
            return a > b
        }
        print(array.description)
        // print [6,1]
    }

• 闭包是引用类型，这意味着如果您将闭包赋值给了两个不同的常量或者变量，两个值都会指向同一个闭包
• 非逃逸闭包，当一个闭包作为参数传到一个函数中,但是这个闭包在函数返回之后才被执行,我们称该闭包从函数中逃逸。当你定义接受闭包作为参数的函数时,你可以在参数名之前标注 @noescape,用来指明这个闭包是不允许“逃 逸”出这个函数的。将闭包标注 @noescape 能使编译器知道这个闭包的生命周期(译者注:闭包只能在函数体中 被执行,不能脱离函数体执行,所以编译器明确知道运行时的上下文),从而可以进行一些比较激进的优化。

func someFunctionWithNoescapeClosure(@noescape closure: () -> Void) { closure() }

• block与闭包 block可以在外部定义方法，然后内部调用，获取某些值，也可以将某些值返回给外部，block需要在类名前用typealias给方法重新命名
  

typealias 是用来为已经存在的类型重新定义名字的，通过命名，可以使代码变得更加清晰。使用的语法也很简单，使用 typealias 关键字像使用普通的赋值语句一样，可以将某个已经存在的类型赋值为新的名字

import Foundation

// 包含Block的类
typealias funcBlock = (Array<Int>) -> () //或者 () -> Void

class SwiftClosure {

    var blockD: funcBlock?
    var newArray: Array<Int> = []

    // 定义一个闭包
    func sort(array: Array<Int>,@noescape function:(a: Int,b: Int) -> Bool,block: funcBlock) -> Void {
        newArray = []
        for i in 0...array.count - 1 {
            if newArray.count == 0 {
                newArray.append(array[i])
                continue
            }
            for j in 0...newArray.count - 1  {
                if function(a:array[i],b: newArray[j]) {
                    newArray.insert(array[i],atIndex: j)
                    break
                } else {
                    newArray.append(array[i])
                    break
                }
            }
        }
        blockD = block
    }

    func getNewArray()->Void {
        blockD!(newArray)
    }
}

// 调用含有Block的类
import UIKit

class ViewController: UIViewController {


    override func viewDidLoad() {
        super.viewDidLoad()
        // Do any additional setup after loading the view,typically from a nib.
        let array:[Int] = [5,1]
        let swiftClosure = SwiftClosure()
        swiftClosure.sort(array,function: { (a,b) -> Bool in
            return a > b
            }) { (newArray) -> () in
                print(newArray)
        }
        swiftClosure.getNewArray() // 调用这句话后控制台打印[6,5,2,1]
    }
}

我日了，写Swift写的不会写OC了!!!WTF

我日了，在Xcode中Swift跟OC一比，完全是Xcode不支持Swift啊！！！WTF