Swift函数

huang1233

已于 2022-08-20 17:00:14 修改

阅读量462

点赞数

分类专栏： Swift 文章标签： swift 开发语言 ios

于 2022-08-20 15:21:20 首次发布

本文链接：https://blog.csdn.net/huang1233/article/details/126440053

版权

Swift 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

func pi() -> Double {
    return 3.14
}

func sum(v1: Int, v2: Int) -> Int {
    return v1 + v2
}

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

// 无返回值
func sayHello() -> Void {
    print("hello")
}

func sayHello() -> () {
    print("hello")
}

func sayHello() {
    print("hello")
}

隐式返回

//如果整个函数体是一个单一表达式,那么函数会隐式返回这个表达式
func sum(v1: Int,v2: Int) -> Int {
    v1 + v2
}
print(sum(v1: 10, v2: 20)) // 20

// 返回元组:实现多返回值
func calculate(v1: Int,v2: Int) -> (sum: Int,difference: Int,average: Int) {
    let sum = v1 + v2
    return (sum, v1 - v2, sum >> 1)
}
let result = calculate(v1: 20, v2: 10)
print(result.sum) // 30
print(result.difference) // 10
print(result.average) // 15

函数文档注释

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

参数标签

// 可以修改参数标签
func goToWork(at time: String) {
    print("this time is \(time)")
}
goToWork(at: "08:30") // this time is 08:30

// 可以使用下划线_ 省略参数标签
func sum(_ v1: Int,_ v2: Int) -> Int {
    v1 + v2
}
print(sum(10, 20)) // 30

默认参数值

// 参数可以由默认值
func check(name: String = "nobody",age: Int,job: String = "none") {
    print("name=\(name), age=\(age), job=\(job)")
}
check(name: "Jack", age: 20, job: "Doctor") // name=Jack, age=20, job=Doctor
check(age: 15) // name=nobody, age=15, job=none
check(name: "Rose",age: 18) // name=Rose, age=18, job=none
check(age: 10, job: "Batman") // name=nobody, age=10, job=Batman

// C++的默认参数值有个限制:必须从右往左设置. 由于Swift拥有参数标签,因此并没有此类限制
// 但是在省略参数标签时,需要特别注意,避免出错
func test(_ first: Int = 10, middle: Int, _ last: Int = 30) {
    
}
test(middle: 20)

可变参数

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

可变参数下划线_省略参数标签不能少

一个函数最多只能有一个可以变参数

紧跟在可变参数后面的参数不能省略参数标签

// 一个函数最多只能有一个可以变参数
//紧跟在可变参数后面的参数不能省略参数标签
func test(_ numbers: Int..., string: String,_ other: String) {
    
}
test(10, 20, 30, string: "Jack", "Rose")

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"`).
public func print(_ items: Any..., separator: String = " ", terminator: String = "\n")

print(1, 2, 3, 4, 5)
print(1, 2, 3, 4, 5,separator: "_")
print("My name is Jack.",terminator: "")
print("My age is 20.")
//1 2 3 4 5
//1_2_3_4_5
//My name is Jack.My age is 20.

输入输出参数(In-Out Parameter)

// 可以用inout定义一个输入输出参数: 可以在函数内部修改外部实参的值
func swapValues(_ v1: inout Int,_ v2: inout Int) {
    let tmp = v1
    v1 = v2
    v2 = tmp
}
var num1 = 10
var num2 = 20
swapValues(&num1, &num2)
print("\(num1),\(num2)")

等价:

func swapValues(_ v1: inout Int,_ v2: inout Int) {
    (v1,v2) = (v2,v1)
}
var num1 = 10
var num2 = 20
swapValues(&num1, &num2)
print("\(num1),\(num2)")

可变参数不能标记为inout
inout参数不能有默认值
inout参数只能传入可以被多次赋值的
inout参数的本质是地址传递(引用传递)

函数重载

规则

.函数名相同

.参数个数不同 || 参数类型不同 || 参数标签不同

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) // 30
sum(v1: 10, v2: 20, v3: 30) // 60
sum(v1: 10, v2: 20.0) // 30.0
sum(v1: 10.0, v2: 20)
sum(10, 20) // 30
sum(a: 10, b: 20) // 30

注意点:

函数返回值类型与函数重载无关

默认参数值和函数重载一起使用产生二义性时,编译器并不会报错(在C++中会报错)

func sum(v1: Int, v2: Int) -> Int { // 参数个数不同
    v1 + v2
}
func sum(v1: Int, v2: Int,v3: Int = 10) -> Int { // 参数个数不同
    v1 + v2 + v3
}

// 调用sum(v1: Int, v2: Int)
print(sum(v1: 10, v2: 20)) // 30

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

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(v1:10, v2:20) // 不报错
sum(10, 20) // 报错 Ambiguous use of 'sum'

内联函数

如果开启了编译器优化(Release模式默认开启优化),编译器会自动将某些函数变成内联函数

哪些函数不会被自动内联

.函数体比较长

.包含递归调用

.包含动态派发

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

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

在Release模式下,编译器已经开启优化,会自动决定哪些函数需要内联,因此没必要使用@inline

函数类型(Function Type)

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

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

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

// 定义变量
var fn: (Int , Int) -> Int = sum
fn(2,3) // 5 ,调用时不需要参数标签

// 函数类型作为函数参数

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) // Result: 7
printResult(difference, 5, 2) // Result: 3

// 函数类型作为函数返回值
func next(_ input: Int) -> Int {
    input + 1
}

func previous(_ input: Int) -> Int {
    input - 1
}

func forward(_ forward: Bool) -> (Int) -> Int {
    forward ? next : previous
}

print(forward(true)(3)) // 4

// 返回值是函数类型的函数,叫做高阶函数

typealias

// typealias用来给类型起别名
typealias Btye = Int8
typealias Short = Int16
typealias Long = Int64

typealias Date = (year: Int, month: Int, day: Int) // 定义元组别名
func test(_ date: Date) {
    print(date.0) // 2022
    print(date.year) // 2022
    print(date) // (year: 2022, month: 8, day: 20)
}
test((2022,08,20))


typealias IntFn = (Int,Int) -> Int // 定义函数别名

func difference(v1: Int, v2: Int) -> Int {
    v1 - v2
}

let fn: IntFn = difference
print(fn(20,10)) // 10

func setFn(_ fn: IntFn) {
    
}
setFn(difference)

func getFn() -> IntFn {
    difference
}

嵌套函数 (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
}

print(forward(true)(3)) // 4
print(forward(false)(3)) // 2