Swift基础语法详述

0. 代码注释 Comments

// 单行注释 - //
/* 多行
     注释 - /* ... */
*/

1. 常量与变量 Constant & Variable

• 声明常量：关键字 let
• 声明变量：关键字 var

let taskCount = 10 // 不可改变
var days = 5
days = 8                     // 可改变

2. 运算符 Operators

• 基本运算符：=, +, -, *, /, %, +=, -=, *=, /=

// 赋值运算符 = 将右边的值赋给左边
let a = 1
let b = 2
let c = 3

var result: Int
// +、-、*、/、%（求余）为基本数学运算符
result = a + b
result = a - b
result = a * b
result = a / b
result = a % b
// 涉及到小数计算，swift为向下取整

// 运算并赋值：+=、-=、/=、*=、%=
var count = 1
count += 1 // count: 2 等价于 count = count + 1

• 逻辑运算符：&&, ||, !

// && 与 运算
let isCheap: Bool = false
let isBuzy: Bool = true
if isCheap && isBuzy {
  print("便宜但人多") // 不会运行，A、B两条件必须同时满足
}

// || 或 运算
let isCheap: Bool = false
let isBuzy: Bool = true
if isCheap || isBuzy {
  print("要么便宜，要么人多") // 运行，A、B两条件只要一个满足
}

// ! 非 运算
if !isCheap {
  print("价格便宜") // 运行，false 条件的反义满足 true
}

• 比较运算符：>, <, ==, >=, <=

// >, < , >=, <= 都可以按照数学逻辑比较
// == 只判定等等号两边元素是否相等，相等返回true，否则返回false
"Hello" == "Hello" // 此处返回true
// 字符串可比较是因为Swift中的String遵循Comparable协议

3. 条件判断 Control Flow

• if 语句

let isOpened: Bool = true
if isOpened {
    print("已开门") // if 判断是否为真，为真则运行{}代码，否则不执行
}

• if-else 语句

let isOpened: Bool = true
if isOpened {
    print("已开门")
} else {
    print("还未开门")
}
// if-else 为真执行if{}代码，否则执行else{}代码

• 三元运算符：<condition> ? <isTure Code> : <isFalse Code>

// 三元运算符 _ ? _ : _ 可以将上述代码写成：
let isOpened: Bool = true
isOpened ? print("已开门") : print("还未开门")

• else-if 语句：if-else if-else

let favoriteNumber = 1
let hatedNumber = 3

// 假设猜测数字为 2
let number = 2

if number == favoriteNumber {
    print("Yes, you are right!")
} else if number == hatedNumber {
    print("No, it's my most hated number!")
} else {
    print("Please guess again!")
}

• switch-case 语句

let dateNumber = 1
switch dateNumber {
case 1...5:
    print("It's working...")
case 6:
    print("Play the piano")
case 7: 
    print("Have a rest!")
// Swift要求 完全列举Exhaustive 必须包含全部可能
// 处理意外数值的默认情况 default
default:
    print("Error!")
}

4. 类型 Types

4.0 类型分类图：

• 整数型 Int

let userAge: Int = 19
// userAge 为Int整型

• 浮点型 Double

let temperature: Double = 24.6
// temperature 为Double浮点型

• 布尔型 Bool

var isClosed: Bool = false
// isClosed 为Bool布尔型

• 字符串 String

var userName: String = "TabYang"
// userName 为String字符串

• 字符串插值 String Interpolation

var userAge: Int = 19
var userName: String = "TabYang"
// Swift可使用"\(<变量名>)"来进行插值
var userInfo: String = "\(userName) is \(userAge) years old."
print(userInfo)
// 输出 TabYang is 19 years old

• 类型推断 Type Inference

  Swift可以根据开发者提供的数据，自动推断其类型

// Type Inference 类型推断
let userAge: Int = 19    // 此时userAge类型为Int
let userID = 1    // 此时通过类型推断userID类型为Int

• 类型转换 Type Conversion

var userAge: Int = 19
var userName: String = "TabYang"
// Swift 可通过 <类型名>(<变量名>) 完成类型转化
var userInfo = userName + "is " + String(userAge) + " years old."

• 类型别名 Typealias

  当需要修改Swift本身定义的类型名称来使名称更符合表达或使用第三方库时需要修改struct的命名时（但不建议这么做），可以使用关键字typealias定义类型别名，其语法为 typealias <新类型名> = <老类型名>

