函数

/*

函数分为函数名，参数，返回值，执行代码块四部分

有返回值函数可以作为一个值直接在print里输出

*/

//函数定义

func max(a:Int, b:Int, c:Int) -> Int

{

return 1

}

max(1, b: 2, c: 3)

func firstMethod(str:String) ->String

{

return "123"

}

print(firstMethod("123"))

//没有返回值的函数

func noReturn(str:String)

{

print("no return")

}

//多个返回值的函数

func mutableReturn(str:String) ->(String, String)

{

return ("1", "2")

}

func mutableReturnWithName() ->(height:Int, weight:Int)

{

return (1, 2)

}

var man = mutableReturnWithName()

print(man.height)

//函数调用本身  也就是递归

func doAgain(num:Int) -> String

{

if num > 5{

print("000")

return "\(doAgain(num - 1))"

}else{

return "fff"

}

}

print(doAgain(10))

/*

递归是非常有用的，例如程序希望遍历某个路径下的所有文件，但这个路径下的文件夹的深度是未知的，那就可以使用递归来实现这个需求。系统可以设定一个函数，改函数接受一个文件路径作为参数，该参数可遍历出当前路径下的所有文件和文件路径--该函数再次调用函数本身来处理该路径下的所有文件路径

*/

/*

函数的参数

第一个参数如果不写外部参数，是不会显示外部参数的，第二个和之后的参数如果不写外部参数，会自动默认外部参数和内部参数同名

也就是说，除了第一个参数，其他的参数就算不设置外部参数也会有外部参数

*/

//拥有外部参数名的函数

func haveWaiName(wainame neiname:String) ->String

{

print(neiname)

return "\(neiname)"

}

print(haveWaiName(wainame: "name"))

//外部形参名和内部形参名一样的函数

func havesameName(name name:String) ->String

{

return name

}

print(havesameName(name: "sarah"))

//只有一部分形参有外部形参名的函数

func justSomehavename(name name:String, years:Int) -> (String, Int)

{

return (name, years)

}

print(justSomehavename(name: "marry", years: 10).0)

//形参有默认值的函数 一般将带有默认值的形参放在最后面，下面这个并不是一个好的编程习惯

func valueAlready(user name:String = "marry", msg:String)

{

print("\(name),\(msg)")

}

valueAlready(msg: "hi")

valueAlready(user: "tom", msg: "hi")

//参数个数可变的函数

func varibleValue(a:Int, books:String..., name:String)

{

for tmp in books

{

print(tmp)

}

}

varibleValue(3, books: "java","swift", name: "string")

/*

数量可变的参数的本质是一个数组参数，在执行代码块中当做一个数组来使用

*/

/*

函数中的形参默认是常量，如果想要变量的形参，需要自己声明

*/

func mutableNum(var name:String) ->String

{

name = name + "sss"

return name

}

print(mutableNum("mother"))

/*

在函数中，传入的参数如果是值类型，则传进去的是该值的副本，在函数中不会对原来的值产生影响

如果想要在函数中对该值进行改变，可以使用inout标签来标注

*/

func inoutFunc(inout age:Int) ->Int

{

age = age + 1

return age

}

var age = 5

print(age)//5

print(inoutFunc(&age))//6

print(age)//6

/*

当参数是引用类型的时候，程序会赋值引用的副本，不会复制该引用指向的对象

所以，当参数是引用类型的时候，即使不适用inout标签，该值仍然会在函数中被修改

但是，如果在函数中将引用类型置为空，只会切断副本和指向对象之间的联系，在函数之外，该值仍然不为空

*/

class DataWrap

{

var a:Int = 0

var b:Int = 0

}

func swap(var dw:DataWrap!)

{

var tmp = dw.a

dw.a = dw.b

dw.b = tmp

tmp = 0

dw = nil

}

var wp:DataWrap! = DataWrap()

print(wp)

swap(wp)

print(wp)//wp没有被置为空，但是如果使用了inout标签，这里就会出错

//定义一个函数变量

var myfun : (Int, Int) ->Int //这里最好不要给参数命名，虽然也可以命名，但是在使用的时候系统不会提示

var test : (String) ->Void

func pow(base base:Int, exponent:Int) ->Int

