swift基础语法(17- 内部函数,外部函数)

内部函数: 默认情况下的参数都是内部参数

外部函数: 如果有多个参数的情况, 调用者并不知道每个参数的含义,

         只能通过查看头文件的形式理解参数的含义

        那么能不能和OC一样让调用者直观的知道参数的含义呢? 使用外部参数

         外部参数只能外部用, 函数内部不能使用, 函数内部只能使用内部参数

func divisionOpertaion1(a: Double, b:Double) -> Double{
    return a / b

}

func divisionOpertaion2(dividend: Double, divisor:Double) -> Double{
    return dividend / divisor

}

func divisionOpertaion3(dividend a: Double, divisor b:Double) -> Double{
    return a / b
}

print(divisionOpertaion3(dividend: 10, divisor: 3.5))

func divisionOpertaion4(a: Double, divisor b:Double) -> Double{
    return a / b
}

print(divisionOpertaion4(10, divisor: 3.5))

输出结果:

2.85714285714286

2.85714285714286

 

 

func divisionOpertaion(dividend: Double, divisor:Double) -> Double{
    return dividend / divisor
}

print(divisionOpertaion(10, divisor: 3.5))

输出结果:2.85714285714286

 

默认参数:

可以在定义函数的时候给某个参数赋值, 当外部调用没有传递该参数时会自动使用默认值

func joinString(s1:String ,toString s2:String, jioner s3:String) ->String
{
    return s1 + s3 + s2;
}

func joinString2(s1:String ,toString

                 s2:String, jioner

                 s3:String = "❤️") ->String

{
    return s1 + s3 + s2;
}

print(joinString2("hi", toString:"beauty"))

输出结果:hi❤️beauty

 

如果指定了默认参数, 但是确没有声明外部参数时

系统会自动把内部参数名称既作为内部参数也作为外部参数名称

并且在调用时如果需要修改默认参数的值必须写上外部参数名称

func joinString3(s1:String ,toString

                 s2:String,

             jioner:String = "❤️") ->String

{
    return s1 + jioner + s2;
}

print(joinString3("hi", toString:"beauty", jioner:"🐔"))

输出结果: hi🐔beauty

 

在其它语言中默认参数智能出现在参数列表的最后面, 但是在Swift中可以出现在任何位置

func joinString4(s1:String ,

             jioner:String = "❤️",

        toString s2:String) ->String

{
    return s1 + jioner + s2;
}

print(joinString4("hi", jioner:"🐔", toString:"beauty"))

输出结果: hi🐔beauty

 

常量参数和遍历参数:

默认情况下Swift中所有函数的参数都是常量参数

如果想在函数中修改参数, 必须在参数前加上var

func swap(var a:Int, var b:Int)
{
    print("交换前 a = \(a) b = \(b)")
    let temp = a;
    a = b;
    b = temp;
    print("交换后 a = \(a) b = \(b)")

}

swap(10, b: 20)

输出结果:

交换前 a = 10 b = 20

交换后 a = 20 b = 10

 

inout参数

如果想在函数中修改外界传入的参数

可以将参数的var换成inout, 这回会传递参数本身而不是参数的值

func swap(inout a:Int, inout b:Int)
{
    let temp = a;
    a = b;
    b = temp;
}
var x1 = 10;
var y1 = 20;
print("交换前 a = \(x1) b = \(y1)")
swap(&x1, b: &y1)

print("交换后 a = \(x1) b = \(y1)")

输出结果:

交换前 a = 10 b = 20

交换后 a = 20 b = 10

 

 

变参函数

如果没有变参函数 , 并且函数的参数个数又不确定那么只能写多个方法或者用将函数参数改为集合

变参只能放到参数列表的最后一位, 变参必须指定数据类型, 变参只能是同种类型的数据

 

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

print(add(1, num2: 2, num3: 3))

输出结果:6

 

func add(nums:[Int]) -> Int
{
    var sum = 0;
    for num in nums
    {
        sum += num
    }
    return sum
}

print(add([1, 2, 3]))

输出结果:6

 

func add(nums:Int...) -> Int
{
    var sum = 0;
    for num in nums
    {
        sum += num
    }
    return sum
}

print(add(1, 2, 3))

输出结果:6

 

func add(other:Int, nums:Int...) -> Int
{
    var sum = 0;
    for num in nums
    {
        sum += num
    }
    return sum
}

print(add(99, nums: 1, 2, 3))

输出结果:6