// Swift允许通过typealias关键字实现类型别名
typealias Age = Int
var userOneAge: Int = 19
var userTwoAge: Age = 20

typealias UserInfo = [String: Int]
let userOne: UserInfo = ["Tab": 19]

struct GameCenter { }
typealias MusicGame = GameCenter
let gameVersionOne: MusicGame = GameCenter()

5. 函数和闭包

5.0 函数的定义 Define

函数的本质是一个 具备独立命名、明确类型、能够捕获上下文的代码块，它可以作为闭包的一种具体形式用于调用和重用。

当Swift提供的基础函数不能满足开发需求时，需要开发者自定义函数来实现某个功能，其定义必须包括：函数关键字 func，函数名 sayHello，参数列表 ()，函数实现 Implementation

// 函数定义Function Define
func sayHello() {
    print("Hello world!")
}

5.1 函数的使用 Call

可以通过使用函数名和参数列来调用函数 Call Function

sayHello()
// 自动执行其函数实现，输出 Hello world

5.2 函数参数列 Parameter List

开发者自定义的函数可能需要访问外来数据 Parameter ，并对这个数据进行处理，此时这个数据可以作为函数的参数传入。开发者在函数定义中所有所需的参数组成参数列Parameter List，符号为()

定义参数列语法为：<参数名>: <参数类型>

func userInfo(userName: String, userAge: Int) {
    print("\(userName) is \(userAge) years old.")
}
// String和Int为参数类型，整体为参数列Parameter

根据定义用户必须传入具体实参 Argument 到函数参数列中使用：

userInfo(userName: "TabYang", userAge: 19)
// 输出 TabYang is 19 years old.
// "TabYang"和"19"为具体参数 Argument

5.3 函数标签及默认值

• 参数标签 Argument Label

  开发者可能会为了使函数调用更符合语言习惯，Swift提供了参数标签，将参数标签写在参数名前面，函数调用传参时可以使用该标签来代替参数名。

// 定义参数标签
func creatorInfo(by creatorName: String) {
    print("This product is created by \(creatorName).")
}

// 调用函数
creatorInfo(by: "TabYang")
// 输出 This product is created by TabYang.

• 参数标签省略：用 _ 替代参数标签可以让函数调用时直接省略参数名。

// 省略参数标签
func creatorInfo(_ creatorName: String) {
    print("This product is created by \(creatorName).")
}

// 调用函数
creatorInfo("TabYang")
// 输出 This product is created by TabYang.

• 设置参数默认值：通过设置参数默认值，调用函数时可以不传入该参数，函数会按照默认值进行操作。

// 传入参数默认值
func creatorInfo(_ creatorName: String = "TabYang") {
    print("This product is created by \(creatorName).")
}

// 调用函数但不传参
creatorInfo()
// 输出 This product is created by TabYang.

// 调用函数并传参
creatorInfo("John")
// 输出 This product is created by John.

5.4 函数返回值

Swift中，函数是有明确类型的，由参数和返回值确定，并且函数类型可以作为其他函数的参数和返回值。

传入函数的值叫参数，参数经函数中代码处理后返回的值叫返回值，参数和返回值对于不同目的的函数来说可有可无。对于不需要函数返回值的函数，返回值可为空；对于不需要参数的函数，参数列可为空。

函数所返回的结果叫做函数的返回值 Return Value，返回值的类型叫做返回类型 Return Type。

在 Swift 中，函数的类型由参数类型和返回值类型共同决定。如果传入参数为 Int 类型，返回值为 Double 类型，那么该函数的类型表示为：(Int) -> Double

// 定义函数
func convertToDouble(_ value: Int) -> Double {
    return Double(value) * 1.5
}

// 使用函数类型变量
let function: (Int) -> Double = convertToDouble
let result = function(10)
print(result)    // 返回 15.0

当函数体内部只有一个返回值时，可以省略 return 。

5.5 闭包 Closure

闭包Closure是Swift 中的一种代码块，类似于函数，可以捕获并存储其上下文中的变量和常量（值捕获）。可以理解为没有函数名的函数（即匿名函数），是函数的抽象。可以在程序中作为值传递和调用。

