函數

/*

函數分為函數名，參數，返回值，執行代碼塊四部分

有返回值函數可以作為一個值直接在print里輸出?

*/

?

//函數定義

func max(a:Int, b:Int, c:Int) -> Int

{

? ? return 1

}

max(1, b: 2, c: 3)

?

func firstMethod(str:String) ->String

{

? ? return "123"

}

print(firstMethod("123"))

?

?

//沒有返回值的函數

func noReturn(str:String)

{

? ? print("no return")

}

?

?

//多個返回值的函數

func mutableReturn(str:String) ->(String, String)

{

? ? return ("1", "2")

}

?

func mutableReturnWithName() ->(height:Int, weight:Int)

{

? ? return (1, 2)

}

var man = mutableReturnWithName()

print(man.height)

?

//函數調用本身? 也就是遞歸

func doAgain(num:Int) -> String

{

? ? if num > 5{

? ? ? ? print("000")

? ? ? ? return "\(doAgain(num - 1))"

? ? }else{

? ? ? ? return "fff"

? ? }

}

print(doAgain(10))

/*

遞歸是非常有用的，例如程序希望遍歷某個路徑下的所有文件，但這個路徑下的文件夾的深度是未知的，那就可以使用遞歸來實現這個需求。系統可以設定一個函數，改函數接受一個文件路徑作為參數，該參數可遍歷出當前路徑下的所有文件和文件路徑--該函數再次調用函數本身來處理該路徑下的所有文件路徑

*/

?

?

/*

函數的參數

第一個參數如果不寫外部參數，是不會顯示外部參數的，第二個和之后的參數如果不寫外部參數，會自動默認外部參數和內部參數同名

也就是說，除了第一個參數，其他的參數就算不設置外部參數也會有外部參數

?

*/

//擁有外部參數名的函數

func haveWaiName(wainame neiname:String) ->String

{

? ? print(neiname)

? ? return "\(neiname)"

}

print(haveWaiName(wainame: "name"))

?

//外部形參名和內部形參名一樣的函數

func havesameName(name name:String) ->String

{

? ? return name

}

print(havesameName(name: "sarah"))

?

//只有一部分形參有外部形參名的函數

func justSomehavename(name name:String, years:Int) -> (String, Int)

{

? ? return (name, years)

}

print(justSomehavename(name: "marry", years: 10).0)

?

//形參有默認值的函數 一般將帶有默認值的形參放在最后面，下面這個并不是一個好的編程習慣

func valueAlready(user name:String = "marry", msg:String)

{

? ? print("\(name),\(msg)")

}

valueAlready(msg: "hi")

valueAlready(user: "tom", msg: "hi")

?

//參數個數可變的函數

func varibleValue(a:Int, books:String..., name:String)

{

? ? for tmp in books

? ? {

? ? ? ? print(tmp)

? ? }

}

varibleValue(3, books: "java","swift", name: "string")

/*

數量可變的參數的本質是一個數組參數，在執行代碼塊中當做一個數組來使用

*/

?

?

/*

函數中的形參默認是常量，如果想要變量的形參，需要自己聲明

*/

func mutableNum(var name:String) ->String

{

? ? name = name + "sss"

? ? return name

}

print(mutableNum("mother"))

?

?

/*

在函數中，傳入的參數如果是值類型，則傳進去的是該值的副本，在函數中不會對原來的值產生影響

如果想要在函數中對該值進行改變，可以使用inout標簽來標注

*/

func inoutFunc(inout age:Int) ->Int

{

? ? age = age + 1

? ? return age

}

var age = 5

print(age)//5

print(inoutFunc(&age))//6

print(age)//6

/*

當參數是引用類型的時候，程序會賦值引用的副本，不會復制該引用指向的對象

所以，當參數是引用類型的時候，即使不適用inout標簽，該值仍然會在函數中被修改

但是，如果在函數中將引用類型置為空，只會切斷副本和指向對象之間的聯系，在函數之外，該值仍然不為空

*/

class DataWrap

{

? ? var a:Int = 0

? ? var b:Int = 0

}

func swap(var dw:DataWrap!)

{

? ? var tmp = dw.a

? ? dw.a = dw.b

? ? dw.b = tmp

? ? tmp = 0

? ? dw = nil

}

var wp:DataWrap! = DataWrap()

print(wp)

swap(wp)

print(wp)//wp沒有被置為空，但是如果使用了inout標簽，這里就會出錯

?

?

?

//定義一個函數變量

var myfun : (Int, Int) ->Int //這里最好不要給參數命名，雖然也可以命名，但是在使用的時候系統不會提示

var test : (String) ->Void

func pow(base base:Int, exponent:Int) ->Int

{

? ? var result = 1

? ? for _ in 1...exponent

? ? {

? ? ? ? result *= base

? ? }

? ? return result

}

//將pow函數賦值給mufun，則myfun可以當成pow使用

myfun = pow

print(myfun(3,4))

/*

只要被賦值的函數類型與myfun的變量類型一致，程序就可以賦值成功

通過使用函數類型的變量，可以讓myfun在不同的時間指向不同的函數，從而讓程序更加靈活。

*/

?

?

//其中一個參數是函數的函數

