简单介绍一下Swift

Swift 语言由苹果公司在 2014 年推出，用来撰写 OS X 和 iOS 应用程序，Swift语言让应用开发更简单、更快、更稳定，确保最终应用有着更好的质量更多了解Swift可以去 《The Swift Programming Language》中文版，这次分享给大家是Swift基础知识，如果你耐心看完本篇文章，并且可以理解Swift的编程技巧和方法，恭喜你可以顺利的使用Swift开发了，已经掌握了Swift的基本语法，想要真正从事苹果开发，还需要在以后的学习中不断探索和挖掘Swift
在接下来的文章中，直接深入主题，不做过多没必要的文字说明，提高大家阅读和吸收能力

一、常量和变量
常量：使用let来定义常量，定义之后不可以修改
变量：使用var来定义变量，定义之后可以修改
在使用过程中建议先定义常量,如果需要修改再修改为变量

import UIKit
let a : Int = 10
var b : Int = 20
b = 30 变量可以修改
// a = 20是错误的，常量是不能修改的

二、数据类型
1、类型介绍
Swift中的数据类型也有:整型/浮点型/对象类型/结构体类型等，整型分为有符号整型和无符号整型，例如Int、UInt，浮点型分为Float和Double

// 定义一个Int类型
var m : Int = 10
// 定义一个Double类型
let n : Double = 3.14

2、类型推导
Swift是强类型的语言，Swift中任何一个标识符都有明确的类型，如果定义一个标识符时有直接进行赋值,那么标识符后面的类型可以省略，Swift会自动根据后面的赋值来决定前面的标识符的数据类型，同时可以通过option+鼠标左键来查看变量的数据类型

Swift会自动识别a是整数，如果之后再赋值给a一个其他类型(比如浮点型)数值,则会报错
var a = 20
// 正确写法
var b = 3.33
b = 6.66

3、基本运算
Swift中在进行基本运算时必须保证类型一致,否则会出错，相同类型之间才可以进行运算，Swift中没有隐式转换
Swift中数据类型的转化，Int类型转成Double类型是Double(标识符)，Double类型转成Int类型是Int(标识符)

let a = 12
let b = 3.14

// 错误写法，形同类型之间才可以进行运算
// let c = a + b
// let c = a * b

// 正确写法，转换类型进行运算
let c = Double(a) + b
let d = a + Int(b)

三、逻辑分支
1、分支的了解
分支即if、switch、三目运算符等判断语句，通过分支语句可以控制程序的执行流程
2、if分支语句
和OC不同，Swift判断句可以不加()，在Swift的判断句中必须有明确的真假，不再有非0即真，必须有明确的Bool值，Bool有两个取值:false、true，没有Yes、NO的使用

例1
确定值存在的判断
let a = 12

// 错误写法，在Swift的判断句中必须有明确的真假，不再有非0即真
//if a {
//    print("a")
//}

// 正确写法
if a > 9 {
    print(a)
}

例2
可选类型的判断，判断如果view有值,则设置背景
let view : UIView? = UIView()
// 错误写法
//if view {
//    view.backgroundColor = UIColor.red
//}

if view != nil {
    view!.backgroundColor = UIColor.red
}

3、三目运算符
Swift 中的 三目 运算符和 OC 的用法是一样的

var a = 12
var b = 24

var result = a > b ? a : b
println(result)

4、guard的使用
guard是很重要的，在以后的开发中会经常用到，来判断该值是否是可选类型，guard在Swift2.0就出现了，与if语句非常类似，它设计的目的是提高程序的可读性
guard语句必须带有else语句，当条件表达式为true时候跳过else语句中的内容，执行语句组内容，条件表达式为false时候执行else语句中的内容，跳转语句一般是return、break、continue和throw

例1
guard用法说明
guard 条件表达式 else {
    // 条换语句，走这里的都是错误的，判断不符合要求的
    break
}
语句组，正确的执行这里

例2
简单使用guard的用法
 func gotToSchool(time:Int) -> Void {
        guard time > 6 else {
            print("去上学")
            return
        }
        print("不去上学")
    }
gotToSchool(time: 5)

5、switch分支
Switch作为选择结构中必不可少的语句也被加入到了Swift中，只要有过编程经验的人对Switch语句都不会感到陌生，苹果对Switch进行了大大的增强，使其拥有其他语言中没有的特性
基本用法和OC用法一致，switch后可以不跟()，case后可以不跟break(默认会有break)

