Swift 3.0 函数（Function）

一、函数定义及分类

1、语法格式:

func 函数名(参数列表) -> 返回值类型 {

}

2、无参数无返回值

func println(){

print("Hello Swift 3.0");
}
//Hello Swift 3.0

3、有参数无返回值

func println(version:String){

print("Hello Swift "+version);

}

println(version:"3.0");
// Hello Swift 3.0

4、无参数有返回值

func returnMessage() -> String{

return "Hello Swift 3.0";
}

let message = returnMessage();
print(message);
//Hello Swift 3.0

5、有参数有返回值

func introduce(name:String,age:Int) -> String{

return "my name is \(name),my age is \(age)";

}

let put = introduce(name: "jack", age: 24);
print(put);
//my name is jack,my age is 24

关于返回值: 返回值可以被忽略(用”_”忽略返回值)，但定义了有返回值的函数必须返回一个值，如果在函数定义底部没有返回任何值，将导致编译时错误。

二、函数的返回值

1、多重返回值(返回值类型：元组)

func minAndMax(array:[Int])->(min:Int,max:Int){

var min = array[0];
var max = array[0];

for (_,value) in array.enumerated() {

if value < min {

min = value;
}

if value > max {

max = value;
}
}

return(min,max);

}

let arrays:[Int] = [45,13,78,4,98,45];
let touples = minAndMax(array: arrays);
print(touples);
//(4, 98)
//print(touples.min,touples.max);

注意 ：

（1）元组的成员不需要在元组从函数中返回时命名，因为它们的名字已经在函数返回类型中指定了

（2） 如果我传入的数组为空，那么可能，上面的函数取出数组的值就可能会报错 ？ 那么如何处理呢？判断数组是否为空，其次，如果数组为空，并且当数组为空时返回 nil。那么返回的元组就是可选类型的

func getMinxAndMax(arrays:[Int]) ->(max:Int,min:Int)?{

if arrays.isEmpty {

return nil;

}

var currentMin = arrays[0];
var currentMax = arrays[0];
for (_,value) in arrays.enumerated() {

if value < currentMin {

currentMin = value;
}

if  value > currentMax {

currentMax = value;
}
}

return(currentMax,currentMin);

}

let array:[Int] = [];

// 可选值解绑
if let touples = getMinxAndMax(arrays: array){

print(touples.max,touples.min);

}
//let touples = getMinxAndMax(arrays: array) ?? (0,0);
//print(touples.max,touples.min);

三、函数的默认参数值

你可以在函数体中通过给参数赋值来为任意一个参数定义默认值（Deafult Value）。当默认值被定义后，调用这个函数时可以忽略这个参数。

func mySelf(name:String,version:Double = 3.0) ->String{

return name + " version is " + "\(version)";

}

print(mySelf(name: "Swift"));
print(mySelf(name: "Swift", version: 3.0));
/*
Swift version is 3.0
Swift version is 3.0
*/

四、可变参数

一个可变参数（variadic parameter）可以接受零个或多个值。函数调用时，你可以用可变参数来指定函数参数可以被传入不确定数量的输入值。通过在变量类型名后面加入（…）的方式来定义可变参数。

func getAverage(_ numbers:Double...) ->Double{

//
var sum:Double = 0.0;

for value in numbers {

sum += value;
}

return sum / Double(numbers.count);

}

let average1 = getAverage(1,2,3,4,5);
print(average1);
//3.0

let average2 = getAverage(1,2,4);
print(average2);
//2.33333333333333

注意: 是同类型，数量不确定(可多可少) “_” 可以忽略参数名。

五、输入输出参数（inout）

如果你想要一个函数可以修改参数的值，并且想要在这些修改在函数调用结束后仍然存在，那么就应该把这个参数定义为输入输出参数,定义一个输入输出参数时，在参数定义前加 inout 关键字。（Swift是值类型）

var x = 2;
var y = 5;

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

let temp = a;

a  = b;

b = temp;

}

swap(&x, &y);
print(x,y);

// 5 2

六、函数类型

1、什么是函数类型？

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

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

return a+b;
}
// 函数类型 (Int,Int) -> Int

定义一个叫做 mathFunction 的变量，类型是‘一个有两个 Int 型的参数并返回一个 Int 型的值的函数’，并让这个新变量指向 addTwoInts 函数”。

var typeFunction:(Int,Int) -> Int = addTwoNumber;
print(typeFunction(5,6));
// 11

2、如何使用函数类型

2.1 函数类型作为参数类型

func printMathResult(typeFunction:(Int,Int) -> Int,a:Int,b:Int){

print(typeFunction(a,b));

}
printMathResult(typeFunction: addTwoNumber,a: 5,b: 8);

//13

2.2 函数类型作为返回值类型

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;

// 此刻， moveToZero指向  stepBackward
let moveToZero = chooseStepFunction(backward: currentValue > 0);

while currentValue != 0{

print("\(currentValue)...")
currentValue = moveToZero(currentValue);

}

print("zero");

/*

3...
2...
1...
zero
*/

七、函数嵌套

将上面的函数修改成

func chooseStepFunction(backward: Bool) -> (Int) -> Int {
func stepForward(input: Int) -> Int { return input + 1 }
func stepBackward(input: Int) -> Int { return input - 1 }
return backward ? stepBackward : stepForward
}