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