Swift5.1学习随笔之函数func

作者: SAW_ | 来源:发表于2020-04-10 17:14 被阅读0次

Swift5.1学习随笔之函数func
Swift 学习之函数(Func)基础
Python 函数(func)学习
【从零开始学swift】Day6-func函数（1）
Swift 高阶函数
go 零散笔记(未整理)
JS-函数
★ 学习笔记:《iOS高级：Swift入门精讲②》第一节 Swi
Swift5.1学习随笔之指针
Swift5.1学习随笔之fatalError

Swift中的函数用`func`关键字定义

func <#name#>(<#parameters#>) -> <#return type#> {
    <#function body#>
}
<#name#> //函数名
(<#parameters#>) //括号里为参数（形参默认是let，也只能是let）
<#return type#> //返回值类型
<#function body#> //函数内部实现

举个🌰

//定义一个函数pi，无输入参数，返回值为Double类型
func pi() -> Double {
    return 3.14159
}
print(pi()) // 3.14159
//定义一个函数sum实现两数相加，需要两个Int类型参数，返回相加后的值也是Int类型
func sum(v1: Int, v2: Int) -> Int {
    return v1 + v2
}
let result = sum(v1: 10, v2: 20)
print(result) // 30

无返回值的函数

有3中表达写法

//返回一个Void代表空，无返回值
func func1() -> Void {
    print("func1")
}
//返回一个括号
func func2() -> () {
    print("func2")
}
//什么都不写，连->都可以省略
func func3() {
    print("func3")
}

隐式返回

如果整个函数体是一个单一表达式，那么函数会隐式返回整个表达式

//sum函数内部实现只有一句代码，既可以省略return，直接书写 v1 + v2
func sum(v1: Int, v2: Int) -> Int {
    v1 + v2
}
let result = sum(v1: 10, v2: 20)
print(result) // 30

返回元组，实现多返回值

在OC中，无法实现函数返回多个参数，只能用数组、字典等曲线实现，在swift中可以用元组实现

func calculate(v1: Int, v2: Int) -> (sum: Int, difference: Int, average: Int) {
    let sum = v1 + v2
    return (sum, v1 - v2, sum  / 2)
}
let result = calculate(v1: 20, v2: 10)
print(result.sum) // 30
print(result.difference) // 10
print(result.average) // 15

参数标签 Argument Label

func sum(v1: Int, v2: Int) -> Int {
    return v1 + v2
}
//参数名 v1 v2 就是参数标签

修改参数标签，举个🌰

func goToWork(at: String) {
    print("this time is \(at)") //这里的at 从阅读体验上来说，不太通顺
}
goToWork(at: "09:00")

func goToWork(at time: String) {
    print("this time is \(time)") //这里内部用time，更加便于阅读理解
}
goToWork(at: "09:00") //外部依然显示at

可以用下划线_来省略参数标签
建议不要省略，增加阅读性

func sum(v1: Int, v2: Int) -> Int {
    return v1 + v2
}
sum(v1: 10, v2: 20)
//忽略下划线，代码更加简洁
func sum(_ v1: Int, _ v2: Int) -> Int {
    return v1 + v2
}
sum(10, 20)

默认参数值 Default Parameter Value

参数可以有默认值

//声明一个函数，需要三个参数
//name有默认值“老王”
//age没有默认值，必传
//job有默认值“老司机”
func check(name: String = "老王", age: Int, job: String = "老司机") {
    print("name = \(name), age = \(age), job = \(job)")
}
check(name: "张三", age: 20, job: "城管") //name = 张三, age = 20, job = 城管
check(name: "李四", age: 19) //name = 李四, age = 19, job = 老司机
check(age: 10, job: "小学生") //name = 老王, age = 10, job = 小学生
check(age: 15) //name = 老王, age = 15, job = 老司机

可变参数 Variadic Parameter

Int类型后面加...表示可以传入多个参数
这里的numbers可以理解成数组

func sum(_ numbers: Int...) -> Int {
    var total = 0
    for number in numbers {
        total += number
    }
    return total
}
sum(10, 20, 30, 40) // 60

func nameAll(_ names: String...) -> String {
    var result = ""
    for name in names {
        result += " \(name) "
    }
    return result
}
print(nameAll("1", "2", "3", "4")) //"1  2  3  4"

注意：
1、一个函数最多只能有一个可变参数
2、紧跟在可变参数后面的参数不能省略参数标签

输入输出参数 In-Out Parameter

//实现传入num，是的num在函数内部+1操作
var num = 10
func add(_ num: Int) {
    num += 1 //此处报错 Left side of mutating operator isn't mutable: 'num' is a 'let' constant
    //因为num默认为let，不能做修改
    //并且此处num为值传递，不能修改
}
add(num)

用inout定义一个输入输出参数：可以在函数内部修改外部实参的值

var num = 10
func add(_ num: inout Int) {
    num += 1
}
add(&num) //必须加上&，地址传递

举个🌰：实现连个变量的交互

func swapValue(_ v1: inout Int, _ v2: inout Int) {
    let temp = v1
    v1 = v2
    v2 = temp
}
var num1 = 10
var num2 = 20
swap(&num1, &num2)

//PS：内部实现可以用元组更方便的实现两个变量交互
func swapValue(_ v1: inout Int, _ v2: inout Int) {
    (v1, v2) = (v2, v1)
}

注意：
1、可变参数不能标记为inout
2、inout参数不能有默认值
3、inout参数的本质是地址传递（引用传递）
4、inout参数只能传入可以被多次赋值的，比如变量等

函数重载 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(a1: Int, a2: Int) -> Int {
    a1 + a2
} //参数标签不同

注意：
1、返回值类型与函数重载无关

func sum(v1: Int, v2: Int) -> Int { v1 + v2 }
func sum(v1: Int, v2: Int) { }
sum(v1: 10, v2: 20) //报错：Ambiguous use of 'sum(v1:v2:)'

2、默认参数值和函数重载一起使用产生二义性时，编译器并不会报错（在C++中会报错）

func sum(v1: Int, v2: Int) -> Int {
    v1 + v2
}
func sum(v1: Int, v2: Int , v3: Int = 30) -> Int {
    v1 + v2 + v3
}
sum(v1: 10, v2: 20) //调用第一个函数

3、可变参数、省略参数标签、函数重载一起使用产生二义性时，编译器有可能会报错

func sum(v1: Int, v2: Int) -> Int {
    v1 + v2
}
func sum(_ v1: Int, _ v2: Int) -> Int {
    v1 + v2
}
func sum(_ numbers: Int...) -> Int {
    var total = 0
    for number in numbers {
        total += number
    }
    return total
}

sum(10, 20) //报错：Ambiguous use of 'sum'

//func sum(v1: Int, v2: Int) -> Int {
//    v1 + v2
//}
func sum(_ v1: Int, _ v2: Int) -> Int {
    v1 + v2
}
func sum(_ numbers: Int...) -> Int {
    var total = 0
    for number in numbers {
        total += number
    }
    return total
}
//注释第一个函数
sum(10, 20) //不报错

内联函数 Inline Function

如果开启了编译器优化（Release模式默认开启），编译器会自动将默写函数变成内联函数

作用：
1、将函数调用展开成函数体

func test() {
    print("test")
}
test()
//执行test()，会调用test函数，会开辟栈空间给函数，函数调用完会回收栈空间
//如果调用test()能直接优化成调用print("test")，能提高性能，因为test函数内部的代码特别少，就1行
//这就是内联函数的意思，会自动将函数调用展开成函数体代码

注意：哪些函数不会内联
1、函数体比较长

func test1() {
    print("aaaaaaaaaaaa")
    print("bbbbbbbbbbb")
    print("dsafsdfa")
    print("aaaaaaadsfasdfaaaaa")
    print("sdfasdf")
    print("aaaaaaaasdfasdaaaaa")
    print("cxzvxcv")
}
test1()
test1()
test1()
//这种函数就很没有意义，编译器会智能判断

2、包含了递归调用

func test2() {
    test2()
}

3、包含动态派发（OC中的动态绑定）

class Person {
    func test() {
        
    }
}
class Student: Person {
    override func test() {
        
    }
}
class Teacher: Person {
    override func test() {
        
    }
}

var p: Person = Student() //多态
p.test() //运行时再决定调用Person还是Student的test

p = Teacher() //变量p随时可能变化
p.test() //编译器无法确定调用谁的

手动禁用内联：
函数声明时候加上@inline(never)关键字

//永远不会被内联，即使开启了编译器优化
@inline(never) func test() {
    print("test")
}

手动开启内联：
函数声明时候加上@inline(__always)关键字

//开启编译器优化后，即使代码很长，也会被内联（递归调用函数、动态派发的函数除外）
@inline(__always) func test() {
    print("test")
}

函数类型 Function Type

1、每一个函数都是有类型的，函数类型由形式参数类型、返回值类型组成

func test() { }
// test函数的类型为：() -> Void 或者 () -> ()

func sum(a: Int, b: Int) -> Int {
    a + b
} 
// sum类型为：(Int, Int) -> Int

作用：
1、定义变量

var fn: (Int, Int) -> Int = sum
fn(6, 9) // 15，调用不需要参数标签

2、作为函数参数

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

func printResult(_ mathFn: (Int, Int) -> Int, _ a: Int, _ b: Int) {
    print("Result == \(mathFn(a, b))")
}

printResult(sum, 5, 2) // 7 :调用sum函数
printResult(difference, 5, 2) // 3 :调用difference函数

3、作为函数返回值
返回值是函数类型的函数，叫做高阶函数（Higher-Order Function）

func next(_ input: Int) -> Int {
    input + 1
}
func previous(_ input: Int) -> Int {
    input - 1
}
//forward返回值是 (Int) -> Int函数
func forward(_ forward: Bool) -> (Int) -> Int {
    forward ? next : previous
}

forward(true)(3) // 4 : true调用next(3)
forward(false)(3) // 2 : false调用previous(3)

嵌套函数 Nested Function

将函数定义在函数内部

func forward(_ forward: Bool) -> (Int) -> Int {
    func next(_ input: Int) -> Int {
        input + 1
    }
    func previous(_ input: Int) -> Int {
        input - 1
    }
    return forward ? next : previous
}
forward(true)(3)
forward(false)(3)
//外部无法直接调用next()跟previous()

Swift5.1学习随笔之函数func
Swift中的函数用func关键字定义举个? 无返回值的函数有3中表达写法隐式返回如果整个函数体是一个单一...
Swift 学习之函数(Func)基础
从编写面向过程语言的C语言开始就一直离不开函数，当然任何语言都有函数这个概念，函数是用来完成特定任务的独立的代码块...
Python 函数(func)学习
【从零开始学swift】Day6-func函数（1）
一、函数func的定义： func函数是一段完成特定任务的独立代码片段。二、函数func的组成： func函数，...
Swift 高阶函数
高阶函数之Reduce public func reduce(_ initialResult: R...
go 零散笔记(未整理)
go 学习零散笔记 Go语言程序员推荐使用驼峰式命名函数(func) 一个函数的声明由func关键字、函数名...
JS-函数
1.函数基础函数参数函数写法：function func(){}var func=function(){}经常...
★ 学习笔记:《iOS高级：Swift入门精讲②》第一节 Swi
前言:本篇仅为视频学习笔记嵌套函数(Nested Function)★ 将函数定义在函数内部 func forw...
Swift5.1学习随笔之指针
Swift中也有专门的指针类型，这些都被定义为Unsafe（不安全的），常见的有以下4种类型 UnsafePoin...
Swift5.1学习随笔之fatalError
如果遇到严重问题，希望结束程序运行，可以直接使用fatalError函数抛出错误（这是无法通过do-catch捕捉...