Swift(三函数闭包)

第九章函数

关于函数返回值为元组的情况下，打印字段值(多返回值函数的两种方式实现：1、在函数定义时，将函数的多个参数声明为引用类型传递 2、返回值为元组类型)

func add(A a: Int, B b: Int)->(a1: Int, b1: Int){

     return (a, b)
}

var c: (a1: Int, b1: Int) = add(A: 1, B: 2)
print("\(c.a1)") // 按最近的字段访问
var c4: (Int, Int) = add(A: 1, B: 2)
print("\(c4.0)")  // 只能下标访问



func add1(A a: Int, B b: Int)->(Int, Int){

   return (a, b)
}

var c1: (Int, Int) = add1(A: 1, B: 2)
print("\(c.0)") // 只能下标访问

var c2: (a2: Int, b2: Int) = add1(A: 1, B: 2)
print("\(c2.a2)") // 用最新字段访问  下标也是可以的

var c3 = add1(A: 1, B: 2)
print("\(c3.0)")  // 用下标访问

每个参数由参数标签，参数名，参数类型3部分构成。
```
   如果函数参数为 W width：Double    那么W为参数标签
   如果函数参数为width：Double     那么width为参数标签
```
参数标签可以省略 _ width：Double 调用时候参数标签不存在。在Swift3.0后，调用函数时要求指定所有参数的标签，除非函数定义时使用下划线(_)关键字。

参数存在默认值

func add3(A a: Int, B b: Int = 1)->Int{
       return a + b
}
add3(A: 2)
add3(A: 2, B: 2)

可变参数

  func sum(m: Int...)->Int{
       var result: Int = 0
       for i in m {
             result += i
       }
      return result

   }


sum(m: 1,2,3)  // 参数个数可以放任意多个

引用传递（指针传递）：1、类类型 2、值类型
值类型：值类型的引用传递也改变了原来的值的内容，引用传递过去的是内存地址必须在参数冒号后面加inout关键字(方法内的参数默认是let, 也只能是let 不能修改为var以及不能修改值。但用inout可以修改值)
```
func add4(A a: Int,B b: inout Int)->Int{  // a是不可变的let，不能换成var，inout必须放在类型之前  冒号之后

     b += a
     return b
}
var value: Int = 3
add4(A: 3, B: &value)
print(value)  // 6
```
函数类型：([参数1类型，参数2类型...])->返回值类型
函数类型可以作为函数返回类型使用。也可以作为参数类型使用。与其他类型用法一样。

函数的嵌套（了解）：默认情况下，嵌套函数的作用域在外函数体内，但我们可以定义外函数的返回值类型为嵌套函数的类型，从而将嵌套函数传递给外函数，被其他调用者使用。

   // 函数的嵌套
func calculate(opr: String)->(Int, Int)->Int
{

    // +
   func add(a: Int, b: Int)->Int
   {
       return a + b
   }
    // -
   func sub(a: Int, b: Int)->Int
  {
      return a - b
  }


  switch opr {
    case "+":
       return add
    case "-":
       return sub
    default:
      return add
   }

}

let f1:(Int, Int)-> Int = calculate(opr: "+")
f1(2, 1)

let f2: (Int, Int)-> Int = calculate(opr: "-")
f2(2, 1)  // 说白了  f1 f2就是嵌套函数，在外部使用

第十章闭包

闭包是自包含的匿名函数代码块, 可以作为表达式、函数参数和函数返回值，闭包表达式的运算结果是一种函数类型

作为表达式以及函数返回值

func calculate(opr: String)->(Int, Int)->Int
{

   // +
  func add(a: Int, b: Int)->Int
  {
         return a + b
  }
  // -
 func sub(a: Int, b: Int)->Int
 {
     return a - b
 }

var result: (Int, Int) -> Int

switch opr {
    case "+":
     result = {
           (a: Int, b: Int) -> Int in
               return a + b
         }  // 返回的类型是 (Int, Int) -> Int 
            // <=>  result = {a, b  in return a + b}  类型推断简化， 也可以带小括号
            // <=> result = {a, b in a + b}  return隐藏  只有一条return语句时候  才可以省略
            // <=>result = { return  $0 + $1} in和变量一块隐藏
            // <=> result = {$0 + $1}   省略参数名
          
           

    default:
    result = {
          (a: Int, b: Int) -> Int in
               return a - b 
          } // 返回的类型是 (Int, Int) -> Int
    }
 return result

}

总结：有参数时候必须有in的存在，有参数时候return可以省略。无参数时候，in省略 return可有可无。

使用闭包返回值-闭包本质是函数类型，是有返回值的。返回值可以在表达式中获取使用。
```
 var c1: Int = {(a: Int, b: Int)->Int in
 return a + b
}(1, 3)  // 可以看作函数后面跟了参数列表
```

作为参数--又叫尾随闭包（不放在尾部会影响程序的阅读性，规定必须放在尾部）

func calculate(opr: String, funN:(Int, Int)->Int){

switch opr {
case "+":
  print("10 + 5 = \(funN(10, 5))")
default:
  print("10 - 5 = \(funN(10, 5))")
   }
}

calculate(opr: "+", funN: {$0 + $1})
calculate(opr: "-", funN: {$0 - $1})
calculate(opr: "-"){$0 - $1}
// 打印： 10 + 5 = 15     10 - 5 = 5

Swift(三 函数 闭包)

第九章 函数

第十章 闭包

推荐阅读更多精彩内容

Swift(三函数闭包)

第九章函数

第十章闭包