1、什么是函数？
函数在数学上的定义：给定一个数集A,对A施加对应法则f,记作f（A）,得到另一数集B,也就是B=f（A）.那么这个关系式就叫函数关系式,简称函数。
2、函数的定义
函数过程中的这些语句用于完成某些有意义的工作——通常是处理文本，控制输入或计算数值。通过在程序代码中引入函数名称和所需的参数，可在该程序中执行（或称调用）该函数。
3、常见函数举例
1》常见函数
/**
简单的函数
*/
func printValue(){
print("printValue is Start")
}
/* 调用 */
printValue()
/**
输出： getValue is Start
*/
2》带有返回值的函数
/**
带有返回值的函数
函数可以向调用它的代码返回一个值。在定义函数的时候，必须必须使用箭头符号(->) 指明返回值类型。
*/
func getValue() -> Int {
return 250
}
/* 调用 */
let value = getValue()
print(value)
/* 输出：250 */
3》带参数的函数
/**
带参数的函数
注意： 带参数的函数定义时，必须要定义这些参数的类型
*/
func sum(value:Int ,value1: Int)->Int{
return value + value1
}
/* 调用 */
let sumValue = sum(value: 110, value1: 110)
print(sumValue)
/* 输出： 220 */
4》返回多值的函数
/**
返回多值的函数
注释： 函数返回一个值的情况，我们已经了解。但也可以通过元组的形式，让函数一次返回多个值。另外可以在元组中添加标志，一遍获取其值
*/
func getValues(name:String,age:Int)->(address:String,class:String){
let addressString = name + "is address "
let classString = String(age) + "is class"
return (addressString,classString)
}
/* 调用 */
let tuples = getValues(name: "小郑", age: 10)
print(tuples)
/*输出：(address: "小郑is address ", class: "10is class") */
/**
可以通过下标或者标签来访问数值
*/
let value1 = getValues(name: "小郑", age: 10).1
let value2 = getValues(name: "小郑", age: 10).address
print(value1 + value2)
/*输出： 10is class小郑is address */
5》带有指定名字的函数
/**
带指定名字参数的函数
注释：在定义函数的时候，可以为参数指定名字，在使用的时候，可以了解其意思
*/
func getUserInfo(Username nameString:String , UserAge ageInt:Int){
print(nameString + "is" + String(ageInt) + "岁")
}
/* 调用 */
getUserInfo(Username: "小郑", UserAge: 250)
/* 输出：小郑is250岁 */
6》带有默认值的函数
/**
带有默认值的函数
注释： 调用这写函数的时候可以省略特定的参数
*/
func getArea(weight:Float,height:Float = 100.0){
print("面积:"+String(weight * height))
}
/* 调用 */
getArea(weight: 0.25)
/* 输出：面积:25.0 */
7》参数可变的函数
/**
参数可变的函数
注释： 一个取值数目可变的参数成为可变参数。为此可以使用三个句点（...） 表示一个参数的取值是可变的。在函数的主体内部，可变参数变成一个数组。
警告： 在使用可变参数时，可以有任意多个非可变参数。但是，只有列表中的最后一个参数可以是可变参数。
*/
func AbleParamsFunc(numbers:Int ...)->Int{
/* 其中 numbers 是一个数组*/
var sum = 0
for temp in numbers {
sum += temp
}
return sum
}
/* 调用*/
let sumValueAll = AbleParamsFunc(numbers: 1,2,3,4,5,6,7,8,9)
print(sumValueAll)
/* 输出：45 */
8》inout 关键字的函数
/**
inout 关键字
注释： inout 定义一个参数，那么就可以在函数内部改变这个参数的值。
*/
func swapValue( firstV:inout Int , secondV:inout Int){
let temp = firstV
firstV = secondV
secondV = temp
}
var swapV = 110
var swapV1 = 120
/* 调用 */
swapValue(firstV: &swapV, secondV: &swapV1)
print("swapV:",swapV,"swapV1:",swapV1)
/* 输出： swapV: 120 swapV1: 110 */
9》函数变量
/**
函数变量
注释：函数可以存储在变量中，为此，首先声明一个变量，它能够存储一个接受特定参数，返回一个值的函数。声明后，只要一个函数的参数与返回值类型都与声明中的函数相同，就可以将它存储在这个变量中。
*/
/* 定义一个函数变量*/
var funcParam:(Int,Int)->Int;
/*funcParam 就可以存储任何接受两个Int,并返回Int的函数 */
// 第一种写法：funcParam = sum 第二种写法：funcParam = sum(value:value1:)
funcParam = sum(value:value1:)
/* 调用*/
let sumValueParam = funcParam(110,110)
print(sumValueParam)
/* 输出：220 */
10》函数作为函数的参数
/**
函数作为函数的参数
注释：函数可以接受其他函数作为自己的参数，这就意味着函数可以合并。
*/
func funcSum(aNumber:Int)->Int{
return aNumber * 3
}
func funcSums(aNumber:Int,aNumberFunc:(Int)->Int)->Int{
/**
aNumberFunc:(Int)->Int 就是一个参数
*/
return aNumberFunc(aNumber)
}
/* 调用 */
/* 从传入的参数来看，这就是将函数作为参数传递进去*/
let aNumberV = funcSums(aNumber: 3, aNumberFunc: funcSum(aNumber:))
print(aNumberV)
11》函数作为返回函数
/**
函数返回函数
注释：函数可以返回函数，这就可以使用函数创建函数
*/
func createFunc(aNumber:Int)->(Int)->Int{
func adder(aNum:Int)->Int{
return aNum * aNumber
}
return adder(aNum:)
// return adder
}
/* 调用 */
let adderFunc = createFunc(aNumber: 3)
let adderV = adderFunc(4)
print(adderV)
12》生成器函数
funcmakeFunc(aNumber:Int)->()->Int{①
vartemp =0②
funcsumFunc()->Int{③
temp += aNumber④
returntemp
}
returnsumFunc⑤
}
letaNumberValue = makeFunc(aNumber:10)⑥
letnumberV = aNumberValue()⑦
print(numberV)
letnumberV1 = aNumberValue()
print(numberV1)
letaNumberValue1 = makeFunc(aNumber:15)⑧
letnumberV2 = aNumberValue1()⑨
print(numberV2)
注释：
①makeFunc函数接受一个Int参数，并返回一个函数，此函数没有参数，返回一个Int
② 在函数内部创建一个temp变量，并赋值为0
③在函数内部创建一个sumFunc的函数，没有参数，但有返回值
④ 在这个新函数的内部，aNumber作为参数，将其添加到temp,并返回temp变量
⑤ 返回sunFunc函数
⑥ 是用makeFunc创建一个递增函数，初始值为10
⑦ 每次调用makeFunc函数，它的返回值就比上一次调用增加10。因为makeFunc捕获了变量temp,每次调用它的时候就会增大。
⑧temp变量，并没有在各个函数间共享，在创建一个新的递增函数，它就会拥有新的变量
⑨第二个函数递增15
