swift --函数

/*

函数（Function）

函数是为执行特定功能的自包含的代码块。函数需要给定一个特定标识符（名字），然后当需要的时候，

就调用此函数来执行功能。

*/

// 函数的定义与调用

// 定义函数时，使用关键字func，返回值类型通过->指明，如下：

// 函数名：sayHello，

// 参数列表中只有一个参数，叫personName,参数类型是String

// 函数返回值类型：String

func sayHello(personName: String) -> String {

let greeting = "Hello, " + personName + "!"

return greeting

}

// 函数调用

println(sayHello("Anna")) // prints "Hello, Anna"

println(sayHello("Brian")) // prints "Hello, Brian"

// 简化函数体

func sayHelloAgain(personName: String) -> String {

return "Hello, " + personName + "!"

}

println(sayHelloAgain("Anna"))

// 函数可以有多个参数

/*!

* @brief 返回两个值的差

* @param start Int类型，范围区间的起点

* @param end Int类型，范围区间的终点

* @return 返回值为Int类型，表示终点-起点的值

*/

func halfOpenRangeLength(start: Int, end: Int) -> Int {

return end - start

}

println(halfOpenRangeLength(1, 10)) // prints "9"

// 无参数函数

func sayHelloWorld() -> String {

return "Hello, world"

}

println(sayHelloWorld())

// 无返回值的函数,其实这里没有指定返回值，也会返回一个特殊的值，Void

func sayGoodbye(personName: String) {

println("Goodbye, \(personName)!")

}

sayGoodbye("David")

// 函数返回值是可以忽略的

func printAndCount(stringToPrint: String) -> Int {

println(stringToPrint)

return countElements(stringToPrint) // 计算字符串的长度

}

// 不带返回值

func printWithoutCounting(stringToPrint: String) {

printAndCount(stringToPrint)

}

printAndCount("Hello,world")

printWithoutCounting("hello, world")

/*

* @brief 函数可以返回元组（多个值）

* @param string 字符串

* @return (vowels: Int, consonants: Int, others: Int)

* vowels:元音， consonants:辅音，others：其它字符

*/

func count(string: String) ->(vowels: Int, consonants: Int, others: Int) {

var vowels = 0

var consonants = 0

var others = 0

for c in string {

switch String(c).lowercaseString {

case "a", "o", "e", "i", "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")

// 外部参数名(External Parameter Names)

// 有时候使用外部参数名是很有用的，这直到提示的作用，就好像OC语法中的参数一样，见名知意

func someFunction(externalParameterName localParameterName: Int) {

// do something

}

// 看例子：

func join(lhsString: String, rhsString: String, joiner:String) -> String {

return lhsString + joiner + rhsString

}

// 这里调用的时候，没有外部参数名

join("hello", "world", ",") // prints "hello,world"

// 加上#号后，参数名与外部名相同，这是快捷方式

func join(#lhsString: String, #rhsString: String, #joiner:String) -> String {

return lhsString + joiner + rhsString

}

// 调用方式

join(lhsString: "hello", rhsString: "world", joiner: ",") // prints "hello,world"

// 可以不使用快捷方式

func join(lhsString: String, rhsString: String, withJoiner joiner: String) -> String {

return lhsString + joiner + rhsString

}

join("hello", "world", withJoiner: ",")// prints "hello,world"

// 函数参数默认值

// 参数参数可以提供默认值，但是默认值只能是参数列表的最后，也就是说

// 如果arg1提供默认值，后面的都需要提供默认值。

func join(#originalString: String, #destinationString: String, #withJoiner: String = " ") -> String {

return originalString + withJoiner + destinationString

}

join(originalString: "hello", destinationString: "world", withJoiner: "-") // prints "hello-world"

join(originalString: "hello", destinationString: "world") // prints "hello world"

// 如果提供了参数默认值，Swift会自动把这个参数名也作为外部参数名

// 这里withJoiner相当于加上了#:#withJoiner

func join(lhsString: String, rhsString: String, withJoiner: String = " ") -> String {

return lhsString + withJoiner + rhsString

}

join("hello", "world", withJoiner: "-")// // prints "hello-world"

// 可变参数

// 可变参数接受0个或者多个指定类型的值。可变参数使用...表示

// 函数最多只能有一个可变参数，并且如果有可变参数，这个可变参数必须出现在参数列表的最后

// 如果参数列表中有一或多个参数提供默认值，且有可变参数，那么可变参数也要放到所有最后一个

// 提供默认值的参数之后（先是默认值参数，才能到可变参数）

func arithmeticMean(numbers: Double...) -> Double {

var total = 0.0

for number in numbers {

total += number

}

return total / Double(numbers.count)

}

arithmeticMean(1, 2, 3, ,4 5) // return 3.0

arithmeticMean(1, 2, 3) // return 2.0

// 常量和变量参数

// 在函数参数列表中，如果没有指定参数是常量还是变量，那么默认是let，即常量

// 这里Str需要在函数体内修改，所以需要指定为变量类型，即用关键字var

func alignRight(var str: String, count: Int, pad: Character) -> String {

let amountToPad = count - countElements(str)

// 使用_表示忽略，因为这里没有使用到

for _ in 1...amountToPad {

str = pad + str

}

return str

}

// 输入/输出参数

// 有时候，在函数体内修改了参数的值，如何能直接修改原始实参呢？就是使用In-Out参数

// 使用inout关键字声明的变量就是了

// 下面这种写法，是不是很像C++中的传引用？

func swap(inout lhs: Int, inout rhs: Int) {

let tmp = lhs

lhs = rhs

rhs = tmp

}

// 如何调用呢？调用的调用，对应的实参前面需要添加&这个符号

// 因为需要修改，所以一定是var类型的

var first = 3

var second = 4

// 这种方式会修改实参的值

swap(&first, &second) // first = 4, second = 3

// 使用函数类型

// 这里是返回Int类型

// 参数类型是：(Int, Int) -> Int

func addTwoInts(first: Int, second: Int) -> Int {

return first + second

}

// 参数类型是：(Int, Int) -> Int

func multiplyTwoInts(first: Int, second: Int) -> Int {

return first * second

}

var mathFunction: (Int, Int) -> Int = addTwoInts

mathFunction(1, 2) // return 3

mathFunction = multiplyTwoInts

mathFunction(1, 2) // return 2

// 参数可以作为参数

func printMathResult(mathFunction: (Int, Int) -> Int, first: Int, second: Int) {

println("Result: \(mathFunction(first, second))")

}

printMathResult(addTwoInts, 3, 5) // prints "Result: 8"

printMathResult(multiplyTwoInts, 3, 5) // prints "Result: 15"

// 函数作为返回类型

func stepForward(input: Int) -> Int {

return input + 1

}

func stepBackward(intput: Int) -> Int {

return input - 1

}

func chooseStepFunction(backwards: Bool) -> ((Int) -> Int) {

return backwards ? stepBackward : stepForward

}

var currentValue = 3

let moveNearerToZero = chooseStepFunction(currentValue > 0) // call stepBackward() function

// 参数可以嵌套定义，在C、OC中是不可以嵌套的哦

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

}