Swift函数总结

//
//  main.swift
//  Swift之函数
//
//  Created by Goddog on 15/7/15.
//  Copyright (C) 2015年 Goddog. All rights reserved.
//

import Foundation

println("Swift融合了面向对象和面向过程的特征，而且Swift支持嵌套函数，每一个函数都有一个类型，包括函数的参数类型和返回值类型，也可以将函数作为参数传递给其他函数，甚至从函数中返回函数类型，函数也可以被写入其他函数中以在函数作用于中封装有用的功能!")

//MARK: - 定义和调用函数
//定义一个函数，声明2个形参，返回值为Int类型
func max(x:Int,y:int) -> Int
{
    var z = x>y ? x : y
    return z
}
println("x和y最大值是：\(max(1,2))")

//MARK: -无形参函数
func sayHelloSwift() ->String
{
    return "Hello Swift"
}
println("无形参函数: \(sayHelloSwift())")

//MARK: - 函数返回值
//定义一个函数，该函数无形参，也无返回值
func foo()
{
    println("无形参无返回值的函数")
}
//定义一个函数，有形参，无返回值
func sayHi(lug : String) -> ()
{
    println("好好学习\(lug)")
}
//定义一个函数，有形参，无返回值
func showMsg(msg:string,count:int) ->Void
{
    for _ in 1...count
    {
        println(msg)
    }
}
println(foo())
println(sayHi("Swift"))
println(showMsg("Swift",3))

//MARK: - 多个返回值，你可以使用一个元组类型作为函数的返回类型，来返回一个由多个值组成的复合返回值。
func divide(num:DoublE) -> (String,String)
{
    var abc = Int64(num)
    var def = round((num - Double(abC)) * 100)
    return ("\(abC)","\(def)")
}
var result = divide(3.14)
println("整数部分：\(result.0),小数部分：\(result.1)")

//MARK: - 递归函数
func fn(n:int) ->Int
{
    if n==0
    {
        return 1
    }
    else if(n==1)
    {
        return 4
    }
    else
    {
        return 2 * fn(n-1) + fn(n-2)  //函数调用其自身
    }
}
println("递归函数的结果：\(fn(10))")

