函数定义
// 有返回值参数
func pi() -> Double{
return 3.14;
}
func sum(v1: Int, v2: Int) -> Int{
return v1 + v2
}
// 无返回值参数
func sayHello() -> Void{
print("Hello")
}
func sayHello() -> (){
print("Hello")
}
func sayHello(){
print("Hello")
}
形参默认是let
,也只能是let
隐式返回(Implicit Return)
如果整体函数是一个单一表达式,那么函数会隐试返回这个表达式,不用显示使用return
func sum(v1: Int, v2: Int) -> Int{
v1 + v2
}
返回元组:实现多返回值
func calculate(v1: Int ,v2: Int) -> (sum: Int, difference: Int, average: Int){
let sum = v1 + v2
return (sum, v1- v2, sum >> 1)
}
let result = calculate(v1: 10, v2: 20)
result.sum // 30
result.difference // -10
result.average // 15
函数的文档注释
/// 求和【概述】
///
/// 将两个整数相加【更加详细的描述】
///
/// - Parameter v1: 第一个整数
/// - Parameter v2: 第二个整数
/// - Returns:2个整数的和
///
/// - Note:传入2个整数即可【批注】
func sum(v1: Int , v2: Int) -> Int {
v1 + v2
}
参考:文档
参数标签(Argument Label)
可以修改参数标签
func goToWork(at time:String){
print("this time is \(time)")
}
goToWork(at: "10:00")
可以使用下划线_
省略参数标签
func sum(_ v1: Int ,_ v2: Int) -> Int {
v1 + v2
}
sum(1,1)
默认参数值(Default Parameter Value)
参数可以有默认值
func check(name: String = "nobody", age: Int, job: String = "none") {
print("name=\(name), age=\(age), job=\(job)")
}
check(name: "Jack", age: 20, job: "Doctor") // name=Jack, age=20, job=Doctor
check(name: "Rose", age: 18) // name=Rose, age=18, job=none
check(age: 10, job: "Batman") // name=nobody, age=10, job=Batman
check(age: 15) // name=nobody, age=15, job=none
c++的默认参数有个限制:必须从右往左设置。由于Swift
有参数标签,因此没有此类限制;
但是在省略参数标签时,需要注意避免出错
// 这里的 middle 不可以省略参数标签
func sum(_ first: Int = 10 ,middle: Int, _ last: Int = 30){}
sum(middle:20)
可变参数(Variadic Parameter)
func sum(_ numbers: Int...) -> Int{
var total
for number in numbers{
total += number
}
return total
}
sum(10,20,30,40) // 100
一个函数最多只能有一个可变参数;紧跟在可变参数后面的参数不能带省略参数标签
func test(_ numbers: Int..., string: String, _ other: String) { }
test(10, 20, 30, string: "Jack", "Rose")
Swift自带的print函数
/// - Parameters:
/// - items: Zero or more items to print.
/// - separator: A string to print between each item. The default is a single
/// space (`" "`).
/// - terminator: The string to print after all items have been printed. The
/// default is a newline (`"\n"`).
public func print(_ items: Any..., separator: String = " ", terminator: String = "\n")
print(1,2,3,4,5,separator:" *** ",terminator: " 本次打印?")
第一个参数:输入的内容,第二个参数:间隔符号内容,第三个:处理完所有字符串之后的操作,后面两个选项可以进行自定义
输入输出参数(In-Out Parameter)
可以用inout
定义一个输入输入出参数,可以再函数内部修改外部参数的值
func swapValues(_ v1: inout Int, _ v2: inout Int) {
let tmp = v1
v1 = v2
v2 = tmp
// 也可以使用元组方式交换
// (v1,v2) = (v2,v1)
}
var num1 = 10
var num2 = 20
swapValues(&num1, &num2) // num1 = 20 num2 = 10
注意
- 可变参数不能标记为
inout
inout
参数不能有默认值inout
参数只能传入可以被多次赋值的变量;不能传递具体的数值,例如:1
2
Tom
*inout
参数的本质是地址传递(引用传递)
函数重载(Function Overload)
规则:1.函数名相同;2.参数个数不同 || 参数类型不同 || 参数标签不同
func sum(v1: Int , v2: Int){
v1 + v2
}
// 参数个数不同
func sum(v1: Int, v2: Int, v3: Int){
v1 + v2 + v3
}
// 参数类型不同
func sum(v1: Int, v2: Double) -> Double {
Double(v1) + v2
}
// 参数标签不同
func sum(_ v1: Int , _ v2: Int){
v1 + v2
}
返回值类型与函数重载无关
func sum(v1: Int , v2: Int) -> Int {
v1 + v2
}
func sum(v1: Int , v2: Int){
v1 + v2
}
// ❌ Ambiguous use of 'sum(v1:v2:)'
sum(v1: 10, v2: 20)
默认参数值和函数重载一起使用产生二义性时,编译器并不会报错(在c++中会报错)
func sum(v1: Int, v2: Int) -> Int {
v1 + v2
}
func sum(v1: Int, v2: Int, v3: Int = 10) -> Int {
v1 + v2 + v3
}
// 会调用sum(v1: Int, v2: Int)
print(sum(v1: 10, v2: 20))
可变参数、省略参数标签、函数重载一起使用产生二义性时,编译器有可能会报错
func sum(v1: Int, v2: Int) -> Int {
v1 + v2
}
func sum(_ v1: Int, _ v2: Int) -> Int {
v1 + v2
}
func sum(_ numbers: Int...) -> Int {
var total = 0
for number in numbers {
total += number
}
return total
}
// ❌ Ambiguous use of 'sum'
sum(10, 20)
内联函数(Inline Function)
如果开启编译器优化(Release模式默认会开启优化),编译器会自动将某些函数变成内联函数(将函数调用展开成函数体)
不会自动内联的情况
- 函数体比较长
- 包含动态调用
- 包含动态派发
@inline
在Release
模式下,编译器已经开启优化,会自动决定哪些函数需要内联,因此没必要使用
// 永远不会被内联(即使开启了编译器优化)
@inline(never) func test() {
print("test")
}
// 开启编译器优化后,即使代码很长,也会被内联(递归调用函数、动态派发的函数除外)
@inline(__always) func test() {
print("test")
}
函数类型(Function Type)
每个函数都是有类型的,函数类型由形式参数类型
、 返回值类型
组成
// () -> Void 或者 () ->()
func test(){}
// (Int,Int) -> Int
func sum(v1: Int, v2: Int) -> Int{
v1 + v2
}
// 定义变量
var fn: (Int, Int) -> Int = sum
// 调用时不需要参数标签
fn(1,1)
函数类型作为函数参数
// 示例1
func sum(v1: Int, v2: Int) -> Int{
v1 + v2
}
func difference(v1: Int, v2: Int) -> Int{
v1 - v2
}
func printResult(_ mathFn:(Int, Int) -> Int,v1: Int, v2: Int){
print("Result \(mathFn(v1,v2))")
}
printResult(sum, v1: 10, v2: 20) // Result = 30
printResult(difference, v1: 20, v2: 10) // Result = 10
返回值是函数类型的函数,叫做高阶函数(Higher-Order Function)
//示例2
func next(_ input: Int) -> Int{
input + 1
}
func previou(_ input: Int) -> Int{
input - 1
}
func forward(_ forward: Bool) -> (Int) -> Int{
forward ? next : previou
}
forward(true)(2) // 3
forward(false)(2) // 1
typealias(给类型起别名)
typealias Byte = Int8
typealias Short = Int16
typealias Long = Int64
typealias Date = (year: Int, month: Int, day: Int)
func test(_ date: Date) {
print(date.0)
print(date.year)
}
test((2011, 9, 10))
typealias IntFn = (Int, Int) -> Int
func difference(v1: Int, v2: Int) -> Int {
v1 - v2
}
let fn: IntFn = difference
fn(20, 10) // 10
func setFn(_ fn: IntFn) { }
setFn(difference)
func getFn() -> IntFn { difference }
按照Swift标准库的定义,Void就是空元组()
public typealias Void = ()
嵌套函数(Nested Function)
将函数定义在函数内部
func forward(_ forward: Bool) -> (Int) -> Int {
func next(_ input: Int) -> Int {
input + 1
}
func previous(_ input: Int) -> Int {
input - 1
}
return forward ? next : previous
}
forward(true)(3) // 4
forward(false)(3) // 2
参考内容:
从入门到精通Swift编程