1. 闭包

** 闭包**
函数是闭包的一种
类似于OC语言中block
闭包的表达式（匿名函数）--能够捕获上下文中的值

语法：in 关键字的目的是便于区分返回值和执行语句
闭包的表达式类型和函数的类型一样，是参数加上返回值，也就是in 之前的一部分
{
（参数）-> 返回值类型 in
执行语句

}

完整的写法：

let say:(String) -> Void = {
    (name: String) -> Void in
    print("hi \(name)")

}
say("gaojun")

let say:(String) -> Void = {
    (name: String) -> Void in
    print("hi \(name)")

}
say("gaojun")

闭包表达式作为回调函数

传统数组排序写法

缺点：不一定是由小到大，不一定是全部比较，有可能只比较个位数，所以如何比较可以交给调用者决定

func bubbleSort (inout array:[Int])
{
    let count = array.count

    for var i = 1 ; i < count ; i++
    {
        for var j = 0 ; j < (count - i) ; j++
        {
            if array[j] > array[j + 1]
            {
                let temp = array[j]
            
                array[j] = array[j + 1]
            
                array[j + 1] = temp
            }
        }
    }
}

闭包写法

  func bubbleSort(inout array:[Int], cmp: (Int, Int) ->Int)
{
    let count = array.count

    for var i = 1 ; i < count ; i++
    {
        for var j = 0 ; j < (count - i) ; j++
        {
            if cmp(array[j], array[j + 1]) == -1
            {
        
                let temp = array[j]
            
                array[j] = array[j + 1]
            
                array[j + 1] = temp
            }
        }
    }
}

let cmp = {

    (a: Int, b: Int) -> Int in
    if a > b{
        return 1;
    }else if a < b {
    
        return -1

    }else{

        return 0
  }

}

var arr: Array<Int> = [31, 13, 52, 84, 5]

bubbleSort(&arr, cmp: cmp)

print(arr)

闭包作为参数传递

var arr1:Array<Int> =  [31, 13, 52, 84, 5]

bubbleSort(&arr1, cmp: {

    (a: Int, b: Int) -> Int in
    if a > b{
        return 1;
    }else if a < b {
    
        return -1
    
    }else{
    
        return 0
    }

})

** 尾随闭包**

如果闭包是最后一个参数，可以直接将闭包写到参数列表后面
这样可以提高阅读性，称之为尾随闭包

bubbleSort(&arr1
    ){

    (a: Int, b: Int) -> Int in
    if a > b{
        return 1;
    }else if a < b {
    
        return -1
    
    }else{
    
        return 0
    }
}

闭包表达式优化

1、类型优化，由于函数中已经声明了闭包的参数类型，所以传入的实参可以不用写类型

2、返回值优化，同理由于函数中已经声明了闭包的返回值类型，所以传入的实参可以不用写类型
3、参数优化，Swift可以使用$索引的方式来访问闭包的参数

bubbleSort(&arr1){

    if $0 > $1{

        return 1
    }else if $0 < $1{

        return -1
    }else{

        return 0
    }
}

 // 如果只有一条语句可以省略return

let hehe = {

    "我是gaojun"
}

** 闭包捕获值**

func getIncFunc() -> (Int) ->Int
{
    var max = 10

    func incFunc (x: Int) ->Int{

        print("incFunc函数结束")
    
        max++
    
        return max +  x
    }

/*
    当执行到这一句时inc参数就应该被释放了
    但是由于在内部函数中使用到了它，所以它被捕获了
    同理，当执行完这一句时max变量被释放了
    但是由于在内部函数中使用到了它，所以它被捕获了
*/

print("getIncFunc函数结束")
return incFunc
}

//被捕获的值回和与之对应方法绑定在一起 同一个方法中的变量会被绑定到不同的方法中

let incFunc = getIncFunc()

print("--------")

print(incFunc(5))

print("--------")

print(incFunc(5))

**输出结果: **

Snip20160301_6.png

2. 枚举

Swift中的枚举比OC中的枚举强大，因为Swift中的枚举是一等类型
它可以像类和结构体一样增加属性和方法
格式：

enum Method{

    case 枚举值
}

enum Method {

case Add, Sub, Mul, Div

}

// 可以使用枚举类型变量或常量接受枚举值

var m: Method = .Add

// 注意：如果变量或常量没有指定类型，那么前面必须加上该值属于哪个枚举类型

var m1 = Method.Add

// 利用Switch匹配
// 如果case中包含所有的值，可以不写default；如果case没有包含所有的值，必须写

switch (Method.Add){

case Method.Add:
    print("加法")
case Method.Sub:
    print("减法")
case Method.Mul:
    print("除法")
case Method.Div:
    print("乘法")
}

// 原始值
// OC中枚举的本质就是整数，所以OC中的枚举是有原始值的，默认是从0开始
// 而Swift中的枚举默认是没有原始值得，但是可以在定义时告诉系统让枚举有原始值

enum Method : 枚举值原始值类型{
    case 枚举值

}

enum Method2: Int{
    可以写在一起
    case Add, Sub, Mul, Div
}

和OC中的枚举一样，也可以指定原始值，后面的值默认 +1
enum Method3 : Int{
    case Add = 5, Sub, Mul, Div

}