例1
switch对整数的判断

let sex = 0
switch sex {
case 0 :
    print("男")
case 1 :
    print("女")
default :
    print("其他")
}

例2
一个case判断中,可以判断多个值，多个值以,隔开

let sex = 0
switch sex {
case 0, 1:
    print("正常人")
default:
    print("其他")
}

例3
希望出现之前的case穿透,则可以使用关键字fallthrough

let sex = 0
switch sex {
case 0:
    fallthrough
case 1:
    print("正常人")
default:
    print("其他")
}

Switch支持多种数据类型

① 浮点型的switch判断

let f = 3.14
switch f {
case 3.14:
    print("π")
default:
    print("not π")
}

② 支持字符串类型

let m = 5
let n = 10
var result = 0

let opration = "+"

switch opration {
    case "+":
        result = m + n
    case "-":
        result = m - n
    case "*":
        result = m * n
    case "/":
        result = m / n
default:
    result = 0
}

③ switch支持区间判断
开区间:0..<10 表示:0~9,不包括10
闭区间:0...10 表示:0~10

let score = 88
switch score {
case 0..<60:
    print("不及格")
case 60..<80:
    print("几个")
case 80..<90:
    print("良好")
case 90..<100:
    print("优秀")
default:
    print("满分")
}

四、循环
在开发中经常会需要循环，常见的循环有：for、while、do while
1、for循环

① 传统写法
for var i = 0; i < 10; i++ {
    print(i)
}

② 区间for循环
for i in 0..<10 {
    print(i)
}

for i in 0...10 {
    print(i)
}

③ 特殊写法
如果在for循环中不需要用到下标i，用`_`标示
for _ in 0..<10 {
    print("hello")
}

2、while和do while循环

① while的判断句必须有正确的真假,没有非0即真，while后面的()可以省略
var a = 0
while a < 10 {
    a++
}

② do while循环，使用repeat关键字来代替了do
let b = 0
repeat {
    print(b)
    b++
} while b < 20

五、字符串
OC和Swift中字符串的区别，在OC中字符串类型时NSString,在Swift中字符串类型是String，OC中字符串@"",Swift中字符串""
Swift中的String 是一个结构体，性能更高，NSString 是一个 OC 对象，性能略差，String 支持直接遍历，Swift 提供了 String 和 NSString 之间的无缝转换，可以使用as或者as?进行转换
1、遍历字符串

// 字符串遍历
var str = "Hello, Swift"
for c in str.characters {
    print(c)
}

2、字符串拼接

例1
let str1 = "Hello"
let str2 = "World"
let str3 = str1 + str2

例2
let name = "why"
let age = 18
let info = "my name is \(name), age is \(age)"

例3
字符串的格式化
let min = 3
let second = 4
let time = String(format: "%02d:%02d", arguments: [min, second])

3、字符串的截取
Swift中提供了特殊的截取方式，该方式非常麻烦，简单的方式是将String转成NSString来使用，在标识符后加:as NSString即可

let myStr = "www.baidu.com"
var subStr = (myStr as NSString).substringFromIndex(4)
subStr = (myStr as NSString).substringToIndex(3)
subStr = (myStr as NSString).substringWithRange(NSRange(location: 4, length: 5))

六、数组
数组（Array）是一串有序的由相同类型元素构成的集合，数组中的集合元素是有序的，可以重复出现，swift数组类型是Array，是一个泛型集合
1、数组的初始化
数组分成可变数组和不可变数组，使用let修饰的数组是不可变数组，使用var修饰的数组是可变数组

// 定义一个可变数组，必须初始化才能使用
var array1 : [String] = [String]()

// 定义一个不可变数组
let array2 : [NSObject] = ["xiaoming", 18]

在声明一个Array类型的时候可以使用下列的语句之一
var stuArray1:Array<String>
var stuArray2: [String]

声明的数组需要进行初始化才能使用，数组类型往往是在声明的同时进行初始化的
// 定义时直接初始化
var array = ["xm", "xl", "my"]

// 先定义,后初始化
var array : Array<String>
array = ["xm", "xl", "my"]

2、对数组的基本操作

// 添加数据
array.append("xiaoming")

// 删除元素
array.removeFirst()

// 修改元素
array[0] = "xiaoming"

// 取值
array[1]

3、数组的遍历

