Swift超基础语法(函数篇)

函数

定义函数的格式

• Swift中的函数与OC中的方法比较相似,其格式如下:

func 函数名(参数列表) -> 返回值类型{
代码块
return 返回值
}

• Swift中的函数相比于OC方法更为强大,我们从返回值与参数两个方面来进行举例
  • 没有参数没有返回值的函数

例:判断机型
func about() -> Void {
print("iPhone7")
}
简化:
func about() {
print("iPhone7")
}
about();  //调用函数

• 有参数没有返回值的函数

例:根据电话号码拨打电话
func callPhone(phoneNumber : String) {
print("打电话给" + phoneNumber)
}
callPhone("133")  //调用函数

• 没有参数有返回值的函数

例:读取短信息
func readMessage() -> String{
return "你好"
}
let message = readMessage()  //调用函数
print(message)  

• 有参数有返回值的函数

例:有参数有返回值的函数
func sum(num1 : Int , num2 : Int) -> Int{
return num1 + num2
}
let result = sum(20 , num2 : 10)  //调用函数
print(result)

• 有多个返回值的函数

例:判断数组中奇数,偶数的个数
let array = [12,13,14,15,16]
func getCount(nums : [Int]) ->(Int , Int){
var oddCount = 0
var evenCount = 0
for num in nums {
if num % 2 == 0{oddCount += 1}
else {evenCount += 1}
}
return (oddCount , evenCount)
}
let result = getCount(array)
result.0
result.1

函数的参数

• 外部参数与内部参数
  • 内部参数:在函数内部能看到的参数叫内部参数

sum(1,2,3)  //调用函数的时候看不到参数名称

• 外部参数:在函数外部能看到的参数叫外部参数

sum(a : 1 , b : 2 , c : 3)   //调用函数的时候能看到参数名称

• 默认情况下从第二个参数开始,所有的参数既是内部参数也是外部参数,但是第一个参数只是内部参数,不是外部参数

        func sum (a : Int ,b : Int ,c : Int) -> Int{
            return a + b + c
        }
        sum(1, b: 2, c: 3)

• 如果希望第一个参数也是外部参数,可以在标识符前加上外部参数的名称

        func sum (a a : Int ,b : Int ,c : Int) -> Int{
            return a + b + c
        }
        sum(a: 1, b: 2, c: 3)

• 如果希望所有的参数都只是内部参数,可以在从第二个参数开始的标识符前加上一个_(和空格)

        func sum (a : Int ,_ b : Int ,_ c : Int) -> Int{
            return a + b + c
        }
        sum(1, 2, 3)

• 默认参数

        func makeCoffee(coffeeName : String = "雀巢") -> Void{
            print("制作了一杯\(coffeeName)咖啡")
        }
        makeCoffee("拿铁")
        makeCoffee()

• 可变参数
  当我们不确定参数数量的时候,可以使用这种方法来定义函数

        func sum(numbers : Int...){
            var count = 0
            for number in numbers {
                count += number
            }
            print(count)
        }
        sum(12,13)  //注意:调用函数的时候,直接传入两个参数而不是数组,这就是可变参数与数组作为参数的区别

• 引用类型(指针类型参数):
  Swift中并没有指针类型,如果想进行地址传递的操作需要在形参前加上inout关键字

例:交换两个参数的值
        func swapNumber(inout number1 : Int ,inout number2 : Int){
            let temp = number1
            number1 = number2
            number2 = temp
        }
        var a = 22
        var b = 33
        swapNumber(&a, number2: &b)  //&符号是系统自动加上的

函数的类型

• 函数本身作为一个变量也是有类型的,函数的类型由其参数类型与返回值类型组成

例:(Int , Int) -> Int类型的函数
        func sum(a : Int , b : Int) -> Int{
            return a + b
        }
        func minus(a : Int , b : Int) -> Int{
            return a - b
        }

• 利用函数类型调用函数

例:书接上文的例子
        func sum(a : Int , b : Int) -> Int{
            return a + b
        }
        func minus(a : Int , b : Int) -> Int{
            return a - b
        }
        var funcName : (Int , Int) -> Int  //定义一个变量为(Int , Int) -> Int类型,用来接收函数名
        funcName = sum 
        funcName(3, 1)  //结果为4
        funcName = minus
        funcName(3, 1)  //结果为2

函数使用的拓展

• 函数作为方法的返回值
  如果有需求在不同情况下使用不同函数,那么可以使用这种方法

例:
        func countAdd(inout number : Int) {  //定义第一个函数
            while number > 0 {
                print(number)
                number -= 1
            }
        }
        func countMinus(inout number : Int) {  //定义第二个函数
            while number < 0 {
                print(number)
                number += 1
            }
        }
        
        func chooseFunc(number : Int) -> (inout Int) -> (){  //根据条件判断使用上面哪个函数
            return number > 0 ? countAdd : countMinus
        }
        var number = 13
        let funcName = chooseFunc(number)  //选择函数
        funcName(&number)  //调用函数

• 函数的嵌套使用
  不建议这样使用,影响代码可读性,扰乱代码顺序

例:
func test() {
    func demo() {
        print("demo")
    }
    print("test")
    demo()
}