Swift-函数

Graves_Godfather
179 阅读9分钟

Swift函数

Swift 函数用来完成特定任务的独立的代码块。

Swift使用一个统一的语法来表示简单的C语言风格的函数到复杂的Objective-C语言风格的方法。

♦ 函数声明: 告诉编译器函数的名字，返回类型及参数。

♦ 函数定义: 提供了函数的实体。

Swift 函数包含了参数类型及返回值类型。

函数定义

Swift 定义函数使用关键字 func。

定义函数的时候，可以指定一个或多个输入参数和一个返回值类型。

每个函数都有一个函数名来描述它的功能。通过函数名以及对应类型的参数值来调用这个函数。函数的参数传递的顺序必须与参数列表相同。

函数的实参传递的顺序必须与形参列表相同，-> 后定义函数的返回值类型。

语法

func funcname(形参) -> returntype
{
   Statement1
   Statement2
   ……
   Statement N
   return parameters
}

实例

func test(a: String) -> String {
    return (a)
}
print(test(a: "这是一个函数"))

以上程序执行输出结果为：

这是一个函数

函数调用

我们可以通过函数名以及对应类型的参数值来调用函数，函数的参数传递的顺序必须与参数列表相同。

以下我们定义了一个函数名为 runoob 的函数，形参 site 的数据类型为 String，之后我们调用函数传递的实参也必须 String

类型，实参传入函数体后，将直接返回，返回的数据类型为 String。

func test(a: String) -> String {
    return (a)
}
print(test(a: "这是一个函数"))

以上程序执行输出结果为：

这是一个函数

函数参数

函数可以接受一个或者多个参数，这些参数被包含在函数的括号之中，以逗号分隔。

以下实例向函数 test 传递 a 和 b：

func test(a: String, b: String) -> String {
    return a + b
}
print(test(a: "百度：", b: "www.baidu.com"))

以上程序执行输出结果为：

百度：www.baidu.com

函数参数与返回值

函数参数与返回值在 Swift 中非常的灵活。
你可以定义任何类型的函数，包括从只带一个未名参数的简单函数到复杂的带有表达性参数名和不同参数选项的复杂函数。

不带参数函数

我们可以创建不带参数的函数。

实例

func test1()->Void{
   print("这是一个无参无返回值的函数")
}
test1()

func test2()->(){
   print("这是一个无参无返回值的函数")
}
test2()

func test3(){//最常用
   print("这是一个无参无返回值的函数")
}
test3()

有参无返函数

我们可以创建有参无返的函数。

实例

func test(a:String){
    print("这是\(a)的函数")
}
test(a:"有参无返")

以上程序执行输出结果为：

这是有参无返的函数

无参有返函数

我们可以创建无参有返的函数。

实例

func a()->String{
    return "这是一个无参有返的函数"
}
print(a())

以上程序执行输出结果为：

这是一个无参有返的函数

元组作为函数返回值

函数返回值类型可以是字符串，整型，浮点型等。

元组与数组类似，不同的是，元组中的元素可以是任意类型，使用的是圆括号。

你可以用元组（tuple）类型让多个值作为一个复合值从函数中返回。

下面的这个例子中，定义了一个名为minMax(_:)的函数，作用是在一个Int数组中找出最小值与最大值。

func minMax(array: [Int]) -> (min: Int, max: Int) {
    var Min = array[0]
    var Max = array[0]
    for value in array[1..<array.count] {
        if value < Min {
            Min = value
        } else if value > Max {
            Max = value
        }
    }
    return (Min, Max)
}
let bounds = minMax(array: [8, -6, 2, 109, 3, 71])
print("最小值为 \(bounds.min) ，最大值为 \(bounds.max)")

minMax(_:)函数返回一个包含两个Int值的元组，这些值被标记为min和max，以便查询函数的返回值时可以通过名字访问它们。

以上程序执行输出结果为：

最小值为 -6 ，最大值为 109

如果你不确定返回的元组一定不为nil，那么你可以返回一个可选的元组类型。

你可以通过在元组类型的右括号后放置一个问号来定义一个可选元组，例如(Int, Int)?或(String, Int, Bool)?

注意: 可选元组类型如(Int, Int)?与元组包含可选类型如(Int?, Int?)是不同的.可选的元组类型，整个元组是可选的，而不只是元组中的每个元素值。

函数参数名称

函数参数都有一个外部参数名和一个局部参数名。
参数标签在调用函数的时候使用；调用的时候需要将函数的参数标签写在对应的参数前面。参数名称在函数的实现中使用。默认情况下，函数参数使用参数名称来作为它们的参数标签。

局部参数名

局部参数名在函数的实现内部使用。

func a(number: Int) {
   println(number)
}

以上实例中 number 为局部参数名，只能在函数体内使用。

func a(number: Int) {
    print(number)
}
a(number: 1)
a(number: 2)
a(number: 3)

以上程序执行输出结果为：

1
2
3

外部参数名

你可以在局部参数名前指定外部参数名，中间以空格分隔，外部参数名用于在函数调用时传递给函数的参数。

如下你可以定义以下两个函数参数名并调用它：

