Swift 函数的理解

Swift.png

函数的简单说明

函数是一段完成特定任务的独立代码片段。
在定义一个函数时，有多个或者一个数据类型的值，作为函数的输入，成为参数
在一定某个类型的值作为返回值的时候，成为返回类型
以func作为前缀，指定函数的返回类型时，用返回箭头-> 后跟返回类型的名称的方式表示

//表示如下:
func 函数名(参数1:参数类型，参数2:参数类型，参数3:参数类型...) -> 返回值类型 {
    代码块
    return 返回值
}

注意: 函数的参数默认是 let类型，不可以修改的，如果想要修改，必须使用inout关键字就是后面说的 引用类型指针传递

函数参数与返回值

无参数无返回值的函数

func hanshu() -> Void {
    
    print("没有参数，没有返回值");
}

hanshu();
//打印结果: 没有参数，没有返回值

//简写的 没有返回值的话  直接简写

func hanshu(){
    
    print("没有参数，没有返回值");
}

hanshu();

//注意：严格上来说，虽然没有返回值被定义，hanshu() 函数依然返回了值。没有定义返回类型的函数会返回一 个特殊的 Void 值。它其实是一个空的元组(tuple)，没有任何元素，可以写成()。

无参数有返回值的函数

func sayHello() ->String {
    
    return "hello 你好";
}

let hello = sayHello();
print(hello);
//打印结果: hello 你好

有参数没有返回值

//name:参数名 String:参数类型
func personName(name:String) {
    
    print("我是\(name),哈哈");
}

personName(name: "CC");

//打印结果：我是CC,哈哈

有参数有返回值，多个参数用，分开

func sum(num1:Int,num2:Int,num3:Int) -> Int {
    
    return  num1+num2 + num3;
}

let numSum = sum(num1: 10, num2: 20, num3: 30);
print(numSum);

//打印结果：60

返回一组数据的函数多重返回值函数

//元祖 是保存一组数据的，这个函数 返回值是一个  元祖
func tulpNum(PersonName:String,PersonAge:Int,PersonSex:String) -> (name:String,age:Int,sex:String){
    
    
    return (PersonName,PersonAge,PersonSex);
}


let tulp =  tulpNum(PersonName: "CC", PersonAge: 20, PersonSex: "男");
tulp.name;
//打印是 “CC

//参数是数组 返回是元祖
 func minMax(array: [Int]) -> (min: Int, max: Int) {
     var currentMin = array[0]
     var currentMax = array[0]
     for value in array[1..<array.count] {
         if value < currentMin {
             currentMin = value
         } else if value > currentMax {
             currentMax = value
} }
     return (currentMin, currentMax)
 }


let arrayTulp = minMax(array: [1,2,3,10,5,9]);

print(arrayTulp.min);
print(arrayTulp.max);
//打印结果是 ： min是:1
              max是：10

函数`参数标签`和`参数名称`

指定参数标签
- 可以在函数名称前指定它的参数标签，中间以空格分隔

func someFunction(argumentLabel  parameterName: Int) { 
// 在函数体内，   parameterName 代表参数值
}

//  from 参数标签
func greet(person: String, from hometown: String) -> String {
    return "Hello \(person)!  Glad you could visit from \(hometown)."
}
print(greet(person: "Bill", from: "Cupertino"))
// 打印 "Hello Bill! Glad you could visit from Cupertino."

忽略参数标签
- 不希望为某个参数添加一个标签，可以使用一个下划线( _ )来代替一个明确的参数标签。

func someFunction(_ firstParameterName: Int, secondParameterName: Int) {
// 在函数体内，firstParameterName 和 secondParameterName 代表参数中的第一个和第二个参数值
}
someFunction(1, secondParameterName: 2)

默认参数
- 某些情况,如果没有传入具体的参数,可以使用默认参数

func makecoffee(type :String = "卡布奇诺") -> String {
    return "制作一杯\(type)咖啡。"
}

let coffee1 = makecoffee("拿铁")
// "制作一杯拿铁咖啡。"
let coffee2 = makecoffee()
// 打印："制作一杯卡布奇诺咖啡。

可变参数
- swift中函数的参数个数可以变化，它可以接受不确定数量的输入类型参数
- 它们必须具有相同的类型
- 我们可以通过在参数类型名后面加入（...）的方式来指示这是可变参数

注意:一个函数，最多只能有一个可变参数，紧跟在可变参数后面的参数不能省略参数标签

func sum(numbers:Double...) -> Double {
    var total: Double = 0
    for number in numbers {
        total += number
    }
    return total
}

sum(100.0, 20, 30)
sum(30, 80)
//注意： 一个函数最多只能拥有一个可变参数。

引用类型(指针的传递)
- 默认情况下,函数的参数是值传递.如果想改变外面的变量,则需要传递变量的地址
- 必须是变量,因为需要在内部改变其值
- Swift提供的inout关键字就可以实现

 // 函数一:值传递
  func swap(var a : Int, var b : Int) {
    let temp = a;
    a = b;
    b = temp
   print("a:\(a), b:\(b)")
  }
   var a = 10
  var b = 20
  swap(a, b: b)
  print("a:\(a), b:\(b)")


  // 函数二:指针的传递
  func swap1(a:inout  Int, inout b : Int) {
  let temp = a
    a = b
    b = temp
    print("a:\(a), b:\(b)")
}

  swap1(&a, b: &b)
  print("a:\(a), b:\(b)")

函数的类型

// 函数类型 (Int, Int, Int) -> Int

//函数类型： 参数类型 和返回值类型 组成
func sum(num1:Int,num2:Int,num3:Int) -> Int {

    return  num1+num2 + num3;
}


//函数类型作为参数
func exen(n1:Int,n2:Int,n3:Int,fun:(Int,Int,Int) -> Int) -> Void{
    
    let result = fun(n1,n2,n3);
    print(result);
    
}

exen(n1: 10, n2: 10, n3:30,fun: sum);


//函数类型作为返回值


func getFunc() -> (Int,Int,Int) -> Int{
    return sum;
}
let value1 = getFunc();
value1(20,30,20);

//打印： 70

//函数类型 作为 类的属性




//编辑器根据
 1.函数的名称分别函数
 2.根据外部参数名称 分别函数
3.根据 参数类型 + 返回值类型 = 函数类型 来区别

函数重载

函数名相同
参数个数不同 || 参数不同 || 参数标签不同

//函数名相同  参数标签不同
func f1(v1:Int,v2:Int){
    print(v1 + v2);
}

func f1(v3:Int,v4:Int){
    print(v3 + v4);
}

内联函数

内联函数: 在函数调用的时候，把其展开成函数体，直接执行
以下函数是不会内联的
- 函数体过长
- 包含递归函数
- 包含动态派发

在Swift中的项目中，如果在打包函数或者调试中使用Release模式,

image.png

Swift 函数的理解

函数的简单说明

函数参数与返回值

函数参数标签和参数名称

函数的类型

函数重载

内联函数

推荐阅读更多精彩内容

函数`参数标签`和`参数名称`