{

var result = 1

for _ in 1...exponent

{

result *= base

}

return result

}

//将pow函数赋值给mufun，则myfun可以当成pow使用

myfun = pow

print(myfun(3,4))

/*

只要被赋值的函数类型与myfun的变量类型一致，程序就可以赋值成功

通过使用函数类型的变量，可以让myfun在不同的时间指向不同的函数，从而让程序更加灵活。

*/

//其中一个参数是函数的函数

func map(var data data:[Int],fn:(Int) ->Int) ->[Int]

{

for var i = 0, len = data.count; i<len ;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]

print(map(data: data, fn: square))

print(map(data: data, fn: cube))

//这种方式可以动态的改变一个函数中的部分代码块，类似于c中的函数指针

//返回值为函数的函数

func getMathFunc(type type:String) -> (Int) ->Int

{

switch(type)

{

case "square":

return square

default:

return cube

}

}

var mathFunc = getMathFunc(type: "cube")

print(mathFunc(5))

/*

函数重载

函数名相同，但是参数个数不同或外部参数名称不同或返回值不同

这种情况就是重载

*/

/*

嵌套函数

在swift中，函数和类享有同样的级别，函数可以直接声明在文件里，而不用单独声明在一个类里

所以，函数可以当成变量被引用，被返回，在函数中声明函数

*/

func getMathFunc2(type 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

}

}

闭包

//本质是功能更灵活的代码块，可以直接作为返回值被返回

//在闭包里不要给参数写外部参数名，因为Xcode不会提示，还要自己写，很麻烦

var square3 = {

(val:Int) -> Int in

return val*val

}

print(square3(5))

//在闭包的后面添加圆括号来调用闭包

var resultt2 = {

(base:Int,exponent:Int) -> Int in

var result = 1

for _ in 1...exponent

{

result *= base

}

return result

}(3, 4)

print(resultt2)

//省略形参类型，返回值类型的闭包

var square4:(Int) ->Int = {(val) in return val*val}

//省略了参数类型，参数列表的那个圆括号也可以省略

var square6:(Int) ->Int = {val in return val*val}

print(square6(5))

var result3:Int = {base, exponent in

var result = 1

for _ in 1...exponent

{

result *= base

}

return result

}(4, 3)//因为这个地方有声明int类型的变量，所以不用指定返回值类型

//上面两个闭包因为有声明闭包类型变量，所以也可以不声明返回值

//省略return

//如果闭包表达式的执行体只有一行代码，而且这行代码的返回值将作为闭包表达式的返回值，那么swift允许省略return关键字

var square7:(Int) ->Int = {val in val*val}

var square8 = {(val:Int) -> Int in val*val*val}

print(square7(3))

print(square8(3))

//省略形参名

var square9:(Int) ->Int = {$0 * $0}

var result4:Int = {

var result = 1

for _ in 1...$0

{

result *= $1

}

return result

}(3, 4)

//尾随闭包

//当函数的最后一个参数是一个函数类型的时候，可以用闭包来进行传参，然后把小括号放在闭包前面，把闭包给单独放置在外面

func map2(var data data:[Int], fn:(Int) -> Int) -> [Int]

{

for var i = 0, len = data.count; i<len; i++

{

data[i] = fn(data[i])

}

return data

}

var data2 = [3, 4, 5, 6, 7]

print("原数据\(data2)")//"原数据[3, 4, 5, 6, 7]\n"

var rvt1 = map2(data: data2){$0 * $0}

var rvt3 = map2(data: data2){

var result = 1

for index in 2...$0

{

result *= index

}

return result

}

//如果调用函数时只需要闭包表达式一个参数，那么使用尾随闭包时，swift甚至允许程序省略调用函数的圆括号

//闭包可以捕获上下文中的变量和常量

//每个闭包都会持有一个它所捕获的变量的副本，所以，闭包执行与原来所在的函数并没有联系

//闭包是引用类型，所以即使是声明成常量也可以改变内部值

func makeArray(ele:String) -> () ->[String]

{

var arr:[String] = []

func addElement() ->[String]

{

arr.append(ele)

return arr

}

return addElement

}

let add1 = makeArray("sun")

print(add1())

print(add1())

let add2 = makeArray("zhu")

print(add2())

print(add2())