1.函数的定义与调用
-
定义
func say(name:String) -> String{return "hello", + name + "!" } -
调用
print(say("wanwan")) //hello,wanwan! -
无参函数
func say() -> String{ return "hello,wanwan" } print(say()) //hello,wanwan -
多参函数
func say(name:String，isgirl:Bool) -> String{
if isgirl{
return "hello", + name + "!"
}else{
return "hello"
}} * 调用 print(say("wanwan",ture)) //hello,wanwan! -
无返回值函数
func say(name:String){ print("hello,wanwan") } say("wanwan") 因为这个函数不需要返回值，所以这个函数的定义中没有返回箭头（->）和返回类型。 -
当一个函数调用另一个函数的时候，该函数返回值可以忽略
func inputsome(name:String) -> Int { print("name\(name)") return name.characters.count } func lala(name: String) { inputsome(name) } -
多重返回值
func minmax(array: [Int]) -> (min: Int, max: Int) { var currenmin = array[0] var currenmax = array[0] for value in array[1..<array.count]{ if value < currenmin{ currenmin = value }else if value > currenmax{ currenmax = value } } return (currenmin,currenmax) } minmax([1,2,3,4,5,6,7,8,8]) -
函数参数名称
func come(first:String,last:String) { print("\(first)\(last)") } come("wanwan", last: "heihei")
函数有内部参数名和外部参数名，外部参数省略第一个参数名，第二个及后面的都需要带上参数名。
-
指定外部参数名
可以在局部参数名前指定外部参数名，中间空哥分开 func some(outname inname:String) { } some(outname: "wanwan") func sayHello(to person: String, and anotherPerson: String) -> String { return "Hello \(person) and \(anotherPerson)!" } print(sayHello(to: "Bill", and: "Ted")) // prints "Hello Bill and Ted!" -
忽略外部参数名
func come(firat:Int , last : Int){ } come(1,2) -
默认参数
func come(firat:Int ＝12){ print(firat) } come() //12 -
可变参数
func some(number:Double...) -> Double { var total:Double = 0 for num in number { total += num } return total } some(1,2,3) -
输入输出参数
函数参数默认是常量，不能在函数内部修改参数值，如果想修改，并且函数调用结束后这些修改仍然存在，就要定义为输入输出参数：inoutfunc swapTwoInts(inout a: Int, inout _ b: Int) { let temporaryA = a a = b b = temporaryA } var someInt = 3 var anotherInt = 107 swapTwoInts(&someInt, &anotherInt) print("someInt is now \(someInt), and anotherInt is now \(anotherInt)") // prints "someInt is now 107, and anotherInt is now 3"
注意 参数名必须用
inout标记 调用必须用指针&
2.函数类型
每个函数都有种特定的函数类型，由函数的参数类型和返回类型组成。
func addTwoInts(a: Int, _ b: Int) -> Int {
return a + b
}
func multiplyTwoInts(a: Int, _ b: Int) -> Int {
return a * b
}
这两个函数的类型是 (Int, Int) -> Int，可以解读为“这个函数类型有两个 Int 型的参数并返回一个 Int 型的值。”
3.使用函数类型
-
定义一个
有两个Int类型的参数并返回一个Int型的值的函数变量，并将addTwoInts函数赋值给它
func addTwoInts(a: Int, _ b: Int) -> Int {
return a + b
}var mathadd: (Int, Int) -> Int = addTwoInts 现在可以用 `mathadd`调用被赋值的函数 mathadd(1,4) //5 -
相同类型的不同函数可以赋值给同一变量
func multiplyTwoInts(a: Int, _ b: Int) -> Int { return a * b } mathadd = multiplyTwoInts marhadd(2,3) //6
4.函数类型作为参数类型
函数作为参数类型
定义一个`aa`类型的函数，再定义一个包含`aa`类型函数的函数，调用的时候传入`aa`类型的函数。
5.函数类型作为返回类型
先定义几个函数,这两个函数类型都是 (Int) -> Int
func stepfor(input:Int) -> Int {
return input+1
}
func stepback(input:Int) -> Int {
return input-1
}
下面这个函数的返回类型为(Int) -> Int
func choose(back:Bool) -> (Int)->Int {
return back ? stepfor : stepback
}
调用：
var value = 3
let over = choose(value >0) //这时候的返回结果应该是`stepfor`这个函数
over(4) // 给这个函数赋值
print(over(4)) //打印出来为5
上述步骤其实可以简化
let over = choose(value>0)(4) //5
6.嵌套函数
全局函数可以被外界访问，嵌套函数只能被它的外围函数调用，上面的例子可以改写为嵌套函数：
func choose(back:Bool) -> (Int)->Int {
func stepfor(input:Int) -> Int { return input+1}
func stepback(input:Int) -> Int {return input-1}
return back ? stepfor : stepback
}
调用：
var value = 3
let over = choose(value>0)(4) //5