swift函数学习

//函数的定义与调用

//定义

func sayHolle(personName : String) -> String{

    let greeting = "holle," + personName + "!";

    return greeting;

}

//调用

print(sayHolle("nick"));

//函数参数与返回值

//多重参数

func halfOpenRangeLength(start : Int, end : Int) -> Int {

    return end - start;

}

print(halfOpenRangeLength(3, end: 10));

//无参函数

func sayHolleWorld() -> String {

    return "holle world!";

}

print(sayHolleWorld());

//无返回值函数

func sayGoodbye(personName : String) {

    print("goodbye \(personName)!");

}

sayGoodbye("Nick");

//多重返回值函数

func count(string : String) -> (vowels : Int, consonants : Int, others : Int) {

    var vowels = 0, consonants = 0, others = 0;

    for character in string.characters {

        switch String(character).lowercaseString {

            case "a","e","i","o","u":

                ++vowels;

            case "b","c","d","f","g","h","j","k","l","m":

                ++consonants;

        default:

            ++others;

        }

    }

    return (vowels, consonants, others);

}

let total = count("hclksajlhflkahflkagflsadgfliusag8whklwb");

print(total);

//元组返回可以存放不同类型的数据

func count1(string : String) -> (vowels : Int, consonants : Int, others : String) {

    var vowels = 0, consonants = 0, others = "";

    for character in string.characters {

        switch String(character).lowercaseString {

        case "a","e","i","o","u":

            ++vowels;

        case "b","c","d","f","g","h","j","k","l","m":

            ++consonants;

        default:

            others.append(character);

        }

    }

    return (vowels, consonants, others);

}

let total1 = count1("hclksajlhflkahflkagflsadgfliusag8whklwb");

print(total1);

//外部参数名

/**

如果希望函数的使用在调用函数时提供参数名字，那就需要给每个参数除了局部参数名外再定义一个外部参数名。外部参数名写在局部参数名之前，用空格分隔

*/

func someFunction(jubuCanshuming jubuCanshuming : Int) {

    print(jubuCanshuming);

}

someFunction(jubuCanshuming: 10);

//可变参数

/**

一个可变参数可以接受一个或多个值。函数调用时，你可以用可变参数来传入不确定数量的输入参数。通过在变量类型名后面加入(...)的方式定义可变参数，在函数体内可以当做数组常量,但不是数组.

使用时，一个函数最多只能有一个可变参数，而且它必须是参数表中最后一个，这样做是为了避免函数调用时出现歧义。

*/

//计算平均数

func arithmeticMean(numbers : Double...) -> Double {

    var total : Double = 0;

    for number in numbers {

        total += number;

    }

    return total / Double(numbers.count);

}

print(arithmeticMean(1, 2, 3, 4, 5));

//变量参数

func alignRight(var string : String, count : Int

    , pad : Character) -> String {

        let amountToPad = count - string.characters.count;

        for _ in 1...amountToPad {

            string = "\(pad)\(string)";

        }

        return string;

}

let originalString = "hahaha";

print(alignRight(originalString, count: 10, pad: "*"));

//输入输出参数

/**

定义一个输入输出参数时，在参数定义前加inout关键字。一个输入输出参数有传入函数的值，这个值被函数修改，然后被传出函数，替换原来的值。

只能传入一个变量作为输入输出参数，不能传入常量或者字面量。当传入的参数作为输入输出参数时，需要在参数前加&符，表示这个值可以被函数修改

有利于代码抽取

谨防埋雷

*/

func swapTwoInts(inout a : Int, inout b : Int) {

    let temporaryA = a;

    a = b;

    b = temporaryA;

}

var someInt = 3;

var anotherInt = 10;

print(someInt,anotherInt);

swap(&someInt, &anotherInt);//注意&符号

print(someInt,anotherInt);

//使用函数类型

/**

相同类型函数可以赋值，可以想其他类型一样，当赋值一个函数给常量或变量时，可以让swift推测其函数类型

*/

func addFunction(a : Int, b : Int) -> Int {

    return a + b;

}

func multiplyFunction(a : Int, b : Int) -> Int {

    return a * b;

}

var newAddFunction: (Int, Int) -> Int = addFunction;

print(newAddFunction(3,4));

newAddFunction = multiplyFunction;

print(newAddFunction(2,5));

//函数类型作为参数类型

/**

函数类型可以作为另一个函数的参数类型，可以将函数的一部分实现交由给函数的调用者

有利于迭代

*/

func printResult(newFunction: (Int, Int) -> Int, a : Int, b : Int) {

    print("result is \(newFunction(a, b))");

}

printResult(newAddFunction, a: 5, b: 10);

//函数类型作为返回类型

/**

用函数类型作为另一个函数的返回类型。需要做的是在返回箭头后面写一个完整的函数类型

*/

func stepForward(input : Int) -> Int {

    return input + 1;

}

func stepBackward(input : Int) -> Int {

    return input - 1;

}

func chooseStepFunction(backward : Bool) -> (Int) -> Int {

    return backward ? stepBackward : stepForward;

}

var currentValue = 3;

let moveNearerToZero = chooseStepFunction(currentValue < 0);

currentValue = moveNearerToZero(currentValue);

print(currentValue);

//嵌套函数

/**

可以视为局部域函数

默认情况下，嵌套函数是对外界不可见的，但是可以被他们的封闭函数调用，一个封闭函数也可以返回她的某一个嵌套函数，使得这个函数可以在其他域中被使用

*/

func chooseStepFunction2(backward : Bool) -> (Int) -> Int {

    func stepForward1(input : Int) -> Int {

        return input + 1;

    }

    func stepBackward1(input : Int) -> Int {

        return input - 1;

    }

    return backward ? stepBackward1 : stepForward1;

}

var currentValue1 = 4;

let moveNearerToMax = chooseStepFunction2(currentValue1 < 0);

print(moveNearerToMax(currentValue1));