<pre name="code" class="objc">//
//  main.swift
//  FunctionsDemo
//
//  Created by 程磊 on 15/5/23.
//  Copyright (c) 2015年 chenglei. All rights reserved.
//

import Foundation

//1.函数的定义与调用
//以 func 作为前缀，返回箭头 -> 表示函数的返回类型
func sayHello(name:String) -> String {
    let greeting = "Hello" + name;
    return greeting;
}

println(sayHello("bielian"))

//1.1函数的参数与返回值
func minusResult(start: Int,end: Int) -> Int {
    return end - start;
}

println(minusResult(1,10));

//1.2无参函数
func sayHelloWorld() -> String {
    return "Hello World"
}

//1.3无返回值函数
/*
    严格上来说，虽然没有定义返回值，sayGoodBye函数依然返回了值。
    没有定义返回类型的函数会返回特殊的值，叫Void。它其实是一个空的元组(tuple),没有任何元素，可以写成()
*/
func sayGoodBye(name: String){
    println("GoodBye \(name)");
}

println(sayGoodBye("bielian"))

//1.4多重返回值函数
func count(string: String) -> (vs: Int,cs: Int,os:Int) {//返回一个元组
    var vowels = 0,consonants = 0,others = 0
    for character in string {
        switch String(character).lowercaseString {
            case "a","e","i","o","u":
                ++vowels;
            case "b","c","d","f","g","h":
                ++consonants;
            default:
                ++others;
        }
    }
    return (vowels,consonants,others);
}

let total = count("Hello!")
println("\(total.vs) vowels,and\(total.cs) consonants and\(total.os)others")

//2  函数参数名
//2.1 外部参数名

//Demo:把两个字符串联在一起，演示使用外部参数的好处
/*
    不使用外部参数
*/
//func join(s1: String,s2: String,joiner: String) -> String {
//    return s1 + joiner + s2;
//}
//println(join("Hello","World",","))

//使用外部参数
func join(string s1:String,toSting s2: String,withJoiner joiner: String) -> String {
    return (s1 + joiner + s2);
}
println(join(string: "hello",toSting: "world",withJoiner: ","));

//2.2 简写外部参数名
//如果你需要提供外部参数名，但是局部参数名已经定义好了，那么你不需要写两次这些参数名。相反，只写一次参数名，并用井号(#)作为前缀就可以了。这告诉Swift使用参数名作为局部和外部参数名。
func containsCharacter(#string: String,#charactertoFind: Character) -> Bool {
    for character in string {
        if character == charactertoFind {
            return true
        }
    }
    return false
}

//这样定义参数名，使得函数体更为可读，清晰，同时也可以以一个不含糊的方式被调用
let containsCon = containsCharacter(string: "qwertyuiop",charactertoFind: "y")
println(containsCon)

//2.3 默认参数值
//你可以在函数体中为每个参数定义默认值。当默认值被定以后，调用这个函数时可以略去这个参数
func join2(string s1:String,toString s2:String,withJoiner joiner:String = ",") ->String {
    return s1 + joiner + s2
}

let str1 = join2(string: "hello",toString: "world",withJoiner: "-");//指定第三个参数
println(str1);

let str2 = join2(string: "hello",toString: "world")
println(str2)

//2.4 默认参数的外部参数名
func join2(s1: String,joiner: String = " ") -> String {
    return s1 + s2 + joiner
}
let str3 = join2("hello","world",joiner: "=")


//3.可变参数
//传入可变参数的值在函数体内当做这个类型的一个数组。例如，一个叫做numbers 的 Double... 型可变参数，在函数体内可以做一个叫numbers的Double[]型的数组常量。
//一个函数最多能有一个可变参数
//可变参数必须放在参数表中最后的位置
func aritheticMean(numbers: Double...) -> Double {
    var total: Double = 0;
    for number in numbers {
        total += number
    }
    return total / Double(numbers.count)
}
println(aritheticMean(1.1,1.3,1.5))
println(aritheticMean(0.3,0.5,0.9))

