美文网首页
Swift-函数基础

Swift-函数基础

作者: Burgess_9527 | 来源:发表于2020-11-29 14:06 被阅读0次
    文章结构.png

    一、函数

    1、定义

    1、声明:func 函数名(形参名:形参类型,形参名:形参类型)-> 返回值类型

    // func 函数名(形参名:形参类型,形参名:形参类型)-> 返回值类型
    func sum(num1: Int, num2: Int) -> Int {
        return num1 + num2
    }
    

    2、调用:函数名(形参名:实参,形参名:实参)

    // 函数名(形参名:实参,形参名:实参)
    sum(num1: 10, num2: 20)
    

    2、知识点

    \color{#FF0000}{1、形参默认是let,也只能是let}
    2、无返回值的三种写法:

    // 1、直接不写返回值
    func sum(num1: Int, num2: Int) {
        
    }
    
    // 2、Void
    func sum(num1: Int, num2: Int) -> Void {
        
    }
    
    // 3、返回空元组
    func sum(num1: Int, num2: Int) -> () {
        
    }
    

    3、隐式返回
    条件:如果整个函数体都是一个单一表达式,那么函数会隐式返回这个表达式

    func sum(num1: Int, num2: Int) -> Int {
        num1 + num2
    }
    sum(num1: 10, num2: 20) // 30
    

    4、返回元组(作用:实现多返回值)
    对比C语言:C语言返回值都只有一个

    // 计算后返回:和、差、平均
    func calculate(v1: Int, v2: Int) -> (sum: Int, difference: Int, average: Int) {
        let sum = v1 + v2
        return (sum, v1 - v2, sum >> 1)
    }
    let result = calculate(v1: 20, v2: 10)
    result.sum // 30
    result.difference // 10
    result.average // 15
    

    5、函数文档注释
    Swift代码规范:https://swift.org/documentation/api-design-guidelines/

    /// 求和【概述】
    ///
    /// 将2个整数相加【更详细的描述】
    ///
    /// - Parameter v1: 第1个整数
    /// - Parameter v2: 第2个整数
    /// - Returns: 2个整数的和
    ///
    /// - Note:传入2个整数即可【批注】
    ///
    func sum(v1: Int, v2: Int) -> Int {
        v1 + v2
    }
    
    函数注释样式.png

    6、参数标签(Argument Label)

    • 修改参数标签
    func goToWork(at time: String) {
    print("this time is \(time)")
    }
    goToWork(at: "08:00") // 如果没有写at这个参数标签时,调用:goToWork(time: "08:00")
    // this time is 08:00
    
    • 可以使用 _ 省略参数标签
    func sum(_ v1:  Int, _ v2: Int) -> Int {
        v1 + v2
    }
    sum(10, 20)
    

    二、默认参数值(Default Parameter Value)

    1、参数可以有默认值

    func check(name: String = "nobody", age: Int, job: String = "none") {
        print("name=\(name), age=\(age), job=\(job)")
    }
    check(name: "Jack", age: 20, job: "Doctor") // name=Jack, age=20, job=Doctor
    check(name: "Rose", age: 18) // name=Rose, age=18, job=none
    check(age: 10, job: "Batman") // name=nobody, age=10, job=Batman
    check(age: 15) // name=nobody, age=15, job=none
    

    2、C++的默认参数值有个限制:必须从右往左设置。由于Swift拥有参数标签,因此并没有此类限制
    3、但是在省略参数标签时,需要特别注意,避免出错

    // 这里的middle不可以省略参数标签
    func test(_ first: Int = 10, middle: Int, _ last: Int = 30) {
    
     }
    test(middle: 20)
    

    三、可变参数(Variadic Parameter)

    func sum(_ numbers: Int...) -> Int {
        var total = 0
        for number in numbers {
            total += number
        }
        return total
    }
    sum(10, 20, 30, 40) // 100
    

    注意:

    • 一个函数\color{#FF0000}{最多只能有1个}可变参
    • 紧跟在可变参数后面的参数不能省略参数标签
    // 参数string不能省略标签
    func test(_ numbers: Int..., string: String, _ other: String) { 
    
    }
    test(10, 20, 30, string: "Jack", "Rose"
    

    例子:Swift自带的print函数

    /// - Parameters:
    /// 
    - items: Zero or more items to print.
    /// 
    - separator: A string to print between each item. The default is a single space (`" "`).
    /// 
    - terminator: The string to print after all items have been printed. The
    /// 
    default is a newline (`"\n"`).
    public func print(_ items: Any..., separator: String = " ", terminator: String = "\n")
    
    print(1, 2, 3, 4, 5) // 1 2 3 4 5
    print(1, 2, 3, 4, 5, separator: "_") // 1_2_3_4_5
    print("My name is Jake.", terminator: "")
    print("My age is 18.")
    // My name is Jake.My age is 18.
    

    四、输入输出参数(In-Out Parameter)

    描述:可以用inout定义一个输入输出参数:可以在函数内部修改外部实参的值

    func swapValues(_ v1: inout Int, _ v2: inout Int) {
        let tmp = v1
        v1 = v2
        v2 = tmp
    }
    var num1 = 10
    var num2 = 20
    
    swapValues(&num1, &num2)
    func swapValues(_ v1: inout Int, _ v2: inout Int) {
        (v1, v2) = (v2, v1)
    }
    
    • 可变参数不能标记为inout
    • inout参数不能有默认值
    • inout参数只能传入可以被多次赋值的(不能是let类型)
    • inout参数的本质是地址传递(引用传递)

    五、函数重载(Function Overload)

    1、规则:

    1、函数名相同
    2、参数个数不同 || 参数类型不同 || 参数标签不同

    func sum(v1: Int, v2: Int) -> Int {
        v1 + v2
    }
    
    func sum(v1: Int, v2: Int, v3: Int) -> Int {
        v1 + v2 + v3
    } // 参数个数不同
    
    func sum(v1: Int, v2: Double) -> Double {
        Double(v1) + v2
    } // 参数类型不同
    
    func sum(v1: Double, v2: Int) -> Double {
        v1 + Double(v2)
    } // 参数类型不同
    
    func sum(_ v1: Int, _ v2: Int) -> Int {
        v1 + v2
    } // 参数标签不同
    
    func sum(a: Int, b: Int) -> Int {
        a + b
    } // 参数标签不同
    
    sum(v1: 10, v2: 20) // 30
    sum(v1: 10, v2: 20, v3: 30) // 60
    sum(v1: 10, v2: 20.0) // 30.0
    sum(v1: 10.0, v2: 20) // 30.0
    sum(10, 20) // 30
    sum(1020) // 30
    

    2、注意

    1、返回值类型与函数重载无关
    2、默认参数值和函数重载一起使用产生二义性时,编译器并不会报错(在C++中会报错)

    func sum(v1: Int, v2: Int) -> Int {
        v1 + v2
    }
    func sum(v1: Int, v2: Int, v3: Int = 10) -> Int {
        v1 + v2 + v3
    }
    
    // 会调用sum(v1: Int, v2: Int) 
    sum(v1: 10, v2: 20)
    

    3、可变参数、省略参数标签、函数重载一起使用产生二义性时,编译器有可能会报错

    func sum(v1: Int, v2: Int) -> Int {
        v1 + v2
    }
    func sum(_ v1: Int, _ v2: Int) -> Int {
        v1 + v2
    }
    func sum(_ numbers: Int...) -> Int {
        var total = 0
        for number in numbers {
            total += number
        }
        return total
    }
    
    // error: ambiguous use of 'sum'
    sum(10, 20)
    

    六、内联函数(Inline Function)

    1、内联函数

    如果开启了编译器优化(Release模式默认会开启优化),编译器会自动将某些函数变成内联函数:将函数调用展开成函数体

    Swift编译优化设置.png

    哪些函数不会被自动内联?

    • 函数体比较长
    • 包含递归调用
    • 包含动态派发
    • ......

    2、@linline

    在Release模式下,编译器已经开启优化,会自动决定哪些函数需要内联,因此没必要使用@inline

    // 永远不会被内联(即使开启了编译器优化)
    @inline(never) func test() {
        print("test")
    }
    
    // 开启编译器优化后,即使代码很长,也会被内联(递归调用函数、动态派发的函数除外)
    @inline(__always) func test() {
        print("test")
    }
    

    七、函数类型(Function Type)

    每一个函数都是有类型的,函数类型由形式参数类型返回值类型组成

    func test() { } // () -> Void 或者 () -> ()
    func sum(a: Int, b: Int) -> Int {
        a + b
    } // (Int, Int) -> Int
    
    // 定义变量
    var fn: (Int, Int) -> Int = sum
    fn(2, 3) // 5,调用时不需要参数标
    

    1.1、函数类型作为函数参数

    func sum(v1: Int, v2: Int) -> Int {
      v1 + v2
    }
    
    func difference(v1: Int, v2: Int) -> Int {
      v1 - v2
    }
    
    func printResult(_ mathFn: (Int, Int) -> Int, _ a: Int, _ b: Int) {
        print("Result: \(mathFn(a, b))")
    }
    
    printResult(sum, 5, 2) // Result: 7
    printResult(difference, 5, 2) // Result: 3
    

    1.2、函数类型作为函数返回值
    返回值是函数类型的函数,叫做高阶函数(Higher-Order Function)

    func next(_ input: Int) -> Int {
        input + 1
    }
    
    func previous(_ input: Int) -> Int {
        input - 1
    }
    
    func forward(_ forward: Bool) -> (Int) -> Int {
        forward ? next : previous
    }
    
    forward(true)(3) // 4
    forward(false)(3) // 2
    

    八、嵌套函数(Nested Function)

    将函数定义在函数内部(不想暴露内部函数)

    func forward(_ forward: Bool) -> (Int) -> Int {
        func next(_ input: Int) -> Int {
            input + 1
        }
        func previous(_ input: Int) -> Int {
            input - 1
        }
        return forward ? next : previous
    }
    
    forward(true)(3) // 4
    forward(false)(3) // 2
    

    相关文章

      网友评论

          本文标题:Swift-函数基础

          本文链接:https://www.haomeiwen.com/subject/ivxkwktx.html