import Foundation
/*函数的定义与调用*****************************************************/
//在下面例子中的函数叫做 "sayHello(_:)",之所以叫这个名字,是因为这个函数用一个人的名字当做输入,并返回 给这个人的问候语。为了完成这个任务,你定义一个输入参数-一个叫做 personName 的 String 值,和一个 包含给这个人问候语的 String 类型的返回值:
func sayHello(personName: String) -> String {
let greeting = "Hello," + personName + "!"
return greeting
}
//所有的这些信息汇总起来成为函数的定义,并以 func 作为前缀。指定函数返回类型时,用返回箭头 -> (一个 连字符后跟一个右尖括号)后跟返回类型的名称的方式来表示。
print(sayHello("Anna"))
// prints "Hello,Anna!"
print(sayHello("Brian"))
// prints "Hello,Brian!"
//为了简化这个函数的定义,可以将问候消息的创建和返回写成一句:
func sayHelloAgain(personName: String) -> String {
return "Hello again," + personName + "!"
}
print(sayHelloAgain("lll"))
// prints "Hello again,Anna!"
/*函数参数与返回值*****************************************************/
// 多重输入参数
//下面这个函数用一个半开区间的开始点和结束点,计算出这个范围内包含多少数字:
func halfOpenRangeLength(start: Int,end: Int) -> Int {
return end - start
}
print(halfOpenRangeLength(1,end: 10))
// prints "9"
// 无参函数
func sayHelloWorld() -> String {
return "Hello,world"
}
print(sayHelloWorld())
// prints "hello,world"
// 多参量函数
func sayHello(personName: String,alreadyGreeted: Bool) -> String {
if alreadyGreeted {
return sayHelloAgain(personName)
} else {
return sayHello(personName)
}
}
print(sayHello("Tim",alreadyGreeted: true))
// prints "Hello again,Tim!"
// 无返回值函数
func sayGoodbye(personName: String) {
print("Goodbye,\(personName)")
}
sayGoodbye("Dave")
// prints "Goodbye,Dave!"
//严格上来说,虽然没有返回值被定义,sayGoodbye(_:) 函数依然返回了值。没有定义返回类型的函数 会返回特殊的值,叫 Void 。它其实是一个空的元组(tuple),没有任何元素,可以写成 () 。
func printAndCount(stringToPring: String) -> Int {
print(stringToPring)
return stringToPring.characters.count
}
func printWithoutCounting(stringToPoint: String) {
printAndCount(stringToPoint)
}
printAndCount("hello,world")
// prints "hello,world" and returns a value of 12
printWithoutCounting("hello,world" but does not return a value
//多重返回值函数
//下面的这个例子中,定义了一个名为 minMax(_:) 的函数,作用是在一个 Int 数组中找出最小值与最大值.
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)
}
print(minMax([5,2,123,4,576,23]))
let bounds = minMax([8,-6,109,3,71])
print("min is \(bounds.min) and max is \(bounds.max)")
// prints "min is -6 and max is 109"
//为了安全的处理这个"空数组"问题,写一个 minMax(_:) 函数使用可选元组返回类型,并且当数组为空时返回 nil :
func minMax2(array:[Int]) -> (min:Int,max:Int)? {
if array.isEmpty {
return nil
}
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)
}
//你可以选择性的绑定当 minMax(_:) 函数返回的是一个实际的元组值还是 nil
if let bounds = minMax2([8,71]) {
print("min is \(bounds.min) and max is \(bounds.max)")
}
// prints "min is -6 and max is 109"
/*函数参数名称*****************************************************/
//函数参数都有一个外部参数名(external parameter name)和一个本地参数名(local parameter name).外部参数名用来标记传递给函数调用的参数,本地参数名在实现函数的时候使用.
func someFunction(FirstParameterName: Int,secondParameterName: Int) {
// function body goes here
// firstParameterName and secondParameterName refer to
// the argument values for the first and second parameters
}
someFunction(1,secondParameterName: 2)
//你可以在本地参数名前指定外部参数名,中间以空格分隔.
func someFunction(externalParameterName localParameterName: Int) {
// function body goes here,and can use localParameterName
// to refer to the argument value for that parameter
}
//注意: 如果你提供了外部参数名,那么函数在被调用时,必须使用外部参数名。
func sayHello(to person: String,and anotherPerson: String) -> String {
return "Hello \(person) and \(anotherPerson)"
}
print(sayHello(to: "Bill",and: "Ted"))
// prints "Hello Bill and Ted!"
//如果你不想为第二个及后续的参数设置参数名,用一个下划线(_)代替一个明确地参数名.
func someFunction2(firstParameterName: Int,_ secondParameterName: Int) {
// function body goes here
// firstParameterName and secondParameterName refer to
// the argument values for the first and second parameters
}
someFunction2(1,2)
//注意: 因为第一个参数默认忽略其外部参数名称,明确写下划线是多余的。
//你可以在函数体中为每个参数定义 默认值(Deafult Values) 。当默认值被定义后,调用这个函数时可以忽略这个 参数。
func someFunction3(parameterWithDefault: Int = 12) {
print("参数是\(parameterWithDefault)")
}
someFunction3(6)
someFunction3()
//注意: 将带有默认值的参数放在函数参数列表的最后。这样可以保证在函数调用时,非默认参数的顺序是一致 的,同时使得相同的函数在不同情况下调用时显得更为清晰。
//一个 可变参数(variadic parameter) 可以接受零个或多个值。函数调用时,你可以用可变参数来传入不确定数量的输入参数。通过在变量类型名后面加入 (...) 的方式来定义可变参数。
//下面的这个函数用来计算一组任意长度数字的 算术平均数(arithmetic mean) :
func arithmeticMean(numbers: Double...) -> Double {
var total: Double = 0
for number in numbers {
total += number
}
return total / Double(numbers.count)
}
print(arithmeticMean(1,2,3,4,5))
print(arithmeticMean(3,8.25,18.75))
//注意: 最多可以有一个可变参数函数,和它必须出现在参数列表中,为了避免歧义在调用函数有多个参数。 如果你的函数有一个或多个参数有默认值,还有一个可变的参数,将可变参写在参数列表的最后。
//常量参数和变量参数(Constant and Variable Parameters)
//通过在参数名前加关键字 var 来定义变量参数
func alignRight(var string: String,totalength: Int,pad: Character) -> String {
let amountToPad = totalength - string.characters.count
if amountToPad < 1 {
return string
}
let padString = String(pad)
for _ in 1...amountToPad {
string = padString + string
}
return string
}
let originalString = "hello"
let paddedString = alignRight(originalString,totalength: 10,pad: "-")
print("originalString is \(originalString) and paddedString is \(paddedString)")
//输入输出参数(In-Out Parameters)
//注意: 输入输出参数不能有默认值,而且可变参数不能用 inout 标记。如果你用 inout 标记一个参数,这个参数不能被 var 或者 let 标记。
func swapTwoInts(inout a: Int,inout _ b: Int) {
let temporaryA = a
a = b
b = temporaryA
}
//这个 swapTwoInts(_:_:) 函数仅仅交换 a 与 b 的值。该函数先将 a 的值存到一个暂时常量 temporaryA 中,然后将 b 的值赋给 a,最后将 temporaryA 幅值给 b 。
//你可以用两个 Int 型的变量来调用 swapTwoInts(_:_:) 。需要注意的是,someInt 和 anotherInt 在传入 s wapTwoInts(_:_:) 函数前,都加了 & 的前缀:
var someInt = 3
var anotherInt = 107
swapTwoInts(&someInt,&anotherInt)
print("someInt is now \(someInt),and anotherInt is now \(anotherInt)")
// prints "someInt is now 107,and anotherInt is now 3"
//注意: 输入输出参数和返回值是不一样的。上面的 swapTwoInts 函数并没有定义任何返回值,但仍然修改了 someInt 和 anotherInt 的值。输入输出参数是函数对函数体外产生影响的另一种方式。
/*函数类型*****************************************************/
//每个函数都有种特定的函数类型,由函数的参数类型和返回类型组成。
func addTwoInts(a: Int,_ b: Int) -> Int {
return a + b
}
func multiplyTwoInts(a: Int,_ b: Int) -> Int {
return a * b
}
//这两个函数的类型是 (Int,Int) -> Int,可以读作“这个函数类型,它有两个 Int 型的参数并返回一个 Int 型的 值。”。
//下面是另一个例子,一个没有参数,也没有返回值的函数:
func printHelloWorld() {
print("hello,world")
}
//这个函数的类型是: () -> void,或者叫“没有参数,并返回 Void 类型的函数”。
//在 Swift 中,使用函数类型就像使用其他类型一样。例如,你可以定义一个类型为函数的常量或变量,并将函数 赋值给它
var mathFunction: (Int,Int) -> Int = addTwoInts
//这个可以读作:“定义一个叫做 mathFunction 的变量,类型是‘一个有两个 Int 型的参数并返回一个 Int 型的值的函数’,并让这个新变量指向 addTwoInts 函数”。
print("Result: \(mathFunction(2,3))")
//有相同匹配类型的不同函数可以被赋值给同一个变量,就像非函数类型的变量一样:
mathFunction = multiplyTwoInts
print("Result: \(mathFunction(2,3))")
// prints "Result: 6"
//下面是另一个例子,正如上面的函数一样,同样是输出某种数学运算结果:
func printMathResult(mathFunction: (Int,Int) -> Int,_ a: Int,_ b: Int) {
print("Result: \(mathFunction(a,b))")
}
printMathResult(addTwoInts,5) // prints "Result: 8"
//printMathResult(_:_:_:) 函数的作用就是输出另一个合适类型的数学函数的调用结果。它不关心传入函数是如 何实现的,它只关心这个传入的函数类型是正确的。这使得 printMathResult(_:_:_:) 可以以一种类型安全(type-safe)的方式来保证传入函数的调用是正确的。
//你可以用函数类型作为另一个函数的返回类型。你需要做的是在返回箭头( -> )后写一个完整的函数类型。
//下面的这个例子中定义了两个简单函数,分别是 stepForward 和 stepBackward 。 stepForward 函数返回一个比输入值大一的值。 stepBackward 函数返回一个比输入值小一的值。这两个函数的类型都是 (Int) -> Int :
func stepForward(input: Int) -> Int {
return input + 1
}
func stepBackward(input: Int) -> Int {
return input - 1
}
//下面这个叫做 chooseStepFunction(_:) 的函数,它的返回类型是 (Int) -> Int 的函数。 chooseStepFunction(_:) 根据布尔值 backwards 来返回 stepForward(_:) 函数或 stepBackward(_:) 函数:
func chooseStepFunction(backwards:Bool) -> (Int) -> Int {
return backwards ? stepBackward : stepForward
}
var currentValue = 3
let moveNearerToZero = chooseStepFunction(currentValue > 0)
// moveNearerToZero now refers to the stepBackward() function
print("Counting to zero:")
// Counting to zero:
while currentValue != 0 {
print("\(currentValue)... ")
currentValue = moveNearerToZero(currentValue)
}
print("zero!")
// 3...
// 2...
// 1...
// zero!
/*嵌套函数*****************************************************/
//这章中你所见到的所有函数都叫全局函数(global functions),它们定义在全局域中。你也可以把函数定义在别的函数体中,称作嵌套函数(nested functions)。
func chooseStepFunction2(backwards: Bool) -> (Int) -> Int {
func stepForward2(input: Int) -> Int {return input + 1}
func stepBackward2(input: Int) -> Int {return input - 1}
return backwards ? stepBackward2 : stepForward2
}
var currentValue2 = -4
let moveNearerToZero2 = chooseStepFunction2(currentValue2 > 0)
// moveNearerToZero now refers to the nested stepForward() function
while currentValue2 != 0 {
print("\(currentValue2)...")
currentValue2 = moveNearerToZero2(currentValue2)
}
print("zero!")
