函数的介绍

• 函数相当于OC中的方法
• 函数的格式如下

func 函数名(参数列表) -> 返回值类型 {
    代码块
    return 返回值
}

• func是关键字,多个参数列表之间可以用逗号（,）分隔，也可以没有参数
• 使用箭头“->”指向返回值类型
• 如果函数没有返回值，返回值为Void.并且“-> 返回值类型”部分可以省略

常见的函数类型

 // 1.没有参数,没用返回值
 func about() -> Void {
    print("ios")
 }
 // 调用函数
 about()
 
 // 简单写法
 // 如果没用返回值,Void可以写成()
 func about1() -> () {
    print("iphone")
 }
 about1()
 
 // 如果没有返回值,后面的内容可以都不写
 func about2() {
    print("iphone 2")
 }
 about2()
 
 // 2.有参数,没用返回值
 func callPhone(phoneNum : String) {
    print("打电话给\(phoneNum)")
 }
 callPhone(phoneNum: "+86 10086")
 
 // 3.没用参数,有返回值
 func readMessage() -> String {
    return "吃饭了吗?"
 }
 var str = readMessage()
 print(str)

 // 4.有参数,有返回值
 func sum(num1 : Int, num2 : Int) -> Int {
    return num1 + num2
 }
 var result = sum(num1: 20, num2: 30)
 print(result)

 // 5.有多个返回值的函数
 func getNumCount(nums : [Int]) -> (oddCount : Int, evenCount : Int) {
    var oddCount = 0
    var evenCount = 0
    for num in nums {
        if num % 2 == 0 {
            oddCount += 1
        } else {
            evenCount += 1
        }
    }
    return (oddCount, evenCount)
 }
 
 let nums = [1, 3, 4, 8, 23]
 
 let result1 = getNumCount(nums: nums)
 print(result1.oddCount)
 print(result1.evenCount)

函数的使用注意

• 注意一: 外部参数和内部参数
  • 在函数内部可以看到的参数,就是内部参数
  • 在函数外面可以看到的参数,就是外部参数
  • 默认情况下,从第二个参数开始,参数名称既是内部参数也是外部参数
  • 如果第一个参数也想要有外部参数,可以设置标签:在变量名前加标签即可
  • 如果不想要外部参数,可以在参数名称前加_

 // num1、a、b 是外部参数的名称
 func ride(num1 num1 : Int, a num2 : Int, b num3 : Int) -> Int {
    return num1 * num2 * num3
 }
 var result1 = ride(num1: 20, a: 4, b: 5)
 
 // 方法的重载:方法名称相同,但是参数不同,可以称之为方法的重载(了解)
 func ride(num1: Int, _ num2 :Int) -> Int {
    return num1 * num2
 }
 
 var result2 = ride(num1: 20, 20)

• 注意二: 默认参数
  • 某些情况,如果没有传入具体的参数,可以使用默认参数

 func makecoffee(type :String = "卡布奇诺") -> String {
    return "制作一杯\(type)咖啡。"
 }
 
 let coffee1 = makecoffee(type: "拿铁")
 let coffee2 = makecoffee()

• 注意三: 可变参数
  • swift中函数的参数个数可以变化，它可以接受不确定数量的输入类型参数
  • 它们必须具有相同的类型
  • 我们可以通过在参数类型名后面加入（...）的方式来指示这是可变参数

 func sum(numbers:Double...) -> Double {
    var total: Double = 0
    for number in numbers {
        total += number
    }
    return total
 }
 
 sum(numbers: 10.0, 20, 30)
 sum(numbers: 30, 80)

• 注意四: 引用类型(指针的传递)
  • 默认情况下,函数的参数是值传递.如果想改变外面的变量,则需要传递变量的地址
  • 必须是变量,因为需要在内部改变其值
  • Swift提供的inout关键字就可以实现
  • 对比下列两个函数

 // 函数一:值传递
 func swap(a : Int, b : Int) {
    let temp = a;
    a = b;
    b = temp
    
    print("a:\(a), b:\(b)")
 }

 var a = 10
 var b = 20
 swap(a: a, b: b)
 print("a:\(a), b:\(b)")