//4 常量参数与变量参数
//函数参数默认是常量。但有时候，如果函数中传入的参数可以修改的话将很有用。你可以通过指定一个或者多个参数为变量参数，从而避免自己在函数中定义新的变量，变量参数不是常量，你可以在函数中把它当做新的可以修改的副本来使用。
//通常在参数名前加关键字 var 来定义变量参数
func alignRight(var string: String,countNum: Int,pad:Character) -> String {//想要指定变量参数在其参数名前面加关键字var
    let amountToPad = countNum - count(string)
    for _ in 1...amountToPad {
        string = String(pad) + string
    }
    return string
}

let originalString = "Hello"
let paddedString = alignRight(originalString,10,"-")
println("originalString:" + originalString)
println("paddedString" + paddedString)

//5 输入输出参数
//变量参数，正如上面所述，仅仅能在函数体内被更改。如果你想要一个函数可以修改参数的值，并且想要这些修改在函数调用结束后仍然存在，那么就应该把这个参数定义为输入输出参数(In-Out Parameters).
 //定义一个输入输出参数，在参数的前面加inout关键字
//输入输出参数不能有默认值，而且可变参数不能用inout标记，如果你用inout标记一个参数，这个参数就不能被var 或者 let标记
func swapTwoInts(inout a: Int,inout b: Int) {
    let temp = a
    a = b
    b = temp
}

//只能传入一个变量作为输入输出参数
var someInt = 3
var anotherInt = 7

//当传入的参数作为输入输出参数时，需要在参数的前面加&，表示这个值可以被函数修改
swapTwoInts(&someInt,&anotherInt)
println("someInt is now \(someInt),and anotherInt is now \(anotherInt)")

//6.函数类型
//分三步： 1.定义函数;2.声明函数类型变量或常量;3.给函数类型变量赋值
func addToInts(a: Int,b: Int) -> Int {
    return a + b;
}

//2.声明函数类型变量,如下声明了一个叫做mathFunction的变量，类型是'一个有两个Int型的参数并返回一个Int型的值的函数'，这里定义的参数类型以及返回值类型与上面定义的函数参数类型以及返回值类型都是一一对应的
var mathFunction: (Int,Int) -> Int

//3.给函数类型变量赋值
mathFunction = addToInts;

//可以讲上述步骤合并
//(1)
var mathFunction2: (Int,Int) -> Int = addToInts;
//(2)
var mathFunction3 = addToInts

//4.使用
println("Result: \(mathFunction(2,3)) ")
println("Result2: \(mathFunction2(2,3)) ")
println("Result3: \(mathFunction3(2,3)) ")



//Swift中调用C或者OC函数，必须要建立一个.h作为桥梁，其命名格式为"项目名字-Bridging-Header.h"，在文件中引入相对应的文件或者方法，如果是C函数，则直接将方法名引入即可，如果是OC函数，则直接import导入头文件即可
//Swift中调用C函数
desc1()

//Swift中调用OC函数
var funcClass = FuncBlock()  //拿到OC类对象
funcClass.desc2()


//6.1函数类型作为参数类型
func printMathResult(mathFun: (Int,Int) -> Int,a: Int,b: Int) {
    println("Result4: \(mathFun(a,b))")
}

printMathResult(addToInts,3,4)


//6.2 函数类型作为返回类型
func stepForward(input: Int) -> Int {
    return input + 1
}

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

//返回一个函数类型，第一个箭头指向对应要返回的函数类型
func chooseStepFunction(backwards: Bool) -> (Int) -> Int {
    return backwards ? stepBackward : stepForward
}

var currentValue = 3
//let moveNearTozero:(Int) -> Int = chooseStepFunction(currentValue > 0)//原型
let moveNearTozero = chooseStepFunction(currentValue > 0)
println("moveNearTozero = \(moveNearTozero)")//并没有调用其中的函数
println("Result5 = \(moveNearTozero(6))")

