一：playground

作用：学习代码、实验代码、测试代码

官方的学习资源是以playgroud形式提供的，建立自己的playgroud文件，能够每次版本升级时，第一时间发现语法的变化

Swift程序中与Oc的不同

1、没有.h与.m文件，都是以.swift结尾的文件

2、没有main.m文件 —— appDelegate中的@UIApplicationMain 就是程序的入口

3、Swift的类都是用class标识

4、OC中的initwithXX方法在Swift中是“类型（xxx）”

5、swift中的属性和方法都是用 “.” 的形式

6、结尾可以不加分号（加了也可以）

7、在当前类中使用当前属性，不需要加“self."（除了闭包）

8、在swift中把枚举分成了两部分"枚举名.枚举值"，枚举名可以省略

9、在swift中使用print打印，也可以使用nslog，但效率没有print高

---

二、Swift的基本语法

1、变量与常量

swift中变量与常量的类型可以不设置，在赋值时由系统自动推断，如果希望手动指定那么在变量或常量后加":类型"

在swift中，不同类型之间不能进行运算，oc可以，因为oc有隐式转换

运算符对称，运算符左右两边的空格要对称，如果一边有空格，另一边没有就会报错，一边多了个空格不会报错，但影响美观

var来声明变量。在swift中，如果定义了一个变量，没有初始值的时候，系统会报错。如果开发者就是想声明一个变量为空，那么需要在类型的后面加个"?"

let用来声明常量。在swift中，如果定义了一个常量，没有初始值的时候，系统会报错。对于常量，不能通过后面加"？"来处理，只能赋值为nil或者0来处理。

---

2、if判断与guard判断

在swift中没有  非零即真  的概念，条件语句一定是bool类型（true/false ）

swift中条件语句的小括号可以省略，但如果执行代码只有一句，代码块的大括号不可以省略

guard判断如果条件不成立，那么执行else代码块，相当于一个没有第一个代码块的if

---

3、三目运算 与 可选类型

三目运算在swift中与oc没有区别

在可选类型中，"??" 是一个简单的三目运算，比如

age ?? 0   意为age为nil或空时使用??后面的0值

使用 ？ 修饰的类型为可选类型，属性在赋值时候，会带有Optional关键字，这样不能与不带关键字的类型做操作，可以使用 "！"来强行解包，但使用需要小心小心再小心。

---

4、if  _ let  /   guard    _  let   

类似自定义view的if（self =  [super   XXX]）中的  “=”，判断等号前面的有值就执行第一代码块，否则else。声明的作用域仅仅在if内部。

而guard是判断不成立则执行else，声明作用域为guard的下方（不仅仅在guard内部）

---

5、for循环

不可以使用c形式的for循环，++形式在swift3.0后移除不能在使用，for循环的时候，小括号不要写

语法：

for    i       in        x..<y    （x ---- y-1）

for    i        in       x...y       (x-------y)

for    value   in  arr            (arr 数组)

---

6、switch

swift的switch可以判断任何类型，比oc要广；

默认没有break，并且不会造成穿透效果（如果想实现穿透，设置关键字 "fallthrough"）;

switch可以进行范围判断           语法：

case     _where   c(声明的变量) > 60 (范围)

---

7、字符串的长度、遍历、截取、拼接

在swift中字符串可以直接使用String表示，string本质是一个结构体，比oc的NSSting更加轻便，而且效率更高。

问题：

——如何获取字符串长度

     ——str.characters.count

——如何遍历字符串

     ——for char   in  str.characters   其中char就是一个字符

——字符串字节注意点

    ——一个英文/数字等于一个字节，一个中文等于三个字节

——字符串截取

     ——如一字符串"123456789"

        ~  最后两个不要  let  end2index = str.index(str.endIndex, offsetBy: - 2)

           str.substring(to: end2index)

        ~  前两个不要  let  start2index = str.index(str.start, offsetBy: 2)

        str.substring(from: end2index)

        ~  如何把string转化成NSString

        使用as 相当于强转

——字符串如何拼接

    ——需求：两个常量 "老王"  18，拼接成"我叫老王今年18"

         ~方式1

           ~  "我叫" + name + "今年" + string(age)

       ~方式2

            ~"我叫\(name)今年\(age)"    **常用

---

8、数组定义、拼接、遍历

——数组定义

——使用中括号形式，如果数组中有不同类型，需指定一下 ":[Any]"

——如何定义可变和不可变的数组

——可变数组用var    不可变的就是let

——如何合并数组

——"+="  arr  +=  arrb;

——如何往数组添加元素

——"append"

——如何移除元素

——"remove"系列

——如何获取元素

——和oc一样通过下标

---

9、函数

无参无返、有参无返，有参有返、外部参数

无返回值的三种写法

方法一

func  demo （）{

}

方法二

func  demo （） -> Void{

}

方法三

func  demo （） -> (){

}

——函数类型作为参数

你可以用(Int, Int) -> Int这样的函数类型作为另一个函数的参数类型。这样你可以将函数的一部分实现留给函数的调用者来提供。

下面是另一个例子，正如上面的函数一样，同样是输出某种数学运算结果：

func printMathResult(_ mathFunction: (Int, Int) -> Int, _ a: Int, _ b: Int) {

print("Result: \(mathFunction(a, b))")

}

printMathResult(addTwoInts, 3, 5)

// 打印 "Result: 8"

——函数类型作为返回类型

你可以用函数类型作为另一个函数的返回类型。你需要做的是在返回箭头（->）后写一个完整的函数类型。

下面的这个例子中定义了两个简单函数，这两个函数的类型都是(Int) -> Int：

