• 设为首页
  • 点击收藏
  • 手机版
    手机扫一扫访问
    迪恩网络手机版
  • 关注官方公众号
    微信扫一扫关注
    公众号

Swift学习笔记(8)--函数

原作者: [db:作者] 来自: [db:来源] 收藏 邀请

1.定义及调用

func sayHelloAgain(personName: String) -> String {
    return "Hello again, " + personName + "!"
}
println(sayHelloAgain("Anna"))  //Hello again, Anna!

  

2.函数分类

//1.普通函数(略)

//2.无参函数
func sayHelloWorld() -> String {
    return "hello, world"
}

//3.无返回值函数
func sayHelloWorld(){
    println("hello, world")
}

//4.多参数函数
func add(start: Int, end: Int) -> Int {
    return end + start
}

//5.多返回值函数
    //例子:统计一个字符串中元音辅音的数量
func count(string: String) -> (vowels: Int, consonants: Int, others: Int) {
    var vowels = 0, consonants = 0, others = 0
    for character in string {
        switch String(character).lowercaseString {
        case "a", "e", "i", "o", "u":
            ++vowels
        case "b", "c", "d", "f", "g", "h", "j", "k", "l", "m",
        "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z":
            ++consonants
        default:
            ++others
        }
    }
    return (vowels, consonants, others)
}

let total = count("some arbitrary string!")
println("\(total.vowels) vowels and \(total.consonants) consonants")    //6 vowels and 13 consonants

  

3.外部参数名

  局部参数名(local parameter name),只能在函数体中使用

  外部参数名(External Parameter Names),函数的使用者在调用函数时提供参数名字

与OC类似,swift提供了外部参数名的定义方法:

//1.显示定义外部参数名
func join(firstName s1: String,lastName s2: String, middleName s3:String) {
    println("The name is :\(s1) \(s3) \(s2)")
}

join(firstName: "Jason", lastName: "Wood", middleName: "Hasen")

//2.隐式定义外部参数名,使用 # + 参数名
func join2(#firstName: String,#lastName: String, #middleName:String) {
    println("The name is :\(firstName) \(middleName) \(lastName)")
}
join2(firstName: "Jason", lastName: "Wood", middleName: "Hasen")

  

4.默认参数值

在函数定义时可以提供一个默认的参数值

func join(string s1: String, toString s2: String, withJoiner joiner: String = "-") -> String {
    return s1 + joiner + s2
}
println(join(string: "hello", toString:"world"))    //hello-world

  

