Swift学习－函数（六）
这章就以代码的方式记录了，力求做到：简洁、完整。
//带参数 返回值的函数
func sayHello(personName:String) ->String
{
let greeting ="Hello, " + personName +"!"
return greeting
}
print(sayHello("feng"))
//多个参数
func halfOpenRangeLength(start:Int, end:Int) ->Int
{
return end - start
}
print(halfOpenRangeLength(1, end:10))//9
//没参数到函数
func sayHelloWorld() ->String
{
return"Hello, world"
}
//没有返回值的函数－其实是返回特殊值void（是一个空元组（））
func sayGoodBye(personName:String)
{
print("Goodbye,\(personName)")
}
//通过元组返回多个值
func minMax(array:[Int]) -> (min:Int, max:Int)
{
var currentMin = array[0]
var currentMax = array[0]
//array[1..<array.cout]返回范围内的值构成的新数组
for value in array[1..<array.count]{
if value < currentMin
{
currentMin = value
}else if value > currentMax
{
currentMax = value
}
}
return (currentMin, currentMax)
}
let bounds = inMax([8,-6,2,109,3,71])
print("min is\(bounds.min) and max is\(bounds.max)")
//min is -6 and max is 109
//可选元组返回类型,(Int,Int)?与元组包含可选属性如(Int?, Int?)不同。前者是整个元组是可选的
func minMaxOptional(array:[Int]) -> (min:Int, max:Int)? {
if array.isEmpty {returnnil}
var currentMin = array[0]
var currentMax = array[0]
//array[1..<array.cout]返回范围内的值构成的新数组
for value in array[1..<array.count]{
if value < currentMin
{
currentMin = value
}else if value > currentMax
{
currentMax = value
}
}
return (currentMin, currentMax)
}
if let bounds =minMaxOptional([8,-8,2,110,3,71])
{
print("min is\(bounds.min) and max is\(bounds.max)")
}
//min is -8 and max is 110
//外部参数名
func someFunction(to person:String, and anotherPerson:String)->String
{
return"Hello\(person) and\(anotherPerson)!"
}
print(someFunction(to:"feng", and:"liu"))//Hello feng and liu!
// 忽略第二个及后续的参数设置的参数名，用下划线（_）代替
func someFunction1(firstParameterName:Int,_ senondParameterName:Int)->Int
{
return firstParameterName + senondParameterName
}
//调用不需要参数名
print(someFunction1(2,2))//4
// 带默认参数的函数
func someFunction2(parameterWithDefault:Int =12)
{
print(parameterWithDefault)
}
someFunction2() //12
someFunction2(5)//5
/*使用（...）来定义可变参数接受0个或多个值
Double... 相当于 Double[]数组
函数最多有一个可变参数，为避免歧义一般写在参数列表的最后
如果函数有多个默认值，可变参数也放在参数列表最后
*/
func arithmeticMean(numbers:Double...) ->Double
{
var total:Double =0
for numberin numbers
{
total += number
}
return total / Double(numbers.count)
}
print(arithmeticMean(1,2,3,4,5))// 3.0
//函数默认参数为常量，不能更改值。
//用var声明一个可变参数(其生命周期只存在于函数体)
func alignRight(var string:String, totalLength:Int, pad:Character)->String
{
let amountToPad = totalLength - string.characters.count
if amountToPad < 1
{
return string
}
let padString = String(pad)
for_in1...amountToPad
{
string = padString + string
}
return string
}
let originalString ="hello"
let paddedString =alignRight(originalString, totalLength:10, pad: "-")
print(paddedString)//-----hello
//inout 定义输入输出参数
func swapTwoInts(inout a:Int,inout_ b:Int)
{
let temporaryA = a
a = b
b = temporaryA
}
var someInt = 3
var anotherInt = 100
//传入参数是需要前面加"&"，表示变量可以修改
swapTwoInts(&someInt, &anotherInt)
print("someInt:\(someInt),anotherInt:\(anotherInt)")//someInt:100,anotherInt:3
//函数类型(有函数参数类型和返回值类型组成)例如（Int,Int） -> Int
func addTwoInts(a:Int,_ b:Int)->Int
{
return a + b
}
func multiplyTwoInts(a:Int,_ b:Int)->Int
{
return a * b
}
func operatorIns(a:Int,_ b:Int,_ c:Int)->Int
{
return a + b + c
}
//函数赋值给变量
var mathFunction:(Int,Int)->Int =addTwoInts
print("Result:\(mathFunction(2,3))")//Result:5
mathFunction = multiplyTwoInts
print("Result:\(mathFunction(2,3))")//Result:6
//报错 参数不一样 mathFunction已经是Int,Int） -> Int
//mathFunction = operatorIns
//函数类型被swift推测
var anotherMathFunction =addTwoInts
print("anotherResult:\(anotherMathFunction(5,10))")//anotherResult:15
//函数类型作为参数
func printMathResult(mathFunction:(Int,Int)->Int,_ a:Int, _ b:Int)
{
print("Result:\(mathFunction(a,b))")
}
printMathResult(addTwoInts,3,5)//Result: 8
//函数作为返回类型（“—>”后写完整的函数类型（如（Int）-> (Int)））
func stepForward(input:Int) ->Int
{
return input +1
}
func stepBackward(input:Int) ->Int
{
return input -1
}
//返回一个函数
func chooseStepFunction(backward:Bool) -> (Int)->Int
{
return backward ?stepBackward :stepForward
}
/*嵌套函数
把函数定义在函数体中称为嵌套函数
对外不可见，可别他们的封闭函数调用。
封闭函数也可以返回他的一个嵌套函数
*/
func chooseStepFunction1(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 currValue = -4
let moveNearToZero = chooseStepFunction1(currValue > 0)
while currValue !=0 {
print("\(currValue)...")
currValue = moveNearToZero(currValue)
}
print("Zero!")
//-4...
//-3...
//-2...
//-1...
//Zero!