Swift 学习之函数
// 1. 定义函数
func sayHello(personName:String) ->String
{
let greeting = "Hello, \(personName)"
return greeting
// 简化函数可以合并,之间reture 返回结果
// return "Hello, \(personName)"
}
/** 函数说明
func 是函数的声明标记
sayHello(){} 函数的主体
personName:String 形参且为String类型
->String 函数带返回值且返回值为String类型
*/
// 2.调用函数
let greet = sayHello("apple")
println(greet) // 打印 : Hello, apple
// 3.函数的形参和返回值
// 3.1 函数可以有多个形参,再函数的括号内用" , "隔开
func numrang(start :Int,end :Int) ->Int
{
return end - start
}
println(numrang(1,10)) // 打印: 9
//3.2 无形参函数
func sayHello() ->String{
return "hello,world"
}
println(sayHello()) // 打印: hello,world
//3.3 无返回值参数
func sayGoodbay(personName: String)
{
println("Goodbay \(personName)")
}
sayGoodbay("apple") // 打印: Goodbay apple
/*严示:严格地说,sayGoodbye 函数确实还返回一个值,即使没有定义返回值。没有 定义返回类型的函数返回了一个 Void 类型的特殊值。这仅是一个空元组,这里边没有元素,可以被写成()。*/
// 当一个函数调用时可以忽略返回值不计
func printAndCount(printString: String) -> Int
{
println(printString)
return countElements(printString)
}
func printWithCount(printString: String)
{
printAndCount(printString)
}
printAndCount("apple") // 打印: apple 忽略了返回值
printWithCount("apple") // 打印: apple 没有返回值
// 返回值可以忽略,当定义了有返回值的函数,函数内部必须有返回值,不然会报错
// 3.4 多返回值函数
// 同时返回数组内最大值和最小值
func returnMaxAndMin(array: [Int])-> (maxValue: Int,minValue: Int)
{
var currentMin = array[0]
var currentMax = array[0]
for value in array
{
if currentMax < value
{
currentMax = value
}
if currentMin > value
{
currentMin = value
}
}
return (currentMax,currentMin)
}
let maxAndmin = returnMaxAndMin([48,-30,22,99,12])
println("maxvalue = \(maxAndmin.maxValue) minValue = \(maxAndmin.minValue)")
// 打印: maxvalue = 99 minValue = -30
// 3.5 可选的元组返回类型
// 如果数组为空将返回错误,因此返回的元组应该为可选类型,可以为nil
func minAndmax(array: [Int])->(minValue:Int,maxValue:Int)?
{
if array.isEmpty {return nil};
var currenMin = array[0];
var currenMax = array[0];
for value in array
{
if value > currenMax
{
currenMax = value
}
if value < currenMin
{
currenMin = value
}
}
return (currenMin,currenMax)
}
// 调用函数
let tuple = minAndmax([]) // 传入空数组
println(tuple) // 打印:nil 因为返回的类型为可选类型可以为nil
// 4. 函数形参名称
/** 外部形参名
函数的形参只能内部使用,如果函数外部想使用函数内部的形参,需要给函数形参定义一个外部形参名称
*/
func someFunction (externalParameterName localParametername:Int )
{
}
/*
externalParameterName 外部形参名称
提示:如果您为形参提供一个外部形参名称,那么外部形参名必须在调用时使用。
*/
// 4.1 定义带外部形参的函数
func externalParameterFunc(firstNum num1:Int, secondNum num2:Int, jionCharacter c:String) ->String
{
return ("\(num1) \(c) \(num2)")
}
// 使用带外部形参的函数, **带外部参数的函数,调用时必须带外部参数
let result = externalParameterFunc(firstNum: 2, secondNum: 3, jionCharacter: "+")
println(result) // 打印: 2 + 3
/*注意:
在别人第一次阅读你的代码不知道你函数形参目的时候,就要考虑到使用外
部形参名称了。在调用函数的时候,如果每个形参的目的清晰明确的话,那你就无需
指定外部形参名。
*/
// 4.2 外部参数的速记 速记标记 #
// 如果再函数的内部的形参前加 # ,内部的形参名称可当外部形参使用
// 创建速记外部参数
func externalParamer (#num1:Int,#num2: Int,#joinCharacter: String)->String
{
return ("\(num1) \(joinCharacter) \(num2)")
}
let resultString = externalParamer(num1: 3, num2: 2, joinCharacter: "-") // 速记形参
println(resultString) // 打印: 3 - 2
// 4.3 默认形参值,
// 设置 joinCharacter 默认为空字符
func join(#num1:Int, #num2:Int,join joinCharacter: String = " ")->String
{
return ("\(num1)\(joinCharacter)\(num2)")
}
// 传入join
let joinResult = join(num1: 1, num2: 1,join:"=")
println(joinResult) // 打印: 1=1
// 调用函数,join不传入,将以默认为" "
let joinResult2 = join(num1: 1, num2: 1)
println(joinResult2) // 打印: 1 1 用空字符填充 join的位置
// 4.4 有默认值的外部形参名
//当定义了默认的字符,外部可以只用使用函数的参数,相等于加了 #
func joinFunc(num1: Int,num2: Int,join: String = "+")->String
{
return ("\(num1)\(join)\(num2)")
}
// 当不传入join 值时
let joinresult3 = joinFunc(5,6)
println(joinresult3) // 打印: 5+6
// 当传入join 值时
let joinresult4 = joinFunc(5, 6, join: "-")
println(joinresult4) // 打印: 5-6
// 5. 可变形参
/*
一个可变形参可接受零个或多个指定类型的值。
当函数被调用时,你可以使用可变形参来 指定--形参可以用来传递任意数量的输入值。
可通过在形参的类型名后边插入三个点符号(...)来编写可变形参。
传递至可变形参的值在函数主体内是以适当类型的数组存在的.
例如,一个可变参数的名称
为 numbers 和类型为 Double...在函数体内就作为名为 numbers 类型为 Double[]的常量数组。
*/
func canchange(numbers: Double...) ->Double
{
var total : Double = 0
for number in numbers{
total += number
}
return total / (Double)(numbers.count)
}
// 调用可变参数的名称
let resultDouble = canchange(1,2,3,4,5)
println(resultDouble) // 打印: 3.0
let resultDouble2 = canchange(2.5,3.6,4.7,5.8)
println(resultDouble2) // 打印: 4.15
// 6.常量形参和变量形参
/*
函数的形参默认是常量。试图在函数体内改变函数形参的值会引发一个编译时错误。这意
味着你不能错误地改变形参的值。
可在形参前定义为var 形参可变, 改变形参的值,就无需再函数内部重新定义可变的值
*/
func addCharacter(var string: String, count: Int, pad: Character) -> String
{
let amount = count - countElements(string)
if amount < 1 {return string}
for _ in 1...amount
{
string = String(pad) + string
}
return string
}
let addString = addCharacter("swift", 10, "*")
println(addString) // 打印: *****swift
/*
注意:你对变量形参所做的改变不会比调用函数更持久,并且在函数体外是不可见
的。变量形参仅存在于函数调用的声明周期中。
*/
// 7. In-Out 形参
/*
变量形参只能在函数本身内改变。
如果你想让函数改变形参值,并想要在函数调用结束后保持形参值的改变,那你可以把形参定义为 in-out 形参。
你不能传递一个常量或者字面量作为实参,因为常量和字面量不能被修改。当你把变量作为实参传递给 in out 形参时,需要在直 接在变量前添加 & 符号,以表明它可以被函数修改。
提示:in-out 参数不能有默认值,可变参数的参数也不能被标记为 inout。如果您标记 参数为 inout,它不能同时被标记为 var 或 let。
*/
func swapTwoInts (inout a: Int,inout b: Int)
{
let temp = a
a = b
b = temp
}
var someInt = 3
var anotherInt = 5
// 需要出入两个参数的地址
swapTwoInts(&someInt, &anotherInt)
println(someInt) // 打印: 5
println(anotherInt) // 打印: 3
/*
In-out 形参不同于从函数返回一个值。上边 swapTwoInts 例子没有定义返回类 型或者返回值,
但它仍然会修改 someInt 和 anotherInt 的值。对函数来说,In-out 形 参是一个影响函数主体范围外的可选方式。
*/
// 8. 函数类型
// 8.1 使用函数类型
// 函数类型 (Int,Int)->Int
func 加(a: Int,b: Int)->Int
{
return a+b
}
func 乘(a: Int,b: Int)->Int
{
return a*b
}
var 临时函数: (Int,Int)->Int = 加 // : (Int,Int)->Int 部分可以省略,Swift会
println(临时函数(2,3)) // 打印: 5
临时函数 = 乘
println(临时函数(2,3)) // 打印: 6
// 8.2 作为形参类型的函数类型
func printMathResult(math:(Int,Int) -> Int,a :Int,b :Int)
{
println("result: \(math(a,b))")
}
// 调用
printMathResult(加, 3, 5) // 打印: 8
// 8.3 作为返回类型的函数类型 “Function Types as Return Types”
/*
可以将一个函数类型作为另一个函数的返回类型。
你可以在返回函数的返回箭头(->) 后立即编写一个完整的函数类型来实现。
*/
func stepForward(input: Int) ->Int
{
return input + 1;
}
func stepBackward(input: Int) ->Int
{
return input - 1;
}
func chooseStep(ward: Bool)-> (Int)->Int
{
return ward ?stepBackward : stepForward
}
var currentValue = 5
let moveNear = chooseStep(currentValue > 0) // 返回函数为真的函数
while currentValue != 0
{
println(currentValue)
currentValue = moveNear(currentValue)
}
/*
5
4
3
2
1
*/
// 9.嵌套函数 Nested Functions
// 在其他函数体中定义函数,被称为嵌套函数。
func chooseStep2(ward: Bool)-> (Int)->Int
{
func stepForward(input: Int) ->Int
{
return input + 1;
}
func stepBackward(input: Int) ->Int
{
return input - 1;
}
return ward ?stepBackward : stepForward
}
var currentValue2 = -5
let moveNear2 = chooseStep2(currentValue > 0) // 返回函数为真的函数
while currentValue2 != 0
{
println(currentValue2)
currentValue2 = moveNear2(currentValue2)
}
/*
-5
-4
-3
-2
-1
*/
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
