//无参数无返回值的函数
func sayHelloWorld(){
print("hello,世界")
}
() = sayHelloWorld()//虽然函数无返回值，但是其实返回的是一个空的元组，没有任何元素,可以写为()
print("无参无返回值函数调用的结果：")
//声明一个传入固定数量参数 有单一返回值的函数
func greet(person: String,day: String) -> String{//函数名greet，参数有两个，返回String类型的值
return "Hi \(person),today is \(day)"
}
let str1 = greet(person: "萧瑟", day: "周日")
print("函数1的调用结果：\(str1)")
//参数的标签：默认情况下是参数名作为调用的标签，当然可以在参数名前自定义标签（_表示不用标签，）
func greet(_ person:String,on day:String)->String{
return "你好 \(person),今天是\(day)"
}
let str2 = greet("小三儿", on: "周六")
print("调用函数的标签写法：\(str2)")
//参数默认值：函数中参数可以给个默认值，调用时如果没有传该参数的值，就会使用默认值
func someFunc(parameterA: Int, parameterB: Int = 33) {
print("函数参数默认值的调用：\(parameterA)----\(parameterB)")
}
someFunc(parameterA: 2)//2、33
someFunc(parameterA: 3, parameterB: 4)//3、4
//一个函数返回多个值（元组的使用）
func calculateStatistics(scoreArr:[Int]) -> (min:Int, max:Int, sum:Int){
//传入分数数组，计算出最大值、最小值、总和
var min = scoreArr[0]
var max = scoreArr[0]
var sum = 0
for score in scoreArr {
if score > max {
max = score
} else if score < min {
min = score
}
sum += score
}
return (min,max,sum)
}
let statistics = calculateStatistics(scoreArr: [45,59,78,32,43,100,99,91])
print("调用返回多个值得函数结果：最小值：\(statistics.min),最大值：\(statistics.1),总和：\(statistics.sum)")
//如果调用上方函数传入了一个空数组，会报错 ======= 返回可选元组
//let statisticsNil = calculateStatistics(scoreArr: [])
func minMax(array:[Int]) -> (min: Int, max: Int)? { //返回值后面加个？,注意(Int, Int)?表示整个元组是可选的，(Int?, Int?)是元组中的元素值是可选的
if array.isEmpty {
return nil
}
var currentMin = array[0]
var currentMax = array[0]
for value in array {
if value < currentMin {
currentMin = value
}else if value > currentMax{
currentMax = value
}
}
return (currentMin,currentMax)
}
if let minMaxValue = minMax(array: []){
print("返回可选元组：\(String(describing: minMaxValue))")
}
if let minMaxValue2 = minMax(array: [3,5,2,7]){
print("返回可选元组2：\(String(describing: minMaxValue2))")
}
//一个函数传入不固定的参数(以数组形式)，返回一个值
func sumOf(numArr: Int...) -> Int{//传入不固定个参数，在参数的类型后加...
var sum = 0
for num in numArr {
sum += num
}
return sum //返回所有参数的和
}
let zeroSum = sumOf()
let threeSum = sumOf(numArr: 12,35,41)
print("传入不固定个参数的函数调用结果：\(zeroSum)---\(threeSum)")
//函数的嵌套：重构一个太长或者太复杂的函数（函数先声明 再调用）
func returnFifteen() -> Int{//无参，有返回值
var y = 10
func add(){//函数内的一个函数
y += 5
}
add()
return y
}
let fifteen = returnFifteen()//调用最外层的函数
print("函数嵌套的结果：\(fifteen)")
//函数作为一个函数的返回值
func makeOne() -> ((Int) -> Int){//参数为空，返回值是另一个函数（可以参照另一个函数的传参和返回值来写）
func addOne(number: Int) -> Int{//参数为Int型，返回值为 Int型
return 1 + number
}
return addOne
}
var oneMake = makeOne()//调用最外层函数，返回的结果oneMake是最外层函数中的返回函数
let oneValue = oneMake(7)//然后在调用最外层函数返回的函数，获取返回函数的返回值（真TM绕）
print("函数作为一个函数的返回值调用：\(oneValue)")
//函数作为一个函数的参数
func lessThanTen(num: Int) -> Bool{//传入一个参数，判断是否小于10 （定义一个作为参数的函数）
return num < 10
}
func hasAnyMatches(list:[Int], condition:(Int) -> Bool) -> Bool{//一个参数是个数组，另一个参数是一个函数，返回值是Bool型
for item in list {//遍历参数数组
if condition(item) {//如果数组中有值小于10 就返回true
return true
}
}
return false//遍历完成后，没有小于10的值，就返回false
}
let isLessTen = hasAnyMatches(list: [19,17,25,13], condition: lessThanTen)//检查list中是否有小于10的数
print("函数作为一个函数的参数调用结果：\(isLessTen)")
//输入输出参数：在函数中修改函数外的参数变量的值
func swapTwoInts(a: inout Int, inputB b: inout Int){//定义一个输入输出参数时，在参数定义前加inout关键字；输入输出参数不能有默认值，而且可变参数不能用inout标记
let tempA = a
a = b
b = tempA
//该函数主要功能是交换两个参数的值
}
var someInt = 33
var anotherInt = 95
swapTwoInts(a: &someInt, inputB: &anotherInt)//需要传入变量，而且传入的参数前要加&符号，表示可以被函数修改
print("输入输入参数在函数中被修改了：\(someInt)--\(anotherInt)") //95，33
//函数类型：函数是有类型的，例如：(Int,Int) -> Int; () -> Void 类型等
func addTwoInts(a:Int,b:Int) -> Int {
return a + b
}
var mathFunction: (Int, Int) -> Int = addTwoInts//定义了一个mathFunction的变量，类型是“一个有两个Int型的参数并返回一个Int型值的函数”，并将这个新的变量指向了 addTwoInts函数
print("函数的类型调用：\(mathFunction(2,3))")//调用函数变量并打印其值
网友评论