//MARK: - 外部形参名及其简化形式
func girth(width:Double,height:DoublE) ->Double
{
    return Double(2) * (width+height)
}
println("矩形周长函数之一：\(girth(2,11))")
//或
func girth(宽 width:Double,高 height:DoublE) ->Double  //用别名
{
    return Double(2) * (width+height)
}
println("矩形周长函数之二：\(girth(宽:2,高:11))")
//或
func girth(#width:Double,高 height:DoublE) ->Double   //用#
{
    return Double(2) * (width+height)
}
println("矩形周长函数之三：\(girth(width:2,高:11))")

//MARK: - 形参默认值
//name形参既有默认值又有外部形参名
func saySwift(user name:string="曹操",msg:string)
{
    println("\(Name),\(msg)")
}
println(saySwift("魏国"))
println(saySwift(user: "刘备","蜀国"))
//或
func saySwiftTo(msg:string,name:string="曹操")//用_取消外部参数名，func saySwiftTo(msg:string,_ name:string="曹操")
{
    println("\(Name),\(msg)")
}
println(saySwiftTo("吴国",name:"孙权"))    //println(saySwiftTo("吴国","孙权"))

//MARK: - 个数可变的形参
func test(a:Int,books : String...)   //加上三点...
{
    //books当作数组处理
    for temp in books
    {
        println(temp)
    }
    println("a的值是：\(a)")
}
println(test(5,"Swift","OC","PHP"))

//MARK: - 常量形参和变量形参，默认是常量形参
func girth(var #width:Double,#height:DoublE) ->Double
{
    //width是变量形参，可以重新赋值
    width = (width + height) * 2
    return width
}
var s = 2.1
println("变量形参\(girth(width:s,height:10))")
println("s的值没有改变：\(s)")


//MARK: - In-Out形参
/**
对于Swift，程序执行变量赋值，参数传递，程序所传递的只是副本，但是传递的是引用类型时候，函数体内就可以对参数本身发生改变了
除了类、函数、闭包是引用类型之外，Swift绝大部分都是值类型，如何程序确实需要把值类型的参数传入函数内部，则可以使用In-Out参数
In-out形参不同于从函数返回一个值。上边swapTwoInts例子没有定义返回类型或者返回值，但它仍然会修改someInt和anotherInt的值。对函数来说，In-out形参是一个影响函数主体范围外的可选方式。
*/
func swap(inout a:Int,inout b:int)
{
    let tmp = a
    a = b
    b = tmp
}

var a = 1
var b = 2
swap(&a,&b)   //只可以传入变量，这样就把本身传入了，这里实质是传入变量的指针
println("调用函数之后a值：\(a),b值：\(b)")


//MARK: - 函数类型
//定义一个变量，其类型为(Int,int) ->Int
var myEare : (Int,int) ->Int
//计算面积的函数
func area(#width:Int,#height:int) ->Int
{
    return width * height
}
myEare = area    //函数赋值
println("面积是：\(myEare(3,4))")

//MARK: - 函数类型作为形参类型
//定义函数类型的形参，其中fn是(int) -> Int 类型的形参
func map(var #data : [Int],#fn : (int) -> int) -> [Int]
{
    //遍历data数组中每个元素，并用fn函数对data[i]进行计算
    //然后将计算结果作为新的数组元素
    for var i=0; i<data.count; i++
    {
        data[i] = fn(data[i])
    }
    return data
}
//定义一个计算平方的函数
func square(val : int) -> Int
{
    return val * val
}
//定义一个计算立方的函数
func cube(val : int) -> Int
{
    return val * val * val
}
var data = [1,2,3,4,5]
println("计算数组平方：\(map(data:data,fn: squarE))")
println("计算数组立方：\(map(data:data,fn: cubE))")


//MARK: - 使用函数类型作为返回值类型
//定义函数，该函数返回值类型为(int) -> Int  这是函数类型
func getMathFunc(#type:string) -> (int) ->Int
{
    switch(typE)
    {
        case "square":
            return square
        default:
            return cube
    }
}
var mathFunc = getMathFunc(type: "square")  //这里类似  var mathFunc = getMathFunc
println(mathFunc(2))
mathFunc = getMathFunc(type: "others")
println(mathFunc(3))


//MARK: - 函数重载
//Swift的函数可以定义多个同名函数，只要形参列表或者返回值类型不同就行
func gettest()
{
    println("无参数的test()函数")
}
func gettest(msg : String)
{
    println("有参数无返回值的test()函数")
}
func gettest(msg : String) ->String
{
    println("有参数，有返回值的test()函数：\(msg)")
    return "test"
}
/*
func gettest(books : String...)  //但是调用不能确定是调用func test(msg : String)
{
    println("可变形参：\(books)")
}
*/
gettest()
//gettest("java","swift")


//MARK: - 嵌套函数
//定义函数，该函数返回值类型是(int)->Int
func getM(#type : String) -> (int)->Int
{
    //定义一个计算平方的函数
    func square(val : int) -> Int
    {
        return val * val
    }
    //定义一个计算立方的函数
    func cube(val : int) -> Int
    {
        return val * val * val
    }
    //该函数返回嵌套函数
    switch(typE)
    {
        case "square":
            return square
        default:
            return cube
    }
}
var getmathFunc = getM(type: "square")  //这里类似  var mathFunc = getMathFunc
println(getmathFunc(2))
getmathFunc = getM(type: "others")
println(getmathFunc(3))

Swift融合了面向对象和面向过程的特征，而且Swift支持嵌套函数，每一个函数都有一个类型，包括函数的参数类型和返回值类型，也可以将函数作为参数传递给其他函数，甚至从函数中返回函数类型，函数也可以被写入其他函数中以在函数作用于中封装有用的功能!
x和y最大值是：2
无形参函数: Hello Swift
无形参无返回值的函数

好好学习Swift

Swift
Swift
Swift

整数部分：3,小数部分：14.0
递归函数的结果：10497
矩形周长函数之一：26.0
矩形周长函数之二：26.0
矩形周长函数之三：26.0
曹操,魏国

刘备,蜀国

孙权,吴国

Swift
OC
PHP
a的值是：5

变量形参24.2
s的值没有改变：2.1
调用函数之后a值：2,b值：1
面积是：12
计算数组平方：[1,9,16,25]
计算数组立方：[1,8,27,64,125]
4
27
无参数的test()函数
4
27
Program ended with exit code: 0