swift基础语法

swift学习笔记

参考教程

https://www.runoob.com/swift/swift-data-types.html

swift代码规范

https://juejin.cn/post/7129465308376465422

1 环境搭建

必须要有苹果电脑且安装Xcode

2 基本语法

Swift是类型安全的语言，编译时会进行类型检查

import Cocoa
var mySting = "Hello, World!"
print(myString)

2.1 引入

可以使用import语句引入任何的Objective-C（C语言的严格超集）

• 创建macOS playground则引入Cocoa，Cocoa由Objective-C语言写成，因此可以混入C语言代码，甚至C++代码
• 创建iOS playground则引入UIKit

2.2 注释

// 这是单行注释（单行注释以//开头）

/* 多行注释
多行注释（以/*开始，以*/结束，可以嵌套单行注释）*/

2.3 分号

Swift不要求每行结尾使用分号，但在同一行书写多条语句必须用分号隔开

import Cocoa
var myString = "Hello, World!"; print(myString)

2.4 标识符

标识符是给变量、常量、方法、函数、枚举、结构体、类、协议等指定的名字

• 区分大小写
• 可以以字母或下划线开头，但不能以数字开头
• 标识符中的其他字符可以是字母、数字或下划线，不能是关键字

Swift使用Unicode编码，可以使用中文，甚至聊天表情符

import Cocoa
// 如果一定要使用关键字作标识符，可以在关键字前后加`
let `class` = "Runoob"

2.5 关键字

2.6 空格

Swift语言并不是像C/C++，Java那样完全忽视空格，Swift对空格的使用有一定的要求，但是又不像Python对缩进的要求那么严格。在Swift中，运算符不能直接跟在变量或常量的后面。

import Cocoa
// 错误1：let a= 1+ 2
// 错误2：let a = 1+ 2

let a = 1 + 2
let b = 3+4  // 这样写是可以的

为避免错误，尽量严格缩进

2.7 打印输出

import Cocoa
print("Runoob")  // 使用print函数输出，如果多个print，默认换行输出
// 如果不想换行则将terminator设置为空字符串，这样每个输出以空格分隔
for x in 0...10 {  // 这是循环语句，后续会介绍
  print("\(x)", terminator: "")  // \()可以将x变为字符串
}

// 如果接收用户的输入使用readLine()
let theInput = readLine()

3 数据类型

3.1 内置数据类型

• Int：整型，在32位平台上和Int32长度相同，在64位平台上和Int64长度相同
• UInt：无符号整型，在32位平台上和UInt32长度相同，在64位平台上和UInt64长度相同（尽量不要使用UInt，统一使用Int可以提高代码的可复用性）
• Float：32位浮点数，精度较低，至少有6位数字
• Double：64位浮点数，精度很高，至少有15位数字
• Bool：布尔值，有true、false和nil（表示没有值）
• String：字符串，是字符的序列集合，用双引号引起来
• Character：字符，单个字母，用双引号引起来
• Optional：可选类型，表示有值或没有值
  

3.1.1 字符串

1.字符串的创建：使用字符串字面量或String类实例子创建字符串

import Cocoa

// 使用字符串字面量创建字符串
var stringA = "Hello, World"
print(stringA)

// 使用String类的实例创建字符串
var stringB = String("Hello, World!")
print(stringB)

2.空字符串，可以使用字符串属性isEmpty判断字符串是否为空

import Cocoa

// 使用字符串字面量创建空字符串
var stringA = "" 
if stringA.isEmpty {
  print("stringA是空的")
} else {
  print("stringA不是空的")
}

// 使用String类的实例创建空字符串
var stringB = String()
if stringB.isEmpty {
  print("stringB是空的")
} else {
  print("stringB不是空的")
}

3.字符串插值：在字符串中使用反斜线和括号插入变量

import Cocoa
var age: Int = 24
print("My age is \(age)")

4.字符串连接：使用加号连接

import Cocoa
let constA = "Hello, "
let constB = "World!"
var stringComb = constA + constB
print(stringComb)

5.字符串长度：使用count属性计算

import Cocoa
var varA = "Hello, World!"
print("\(varA)的长度为\(varA.count)")  // 输出为13