Swift 中的枚举除了可以指定整型意外还可以指定其他类型
但是如果指定其他类型，必须给所有枚举值赋值，因为不能自动递增

  enum Method: Double{

    case Add = 5.0, Sub = 6.0, Mul = 6.1, Div = 8.0
}

rawValue代表将枚举值转换成原始值，注意老版本中转换原始值的方法名叫toRaw

Method4.Sub.rawValue

原始值转换为枚举值

enum Method5: String{
    case Add = "add", Sub = "sub", Mul = "mul", Div = "div"

}

通过原始值创建枚举值
注意：
1、原始值区分大小写
2、返回值的是一个可选值，因为原始值对应的枚举值不一定存在
3、老版本中为fromRaw（“add”）

enum Method5: String{
    case Add = "add", Sub = "sub", Mul = "mul", Div = "div"

}

let m2 = Method5(rawValue:"add")

print(m2)

func chooseMethod(op:String)
{
    // 由于返回值是可选类型，所以有可能为nil，最好使用可选绑定
    if let opE = Method5(rawValue: op){
        switch(opE){
        case .Add:
            print("加法")
        case .Sub:
            print("减法")
        case .Mul:
            print("除法")
        case .Div:
              print("乘法")
        
        }
    }
}

枚举相关值：

// 可以让枚举值对应的原始值不是唯一的，而是一个变量
// 每一个枚举可以是在某种模式下的一些特定值

enum lineSegmentDescriptor{

case StartAndEndPattern(start: Double, end: Double)
case StartAndLengthPattern(start: Double, length: Double)

}

var lsd =     lineSegmentDescriptor.StartAndEndPattern(start: 0.0, end: 50.0)

lsd = lineSegmentDescriptor.StartAndLengthPattern(start: 0.0, length: 100.0)

利用switch提取枚举联值

switch lsd
{
    case let .StartAndEndPattern(s, e):
        print("start = \(s) end = \(e)")
    case .StartAndLengthPattern(let s, let l):
        print("start = \(s) length = \(l)")
}

**输出结果: **

Snip20160301_7.png

3. 结构体

结构体

结构体是用于封装不同或相同类型的数据的
Swift中的结构体是一类类型，可以定义属性和方法（甚至构造方法和析构方法等）
格式：

struct 结构体名称 {
    结构体属性和方法

}

struct Rect {

    var width: Double = 0.0

    var height: Double = 0.0

}

如果结构体的属性有默认值，可以直接使用（）构造一个结构体
如果结构体的属性没有默认值，必须使用逐一构造器实例化结构体

var r = Rect()

print("width = \(r.width) height = \(r.height)")

*结构体属性的访问使用.语法 *

struct Rect {

var width: Double = 0.0

var height: Double = 0.0

}

var r = Rect()

r.width = 100
r.height = 99

print("width = \(r.width) height = \(r.height)")

结构体构造器
Swift中的结构体和类跟其他面向对象语言一样都有构造函数，而OC是没有的
Swift要求实例化一个结构体或类的时候，所有的成员变量必须有初始值
构造函数的意义就是用于初始化所有成员变量的，而不是分配内存的，分配内存是系统帮我们做的
如果结构体中所有属性都有默认值，可以调用（）构造一个结构体实例
如果结构体中的属性没有默认值，可以自定义构造器，并在构造器中给所欲的属性赋值
其实结构体有一个默认的逐一构造器，用于初始化时果所有属性赋值

struct Rect2 {
    var width: Double
    var height: Double = 0.0
}

逐一构造器

var r1 = Rect2(width: 10.0, height: 10.0)

// 错误写法，书写的顺序必须与结构体中成员的顺序一致
// 错误写法，书写必须包含所有成员

结构体中定义成员方法

// 在C和OC中结构体只有属性，而Swift中结构体中还可以定义方法

struct Rect3 {
    var width: Double
    var height: Double = 0.0

// 给结构体定义一个方法，该方法属于该结构体
// 结构体中的成员方法必须使用某个实例调用
// 成员方法可以反复顾问成员属性
func getWidth() -> Double{

        return width
    }
}

var r2 = Rect3(width: 10.0, height: 20.0)

 // 结构体中的成员方法是和某个实例对象绑定在一起的，所以谁调用，方法中访问的属性就属于谁
print(r2.getWidth())

var r3 = Rect3(width: 30.0, height: 20.0)

print(r3.getWidth())

结构体是值类型

struct Rect4 {
    var width: Double
    var height: Double = 0.0

    func show() ->Void{

        print("width = \(width) height = \(height)")

    }
}

var r4 = Rect4(width: 10.0, height: 10.0)

var r5 = r4

r4.show()

r5.show()

r4.width = 20.0

 // 结构体是值类型，结构体之间的赋值其实是将r4中的值完全拷贝一份到r5中，所以他们是两个不同的实例
r4.show()
r5.show()

作者说:

由于这学期的课程实在是太满了, 所以在写笔记的时候, 是直接复制我在学习的时候的笔记, 没有加以整理. 望各位见谅.
由于我之前没有学习Swift中关于协议和内存管理以及使用Foundation框架现在我在抽空学习, 过一段时间会更新的.