swift语言学习笔记（5）

函数
func sayHello(personName : String) -> String {
let greeting = "Hello,"+personName + "!"
return greeting
}


func关键字定义一个函数名为sayHello，其中参数名为String类型的personName,
->表示返回值为Stirng类型


调用
println(sayHello("Sam"))


外部形参名，目的是命名外部参数以表明每个实参传递给函数的目的。
调用时候使用外部形参
func join(string s1 : String,toString s2 : String,withJoiner joiner:String) -> String {
return s1 + joiner + s2
}


join(string:"hello",toString:"world",withJoiner:" ")


疑问：带有外部形参，调用时一定显示吗？


如果你本身形参已经命名一个合适名字，不想命名外部形参或重复命名本地一样形参名字。可以本地形参前加#，以表示和外部形参名称一样。
func contiansCharacter(#string:String){
println(string)
}


containsCharacter(string : "to do something")


默认形参值：可以为本地形参设置默认值，调用时，可以省略该形参。
注意的是有默认的形参放在形参列表的末尾
func join(string s1:String,toString s2:String,withJoiner joiner:String = "-") -> String {
return s1 + joiner + s2
}


join(string:"hello",toString:"Sam") //hello-Sam


注意的是swift为一个带有默认值的形参自动设置外部名字（当自己没有提供名称）
func join(s1:String,s2:String,joiner:String = "--"){
println(s1+joiner+s2)
}


join("hello","Ben",joiner:" ")


可变形参 ...
如果调用函数时，输入多个一样数据类型形参，可用形参。
func sumNum(nums:Double...)->Double{
var result : Double = 0
for num in nums {
result += num
}


return result
}


sunNum(1,2,3) //6
nums是Double类型的数组，注意的是1、函数最多可以有一个可变形参；2、必须出现在形参列表最后；3、若有多个默认值的形参，还有可变形参，可变形参应放在所有默认形参之后


常量形参和变量形参
特别注意的是函数的形参默认是常量，所以函数体内修改形参的值会引发一个编译时的错误。


但是可以形参为变量，有时以避免在函数体内重复命名变量。
func addSum (var sum : Int)-> Int {
for _ in 1...3 {
sum += 1
}


return sum
}


addSum(1) //4 sum值存在函数调用周期中


In-Out形参，使用目的是正如函数体内声明变量形参，在函数调用结束时，变量形参就会结束。如果想继续获取函数调用后保存修改的形参值时，值可以命名inout形参。
注意以下几点：
1、inout形参是一个变量，如果是常量或字面量为形参，因为常量和字面量是不可修改的。
2、调用时，变量实参前添加&符号，以表明它可以被函数修改。
3、inout形参不可以有默认值，可变参数的形参也不能被标记为inout
4、标记inout参数，也不能同时被标记var或let


func swapTwoInts(inout a:Int,inout b:Int){
let temporary = a
a = b
b = temporary
}


var oneInt = 3
var twoInt = 5
swapTwoInts(&oneInt,&twoInt)
println("result is \(oneInt) and \(twoInt)") //result is 5 and 3


没有指明返回值的函数通常会返回void，在swift中相当于一个空元组，显示为()


使用函数类型


一个变量或常量赋值于函数
var mathFunction : (Int,Int) -> Int = addTwoInts
声明一个mathFunction变量为一个函数，接收两个Int类型形参，并返回Int值，
引用名为addTwoInts函数
同样可以不写冒号后类型定义，直接函数引用，swift会自动推断函数的类型


函数可以形参形式：
func printMathResult(mathFunction:(Int,Int) -> Int,a:Int){
//to do
}


可以做为返回类型的函数类型：
func chooseStepFunction(step1:Bool) -> (Int) -> Int {
//to do.. return Int类型
}


函数里面嵌套函数


闭包：可以捕获和存储其所在上下文中任意常量和变量的引用。这就是所谓的闭合并包裹着这些常量和变量


1、第一个例子
let somethingArr = ["one","two","three"]
func backward(s1 : String,s2:String) -> Boon {
return s1 > s2
}


var result = sort(somthingArr,backward)


闭包表达式
{ (parameters) -> returnType in
statements
}


注意：形参不提供默认值
上一个列子改为
result = sort(somethingArr,{ (s1:String,s2:String) -> Bool in
return s1 > s2
})


swift可以推断其参数和返回值的类型，对参数类型和返回类型省略
result = sort(names,{s1,s2 in return s1>s2 })


单行表达式闭包可以省略return
如闭包函数体只包含了一个单一表达式，返回类型正确，return可以省略
result = sort(names,{s1,s2 in s1>s2 })


swift自动为内联函数提供了参数名称简写功能，如$0，$1，$2等名字来引用的闭包的参数的值，所以闭包参数列表中省略对其的定义，对其类型进行推断，in关键字同样额可以被省略
result = sort(names,{$0>$1})


运算符函数
swift的String类型定义了关于大于号的字符串实现，符合sort函数的第二个参数需要
result = sort(names,>)


Trailing闭包
如果需要一个很长的闭包表达式作为最后一个参数传递给函数，使用trailing闭包来增强函数的可读性。调用时，其函数参数可以写在()之后，而且可以省略()。
result = sort(names){$0>$1}


闭包有捕获能力，调用函数周期已经结束，函数嵌套函数里变量或常量的值依然存在


枚举


enum Something {
case One
case Two
case Three
}


One/Two被定义为枚举成员值或成员，成员不会被赋予一个默认整数值。
enum Planet {
case Venus,Earth,Mars
}
用逗号形式命名成员，枚举推荐起单数名字


var hasSomething = Something.One
hasSomething的类型被推断当它被Something的一个可能值初始化。其后赋予其他值可以直接加.
hasSomething = .Two


枚举与switch语句
hasSomething = .Three
switch hasSomething {
case .One :
println("has one thing")
case .Two :
//to do
default :
//to do
}


关联值
enum Barcode {
case UPCA(Int,Int,Int)
case QRCode(String)
}


var productBarcode = Barcode.UPCA(8,123,8)
一个常量或变量可以存储枚举成员和其关联值
提取其关联值
switch productBarcode {
case .UPCA(let numOne,let numTwo,let check) :
//to do
case let .QRCode(productCode)
//to do
}


原始值
enum ASCIIControlCharacter : Character {
case Tab = "\t"
case LineFeed = "\n"
}


注意的是每个原始值在它的枚举声明中必须是唯一的，相同类型。当整型值被用于原始值，如其他成员没有值的时，它们会自动递增。


toRaw方法可以访问成员的原始值
fromRaw方法可以返回一个可选的枚举成员，返回可选值