Swift.png
函數的簡單說明
- 函數是一段完成特定任務的獨立代碼片段。
- 在定義一個函數時，有多個或者一個數據類型的值，作為函數的輸入，成為參數
- 在一定某個類型的值作為返回值的時候，成為返回類型
- 以
func作為前綴，指定函數的返回類型時，用返回箭頭->后跟返回類型的名稱的方式表示
//表示如下:
func 函數名(參數1:參數類型，參數2:參數類型，參數3:參數類型...) -> 返回值類型 {
代碼塊
return 返回值
}
注意: 函數的參數默認是
let類型，不可以修改的，如果想要修改，必須使用inout關鍵字 就是后面說的引用類型指針傳遞
函數參數與返回值
- 無參數無返回值的函數
func hanshu() -> Void {
print("沒有參數，沒有返回值");
}
hanshu();
//打印結果: 沒有參數，沒有返回值
//簡寫的 沒有返回值的話 直接簡寫
func hanshu(){
print("沒有參數，沒有返回值");
}
hanshu();
//注意：嚴格上來說，雖然沒有返回值被定義，hanshu() 函數依然返回了值。沒有定義返回類型的函數會返回一 個特殊的 Void 值。它其實是一個空的元組(tuple)，沒有任何元素，可以寫成()。
- 無參數有返回值的函數
func sayHello() ->String {
return "hello 你好";
}
let hello = sayHello();
print(hello);
//打印結果: hello 你好
- 有參數 沒有返回值
//name:參數名 String:參數類型
func personName(name:String) {
print("我是\(name),哈哈");
}
personName(name: "CC");
//打印結果：我是CC,哈哈
- 有參數 有返回值，多個參數用 ， 分開
func sum(num1:Int,num2:Int,num3:Int) -> Int {
return num1+num2 + num3;
}
let numSum = sum(num1: 10, num2: 20, num3: 30);
print(numSum);
//打印結果：60
- 返回一組數據的函數 多重返回值函數
//元祖 是保存一組數據的，這個函數 返回值是一個 元祖
func tulpNum(PersonName:String,PersonAge:Int,PersonSex:String) -> (name:String,age:Int,sex:String){
return (PersonName,PersonAge,PersonSex);
}
let tulp = tulpNum(PersonName: "CC", PersonAge: 20, PersonSex: "男");
tulp.name;
//打印是 “CC
//參數是數組 返回是元祖
func minMax(array: [Int]) -> (min: Int, max: Int) {
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)
}
let arrayTulp = minMax(array: [1,2,3,10,5,9]);
print(arrayTulp.min);
print(arrayTulp.max);
//打印結果是 ： min是:1
max是：10
函數參數標簽和參數名稱
- 指定
參數標簽- 可以在函數名稱前指定它的
參數標簽，中間以空格分隔
- 可以在函數名稱前指定它的
func someFunction(argumentLabel parameterName: Int) {
// 在函數體內， parameterName 代表參數值
}
// from 參數標簽
func greet(person: String, from hometown: String) -> String {
return "Hello \(person)! Glad you could visit from \(hometown)."
}
print(greet(person: "Bill", from: "Cupertino"))
// 打印 "Hello Bill! Glad you could visit from Cupertino."
- 忽略參數標簽
- 不希望為某個參數添加一個標簽，可以使用一個
下劃線( _ )來代替一個明確的參數標簽。
- 不希望為某個參數添加一個標簽，可以使用一個
func someFunction(_ firstParameterName: Int, secondParameterName: Int) {
// 在函數體內，firstParameterName 和 secondParameterName 代表參數中的第一個和第二個參數值
}
someFunction(1, secondParameterName: 2)
- 默認參數
- 某些情況,如果沒有傳入具體的參數,可以
使用默認參數
- 某些情況,如果沒有傳入具體的參數,可以
func makecoffee(type :String = "卡布奇諾") -> String {
return "制作一杯\(type)咖啡。"
}
let coffee1 = makecoffee("拿鐵")
// "制作一杯拿鐵咖啡。"
let coffee2 = makecoffee()
// 打印："制作一杯卡布奇諾咖啡。
- 可變參數
- swift中函數的參數
個數可以變化，它可以接受不確定數量的輸入類型參數 - 它們必須具有相同的類型
- 我們可以通過在參數類型名后面加入（
...）的方式來指示這是可變參數
- swift中函數的參數
注意:一個函數，
最多只能有一個可變參數，緊跟在可變參數后面的參數不能省略參數標簽
func sum(numbers:Double...) -> Double {
var total: Double = 0
for number in numbers {
total += number
}
return total
}
sum(100.0, 20, 30)
sum(30, 80)
//注意： 一個函數最多只能擁有一個可變參數。
- 引用類型(指針的傳遞)
- 默認情況下,函數的參數是值傳遞.如果想改變外面的變量,則需要傳遞變量的地址
- 必須是變量,因為需要在內部改變其值
- Swift提供的
inout關鍵字就可以實現
// 函數一:值傳遞
func swap(var a : Int, var b : Int) {
let temp = a;
a = b;
b = temp
print("a:\(a), b:\(b)")
}
var a = 10
var b = 20
swap(a, b: b)
print("a:\(a), b:\(b)")
// 函數二:指針的傳遞
func swap1(a:inout Int, inout b : Int) {
let temp = a
a = b
b = temp
print("a:\(a), b:\(b)")
}
swap1(&a, b: &b)
print("a:\(a), b:\(b)")
函數的類型
// 函數類型 (Int, Int, Int) -> Int
//函數類型： 參數類型 和返回值類型 組成
func sum(num1:Int,num2:Int,num3:Int) -> Int {
return num1+num2 + num3;
}
//函數類型作為參數
func exen(n1:Int,n2:Int,n3:Int,fun:(Int,Int,Int) -> Int) -> Void{
let result = fun(n1,n2,n3);
print(result);
}
exen(n1: 10, n2: 10, n3:30,fun: sum);
//函數類型作為返回值
func getFunc() -> (Int,Int,Int) -> Int{
return sum;
}
let value1 = getFunc();
value1(20,30,20);
//打印： 70
//函數類型 作為 類的屬性
//編輯器根據
1.函數的名稱分別函數
2.根據外部參數名稱 分別函數
3.根據 參數類型 + 返回值類型 = 函數類型 來區別
函數重載
- 函數名相同
- 參數個數不同 || 參數不同 || 參數標簽不同
//函數名相同 參數標簽不同
func f1(v1:Int,v2:Int){
print(v1 + v2);
}
func f1(v3:Int,v4:Int){
print(v3 + v4);
}
內聯函數
- 內聯函數:
在函數調用的時候， 把其展開成函數體，直接執行 - 以下函數是不會內聯的
- 函數體過長
- 包含遞歸函數
- 包含動態派發
在Swift中的項目中，如果在打包函數或者調試中使用
Release模式,
image.png
image.png
