知识点14:函数

清杨VIP

已于 2022-03-09 18:14:28 修改

阅读量255

点赞数

分类专栏： Swift-B 文章标签： ios swift

于 2022-03-09 17:11:27 首次发布

本文链接：https://blog.csdn.net/qq_34491373/article/details/123360517

版权

Swift-B 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

函数的定义（参数默认let）。

func play () {
    print("play")
}

play()

func getAge () -> Int {
    return 18
}

getAge()

func getDes (name:String,age:Int) -> String {
    return "\(name) age is \(age)"
}

let getDesDesValue = getDes(name: "LiSi", age: 15)

func sumValue (num1:Int,num2:Int) ->Int{
    return num1 + num2
}

let sumAndValue = sumValue(num1: 21, num2: 20)

隐式返回(如果整个函数体是一个单一表达式，那么函数隐式返回这个表达式)。

func runDes(name:String,speed:Float) -> String {
     "\(name) age is \(speed)"
}

let runDesValue = runDes(name: "ZhangSan", speed: 15)

返回元组。

func calculate(v1:Int,v2:Int) ->(sum:Int,sub:Int,average:Int){
    
    return (v1 + v2,v1 - v2,(v1 + v2)/2)
}

let calculateValue = calculate(v1: 3, v2: 4)

calculateValue.sum
calculateValue.sub
calculateValue.average

文档注释。

/// 吃水果【该方法描述一个吃水果的动作】
///
/// 具体的动作要领【是谁用了什么样的速度、吃了多少个水果】
///
/// - Parameter name:姓名
/// - Parameter number:数量
/// - Parameter speed:速度
/// - Returns 一个完整的描述
///
/// - Note:传入三个参数即可【批注】
///

func eatFruit (name:String,number:Int,speed:Float) -> String{
    
    return "\(name) eat \(number),speed is \(speed)"
}

参数标签。

func goToWork (at time:String){
    print("this time is \(time)")
}
goToWork(at: "08:00")

省略标签。

func goToSchool (_ time:String){
    print("this time is \(time)")
}
goToSchool("05:00")

默认参数值。

func checkPerson(name:String = "XXX",age:Int,job:String = "xxx公司"){
print("name = \(name) age = \(age) job = \(job)")
}
checkPerson(age: 23)
checkPerson(name: "LiSi", age: 12)
checkPerson(name: "WangWu", age: 12, job: "BeiJingGuoMei")

可变参数。

//一个函数最多只能有一个可变参数。紧跟在可变参数后面的参数不能省略参数标签。
func addValue(_ numbers:Int...) ->Int{
    var total = 0
    for num in numbers{
        total += num
    }
    return total
}
addValue(10,20,30)// 60

func parameterLab(_ numvers:Int,name:String,_ nick:String){
    "name is \(name),nick is \(nick)"
}

print 函数。

print("Test_1","Test_2","Test_1",separator: "分隔符 ",terminator: "换行符\n")
//Test_1分隔符 Test_2分隔符 Test_1换行符

输入输出参数。

//（可以用inout）定义一个输入输出函数：可以在函数内部修改外部实参数的值。
/**注意点：
 可变参数不能标记为inout。
 inout参数不能有默认值。
 inout参数的本质是地址传递。
 inout参数只能传入可以被多次赋值的值。
 */
var inoutValue:String = "inoutValue"

func changeInoutValue(_ parameter:inout String) {
    parameter += " 值已经改变了"
}

print(inoutValue)//inoutValue
changeInoutValue(&inoutValue)
print(inoutValue)//inoutValue 值已经改变了
//交换两个值 自定义
func swapValues (_ v1: inout Int,_ v2: inout Int){
    let tem = v1
    v1 = v2
    v2 = tem
}

var swapV1 = 2
var swapV2 = 3

swapValues(&swapV1, &swapV2)
print(swapV1,swapV2)//3 2

