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)

闭包是自包含的函数代码块，可以在代码中被传递和使用。 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);