6.字符串比较：使用==比较两个字符串是否相同

7.Unicode字符串：String是基于Unicode建立的，可以循环迭代出字符串中的UTF-8和UTF-16的编码

import Cocoa
var unicodeString = "Hello, World!"
for code in unicodeString.utf8 {
  print(code)
}

for code in unicodeString.utf16 {
  print(code)
}

8.字符串分割成数组

import Cocoa

let fullName = "First Last"
let fullNameArr = fullName.split{" "}.map(String.init)

fullNameArr[0] // First
fullNameArr[1] // Last

3.1.2 字符

1.空字符：swift不能创建空字符常量或变量

2.遍历字符串中的字符

import Cocoa
for ch in "Hello, World!" {
  print(ch)
}

3.字符串连接字符：使用String的append()方法

import Cocoa
var varA: String = "Hell"
var varB: Character = "o"

varA.append(varB)
print(varA)

3.2 类型别名

// 使用typealias关键字定义
import Cocoa
typealias Feet = Int  // 定义类型别名
var distance: Feet = 100
print(distance)

3.3 类型推断

如果没有显示的制定类型，Swift会根据初始值进行类型推断

import Cocoa
let meaningOfLife = 42  // meaningOfLife被推断为Int类型
let pi = 3.1415  // pi被推断为Double类型，而非Float类型
let anotherPi = 3 + 0.1415  // anotherPi被推断为Double类型

4 变量

4.1 变量声明

使用var关键字来声明

import Cocoa
// 方式一：
var varA: Int
varA = 42

// 方式二：
var varB: Double = 3.14

4.2 变量命名

• 变量名可以由字母、数字和下划线组成
• 变量名需要以字母或下划线开始
• 变量名区分大小写
• 变量名可以使用Unicode