func pow(firstArg a: Int, secondArg b: Int) -> Int {
   var res = a
   for _ in 1..<b {
      res = res * a
   }
   print(res)
   return res
}
pow(firstArg:5, secondArg:3)

以上程序执行输出结果为：

125

注意 : 如果你提供了外部参数名，那么函数在被调用时，必须使用外部参数名。

忽略参数标签

如果你不希望为某个参数添加一个标签，可以使用一个下划线（_）来代替一个明确的参数标签。

func someFunction(_ firstParameterName: Int, secondParameterName: Int) {
     // 在函数体内，firstParameterName 和 secondParameterName 代表参数中的第一个和第二个参数值
}
someFunction(1, secondParameterName: 2)

默认参数值

你可以在函数体中通过给参数赋值来为任意一个参数定义默认值（Deafult Value）。当默认值被定义后，调用这个函数时可以忽略这个参数。

func someFunction(parameterWithoutDefault: Int, parameterWithDefault: Int = 12) {
    // 如果你在调用时候不传第二个参数，parameterWithDefault 会值为 12 传入到函数体中。
}
someFunction(parameterWithoutDefault: 3, parameterWithDefault: 6) // parameterWithDefault = 6
someFunction(parameterWithoutDefault: 4) // parameterWithDefault = 12

将不带有默认值的参数放在函数参数列表的最前。一般来说，没有默认值的参数更加的重要，将不带默认值的参数放在最前保证在函数调用时，非默认参数的顺序是一致的，同时也使得相同的函数在不同情况下调用时显得更为清晰。

可变参数

可变参数可以接受零个或多个值。函数调用时，你可以用可变参数来指定函数参数，其数量是不确定的。

可变参数通过在变量类型名后面加入（...）的方式来定义。

func add(nums:Int...)->Int{
    print(type(of:nums))//可变参数当成数组来处理
    var sum = 0
    for i in nums{
        sum += i
    }
    return sum
}
print(add(nums:10,20))
print(add(nums:10,20,30))

以上程序执行输出结果为：

Array
30
Arry
60

输入输出参数

函数参数默认是常量。试图在函数体中更改参数值将会导致编译错误。这意味着你不能错误地更改参数值。

定义一个输入输出参数时，在参数定义前加 inout 关键字。一个 输入输出参数有传入函数的值，这个值被函数修改，然后被传出函数，替换原来的值。想获取更多的关于输入输出参数的细节和相关的编译器优化，请查看 输入输出参数 一节。

你只能传递变量给输入输出参数。你不能传入常量或者字面量，因为这些量是不能被修改的。当传入的参数作为输入输出参数时，需要在参数名前加 & 符，表示这个值可以被函数修改。

注意: 输入输出参数不能有默认值，而且可变参数不能用 inout 标记。 

func swap1(a:Int,b:Int){
    let tmp = a
    a = b
    b = tmp
    print("a:\(a),b:\(b)")
}
swap1(a:10,b:30)
//代码报错：默认情况下参数都是let类型，你可以把值传给他，不能改变

如果你想要一个函数可以修改参数的值，并且想要在这些修改在函数调用结束后仍然存在，那么就应该把这个参数定义为输入输出参数（In-Out Parameters）。

func swap2(a:inout Int,b:inout Int){
    let tmp = a
    a = b
    b = tmp
    print("a:\(a),b:\(b)")
}
var num1 = 10
var num2 = 30
swap2(a:&num1,b:&num2)
print("num1:\(num1),num2:\(num2)")

注意: 输入输出参数和返回值是不一样的。上面的 swap2 函数并没有定义任何返回值，但仍然修改了 num1 和 num2 的值。输入输出参数是函数对函数体外产生影响的另一种方式。

函数类型及使用

每个函数都有种特定的函数类型，由函数的参数类型和返回类型组成。

func inputs(a: Int, b: Int) -> Int {
   return a/b
}

inputs 函数类型有两个 Int 型的参数(a、b)并返回一个 Int 型的值。

实例如下：

func inputs(a: Int, b: Int) -> Int {
    return a/b
}
print(inputs(a: 20, b: 10))
print(inputs(a: 36, b: 6))

以上程序执行输出结果为：

2
6

以上函数定义了两个 Int 参数类型，返回值也为 Int 类型。

接下来我们看下如下函数，函数定义了参数为 String 类型，返回值为 String 类型。

func inputstr(name: String) -> String {
   return name
}

函数也可以定义一个没有参数，也没有返回值的函数，如下所示：

func inputstr() {
   print("这是一个无参无返的函数")
}
inputstr()

以上程序执行输出结果为：

这是一个无参无返的函数

使用函数类型

在 Swift 中，使用函数类型就像使用其他类型一样。例如，你可以定义一个类型为函数的常量或变量，并将适当的函数赋值给它：

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

解析:

"定义一个叫做 addition 的变量，参数与返回值类型均是 Int ，并让这个新变量指向 sum 函数"。

sum 和 addition 有同样的类型，所以以上操作是合法的。

现在，你可以用 addition 来调用被赋值的函数了：

func sum(a: Int, b: Int) -> Int {
   return a + b
}
var addition: (Int, Int) -> Int = sum
print("输出结果: \(addition(40, 89))")

以上程序执行输出结果为：

输出结果: 129
avatar
文章
阅读
粉丝