1-1 基础语法

1. 不需要写 main 函数，全局范围内第一句作为入口
2. let 定义常量，var 定义变量；可以一行定义多个常量变量，需要用,分开

var x = 0.0, y = 0.0, z = 0.0

3. 常量/变量在初始化之前都不能使用
4. 如果常量/变量没有初始值，可以类型注释来确认常量/变量的类型，同样可以一行定义多个，用,分开

let name: String // 类型注释，表示 name 是字符串类型，只能存储字符串
var a, b, c: Double

5. 常量/变量如果没有初始值，必须使用类型注释，编辑器需要确认其数据类型

// 报错
let b
b = 10

// 添加类型注释👌
let b: Int

// 报错
var v
v = 10

// 添加类型注释👌
let v: Int

6. 常量let
   1. 只能赋值一次，之后不能修改
   2. 不要求编译时期确定值，但是使用前必须赋值一次

   func add(a: Int, b: Int) -> Int {
     return a + b
   }
   
   // 输出值为30，此时 count 就是在运行时确认的值
   let count = add(a: 10, b: 20) 
   

7. 数据类型分为：
   1. 值类型：
      1. 元组(tuples)
      2. 枚举(enum)
      3. 结构体(struct)：Bool Int Float Double String Character Array Dictionary Set
   2. 引用类型：Class

补充：关于 值类型&引用类型 可以看看这个。

8. Int可以指定长度：8、16、32、64

   1. 32位平台，使用 Int32，Int 和 Int32 长度相同
   2. 64位平台，使用 Int64，Int 和 Int64 长度相同
   3. 同时无符号整数类型，同理👆 类似 UInt UInt8 ...
   4. 通过 min max 可以获取类型的最小值和最大值

   // 输出：0 255
   print(UInt8.min, UInt8.max)
   

   5. 尽量统一使用 Int，避免类型不同的转换和可复用性。
   6. 整数可以由多种进制表示，十进制、二进制0b、八进制0o、十六进制0x：

   // 下面都是表示的 17
   let decimalInteger = 17 // 十进制的17
   let binaryInteger = 0b10001 // 二进制的17
   let octalInteger = 0o21 // 8进制的17
   let hexadecimalInteger = 0x11 // 16进制的16
   

9. 浮点数

   1. Float 32位精度，有6位小数
   2. Double，有64位精度，优先使用 Double

   let a: Float = 2.8 // Float 需要指定类型
   let b = 1.4 // Double 系统默认
   

   3. 如果表达式中同出现整数+浮点数，会被推断为Double

   // a 会被人为是 Double
   let a = 1 + 3.2
   

   4. 浮点数可以由十进制或十六进制0x表示：

      1. 十进制表示方法有两种，👇：

      // 1. 正常写法
      let a = 125.0
      
      // 2. e: 表示浮点指数，10^e
      // 此处表示：1.25 x 10^2 = 125.0
      let b = 1.25e2
      
      // 表示：1.25 x 10^-2 = 0.0125
      let c = 1.25e-2
      

      2. 十六进制浮点数，必须有一个指数p，表示2^p，👇：

      // 15 x 2^2 = 60.0
      let a = 0xFp2
      
      // 15 × 2^-2 = 3.75
      let b = 0xFp-2
      
      // c = 12 x 16^0 = 12
      // .3 = 3 x 16^-1 = 3/16 = 0.1875
      // p0 = 2^2 = 0
      // 12 + 0.1875 + 0 = 12.1875
      let c = 0xC.3p0
      

      补仓：进制转换方法

10. 编译器会在编译期间进行 类型检查，确认常量/变量的数据类型。

    1. 有类型注释，则根据注释确认
    2. 无类型注释，有赋值，根据赋值类型推断类型

注意：这里有个问题，数据类型是在编译器推断出来，但是常量的值可以是运行时再确认。  
那像上面示例代码 6.2 中，`count` 怎么在编译期间推断出来类型喃？
这里初步推断，`add` 函数的返回值类型是确定了，那 `count` 类型和函数返回值类型是一样的，所以就能够推断出是 `Int`。

11. 为了增加整数和浮点数的可读性，可以增加0和_。

let a = 1000_000_000 // 实际等于 1000000000
let b = 001.1_001_001 // 实际等于1.1001001

12. 不同数字数据类型，不可相加，可以使用 SomeType(ofInitialValue) 来相互转换。
13. 不同数字字面量类型可以相加，因为其本身没有明确的类型，它们的类型只在编译器需要求值的时候被推测。

// Int类型装换
let a32: UInt32 = 8
let b16: UInt16 = 16
let c32 = a32 + UInt32(b16)

// 整数浮点数转换
let i = 10
let d = 18.9
let total = d + Double(i)

// 字面量相加
let d1 = 10 + 18.9

14. 通过typealias定义类型别名

typealias AudioSample = UInt16
// audioSampleMax = UInt16.max
let audioSampleMax = AudioSample.max

15. 元组（tuples），可以定义多个元素，基本用法👇：

let tuple = ("status", 500)
// 可以通过下标获取 0、1
print("status - \(tuple.0); code - \(tuple.1)")

// 直接分解元组内容
let (status, code) = ("status", 404)
print("status - \(status); code - \(code)")

// 给元组每个元素命名
let response = (status: "Successful", code: 200)
print("status - \(response.status); code - \(response.code)")