函数一在swift3.0中报错

Playground execution failed: error: MyPlayground.playground:3:7: error: cannot assign to value: 'a' is a 'let' constant
a = b;
~ ^
error: MyPlayground.playground:4:7: error: cannot assign to value: 'b' is a 'let' constant
b = temp
~ ^

正确写法是函数二

 // 函数二:指针的传递
 func swap1(a : inout Int, b : inout Int) {
    let temp = a
    a = b
    b = temp
    
    print("a:\(a), b:\(b)")
 }
 
 var a = 10
 var b = 20
 
 swap1(a: &a, b: &b)
 print("a:\(a), b:\(b)")

• 函数的嵌套使用
  • swift中函数可以嵌套使用
  • 即函数中包含函数,但是不推荐该写法

 // 函数的嵌套
 let value = 55
 
 func test() {
    
    func demo() {
        print("demo \(value)")
    }
    
    print("test")
    demo()
 }
 
// demo() // 错误：demo 是 test 的内部函数，外部无法调用
 test() // 执行函数会先打印'test',再打印'demo'

函数的类型

• 函数类型的概念
  • 每个函数都有属于自己的类型，由函数的参数类型和返回类型组成
    • 这个例子中定义了两个简单的数学函数：addTwoInts 和 multiplyTwoInts
    • 这两个函数都传入两个 Int 类型， 返回一个合适的Int值
    • 这两个函数的类型是 (Int, Int) -> Int

// 定义两个函数
func addTwoInts(a : Int, b : Int) -> Int {
    return a + b
}

func multiplyTwoInt(a : Int, b : Int) -> Int {
    return a * b
}

• 抽取两个函数的类型,并且使用

 // 定义函数的类型
 var mathFunction : (Int, Int) -> Int = addTwoInts
 
 // 使用函数的名称
 mathFunction(10, 20)   // 30
 
 // 给函数的标识符赋值其他值
 mathFunction = multiplyTwoInt
 
 // 使用函数的名称
 mathFunction(10, 20)   // 200

• 函数作为方法的参数

 // 将函数的类型作为方法的参数
 func printResult(a : Int, b : Int, calculateMethod : (Int, Int) -> Int) {
    print(calculateMethod(a, b))
 }
 
 printResult(a: 10, b: 20, calculateMethod: addTwoInts)         // 30
 printResult(a: 10, b: 20, calculateMethod: multiplyTwoInt)     // 200

• 函数作为方法的返回值

 // 1.定义两个函数
 func stepForward(num : Int) -> Int {
    return num + 1
 }
 
 func stepBackward(num : Int) -> Int {
    return num - 1
 }
 
 // 2.定义一个变量,希望该变量经过计算得到0
 var num = -4
 
 // 3.定义获取哪一个函数
 func getOprationMethod(num : Int) -> (Int) -> Int {
    return num <= 0 ? stepForward : stepBackward
 }
 
 // 4.for循环进行操作
 while num != 0 {
    let oprationMethod = getOprationMethod(num: num)
    num = oprationMethod(num)
    print(num)
 }

• 系列文章
  01 Swift最基本的语法变化
  02 Swift中的变量和常量
  03 Swift中的数据类型
  04 Swift逻辑分支
  05 Swift中的循环
  06 Switf中的字符串
  07 Swift 数组
  08 Swift字典
  09 Swift 元组
  10 Swift 可选类型
  11 Swift 类型转化
  12 Swift 函数
  13 Swift 枚举类型
  14 Swift 结构体
  15 Swift 类的定义
  16 Swift 类的构造函数
  17 Swift 类的析构函数
  18 自动引用计数
  19 Swift 可选链
  20 协议
  21 闭包
  22 Swift 懒加载
  23 Swift 注释