// 遍历数组
for i in 0..<array.count {
    print(array[i])
}

// forin方式，经常使用
for item in array {
    print(item)
}

// 设置遍历的区间
for item in array[0..<2] {
    print(item)
}

4、数组的合并

// 数组合并
// 注意：只有相同类型的数组才能合并
var array = ["xm", "xl","my"]
var array1 = ["haha", "wsz"]
var array2 = array + array1;

// 不建议一个数组中存放多种类型的数据
var array3 = [2, 3, "why"]
var array4 = ["yz", 23]
array3 + array4

七、字典
字典是由两部分集合构成的，一个是键（key）集合，一个是值（value）集合，键集合是不能有重复元素的，而值集合是可以重复的，键和值是成对出现的，Swift字典类型是Dictionary，也是一个泛型集合
1、Swift中的可变和不可变字典，使用let修饰的数组是不可变字典，使用var修饰的数组是可变字典

// 定义一个可变字典
var dict1 : [String : NSObject] = [String : NSObject]()

// 定义一个不可变字典
let dict2 = ["name" : "xl", "age" : 18]

在声明一个Dictionary类型的时候可以使用下面的语句之一
var dict1: Dictionary<Int, String>
var dict2: [Int: String]

声明的字典需要进行初始化才能使用，字典类型往往是在声明的同时进行初始化的
// 定义字典的同时,进行初始化
var dict = ["name" : "why", "age" : 18]

// swift中任意对象,通常不使用NSObject,使用AnyObject
var dict : Dictionary<String, AnyObject>
dict = ["name" : "why", "age" : 18]

2、字典的基本操作

// 添加数据
dict["height"] = 1.80
dict["weight"] = 65.0

// 删除字段
dict.removeValueForKey("height")

// 修改字典
dict["name"] = "lmj"

// 查询字典
dict["name"]

3、字典的遍历

// 遍历字典中所有的值
for value in dict.values {
    print(value)
}
// 遍历字典中所有的键
for key in dict.keys {
    print(key)
}
// 遍历所有的键值对
for (key, value) in dict {
    print(key)
    print(value)
}

4、字典的合并

// 字典的合并
var dict1 = ["name" : "xl", "age" : 20]
var dict2 = ["height" : 1.87, "phoneNum" : "+86 110"]
// 字典不可以相加合并
for (key, value) in dict1 {
    dict2[key] = value
}

八、元组
元组是Swift中特有的,OC中并没有相关类型，类似于数组或者字典，可以用于定义一组数据，组成元组类型的数据可以称为“元素”
1、元组的定义

元组的常见写法
// 使用元组描述一个人的信息
("1001", "张三", 30, 90)
// 给元素加上元素名称,之后可以通过元素名称访问元素
(id:"1001", name:"张三", english_score:30, chinese_score:90)

2、元祖的简单使用

// 元祖使用

// 写法一:
let object = (xiaoming, "18")
print(object.0)
print(object.1)

// 写法二:
let object = (name : xiaoming, age : "18")
print(object.name)
print(object.age)

// 写法三:
let (name, age) = (xiaoming, "18")
print(name)
print(age)

九、可选类型
在OC开发中,如果一个变量暂停不使用,可以赋值为0(基本属性类型)或者赋值为空(对象类型)，在swift开发中，nil也是一个特殊的类型.因为和真实的类型不匹配是不能赋值的(swift是强类型语言)，但是开发中赋值nil，在所难免，因此推出了可选类型
可选类型的取值：空值或者有值
1、定义可选类型

// 写法一:定义可选类型
let name : Optional<String> = nil

// 写法二:定义可选类型,语法糖(常用)
let name : String? = nil

2、可选类型的使用

// 定义可选类型
var string : Optional<String> = nil

// 给可选类型赋值
string = "Hello world"

// 打印结果
print(string)
// 结果:Optional("Hello world")\n

// 取出可选类型的真实值(解包)
print(string!)
// 结果:Hello world\n

// 注意:如果可选类型为nil，强制取出其中的值(解包)，会出错
string = nil
print(string!) // 报错

// 正确写法:
if string != nil {
    print(string!)
}

// 简单写法:为了让在if语句中可以方便使用string
// 可选绑定
if let str = string {
    print(str)
}

十、函数
1、函数介绍
函数相当于OC中的方法，函数的格式如下

func 函数名(参数列表) -> 返回值类型 {
    代码块
    return 返回值
}

