Swift函数和闭包

1:函数

使用func来声明一个函数，使用名字和参数来调用函数。使用->来指定函数返回值的类型,如下:

func greet(name: String, day: String) -> String {
    return "Hello \(name), today is \(day)."
}
greet("Bob", "Tuesday")

使用元组来让一个函数返回多个值。该元组的元素可以用名称或数字来表示

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 if score < min {
            min = score
        }
        sum += score
    }

    return (min, max, sum)
}

函数可以带有可变个数的参数，这些参数在函数内表现为数组的形式


func sumOf(numbers: Int...) -> Int {
    var sum = 0
    for number in numbers {
        sum += number
    }
    return sum
}
sumOf()
sumOf(42, 597, 12)

函数可以嵌套。被嵌套的函数可以访问外侧函数的变量，你可以使用嵌套函数来重构一个太长或者太复杂的函数。

func returnFifteen() -> Int {
    var y = 10
    func add() {
        y += 5
    }
    add()
    return y
}

函数是第一等类型，这意味着函数可以作为另一个函数的返回值

func maxAndMinValue() ->([Int] ->(Int,Int)){
    
        func values(value: [Int]) ->(min: Int,max: Int){
            var max = value[0];
            var min = value[0];
            for eacherValue in value{
            
                if eacherValue > max{
                    
                    max = eacherValue;
                    
                }else if eacherValue < min{
                
                    min = eacherValue;
                }
            }
            return(min,max);
        }
        return values;
    }
  
  


  
  

函数也可以当做参数传入另一个函数

func hasAnyMatches(list: [Int], condition: Int -> Bool) -> 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(numbers, lessThanTen)

2:闭包

闭包是自包含的函数代码块，可以在代码中被传递和使用。 Swift 中的闭包与 C 和 Objective-C 中的代码块（blocks）以及其他一些编程语言中的 lambdas 函数比较相似。闭包可以捕获和存储其所在上下文中任意常量和变量的引用

函数其实也是闭包,闭包采取如下三种形式之一：

• 全局函数是一个有名字但不会捕获任何值的闭包
• 嵌套函数是一个有名字并可以捕获其封闭函数域内值的闭包
• 闭包表达式是一个利用轻量级语法所写的可以捕获其上下文中变量或常量值的匿名闭包

Swift 的闭包表达式拥有简洁的风格，并鼓励在常见场景中进行语法优化，主要优化如下：

• 利用上下文推断参数和返回值类型
• 隐式返回单表达式闭包，即单表达式闭包可以省略return关键字
• 参数名称缩写
• 尾随（Trailing）闭包语法

闭包表达式语法有如下一般形式：

{ (parameters) -> returnType in
    statements
}

尾随闭包（Trailing Closures）

如果您需要将一个很长的闭包表达式作为最后一个参数传递给函数，可以使用尾随闭包来增强函数的可读性。 尾随闭包是一个书写在函数括号之后的闭包表达式，函数支持将其作为最后一个参数调用。

//尾随闭包

    

    func someFunctionThatTakesAClosure(closure: (Int) -> Int){

    

        print("函数主体部分");

        print(closure(10));

    }

var strValue = {

            

            (number: Int) -> Int in

            print("haha");    

            return number;

        }

        someFunctionThatTakesAClosure(strValue);