整型

• 有符号的整型：能表示正数、零和负数。

• 无符号的整型：能表示正数和零，不能表示负数。

• 整型字面量

  (1) 十进制数， 没有前缀；
  (2) 二进制数，  前缀是 0b；
  (3) 八进制数，   前缀是 0o；
  (4) 十六进制数，  前缀是 0x。
      let a = 17
      let b = 0b10001
      let c = 0o21
      let d = 0x11
      print(a, b, c, d)

• 整型的选择

  (1)虽然有这么多的整数类型，但是 Swift 的官方文档推荐开发人员尽量使用 Int；

  (2)除非需要特定长度的整数，一般情况下不要使用 Int8，Int16 等特定长度的整数，用 Int 就够了；提高代码一
     致性和可复用性；

  (3)尽量不要使用 UInt，即使要存储的值是整数，也尽量使用 Int 。
     好处：* 提高代码的可复用性
          ** 避免不同类型数字之间的转换
          *** 有利于数据类型的自动推断

浮点型

• Float：表示 32 位浮点数，当精度要求不高时可使用该类型。
• Double：表示 64 位浮点数，是系统默认类型，存储精度很高
• 浮点型字面量：有十进制和十六进制两种形式，小数点两边必须至少有一个数字。

  在 Swift 中：
  (1) 可以给整型和浮点型添加 0 用于分割数值；
  (2) 可以给整型和浮点型添加 下划线(_) 用于分割数值。
      好处：* 提高数值的可读性
           ** 并不影响实际值

      var a = 003.1415
      let b = 3_500_000

布尔类型

• 作用：用于表示逻辑上的真或者假。
• 取值：只能为 true 或者 false。

  let hasError = false
  if hasError {
    print("程序出错啦")
  } else {
    print("程序正常运行")
  }

元组类型

• 定义：把多个值组合成一个复合值；元组内的值可以是任意类型，每个值的类型也可以不同。

• 应用场景：作为函数的返回值，可以传递多个值。

• 声明和定义

  (1) let 常量名 = (元素值1, 元素值2, 元素值3, ......, 元素值n)
      let student = ("张三", 18, "男")

  (2) let 常量名 = (元素名称1 : 元素值1, 元素名称2 : 元素值2, ......, 元素名称n : 元素值n)    
      let student = (name : "张三", age : 18, gender : "男")

  (3) let (name, age, gender) = ("张三", 18, "男")

  (4) let (name, _, _) = ("张三", 18, "男")

• 变量访问

  (1)通过元素的下标访问
     let student = ("张三", 18, "男")
     print("姓名:\(student.0), 年龄:\(student.1), 性别:\(student.2)")

  (2)通过元素的名称访问
     let student = (name : "张三", age : 18, gender : "男")
     print("姓名:\(student.name), 年龄:\(student.age), 性别:\(student.gender)")

  (3)通过元素的常量或者变量名访问
     let(name, age, gender) = ("张三", 18, "男")
     print("姓名:\(name), 年龄:\(age), 性别:\(gender)")

• 比较：使用 == 操作符只能对最多含有 6 个元素的元组进行比较

  let xiaoMing1 = (first : "xiaoMing", last : 19)

  let xiaoMing2 = (name : "xiaoMing", age : 19)

  let isEqualt = (xiaoMing1 == xiaoMing2)

  print(isEqualt)

可选类型

• nil：只有可选类型可以赋值为 nil。

  在 OC 中：nil 表示一个空指针，只能用于对象；

  在 Swift 中：
  (1) 指针被映射为泛型类型，nil 的含义是一个值，表示值的缺失；
  (2) nil 可用于任何类型的可选项，不仅限于对象。

• 可选类型的声明

  1. 可选常量 
  // 声明常量，同时赋值，则它的值就是实际值
  let 常量名: 常量类型? = 常量值
  let a: Int? = 20 
  print(a as Any)

  // 声明常量，没有同时赋值
  let 常量名: 常量类型?
  let a: Int?
  a = nil
  print(a as Any)

   可选常量没有默认值，在使用之前必须设置初值，否则会报错

  2. 可选变量
  // 声明变量，同时赋值，则它的值就是实际值
  let 变量名: 变量类型? = 变量值
  var y: Int? = 10
  print(y as Any)

  // 声明变量，没有同时赋值
  var 变量名: 变量类型?
  var y: Int?
  y = nil
  print(y as Any)  

   如果不给可选变量赋值，则它的值默认为 nil

• 解包

  (1) 确定可选类型包含一个非 nil 的值，然后强制解包
      let y: Int? = 10
      print(y! + 20)

  (2) 使用 if 语句提前对它进行判断
      let convertedNumber: String? = "demo"
      if convertedNumber != nil {
         print("convertedNumber has an integer value of \(convertedNumber!).")
      }

  (3) 可选绑定：判断可选类型是否包含值，如果包含就把值赋给一个临时常量或者变量
      let possibleNumber = "123"
      if let actualNumber = Int(possibleNumber) {
         print("\"\(possibleNumber)\" has an integer value of \(actualNumber).")
      } else {
        print("\"\(possibleNumber)\" could not be converted to an integer") 
      }

  (4) 隐式解析可选类型
      let possibleStrin: String? = "An optional string."
      // 需要感叹号来获取值
      let forcedString: String = possibleString!

      let assumedString: String! = "An implicitly unwrapped optional string."
      // 不需要感叹号
      let implicitString: String = assumedString

       应用场景：当可选类型被第一次赋值之后就可以确定以后一直有值的时候，隐式解析可选类型非常有用；主要被
        用在 Swift 中类的构造过程中。

      本质：隐式解析可选类型本质上是一个可选类型
      1. 可以把隐式解析可选类型当做普通可选类型来判断它是否包含值
         let assumedString: String! = "An implicitly unwrapped optional string."
         if assumedString != nil {
             print(assumedString)
         }

      2. 可以在可选绑定中使用隐式解析可选类型来检查并解析它的值
         let assumedString: String! = "An implicitly unwrapped optional."
         if let definiteString = assumedString {
             print(definiteString)
         }