func是关键字，多个参数列表之间可以用逗号（,）分隔，也可以没有参数，使用箭头“->”指向返回值类型，如果函数没有返回值，返回值为Void.并且“-> 返回值类型”部分可以省略

2、常见的函数类型

① 没有参数，没用返回值
func about() -> Void {
    print("iphone6s plus")
}
// 调用函数
about()

如果没用返回值,Void可以写成()
func about1() -> () {
    print("iphone6s plus")
}
// 如果没有返回值，后面的内容可以都不写
func about2() {
    print("iphone6s plus")
}
about2()

② 有参数，没用返回值
func callPhone(phoneNum : String) {
    print("打电话给\(phoneNum)")
}
callPhone("+86 110")

③ 没用参数，有返回值
func readMessage() -> String {
    return "吃饭了吗?"
}
var str = readMessage()
print(str)

④ 有参数，有返回值
func sum(num1 : Int，num2 : Int) -> Int {
    return num1 + num2
}
var result = sum(20，num2: 30)
print(result)

3、函数的使用
① 外部参数和内部参数
在函数内部可以看到的参数,就是内部参数，在函数外面可以看到的参数,就是外部参数，默认情况下,从第二个参数开始,参数名称既是内部参数也是外部参数，如果第一个参数也想要有外部参数，可以设置标签，在变量名前加标签即可，如果不想要外部参数,可以在参数名称前加_

// num1和a是外部参数的名称
func ride(num1 num1 : Int, a num2 : Int, b num3 : Int) -> Int {
    return num1 * num2 * num3
}
var result1 = ride(num1: 20, a: 4, b: 5)

// 方法的重载:方法名称相同，但是参数不同，可以称之为方法的重载(了解)
func ride(num1: Int, _ num2 :Int) -> Int {
    return num1 * num2
}

var result2 = ride(20, 20)

② 默认参数
如果没有传入具体的参数,可以使用默认参数

func makecoffee(type :String = "卡布奇诺") -> String {
    return "制作一杯\(type)咖啡。"
}

let coffee1 = makecoffee("铁观音")
let coffee2 = makecoffee()

③ 可变参数
Swift中函数的参数个数可以变化，它可以接受不确定数量的输入类型参数，它们必须具有相同的类型，我们可以通过在参数类型名后面加入（...）的方式来指示这是可变参数

func sum(numbers:Double...) -> Double {
    var total: Double = 0
    for number in numbers {
        total += number
    }
    return total
}

sum(100.0, 20, 30)
sum(30, 80)

④ 引用类型(指针的传递)
默认情况下，函数的参数是值传递，如果想改变外面的变量，则需要传递变量的地址，必须是变量，因为需要在内部改变其值，Swift提供的inout关键字就可以实现

// 函数一：值传递
func swap(var a : Int, var b : Int) {
    let temp = a;
    a = b;
    b = temp
    print("a:\(a), b:\(b)")
}

var a = 10
var b = 20
swap(a, b: b)
print("a:\(a), b:\(b)")

// 函数二:指针的传递
func swap1(inout a : Int, inout b : Int) {
    let temp = a
    a = b
    b = temp

    print("a:\(a), b:\(b)")
}

swap1(&a, b: &b)
print("a:\(a), b:\(b)")

⑤ 函数的嵌套使用
swift中函数可以嵌套使用，即函数中包含函数,但是不推荐该写法
十一、类的使用
1、类的介绍和定义
Swift也是一门面向对象开发的语言，面向对象的基础是类，类产生了对象，class是Swift中的关键字，用于定义类

定义的类,可以没有父类.那么该类是rootClass，通常情况下，定义类时，继承自NSObject(非OC的NSObject)
class 类名 : SuperClass {
    // 定义属性和方法
}

2、定义类的属性
Swift中类的属性有多种：存储属性，存储实例的常量和变量；计算属性，通过某种方式计算出来的属性；类属性，与整个类自身相关的属性
① 存储属性
存储属性是最简单的属性，它作为类实例的一部分，用于存储常量和变量，可以给存储属性提供一个默认值，也可以在初始化方法中对其进行初始化

// 给存储属性赋值
stu.age = 10
stu.name = "xiaoming"

stu.chineseScore = 89.0
stu.mathScore = 98.0

② 计算属性
计算属性并不存储实际的值，而是提供一个getter和一个可选的setter来间接获取和设置其它属性，计算属性一般只提供getter方法，如果只提供getter，而不提供setter，则该计算属性为只读属性,并且可以省略get{}

