/*
函数的定义与调用
*/
//下面例子中的函数的名字是 greet(person:) ,之所以叫这个名字,是因为这个函数用一个人的名字当做输入,并 返回向这个人问候的语句。为了完成这个任务,你需要定义一个输入参数——一个叫做 person 的 String 值,和一个包含给这个人问候语的 String 类型的返回值:
func greet(person:String) -> String{
let greeting = "Hello," + person + "!"
return greeting
}
var sddd:String = greet(person: "asas");
print(greet(person: "asas"))
func greetAgain(person: String) -> String {
return "Hello again, " + person + "!"
}
print(greetAgain(person: "Anna")) // 打印 "Hello again, Anna!"
//函数参数与返回值
//无参数函数
func sayHelloWorld() -> String {
return "hello, world"
}
print(sayHelloWorld()) // 打印 "hello, world"
//多参数函数
func greets(person:String , alreadyGreeted:Bool) -> String {
if alreadyGreeted {
return greetAgain(person:person)
}else{
return greet(person: person)
}
}
print(greets(person: "Tim", alreadyGreeted:true))
// 打印 "Hello again, Tim!"
//无返回值参数
func greet2(person: String) {
print("Hello, \(person)!")
}
greet2(person: "Dave") // 打印 "Hello, Dave!"
//因为这个函数不需要返回值,所以这个函数的定义中没有返回箭头(->)和返回类型。
//被调用时,一个函数的返回值可以被忽略:
func printAndCount(string: String) -> Int {
print(string)
return string.characters.count
}
func printWithoutCounting(string: String) {
let _ = printAndCount(string: string)
}
printAndCount(string: "hello, world")
// 打印 "hello, world" 并且返回值 12 printWithoutCounting(string: "hello, world") // 打印 "hello, world" 但是没有返回任何值
//多重返回值函数
//你可以用元祖（tuple）类型让多个值作为一个符合值从函数中返回,下例中定义了一个名为 minMax(array:) 的函数,作用是在一个 Int 类型的数组中找出最小值与最大值。
func minMax(array:[NSInteger]) -> (min: NSInteger,max: NSInteger) {
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);
}
var bounds = minMax(array: [8, -6, 2, 109, 3, 71])
print("min is \(bounds.min) and max is \(bounds.max)")
//可选元祖返回类型
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(array:) 函数返回的是一个存在的元组值还是 nil :
if let bounds = minMax2(array: [8, -6, 2, 109, 3, 71]) {
print("min is \(bounds.min) and max is \(bounds.max)")
}
//函数参数标签和参数名称
func someFunction(firstParameterName: Int, secondParameterName: Int) {
// 在函数体内,firstParameterName 和 secondParameterName 代表参数中的第一个和第二个参数值
}
someFunction(firstParameterName: 1, secondParameterName: 2)
//指定参数标签
func someFunction2(argumentLabel parameterName: Int) {
// 在函数体内,parameterName 代表参数值
}
//这个版本的 greet(person:) 函数,接收一个人的名字和他的家乡,并且返回一句问候:
func greet3(person: String, from hometown: String) -> String {
return "Hello \(person)! Glad you could visit from \(hometown)."
}
print(greet3(person: "Bill", from: "Cupertino"))
// 打印 "Hello Bill! Glad you could visit from Cupertino."
//忽略参数标签
//如果你不希望为某个参数添加一个标签,可以使用一个下划线( _ )来代替一个明确的参数标签。
func someFunction3(_ firstParameterName: Int, secondParameterName: Int) {
// 在函数体内,firstParameterName 和 secondParameterName 代表参数中的第一个和第二个参数值
}
someFunction3(1, secondParameterName: 2)
//默认参数值
func someFunction4(parameterWithoutDefault: Int, parameterWithDefault: Int = 12) {
// 如果你在调用时候不传第二个参数,parameterWithDefault 会值为 12 传入到函数体中。
}
someFunction4(parameterWithoutDefault: 3, parameterWithDefault: 6) // parameterWithDefault = 6
someFunction4(parameterWithoutDefault: 4) // parameterWithDefault = 12
//可变参数:
//一个可变参数(variadic parameter)可以接受零个或多个值。函数调用时,你可以用可变参数来指定函数参数 可以被传入不确定数量的输入值。通过在变量类型名后面加入( ... )的方式来定义可变参数。
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))
//输入输出参数，定义一个输入输出参数时,在参数定义前加 inout 关键字。一个输入输出参数有传入函数的值,这个值被函数 修改,然后被传出函数,替换原来的值。你只能传递变量给输入输出参数。你不能传入常量或者字面量,因为这些量是不能被修改的。当传入的参数作为输入输出参数时,需要在参数名前加&符,表示这个值可以被函数修改。
//函数参数默认是常量。下例中,（_:_:）函数有两个分别叫做a和b的输入输出参数:
func swapTwoInts(_ a: inout NSInteger, _ b: inout NSInteger) {
let temporaryA = 0
a = b
b = temporaryA
}
//你可以用两个int型的变量来调用swapTwoInts(_:_:)。需要注意的是，someInt和anotherInt在传入swapTwoInts(_:_:)函数前,都加了&的前缀:
var someInt = 3
var anotherInt = 107
swapTwoInts(&someInt, &anotherInt)
print("someInt is now \(someInt), and anotherInt is now \(anotherInt)") // 打印 "someInt is now 107, and anotherInt is now 3"
//函数类型:
//函数类型由函数的参数类型和返回类型组成
func addTwoInts(_ a:NSInteger,_ b:NSInteger) -> NSInteger {
return a + b
}
func multiplyTwoInts(_ a: Int, _ b: Int) -> Int {
return a * b
}
//没有参数，没有返回值的函数
func printHelloWorld() {
print("hello world")
}
//使用函数的类型
var mathFunction:(NSInteger,NSInteger) -> NSInteger = addTwoInts
print("Resualt: \(mathFunction(2,3))")
//有相同匹配类型的不同函数可以被赋值给同一个变量,就像非函数类型的变量一样:
mathFunction = multiplyTwoInts
print("Result: \(mathFunction(2, 3))")
// Prints "Result: 6"
//函数类型作为参数类型
//你可以用（Int,Int） ->Int 这样的函数类型作为另一个函数的参数类型，这样可以将函数的一部分实现留给函数的调用者来提供
func printMathResult(_ mathFunction:(NSInteger,NSInteger) -> NSInteger , _ a:NSInteger , _ b:NSInteger) {
print("resault: \(mathFunction(a,b))")
}
print(printMathResult(addTwoInts, 3, 5))
//函数作为返回值类型
//你可以用函数类型作为另一个函数的返回类型。你需要做的是在返回箭头(->)后写一个完整的函数类型。
func stepForward(_ input:NSInteger) -> NSInteger {
return input + 1
}
func stepBackword(_ input: NSInteger) -> NSInteger {
return input - 1
}
func chooseStepFunction(backword: Bool) -> (NSInteger) -> NSInteger {
return backword ? stepBackword : stepForward
}
var currentValue = 3
let moveNearerZero = chooseStepFunction(backword: currentValue > 0)
print(moveNearerZero)
while currentValue != 0 {
print("\(currentValue)...")
currentValue = moveNearerZero(currentValue)
}
//嵌套函数
//默认情况下嵌套函数是对外界不可见得，但是可以被他们的外围函数调用。一个外围函数也可以返回它的某一个嵌套函数，使得这个函数可以在其他域中被使用
//用返回嵌套函数的方式重写 chooseStepFunction(backward:) 函数:
func chooseStepFunctions(backword: Bool) -> (NSInteger) -> NSInteger {
func stepForward(input: NSInteger) -> NSInteger {
return input + 1
}
func stepBackword(input: NSInteger) -> NSInteger {
return input - 1
}
return backword ? stepBackword : stepForward
}
var currentValue2 = -4
let moveNearerToZero = chooseStepFunctions(backword: currentValue2 > 0)
// moveNearerToZero now refers to the nested stepForward() function
while currentValue2 != 0 {
print("\(currentValue2)... ")
currentValue2 = moveNearerToZero(currentValue2)
}
网友评论