Swift---6.函数

• 函数
• 函数的定义与调用
  • 定义:func xxx (xxx:type,xxx:type) -> type
    以func关键字开头,后接方法名,()内为传入参数,参数形式为名称,类型,多个参数以","隔开,可为空,但必须写上(),->后带的数据类型,就是函数返回的类型,若不返回值,则->type整段不写
  • 调用函数:只需要在函数后,输入函数名,并以()结尾即可,有传入参数的则必须传入参数,有返回值的,定义一个变量或者常量来接收这个返回值

func hello() {
     print("hello world!")
}
hello()
func appendStr (first:String,second:String) -> String {
     let string = first + second
     return string
}
var helloworld = appendStr(first: "hello ", second: "world!")

• 参数(相同方法名,若传入参数不同,则方法不同.函数内,参数为常数,若尝试修改其值,报错)

func hello (string:String) {
     print(string)
}
func hello() {
     print("hello")
}
hello()
hello(string: "test")

- 参数标签(Swift中,函数参数拥有一个标签名,用于外部调用时传入参数,若我们不想暴露参数名称,可以使用关键字```_```,则外部调用参数时,不会看到对应的参数名)
```
func appendStr (str1 first:String,str2 second:String) -> String {
    let string = first + second
    return string
}
print(appendStr(str1:"a", str2:"b"))
func appendStr (_ first:String,_ second:String) -> String {
    let string = first + second
    return string
}
print(appendStr("a", "b"))
```
- 参数默认值(Swift中,可以在定义传入参数时,为其添加默认值,若调用方法时不传入,则默认使用该值)
```
func num(first:Int = 11 , second:Int = 12) {
    print("\(first) + \(second) = \((first+second))")
}
num()
num(first:1)
num(first: 10, second: 10)
```
- 可变参数(当我们不确定传入参数个数时,我们可以使用可变参数来声明改函数可以传入不同数量的值作为参数,在参数类型后使用```...```即可)
```
func variableArguments(_ arguments:Int...) {
    var total = 0
    guard arguments.count>0 else {
        return
    }
    for number in arguments {
        total += number
    }
    print(total)
}
variableArguments(1,2,3,4,5,6)
variableArguments()
```
- 改变参数的值(我们知道传入的值是常量,不可改变,但如果我们想改变传入的值,可以使用```inout```关键字加在参数名类型前,注意,调用函数式,参数名前面需要加入```&```符号;同时,内部参数改变,外部的参数也会发生变化,且可变参数不可使用```inout```关键字,也不可传入常数作为参数)
```
func swapTwoInts(_ a:inout Int ,_ b:inout Int) {
    var tem = 0
    tem = a
    a = b
    b = tem
}
var a = 3
var b = 4
swapTwoInts(&a, &b)
print(a,b)
```
-

• 返回值
  • 单一返回值

  func returnStr() ->String {
      return "str"
  }
  returnStr()
  

  • 使用元组返回多个值

  var array = [3,1,5,7,2,0,10]
  func arrayMinAndMax(array:[Int]) ->(min:Int,max:Int) {
      var currentMax = array[0]
      var currentMin = array[0]
      for value in array[1..<array.count] {
          if value < currentMin {
              currentMin = value
          }
          else if value > currentMax {
              currentMax = value
          }
      }
      return (currentMin,currentMax)
  }
  var result = arrayMinAndMax(array: array)
  result.max
  

  • 上述写法,如果传入空数组,会报错,因为引起数组越界,为了安全性,我们修改方法判断,同时因为此时没有min和max可以返回,我们也应该修改返回值为可选类型,即,我们可以使用nil作为返回值

  var array = [Int]()
  func arrayMinAndMax(array:[Int]) ->(min:Int,max:Int)? {
      if array.isEmpty {
          return nil
      }
      var currentMax = array[0]
      var currentMin = array[0]
      for value in array[1..<array.count] {
          if value < currentMin {
              currentMin = value
          }
          else if value > currentMax {
              currentMax = value
          }
      }
      return (currentMin,currentMax)
  }
  var result = arrayMinAndMax(array: array)
  if result != nil {
      print("min is \(result!.min) max is \(result!.max)")
  }
  

• 函数类型(每个函数都可以视为参数为何,返回值为何的参数,如下例子,则是含有两个int类型参数,返回一个int类型的函数),既然将其视为一种数据类型,则,我们可以定义类型为该函数类型的变量或常量

func addFunction(_ number1:Int , _ number2 : Int) -> Int {
       return number1 + number2
}
var function:(Int,Int) -> Int = addFunction
print(function(1,3))

• 函数类型作为函数参数(上面提到函数可以作为一种类型,那么它也可作为参数传入函数)

func addFunction(_ number1:Int , _ number2 : Int) -> Int {
       return number1 + number2
}
var function:(Int,Int) -> Int = addFunction
func printAddFuctionResult (function:(Int,Int) -> Int,_ a:Int,_ b : Int) {
       function(a,b)
}
printAddFuctionResult(function: addFunction, 3, 5)

• 函数类型作为返回值

func addFunction() -> (Int,Int) -> Int {
       func returnFunc (_ a:Int , _ b:Int) ->Int {
           return a+b
       }
       return returnFunc
}
var function = addFunction()
var total = function(1,3)