* 函数是用来完成特定任务的独立的代码块。你给一个函数起一个合适的名字，用来标识函数做什么，并且当函数需要执行的时候，这个名字会被用于“调用”函数
* 格式：
* func 函数名称(参数名:参数类型, 参数名:参数类型...) -> 函数返回值 {函数实现部分}
*没有参数没有返回值*
* 可以写为 ->Void
* 可以写为 ->()
* 可以省略
* Void 它其实是一个空的元组（tuple），没有任何元素，可以写成()
func say() -> Void{
'' print("cool")
}
say() //调用方法
func say2() -> (){
'' print("cool")
}
say2() //调用方法
func say3(){
'' print("cool")
}
say3() //调用方法
*有参数没有返回值*
* 内部参数: Swift2.0以前, 默认情况下的参数都是内部参数
* Swift2.0开始, 默认将第二个参数名称作为外部参数
* 外部参数只能外部用, 函数内部不能使用, 函数内部只能使用内部参数
* 忽略外部参数: 在内部参数前加‘ _ ’
func sum(a: Int, b: Int){
'' print(a + b)
}
sum(10, b: 20)
func summ(a: Int, _ b: Int){
'' print(a + b)
}
summ(10, 20)
// xy外部参数, ab内部参数
// Swift2.0以前可以写#
func sum2(x a: Int, y b: Int){
'' print(a + b)
}
sum2(x: 10, y: 20)
*默认参数*
* 格式: func method(parameter: Int = 0){}
* 当默认值被定义后，调用这个函数时可以忽略这个参数
* 其它语言的默认参数必须写在最后面, Swift可以写在任意位置
* 注意：
* 将带有默认值的参数放在函数参数列表的最后。这样可以保证在函数调用时，非默认参数的顺序是一致的，同时使得相同的函数在不同情况下调用时显得更为清晰。
func joinString(s1:String , jioner:String = "❤️",toString s2:String) ->String
{
'' return s1 + jioner + s2;
}
joinString("cool", jioner: "和", toString: "boy")
joinString("cool", toString: "boy")
*常量参数和变量参数（Constant and Variable Parameters)*
* 函数参数默认是常量, 在函数内部不能修改
* 如果想在函数中修改参数, 必须在参数前加上var
* 注意：
* 对变量参数所进行的修改在函数调用结束后便消失了，并且对于函数体外是不可见的。变量参数仅仅存在于函数调用的生命周期中
func swap(a:Int, b:Int)
{
'' print("交换前 a = \(a) b = \(b)")
'' let temp = a;
'' a = b; // 不能修改
'' b = temp;
'' print("交换后 a = \(a) b = \(b)")
}
func swap1(var a:Int, var b:Int)
{
'' print("交换前 a = \(a) b = \(b)")
'' let temp = a;
'' a = b; // 可以修改, 但不会影响实参
'' b = temp;
'' print("交换后 a = \(a) b = \(b)")
}
var x = 10
var y = 20
print("交换前 a = \(x) b = \(y)")
swap1(x, b: y)
print("交换后 a = \(x) b = \(y)")
*输入输出参数（In-Out Parameters*
* 变量参数，正如上面所述，仅仅能在函数体内被更改。如果你想要一个函数可以修改参数的值，并且想要在这些修改在函数调用结束后仍然存在，那么就应该把这个参数定义为输入输出参数（In-Out Parameters)
* 定义一个输入输出参数时，在参数定义前加 inout 关键字
* 注意：
* 输入输出参数不能有默认值，而且可变参数不能用 inout 标记。如果你用 inout 标记一个参数，这个参数不能被 var 或者 let 标记。
func swap2(inout a:Int, inout b:Int)
{
'' let temp = a;
'' a = b;
'' b = temp;
}
var x1 = 10;
var y1 = 20;
print("交换前 a = \(x1) b = \(y1)")
swap2(&x1, b: &y1)
print("交换后 a = \(x1) b = \(y1)")
*可变参数（Variadic Parameters*
* 一个可变参数可以接收零个或多个值
* 如果没有变参函数 , 并且函数的参数个数又不确定那么只能写多个方法或者用将函数参数改为集合
* 格式 func method(parameter: Int...){}
* 可变参数在函数中可以当做一个数组
* 注意：
* 一个函数最多只能有一个可变参数
* 变参只能是同种类型的数据
* 变参必须指定数据类型
* 如果函数有一个或多个带默认值的参数，而且还有一个可变参数，那么把可变参数放在参数表的最后
func add(nums:Int..., other:Int) -> Int
{
'' var sum = 0;
'' for num in nums
'' {
'' sum += num
'' }
'' return sum + other
}
print(add(1, 2, 3, other: 9))// 会将9传递给第一个参数, 后面的传递给nums
没有参数有返回值
func getNumer() ->Int{
'' return 998
}
print(getNumer())
有参数有返回值
func sum3(a: Int, b: Int) ->Int{
'' return a + b
}
print(sum3(10, b: 20))
嵌套函数
func showArray(array:\[Int])
{
'' // 嵌套函数
'' func printArray(arr:[Int])
'' {
'' for number in array
'' {
'' print("\(number), ")
'' }
'' }
'' printArray(array)
}
showArray(\[1, 3, 5, 7, 9])
* 函数类型（Function Types）*
* 函数类型作为参数类型（Function Types as Parameter Types）
* 函数类型作为返回类型（Function Types as Return Types）
* 嵌套函数（Nested Functions）
*提前退出*
* 像if语句一样，guard的执行取决于一个表达式的布尔值。我们可以使用guard语句来要求条件必须为真时，以执行guard语句后的代码。
* 如果guard语句的条件被满足，则在保护语句的封闭大括号结束后继续执行代码
* 任何使用了可选绑定作为条件的一部分并被分配了值的变量或常量对于剩下的保护语句出现的代码段是可用的
* 如果条件不被满足，在else分支上的代码就会被执行。
* else这个分支必须转移控制以退出guard语句出现的代码段。它可以用控制转移语句如return,break,continue或者throw做这件事
func divide(dividend: Double? , divisor: Double?) -> Double?
{
'' if dividend == .None {
'' return .None
'' }
''
'' if divisor == .None {
'' return .None
'' }
''
'' if divisor == 0 {
'' return .None
'' }
'' // 应该尽量避免使用强制解包
'' return dividend! / divisor!
}
print(divide(10, divisor: 20))
func divide2(dividend: Double?, divisor: Double?) -> Double? {
'' // 嵌套太深
'' if let dividend = dividend
'' {
'' if let divisor = divisor
'' {
'' if divisor != 0
'' {
'' return dividend / divisor
'' }
'' }
'' }
'' return .None
}
print(divide2(10, divisor: 20))
func divide3(dividend: Double?, divisor: Double?) -> Double? {
'' guard let dividend = dividend else {
'' return .None
'' }
'' guard let divisor = divisor else {
'' return .None
'' }
'' guard divisor != 0 else {
'' return .None
'' }
'' return dividend / divisor
}
print(divide3(10, divisor: 20))