class Student : NSObject {
    // 存储属性
    var age : Int = 0
    var name : String?

    var chineseScore : Double = 0.0
    var mathScore : Double = 0.0

    // 计算属性
    var averageScore : Double {
        get {
            return (chineseScore + mathScore) / 2
        }

        // 没有意义,因为之后获取值时依然是计算得到的
        // newValue是系统分配的变量名，内部存储着新值
        set {
            self.averageScore = newValue
        }
    }
}

③ 类属性
类属性是与类相关联的，而不是与类的实例相关联，类属性的设置和修改,需要通过类来完成，类属性使用static来修饰

class Student : NSObject {
    // 类属性
    static var corseCount : Int = 0
}

// 设置类属性的值
Student.corseCount = 3
// 取出类属性的值
print(Student.corseCount)

④ 监听属性的改变
在OC中我们可以重写set方法来监听属性的改变，在Swift中可以通过属性观察者来监听和响应属性值的变化，通常是监听存储属性和类属性的改变，(对于计算属性，我们不需要定义属性观察者，因为我们可以在计算属性的setter中直接观察并响应这种值的变化)
willSet：在属性值被存储之前设置，此时新属性值作为一个常量参数被传入，该参数名默认为newValue，我们可以自己定义该参数名；didSet：在新属性值被存储后立即调用，与willSet相同，此时传入的是属性的旧值，默认参数名为oldValue；
willSet与didSet只有在属性第一次被设置时才会调用，在初始化时，不会去调用这些监听方法

class Person : NSObject {
    var name : String? {
        // 可以给newValue自定义名称
        willSet (new){ // 属性即将改变,还未改变时会调用的方法
            // 在该方法中有一个默认的系统属性newValue，用于存储新值
            print(name)
            print(new)
        }
        // 可以给oldValue自定义名称
        didSet (old) { // 属性值已经改变了,会调用的方法
            // 在该方法中有一个默认的系统属性oldValue，用于存储旧值
            print(name)
            print(old)
        }
    }
    var age : Int = 0
    var height : Double = 0.0
}

let p : Person = Person()

// 在赋值时,监听该属性的改变
// 在OC中是通过重写set方法
// 在swift中,可以给属性添加监听器
p.name = "xiaoming"

十二、类的构造函数
构造函数类似于OC中的初始化方法init方法，默认情况下载创建一个类时,必然会调用一个构造函数，即便是没有编写任何构造函数，编译器也会提供一个默认的构造函数，如果是继承自NSObject，可以对父类的构造函数进行重写
1、构造函数的基本使用
① 类的属性必须有值，如果不是在定义时初始化值,可以在构造函数中赋值

class Person: NSObject {
    var name : String
    var age : Int
    // 重写了NSObject(父类)的构造方法
    override init() {
        name = ""
        age = 0
    }
}

// 创建一个Person对象
let p = Person()

② 初始化时给属性赋值
我们在创建一个对象时就会给属性赋值，可以自定义构造函数，如果自定义了构造函数,会覆盖init()方法，即不在有默认的构造函数

class Person: NSObject {
    var name : String
    var age : Int

    // 自定义构造函数,会覆盖init()函数
    init(name : String, age : Int) {
        self.name = name
        self.age = age
    }
}

// 创建一个Person对象
let p = Person(name: "xiaoming", age: 18)

③ 字典转模型(初始化时传入字典)

例1
class Person: NSObject {
    var name : String
    var age : Int

    // 自定义构造函数,会覆盖init()函数
    init(dict : [String : NSObject]) {
        name = dict["name"] as! String
        age = dict["age"] as! Int
    }
}

// 创建一个Person对象
let dict = ["name" : "xiaoming", "age" : 18]
let p = Person(dict: dict)

例2
利用KVC字典转模型
class Person: NSObject {
    // 结构体或者类的类型，必须是可选类型，因为不能保证一定会赋值
    var name : String?

    // 基本数据类型不能是可选类型，否则KVC无法转化
    var age : Int = 0

    // 自定义构造函数，会覆盖init()函数
    init(dict : [String : NSObject]) {
        // 必须先初始化对象
        super.init()

        // 调用对象的KVC方法字典转模型
        setValuesForKeysWithDictionary(dict)
    }
}

