Swift-函数

e.g.1

func sayHello(name: String?) -> String {
  return "Hello" + name ?? "guest"
}
var nickname: String? = nil
sayHello(name: nickname)

e.g.2: 使用元组返回多个值

func findMaxAndMin(numbers: [Int]) -> (max: Int, min: Int)? {
    
//    当数组为空的时候，返回nil
//    if numbers.isEmpty {
//        return nil
//    }
    
    
    guard numbers.count > 0 else {
        return nil
    }
    
    var maxValue = numbers[0]
    var minValue = numbers[0]
    
    for number in numbers {
        maxValue = maxValue > number ? maxValue : number
        minValue = minValue < number ? minValue : number
    }
    
    return (maxValue, minValue)
    
}

var scores: [Int]? = [202, 1234, 5659, 982, 555]
scores = scores ?? [] //如果是nil直接赋一个空数组

if let result = findMaxAndMin(numbers: scores!) { //强制解包，上段代码已经保证了其安全
    print("The max score is \(result.max)")
    print("The min score is \(result.min)")
}

e.g.3: 调用时隐藏变量名

// 下划线代表忽略
func mutiply(_ num1: Int, _ num2: Int) -> Int {
    return num1 * num2
}
mutiply(2, 3)

e.g.4: 默认参数和可变参数

//变长型函数参数
print("Hello",1, 2, 3, separator: "|", terminator: "...") // Hello|1|2|3...
//例子
func mean(_ numbers: Double ...) -> Double {
    var sum: Double = 0
    
    for number in numbers {
        sum += number
    }
    
    return sum / Double(numbers.count)
}

mean(numbers: 3)
mean(numbers: 2, 4)
mean(numbers: 3, 4, 8)

e.g.5: 函数可以作为参数使用

//1. 当函数有两个参数，同时有返回值时
func add(_ a: Int, _ b: Int) -> Int {
    return a + b
}

//let anotherAdd = add
let anotherAdd: (Int, Int) -> Int = add   //将函数当作变量使用


//2. 当函数只有一个参数，返回值是空时
func sayHello(name: String) {
    print("Hello, \(name)")
}

let anotherSayHello: (String) -> () = sayHello
//let anotherSayHello: (String) -> Void = sayHello

//3. 当函数即没有参数也没有返回时值
func sayHello(){
    print("Hello")
}

let anotherSayHello1: () -> () = sayHello
let anotherSayHello2: () -> Void = sayHello


//算法1. 默认从小到大排序
var arr: [Int] = []
for _ in 0..<100 {
    arr.append(Int(arc4random() % 1000))
}
arr.sort() //改变arr本身
arr.sorted() //不改变arr本身

//算法2. 按从大到小排序
func biggerNumberFirst(_ a: Int, _ b: Int) -> Bool {
    return a > b
}
arr.sort(by: biggerNumberFirst)

//算法3. 首位是1..2..3..4的排序
func cmpByNumberString(_ a: Int, _ b: Int) -> Bool {
    return String(a) < String(b)
}
arr.sort(by: cmpByNumberString)
//print(arr)

//算法4. 谁离500更近
func near500(_ a: Int, _ b: Int) -> Bool {
    return abs(500-a) < abs(500-b) //abs():取绝对值
}
arr.sort(by: near500)

//自己定义排序的规则，然后统一传到sort()函数里，实现任何想要的排序方法

e.g.6：高阶函数初探

func changeScores1(scores: inout [Int]){

    for (index, score) in scores.enumerated() {
        scores[index] = Int(sqrt(Double(score)) * 10)
    }
}

func changeScores2(scores: inout [Int]) {

    for (index, score) in scores.enumerated() {
        scores[index] = Int(Double(score) / 300 * 100)
    }
}

var scores1 = [36, 61, 78, 89, 91]
changeScores1(scores: &scores1)

var scores2 = [188, 240, 220, 260, 160]
changeScores2(scores: &scores2)

//高阶函数，函数式编程初探

//1. 初阶抽象
//建立通用的函数模版（把函数当参数传入）
func changeScores(scores: inout [Int], changeMethod: (Int) -> Int) {

    for (index, score) in scores.enumerated() {
        scores[index] = changeMethod(score)
    }
}

//实现具体改变的方式
func changeMethod1(score: Int) -> Int {
    return Int(sqrt(Double(score)) * 10)
}

func changeMethod2(score: Int) -> Int {
    return Int(Double(score) / 300 * 100)
}

//调用时将函数名作为参数传入
var scores1 = [36, 61, 78, 89, 91]
//changeScores(scores: &scores1, changeMethod: changeMethod1)

var scores2 = [188, 240, 220, 260, 160]
//changeScores(scores: &scores2, changeMethod: changeMethod2)



//2. 三大著名函数, 高阶抽象

var scores = [65, 91, 45, 59, 87]

//map():遍历，把调用的数组根据参数（函数）变化成另一个新的数组，返回新的数组
scores.map(changeMethod1) //更高一层的抽象

func isPassOrFail(score: Int) -> String {
    return score > 60 ? "Pass" : "Fail"
}
scores.map(isPassOrFail) // ["Pass", "Pass", "Fail", ...


//filter(): 遍历，根据参数（函数）规则来过滤，返回过滤后的新数组
func fail(score: Int) -> Bool {
    return score < 60
}
//filter接收的函数参数必须返回的是Bool型
scores.filter(fail) // [45, 59]


//reduce(): 遍历，最终聚合成一个值，此处为计算数组的和

func add(num1: Int, num2: Int) -> Int {
    return num1 + num2
}
scores.reduce(0, add)
scores.reduce(0, +) //用法相同

func concatenate(str: String, int: Int) -> String{
    return str + String(int) + " | "
}
scores.reduce("+", concatenate) // +65 | 91 | 45 | 59 | 8...

e.g.7：函数的嵌套和作为返回值

func tier1MailFeeByWeight(weight: Int) -> Int {
   return 1 * weight
}

func tier2MailFeeByWeight(weight: Int) -> Int {
   return 3 * weight
}


func feeByUnitPrice(price: Int, weight: Int) -> Int {
   
   //返回值是函数
   func chooseMailFeeCalculationByWeight(_ weight: Int) -> (Int) -> (Int) {
       return weight >= 10 ? tier2MailFeeByWeight : tier1MailFeeByWeight
   }

   let mailFeeByWeight = chooseMailFeeCalculationByWeight(weight) //变量代表一个函数，因此可以给他赋值
   return mailFeeByWeight(weight) + price * weight 
}