Captain9911

Swift函数

  • Sep 20, 2022

关键词：Swift, iOS, 函数, func

概述

  • 函数是一段完成特定任务的独立代码片段。
  • 函数是一种特殊的闭包，是一段能之后被调取的代码。

示例

声明一个以函数为类型的变量

var ttFunc:(Int, String) -> String =

声明函数与闭包的区别

//函数
var val1:(Int, String) -> String = 
//闭包
var val1:((Int, String) -> String) =

函数的声明

用func声明，用->表示返回值类型。

func getInfoWithName(param1:String, param2:String) -> String {
    return "\(param1) 连上 \(param2)"
}
let resultStr = getInfoWithName(param1: "jiji", param2: "waiwai")
print("结果：\(resultStr)”)

不需要使用返回值时

可以：
let _ = getInfoWithName(param1: "jiji", param2: "waiwai”)
或者：
getInfoWithName(param1: "jiji", param2: "waiwai")

隐式返回

当函数体只有一个单行表达式时，可以省略return。

//隐式返回，当函数体只有一个单行表达式时，可以省略return
func showSomeInfo(param1:String, param2:String) -> String {
    param1 + param2
}
let res3 = showSomeInfo(param1: "aaa", param2: "bbb")
print("隐式返回的内容：\(res3)")

返回一个可选值

//返回一个可选值
func getSomeString(param0:String, param1:String) -> String? {
    return param0 + param1
}
let res0 = getSomeString(param0: "xxx", param1: "qqq")
if let rr = res0 {
    print("返回的可选内容：\(rr)")
} else {
    print("返回的可选值是个空的")
}

返回多个值

使用元组返回复合值。

func yigehanshu(paramA:Int, paramB:Int) -> (min:Int, max:Int, sum:Int) {
    var minValue = 0
    var maxValue = 0
    if paramA > paramB {
        minValue = paramB
        maxValue = paramA
    } else {
        minValue = paramA
        maxValue = paramB
    }
    let sumValue = minValue + maxValue
    return (minValue, maxValue, sumValue)
}
let res = yigehanshu(paramA: 5, paramB: 9)
print("获取到的最小值：\(res.min)")
print("获取到的最大值：\(res.max)")
print("获取到的总和：\(res.sum)”)

自定义标签

默认使用参数名称作为参数标签。也可以在参数名称前自定义参数标签（修改默认标签），使用下划线_表示省略该参数的标签（删除默认标签）。

func zhegehanshu(_ paramA:String, thisname paramB:String) {
    print("传过来的参数：\(paramA) 另一个参数：\(paramB)")
}
zhegehanshu("yihao", name: "erhao")

参数默认值

带默认值的那个参数可以不传。

//默认参数值
func showDefaltInfo(param1:String, param2:String = "zzz") -> String {
    return param1 + param2
}
//可以不传有默认值的那个参数
let res4 = showDefaltInfo(param1: "sss")

可变参数

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

//可变参数
func linkStrFunc(names:String...) -> String {
    var resStr:String = ""
    for name:String in names {
        resStr += name
    }
    return resStr
}
let res6 = linkStrFunc(names: "aa", "bb", "cc", "dd")

输入输出参数

函数对函数体外产生影响的一种方式。

  • 在形参参数类型前加 inout 标记。
  • 实参必须为变量，不能是常量或字面量。
  • 不能有默认值。
  • inout不能用于可变参数。
  • 类似OC的传指针，在函数内部可以修改实参
//输入输出参数。
var tt1 = "aa"
func modifyVa(modiStr:inout String) {
    modiStr = "bb"
}
modifyVa(modiStr: &tt1)

函数类型的表示

函数类型也是一种数据类型，可以作为常量或者变量的类型。

(Int, Int) -> Int
(String, String) -> String
() -> Void

使用函数类型

//一个函数
func funcaaa(param1:Int, param2:String) -> String {
    return "\(param1)" + param2
}
//定义一个类型为函数的变量，并将一个函数赋值给它
var ttFunc:(Int, String) -> String = funcaaa(param1:param2:)
//可以通过这个变量来调用函数
let res7 = ttFunc(11, "aa")

函数类型作为参数类型

//函数类型作为参数类型
func funcbb(funca:(Int, String) -> String, param1:String) {
    var res = funca(55, "sss")
    res += param1
    print("打印店什么：\(res)")
}
funcbb(funca: funcaaa(param1:param2:), param1: "ppp”)
funcbb(funca: ttFunc, param1: "ccc")

函数可以作为参数被传递

//这是一个参数为Int，返回值为String的函数
func hanshu11(param11:Int) -> String {
    print("这里是函数11")
    return "结果：\(param11)"
}
//这个函数的第一个参数是一个函数
func hanshu12(hs:(Int) -> String, param:String) {
    let result = hs(15)
    print("第一个参数返回的值：\(result)")
    print("第二个参数返回的值：\(param)")
}
hanshu12(hs: hanshu11(param11:), param: "第二个参数")

函数可以作为另一个函数的返回值

//这个函数的返回值是一个函数
func hanshu22(param:String) -> ((Int) -> String) {
    //也可以写成：func hanshu22(param:String) -> (Int) -> String {
    print("传过来的参数：\(param)")
    //这是一个参数为Int，返回值为String的函数
    func hanshu21(param21:Int) -> String {
        print("这里是函数21")
        return "结果：\(param21)"
    }
    return hanshu21(param21:)
}
//这里是返回值函数
let retFunc = hanshu22(param: "这是一个参数啊")
//这里是返回值函数执行后的返回值
let result = retFunc(60)
print("返回值函数返回的内容：\(result)")

函数嵌套

被嵌套的函数，可以访问函数外的变量。

var ceshiA = 1
let ceshiB = 2
func hanshuA() {
    print("这是在函数A里面。ceshiA的值：\(ceshiA)")
    print("这是在函数A里面。ceshiB的值：\(ceshiB)")
    func hanshuB() {
        ceshiA += 10
        print("这是在函数B里面。ceshiA的值：\(ceshiA)")
        print("这是在函数B藜麦。ceshiB的值：\(ceshiB)")
    }
    hanshuB()
}
hanshuA()
Search