func sayHI(){
print("sayHI")
}
sayHI()
func sayHI(name:String) {
print("hello " + name)
}
sayHI(name: "lily")
func sayHI() -> String {
return "sayHI"
}
let str = sayHI()
func sayHI(name:String,age:Int) -> String {
return "我是\(name),今年\(age)岁"
}
let str = sayHI(name: "lily", age: 12)
func sayHI(nameLabel name:String,ageLabel age:Int) -> String {
return "我是\(name),今年\(age)岁"
}
func sayHello(_ name:String,ageLabel age:Int) {
print("我是\(name),今年\(age)岁")
}
sayHello("lily", ageLabel: 12)
func sayHello(nameLabel name:String,ageLabel age:Int = 12) {
print("我是\(name),今年\(age)岁")
}
sayHello(nameLabel: "lily")
func message(_ str:String ...) {
print(str[0] + " " + str[1])
}
message("hello","world")
inout
关键字func exchangeValue(valueA value1:inout Int,valueB value2:inout Int) {
let temp = value1
value1 = value2
value2 = temp
}
var a = 3
var b = 5
exchangeValue(valueA: &a, valueB: &b)
print("\(a),\(b)") //5,3
func add(_ a:Int, _ b:Int) -> Int {
return a + b
}
这个函数的类型是(Int, Int) -> Int
,可以理解为“这个函数类型有俩个Int型的参数并返回一个Int型的值”
func sayHI(){
print("sayHI")
}
这个函数的类型是() -> void
,可以理解为“这个函数类型没有参数,返回Void类型的函数”
func add(_ a:Int, _ b:Int) -> Int {
return a + b
}
//定义一个叫做 function 的变量,类型是‘一个有两个 Int 型的参数并返回一个 Int 型的值的函数’,并让这个新变量指向 add 函数
var function :(Int,Int)-> Int = add
print(function(2,3))
showResult(_:_:_:)
函数,它有三个参数:第一个参数叫fun
,类型是 (Int, Int) -> Int
,你可以传入任何这种类型的函数;第二个和第三个参数叫 a
和 b
,它们的类型都是 Int
,这两个值作为已给出的函数的输入值func showResult(_ fun:(Int,Int)->Int,_ a:Int,_ b:Int) {
print(fun(a,b))
}
func add(_ a:Int, _ b:Int) -> Int {
return a + b
}
showResult(add(_:_:), 3, 2)
showResult(_:_:_:)
函数的作用就是输出另一个适当类型的数学函数的调用结果。它不关心传入函数是如何实现的,只关心传入的函数是不是一个正确的类型。这使得 showResult(_:_:_:)
能以一种类型安全(type-safe)的方式将一部分功能转给调用者实现。
sayHI(_:)
和 sayHello(_:)
,这两个函数的类型都是 (String) -> String
。之后在定义一个showResult(:)
的函数,它的返回类型是(String) -> String
类型的函数。showResult(backward:)
根据布尔值来返回(String) -> String
类型函数func sayHI(_ name:String) -> String {
return "HI \(name)"
}
func sayHello(_ name:String) -> String {
return "Hello \(name)"
}
func showResult(_ backward: Bool) -> (String) -> String {
return backward ? sayHI : sayHello
}
let show = showResult(true)
print(show("world")) //HI world
把函数定义在别的函数体中,称作嵌套函数
func showResult(_ backward: Bool) -> (String) -> String {
func sayHI(_ name:String) -> String {
return "HI \(name)"
}
func sayHello(_ name:String) -> String {
return "Hello \(name)"
}
return backward ? sayHI : sayHello
}
let show = showResult(true)
print(show("world")) //HI world