程序師世界是廣大編程愛好者互助、分享、學習的平台,程序師世界有你更精彩!
首頁
編程語言
C語言|JAVA編程
Python編程
網頁編程
ASP編程|PHP編程
JSP編程
數據庫知識
MYSQL數據庫|SqlServer數據庫
Oracle數據庫|DB2數據庫
 程式師世界 >> 編程語言 >> 更多編程語言 >> 更多關於編程 >> Swift說話中的函數進修教程

Swift說話中的函數進修教程

編輯:更多關於編程

Swift說話中的函數進修教程。本站提示廣大學習愛好者:(Swift說話中的函數進修教程)文章只能為提供參考,不一定能成為您想要的結果。以下是Swift說話中的函數進修教程正文


函數是一個組織在一路語句聚集,以履行特定義務。Swift 函數相似於簡略 C 函數和龐雜的 Objective C 說話函數。 它使我們可以或許經由過程函數挪用外部的部分和全局參數值。 像其他任何說話一樣 swift 函數也遵守雷同的步調。

函數聲明:它告知編譯器有關的函數的稱號,前往類型和參數。

函數界說:它供給函數的現實主體。

Swift 函數包括參數類型和前往類型。

函數界說
在Swift 說話中函數是由 “func” 症結字來界說。當一個新界說函數時,它能夠須要一個或幾個值作為函數輸出作為“參數” ,它將被處置在函數體中並傳回值作為 '前往類型' 輸入。

每一個函數都有一個函數名,它描寫了函數將履行的義務。要應用函數,須要挪用其名字函數,並經由過程它的輸出值(稱為參數)婚配函數的參數類型。函數參數也被稱為“元組”。

函數的參數必需供給與函數參數列表的次序雷同,並前往一個值在 -> 以後。

語法

Syntax:
func funcname(Parameters) -> returntype
{
   Statement1
   Statement2
    ---
   Statement N
   return parameters
}

先生們的名字被聲明為函數“student” ,函數外部聲明字符串作為前往數據類型,當挪用該函數將前往先生姓名。

func student(name: String) -> String {
   return name
}
println(student("First Program"))
println(student("About Functions"))

當我們應用 playground 運轉下面的法式,獲得以下成果

First Program
About Functions

挪用函數
斟酌上面的例子是一個用來顯示數字的“display”函數,起首用參數 “no1” 初始化且持整數數據類型。 然後參數 “no1” 被分派給參數 “a”,指向雷同的數據類型的整數。 如今參數 a 被前往給函數。這裡 display()函數將持有整數值,每挪用函數一次,前往整數值。

func display(no1: Int) -> Int {
   let a = no1
   return a
}

println(display(100))
println(display(200))

當我們應用 playground 運轉下面的法式,獲得以下成果

100
200

參數和前往值
Swift 供給了靈巧的函數參數和前往值,從簡略到龐雜的值。相似於 C 和 Objective C 函數也能夠有多種情勢

帶參數的函數
函數是經由過程其參數值傳到函數體拜訪。我們可以經由過程單一到多元的參數值作為元組傳到函數外部。

func mult(no1: Int, no2: Int) -> Int {
   return no1*no2
}
println(mult(2,20))
println(mult(3,15))
println(mult(4,30))

當我們應用 playground 運轉下面的法式,獲得以下成果:

40
45
120

不帶參數的函數
我們能夠應用包括函數不帶任何參數。

語法

func funcname() -> datatype {
   return datatype
}

以下是不帶參數函數的一個例子:

func votersname() -> String {
   return "Alice"
}
println(votersname())

當我們應用 playground 運轉下面的法式,獲得以下成果

Alice

函數帶前往值
函數也可用於前往字符串,整數和浮點數據類型值來作為前往類型。要找出數組函數 “ls” 的最年夜和最小的數,用large,small 整數數據類型聲明。

數組初始化為持有整數值。然後數組被處置並將數組中的每個值讀出並寫其先前的值比擬。當該值比前一個存儲在“small”的參數更小,不然存儲在 “large” 的參數值經由過程挪用函數前往

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([40,12,-5,78,98])
println("Largest number is: \(num.large) and smallest number is: \(num.small)")

當我們應用 playground 運轉下面的法式,獲得以下成果

Largest number is: 98 and smallest number is: -5

