循环

repeat{
    
}while a > 0
相当于do while


for var i in 0...3{
}
i默认是常量,如果想要修改,可以var声明为变量

区间

闭合区间

let range0 = 0 ... 3 //<=0 <=3
let range1 = 0 ..< 3 //<=0 <3
//用于数组
let arr = ["a","b","c","d","e"]
for i in arr[0...3]{
    print(i) //a.b.c.d
}

单侧区间

let arr = ["a","b","c","d","e"]
for i in arr[1...] {
    print(i)//bcde 从0开始到数组最大值
}
for i in arr[...3] {
    print(i)//abce 从0开始到下标3
}
for i in 0... {
    print(i)//从0到Int最大值
}

let range = ...5
range.contains(-10) //true
range.contains(5) //true
range.contains(7) //false

单侧区间可以用于字符串,但不能用于for循环中
let range = "cc"..."ff" // cc cd ce ...... fc fd fe ff
range.contains("aa") //false
range.contains("cd") //true
range.contains("fg") //false

switch

break可以省略不写 与oc的区别

在case 最后加一个fallthrough可以贯穿下一个

支持string

可以case 多个值用逗号隔开 case 1,2:

case可以区间匹配

var num = 1
switch num {
case 1...10:
    print("1到10都会走这个case")
default:
    print(num)
}

case可以元祖匹配

let point = (1,1)
switch point {
case (0,1):
    print("不会走这里")
case (0,-1...1):
    print("不会走这里")
case (1,-1...1):
    print("走这里")
case (0...1920,0...1080):
    print("走这里,可以判断点在不在个范围里")
default:
    print()
}

值绑定

let point = (1,1)
switch point {
case (let x,3):
    print("假如一个元祖的1的位置为3,那么x就等于这个元祖的0的位置的值")
case (let x,let y) where x == y:
    print("where相当于一个条件判断 只有x == y 才会走到这里")
case (let x,let y):
    print("无论x,y等于多少都会走这里")
}

where

where除了上面可以用在case里面还可以用在for循环里

var arr = [0,1,12,-3,4,68,-1000_0000]
var sum = 0
for num in arr where num > 0 {//只把大于零的元素累加
    sum += num
}
sum 等于 85

标签语句

可以在for前面加上一个自定义标识符,然后continue或者break时区分外圈循环还是内圈循环.有些绕

outer: for i in 0...5{
    for j in 0...5{
        if j == 3{
            continue outer
        }
        if i == 3{
            break outer
        }
        print("j == \(j),i == \(i)")
    }
}
j == 0,i == 0
j == 1,i == 0
j == 2,i == 0
j == 0,i == 1
j == 1,i == 1
j == 2,i == 1
j == 0,i == 2
j == 1,i == 2
j == 2,i == 2

函数注意

可变参数

1个函数只能含有一个可变参数

func sum(_ numbers:Int...) ->Int{
    return numbers.reduce(0, {($0 + $1)})
}
print(sum(1,2,3)) // 6

inout参数调用时需要加上& 因为 inout 是地址传递,不是值传递

var num = 10
func change(num:inout Int){
    num = 20
}
change(num: &num)
print(num)//20

内联函数 编译器优化在编译的时候如果遇到 函数体比较少的代码 会直接拿出函数体执行

func fuck(){
    print("")
}
fuck()

想要不被优化为内联函数要加上@inline(never) func ………
@inline(__always) 一直被内联(递归函数,动态派发函数不算)

这样的函数会直接取出函数体,省去函数调用(省掉了栈去的开辟释放)