函数的基本构造
基本结构
func 函数名 (形参名:形参类型) ->返回值 {实现代码}
如果没有参数,那么也必须把参数的括号带上
如果有多个形参,那么必须以逗号 , 隔开
如果没有返回值,那么可以省略 也可以以->Void 和 () 代替
你可以在形名前指定外部参数名,中间以空格分隔.
注意: 如果你提供了外部参数名,那么函数在被调用时,必须使用外部参数名。
第一个参数默认忽略其外部参数名称,明确写下划线是多余的
如果你不想为第二个及后续的参数设置参数名,用一个下划线(_)代替一个明确地参数名.
func someFunction(firstParameterName: Int, _ secondParameterName: Int) {
}
someFunction(, )
函数的基本类型
有参数有返回值函数
func 函数名 (形参名:形参类型) ->返回值 {实现代码}
func myName(name:String,age:Int) ->String {
return (name + "\(age)")
}
调用定义好的函数
let nema = myName("xiaoming", age: )
print(nema)
func 函数名 (外部参数名 形参名:形参类型) ->返回值 {实现代码}
func myName1(na name:String,num age:Int) ->String {
return (name + "\(age)")
}
调用定义好的函数
let nema1 = myName1(na: "xiaohong", num: ) print(nema1)
无参数 有返回值 函数
func 函数名() ->返回值 !哪怕函数没有参数 也一样要加()
func myNum() ->String{
return "无参数 有返回值"
}
let num = myNum()
print(num)
无参数无返回值函数
func 函数名() !返回值可以省略
func myReturn(){
print("无参数无返回值")
}
myReturn()
->()来标识无返回值
func myRetu()->(){
print("无参无返回值")
}
myRetu()
->Void来标识无返回值
func myRetu1()->Void{
print("无参无返回值")
}
myRetu1()
有参数 无返回值函数
func 函数名(形参:形参类型)
func myPargam(name:String,age:Int){
print(name + "\(age)")
}
myPargam("xiaowang", age: )
可变参数
最多可以有一个可变参数函数,和它必须出现在参数列表中,为了避免歧义在调用函数有多个参数。
如果 你的函数有一个或多个参数有默认值,还有一个可变的参数,将可变参写在参数列表的最后。
func arithmeticMean(numbers: Double...) -> Double {
var total: Double =
for number in numbers {
total += number }
print(numbers)
return total / Double(numbers.count)
}
let dou = arithmeticMean(,,,)
print(dou)
通过在参数名前加关键字 var 来定义变量参数:
对变量参数所进行的修改在函数调用结束后便消失了,并且对于函数体外是不可见的。变量参数仅仅存 在于函数调用的生命周期中。
func alignRight(var string: String, totalLength: Int, pad: Character) -> String {
let amountToPad = totalLength - string.characters.count
if amountToPad < {
return string
}
let padString = String(pad)
for _ in ...amountToPad {
string = padString + string
}
return string
}
let originalString = "hello"
let paddedString = alignRight(originalString, totalLength: , pad: "-")
输入输出参数
/*
*你只能将变量作为输入输出参数
*当 传入的参数作为输入输出参数时,需要在参数前加 & 符,表示这个值可以被函数修改。
*/
func swapTwoInts(inout a: Int, inout _ b: Int) {
let temporaryA = a
a = b
b = temporaryA
}
var someInt =
var anotherInt =
swapTwoInts(&someInt, &anotherInt)
print("someInt is now \(someInt), and anotherInt is now \(anotherInt)")
输入输出参数和返回值是不一样的。上面的 swapTwoInts 函数并没有定义任何返回值,但仍然修改了 someInt 和 anotherInt 的值。输入输出参数是函数对函数体外产生影响的另一种方式。
默认参数值
你可以在函数体中为每个参数定义 默认值(Deafult Values) 。当默认值被定义后,调用这个函数时可以忽略这个 参数。
func someFunction(parameterWithDefault: Int = ) {
// function body goes here
// if no arguments are passed to the function call,
// value of parameterWithDefault is 42
print(parameterWithDefault)
}
someFunction()
// parameterWithDefault is 6
someFunction()
// parameterWithDefault is 12
使用函数类型
在 Swift 中,使用函数类型就像使用其他类型一样。例如,你可以定义一个类型为函数的常量或变量,并将函数 赋值给它:
addTwoInts 和 mathFunction 有同样的类型,所以这个赋值过程在 Swift 类型检查中是允许的。
func addTwoInts(a:Int,b:Int) ->Int{
return a+b
}
var mathFunction: (Int, Int) -> Int = addTwoInts
let a = mathFunction(,)
print("Result:\(a) \(mathFunction(2, 3))")
作为参数的函数
在 Swift 中，函数可以被用来当做变量传递。比如，一个函数可以含有一个函数类型的参数
func luckyNumberForName(name: String,lotteryHandl lotteryHandler: (String, Int) -> String) -> String {
let luckyNumber = Int(arc4random() % )
return lotteryHandler(name, luckyNumber)
}
func defaultLotteryHandler(name: String, luckyNumber: Int) -> String {
return "\(name), your lucky number is \(luckyNumber)"
}
luckyNumberForName("Mr. Roboto", lotteryHandl: defaultLotteryHandler)
// Mr. Roboto, your lucky number is 38
注意下只有函数的引用被传入 — 在本例中是 defaultLotteryHandler。这个函数之后是否执行是由接收的函数决定。
实例方法也可以用类似的方法传入：
func luckyNumberForName(name: String, lotteryHandl lotteryHandler: (String, Int) -> String) -> String {
let luckyNumber = Int(arc4random() % )
return lotteryHandler(name, luckyNumber)
}
class FunLottery {
func defaultLotteryHandler(name: String, luckyNumber: Int) -> String {
return "\(name), your lucky number is \(luckyNumber)"
}
}
let funLottery = FunLottery()
luckyNumberForName("Mr. Roboto", lotteryHandl: funLottery.defaultLotteryHandler)
// Mr. Roboto, your lucky number is 38
为了让你的函数定义更具可读性，可以考虑为你函数的类型创建别名 (类似于 Objective-C 中的 typedef)：
typealias lotteryOutputHandler = (String, Int) -> String
func luckyNumberForName(name: String, lotteryHandl lotteryHandler: lotteryOutputHandler) -> String {
let luckyNumber = Int(arc4random() % )
return lotteryHandler(name, luckyNumber)
}
你也可以使用不包含参数名的函数 (类似于 Objective-C 中的 blocks)：
func luckyNumberForName(name: String, lotteryHandl lotteryHandler: (String, Int) -> String) -> String {
let luckyNumber = Int(arc4random() % )
return lotteryHandler(name, luckyNumber)
}
luckyNumberForName("Mr. Roboto", lotteryHandl: {name, number in
return "\(name)'s' lucky number is \(number)"
})
// Mr. Roboto's lucky number is 74
在 Objective-C 中，使用 blocks 作为参数是异步操作是操作结束时的回调和错误处理的常见方式，这一方式在 Swift 中得到了很好的延续。