Swift基础（六）函数

Swift 函数

• Swift 函数用来完成特定任务的独立的代码块。
• Swift使用一个统一的语法来表示简单的C语言风格的函数到复杂的Objective-C语言风格的方法。

函数声明: 告诉编译器函数的名字，返回类型及参数。
函数定义: 提供了函数的实体。

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

函数的定义

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

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

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

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

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

函数调用

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

  func runoob(site: String) -> String {
      return (site)
  }
  print(runoob(site: "www.runoob.com")) // www.runoob.com
  

函数参数

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

  // 无参数函数
  func sayHelloWorld() -> String {
      return "hello, world"
  }
  print(sayHelloWorld())
  
  // 多参数函数 用逗号隔开
  func greet(person: String, alreadyGreeted: Bool) -> String {
      if alreadyGreeted {
          return greetAgain(person: person)
      } else {
          return greet(person: person)
      }
  }
  print(greet(person: "Tim", alreadyGreeted: true))
  

函数返回值

• 可以没有返回值

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

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

  // 无返回值函数 定义中没有返回箭头（->）和返回类型。
  func greet(person: String) {
      print("Hello, \(person)!")
  }
  greet(person: "Dave")
  
  // 调用函数时，可以忽略该函数的返回值：
  func printAndCount(string: String) -> Int {
      print(string)
      return string.count
  }
  func printWithoutCounting(string: String) {
      let _ = printAndCount(string: string)
  }
  printAndCount(string: "hello, world") // 打印“hello, world”，并且返回值 12
  printWithoutCounting(string: "hello, world") // 打印“hello, world”，但是没有返回任何值
  
  // 隐式返回的函数
  // 任何一个可以被写成一行 return 语句的函数都可以忽略 return
  func greeting(for person: String) -> String {
      "Hello, " + person + "!"
  }
  print(greeting(for: "Dave"))
  // 打印 "Hello, Dave!"
  
  // 多重返回值函数
  // 可选元组返回类型  
  // 通过在元组类型的右括号后放置一个问号来定义一个可选元组，例如 (Int, Int)? 或 (String, Int, Bool)?
  func minMax(array: [Int]) -> (min: Int, max: Int)? {
      if array.isEmpty { return nil }
      var currentMin = array[0]
      var currentMax = array[0]
      for value in array[1..<array.count] {
          if value < currentMin {
              currentMin = value
          } else if value > currentMax {
              currentMax = value
          }
      }
      return (currentMin, currentMax)
  }
  
  // 不确定返回的元组一定不为nil，那么你可以返回一个可选的元组类型。
  // 使用可选绑定来检查 minMax(array:) 函数返回的是一个存在的元组值还是 nil
  if let bounds = minMax(array: [8, -6, 2, 109, 3, 71]) {
      print("min is \(bounds.min) and max is \(bounds.max)")
  } // 打印“min is -6 and max is 109”
  
  

函数参数标签和参数名称

• 函数参数都有一个参数标签和一个参数名称

  // 参数名称在函数的实现内部使用。 
  func sample(number: Int) {
     println(number)
  }
  
  // 可以在参数名称前指定参数标签，中间以空格分隔，参数标签用于在函数调用时传递给函数的参数。
  // 如果你提供了参数标签，那么函数在被调用时，必须使用参数标签。
  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)
  
  // 默认参数值
  func someFunction(parameterWithoutDefault: Int, parameterWithDefault: Int = 12) {
      // 如果你在调用时候不传第二个参数，parameterWithDefault 会值为 12 传入到函数体中。
  }
  someFunction(parameterWithoutDefault: 3, parameterWithDefault: 6) // parameterWithDefault = 6
  someFunction(parameterWithoutDefault: 4) // parameterWithDefault = 12
  
  // 可变参数可以接受零个或多个值。函数调用时，你可以用可变参数来指定函数参数，其数量是不确定的。
  // 可变参数通过在变量类型名后面加入（...）的方式来定义。
  func vari<N>(members: N...){
      for i in members {
          print(i)
      }
  }
  vari(members: 4,3,5)
  vari(members: 4.5, 3.1, 5.6)
  vari(members: "Google", "Baidu", "Runoob")
  
  // 一般默认在函数中定义的参数都是常量参数，也就是这个参数你只可以查询使用，不能改变它的值。
  // 如果想要声明一个变量参数，可以在参数定义前加 inout 关键字，这样就可以改变这个参数的值了。
  // 此时这个 name 值可以在函数中改变。
  func  getName(_ name: inout String).........
  
  // 一般默认的参数传递都是传值调用的，而不是传引用。所以传入的参数在函数内改变，并不影响原来的那个参数。传入的只是这个参数的副本。
  // 当传入的参数作为输入输出参数时，需要在参数名前加 & 符，表示这个值可以被函数修改。
  func swapTwoInts(_ a: inout Int, _ b: inout Int) {
      let temporaryA = a
      a = b
      b = temporaryA
  }
  var x = 1
  var y = 5
  swapTwoInts(&x, &y)
  print("x 现在的值 \(x), y 现在的值 \(y)")
  

函数类型

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

  func inputs(no1: Int, no2: Int) -> Int {
     return no1/no2
  }
  func inputstr(name: String) -> String {
     return name
  }
  func inputstr() {
     print("菜鸟教程")
     print("www.runoob.com")
  }
  inputstr()
  

使用函数类型

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

  var addition: (Int, Int) -> Int = sum
  // 可以用 addition 来调用被赋值的函数了
  
  func sum(a: Int, b: Int) -> Int {
     return a + b
  }
  var addition: (Int, Int) -> Int = sum
  print("输出结果: \(addition(40, 89))")
  

函数类型作为参数类型、函数类型作为返回类型

• 可以将函数作为参数传递给另外一个参数：

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

嵌套函数

• 函数嵌套指的是函数内定义一个新的函数，外部的函数可以调用函数内定义的函数。

  func calcDecrement(forDecrement total: Int) -> () -> Int {
     var overallDecrement = 0
     func decrementer() -> Int {
        overallDecrement -= total
        return overallDecrement
     }
     return decrementer
  }
  let decrem = calcDecrement(forDecrement: 30)
  print(decrem())