0.3 函数
//---------------- 0.3 函数 ---------------
import UIKit
1.Swift 函数基本格式 func 名称 (参数名:参数类型,参数名:参数类型)->返回值
func greet(_ person: String, day: String) -> String {
return "Hello \(person), today is \(day)."
}
var str = greet( "Bob", day: "Tuesday") //调用函数
print(str)
2.Swift默认函数参数名为参数的标签。在参数名称之前可以自定义参数标签，或者 **在参数名前面写 _ 就可以不使用参数标签。**
func greet(_ person: String, on day: String) -> String {
return "Hello \(person), today is \(day)."
}
greet("John", on: "Wednesday")//可以看到 person 前面有 _ 所以在调用的时候 person 可以省略
3.使用元组创建一个复合值，例如，从函数返回多个值。元组的元素可以通过名称或数字来引用。
//eg: 找出数组中中的最大最小值,求和
func calculateStatistics(scores:[Int]) -> (min:Int,max:Int,sum:Int){
var min = scores[0]
var max = scores[0]
var sum = 0
for score in scores {
if score > max {
max = score
}else{
min = score
}
sum += score
}
return (min,max,sum)
}
let statistics = calculateStatistics(scores: [5, 3, 100, 3, 9])//statistics即为元组
print("min = \(statistics.min), max = \(statistics.max), sum = \(statistics.sum)")//包装成字符串形式后用\()输出值(😌)
//关于元组小 eg
let st = (frist:123,1234,1234)
print("frist == \(st.frist) ,\(st.1),\(st.2)")
//函数可以嵌套。嵌套函数可以访问在外部函数中声明的变量。
func returnFifteen() -> Int {
var y = 10
func add()-> (Int,Int) {
y += 5
return (y,2)
}
return add().0
}
print(returnFifteen())
4.函数可以返回另一个函数作为返回值进行传递
func makeIncrementer() -> ((Int) -> Int) {//括号中的(Int) -> Int 代表此函数返回的是一个函数
func addOne(number: Int) -> Int {
return 1 + number
}
return addOne
}
var increment = makeIncrementer()//同时你也可以把一个函数当做变量去使用!!!!
increment(7)
5.函数可以作为参数传入函数中处理
func hasAnyMatches(list: [Int], condition: (Int) -> Bool) -> Bool {//(Int) -> Bool表示此函数需要传入一个函数作为参数
for item in list {
if condition(item) {
return true
}
}
return false
}
func lessThanTen(number: Int) -> Bool {
return number < 10
}
var numbers = [20, 19, 7, 12]
hasAnyMatches(list: numbers, condition: lessThanTen)
6.闭包初体验
//函数实际上是一个特殊的闭包情况：稍后可以调用的代码块。闭包中的代码可以访问在创建关闭的范围内可用的变量和函数，即使它们在执行时封闭在不同的范围内 - 您看到已经有嵌套函数的示例。您可以使用大括号（{}）的周围代码编写一个没有名称的闭包。使用in分离参数和从包体返回类型。({ in })
numbers.map({ (number: Int) -> Int in
let result = 3 * number
return result
})
//您有几个选项可以更简洁地写入闭包。当闭包类型已知时，例如代理的回调，您可以省略其参数的类型，其返回类型或两者。单个语句闭包隐式地返回它们唯一的语句的值。
let mappedNumbers = numbers.map({ number in 3 * number })
print(mappedNumbers)
//您可以通过数字而不是名称来引用参数 - 这种方法在非常短的关闭中特别有用。作为函数的最后一个参数传递的闭包可以在括号后立即显示。当闭包是函数的唯一参数时，可以完全省略括号。
let sortedNumbers = numbers.sorted { $0 > $1 }
print(sortedNumbers)
