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))
**输出结果: **
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)")
}
**输出结果: **
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框架现在我在抽空学习, 过一段时间会更新的.
