swift学习2

本片主要讲解流程控制,函数

if-else

1.  可以不写小括号.
2. if 后 只能是 Bool 类型

while

1. 可以省略小括号

repeat

相当于 do-while

var num = -1
repeat {
	print("num is \(num)")
} while num > 0

打印了一次

自增自减符号

var num = 5
while num > 0{
	print("num is \(num)")
	num -= 1
}

swift 中的 -=1,相当于 num--

for

使用区间运算符

闭区间运算符: a…b,a <= 取值 <= b

let names = ["Anna","ALex","Brian","Jack"]
// i 的值最小是0,最大是3. 在 0 和 3 的中间
for i in 0...3{
	print(names[i])
}

闭区间赋值

将闭区间的范围付给一个常量. 之后可以直接使用

let range = 1...3
for i in range{
	print(names[i])
}

循环中的i默认为 let 类型. 也可以声明为 var
还有其他的书写方式

半开区间

a...<b.取值范围: a <= 取值 < b

for i in 1..<5{
	print(i)
}
// 输出 1,2,3,4

区间用在数组上

单侧区间

让区间尽可能的朝一个方向上远

例如: 
	names 是一个数组. 那么第一个的names[2...]  的范围就是从 2 开始一直到数组的最后一个值
	而第二个 namse[...2]的范围就是 从数组的第一个值开始,一直到索引2位置
	第三个names[...<2],就是从0开始到1位置

contains

是否包含某个shuzhi

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

区间类型

区间对应的实际类型

字符串不能用在 for-in 里面

但是区间的值还是存在的,可以使用 contains 判断

可以看 上图的 contains 判断结果

字符包含

字符区间包含所有有可能用到的ASCII字符

let characterRange: CloseRange<Character> = "\0"..."~"

带间隔的区间

let hourse = 11
let hourInterval = 2
for tickMark in stride(	form:4,	through:hours,	by:hourInterval ){
	print(tickMark)
}
//4,6,8,10

switch

1. 可以不写break.不会产生穿透

fallthrough

在case: 语句 后加上 fallthrough. 会无条件执行下一条case

switch 和 enum

1. 如果 switch 确定要判断的类型是什么,就可以在case 后面省略对应的类型

使用

复合条件

switch 也支持 Character,String 类型

合并case

区间匹配,元组匹配

值绑定

这里的x代表了元组的第一个数字,如果0 和元组的第二个数字相等. 则x = 2. 最终输出结果就是2

case_where扩展

在case中使用 where

for_where扩展

在for中使用where

标签语句 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)")
	}
}

函数

格式

// 1.
func pi() -> Double{
	return 3.14
}
// 2.
func sum(v1:Int,v2:Int) ->Int {
	return v1+v2
}
sum(v1:10,v2:20)
// 3. 无返回值
func sayLello() -> Void{
	// code
}
// 4. 返回的是 空元祖 () 
func sayHello() -> (){
	// code
}
// 5. 
func sayHello(){
	// code
}

形参默认是let,也只能是 let

隐式返回

如果函数是一个单一的表达式,那么函数会隐式返回这个表达式

多返回值

可以通过返回元组返回多个值

求和,求差,求平均值

文档注释

/// 求和[概述]
/// 换行
/// - Parameter v1: 第一个整数
/// - Parameter v2: 第二个整数
/// - Returns: 2个整数的和
///
/// - Note: 传入2个整数即可 [批注]
// 
func sum(v1: Int,v2: Int) -> Int{
	v1 + v2
}

参数标签

1. 可以修改参数标签

// 定义
func getToWork(at time: String){
	print("this time is \(time)")
}
// 调用
getToWork(at:"08: 00")

主要用于 语义化.

省略参数标签

func sum(_ v1:Int,_ v2:Int){
	v1 + v2
}
sum(10,20 )

协商下划线后,可以不用写参数标签

参数默认值

func check(name:String = "nobody",age:Int,job:String = "nooe"){
	print("name = \(name),age = \(age),job = \(job)")
}
check(name:"Jack",age:20,job:"Docter")
check(name:"Rose",age:18)
check(age:15,job:"Batman")
check(age:15)

可变参数

func sum(_ numbers:Int...) -> Int{
	var total = 0
	for number in numbers{
		total += number
	}
    return total
}
print(sum(1,2,3,4))

输入输出参数 inout

var number = 10
func add(_ num:Int){
	print(num)
}
add(number)
print(number)

解析: 这里的参数时值传递,所以在函数内部修改其值不会影响到外部的number的值.
而形参默认为 let 常量类型. 

如果想要修改外部number的值的话. 可以使用 inout 关键字. 获取number的地址,通过地址进行修改

修正如下:

var number = 20
func add(_ num: inout Int){
	num = 10
}
add(&number)
print(number)

总结

1. 可变参数不能标记为 inout
2. inout 不能有默认值
3. inout本质是引用传递

函数重载

函数名相同
参数个数不同,类型不同,标签不同

标签不同案例:

调用:

内联函数

如果开启了编译器优化,编译器会自动将某些函数变为内联函数

内联函数 是将 函数 展开成为 函数体

例如

func test(){
	print("test")
}
test()

编译器进行优化的话,会直接将 print("test") 放在函数外面.

不会内联的函数

函数体很长的函数.
递归的函数
包括动态派发的函数

函数类型

没一个函数都是有类型的. 是由 形式参数和返回值类型 组成的

比如:

func test(){} //() ->Void 或 () -> ()

这个函数类型是 () ->Void 或 () -> ()

再比如:

fun sum(a:Int,b:Int) -> Int{
	a + b
}

这个例子的类型为 (Int,Int) -> Int

第三个例子:

我们还可以拿 函数类型 来定义变量

var fn:(Int,Int) -> Int = sum

函数作为参数

// 接收
func printResult(_ mathFn: (Int,Int) -> Int,_a:Int,_b:Int){
	print("Result: \(mathFn(a,b))")
}

函数作为返回值

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

别名 typelias

 用来给类型起别名

嵌套函数