一、流程控制
1、if-else
- if后面的条件小括号是可以省略的
- 条件后面的大括号不可以省略
- if后面的天剑只能是Bool类型，不能是类
2、while
var num = 5
while num > 0 {
print(num)
num -= 1;//这里不用num-- 是因为从Swift3开始去除了自增（++）自减（--）
}
//repeat-while 相当于C语言中的do-while
var num = -1
repeat{
print(num)
}while num > 0
3、for
- 闭区间运算符：a...b, a<= 取值 <= b
- 半开区间运算符 a...
- 单侧区间：让区间朝一个方向尽可能的远[2...]
- 字符也可以 "a"..."z"
4、带间隔的区间值
let hours = 11
let hourInteval = 2
//stride from：从4开始 to:到11 by:中间间隔2
for tickMark in stride(from: 4, to: hours, by: hourInteval) {
print(tickMark)
}// 4 6 8 10
5、 Switch
- case 、default 后面不能写大括号{}
- 默认可以不写break，并不会贯穿到后面的条件
- fallthrough 是可以贯穿效果
var num = 1
switch num {
case 1:
print(num)
fallthrough
default:
print(num)
}
1,1
- switch 必须要保证能处理所有情况（如果能保证已处理所有情况，也可以不写default）
var num = 1
switch num {
case 1:
print(num)
case 2:
print(num)
}
这样写会报错（Switch must be exhaustive）
- case、default后面至少要有一条语句
- 如果不想做任何事情，就加一个break
var num = 1
switch num {
case 1:
print(num)
case2:
print(num)
default:
break
}
复合条件
-Switch 也可以支持character。string类型
//字符串
let string = "jack"
switch string {
case "jack":
print(string)
fallthrough
case "rose":
print("rose")
default:
break
}
//字符 如果要指定字符：Character
let character:Character = "a"
switch character {
case "a":
fallthrough
case "A":
print(character)
default:
break
}
区间匹配和元组匹配
//区间匹配
let count = 63
switch count {
case 0:
print("none")
case 1...5:
print("a few")
case 5...12:
print("several")
default:
print("many")
}//many
//元组匹配
let point = (1,1)
switch point {
case (0,0):
print("the origin")
case (_,0):
print("on the x-axis")
case (0,_):
print("on the y-axis")
case (-2...2,-2...2)://区间加元组匹配
print("on the box")
default:
print("outside of the box")
}//on the box
- 值绑定
let point = (2,0)
switch point {
case (let x ,0):
print(x)
case (0,let y):
print(y)
case (let x ,var y):
print("\(x)-- \(y)")
}
6、where -------- switch - where
let point = (1,-1)
switch point {
case let (x,y) where x == y:
print("x == y")
case let (x,y) where x == -y:
print("x == -y")
case let (x,y):
print("\(x) - \(y) 是其他的点")
}
//将所有的正数相加
var numbers = [10, 20 ,-10 ,-30, 40]
var sum = 0
for num in numbers where num > 0 {
sum = sum + num
}
print(sum)
7、标签语句
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)")
}
}
二、函数
1、函数的定义
//函数
func p1() ->Double{
return 3.14
}
func sum(v1: Int,v2: Int) ->Int{
return v1 + v2
}
sum(v1: 10, v2: 10)
//形参默认是let,也只能是let
//无返回值
func p2() ->Void{
}
func p3() ->(){
}
func p4(){
}
2 、隐式返回
- 如果整个函数体是一个单一表达式，那么函数会隐式返回这个表达式
func sum(v1: Int,v2: Int) ->Int{
v1 + v2
}
sum(v1: 10, v2: 10)
3、返回元组：实现多返回值
func calculat (v1: Int,v2: Int) -> (sum: Int ,difference: Int, average: Int){
let sum = v1 + v2
return(sum,v1 - v2 ,sum >> 1)
}
let result = calculat(v1: 10, v2: 5)
result.sum
result.difference
result.average
4、文档注释
5、参数标签
- 可以修改参数标签
func goToWork(at time:String){
print("上班时间\(time)")
}
goToWork(at: "8:00")
- 可以使用下划线_ 省略参数标签
func sum(_ v1:Int, _ v2:Int) ->Int{
return v1 + v1
}
sum(10, 10)
6 、默认参数值
func check (name: String = "nobady",age:Int,job:String = "none"){
print("name = \(name),age = \(age),job = \(job)")
}
check(age: 10)//name = nobady,age = 10,job = non
check(name: "李四", age: 10, job: "痞子")//name = 李四,age = 10,job = 痞子
check(age: 10,job:"医生")//name = nobady,age = 10,job = 医生
check(name:"张三",age: 19)//name = 张三,age = 19,job = none
注意点：
C++的默认擦书值有个限制，必须从右往左设置。由于Swift拥有参数标签，因此没有此类限制
但是再省略标签的参数的时候，需要注意。
7、可变参数
func sum(_ numbers: Int...) -> Int{
var totle = 0
for number in numbers {
totle += number
}
return totle
}
sum(10,20,30,40)
注意：
1、一个函数最多稚嫩共有一个可变参数
2、紧跟在可变参数后面的参数，不能省略标签
8、输入输出参数
func swapValues(_ v1: inout Int,_ v2: inout Int) {
// let tmp = v1
// v1 = v2
// v2 = tmp
(v1,v2) = (v2,v1)
}
var num1 = 10
var num2 = 20
swap(&num1, &num2)
print(num1,num2)
注意：
1、可变参数不能标记为inout
2、inout参数不能有默认值
3、inout 参数的本质是地址传递（引用传递）
9、函数重载（Function Overload）
- 规则
1、函数名相同
2、参数个数不同 || 参数类型不同 || 参数标签不同
func sum(v1: Int,v2: Int) -> Int{
v1 + v2
}
func sum(v1: Int, v2: Int, v3: Int) -> Int {
v1 + v2 + v3
}//参数个数不同
func sum(v1: Int, v2: Double) -> Double {
Double(v1) + v2
}//参数类型不同
func sum(v1: Double, v2: Int) -> Double {
v1 + Double(v2)
}//参数类型不同
func sum(_ v1: Int, _ v2: Int) -> Int {
v1 + v2
}// 参数标签不同
func sum(a: Int, b: Int) -> Int{
a + b
}//参数标签不同
sum(v1: 10, v2: 20)
sum(v1: 10, v2: 20, v3: 30)
sum(v1: 10, v2: 20.0)
sum(v1: 10.0, v2: 20)
sum(10, 30)
sum(a: 10, b: 20)
//上面几种情况都是可以调成功的
注意
1、返回值类型与函数重载无关
2、默认参数值和函数重载一起使用产生二义性时，编译器并不会报错（再C++中会报错）
3、可变参数、省略参数标签、函数重载一起使用参数二义性时，编辑器有可能会报错
func sum(v1: Int,v2: Int) -> Int{v1 + v2}
func sum(v1: Int,v2: Int){ v1 + v2}
调用sum(v1: 10, v2: 20)就会报错
func sum(v1: Int,v2: Int) -> Int{v1 + v2}
func sum(v1: Int,v2: Int, v3: Int = 10){ v1 + v2}
这个不会报错 但是容易产生歧义 不推荐使用
10、内联函数（inline function）
开启内联 选择targets -> build settings -> optimization ->Debug 选择-0
- 如果开启编译器优化（Release模式默认开启优化），编译器会自动将某些函数变成内联函数
1、将函数调用展开成函数体
2、函数体比较长的时候不会内联
3、包含递归调用不会内联
4、包含动态派发不会内联
@inline 关键字
//永远不会被被内联（即使开启了编译器的优化）
@inline(never) func test(){
print("test")
}
//开启编译器优化后，即使代码很长，也会被内联（递归调用函数、动态派发的函数除外）
@inline(__always) func test1(){
print("test")
}
11、函数类型
- 每一个函数都有类型的，函数的类型由形式参数类型、返回值类型组成。
- 函数类型作为函数参数
func sum(v1: Int, v2: Int) -> Int {
v1 + v2
}
func difference(v1: Int, v2: Int) -> Int{
v1 - v2
}
func printResult(_ mathFn: (Int, Int) -> Int, _ a:Int, _ b: Int){
print("result: \(mathFn(a,b))")
}
printResult(sum, 5, 2) // 7
printResult(difference, 7, 2) // 5
- 函数类型作为函数返回值(这种函数叫做高阶函数)
func next (_ input: Int) -> Int{
input + 1
}
func previous(_ input: Int) -> Int{
input - 1
}
func forward(_ forward: Bool) -> (Int) -> Int{
forward ? next : previous
}
forward(true)(3) // 4
forward(false)(3)// 2
12 、typealias（别名）
- typealisa 用来给类型起别名
typealias Byte = Int8
typealias Short = Int16
typealias Long = Int64
//给元组起别名 或者叫定义了一个元组
typealias Date = (year: Int, month: Int, day: Int)
func test(_ date: Date){
print(date.0)
print(date.year)
}
test((2021,06,11))
typealias IntFn = (Int, Int) ->Int
func differece(v1: Int, v2: Int) -> Int{ v1 - v2 }
let fn:IntFn = differece
fn(20,30)
//作为参数
func setFn(_ fn:IntFn){}
setFn(differece)
//作为返回值
func getFn() -> IntFn {differece}
13、嵌套函数
- 将函数定义再函数内部
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)
forward(false)(3)
w