Swift 2.0 函数 定义、调用、参数返回值、函数类型、嵌套函数

Swift 2.0 函数

函数定义与调用

func sayHello(name:String) ->String {
let greeting = "Hello," + name + "!"
return greeting
}
// 调用
print(sayHello("CrazyXin"))

函数参数与返回值

override func viewDidLoad() {

print(halfOpenRangeLength(1, end: 10))  // 多重输入参数
print(sayHelloWorld())                  // 无参函数
print(sayHello1("Tim", alreadyGreeted: true)) // 多参数函数
sayGoodbye("Dave")                      // 无参数返回
printAndCount("Hello，world")
printWithoutCounting("hello，world")   // 一个函数的返回值可以被忽略
print(minMax([10,39,4,9,30,2,6]))      // 多重返回值函数   找出数组中的最大数和最小数
let bounds = minMax([10,39,4,9,30,2,6])
print("最小值 是\(bounds.min)    最大值是 \(bounds.max)") // 使用点语法来访问取回发现的最小值和最大值  运维元组的程远志被命名为函数的返回类型的一部分 可以使用点语法
minMax1([]) // 处理 传入空数据 数组越界问题

if let bounds = minMax1([8,-6,2,109,3,58]) {
print("min is \(bounds.min) and max is \(bounds.max)")
}
// 方法：
func sayHello(name:String) ->String {
let greeting = "Hello," + name + "!"
return greeting
}
func sayHelloAgain(personName:String) ->String {
return "Hello again," + personName + "!"
}
func halfOpenRangeLength(start:Int,end:Int) ->Int {
return end - start
}
func sayHelloWorld()->String {
return "hello，world"
}
func sayHello1(personName:String,alreadyGreeted:Bool) ->String {
if alreadyGreeted {
return sayHelloAgain(personName)
}else {
return sayHello(personName)
}
}
func sayGoodbye(personName:String) {
print("Goodbye,\(personName)!")
}
func printAndCount(stringToPrint:String) ->Int {
print(stringToPrint)
return stringToPrint.characters.count
}
func printWithoutCounting(stringToPrint:String) {
printAndCount(stringToPrint)
}
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)
}
// 处理数组为空问题 :处理可选类型 函数使用 可选元组返回类型，并当数组为空时返回nil
func minMax1(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)
}
}

函数参数名称

//调用
someFunction(externalParameterName: 2) // 制定外部参数名
print(sayHello(to: "1", and: "2")) // 制定外部参数名
someFunction(1, 2) //   如果你不想为第二个及后续的参数设置参数名,用一个下划线(_)代替一个明确地参数名. --------重要----------
someFunction1()
someFunction1(10)
print(arithmeticMean(1,2,3,4,5)) // 调用函数传入可变参数
// 注意:  如果函数有一个或多个带默认值的参数，而且还有一个可变参数，那么把可变参数放在参数表的最后
print(arithmeticMean(3,8.25,18.75))
let originalString = "hello"
let paddedString = alignRight(originalString,totalLength: 10,pad: "_")
print(paddedString)
// 输入输出函数 使用
var someInt = 3
var anotherInt = 107
swapTwoInts(&someInt, &anotherInt) // 交换两个的值
print("someInt is now \(someInt) and antherInt is now \(anotherInt)")
/*
“注意： 输入输出参数和返回值是不一样的。上面的 swapTwoInts 函数并没有定义任何返回值，但仍然修改了 someInt 和 anotherInt 的值。输入输出参数是函数对函数体外产生影响的另一种方式。”
*/

// 指定外部参数名   可以在本地参数名钱指定外部参数名，中间以空格分割
func someFunction(externalParameterName localParameterName:Int) {
}

func sayHello(to person:String,and aanotherPerson:String) ->String {
return "Hello \(person) and \(aanotherPerson)"
}

// 忽略外部参数名
func someFunction(firstParameterName:Int,_ secondParameTerName:Int) {
}

// 默认参数值  在函数体中为参数设置默认值
func someFunction1(parameterWithDefault:Int = 12 ) {
print(parameterWithDefault)
}

// 可变参数  一个可变参数可以接受零个或多个值，函数调用时， 你可以用可变参数传入不确定数量的输入参数。通过在变量类型后面加入（ ... ）方式来定义可变参数。
/**
通过在变量类型后面加入（ ... ）方式来定义可变参数。

- parameter numbers: 传入参数

- returns: 返回参数的平均值
*/
func arithmeticMean(numbers:Double...) ->Double {
var total:Double = 0
for number in numbers {
total += number
}
return total / Double(numbers.count)
}

