//有输入参数和返回值的函数
//输入参数为名name,数据类型为String
//返回值  String类型
func SayHello(name:String) ->String {
    return "Hello,"+name;
}
//调用函数
SayHello("_luo")

// 2.1 多重输入参数 ( Multiple Input Parameters )
func HalfOpenRangeLength(start:Int,end:Int) ->Int{
    return end - start;
}
// 2.2 无参函数 ( Functions Without Parameters )
func SayHelloWorld()->String{
return "Hello World";
}

// 2.3 无返回值函数 ( Functions Without Return Values )
func SayGoodbye(name:String){
    println("Goodbye,\(name)");
}

// 2.4 多重返回值函数 (Functions with Multiple Return Values )
//你可以用元组（tuple）类型让多个值作为一个复合值从函数中返回。
//计算一个字符串中元音，辅音和其他字母的个数
func Count(str:String)->(vowels:Int,consonants:Int,others:Int){
    var vowels=0,consonants=0,others=0;
    for item in str {
        switch String(item).lowercaseString{
        case "a","e","i","o","u":vowels++;
        case "b", "c", "d", "f", "g", "h", "j", "k", "l", "m",
        "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z":consonants++;
        default:others++;        }
    }
    return (vowels,consonants,others);
}

// 3.1 外部参数名 （ External Parameter Names ）
//外部参数名写在局部参数名之前，用空格分隔
//如果你提供了外部参数名，那么函数在被调用时，必须使用外部参数名。
//----没有外部参数名的写法????-----
func Join(str1:String,str2:String,joinner:String)->String{
    return str1 + joinner + str2;
}
//当你调用这个函数时，这三个字符串的用途是不清楚的
Join("Hello", "World", ",")

//为了让这些字符串的用途更为明显，我们为Join函数添加外部参数名
func Join(string str1:String,toString str2:String,withJoiner joinner:String)->String{
    return str1 + joinner + str2;
}
//现在，你可以使用这些外部参数名以一种清晰地方式来调用函数了：
Join(string: "Hello", toString: "World", withJoiner: ",");

// 3.2 简写外部参数名 （ Shorthand External Parameter Names ）
//如果你需要提供的外部参数名就是局部参数名，那么只写一次参数名并用＃号作为前缀就可以了
func ContainsCharacter(#str:String,#char:Character)->Bool{
    for item in str{
        if(item == char){
            return true;
        }
    }
    return false;
}

ContainsCharacter(str: "klsdkfjoiwenklaskdf", char: "a")

// 3.3 默认参数值 （ Default Parameter Values ）
// 3.4 默认值参数的外部参数名 （ External Names for Parameters with Default Values ）
// 在大多情况下，给带默认值参数起一个外部参数名是很有用的。这样可以保证当函数被调用时，实參的意图是明显的
// 为了使定义外部参数名更加坚定，当你未给带默认值的参数提供外部参数名是，Swift 会自动提供外部名字。此时外部参数名字与局部名字是一样的，就像你已经在局部参数名前写了＃一样
func Join(str1:String,str2:String,joinner:String=" ")->String{
    return str1 + joinner + str2;
}
Join("Hello", "World", joinner: "-")

// 3.5 可变参数 （ Variadic Parameters ）
//通过这变量类型名后加...的方式来定义可变参数
//计算一组任意长度数字的算术平均数
func AritheticMean(numbers:Double...)->Double{
    var total:Double=0;
    for number in numbers{
        total += number;
        
    }
    return total / Double(numbers.count);
}
AritheticMean(1,2,2,1,23,22,12)
//注意：一个函数至多能有一个可变参数，而且它必须是参数表中的最后一个

// 3.6 常量参数和变量参数 （ Constant and Variable Parameters ）
//函数参数默认上常量。试图这函数体中更改参数值将会导致变异错误，可以通过做参数名前加关键字var来定义变量参数
//使文字右对齐
func TextAlignRight(var str:String,totallength:Int,pad:Character)->String{
   
    let amountToPad = totallength - count(str);
    if(amountToPad<=0){
        return str;
    }
    for _ in 1...amountToPad{
        str=String(pad) + str;
    }
    return str;
}

