Swift学习笔记(四)函数
定义和调用函数 参数名personName,参数类型String 返回值类型是String func sayHello(personName: String) -> String{
let greeting = "hello," + personName + "!"
return greeting;
}
println(sayHello("John"))
func halfOpenRangeLength(start: Int,end: Int) -> Int {
return end - start
}
println(halfOpenRangeLength(1,10))
// prints "9"
函数的多返回值元组(此处的返回值声明了变量名:方便调用函数时可以使用变量名获取值) 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)
}
let bounds = minMax([8,-6,2,109,3,71])
println("min is (bounds.min) and max is (bounds.max)")
// prints "min is -6 and max is 109"
函数的可选元组返回类型 func minMax(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)
}
if let bounds = minMax([8,71]) {
println("min is (bounds.min) and max is (bounds.max)")
}
// prints "min is -6 and max is 109"
函数的参数名:本地参数名和外部参数名 二、外部参数名:帮助理解参数的目的,更好的表达参数的功能,就需要在定义时使用外部参数名,外部参数名需要卸载本地参数名之前,并使用空格将其分开 三、如果调用时使用外部参数,则在调用该函数时需要使用外部参数名 func someFunction(parameterName: Int) {
//parameterName是本地参数名
//调用时不写参数名
}
func someFunction(externalParameterName localParameterName: Int) {
//externalParameterName是外部参数名
//localParameterName是本地参数名
//调用时需要写外部参数名
}
func someFunction(#localParameterName: Int) {
//#用来标识参数即是本地参数名又是外部参数名
}
someFunction(2)
someFunction(externalParameterName: 2)
someFunction(localParameterName: 2)
设置函数参数的默认参数值(调用时传值了,则使用传的值,否则使用默认值) func join(string s1: String,toString s2: String,withJoiner joiner: String = " ") -> String {
return s1 + joiner + s2
}
join(string: "hello",toString: "world",withJoiner: "-")
// returns "hello-world"
join(string: "hello",toString: "world")
// returns "hello world"
可变参数:使一个参数接受0个或多个指定类型的值,设定一个可变参数需要在参数类型名添加”…” func arithmeticMean(numbers: Double...) -> Double {
var total: Double = 0
for number in numbers {
total += number
}
return total / Double(numbers.count)
}
arithmeticMean(1,4,5)
// returns 3.0,which is the arithmetic mean of these five numbers
arithmeticMean(3,8.25,18.75)
// returns 10.0,which is the arithmetic mean of these three numbers
常量参数和变量参数 func alignRight(var string: String,count: Int,pad: Character) -> String {
// let stringCount = count(string)
let amountToPad = count - 5
if amountToPad < 1 {
return string
}
let padString = String(pad)
for _ in 1...amountToPad {
string = padString + string
}
println(string)
return string
}
let originalString = "hello"
let paddedString = alignRight(originalString,10,"-")
// paddedString is equal to "-----hello"
// originalString is still equal to "hello"
输入输出参数: func swapTwoInts(inout #a: Int,inout #b: Int) {
let temporaryA = a
a = b
b = temporaryA
}
var someInt = 3
var anotherInt = 107
swapTwoInts(a: &someInt,b: &anotherInt)
println("someInt is now (someInt),and anotherInt is now (anotherInt)")
// prints "someInt is now 107,and anotherInt is now 3"
函数类型 func addTwoInts(a: Int,b: Int) -> Int {
return a + b
}
func multiplyTwoInts(a: Int,b: Int) -> Int {
return a * b
}
//上面两个函数的类型都是 (Int,Int) -> Int
函数类型的使用:定义一个变量mathFunction,其是一个函数类型,指向addTwoInts函数 var mathFunction: (Int,Int) -> Int = addTwoInts
println("Result: (mathFunction(2,3))")
与其他类型一样,当你为一个常量或变量分配一个函数时,你可以把它推断函数类型 let anotherMathFunction = mathFunction
函数类型做参数类型 func printMathResult(mathFunction: (Int,Int) -> Int,a: Int,b: Int) { println("Result: (mathFunction(a,b))") } printMathResult(addTwoInts,5) // prints "Result: 8"
函数类型做返回值类型 func stepForward(input: Int) -> Int {
println(input+1)
return input + 1
}
func stepBackward(input: Int) -> Int {
println(input-1)
return input - 1
}
chooseStepFunction的返回值类型是函数类型(Int) -> Int 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
moveNearerToZero(10)
//prints "9"
嵌套函数 func chooseStepFunction2(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 currentValue2 = -4
let moveNearerToZero2 = chooseStepFunction2(currentValue2 > 0)
// moveNearerToZero now refers to the nested stepForward() function
while currentValue2 != 0 {
print("(currentValue2),")
currentValue2 = moveNearerToZero2(currentValue2)
}
println("zero!")
// -4,-3,-2,-1,zero!
(编辑:李大同) 【声明】本站内容均来自网络,其相关言论仅代表作者个人观点,不代表本站立场。若无意侵犯到您的权利,请及时与联系站长删除相关内容! |