本文源自本人的学习记录整理与理解，其中参考阅读了部分优秀的博客和书籍，尽量以通俗简单的语句转述。引用到的地方如有遗漏或未能一一列举原文出处还望见谅与指出，另文章内容如有不妥之处还望指教，万分感谢。
流程控制
if - else 使用注意
-
if后面的小括号可以省略不写，条件后面大括号必须要写 -
if判断条件只能是BOOl类型 -
while循环和if的要求是一样的 -
repeat-while相当于C语言中的do-while -
do-while和while的区别是：do-while一定会执行一次，while不满足条件一次都不会执行
if age < 18 {
print("逍遥侯还年轻😁")
}else if age > 18 {
print("😌 年轻真好！")
}
注意：从swift3开始去掉了 ++ 和 --
为什么会去掉++ 和 --呢 ？
虽然这两个运算符好用，但是可读性差且在不同编译器中编译结果是不同的。比如： ++ 放在变量前面和方后面是有区别的，很多时候需要多考虑一步。当出现 ++age ＋ ++age 可读性瞬间就变的很差
微软编译器：首先会对第一个++age 进行加加变成age=21，进行加法运算时发现右边也有加加认为自加加的优先级高，会进行一次自加加运算，这时候两边都是 age=22; 两个22相加结果就是 44
苹果编译器：首先会对第一个++age 进行加加变成age=21，进行加法运算时发现右边也有加加认为自加加的优先级高，会进行一次自加加运算，这时候左边 age=21，右边这时候左边 age=22;结果就是 43
var age = 20
++age ＋ ++age
微软编译器：输出44
GCC编译器：输出43
for循环的运算符
- 闭区间运算符：a...b 这就表示取值区间在大于等于a小于等于b之间 a <= 取值 <= b ; 闭区间也可以定义成一个Range
- 半开区间运算符：a..<b , 这就表示取值区间在大于等于a小于b之间 a <= 取值 < b ; 闭区间也可以定义成一个Range
- 单侧区间：让区间朝一个方向尽可能的远，但不能越界
- 区间运算符也可以用在数组上
Range.png
a...b
let names = ["anna", "alex", "brian", "jack"]
for i in 0...3 {
print(names[i])
}
-------------------- -------------------
定义成 Range
let range = 1...3
for i in range {
print(names[i])
}
-------------------- -------------------
i 默认是let, 如果需要在循环内修改 就需要声明为变量 var
for var i in 0...3 {
print(names[i])
}
-------------------- -------------------
如果循环内部不会用到 i 索引 ，建议直接写成下划线 _ ;不写的话会报警告
for _ in 0...3 {
print(names[i])
}
-------------------- -------------------
区间运算符用在数组上
for name in names[0...3] {
print(names[name])
}
-------------------- -------------------
单侧区间
//无穷大，最大是数组长度减一
for i in names[0...] {
print(names[name])
}
//无穷小，最小是0
for i in names[...3] {
print(names[name])
}
定义成 Range
let range = ...5 //小于5一直到负无穷，和直接写在循环里的不同
contains：调用此方法返回传入的索引是否在区间之内
range.contains(7) //false
range.contains(4) //true
range.contains(-3) //true
- 区间类型
区间类型.png
"cc"..."ff": 就表示从 cc cd cf ce cf cg ch ........ ff 这样一个区间
“a”..."f" : 就表示 a b c d e f
- 带间隔的区间值，需要使用到
stride函数
let hours = 11
let hourIntval = 2
//tickMark的取值：从4开始，累加2，不超过11
for tickMark in stride(from:4, through:hours, by: hourIntval) {
print(tickMark)
}
输出：4 6 8 10
- where 用于for循环
for-where.png
switch使用
case、default后面不能写大括号 --> {}默认可以不写break, 因为编译器已经自动添加了break
如果需要贯穿
case判断,需要在case结束添加fallthroughswitch是安全的，如果没有处理完各种情况会直接报错
switch可以用来判定枚举值，这一点和OC中使用类似
注意：如果default没有做任何处理，就必须添加
break，不然会报：'default' label in a 'switch' should have at least one executable statement的错误
'switch'中的'default'标签应该至少有一个可执行语句注意：case必须有实现, OC中可以没有实现，如果没有会报错：
'case' label in a 'switch' should have at least one executable statement
'switch'中的'case'标签应该至少有一个可执行语句
var num = 1
switch num {
case 0:
print("逍遥侯")
default:
print("发飙妹")
}
-----------------------------------------------
switch num {
case 0:
print("逍遥侯")
fallthrough
case 1:
print("封轻扬")
default:
print("发飙妹")
}
switch注意点.png
- 复合条件： switch也支持Character(字符)、String类型
let string = "逍遥侯"
//两个case都会进来
switch string {
case "逍遥侯":
fallthrough
case "封轻扬":
print("666666")
default:
break
}
输出：666666
----------------------
以下写法在OC中是不支持的
let string = "逍遥侯"
//两个case都会进来
switch string {
case "逍遥侯" , "封轻扬": //复合case
print("666666")
default:
break
}
输出：666666
- 区间匹配、元组匹配
区间匹配、元组匹配示例.png
- 值绑定 ：只需要判定一个符合条件就可以
值绑定.png
- 值绑定➕where条件
- where在循环内的作用是过滤掉不符合条件的元素，并不是阻断；类似
continue
值绑定➕where条件.png
- 标签语句
outer
outer标签
outer: for i in 1...4 {
for k in 1...4 {
if k ==3 {
continue outer
}
if i ==3 {
break outer
}
print("i == \(i), k == \(k)")
}
}
i == 1, k == 1
i == 1, k == 2
i == 2, k == 1
i == 2, k == 2
函数
函数的定义：func 函数名(参数类型) ->返回值类型 {}
- 形参默然是let, 也只能是let
//没有参数，返回int类型
func config() -> Int {
return 20
}
//需要传参，返回Int类型
func sum(v1: Int, v2: Int) -> Int
{
return v1 + v2
}
sum(v1: 10, v2: 5)
-隐式返回(Implicit Return)
- 如果整个函数体是一个单表达式，那么函数会隐式返回这个表达式
func sum(v1: Int, v2: Int) -> Int
{
//会将v1+v2的值返回
v1 + v2
}
sum(v1: 10, v2: 5)
- 返回元组：实现多返回值
//计算两个数的和、差、平均值
func sum(v1: Int, v2: Int) -> (sum: Int, difference: Int, average: Int)
{
sum = v1 + v2
//sum >> 1：和右移一位就相当于除以2
return (sum, v1-v2, sum >> 1)
}
let result = calculate(v1: 20, v2: 10)
result.sum //30
result.difference//10
result.average//15
- 函数的文档注释
标准写法.png
- 参数标签(Argument Label)
- 可以修改参数标签
- 参数标签的设计可以让我们想说英文一样 -->
go to work at 09:00 九点钟上班 - 可以使用下划线
_省略参数标签
可以看出at是参数标签用在函数体外面代替参数名，而time用在函数内部
func goToWork(at time: string) {
print("this time is \(time)")
}
goToWork(at: "9:00")
可以看出at是用在函数体外面代替参数名，而time用在函数内部
- 默认参数值(Default Paramenter Value), 参数可以有默认值；当调用函数时没有传那个参数，函数内部就会使用默认值
- C++的默认参数值有限制：必须从右往左设置，不能有间断。Swift传参时拥有参数标签，因此没有此限制，如果一旦省略标签时需要特别注意，避免出错
注意点.png
func check(name: String = "逍遥侯", age: Int, jod: String = "IOS")
{
print("name=\(name), age =\(age), jod=\(jod)")
}
check(name: "封轻扬", age:18) //name=封轻扬 age=18 jod=IOS
check(age:90000 , jod:"扫地僧") //name=逍遥侯 age= 90000 jod=扫地僧
- 可变参数 (Variadic Parameter)
注意：一个函数最多只能有一个可变参数，紧跟在可变参数后面的参数不能省略参数标签
可变参数.png
不能省略参数标签.png
- print函数是Swift自带的
- print支持自定义
/// - Parameters:
/// - items: Zero or more items to print. 需要打印的内容
/// - separator: A string to print between each item. The default is a single
/// space (`" "`). 分隔符，默认是空格
/// - terminator: The string to print after all items have been printed. The
/// default is a newline (`"\n"`). 结束符 默认换行
Any...: 任意类型
public func print(_ items: Any..., separator: String = " ", terminator: String = "\n")
184338.png
- C语言的
printf
int printf(const char * __restrict, ...) __printflike(1, 2);
- 输入输出参数 (In-Out Parameter)
- 可以使用
inout定义一个输入输出参数：可以在函数内部修改外部实参的值，但是如果参数是计算属性、有监听器属性等内容就不是引用传递了 - 可变参数不能标记为
inout -
inout参数不能有默认值 -
inout参数的本质是地址传递（引用传递） -
inout参数只能传入被多次赋值的；比如：变量、数组、字典、元组
var time = 9.0
func goToWork(at time: inout Int) {
time = 10.0
print("this time is \(time)")
}
goToWork(at: &time)
- 函数重载 (Function Overload)
规则：
- 函数名相同，但参数个数不同
||参数类型不同||参数标签不同
函数重载示例.png
注意点：
使用注意1.png
使用注意2WX20200515-194049.png
- 内联函数(
inline Function)
Xcode如果开启了编译器优化（Release模式默认会开启优化），编译器会自动将某些函数变成内联函数
开启.png
- 内联函数就是将函数展开成
函数体
func test() {
print("test")
}
test()
假设上面代码是内联函数，那么最终就会被编译器优化成以下代码：
print("test")
因为这个函数很简单就是，打印；那内联函数就会把函数体内部的打印代码调用，这样就减少函数的调用开销，不开辟栈空间调用函数，然后在回收栈空间。
哪些函数不会被内联 ？
函数体比较长
包含递归调用
包含动态派发(绑定)
@inline(never) : 永远不会别内联（即使开启了编译器优化）
@inline(never) func test() {
print("逍遥侯")
}
- @inline(__always) : 开启编译器优化后，即使代码很长，也会被内联（递归调用函数、动态派发的函数除外）
@inline(__always) func test() {
print("逍遥侯")
}
- 函数类型
每个函数都是有类型的，函数类型由形式参数类型、返回值类型组成
- 函数类型可以作为参数传递
- 函数类型可以作为函数返回值
- 返回值是函数类型的函数，叫做
高阶函数(Higher-Order Function)
WX20200515-201400.png
-
typealias用来给类型起别名 - 按照Swift标准库定义，Void就是空元组()，因为Swift就是这样定义的：
public typealiasVoid = ()
typealias Byte = Int8
typealias Short = Int16
typealias Long = Int64
Byte、Short、Long 就是别名
typealias Date = (year: Int, month: Int, day:Int) //给元组起别名
typealias.png
- 嵌套函数：将函数定义在函数内部
func forward(_ forward: Bool) -> (Int) -> Int {
func next(_ input: Int) -> Int {
input + 1
}
func pervious(_ input: Int) -> Int {
input - 1
}
return forward ? next : pervious
}
forward(true)(3) //4
forward(false)(3) //2