// 常量参数和变量参数  默认声明的参数都是常量 通过在参数名前添加关键字 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 _ in 1...amountTopad {
string = padString + string
}
return string
}

// 输入输出参数   重要
// “如果你想要一个函数可以修改参数的值，并且想要在这些修改在函数调用结束后仍然存在，那么就应该把这个参数定义为输入输出参数（In-Out Parameters）。”
// “你只能将变量作为输入输出参数。你不能传入常量或者字面量（literal value），因为这些量是不能被修改的。当传入的参数作为输入输出参数时，需要在参数前加 & 符，表示这个值可以被函数修改。”
// “注意： 输入输出参数不能有默认值，而且可变参数不能用 inout 标记。如果你用 inout 标记一个参数，这个参数不能被 var 或者 let 标记。”

func swapTwoInts(inout a:Int, inout _ b:Int) {
let temporaryA = a
a = b
b = temporaryA
}

函数类型

// 调用

// 函数类型 每个函数都有种特定的函数类型， 由函数的参数类型和返回类型组装成
print(addTwoInts(10, 20))
print(multiplyTwoInts(1, 9))
printHelloWorld()

// 使用函数类型
// 在Swift 中 使用函数类型就像使用其他类型一样。 例如，你可以定义一个类型为行数的常量或变量，并将函数赋值给他：
var mathFunction:(Int,Int) ->Int = addTwoInts

// “意思是 ： 定义一个叫做mathFunction的常量，类型是‘一个有两个int 型的参数并返回一个 int 型的值得函数’，并让这个心变量只向 addTwoInts 函数”
print("\(mathFunction(2,3))")

// 有相同匹配类型的不同函数可以被赋值给同一个变量，就像非函数类型的变量一样：
mathFunction = multiplyTwoInts
print("\(mathFunction(2,3))")

// 函数类型作为参数类型 ⭐️
// 你可以使用（int,int） -> int 这样的函数类型作为另一个函数的参数类型。这样你可以将函数的一部分时间交由给函数的调用者
// 下面例子 同样是输出某种数学运算结果：
printMathResult(addTwoInts, 3, 5)
// 函数类型作为返回类型 ⭐️
// 你可以用函数类型作为另一个函数的返回类型。你需要做的是在返回箭头（ -> ） 后写一个完成的函数类型
// 下面的例子中定义了两个简单的函数，分别是 stepForward 和stepBackward. stepForward 函数返回一个比输入值大一的值。 stepBackward 函数返回一个比输入值小一的值。两个函数的类型都是 （int）-> int:
var currentValue = 3
let moveNearerTozero = chooseStepFunction(currentValue > 0)
print("\(moveNearerTozero(1))")

print(" Counting to zero:")

while currentValue != 0 {
print("\(currentValue)...")
currentValue = moveNearerTozero(currentValue)
}
print("zero1")

// 函数类型
func addTwoInts(a:Int,_ b:Int)->Int {
return a + b
}
func multiplyTwoInts(a:Int,_ b:Int) ->Int{
return a*b
}
func printHelloWorld(){ }
func printMathResult(mathFunction:(Int,Int)->Int,_ a:Int,_ b:Int) {
print("Result : \(mathFunction(a,b))")
}
// 函数类型作为返回类型
func stepForward(input:Int) ->Int {
return input + 1
}
func stepBackward(input:Int)->Int {
return input - 1
}
func chooseStepFunction(backwards:Bool) ->(Int)->Int {
return backwards ? stepBackward : stepForward
}

嵌套函数

// 嵌套函数在本章中 你见到的所有函数都叫做全局函数， 他们定义在全局域中。 你也可以吧函数定义在别的函数体重。称作 嵌套函数
// 默认情况下 嵌套函数对外界是不可见的，但是可以被他们封闭函数来调用。 一个封闭函数也可以返回他的某一个嵌套函数，使得这个函数可以在其他域中被使用。

var currentValue1 = 4
let moveNearerTozero1 = chooseStepFunction1(currentValue1 > 0)
print(moveNearerTozero1(1))

while currentValue1 != 0 {
print("\(currentValue1)...")
currentValue1 = moveNearerTozero1(currentValue1)
}
print("zero!")

// 嵌套函数
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
}