Swift - 函数

  • 简述

    函数是一组组织在一起以执行特定任务的语句。Swift 4 函数可以像简单的 C 函数一样简单,也可以像 Objective C 语言函数一样复杂。它允许我们在函数调用中传递局部和全局参数值。
    • 函数声明 - 告诉编译器函数的名称、返回类型和参数。
    • 函数定义 - 它提供了函数的实际主体。
    Swift 4 函数包含参数类型及其返回类型。
  • 功能定义

    在 Swift 4 中,函数是由“func”关键字定义的。当一个函数被新定义时,它可能需要一个或几个值作为函数的输入“参数”,它将处理主体中的函数并将这些值作为输出“返回类型”传递回函数。
    每个函数都有一个函数名,它描述了该函数执行的任务。要使用函数,您需要使用函数名称“调用”该函数并传递与函数参数类型匹配的输入值(称为参数)。函数参数也称为“元组”。
    函数的参数必须始终以与函数参数列表相同的顺序提供,并且返回值后跟 →。

    句法

    
    func funcname(Parameters) -> returntype {
       Statement1
       Statement2
       ---
       Statement N
       return parameters
    }
    
    看看下面的代码。学生的名字被声明为在函数“student”中声明的字符串数据类型,当函数被调用时,它将返回学生的名字。
    
    func student(name: String) -> String {
       return name
    }
    print(student(name: "First Program"))
    print(student(name: "About Functions"))
    
    当我们使用操场运行上述程序时,我们得到以下结果 -
    
    First Program
    About Functions
    
  • 调用函数

    假设我们定义了一个名为“display”的函数,以考虑例如显示数字,函数名称为“display”的函数首先使用参数“no1”进行初始化,该参数包含整数数据类型。然后将参数“no1”分配给参数“a”,该参数此后将指向相同的数据类型整数。现在参数 'a' 返回给函数。这里 display() 函数将保存整数值并在每次调用该函数时返回整数值。
    
    func display(no1: Int) -> Int {
       let a = no1
       return a
    }
    print(display(no1: 100))
    print(display(no1: 200))
    
    当我们使用 Playground 运行上面的程序时,我们得到以下结果 -
    
    100
    200
    
  • 参数和返回值

    Swift 4 提供了灵活的函数参数及其从简单值到复杂值的返回值。与 C 和 Objective C 类似,Swift 4 中的函数也可以采用多种形式。

    带参数的函数

    通过将其参数值传递给函数体来访问函数。我们可以将单个到多个参数值作为函数内部的元组传递。
    
    func mult(no1: Int, no2: Int) -> Int {
       return no1*no2
    }
    print(mult(no1: 2, no2: 20))
    print(mult(no1: 3, no2: 15))
    print(mult(no1: 4, no2: 30))
    
    当我们使用 Playground 运行上面的程序时,我们得到以下结果 -
    
    40
    45
    120
    
  • 没有参数的函数

    我们也可能有没有任何参数的函数。

    句法

    
    func funcname() -> datatype {
       return datatype
    }
    
    以下是一个没有参数的函数的例子 -
    
    func votersname() -> String {
       return "Mooce"
    }
    print(votersname()) 
    
    当我们使用操场运行上述程序时,我们得到以下结果 -
    
    Mooce
    
  • 具有返回值的函数

    函数还用于将字符串、整数和浮点数据类型值作为返回类型返回。为了找出给定数组中的最大和最小数,函数 'ls' 用大整数和小整数数据类型声明。
    初始化数组以保存整数值。然后处理数组,读取数组中的每个值并将其与其先前的值进行比较。当该值小于前一个值时,它存储在“小”参数中,否则存储在“大”参数中,并通过调用函数返回值。
    
    func ls(array: [Int]) -> (large: Int, small: Int) {
       var lar = array[0]
       var sma = array[0]
       for i in array[1..<array.count] {
          if i < sma {
             sma = i
          } else if i > lar {
             lar = i
          }
       }
       return (lar, sma)
    }
    let num = ls(array: [40,12,-5,78,98])
    print("Largest number is: \(num.large) and smallest number is: \(num.small)")
    
    当我们使用操场运行上述程序时,我们得到以下结果 -
    
    Largest number is: 98 and smallest number is: -5
    
  • 没有返回值的函数

    某些函数可能在函数内部声明了参数,而没有任何返回值。以下程序声明ab作为 sum() 函数的参数。在函数本身内部参数的值ab 通过调用函数调用 sum() 传递并打印其值,从而消除返回值。
    
    func sum(a: Int, b: Int) {
       let a = a + b
       let b = a - b
       print(a, b)
    }
    sum(a: 20, b: 10)
    sum(a: 40, b: 10)
    sum(a: 24, b: 6)
    
    当我们使用操场运行上述程序时,我们得到以下结果 -
    
    30 20
    50 40
    30 24
    
  • 具有可选返回类型的函数

    Swift 4 引入了“可选”功能,通过引入安全措施来解决问题。考虑例如我们将函数值的返回类型声明为整数,但是当函数返回字符串值或 nil 值时会发生什么。在这种情况下,编译器将返回一个错误值。引入了“可选”以摆脱这些问题。
    可选函数将采用两种形式“值”和“零”。我们将使用键保留字符 '?' 来提及 'Optionals'。检查元组是返回一个值还是一个 nil 值。
    
    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)
    }
    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
    
    ''Optionals' 用于检查 'nil' 或垃圾值,从而在调试中消耗大量时间并使代码对用户有效和可读。
  • 函数本地与外部参数名称

    本地参数名称

    局部参数名称仅在函数内部访问。
    
    func sample(number: Int) {
       print(number)
    }
    
    在这里, funcsample 参数 number 被声明为内部变量,因为它是由函数 sample() 在内部访问的。这里“数字”被声明为局部变量,但对变量的引用是在函数外部使用以下语句进行的 -
    
    func sample(number: Int) {
       print(number)
    }
    sample(number: 1)
    sample(number: 2)
    sample(number: 3)
    
    当我们使用操场运行上述程序时,我们得到以下结果 -
    
    1
    2
    3
    
  • 外部参数名称

    外部参数名称允许我们命名函数参数以使其用途更加明确。例如,您可以命名两个函数参数,然后按如下方式调用该函数 -
    
    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)
    
    当我们使用操场运行上述程序时,我们得到以下结果 -
    
    125
    
  • 可变参数

    当我们想定义具有多个参数的函数时,我们可以将成员声明为“可变参数”参数。参数可以通过参数名称后的 (···) 指定为可变参数。
    
    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: "Swift 4", "Enumerations", "Closures")
    
    当我们使用操场运行上述程序时,我们得到以下结果 -
    
    4
    3
    5
    4.5
    3.1
    5.6
    Swift 4
    Enumerations
    Closures
    
  • 常量、变量和 I/O 参数

    默认情况下,函数将参数视为“常量”,而用户也可以将函数的参数声明为变量。我们已经讨论过,'let' 关键字用于声明常量参数,而变量参数是用 'var' 关键字定义的。
    Swift 4 中的 I/O 参数提供了保留参数值的功能,即使它的值在函数调用后被修改。在函数参数定义的开头,声明了 'inout' 关键字以保留成员值。
    它派生出关键字“inout”,因为它的值被“in”传递给函数,并且它的值由它的函数体访问和修改,并且它返回到函数的“out”以修改原始参数。
    变量仅作为输入输出参数的参数传递,因为它的值仅在函数内部和外部被修改。因此无需将字符串和文字声明为输入输出参数。变量名前的“&”表示我们正在将参数传递给输入输出参数。
    
    func temp(a1: inout Int, b1: inout Int) {
       let t = a1
       a1 = b1
       b1 = t
    }
    var no = 2
    var co = 10
    temp(a1: &no, b1: &co)
    print("Swapped values are \(no), \(co)")
    
    当我们使用操场运行上述程序时,我们得到以下结果 -
    
    Swapped values are 10, 2
    
  • 函数类型及其用法

    每个函数都通过考虑输入参数来遵循特定的函数并输出所需的结果。
    
    func inputs(no1: Int, no2: Int) -> Int {
       return no1/no2
    }
    
    以下是一个例子 -
    
    func inputs(no1: Int, no2: Int) -> Int {
       return no1/no2
    }
    print(inputs(no1: 20, no2: 10))
    print(inputs(no1: 36, no2: 6))
    
    当我们使用操场运行上述程序时,我们得到以下结果 -
    
    2
    6
    
    这里函数用两个参数初始化 no1no2 作为整数数据类型,其返回类型也声明为“int”
    
    Func inputstr(name: String) -> String {
       return name
    }
    
    这里函数声明为 string 数据类型。
    函数也可能有 void 数据类型和此类函数不会返回任何内容。
    
    func inputstr() {
       print("Swift 4 Functions")
       print("Types and its Usage")
    }
    inputstr()
    
    当我们使用操场运行上述程序时,我们得到以下结果 -
    
    Swift 4 Functions
    Types and its Usage
    
    上面的函数被声明为一个没有参数和返回值的 void 函数。
  • 使用函数类型

    函数首先通过整数、浮点数或字符串类型参数传递,然后作为常量或变量传递给函数,如下所述。
    
    var addition: (Int, Int) -> Int = sum
    
    这里 sum 是具有 'a' 和 'b' 整数变量的函数名称,现在将其声明为函数名称加法的变量。此后,addition 和 sum 函数都有相同数量的参数声明为整数数据类型,并且还返回整数值作为引用。
    
    func sum(a: Int, b: Int) -> Int {
       return a + b
    }
    var addition: (Int, Int) -> Int = sum
    print("Result: \(addition(40, 89))")
    
    当我们使用操场运行上述程序时,我们得到以下结果 -
    
    Result: 129
    
  • 函数类型作为参数类型和返回类型

    我们还可以将函数本身作为参数类型传递给另一个函数。
    
    func sum(a: Int, b: Int) -> Int {
       return a + b
    }
    var addition: (Int, Int) -> Int = sum
    print("Result: \(addition(40, 89))")
    func another(addition: (Int, Int) -> Int, a: Int, b: Int) {
       print("Result: \(addition(a, b))")
    }
    another(sum, 10, 20)
    
    当我们使用操场运行上述程序时,我们得到以下结果 -
    
    Result: 129
    Result: 30
    
  • 嵌套函数

    嵌套函数提供了通过调用内部函数来调用外部函数的便利。
    
    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())
    
    当我们使用操场运行上述程序时,我们得到以下结果 -
    
    -30