Swift学习(五：函数)

1.函数的定义与调用

• 定义
  func say(name:String) -> String{

            return "hello", + name + "!"
    }
  

• 调用

    print(say("wanwan"))          //hello,wanwan!
  

• 无参函数

    func say() -> String{
            return "hello,wanwan"
    }
    print(say())        //hello,wanwan
  

• 多参函数
  func say(name:String，isgirl:Bool) -> String{
  if isgirl{
  return "hello", + name + "!"
  }else{
  return "hello"
  }

    }
    * 调用
    print(say("wanwan",ture))                        
    //hello,wanwan!
  

• 无返回值函数

    func say(name:String){
              print("hello,wanwan")                
    }                           
    say("wanwan")
    因为这个函数不需要返回值，所以这个函数的定义中没有返回箭头（->）和返回类型。
  

• 当一个函数调用另一个函数的时候，该函数返回值可以忽略

  func inputsome(name:String) -> Int {
            print("name\(name)")
            return name.characters.count
  }
  
    func lala(name: String) {
            inputsome(name)
    }
  

• 多重返回值

    func minmax(array: [Int]) -> (min: Int, max: Int) {
            var currenmin = array[0]
            var currenmax = array[0]
            for value in array[1..<array.count]{
                    if value < currenmin{
                                currenmin = value
                    }else if value > currenmax{
                                currenmax = value
                    }
            }
            return (currenmin,currenmax)
    }
      minmax([1,2,3,4,5,6,7,8,8])
  

• 函数参数名称

    func come(first:String,last:String) {
            print("\(first)\(last)")
    
   }
    come("wanwan", last: "heihei")
  

函数有内部参数名和外部参数名，外部参数省略第一个参数名，第二个及后面的都需要带上参数名。

• 指定外部参数名

    可以在局部参数名前指定外部参数名，中间空哥分开  
    func some(outname inname:String) {
    
    }
    some(outname: "wanwan")
  
   func sayHello(to person: String, and anotherPerson: String) -> String {
          return "Hello \(person) and \(anotherPerson)!"
    }
    print(sayHello(to: "Bill", and: "Ted"))
    // prints "Hello Bill and Ted!"
  

• 忽略外部参数名

    func come(firat:Int , last : Int){
            
    }
    come(1,2)
  

• 默认参数

    func come(firat:Int ＝12){
           print(firat)
   }
   come()    //12
  

• 可变参数

   func some(number:Double...) -> Double {
            var total:Double = 0
            for num in number {
                total += num
            }
            return total
    }
    some(1,2,3)
  

• 输入输出参数
  函数参数默认是常量，不能在函数内部修改参数值，如果想修改，并且函数调用结束后这些修改仍然存在，就要定义为输入输出参数：inout

    func swapTwoInts(inout a: Int, inout _ b: Int) {
        let temporaryA = a
        a = b
        b = temporaryA
    }
  
   var someInt = 3
    var anotherInt = 107
    swapTwoInts(&someInt, &anotherInt)
  print("someInt is now \(someInt), and   anotherInt is now \(anotherInt)")
  // prints "someInt is now 107, and anotherInt is now 3"  
  

注意 参数名必须用 inout标记 调用必须用指针&

2.函数类型

每个函数都有种特定的函数类型，由函数的参数类型和返回类型组成。

    func addTwoInts(a: Int, _ b: Int) -> Int {
        return a + b
    }
    func multiplyTwoInts(a: Int, _ b: Int) -> Int {
        return a * b
    }
    这两个函数的类型是 (Int, Int) -> Int，可以解读为“这个函数类型有两个 Int 型的参数并返回一个 Int 型的值。”

3.使用函数类型

• 定义一个有两个Int类型的参数并返回一个Int型的值的函数变量，并将addTwoInts函数赋值给它
  func addTwoInts(a: Int, _ b: Int) -> Int {
  return a + b
  }

    var mathadd: (Int, Int) -> Int = addTwoInts
    
    现在可以用 `mathadd`调用被赋值的函数
    mathadd(1,4)       //5
  

• 相同类型的不同函数可以赋值给同一变量

    func multiplyTwoInts(a: Int, _ b: Int) -> Int {
        return a * b
    }         
  
    mathadd = multiplyTwoInts
    marhadd(2,3)     //6
  

4.函数类型作为参数类型

函数作为参数类型

    定义一个`aa`类型的函数，再定义一个包含`aa`类型函数的函数，调用的时候传入`aa`类型的函数。

5.函数类型作为返回类型

先定义几个函数,这两个函数类型都是 (Int) -> Int

func stepfor(input:Int) -> Int {
    return input+1
}

func stepback(input:Int) -> Int {
    return input-1
}

下面这个函数的返回类型为(Int) -> Int

func choose(back:Bool) -> (Int)->Int {
    
    return back ? stepfor : stepback
}

调用：

var value = 3
let over = choose(value >0)    //这时候的返回结果应该是`stepfor`这个函数
over(4)    // 给这个函数赋值
print(over(4))    //打印出来为5

上述步骤其实可以简化
let over = choose(value>0)(4)        //5

6.嵌套函数

全局函数可以被外界访问，嵌套函数只能被它的外围函数调用，上面的例子可以改写为嵌套函数：

func choose(back:Bool) -> (Int)->Int {
    
    func stepfor(input:Int) -> Int { return input+1}
    
    func stepback(input:Int) -> Int {return input-1}
    
    return back ? stepfor : stepback
}

调用：

    var value = 3
    let over = choose(value>0)(4)        //5