import Cocoa
var 你好 = “你好”
print(你好）

4.3 变量输出

• 变量和常量使用print函数输出
• 字符串差值输出：在字符串中使用反斜线和括号插入变量

import Cocoa
var age: Int = 24
print("My age is \(age)")

5 可选类型

Optional：可选类型，用于处理值缺失情况，表示可能有或可能没有值

当声明一个可选变量或者可选属性时没有提供初始值，则默认为nil

// 声明方式
// 方式一：
var optionalInteger1: Int?  // 类型和?之间没有空格
// 方式二：
var optionalIneger2: Optional<Int>

// 强制解析：如果一个可选类型的实例包含一个值，可以用后缀!来访问这个值，如果可选类型为nil，使用!运行时会报错
optionalInteger1 = 42
print(optionalInteger1!)  // 强制解析

// 自动解析：在声明可选变量时使用!替代?，后续再获取该值时不需要!强制解析
var myString: String!
myString = "Hello, World!"
print(myString)

可选绑定：判断可选类型是否包含值，如果包含就把值赋给一个临时常量或变量，用在if和while语句

import Cocoa
var myString: String?
myString = "Hello World!"
if let yourString = myString {
	print("你的字符串的值为：\(yourString)")
} else {
  print("你的字符串没有值"）
}

6 常量

6.1 常量声明

常量类似于变量，区别在于常量的值一旦设定就不能改变，而变量的值可以随意更改，使用let关键字来声明

import Cocoa
let constA = 42
print(constA)

6.2 类型标注

import Cocoa
let constB: Double = 3.14
print(constB)

6.3 常量命名

和变量的命名规则相同，同4.2

6.4 常量输出

和变量的输出方式相同，同4.3

7 字面量

7.1 整型字面量

二进制前缀为0b，八进制前缀为0o，十六进制前缀为0x，十进制没有前缀

let decimalInteger = 17  // 十进制17
let binaryInteger = 0b100001  // 二进制17
let octalInteger = 0o21  // 八进制17
let hexadecimal = 0x11  // 十六进制17

7.2 浮点型字面量

let decimalDouble = 12.1e2  // 十进制浮点型字面量：12.1*10^2
let hexadecimalDouble = 0xC.3p3  // 十六进制浮点型字面量：12.3*2^3

7.3 字符串型字面量

字符串型字面量中不能包含未转义的引号，未转义的反斜线、回车符或换行符

7.4 布尔型字面量

• true表示真
• false表示假
• nil表示没有值

8 运算符

8.1 算术运算符

+、-、*、/、%

Swift中已经取消了++和–

8.2 比较运算符

==、!=、>、<、>=、<=

8.3 逻辑运算符

• &&：逻辑与
• ||：逻辑或
• !：逻辑非

8.4 位运算符

对二进制位进行操作

• &：按位与
• |：按位或
• ^：按位异或，输入数同一位不同为1，相同为0
• ~：按位取反
• <<：按位左移，左移后左边的数位被丢弃，右边的空位用0填充
• >>：按位右移，右移后右边的数位被丢弃，左边的空位用0填充

8.5 赋值运算符

=、+=、-=、*=、/=、%=、&=、|=、^=、<<=、>>=

8.6 区间运算符

• a…b：闭区间运算符，定义一个从a到b（包括a和b）所有值的区间
• a…<b：开区间运算符，定义一个从a到b但不包含b的所有值的区间

8.7 其他运算符

• a ? b : c 三目运算符，如果a为true值为b，否则为c
• ?? 合并空值运算符，例如a ?? b，如果a有值则展开，如果没有值（nil），则返回b。其中表达式a必须是可选类型，表达式b必须与a的存储类型相同

8.8 运算符优先级

原则

• 指针最优，单目运算符优于双目运算符
• 先乘除后加减
• 先算数运算符，后移位运算符，最后位运算符
• 逻辑运算符最后计算

9 条件语句

10 循环语句

11 数组

如果创建一个数组，并赋值给一个变量，则创建的集合可添加、删除、修改，如果赋给常量则数组不可更改

11.1 创建数组

import Cocoa
// 1. 创建Int类型的空数组变量
// 法一：（推荐）
var someInts1: [Int] = []
// 法二
var someInts2 = [Int]()

// 2. 创建数量为3，初始值为0的Int类型数组
var someInts3 = [Int](repeating: 0, count: 3)

// 3. 创建含有3个元素的数组
var someInts4: [Int] = [10, 20, 30]  // 必须用逗号隔开，不能只用空格隔开

11.2 访问数组

// 通过索引获取数组值：索引下标从0开始
import Cocoa
var someInts = [Int](repeating: 10, count: 3)
var someVar: Int = someInts[0]
print(someVar)

11.3 修改数组

import Cocoa
// 1. 数组末尾添加元素：append()方法或+=
var someInts: [Int] = []
someInts.append(10)
someInts += [20]
print(someInts[0])
print(someInts[1])

// 2. 通过索引修改数组元素值
someInts[1] = 30
print(someInts[1])

11.4 遍历数组

import Cocoa
// 使用for-in循环遍历数组
var someStrs: [String] = ["Hello", "World"]
for item in someStrs {
  print(item)
}

11.5 合并数组

// 可以使用+合并两种已存在的相同类型数组
import Cocoa
var intA = [Int](repeating: 2, count: 2)
var intB = [Int](repeating: 1, count: 3)
var intC = intA + intB
for item in intC {
  print(item)
}

11.6 属性

import Cocoa
// 1. count属性：统计数组元素个数
var intA = [Int](repeating: 2, count: 2)
var intB = [Int](repeating: 1, count: 3)
var intC = intA + intB
print(intC.count)

// 2. isEmpty属性：判断数组是否为空，如果为空返回true，不为空返回false
var varA: [Int] = []
var varB: [Int] = [1, 2, 3]
print(varA.isEmpty)
print(varB.isEmpty)

12 字典

• 字典用来存储无序的相同类型数据的集合。
• 字典中每个值（value）都有关联唯一的键（key），键是值的标识符，通过键访问值，键的类型没有限制但必须唯一
• 同数组一样，如果创建的字典赋值给变量则字典可以修改，赋值给常量则不可修改

12.1 创建字典

import Cocoa
// 1. 创建一个空字典，键的类型为Int，值的类型为String
// 法一（推荐）：
var someDict1: [Int: String] = [:]
// 法二：
var someDict2 = [Int: String]()

// 2. 创建字典实例：注意冒号前无空格，冒号后有空格
var someDict3: [Int: String] = [1: "one", 2: "two"]  

12.2 访问字典

import Cocoa
// 根据字典的键来访问值
var someDict: [Int: String] = [1: "one", 2: "two"]  
var varA: String? = someDict[1]  // 注意如果标注类型，必须是可选类型
var varB = someDict[2]  // varB也是可选类型
print(varA!)
print(varB!)

12.3 修改字典

// 使用updateValue(, forKey: )增加或更新字典内容，如果key不存在，则添加该键值，如果key存在则修改对应的value，该方法返回原来旧的value的Optional类型值
import Cocoa
var someDict: [Int: String] = [1: "One", 2: "Two"]
var oldVal = someDict.updateValue("One 新的值", forKey: 1)  
var newVal = someDict[1]  

print(oldVal)  // oldVal值为Optional("One")
print(newVal)  // newVal值为Optional("One 新的值")

12.4 移除Key-Value对

// 法一：使用removeValue(forKey: )，返回Value的Optional类型值，如果不存在返回nil
import Cocoa
var someDict: [Int: String] = [1: "One", 2: "Tow", 3: "Three"]
var removeValue1 = someDict.removeValue(forKey: 2)  
var removeValue2 = someDict.removeValue(forKey: 4)

print(removeValue1)  // removeValue1值为Optional("Tow")
print(removeValue2)  // removeValue2值为nil

// 法二：也可以通过指定键的值为nil来移除键值对
someDict[1] = nil
print(someDict[1])  // nil

12.5 遍历字典

import Cocoa
var someDict: [Int: String] = [1: "One", 2: "Tow", 3: "Three"]

// 法一：使用for-in循环遍历
for (key, value) in someDict {
  print("键\(key)对应的值为\(value)")
}
// 键2对应的值为Tow
// 键1对应的值为One
// 键3对应的值为Three

// 法二：使用enumerated()遍历，返回的是字典的索引以及键值对
for (key, value) in someDict.enumerated() {  // key是索引，value是键值对
  print("索引\(key)对应的键值对为\(value)")
}
// 索引0对应的键值对为(key: 2, value: "Tow")
// 索引1对应的键值对为(key: 1, value: "One")
// 索引2对应的键值对为(key: 3, value: "Three")

12.6 字典转换成数组

// 使用字典的keys属性和values属性将键和值分别转变为数组
import Cocoa
var someDict: [Int: String] = [1: "One", 2: "Tow", 3: "Three"]
let dictKeys = [Int](someDict.keys)
let dictValues = [String](someDict.values)
// 以下是错误写法！！！
// let dictKeys: [Int] = someDict.keys
// let dictValues: [String] = someDict.values

for key in dictKeys {
  print(key)
}
// 2
// 3
// 1

for value in dictValues {
  print(value)
}
// Tow
// Three
// One

12.7 常用属性

import Cocoa
var someDict1: [Int: String] = [1: "One", 2: "Tow", 3: "Three"]
// 属性一：count属性统计键值对的个数
print(someDict1.count)  // 3
// 属性二：isEmpty判断字典是否为空，空为true，不空为false
var someDict2: [Int: String] = [:]
print(someDict2.isEmpty)  // true

13 函数

13.1 函数定义

• 使用func关键字定义
• 可指定0个、一个或多个输入参数和一个返回值类型
• 函数的实参传递顺序必须与形参列表相同，->后为函数的返回值类型

// 形式
// func funcname(形参名: 形参类型) -> returnType {
// 	...
// 	return ...
// }

import Cocoa
func cityHello(city: String, hello: String) -> String {
  return city + " " + hello
}
print(cityHello(city: "北京", hello: "你好！"))  // 注意city和hello不能省略

13.2 函数参数

• 局部参数名：只能在函数体内部使用

import Cocoa
// city和hello是局部参数
func cityHello(city: String, hello: String) -> String {
  return city + " " + hello
}
print(cityHello(city: "北京", hello: "你好！"))

• 外部参数名：在局部参数名前加外部参数名，再函数被调用时，必须使用外部参数名

import Cocoa
func printFunc(agrv hello: String) {
  print("北京 \(hello)")
}
printFunc(argv: "你好")

// 忽略外部参数名
import Cocoa
func printFunc(_ hello: String) {
  print("北京 \(hello)")
}
printFunc("你好")

• 可变参数：可以接受另个或多个参数，通过在变量类型后加…定义

import Cocoa
func vari<Int>(members: N...){
  for i in members { print(i) }
}
vari(members: 3, 4, 5)
vari(members: 3.1, 4.1, 5.1)
vari(members: "你好", "北京")

13.3 值传递与引用传递

• 函数中的参数默认都是常量，只能查看，不能修改。
• 如果想要声明变量参数，进行引用传递，需要在参数类型前加inout关键字。且在调用时加&

import Cocoa
func swapFunc(_ a: inout Int, _ b: inout Int) {
  var temp = a
  a = b
  b = temp
  print("参数1在函数中的值为\(a)，参数2在函数中的值为\(b)")  // 2， 1
}
var x = 1
var y = 2
swapFunc(&x, &y)
print("参数1在函数外的值为\(x)，参数2在函数外的值为\(y)")  // 2， 1

13.4 函数返回值

元组作为返回值

• 元组与数组类似，不同的是，元组中的元素可以是任意类型，使用圆括号
• 可以使用元组类型让多个值作为一个复合值从函数中返回

// 定义一个函数，实现找到Int数组的最小值和最大值
import Cocoa
func minMax(array: [Int]) -> (min: Int, max: Int) {
  var currentMin = array[0]
  var currentMax = array[0]
  for value in array[1..<array.count] {
    if value < currentMin {
      currentMin = value  // 和C/C+不同的是尽管只有一条语句，也不能不加大括号和if写在一行
    }
    if value > currentMax {
      currentMax = value
    }
  }
  return (currentMin, currentMax)
}
let array: [Int] = [1, 2, 3, 4]
let val = minMax(array: array)
print("array的最小值为\(val.min)，array的最大值为\(val.max)")

• 如果不确定返回的元组一定不为nil，则可以返回一个可选元组类型，例如(Int, Int)?，注意与(Int?, Int?)不同，(Int, Int)?整个元组是可选的，不只是元组中的每个元素值。上面找最小值和最大值的函数，如果传入的array为空，则应该返回nil

import Cocoa
func minMax(array: [Int]) -> (min: Int, max: Int)? {
  if array.isEmpty { return nil }
  var currentMin = array[0]
  var currentMax = array[0]
  for value in array[1 ..< array.count] {
    if value < currentMin { currentMin = value} 
    if value > currentMax { currentMax = value}
  }
  return (min: currentMin, max: currentMax)
}
let array: [Int] = [1, 2, 3, 4, 5]
if let val = minMax(array: array) {
  print("array的最小值为\(val.min)，array的最大值为\(val.max)")
}

没有返回值函数

• 只需要去掉 -> return type

import Cocoa
func printFunc(hello: String) {
  print("北京 \(hello)")
}
printFunc(hello: "你好")

13.5 函数类型

• 函数类型与其他类型类型，可以定一个类型为函数的常量或变量

import Cocoa
func sum(a: Int, b: Int) -> Int {
  return a + b
}
var add: (Int, Int) -> Int = sum  // 定义一个名为add的函数变量，该变量的参数类型和返回值都为Int，并将这个变量指向sum函数
print(add(1, 2))  // 输出3，注意不要加a和b
print(sum(a: 1, b: 2))  // 输出3，注意要加a和b

13.6 函数嵌套

函数嵌套指的是函数内定义一个新的函数，外部函数可以调用函数内定义的函数

14 闭包

14.1 定义与语法

• 定义：闭包是自包含的功能代码块，可以在代码中使用或者用来作为参数传值，和匿名函数类似

• 形式：

  • 全局函数：有名字但不能捕获任何值
  • 嵌套函数：有名字也能捕获封闭函数内的值
  • 闭包表达式：无名闭包，使用轻量语法，根据上下文环境捕获值

• 语法

{(parameters) -> return type in
   statements
}

import Cocoa
let divide = {(val1: Int, val2: Int) -> Int in
	return val1 / val2
}
print(divide(200, 20))

14.2 闭包表达式

• sorted方法：会根据用于排序的闭包函数对数组中的值进行排序，该方法返回一个与原数组长度大小相同且排序正确的新数组，原数组不会被更改。
• sorted方法需要传入两个参数
  • 已知类型的数组
  • 闭包函数：传入两个与数组元素类型相同的两个值，返回布尔值

全局函数

import Cocoa
let num: [Int] = [2, 3, 1, 4]

// 使用全局函数提供排序，闭包函数类型为(Int, Int) -> Bool
func backwards(val1: Int, val2: Int) -> Bool {
	return val1 > val2	// 从大到小排列
}
var reversed = num.sorted(by: backwards)
print(reversed)  // [4, 3, 2, 1]

参数名称缩写

import Cocoa
let num: [Int] = [2, 3, 1, 4]
// swift自动为内联函数提供了参数名称缩写功能，可以直接通过$0，$1顺序调用闭包参数
var reversed = num.sorted(by: { $0 > $1 })
print(reversed)  // [4, 3, 2, 1]

运算符函数

import Cocoa
let num: [Int] = [2, 3, 1, 4]
// 使用运算符排序
var reversed = num.sorted(by: >)
print(reversed)  // [4, 3, 2, 1]

尾随闭包

import Cocoa
let num: [Int] = [2, 3, 1, 4]
// sorted()后的{ $0 > $1 }为尾随闭包
var reversed = num.sorted() { $0 > $1 }
print(reversed)  // [4, 3, 2, 1]

14.3 捕获值

• 闭包可以在其定义的上下文中捕获常量或变量
• swift最简单的闭包是嵌套函数，即定义在其他函数内的函数，嵌套函数可以捕获其外部函数所有的参数及定义的常量和变量

import Cocoa
func makeIncrementor(forIncrement amount: Int) -> () -> Int {
  var runningTotal = 0
  func incrementor() ->Int {
    runningTotal += amount
    return runningTotal
  }
  return incrementor
}
let incrementByTen = makeIncrementor(forIncrement: 10)
print(incrementByTen())  // 10
print(incrementByTen())  // 20
print(incrementByTen())  // 30

• 上面例子尽管incrementByTen是一个常量，但这个常量指向的闭包仍可以增加其捕获的变量值，因为函数和闭包都是引用类型。
• incrementByTen指向闭包的引用是一个常量，并非闭包本身是常量。因此如果将闭包赋值给了两个不同的常量/变量，两个值都会指向同一个闭包

import Cocoa
func makeIncrementor(forIncrement amount: Int) -> () -> Int {
  var runningTotal = 0
  func incrementor() ->Int {
    runningTotal += amount
    return runningTotal
  }
  return incrementor
}
let incrementByTen = makeIncrementor(forIncrement: 10)
print(incrementByTen())  // 10
print(incrementByTen())  // 20
print(incrementByTen())  // 30
// 
let alsoIncrementByTen = incrementByTen
print(alsoIncrementByTen())  // 40

15 枚举

15.1 定义与语法

• 定义：一种数据类型，只包含自定义的特定数据，是一组有共同特性的数据集合，声明在类中，通过实例化类来访问值
• 语法：使用enum和case关键词来创建枚举
• 注意：swift的枚举成员在创建时不会被赋予整型值
• 枚举、结构体、类的标识符（即名称）一般采用大驼峰（即第一个单词的首字母大写）

import Cocoa
enum DaysofWeek {  
  case Sunday
  case Monday
  case Tuesday
  case Wednesday
  case Thursday
  case Friday
  case Saturday
}
var weekDay = DaysofWeek.Thursday
weekDay = .Friday 

15.2 相关值与原始值

相关值：可以是不同类型

import Cocoa
enum Student {
  case Name(String)
  case Mark(Int, Int, Int)
}
var studMarks = Student.Mark(1, 2, 3)
switch studMarks {
  case .Name(let studName):
  	print("学生的名字是\(studName)")
  case .Mark(let mark1, let mark2, let mark3):
  	print("学生的成绩是\(mark1)、\(mark2)、\(mark3)")
}

// 输出：学生的成绩是1、2、3

原始值：可以是整型、符点型、字符或字符串值。每个原始值在枚举声明中唯一。在原始值为整数枚举时，不需要显示的为每个成员赋值，swift会自动赋值，隐式赋值依次递增1，如果第一个值没有被赋处置，将会被自动设置为0

import Cocoa
enum Month: Int {
  case January = 1, February, March, April, May, June, July, August, September, October, November, December
}
let yearMonth = Month.May.rawValue
print("月份为：\(yearMonth)")  // 月份为：5

16 结构体

16.1 语法

• 通过struct关键字定义，可以定义属性和方法。结构体允许我们创建一个单一文件，且系统会自动生成面向其他代码的外部接口

import Cocoa
struct MarkStruct {
  var mark: Int
  
  init(mark: Int) { self.mark = mark }
}
var aStruct = MarkStruct(mark: 99)
var bStruct = aStruct
bStruct.mark = 100
print(aStruct.mark)  // 99
print(bStruct.mark)  // 100

16.2 应用

应用场景

• 几何形状的大小：封装一个width属性和height属性，两者均为Double类型
• 一定范围内的路径：封装一个start属性和length属性，两者均为Int类型
• 三维坐标系内一点：封装x，y和z属性，三者均为Double类型

注意：结构体实例是通过值传递而不是引用

17 类

类可以定义属性和方法，和其他语言不同，swift不要求为自定义类去创建独立的接口和实现文件，只需要在一个单一文件中定义一个类，系统会自动生成面向其他代码的外部接口

import Cocoa
class MarkClass {
  var mark: Int
  init(mark: Int) { self.mark = mark }
}

let marks = MarkClass(mark : 100)
print("成绩为\(marks.mark)")

17.1 类和结构体对比

共同点：

• 定义属性用于存储值
• 定义方法用于提供功能
• 定义附属脚本用于访问值？
• 定义构造器用于生成初始化值
• 通过扩展以增加默认实现的功能？
• 符合协议以对某类提供标准功能？

与结构体相比，类还有如下的附加功能

• 继承：允许一个类继承另一个类的特征
• 类型转换：允许在运行时检查和解释一个类实例的类型？
• 解构器：允许一个类实例释放任何其所被分配的资源
• 引用计数：允许对一个类的多次引用

17.2 恒等运算符

类是引用类型，有可能有多个常量和变量在后台同时引用某一个类实例

import Cocoa

class SampleClass {
  let myProperty: String
  init(s: String) { myProperty = s }
}
let spClass1 = SampleClass(s: "Hello")
let spClass2 = SampleClass(s: "Hello")
if spClass1 === spClass2 { print("引用相同的类实例") }
if spClass1 !== spClass2 { print("引用不同的类实例") }

18 属性

属性可分为存储属性和计算属性

18.1 存储属性

存储属性是存储在特定类或结构体的实例里的一个常量或变量，可以在定义存储属性的时候指定默认值，也可以在构造过程中设置或修改存储属性的值

import Cocoa
struct Number {
  var digits: Int
  let pi = 3.14  // 定义存储属性的时候指定默认值
}
var n = Number(digits: 123)  // 构造过程中设置存储属性的值
n.digits = 1234  // 不会报错，构造过程中修改存储属性的值
// n.pi = 3.141  // 会报错，因为pi是常量
print(n.digits)  // 1234
print(n.pi)  // 3.14

18.2 延迟存储属性

延迟存储属性是指当第一次被调用的时候才会计算其初始值的属性，必须将延迟存储属性声明为变量（var关键词），因为常量属性在构造完成之前必须要有初始值。延迟存储属性常用于延时对象的创建、属性的值依赖于其他未知类。

import Cocoa
class Sample {
  lazy var no = Number()  // lazy定义延迟存储属性，且该属性为var
}
class Number {
  var name = "world"
}
var firstSample = Sample()
print(firstSample.no.name)

18.3 计算属性

计算属性不直接存储值，而是提供一个get来获取值，一个可选的set来设置其他属性或变量的值

import Cocoa

class Sample {
  var no1 = 0.0, no2 = 0.0
  var length = 300.0, breadth = 150.0
  var middle: (Double, Double) {
    get { return (length / 2, breadth / 2) }
    set(axis) {
      no1 = axis.0 - (length / 2)
      no2 = axis.1 - (breadth / 2)
    }
  }
}
var result = Sample()
print(result.middle)
result.middle = (0.0, 10.0)  // (150.0, 75.0)
print(result.no1)  // -150.0
print(result.no2)  // -65.0

18.4 只读计算属性

只有get没有set的计算属性为只读计算属性

import Cocoa
class Film {
  var head = ""
  var duration = 0.0
  var metaInfo: [String: String] {
    return [
      "head": self.head,
      "duration": "\(self.duration)"
    ]
  }
}
var move = Film()
move.head = "Swift 属性"
move.duration = 3.09

print(move.metaInfo["head"]!)  // Swift 属性
print(move.metaInfo["duration"]!)  // 3.09

18.5 属性观察器

属性观察器监控和响应属性值的变化，每次属性被设置值的时候都会调用属性观察器。可以为除了延迟存储属性之外的其他存储属性添加属性观察器，也可以通过重载属性的方式为继承的属性添加属性观察器。不需要为无法重载的计算属性添加属性观察器，因为可以通过set直接监控和响应值的变化。（用willSet和didiSet实现属性观察器）

import Cocoa
class Sample {
  var counter: Int = 0 {
    // 先执行willSet，再执行didSet
    willSet(newTotal) { print("计数器：\(newTotal)") }
    didSet {
      if counter > oldValue { print("新增数：\(counter - oldValue)") }  // oldValue为counter的旧值
    }
  }
}
let newCounter = Sample()
newCounter.counter = 100
newCounter.counter = 800

// 结果为：
// 计数器：100
// 新增数：100
// 计数器：800
// 新增数：700

18.6 类型属性

和实例属性区分开，类型属性是类型定义的一部分写在类型最外层的花括号里，使用关键字static定义值类型的类型属性，class定义类类型的类型属性

import Cocoa

struct StudMarks {
  static let markCount = 97
  static var totalCount = 0
  var InternalMarks: Int = 0 {
    didSet {
      if InternalMarks > StudMarks.markCount {
        InternalMarks = StudMarks.markCount
      }
      if InternalMarks > StudMarks.totalCount {
        StudMarks.totalCount = InternalMarks
      }
    }
  }
}

var stud1Mark1 = StudMarks()
var stud1Mark2 = StudMarks()

stud1Mark1.InternalMarks = 98
print(StudMarks.totalCount)  // 获取类型属性

stud1Mark2.InternalMarks = 87
print(StudMarks.totalCount)  // 获取类型属性

19 方法

在oc中，类是唯一能定义方法的类型，但在swift中，可以在类/结构体/枚举上定义方法

19.1 实例方法

• 实例方法可以访问和修改实例属性，提供与实例目的相关的功能
• 实例方法能够隐式访问它所属类型的所有的其他实例属性和方法
• 实例方法只能被它所属的类型的某个特定实例调用，不能脱离实例而被调用

import Cocoa
class Counter {
  var count = 0
  func increment() { count += 1 }
  func incrementBy(amount: Int) { count += amount }
  func reset() { count = 0 }
}
let counter = Counter()
counter.increment()
print(counter.count)  // 1
counter.incrementBy(amount: 5)
print(counter.count)  // 6
counter.reset()
print(counter.count)  // 0

19.2 方法的局部参数名称和外部参数名称

swift默认给方法的第一个参数名称一个局部参数名称，默认给第二个和后续的参数名称为外部参数名称

import Cocoa

class division {
  var count: Int = 0
  func incrementBy(no1: Int, no2: Int) {  // no1为局部参数名称，no2为外部参数名称
    count = no1 / no2
    print(count)
  }
}
let counter = division()
counter.incrementBy(no1: 1800, no2: 3)  // 600

19.3 self属性

每个实例都有self属性，self完全等同于实例本身

import Cocoa
class Cal {
  let a: Int
  let b: Int
  let res: Int
  init(a: Int, b: Int) {
    self.a = a
    self.b = b
    self.res = a + b
  }
}
let sum = Cal(a: 1, b: 2)
print(sum.res)  // 3