函數不帶前往值
某些函數能夠在函數中聲明參數,但沒有任何前往值。上面的法式聲明 a 和 b 作為參數傳遞給 sum()函數。函數外部自己的參數 a 和 b 的值是經由過程挪用所述函數經由過程挪用 sum(),其值被打印從而不消前往相干值。

func sum(a: Int, b: Int) {
   let a = a + b
   let b = a - b
   println(a, b)
}
sum(20, 10)
sum(40,10)
sum(24,6)

當我們應用 playground 運轉下面的法式,獲得以下成果

(30, 20)
(50, 40)
(30, 24)

前往 Optional  類型的函數
Swift 推出 “optional” 特征以經由過程引入一個平安對策來清除成績。 例如,斟酌我們聲明函數值前往類型為整數,但當函數前往一個字符串值或任何一個零值,會怎樣樣? 在這類情形下,編譯器會前往毛病值。 “optional” 引入以解脫這些成績。

可選(Optional )功效將采用兩種情勢 'value' 和 'nil'。我們會提到 'Optionals' 應用鍵保存字符 “?” 檢討元組能否前往一個值或零值。

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([8, -6, 2, 109, 3, 71]) {
    println("min is \(bounds.min) and max is \(bounds.max)")
}

當我們應用 playground 運轉下面的法式,獲得以下成果

min is -6 and max is 109

'Optionals'被用來檢討 'nil' 或渣滓值,從而消費年夜量的時光調試,使代碼的效力和可讀性的用戶。

函數部分VS內部參數稱號 部分參數稱號
部分參數稱號僅在函數外部拜訪。

func sample(number: Int) {
   println(number)
}

這裡 func 示例參數數目被聲明為外部變量,由於它是由函數 sample() 外部拜訪。在這裡,“number” 被聲明為部分變量,但上面的語句援用變量可以使用函數內部。

func sample(number: Int) {
   println(number)
}
sample(1)
sample(2)
sample(3)

當我們應用 playground 運轉下面的法式,獲得以下成果

1
2
3

內部參數稱號
內部參數稱號許可定名一個函數參數,使它們的目標加倍明白。 定名兩個函數的參數,然後挪用該函數以下

func pow(firstArg a: Int, secondArg b: Int) -> Int {
   var res = a
   for _ in 1..<b {
      res = res * a
   }
   println(res)
   return res
}
pow(firstArg:5, secondArg:3)

當我們應用 playground 運轉下面的法式,獲得以下成果

125

參數可變型參數
當我們想界說具有多個數目參數的函數, 那末我們可以聲明成員為 “可變參數” 的參數。參數可以被指定為可變參數由(...)的參數稱號以後。

func vari<N>(members: N...){
   for i in members {
      println(i)
   }
}
vari(4,3,5)
vari(4.5, 3.1, 5.6)
vari("Swift", "Enumerations", "Closures")

當我們應用 playground 運轉下面的法式,獲得以下成果

4
3
5
4.5
3.1
5.6
Swift
Enumerations
Closures

常量,變量和 I/O 參數
函數默許情形下,斟酌參數'常量',個中的用戶也能夠聲明參數到函數作為變量。我們曾經評論辯論過 'let' 症結字用來聲明常量參數,可變參數的界說是應用 “var” 症結字。

I/O參數在 Swift 中供給保存參數值的功效,即便其值在函數挪用修正以後。在函數參數界說“inout”症結字的開端聲明保存成員值。

它源於症結字“inout”,由於它的值傳遞 'in' 到函數而且它的值被拜訪,並它的函數體修正,函數前往到“out” 來修正本來的參數。

由於單靠它的值在外面,函數內部修正變量僅作為參數傳遞 in-out 參數。是以,沒有需要聲明字符串、文本作為 in-out 參數。 '&' 在之前變量名是指傳遞的參數。

func temp(inout a1: Int, inout b1: Int) {
   let t = a1
   a1 = b1
   b1 = t
}
var no = 2
var co = 10
temp(&no, &co)
println("Swapped values are \(no), \(co)")

當我們應用 playground 運轉下面的法式,獲得以下成果

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
}
println(inputs(20,10))
println(inputs(36,6))

當我們應用 playground 運轉下面的法式,獲得以下成果

2
6

在這裡,函數有兩個參數 no1 和 no2 作為整數數據類型被初始化,它的前往類型也被聲明為'int'

Func inputstr(name: String) -> String {
   return name
}

在這裡,函數聲明為字符串數據類型。

函數也能夠有沒有效(void)的數據類型來表現該函數將不前往任何器械。

