在本swift函数教程中，我们将研究如何在Swift中定义和使用函数。
我们将介绍所有可以使您加深理解的概念，并希望在本教程结束时您已掌握快速编程中的函数概念。

Swift函数

根据Apple文档，" Swift函数是执行特定任务的自包含代码块。
您为函数指定一个名称，该名称可以标识其功能，该名称用于"调用"该函数以在需要时执行其任务"。

在本教程中，我们将介绍以下概念。

• 命名和未命名参数
• 默认参数值
• 多种返回类型
• 输入参数
• 可变参数
• 嵌套函数
• 作为类型，参数和返回类型的函数

让我们在XCode中打开Playground并直接进入！

定义和调用Swift函数

要定义一个快速函数，我们需要以关键字" func"开头，后跟函数名称，如下所示。

func helloFunction()
{
 print("Hello Swift Functions)
}

带参数和返回类型的Swift函数

让我们用参数定义一个swift函数，然后看看它的外观。

func display(websiteName w: String, withTutorial t: String)
{
 print(w + " " + t)
}

括号内的代码片段乍一看可能令人生畏。
让我们仔细观察一下。

上述函数内部的参数由两部分组成。
外部参数后跟内部参数。
这种由两个标签组成的参数类型称为命名参数。

• 参数的类型在冒号"："之后。

• websiteName和withTutorial是外部参数，仅在调用函数时使用。
  外部参数也称为参数标签。

• w和t是内部参数，将在函数体内使用。
  内部参数也称为局部参数。

以上功能按以下方式调用。

display(websiteName: "theitroad", withTutorial: "Functions In Swift")

Swift函数命名参数在本质上很有用，因为它们通过参数标签指示函数中参数的用途，从而以清晰的方式反映函数的功能。

下面给出了定义函数的另一种方法。

func appendStrings(a : String, b: String)
{
  print(a + " " + b)
}

appendStrings(a: "Hello", b:"Swift")

在上面的代码中，我们没有明确设置外部和内部参数。
Swift在上述情况下都将它们视为两者。

要显式地省略外部参数(参数标签)，我们需要添加下划线" _"。

以下代码段演示了第一个参数未命名的示例。

func appendString(_ a: String, with b: String)
{
print(a + " " + b)   
}

appendString("Hello", with: "Swift")

注意：我们无法在函数内部更改参数值(至少不能通过上述方法更改)。

接下来，让我们创建一个带有返回类型的函数。

func sumOfTwo(_ a: Int, _ b:Int) -> Int
{
return a + b
}
print(sumOfTwo(2,3))

要设置返回类型，我们添加了运算符->，然后添加了要返回的数据类型。

可以在参数类型之后分配函数中任何参数的默认值。
如果定义了默认值，则可以在调用函数时忽略该参数。

让我们创建一个为参数设置默认值的函数，如下所示

func sum(_ a:Int, _ b:Int = 2) -> Int
{
 return a + b
}
print(sum(5)) //Prints 7
print(sum(5, 3)) //Prints 8

Swift Function输入参数

inout参数：要更改参数的值，以使新值在函数调用结束后仍保持不变，我们将参数定义为inout。
下面的代码段演示了具有此类参数的功能。

var i = 3
print(i) //prints 3
func increment(_ i: inout Int, by x: Int) -> Int
{
  i = i + x
  return i
}
increment(&i, by: 3)
print(i) //prints 6

常量不能作为swift函数的inout参数传递。

注意：inout参数类似于在C中通过引用传递。

Swift函数可变参数

Swift函数可变参数接受零个或者多个指定类型的值。
每个函数只允许使用一个可变参数。
可变参数在参数类型之后用" ..."表示，如下所示。

func makeSentence( words: String...) -> String
{
  var sentence = ""
  for word in words
  {
   sentence = sentence + " " + word
  }
  return sentence
}

makeSentence(words: "Function","having", "Variadic parameters","Add as many strings here you want", "Can use one variadic parameter per func","Make full use")

Swift函数返回多个值

我们可以使用元组类型作为函数的返回类型，以将多个值作为一个复合值返回，如下所示。

func returnSentenceAndWordCount(_ strings: String...) -> (sentence: String, wordCount: Int)
{
  var sentence = ""
  for s in strings
  {
      sentence = sentence + " " + s
  }
  return (sentence, strings.count)
}

let data = returnSentenceAndWordCount("Function","returns a tuple", "containing", "sentence and number of strings and word count")
                                    
print(data.sentence + "\n\(data.wordCount)")

使用返回类型上的点运算符访问元组成员。

Swift中的嵌套函数

Swift允许我们在一个函数内定义一个函数，如下所示。

func sayHello(to name: String) {
  let s = "Hello " + name
  func printString() {
      print(s)
  }
}
sayHello(to: "Anupam") //prints Hello Anupam

在上面的代码中，常量s可用于嵌套函数。

Swift函数作为类型，参数和返回类型

函数的参数类型和返回类型可以组成可在Swift中巧妙使用的自定义独立数据类型。

此外，Swift中的函数还允许将另一个函数作为参数或者返回类型传递。
我们将在下面实现所有这些功能。

首先，创建两个基本功能，如下所示。

//Function to calculate square of an integer.
func square(_ num :Int)->Int
{
   return num*num
}
square(4) //returns 16

//Function to calculate cube of an integer.
func cube(_ num :Int)->Int
{
  return num*num*num
}
cube(4) //returns 64

我们可以将函数分配给变量/常量，如下所示。

var exponentialFunction = square

exponentialFunction被定义为具有Int参数并返回Int参数的函数类型的变量。

现在，我们可以调用变量exponentialFunction，如下面的代码片段所示。

exponentialFunction(4) //This would work the same way as square(4)

square(exponentialFunction(5)) //This would return 625

exponentialFunction(exponentialFunction(5)) //Same as above

我们可以将" exponentialFunction"的类型更改为函数" cube"，如下所示。

exponentialFunction = cube(_:)
square(exponentialFunction(5)) //square of cube of 5. returns 15625

让我们创建一个接受上述函数square和cube作为参数的函数。

var integers = [1,2,3,4,5]

func sumOfExponentialsOf(array a: [Int], with function: (Int)->Int)->Int
{
  var result = 0
  for x in a
  {
      result = result + function(x)
  }
  return result   
}

上面的函数计算所有数组元素的函数返回值的总和。

提示：Swift足够聪明，可以根据值推断变量/常量的类型。

注意：第二个参数接受类型为(Int)-> Int的类型，该类型与exponentialFunction的类型相同。

我们将使用上述函数来计算所有数组元素的平方和和立方和，如下所示。

exponentialFunction = square(_:)
//sum of squares of all array elements
sumOfExponentialsOf(array: integers, with: exponentialFunction) //returns 55
exponentialFunction = cube(_:)
//sum of cubes of all array elements
sumOfExponentialsOf(array: integers, with: exponentialFunction) //returns 225

最后，一个函数有可能返回另一个函数。
让我们创建一个根据条件返回" square"或者" cube"函数的函数。

func chooseComputation(isSquared b : Bool) -> (Int)->Int{

  func square(_ num :Int)->Int
  {
      return num*num
  }
  
  func cube(_ num :Int)->Int
  {
      return num*num*num
  }
  
  if b {
      return square
  }
  else{
      return cube
  }

}

var result = chooseComputation(isSquared: true)
result(2) //returns 4

result = chooseComputation(isSquared: false)
result(2) //returns 8

" chooseComputation"函数由两个与return类型相同的函数组成。

基于布尔值，" chooseComputation"函数返回对两个嵌套函数的引用，然后从结果变量中对其进行引用。