标签：
1.Swfit语法中使用func关键字来申明函数
func sayHi(){ println("Hi !") }
结果显示：Hi !
2.带参数和返回值函数，参数为String，返回值为String的函数
func sayHiToPerson(personName:String) ->String{ return "Hi ! " + personName; } println(sayHiToPerson("Girl"))
结果显示：Hi ! Girl
3.外部参数名，在使用的时候会有相应的提示，若外部参数名跟局部参数一样的话只要加个#就可以了
func area(宽 a:Double , 高 b:Double) -> Double{ return a * b; } println(area(宽: 3.0, 高: 3.0)) func area(#a:Double , #b:Double) -> Double{ return a * b; } println(area(a: 3.0, b: 3.0))
结果显示：9.0
结果显示：9.0
4.可变参数，可变参数就是表示如果参数比较多的情况下可以使用 "类型..." 来表示多个参数
a.个函数只能接纳一个可变参数
b.一个可变参数必须位于函数的最后
func sum(x:Int...) -> Int{ var t:Int = 0 for v in x{ t+=v } return t } println(sum(1,2,3,4,5,6))
结果显示：21
5.默认参数，就是当参数未填入时，该参数会传入一个默认参数为ta的值
func sayWhat( who:String = "Lucy" , what:String){ println("\(who) say \(what)") } sayWhat(who: "Tom", "Hello")
结果显示：Tom say Hello
6.变量形参，默认的参数都是为常量，这里也可以定义一个变量形参
func fac(var x:Int) -> Int{ var s:Int = 1 while x > 1{ s*=x-- } return s } println(fac(5))
结果显示：120
7.In-Out形参，来交换两个数
func swap(inout a:Int , inout b:Int){ a = a^b; b = a^b; a = a^b; } var a:Int = 1 var b:Int = 3 swap(&a,&b)//传入的实际是a和b的地址 println("交换之后结果为：a=\(a) b=\(b)")
结果显示：交换之后结果为：a=3 b=1
8.元组类型，没有返回值的函数总返回Void，在swift中，Void表示一个元组，无返回值即是一个空元组
func areaWithCircum(#width:Int ,#height:Int) -> (Int , Int){ return (width*height , (width+height)<<1) } println(areaWithCircum(width: 4, height: 4))
结果显示：(16, 16)
9.函数类型，冒号后面是个函数 (Double ,Double) -> Double
a.函数类型可以定义一个常量或者变量
var areaFunc:(Double ,Double) -> Double = area println(areaFunc(3.0,3.0))
结果显示：9.0
b.函数类型可以做为参数类型
func printlnArea(area:(Double,Double)->Double,width:Double,height:Double){ println("\(area(width , height))") } printlnArea(areaFunc,3,3)
结果显示：9.0
c.函数类型做为返回类型，因为getMathFunc返回的是一个函数........这个函数的参数又是Int，所以需要传入一个参数......
当然也可以写成getMathFunc(type:"squre")(10)
func squre(a:Int) -> Int{ return a*a } func cube(a:Int) -> Int{ return a*a*a } func getMathFunc(#type:String) -> (Int) -> Int{ if type == "squre"{ return squre } else{ return cube } } var mathFunc = getMathFunc(type:"squre") println(mathFunc(10))
结果显示：100
10.函数嵌套，函数嵌套就是一个函数中包含另一个函数
func getArea(type:String) -> (Int) -> Int{ func squre(a:Int) -> Int{ return a * a } func cube(a:Int) -> Int{ return a * a * a } switch type{ case "squre": return squre default: return cube } } var getAreaInstance = getArea("squre") println(getAreaInstance(4))
结果显示：16
在getArea中的squre函数离开getArea就会被销毁，所以squre和cube的函数名没有任何的意义！所以可以使用闭包来简化嵌套函数的写法～
//闭包表达式
//{
// (形参列表) -> 返回值类型 in
// 可执行表达式
//}
func getArea1(type:String) -> (Int) -> Int{ switch type{ case "squre":return { (Int) -> Int in return a * a } default: return{ (Int) -> Int in return a * a * a } } }
仔细观察上面的代码，其实就是 " { xxx in xxx } " 的形式， 前面的xxx 就是" 参数列表 -> 返回类型 " ，后面的xxx 就是表达式...
另外~swift闭包可以通过上下文分析出参数列表，参数列表可以使用$0$1....$n这种方式表示。于是新的写法又出现了~
var result: Int = { var result = 1 for i in 1...$1{ result *= $0 } return result }(3 , 4) println(result)
结果显示：81
11.尾随闭包，指函数的参数类型为闭包类型
func someFunction (num : Int , fn: (Int)-> (Int)){ //执行代码 println(num * fn(10)) } someFunction(20,{ $0 * $0 })
结果显示：2000
捕获上下文中的变量或者常量，总之闭包这个东西很灵活！慢慢分析都是能够弄清楚的～
func makeArr (ele: String) -> ()->[String]{ var arr : [String] = [] func addElement() -> [String]{ arr.append(ele) return arr } return addElement } println(makeArr("Lucy")())
结果显示：[Lucy]
标签：
原文地址：http://www.cnblogs.com/chenjianxiang/p/4491318.html