//嵌套函数
func chooseStepFunction2(backwards: Bool) -> (Int) -> Int {
    func stepForward2(input: Int) -> Int {
        return input + 1
    }
    
    func stepBackward2(input: Int) -> Int {
        return input - 1
    }
    return backwards ? stepBackward2 : stepForward2 //返回函数类型
}
var currentValue2 = -4
let moveNearTozero2 = chooseStepFunction2(currentValue2 > 0)
println("Result6 = \(moveNearTozero2(10))")


//8.闭包
/*
    表达式语法一般形式如下:
    {(parameters) -> returnType in 
        statements
    }
*/
//8.1闭包表达式

//不使用闭包
let names = ["Bielian","Harry","Howard","James","Young"]
func backwards(s1: String,s2: String) -> Bool {
    return s1 > s2
}
var reversed = names.sorted(backwards)
println("reversed = \(reversed)")

//使用闭包
//闭包的函数体部分由关键字in引入。该关键字表示闭包的参数和返回值类型定义已经完成，闭包函数即将开始
reversed = names.sorted({(s1: String,s2: String) -> Bool in
    return s1 > s2
})
println("reversed = \(reversed)")

//根据上下文推断类型
reversed = names.sorted({(s1,s2) in return s1 > s2})
println("reversed = \(reversed)")

//8.2单表达式闭包隐式返回
//如果闭包体中只有一个表达式，那么return关键字可以省略
reversed = names.sorted({(s1,s2) in s1 > s2})
println("reversed = \(reversed)")

//8.3参数名称缩写
//Swift自动为内联函数提供了函数名称缩写功能，可以直接通过$0、$1、$2来顺序调用闭包的函数
//如果闭包函数表达式中使用参数名称缩写，可以在闭包参数列表中省略对其的定义，in关键字也可以省略
reversed = names.sorted({$0 > $1})
println("reversed = \(reversed)")

//8.4运算符函数
//Swift的String类型定义了关于大于号(>)的字符串实现
reversed = names.sorted(>)
println("reversed = \(reversed)")

//8.5尾随闭包
//如果需要将一个很长的闭包表达式(以至于不能在一行中进行书写时)作为最后一个参数传递给函数，可以使用尾随闭包来增强函数的可读性。尾随闭包是一个书写在函数括号之后的闭包表达式，函数支持将其作为最后一个参数调用
reversed = names.sorted(){
    $0 > $1
}
println("reversed = \(reversed)")


//8.6捕获值
func makeIncrementor(forIncrement amount: Int) -> ()->Int {
    var runningTotal = 0
    
    //incrementor函数并没有获取任何参数，但是在函数体内访问了runningTotal和amount变量。这是因为其通过捕获在包含他的函数体内已经存在的runningTotal和amount变量而实现
    func incrementor() -> Int {
        runningTotal += amount
        return runningTotal
    }
    return incrementor
}
let incrementByTen = makeIncrementor(forIncrement: 10)
//因为每次调用该函数的时候都会修改runningTotal的值，incrementor捕获了当前runningTotal变量的引用，而不是仅仅复制该变量的初始值。捕获一个引用保证了当makeIncrementor结束时候并不会消失，也保证了当下一次执行incrementor函数时，runningTotal可以继续增加
println(incrementByTen())   //10
println(incrementByTen())   //20
println(incrementByTen())   //30

let incrementByOne = makeIncrementor(forIncrement: 1)
println(incrementByOne())

//8.7闭包是引用类型
//上面的例子中，incrementByOne和ByTen是常量，但是这些常量指向的闭包仍然可以增加其捕获的变量值。这是因为函数和闭包都是引用类型

//如果将闭包赋值给了两个不同的常量/变量，两个值实际上指向的还是同一个闭包，所以仍然会改变其捕获的变量值
let alsoIncrementByTen = incrementByTen
println(alsoIncrementByTen())   //40