Swift 中的函数

学习来自《极客学院：Swift中的函数》

工具：Xcode6.4 

直接上基础的示例代码，多敲多体会就会有收获：百看不如一敲，一敲就会

练习一：

import Foundation

//函数
/*1.定义函数的语法格式
    func 函数名(形参列表) -> 返回值类型 {
    //可执行语句组成的函数
}
*/
//定义和调用函数
func sayHello(personName: String) -> String{
    return "Hello "+personName
}
println(sayHello("HeYang"))

//2.外部参数名 局部参数名：形参类型
func area(宽  Double,高  height: Double) -> Double
{
    return width * height
}
print("面积是：")
println(area(宽: 3.4, 高: 4.3))
//但是这样比较麻烦，所以需要用＃号
func area_1(# Double,#height: Double) -> Double
{
    return width * height
}
print("改了之后：")
println(area_1( 34.1, height: 9.2))

//3可变参数：在参数类型后面添加 ... 表示该参数
func sum(numbers: Int...) -> Int{
    var total : Int = 0
    for num in numbers{
        total += num
    }
    return total
}
println("求和是：(sum(1,2,3,4))")
//要注意的地方：一个函数只能有一个可变参数，而且可变参数只能位于最后

//4.默认参数
func sayHi(msg: String,name: String = "HeYang"){
    println("(name),(msg)")
}
sayHi("你好～")
sayHi("你好～", name: "world")
//不能去掉里面的 name: 也就是带有默认参数的是有外部参数名的，也就是说，默认参数相当于是在外部声明定义的。如果要忽略的话，就在默认参数前面添加下划线:unc sayHi(msg: String,_ name: String = "HeYang")不是_name而是_ name

//如果有可变参数，也有默认参数，那么可变参数放在最后面，默认参数只能出现在次后面

//5.常量形参 和 变量形参
func factorial(var number:Int) -> Int{
    var result: Int = 1
    while number > 1{
        result = result*number
        number--
    }
    return result
    //变量的形参作用域在函数内部，所以形参怎么变化都是不会影响到外面的变量
}
print("形参")
println(factorial(4))

//6.In-Out形参
func swap(inout a:Int,inout b:Int){
    var temp = a
    a = b
    b = temp
}
var a = 1
var b = 2
swap(&a, &b)
println("交换之后,a：(a) b:(b)")
/*注意
1.只能传入变量作为实参
2.输入输出参数不能带有默认值
3.如果你用关键字，inout标记了一个参数，这个参数不能用var或者let去标记
*/

运行输出结果是：

练习二：

 1 import Foundation
 2 
 3 //函数
 4 
 5 //1.多个返回值
 6 func area( Double,height: Double) -> (Double,Double)
 7 {
 8     var b = width
 9     var a = width * height
10     return (a,b)
11 }
12 println(area(2,3))
13 //2、函数类型
14 func addTwoInts(a: Int, b: Int) -> Int{
15     return a + b
16 }
17 var function: (Int,Int) ->Int = addTwoInts
18 println(function(3,4))
19 //3.函数类型作为参数类型
20 func outfunc(function_1: (Int,Int) ->Int,m:Int,n:Int){
21     println("result:(function_1(m, n))")
22 }
23 outfunc(addTwoInts ,12,12)
24 //4函数类型作为返回值类型
25 func square(a :Int)->Int{
26     return a*a
27 }
28 func cube(a:Int)->Int{
29     return a*a*a
30 }
31 func getMatchFunction(str:String)->(Int)->Int{
32     switch(str){
33     case "square":
34         return square
35     default:
36         return cube
37     }
38 }
39 var mathFunc = getMatchFunction("cube")
40 println(mathFunc(5))
41 //函数重载
42 func test(){
43     println("无参数的test函数")
44 }
45 func test(msg:String){
46     println("重载的test()函数(msg)")
47 }
48 func test(msg:String) -> String{
49     println("重载的test()函数，外部参数为(msg)")
50     return "test"
51 }
52 func test(#msg:String) {
53     println("重载的test()函数，外部参数为(msg)")
54 }
55 test()
56 var result: Void = test(msg: "何杨")
57 var result2: String = test("哇哦")
58 /*局部参数名不能作为区分重载 运行会报错
59 func test(message:String){
60     println("")
61 }
62 */

运行的结果：