1. 元组英文名字 Tuple,将多个数据类型(任意类型)组合成一个数据,与c语言的中的机构体有几分相似，功能也是非常强大的，尤其是在定义请求参数，状态之类的地方经常用到。

   let http404Error:(Int,String) = (404,"Not Found")  

   let me:(Int,String,Double) = (99,"阿甘左",9999999)

http404Error.0    //0代表括号内第一个数值索引

http404Error.1    //1 代表括号内第二个数值索引，一次类推

 //重新给 me这个tuple定义描述

let(Levl,Name,attacks) = me

levl    //等级99

Name  //"阿甘左"

attacks //"物理攻击9999999"

   //还可以使用以下写法

var http500Error = (code:500,discription:"server error")

http500Error.code

http500Error.discription

//元组数据修改 2种方式（索引修改，描述名属性修改）

http500Error.code = 501

http500Error.discription = "new server error" 

http500Error.0 = 502

http500Error.1 = "server error2"

2. tuple  combine with switch 

let onePoint ＝ (-15,15)  

switch onePoint {

   case (_ ,0):    // 原组可以作为case的判断条件, 这就意味着某一组 自定义的变量能够进行比较

                        // 而且还能使用 _  任意数类型，

      print(" point at y-axis")

   case (0,_):

     print("point at x- axis")

   case(0,0):

     print("point at origin")

   case (-20...20,-20...20):   // －20...20 一个区间的数据，这相当于除了确切相等的值，不等式也能在switch中进行判定了，简直就是逆天的节奏，这是作者集百家之强的结果。

     print("point in specified rect") 

}

var aPoint = (-15,15)

if aPoint.0 == aPoint.1 {

    print("this point is in x = y ")

}else if aPoint.0 == -aPoint.1 {

    print("this point is in x = -y")

}

/**使用新的写法,在绑定变量的同时，指定条件判断，感觉就像在盗版SQL*/

switch aPoint {

    //在绑定一个变量的同时,可以绑定x == y

  case let(x,y) where x == y:  

    print("x 与 y相等斜线上 x ＝ y")

case let(x,y) where x == -y:

    print("x 与 －y斜线上 x = -y")

  default:

    print("other")

}

3.可选值(Optional)故名思义就是可以选择的,及可以是确切的数，也可以为空。

   标准写法

   var optionalValue:Optional<Int>     //Optional为可选， <Int>为类型

   简写

   var sampleValue: Int ?    //Int为类型，？为可选

//String 转换Number

let possibleNumber = "123"

/**因为Int(possibleNumber) 转换可能会失败，所以转换为Optional类型，所以此处应该标注Int?,以防止程序出现错误时无法知道*/

let convertedNumber:Int? = Int(possibleNumber)

print(convertedNumber)

if Int(possibleNumber) != nil {

   print("convert successfully")

}

else {

   print("convert failure")

}

//可选值如果是nil,则unpackage will error,为了安全需要判断之后再接包，变量 ＋ ! 表示 !

if convertedNumber != nil {

   print(convertedNumber!)

}

else {

   print(convertedNumber)

}

//如下规则，可选数必须经过解包之后才能运算 在变量后面加上！ 即可, 但是选值本省的类型没变。所以如果你要运算 必须写成  convertedNumber ！ ＋ 400  这种形式

/**如下可选则，必须接包之后才能运算,可以赋值;可选值解包之后可以运算，可选值的类型本省没变*/

var y2:Int?

y2 = 200

print(y2)

//y2 = y2 + 100

var y3:Int? = y2

print(y3)

var y4:Int = y2!

print(y4)

if y2 != nil {

     y2!

}

y2! += 3

print(y2!)

print(y2)

/**可选绑定，简化上面的安全解包；将变量赋值类型转换写到一行*/

if let actueNumber = Int("1234") {

    print("convert sucessfully")

}else {

    print("convert failure")

}

/**类型 + !,Int !代表声明自动解包的可选类型，使用时可以不用解包;但是得保证自动解包的类型不能是nil*/

var z:Int!

z = nil     // z为自动解包类型，赋值nil本身编译不会有错，但在运行时会崩溃。苹果格式－－－－

//print(z)  error，打印时有一个解包的过程，所以会报错

z = 100

print(z)

//可选值赋值给一个变量，叫做可选绑定

let rez = z

print(rez) 

//if rez {  //此方式错误❌  因为rez通过赋值后它的类型是  Int！ ，自动解包类型需要判定是否空后才能作为条件判定， 此处正确写法    if rez !＝ nil {   }else {   }

//

//}else {

//

//}

if rez == nil {

   print("解包失败\(z)")

}else {

   print("解包成功\(z)")

}

4. Bug 调试机神器－－－－断言 assert。

   其实原理很简单，就是运行到这一行的时候，通过函数指定一个判断语句，如果满足条件就往下运行，不满不足条件就停在这。实际开发的时候我们可以在需要确认数据的位置写下断言语句进行检测我们预估的变量数值是否正确

/**assert断言:当x 不等于100的时候程序继续执行下去;否者在判断行断开,在写代码的时候就不会自动运行了*/

var x = 101

assert(x != 100,"x 不等于100")

print("app continue")

/**func 表示Swift中的函数，partx为函数名字，Int为函数的类型

 如下，对函数的型参进行断言，如果为0则为空;断言成立，程序继续向下运行，断言不成立，程序出错

 */

func testAssert(parx :Int) {

   assert(parx != 0 ,"parx参数不能为0")

   print(100/parx)

}

testAssert(3)

testAssert(100)

//testAssert(0)