TextAlignRight("loding", 10, "-")---------//"----loding"
TextAlignRight("Error", 10, "-")----------//"-----Error"

func addTwoInts(a: Int, b: Int) -> Int {
    return a + b
}
func multiplyTwoInts(a: Int, b: Int) -> Int {
    return a * b
}

func printHelloWorld() {
    println("hello, world")
}

// 4.1 使用函数类型 (Using Function Types)
//在 Swift 中，使用函数类型就像使用其他类型一样。例如，你可以定义一个类型为函数的常量或变量，并将函数赋值给它：
var mathFunction: (Int, Int) -> Int = addTwoInts
println("Result: \(mathFunction(2, 3))")
// prints "Result: 5"

//有相同匹配类型的不同函数可以被赋值给同一个变量，就像非函数类型的变量一样：
mathFunction = multiplyTwoInts
println("Result: \(mathFunction(2, 3))")
// prints "Result: 6"

//就像其他类型一样，当赋值一个函数给常量或变量时，你可以让 Swift 来推断其函数类型：
let anotherMathFunction = addTwoInts
// anotherMathFunction is inferred to be of type (Int, Int) -> Int

// 4.2 函数类型作为参数类型（Function Types as Parameter Types）
//你可以用(Int, Int) -> Int这样的函数类型作为另一个函数的参数类型。这样你可以将函数的一部分实现交由给函数的调用者。
//下面是另一个例子，正如上面的函数一样，同样是输出某种数学运算结果：
func printMathResult(mathFunction: (Int, Int) -> Int, a: Int, b: Int) {
    println("Result: \(mathFunction(a, b))")
}
printMathResult(addTwoInts, 3, 5)
// prints "Result: 8”

// 4.3 函数类型作为返回类型（Function Type as Return Types）
//你可以用函数类型作为另一个函数的返回类型。你需要做的是在返回箭头（->）后写一个完整的函数类型。
//下面的这个例子中定义了两个简单函数，分别是 stepForward 和stepBackward。stepForward 函数返回一个比输入值大一的值。stepBackward 函数返回一个比输入值小一的值。这两个函数的类型都是 (Int) -> Int：
func stepForward(input: Int) -> Int {
    return input + 1
}
func stepBackward(input: Int) -> Int {
    return input - 1
}
//下面这个叫做 chooseStepFunction 的函数，它的返回类型是 (Int) -> Int 的函数。chooseStepFunction 根据布尔值 backwards 来返回 stepForward 函数或 stepBackward 函数：
func chooseStepFunction(backwards: Bool) -> (Int) -> Int {
    return backwards ? stepBackward : stepForward
}
//你现在可以用 chooseStepFunction 来获得一个函数，不管是那个方向：
var currentValue = 3
let moveNearerToZero = chooseStepFunction(currentValue > 0)
// moveNearerToZero now refers to the stepBackward() function

//上面这个例子中计算出从 currentValue 逐渐接近到0是需要向正数走还是向负数走。currentValue 的初始值是3，这意味着 currentValue > 0 是真的（true），这将使得 chooseStepFunction 返回 stepBackward 函数。一个指向返回的函数的引用保存在了 moveNearerToZero 常量中。

//现在，moveNearerToZero 指向了正确的函数，它可以被用来数到0：
println("Counting to zero:")
// Counting to zero:
while currentValue != 0 {
    println("\(currentValue)... ")
    currentValue = moveNearerToZero(currentValue)
}
println("zero!")
// 3...
// 2...
// 1...
// zero!

func chooseStepFunction(backwards: Bool) -> (Int) -> Int {
    func stepForward(input: Int) -> Int { return input + 1 }
    func stepBackward(input: Int) -> Int { return input - 1 }
    return backwards ? stepBackward : stepForward
}
var currentValue = -4
let moveNearerToZero = chooseStepFunction(currentValue > 0)
// moveNearerToZero now refers to the nested stepForward() function
while currentValue != 0 {
    println("\(currentValue)... ")
    currentValue = moveNearerToZero(currentValue)
}
println("zero!")