// 创建一个Person对象
let dict = ["name" : "xiaoming", "age" : 18]
let p = Person(dict: dict)

十三、闭包
Swift闭包和OC中的block非常相似，OC中的block是匿名的函数，Swift中的闭包是一个特殊的函数，block和闭包都经常用于回调
1、OC中Block的使用

首先介绍一下OC中Block写法
① 第一种Block方式

@property (nonatomic, copy) void(^callBack)(NSString *name);
callBack 是block对象
回调方法
if(_callBack){
_callBack(name)
}

② 第二种Block方式

typedef void(^CallBack)(NSString *str);
@property (nonatomic, copy) CallBack callback;
callback是block对象
回调方法
if(_callBack){
_callBack(name)
}

③ 第三种Block方式

- (void)setUpWith:(void(^)(NSString *str))callback;
callback是block对象
回调方法
if(_callBack){
_callBack(name)
}

总结
Block的写法:
    类型：
    返回值类型(^block的名称)(block的参数)

    值:
    ^(参数列表) {
        // 执行的代码
    };

2、Swift中闭包的使用
① 第一种闭包方式

var callBack : (()->())?

② 第二种闭包方式

func loadRequest(callBack : ()->()){
                callBack()
    }

总结
闭包的写法:
   callBack: (形参列表) -> (返回值类型)
    类型:(形参列表) -> (返回值类型)
    值:
    {
        (形参) -> 返回值类型 in
        // 执行代码
    }

闭包的简写，如果闭包没有参数，没有返回值，in和in之前的内容可以省略

尾随闭包写法
① 如果闭包是函数的最后一个参数，则可以将闭包写在()后面
    httpTool.loadRequest() {
        print("回到主线程", NSThread.currentThread());
    }
② 如果函数只有一个参数,并且这个参数是闭包,那么()可以不写
    // 开发中建议该写法
    httpTool.loadRequest {
        print("回到主线程", NSThread.currentThread());
    }

3、闭包的循环引用
如果在HttpTool中有对闭包进行强引用,则会形成循环引用，在Swift中检测一个对象是否销毁,可以实现对象的deinit函数

// 析构函数(相当于OC中dealloc方法)
    deinit {
        print("ViewController----deinit")
    }

4、swift中解决循环引用的方式
① 使用weak,对当前控制器使用弱引用
但是因为self可能有值也可能没有值，因此weakSelf是一个可选类型，在真正使用时可以对其强制解包(该处强制解包没有问题，因为控制器一定存在,否则无法调用所在函数)

解决一
weak var weakSelf = self
    httpTool.loadData {
        print("加载数据完成,更新界面:", NSThread.currentThread())
        weakSelf!.view.backgroundColor = UIColor.redColor()
    }

② 可以写在闭包中,并且在闭包中用到的self都是弱引用

解决二
 httpTool.loadData {[weak self] () -> () in
        print("加载数据完成,更新界面:", NSThread.currentThread())
        self!.view.backgroundColor = UIColor.redColor()
    }

③ 使用关键字unowned
unowned 更像OC中的 unsafe_unretained，unowned 表示即使它原来引用的对象被释放了，仍然会保持对被已经释放了的对象的一个 "无效的" 引用，它不能是 Optional 值，也不会被指向 nil

解决三
httpTool.loadData {[unowned self] () -> () in
        print("加载数据完成,更新界面:", NSThread.currentThread())
        self.view.backgroundColor = UIColor.redColor()
    }

十四、懒加载
swift中也有懒加载的方式，希望所有的对象在使用时才真正加载到内存中，和OC不同的是swift有专门的关键字来实现懒加载，lazy关键字可以用于定义某一个属性懒加载
1、懒加载普通方式

lazy var 变量：类型 = 系统类()
lazy var button：UIButton = UIButton()

2、懒加载升级方式

lazy var array : [String] = {
        () -> [String] in
        return ["xiaoming", "xl", "lisi"]
    }()

心得体会：
Swift好用，如果你读完本篇文章基本上掌握了Swift基础知识，剩下的就是实战了，实战会增加你编写Swift的能力，对Swift有更深的理解，后期也会补充新的Swift知识，也会分享自己的开源Swift项目共大家学习讨论，请关注下我的github账号lb2281075105，开始分享自己的项目和Demo，如果更好的意见请及时给我说哦，合理我会毫不犹豫采纳，谢谢，您的点赞会更加激励我的热情。