• 闭包的形式：
  1. 全局函数 Global Function：即普通函数，有函数名，不捕获任何值。
  2. 嵌套函数 Nested Functions：有函数名，并且可以捕获外层函数中的值。
  3. 闭包表达式 Closure Expressions：匿名闭包，常作参数或作返回值。
• 闭包的语法：

// 基本语法
{ ( <参数列表ParameterList> ) -> <返回值类型Return Type> in
    <闭包主体代码Closure Main Code>
}

• 闭包的类型：闭包的类型由其参数和返回类型决定

let add: (a: Int, b: Int) -> Int {(a, b) in
    return a + b
}
// 闭包类型为：(Int, Int) -> Int

• 闭包三种基本形式定义：

// 全局函数
func add(a: Int, b: Int) -> Int {
  return a + b
}
print(add(1, 2))    // 输出 3

// 基本闭包
let add = {(a: Int, b: Int) -> Int in 
    return a + b          
}
print(add(1, 2))    // 输出 3

// 嵌套函数：定义在一个函数内部，捕获外部函数中的值
// 嵌套函数会“捕获”外层函数的上下文，因此具备闭包的特性

// 定义一个嵌套函数outerFunction()
func outerFunction() -> () -> String {
  let message = "Outer Function"
  // 嵌套函数内部函数innerFunction()可以捕获外层函数值符合闭包
  func innerFunction() -> String {
    return message
  }
  return innerFunction
}

// 定义一个闭包变量名，outerFunction()返回一个闭包类型给closure
let closure: () -> String = outerFunction()
print(closure())

• 闭包表达式的定义：

// 闭包作为参数传递给函数,闭包类型为(Int, Int) -> Int)
// 闭包作为参数相当于向函数参数列里传入了一个方法
func performCalculation(_ operation: (Int, Int) -> Int) {
  let result = operation(1, 2)    // 传入闭包的参数列
  print("\(result)")
}
let addNumbers = {(a: Int, b: Int) -> Int in 
    return a + b                 
}
performCalculation(addNumbers)    // 普通闭包作为参数传递

// 闭包尾随表达法
// 当闭包是函数唯一的参数，可以去掉函数()
performCalculation {(a: Int, b: Int) -> Int in
    return a + b
}

// 闭包作为返回值
fun makeMultiplier(factor: Int) -> (Int) -> Int {
  return { number in
    return number * factor
  }
}
let multiplayByThree = makeMultiplier(factor: 3)
print(multiplyByThree(4))    // 输出 12

• 闭包的值捕获

  闭包可以捕获局部的变量和常量的值，在一个闭包中可以捕获外部函数的所有参数，和在外部函数内部定义的变量和常量的值。

• 闭包的简化

  • 类型推断：闭包参数列和返回值类型可以由Swift自动推断
  • 隐式返回：若闭包代码块内部只包含一句代码，可省略return
  • 参数名缩写：内联闭包的参数可以用 $0, $1来调用
  • 运算符方法：运算符可以作为闭包参数传递
  • 省略 in：当使用参数名缩写后需要省略in；当闭包参数为简单的运算符时，也要省略in
  • 省略函数( ): 闭包作为函数唯一参数传递时，可以省略函数( )

var array = [1, 4, 9, 2, 3]
array.sort(by: { (first: Int, second: Int) -> Bool in first > second})

// 类型推断：简化闭包值的类型
array.sort(by: { (first, second) in return first > second})

// 隐式返回：简化return
array.sort(by: { (first, second)  in first < second })

// 参数名缩写to
array.sort(by: { $0 > $1 })

// 运算符方法
array.sort(by: <)

// 省略函数 ()
array.sort { $0 > $1 }
print(array)

6. Swift数据容器 Data Container

6.0 集合：数组 Array

6.1 集合：字典 Dictionary

7. 循环

7.0 for-in 循环

7.1 for-each 循环

7.2 while 循环

7.3 repeat-while 循环

8. 可选型

9. Swift数据结构 Data Structure

9.0 结构定义

9.1值类型与引用类型

9.2 创建实体 Instance

9.3 结构属性和方法

9.4 初始化器

9.5 枚举型结构 Enumeration

9.6 类结构 Class

10. 协议 Protocol

10.0 可等性 Equatable

10.1 可比性 Comparable

10.2 可哈希性 Hashable

10.3 可辨识性 Identifiable

10.4 可编码型 Codable

11. 异常处理