//交换两个值 系统
swap(&swapV1, &swapV2)
print(swapV1,swapV2)//2 3

函数重载。

/**
 规则：
函数名相同
参数个数不相同｜｜参数类型不相同｜｜参数标签不相同
 注意：
返回值类型与函数重载无关。
 默认参数编译不会报错。
 可变参数、省略参数标签、函数重载一起使用产生二义性编译器可能会报错。
*/
func subValue(sub1:Int,sub2:Int) ->Int{
    return sub1 - sub2
}

func subValue(sub1:Int,sub2:Int,sub3:Int) ->Int{
    return sub1 - sub2 - sub3
}// 参数个数不相同

func subValue(sub1:Int,sub2:Double) ->Double{
    return Double(sub1) - sub2
}// 参数类型不相同

func subValue(num1:Int,num2:Int) ->Int{
    return num1 - num2
}// 参数标签不相同
subValue(sub1: 4, sub2: 5)//-1
subValue(sub1: 6, sub2: 2, sub3: 2)//2
subValue(sub1: 10, sub2: 8)//2
subValue(num1: 6, num2: 7)//-1

内联函数。

/**
 
 如果开启了编译器优化（Release模式默认会开启优化：Build Settings - swift Compiler - Code Generation -Optimization Level - Debug），编译器会自动将某些函数变成内联函数。
 将函数调用展开成函数体。
 
 哪些函数不会被内联：
 函数体比较长
 包含递归调用
 包含动态派发

 */

函数类型。

//每个函数都是有类型，函数类型由形式参数类型，返回值类型组成。

func testType(){
    
}// () -> void 或者 () -> ()

func testAddType(num1:Int,num2:Int) ->Int{
    num1 + num2
}// (Int,Int) -> Int

//定义变量
var testTypeValue:(Int,Int) -> Int = testAddType
testTypeValue(2,3)//调用时不需要参数标签

//函数类型作为参数
func typeSum(num1:Int,num2:Int) ->Int{
    num1 + num2
}

func typeSub(num1:Int,num2:Int) ->Int{
    num1 - num2
}

func typeResult(_ mathFunc:(Int,Int) -> Int,_ a:Int,_ b:Int){
    
    print("mathFunc is \(mathFunc(a,b))")
}

typeResult(typeSum,1,2)//3

typeResult(typeSub, 2, 1)//1

//函数类型作为返回值
func nextFunc(_ input:Int) ->Int{
    input + 1
}

func previousFunc(_ input:Int) ->Int{
    input - 1
}

func forwardFunc(_ forward:Bool) -> (Int) ->Int{
    forward ? nextFunc : previousFunc
}

forwardFunc(true)(4)//5
forwardFunc(false)(3)//2

typealias 用来给类型起别名。

typealias Byte = Int8
typealias Short = Int16
typealias Long = Int64

typealias Date = (year:Int,moth:Int,day:Int)

func dateValue(_ date:Date){
    print(date.0)
    print(date.1)
    print(date.2)
}
dateValue((2021,9,4))

//函数起别名
func differentFunc(num1:Int,num2:Int) ->Int{
    num1 - num2
}
typealias differentTypealias = (Int,Int) ->Int

let dif:differentTypealias = differentFunc
dif(5,7)

嵌套函数。

func forwardSubFunc(_ forward:Bool) -> (Int) ->Int{
    func next(_ input:Int) ->Int{
        input + 1
    }
    func previous(_ input:Int) ->Int{
        input - 1
    }
  return forward ? next : previous
}

forwardSubFunc(true)(4)//5
forwardSubFunc(false)(3)//2

@inline

// 永远不会被内联（即使开启编译器优化）。
@inline(never) func testFunc(){
    print("Test...")
}

// 开启编译器优化后，即使代码很长也会被内联（递归调用函数、动态派发函数除外）。
@inline(__aways) func testSubFunc(){
    print("Test...")
}