func inputstr() {
   println("Swift Functions")
   println("Types and its Usage")
}
inputstr()

當我們應用 playground 運轉下面的法式,獲得以下成果

Swift Functions
Types and its Usage

上述函數聲明為沒有參數而且函數的前往值為 void。

應用函數類型
函數起首傳遞 整數,浮點數或字符串類型的參數,然後以下所述其被作為常數或變量傳遞到函數中。

var addition: (Int, Int) -> Int = sum

這裡 'a'和 'b' 聲明作為 sum 函數的參數變量,在函數將這兩個整數相加並前往:

func sum(a: Int, b: Int) -> Int {
   return a + b
}
var addition: (Int, Int) -> Int = sum
println("Result: \(addition(40, 89))")

當我們應用 playground 運轉下面的法式,獲得以下成果

Result: 129

函數類型作為參數類型和前往類型
我們也能夠經由過程傳遞函數自己作為參數類型給另外一個函數。

func sum(a: Int, b: Int) -> Int {
   return a + b
}
var addition: (Int, Int) -> Int = sum
println("Result: \(addition(40, 89))")
func another(addition: (Int, Int) -> Int, a: Int, b: Int) {
   println("Result: \(addition(a, b))")
}
another(sum, 10, 20)

當我們應用 playground 運轉下面的法式,獲得以下成果

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)
println(decrem())

當我們應用 playground 運轉下面的法式,獲得以下成果:

-30

函數參數傳遞
函數的語法格局以下:
func 函數名(參數列表) -> 前往值類型 {
    語句組
    return 前往值
}
症結字是func。
多個參數列表之間可以用逗號(,)分隔,也能夠沒有參數。
應用箭頭“->”指導前往值類型。前往值有單個值和多個值。假如函數沒有前往值,則“-> 前往值類型”部門可以省略。
假如函數有前往值,就須要在函數體最初應用return語句;假如沒有前往值,則函數體中可以省略return語句。
函數界說示例代碼以下:

funcrectangleArea(width:Double, height:Double) -> Double {
    let area = width * height
    return area  
}
print("320x480的長方形的面積:\(rectangleArea(320, height:480))")

傳遞參數
引見幾種分歧情勢的參數。
應用內部參數名
為每一個參數供給一個可以在函數內部應用的稱號,稱為內部參數名,修正rectangleArea函數的界說以下:

func rectangleArea(Wwidth:Double, H height:Double) -> Double {
    let area = width * height
    return area
}

在部分參數名之前給一個“內部參數名”,用空格分隔。界說代碼中的W和H就是內部參數名。挪用代碼以下:
print("320x480的長方形的面積:\(rectangleArea(W:320, H:480))")
假如我們供給了內部參數名,那末在函數挪用時,必需應用內部參數名,所以W和H不克不及省略。

省略內部參數名
Swift 2.0供給省略內部參數名能夠,在界說函數時,應用下劃線(_)表現內部參數名,示例代碼以下:

funcrectangleArea(width:Double, _ height:Double) -> Double {
    let area = width * height
    return area
}

如許函數在挪用時便可以省略內部參數名,代碼以下:
print("320x480的長方形的面積:\(rectangleArea(320, 480))")
在界說函數時第一個參數不須要應用下劃線(_),默許第一個參數名是省略的,其他參數名要想省略則須要應用下劃線(_)符號。
 
參數默許值
在界說函數的時刻可認為參數設置一個默許值,當挪用函數的時刻可以疏忽該參數。看上面的一個示例:

func makecoffee(type :String = "卡布奇諾") -> String {
    return "制造一杯\(type)咖啡。"
}

在挪用的時刻,假如挪用者沒有傳遞參數,則應用默許值。挪用代碼以下:
let coffee1 = makecoffee("拿鐵")
let coffee2 = makecoffee() 
最初輸入成果以下:

制造一杯拿鐵咖啡。
制造一杯卡布奇諾咖啡。

 

可變參數
Swift中函數的參數個數可以變更,它可以接收不肯定數目的輸出類型參數,它們具有雷同的類型。我們可以經由過程在參數類型名前面參加(...)的方法來指導這是可變參數。
上面看一個示例:

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

上面是兩次挪用sum函數代碼:

sum(100.0, 20, 30)
sum(30, 80)

可以看到每次傳遞參數的個數是分歧的。

  1. 上一頁:
  2. 下一頁:
Copyright © 程式師世界 All Rights Reserved