函数的关键字是 func ,函数定义的格式是:

swift-function

func funcName(para:paraType) -> returnType{
    // code
}

函数的参数标签

其中参数的那部分的详细结构是用小括号括起来,参数名,冒号,参数类型: (number:Int)。 在默认情况下,函数的参数标签使用参数名,或者用 _ 不使用参数标签,也可以自定义标签,我们定义一个奇葩的函数:

func 求和(数字1 num1:Float, 数字2 num2:Float) -> Float {
   return num1 + num2
}

求和 就是方法名,数字1 就是自定义的参数标签。调用时会显示标签:

let sum = 求和(数字1: 2, 数字2: 4)

函数返回多个值

swift 还可以用元组返回多个返回值:

func compare(numarray:([Int])) -> (min:Int, max:Int) {
   var min = numarray[0]
   var max = numarray[0]
   for num in numarray {
       if num > max {
           max = num
       }else if num < min{
           min = num
       }
   }
   return (min, max)
}

调用时获取返回值:

compare(numarray: [1, 2, 3, 4, 5]).max

函数嵌套函数

swift 语法中函数可以嵌套函数,用于分割太长或者太复杂的函数:

// 不要在意逻辑,只是为了示例一下。。。
func sumWithArray(numArray:([Int])) -> Int{
   var sum = 0
   func add(num1:Int, num2:Int) -> Int{
       return num1 + num2
   }
   sum = add(num1: numArray[0], num2: numArray[1])
   return sum
}

返回一个函数

函数还可以用一个函数做为返回值

func makeMethod() -> ((Int)->(Int)) {
   func addOne(num:Int)->(Int){
       return num+1
   }
   return addOne
}

函数调用:

print("makeMethod()(1993): ",makeMethod()(1993))
// makeMethod()(1993):  1994
/**
makeMethod() 返回的是一个函数,继续传入参数 1993,最后返回 1994
*/

传入一个函数

函数可以把一个函数当做返回值返回,也可以当做一个参数来传入:

func sumOfMaxMin(numarray:([Int]),compare:(_ numarray:([Int]))->(min:Int, max:Int)) -> (Int) {
   return compare(numarray).max + compare(numarray).min
}

可以看到, sumOfMaxMin 函数有两个参数:numarray:([Int])compare:(_ numarray:([Int]))->(min:Int, max:Int) 。其中 compare 是一个函数。

在调用的时候:

var sumOfMaxMinValue = sumOfMaxMin(numarray: [1, 2, 3, 4, 5],compare: compare)

compare 是上个例子中的函数。当然,我们也可以不传入一个现成已经定义和实现的函数:

var sumOfMaxMinValue = sumOfMaxMin(numarray: [1, 2, 3, 4, 5]) { (numarray:([Int])) -> (min: Int, max: Int) in
  var min = numarray[0]
  var max = numarray[0]
  
  for num in numarray {
      if num > max {
          max = num
      }else if num < min{
          min = num
      }
  }
  
  return (min, max)
}

函数是一种特殊的闭包

大家伙看到这里,肯定会一拍大腿:哎呦,这玩意不就是闭包嘛!

(The Swift Programming Language)函数实际上是一种特殊的闭包:它是一段能之后被调取的代码。闭包中的代码能访问闭包所建作用域中能得到的变量和函数,即使闭包是在一个不同的作用域被执行的

我们可以使用{}来创建一个匿名闭包。使用in将参数和返回值类型声明与闭包函数体进行分离。

let numArray:([Int]) = [1, 2, 3, 4, 5] 
var newNumArray:([Int]) = numArray.map({
  (num:Int) -> Int in
  let newNum = num * 3
  return newNum
})

闭包的简写

如果闭包的类型已知,那么可以省略参数和返回值的类型

let numArray:([Int]) = [1, 2, 3, 4, 5]
var newNumArray:([Int]) = numArray.map({
  num in
  let newNum = num * 3
  return newNum
})

单个语句闭包会把它语句的值当做结果返回

let numArray:([Int]) = [1, 2, 3, 4, 5]
var newNumArray:([Int]) = numArray.map({
  num in
  num * 3
})

如果把上面的闭包写成一行的话

let numArray:([Int]) = [1, 2, 3, 4, 5]
var newNumArray:([Int]) = numArray.map({num in num * 3})

我们可以通过参数位置而不是参数名字来引用参数,那么上面的代码就变成这样

let numArray:([Int]) = [1, 2, 3, 4, 5]
var newNumArray:([Int]) = numArray.map({$0 * 3})

当一个闭包是传给函数的唯一参数,我们可以完全忽略括号

let numArray:([Int]) = [1, 2, 3, 4, 5]
var newNumArray:([Int]) = numArray.map{$0 * 3}