func map(var data data:[Int],fn:(Int) ->Int) ->[Int]

{

? ? for var i = 0, len = data.count; i<len ;i++

? ? {

? ? ? ? data[i] = fn(data[i])

? ? }

? ? return data

}

func square(val:Int) ->Int

{

? ? return val*val

}

func cube(val:Int) ->Int

{

? ? return val*val*val

}

var data = [1,2,3]

print(map(data: data, fn: square))

print(map(data: data, fn: cube))

//這種方式可以動態的改變一個函數中的部分代碼塊，類似于c中的函數指針

?

?

//返回值為函數的函數

func getMathFunc(type type:String) -> (Int) ->Int

{

? ? switch(type)

? ? {

? ? case "square":

? ? ? ? return square

? ? default:

? ? ? ? return cube

? ? }

}

var mathFunc = getMathFunc(type: "cube")

print(mathFunc(5))

?

/*

函數重載

函數名相同，但是參數個數不同或外部參數名稱不同或返回值不同

這種情況就是重載

*/

?

?

/*

嵌套函數

在swift中，函數和類享有同樣的級別，函數可以直接聲明在文件里，而不用單獨聲明在一個類里

所以，函數可以當成變量被引用，被返回，在函數中聲明函數

*/

func getMathFunc2(type type:String) ->(Int) ->Int

{

? ? func square(val: Int) ->Int

? ? {

? ? ? ? return val*val

? ? }

? ? func cube(val:Int) ->Int

? ? {

? ? ? ? return val*val*val

? ? }

? ? switch(type)

? ? {

? ? case "square":

? ? ? ? return square

? ? default:

? ? ? ? return cube

? ? }

}

?

?

?

閉包

//本質是功能更靈活的代碼塊，可以直接作為返回值被返回

//在閉包里不要給參數寫外部參數名，因為Xcode不會提示，還要自己寫，很麻煩

var square3 = {

? ? (val:Int) -> Int in

? ? return val*val

}

print(square3(5))

?

//在閉包的后面添加圓括號來調用閉包

var resultt2 = {

? ? (base:Int,exponent:Int) -> Int in

? ? var result = 1

? ? for _ in 1...exponent

? ? {

? ? ? ? result *= base

? ? }

? ? return result

}(3, 4)

?

print(resultt2)

?

//省略形參類型，返回值類型的閉包

var square4:(Int) ->Int = {(val) in return val*val}

//省略了參數類型，參數列表的那個圓括號也可以省略

var square6:(Int) ->Int = {val in return val*val}

print(square6(5))

var result3:Int = {base, exponent in

? ? var result = 1

? ? for _ in 1...exponent

? ? {

? ? ? ? result *= base

? ? }

? ? return result

}(4, 3)//因為這個地方有聲明int類型的變量，所以不用指定返回值類型

//上面兩個閉包因為有聲明閉包類型變量，所以也可以不聲明返回值

?

//省略return

//如果閉包表達式的執行體只有一行代碼，而且這行代碼的返回值將作為閉包表達式的返回值，那么swift允許省略return關鍵字

var square7:(Int) ->Int = {val in val*val}

var square8 = {(val:Int) -> Int in val*val*val}

print(square7(3))

print(square8(3))

?

//省略形參名

var square9:(Int) ->Int = {$0 * $0}

var result4:Int = {

? ? var result = 1

? ? for _ in 1...$0

? ? {

? ? ? ? result *= $1

? ? }

? ? return result

}(3, 4)

?

//尾隨閉包

//當函數的最后一個參數是一個函數類型的時候，可以用閉包來進行傳參，然后把小括號放在閉包前面，把閉包給單獨放置在外面

func map2(var data data:[Int], fn:(Int) -> Int) -> [Int]

{

? ? for var i = 0, len = data.count; i<len; i++

? ? {

? ? ? ? data[i] = fn(data[i])

? ? }

? ? return data

}

var data2 = [3, 4, 5, 6, 7]

print("原數據\(data2)")//"原數據[3, 4, 5, 6, 7]\n"

var rvt1 = map2(data: data2){$0 * $0}

var rvt3 = map2(data: data2){

? ? var result = 1

? ? for index in 2...$0

? ? {

? ? ? ? result *= index

? ? }

? ? return result

}

//如果調用函數時只需要閉包表達式一個參數，那么使用尾隨閉包時，swift甚至允許程序省略調用函數的圓括號

?

//閉包可以捕獲上下文中的變量和常量

//每個閉包都會持有一個它所捕獲的變量的副本，所以，閉包執行與原來所在的函數并沒有聯系

//閉包是引用類型，所以即使是聲明成常量也可以改變內部值

func makeArray(ele:String) -> () ->[String]

{

? ? var arr:[String] = []

? ? func addElement() ->[String]

? ? {

? ? ? ? arr.append(ele)

? ? ? ? return arr

? ? }

? ? return addElement

}

let add1 = makeArray("sun")

print(add1())

print(add1())

let add2 = makeArray("zhu")

print(add2())

print(add2())

轉載于:https://www.cnblogs.com/chebaodaren/p/5501563.html

總結

以上是生活随笔為你收集整理的Swift -- 6.函数和闭包的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。