为了使定义外部参数名更加简单,当你未给带默认值的参数提供外部参数名时,Swift 会自动提供外部名字。此时外部参数名与局部名字是一样的,就像你已经在局部参数名前写了井号(#)一样。

func join(s1: String, s2: String, joiner: String = " ") -> String {
    return s1 + joiner + s2
}
println(join("hello", "world", joiner: "-"))    //hello-world

  

5.可变参数(Variadic Parameters)

一个可变参数(variadic parameter)可以接受一个或多个值。函数调用时,你可以用可变参数来传入不确定数量的输入参数。通过在变量类型名后面加入(...)的方式来定义可变参数。

注:一个函数至多能有一个可变参数,而且它必须是参数表中最后的一个。这样做是为了避免函数调用时出现歧义。

func arithmeticMean(numbers: Double...) -> Double {
    var total: Double = 0
    for number in numbers {
        total += number
    }
    return total / Double(numbers.count)
}
println("平均值为:\(arithmeticMean(1, 2, 3, 4, 5))")    //平均值为:3.0

  

6.常量参数和变量参数(Constant and Variable Parameters)

函数参数默认是常量。试图在函数体中更改参数值将会导致编译错误。这意味着你不能错误地更改参数值。

但是,有时候,如果函数中有传入参数的变量值副本将是很有用的。你可以通过指定一个或多个参数为变量参数,从而避免自己在函数中定义新的变量。变量参数不是常量,你可以在函数中把它当做新的可修改副本来使用。

通过在参数名前加关键字 var 来定义变量参数:

func changeValue(var x:Int){
    x = 12  //如果不定义var,此处语句会报错
}

//函数内部的参数变化是副本值的变化,函数外部的值不受影响
var y = 0
changeValue(y)
println(y)      //还是0

  

7.输入输出参数(In-Out Parameters)

变量参数,正如上面所述,仅仅能在函数体内被更改。如果你想要一个函数可以修改参数的值,并且想要在这些修改在函数调用结束后仍然存在,那么就应该把这个参数定义为输入输出参数(In-Out Parameters)。

定义一个输入输出参数时,在参数定义前加 inout 关键字。一个输入输出参数有传入函数的值,这个值被函数修改,然后被传出函数,替换原来的值。

你只能传入一个变量作为输入输出参数。你不能传入常量或者字面量(literal value),因为这些量是不能被修改的。当传入的参数作为输入输出参数时,需要在参数前加&符,表示这个值可以被函数修改。

注:输入输出参数不能有默认值,而且可变参数不能用 inout 标记。如果你用 inout 标记一个参数,这个参数不能被 var 或者 let 标记。

func changeValue2(inout x:Int){
    x = 12
}

var y = 0           //inout传入的参数只能是变量
changeValue2(&y)    //需要在参数前加 & 来标记是inout参数
println(y)          //此时打印出来的是修改后的值 12

  

8.函数类型(Function Types

每个函数都有种特定的函数类型,由函数的参数类型和返回类型组成。

比如下面两个函数的函数类型就是(Int, Int) -> Int, 可以读作“有两个 Int 型的参数并返回一个 Int 型的值。”

func addTwoInts(a: Int, b: Int) -> Int {
    return a + b
}
func multiplyTwoInts(a: Int, b: Int) -> Int {
    return a * b
}

而对于无参数和无返回值的函数类型为() -> (),叫“没有参数,并返回 Void 类型的函数。”。没有指定返回类型的函数总返回Void。在Swift中,Void 与空的元组是一样的。

使用举例:

func addTwoInts(a: Int, b: Int) -> Int {
    return a + b
}
func multiplyTwoInts(a: Int, b: Int) -> Int {
    return a * b
}

//定义
var mathFunction: (Int, Int) -> Int = addTwoInts

//调用与函数调用一样
println("Result: \(mathFunction(2, 3))")    //Result: 5

//相同匹配类型的不同函数可以被赋值给同一个变量
mathFunction = multiplyTwoInts
println("Result: \(mathFunction(2, 3))")    //Result: 6

//当赋值一个函数给常量或变量时,没有定义函数类型, Swift会自动推断其函数类型
let anotherMathFunction = addTwoInts        //anotherMathFunction 此时的函数类型就是 (Int, Int) -> Int
println("Result: \(anotherMathFunction(3, 4))") //Result: 7



//函数类型作为参数类型
func printMathResult(mathFunction: (Int, Int) -> Int, a: Int, b: Int) {
    println("Result: \(mathFunction(a, b))")
}
printMathResult(addTwoInts, 3, 5)   //Result: 8


//函数类型作为返回值类型
func stepForward(input: Int) -> Int {
    return input + 1
}
func stepBackward(input: Int) -> Int {
    return input - 1
}
func chooseStepFunction(backwards: Bool) -> (Int) -> Int {
    return backwards ? stepBackward : stepForward   //根据条件返回不同的函数类型
}

var currentValue = 3
let moveNearerToZero = chooseStepFunction(currentValue > 0) //获取函数类型
let result = moveNearerToZero(currentValue) //根据函数类型,得到结果
println(result) //2

  

9.嵌套函数(Nested Functions)

把函数定义在别的函数体中,称作嵌套函数(nested functions)。

func chooseStepFunction(backwards: Bool) -> (Int) -> Int {
    func stepForward(input: Int) -> Int { return input + 1 }
    func stepBackward(input: Int) -> Int { return input - 1 }
    return backwards ? stepBackward : stepForward
}
var currentValue = -4
let moveNearerToZero = chooseStepFunction(currentValue > 0)
let result = moveNearerToZero(currentValue) //根据函数类型,得到结果
println(result) //-3

  




鲜花

握手

雷人

路过

鸡蛋
该文章已有0人参与评论

请发表评论

全部评论

专题导读
上一篇:
Electric Rain Swift 3D 6 和 ZAM 3D 汉化发布发布时间:2022-07-13
下一篇:
Swift中文教程(六)--枚举和结构发布时间:2022-07-13
热门推荐
热门话题
阅读排行榜

扫描微信二维码

查看手机版网站

随时了解更新最新资讯

139-2527-9053

在线客服(服务时间 9:00~18:00)

在线QQ客服
地址:深圳市南山区西丽大学城创智工业园
电邮:jeky_zhao#qq.com
移动电话:139-2527-9053

Powered by 互联科技 X3.4© 2001-2213 极客世界.|Sitemap