函数定义
/*
* 函数(参数默认为常量，在函数体不能被修改。函数是引用类型，后面会提到)
*/
func <#name#>(<#parameters#>) -> <#return type#> {
<#function body#>
}
/**
* 例子(有返回值，有参数函数)
*/
func greetPerson(person: String) -> String {
return "Hello, " + person + "!"
}
print(greetPerson(person: "bluajack"))
// 打印 "Hello, bluajack!"
func greetAgain(person: String) -> String {
return "Hello again, " + person + "!"
}
print(greetAgain(person: "bluajack"))
// 打印 "Hello again, bluajack!"
无参数函数
/**
* 无参数函数,下面()为空
*/
func sayHelloWorld() -> String {
return "hello, world"
}
print(sayHelloWorld())
// 打印 "hello, world"
多参数函数
/**
* 多参数函数，参数1 (person:String) 参数2（alreadyGreeted:Bool）
*/
func greet(person:String, alreadyGreeted:Bool) -> String {
if alreadyGreeted {
return greetAgain(person: person)
}else{
return greetPerson(person: person)
}
}
print(greet(person: "girl", alreadyGreeted: false))
// 打印 "Hello, girl!"
print(greet(person: "bluajack", alreadyGreeted: true))
// 打印 "Hello again, bluajack!"
无返回值函数
/**
* 无返回值函数
*/
func greet(person:String) {
print("Hello, \(person)!")
}
greet(person: "约吗？")
// 打印 Hello, 约吗？!
//严格上来说，虽然没有返回值被定义，greet(person:) 函数依然返回了值。没有定义返回类型的函数会返回一个特殊的Void值。它其实是一个空的元组（tuple），没有任何元素，可以写成()。
多重返回值函数
/**
* 多重返回值函数
* 用元组（tuple）类型让多个值作为一个复合值从函数中返回。
*/
func getMinMax(array: [Int]) -> (min: Int, max: Int) {
var min = array[0]
var max = array[0]
for value in array[1..<array.count] {
if value < min {
min = value
} else if value > max {
max = value
}
}
return (min, max)
}
let myArray = getMinMax(array: [12,25,-4,69,88,250])
print("min is \(myArray.min) and max is \(myArray.max)")
//打印 "min is -4 and max is 250"
可选元组返回类型函数
/*
* 基于上面函数的完善(存在传入数组为空的情况)
* 可选元组返回类型函数
*/
func MinMax(array: [Int]) -> (min: Int, max: Int)? {
if array.isEmpty { return nil }
var min = array[0]
var max = array[0]
for value in array[1..<array.count] {
if value < min {
min = value
} else if value > max {
max = value
}
}
return (min, max)
}
//这里注意了 ??为空合运算符，用来判断可选类型，前提是左右两边类型相等
let myArray2 = MinMax(array: []) ?? (0,0)
print(myArray2.min,myArray2.max)
//打印 "0 0"
//可选元组类型如 (Int, Int)? 与元组包含可选类型如 (Int?, Int?) 是不同的.可选的元组类型，整个元组是可选的，而不只是元组中的每个元素值
函数参数标签和参数名称
/**
* 函数参数标签和参数名称
在参数名称前指定参数标签，中间用逗号隔开。函数标签能够使你的代码更具可读性
func testFunction(参数标签 参数名称:类型) -> <#return type#> {
<#function body#>
}
*/
//例子_指定参数标签(不指定参数标签时，默认，函数参数使用参数名称来作为它们的参数标签)
func greet(person: String, from hometown: String) -> String {
return "Hello \(person)! Glad you could visit from \(hometown)."
}
print(greet(person: "bluajack", from: "jingzhou"))
// 打印 "Hello bluajack! Glad you could visit from jingzhou."
//例子_忽略参数标签(如果你不希望为某个参数添加一个标签，可以使用一个下划线(_)来代替一个明确的参数标签)
func someFunction(_ firstParameterName: Int, secondParameterName: Int) {
// 在函数体内，firstParameterName 和 secondParameterName 代表参数中的第一个和第二个参数值
}
someFunction(1, secondParameterName: 2)//如果一个参数有一个标签，那么在调用的时候必须使用标签来标记这个参数
设定默认参数值
/**
* 设定默认参数值(当给参数设定默认值后，调用这个函数可以忽略这个参数，当然你不忽略，那就用你给的值好了啰)
*/
func someFunction(parameterWithoutDefault: Int, parameterWithDefault: Int = 12) {
// 如果你在调用时候不传第二个参数，parameterWithDefault 会值为 12 传入到函数体中。
}
someFunction(parameterWithoutDefault: 3, parameterWithDefault: 6) // parameterWithDefault = 6
someFunction(parameterWithoutDefault: 4) // parameterWithDefault = 12
/**
* 可变参数(方法：在变量类型后面加入(...)的方式定义可变参数)。可变参数的实参在函数体中变为此类型的一个数组
*/
func calAverage(_ numbers: Double...) -> Double {
var total: Double = 0
for number in numbers {
total += number
}
return total / Double(numbers.count)
}
calAverage(1, 2, 3, 4, 5)
// 返回 3.0, 是这 5 个数的平均数。
calAverage(3, 8.25, 18.75)
// 返回 10.0, 是这 3 个数的平均数。
输入输出参数
/**
* 输入输出参数
* 开头提到函数参数默认是常量。如果你想要一个函数可以修改参数的值，并且想要在这些修改在函数调用结束后仍然存在，那么就应该把这个参数定义为输入输出参数
* 定义一个输入输出参数时，在参数定义前加 inout 关键字。只能传递变量给输入输出参数。不能传入常量或者字面量，因为这些量是不能被修改的。当传入的参数作为输入输出参数时，需要在参数名前加 & 符，表示这个值可以被函数修改
* 我感觉这里有点类似于C语言中的函数中的指针参数，传入地址，改变对应地址内存放的变量。
*/
//take care : 输入输出参数不能有默认值，而且可变参数不能用 inout 标记
//例子
func swapTwoInts(_ a: inout Int, _ b: inout Int) {
let temporaryA = a
a = b
b = temporaryA
}
var someInt = 3
var anotherInt = 107
swapTwoInts(&someInt, &anotherInt)
print("someInt is now \(someInt), and anotherInt is now \(anotherInt)")
// 打印 "someInt is now 107, and anotherInt is now 3"
函数类型
/**
* 函数类型('函数的类型' 由函数的 '参数类型' 和 '返回类型' 组成)
*/
//例子
func addTwoInts(_ a: Int, _ b: Int) -> Int {
return a + b
}
func multiplyTwoInts(_ a: Int, _ b: Int) -> Int {
return a * b
}
//这两个函数的类型是 (Int, Int) -> Int，就是说“这个函数类型有两个 Int 型的参数并返回一个 Int 型的值。”
func printHelloWorld() {
print("hello, world")
}
//这个函数的类型是：() -> Void，或者叫“没有参数，并返回 Void 类型的函数”
使用函数类型
/**
* 使用函数类型
*/
//定义---(”定义一个叫做 mathFunction 的变量，类型是‘一个有两个 Int 型的参数并返回一个 Int 型的值的函数’，并让这个新变量指向 addTwoInts 函数”)
//这里的意思就是，函数tm也可以被引用。函数属于引用类型
var mathFunction: (Int, Int) -> Int = addTwoInts
print("Result: \(mathFunction(2, 3))")
// Prints "Result: 5"
mathFunction = multiplyTwoInts
print("Result: \(mathFunction(2, 3))")
// Prints "Result: 6"
函数类型作为参数使用
/**
* 函数类型作为参数类型使用(用 (Int, Int) -> Int 这样的函数类型作为另一个函数的参数类型)
*/ // 参数名称 （参数类型，也就是函数类型）
func printMathResult(_ mathFunction: (Int, Int) -> Int, _ a: Int, _ b: Int) {
print("Result: \(mathFunction(a, b))")
}
printMathResult(addTwoInts, 3, 5)
// 打印 "Result: 8"
函数类型作为返回类型使用
/**
* 函数类型作为返回类型
*/
//先定义两个简单函数((Int) -> Int)
func stepForward(_ input: Int) -> Int {
return input + 1
}
func stepBackward(_ input: Int) -> Int {
return input - 1
}
//本节例子------------------------------(下面就是把函数类型作为返回类型)
func chooseStepFunction(backward: Bool) -> (Int) -> Int {
return backward ? stepBackward : stepForward
}
//简单来说，就是通过你传入的bool值判断返回哪个函数
var currentValue = 3
let moveNearerToZero = chooseStepFunction(backward: currentValue > 0)
// moveNearerToZero 现在指向 stepBackward() 函数。
嵌套函数
/**
* 函数嵌套函数(OC中方法中嵌套方法,当然这里是不一样的!)
* 被嵌套的函数对外界是不可见的，意思就是前面我的那些例子都是全局的函数，下面这个被嵌套的函数变成局部的啦！
* 如何在外界使用内部的嵌套函数呢？？？
* 当然是看下面例子吧。
*/
func chooseFunction(backward: Bool) -> (Int) -> Int {
func stepForward(input: Int) -> Int { return input + 1 }
func stepBackward(input: Int) -> Int { return input - 1 }
return backward ? stepBackward : stepForward
}
var value = -4
let choosedFunc = chooseFunction(backward: value > 0)
//这里定义常量引用作为返回值的被嵌套的函数,后面的操作，就不赘述了！