func stepForward(_ input: Int) -> Int {

return input + 1

}

func stepBackward(_ input: Int) -> Int {

return input - 1

}

如下名为chooseStepFunction(backward:)的函数，它的返回类型是(Int) -> Int类型的函数。

func chooseStepFunction(backward: Bool) -> (Int) -> Int {

return backward ? stepBackward : stepForward

}

——函数内部定义函数（嵌套函数）

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

func chooseStepFunction(backward: Bool) -> (Int) -> Int {

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

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

            return backward ? stepBackward : stepForward

}

var currentValue = -4

let moveNearerToZero = chooseStepFunction(backward: 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!

---

10、block 闭包

——基本的闭包形式

block一般用在  异步任务完成的回调

无参无返回

方法一

let   demo  = {

}

方法二

let  demo  = { () in

}

方法三

let  demo  = { () ->Void  in

}

方法四

let  demo  = { () -> () in

}

有参数无返回

let  demo =  { (a: Int, b:Int) in

}

有参数有返回

let  demo =  { (a: Int, b:Int)  -> Int in

}

解析：in后面写具体希望执行的代码，in前面为  有参无返/有参有返  的定义

——尾随闭包

——若将闭包作为函数最后一个参数，可以省略参数标签,然后将闭包表达式写在函数调用括号后面

func testFunction(testBlock: ()->Void){

//这里需要传进来的闭包类型是无参数和无返回值的

testBlock()

}

//正常写法

testFunction(testBlock: {

print("正常写法")

})

单表达式闭包隐式返回

reversedNames = names.sorted(by: { (s1: String, s2: String) -> Bool in return s1 > s2 } )

根据上下文推断类型

reversedNames = names.sorted(by: { s1, s2 in return s1 > s2 } )

单行表达式闭包可以通过省略return关键字来隐式返回单行表达式的结果，如上版本的例子可以改写为：

reversedNames = names.sorted(by: { s1, s2 in s1 > s2 } )

在这个例子中，sorted(by:)方法的参数类型明确了闭包必须返回一个Bool类型值。因为闭包函数体只包含了一个单一表达式（s1 > s2），该表达式返回Bool类型值，因此这里没有歧义，return关键字可以省略。

1、如果有多个参数，最后一个参数为闭包，（这是才称为尾随闭包）那么尾随闭包就会提前把小括号关闭

//尾随闭包写法

testFunction(){

print("尾随闭包写法")

}

2、当只有一个参数且为闭包时，那么尾随闭包就会把小括号和参数省略

//也可以把括号去掉，也是尾随闭包写法。推荐写法

testFunction {

print("去掉括号的尾随闭包写法")

}

——逃逸闭包

当一个闭包作为参数传到一个函数中，需要这个闭包在函数返回之后才被执行，我们就称该闭包从函数种逃逸。一般如果闭包在函数体内涉及到异步操作，但函数却是很快就会执行完毕并返回的，闭包必须要逃逸掉，以便异步操作的回调。

逃逸闭包一般用于异步函数的回调，比如网络请求成功的回调和失败的回调。语法：在函数的闭包行参前加关键字“@escaping”。

//例1

func doSomething(some: @escaping () -> Void){

//延时操作，注意这里的单位是秒

DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + 1) {

//1秒后操作

some()

}

print("函数体")

}

doSomething {

print("逃逸闭包")

}

//例2

varcomletionHandle: ()->String = {"约吗?"}

func doSomething2(some: @escaping ()->String){

comletionHandle = some

}

doSomething2 {

return"叔叔，我们不约"

}

print(comletionHandle())

//将一个闭包标记为@escaping意味着你必须在闭包中显式的引用self。

//其实@escaping和self都是在提醒你，这是一个逃逸闭包，

//别误操作导致了循环引用！而非逃逸包可以隐式引用self。

——闭包的循环引用及解决方法

      ——原因

        ——原理跟OC中的block类似, 当有个属性记录下了函数传递回来的闭包, 产生强引用, 就会发生闭包的循环引用 

        ——解决方法（三种）

          ——使用weak修饰变量, 打破强引用, 因为使用weak修饰的变量有一次变成nil的机会

          ——使用[weak self] 修饰闭包原理跟__weak类似, 这样在闭包中使用self, 就是弱引用

         ——使用[unowned self ] 修饰闭包, 跟__unsafe_unretained类似, 不安全

11、面向对象

在一个模型类中，属性用var而不是let。

创建Person对象时，可以直接使用    "类名（）"的形式

声明常量或者变量时候，默认应该是有值的。

          解决方案

           方法一

          把属性变为可选类型（一般使用这种）

          方法二

          直接赋值

         方法三

        在构造函数中赋值，（需要写在super之前）

——重写与重载构造函数

    ——重写

     父类方法，子类再写一遍

    ——重载

     都是在一个类中，方法名相同，参数不同

     好处：更灵活，方便记忆，只需要记住方法名即可

---

12、异常处理

所有的方法后带有throws的都应该进行错误处理

写法为     在所需执行的代码前面写      "try/try?/try!"   (其中try与try？比较常用)

方式1   try

使用默认的try时，如果有错误可以通过do—catch进行捕捉，如果没有错误，那就正常执行

do{

       let   res = try   JSONSerialization.jsonObject（with：data，options：[]）

       print()

}catch{

      print()

}

方式2  try?

try?如果使用的是可选try，那么如果有错误会返回nil，没有错误就会正常执行

let  res = try  JSONSerialization.jsonObject（with：data，options：[]）

print()

方式3  try！

try！是强行try，意思是可以放心的用，但是如果是错误的，那么就崩溃了