函数完毕

Author: xcs-go

Control Flow.playground/Contents.swift

@@ -148,5 +148,171 @@ print(sayHi("Tim", true))
 
 
 //3:无返回值函数
+func sayGoodbye(personName: String) {
+    print("Goodbye, \(personName)!")
+}
+sayGoodbye("Dave")
+
+// 被调用时，一个函数的返回值可以被忽略
+//func printAndCount(StringToPrint:String) -> Int {
+//    print(StringToPrint)
+//    return StringToPrint.characters.count
+//}
+//func printWithoutCounting(stringToPrint:String) {
+//    printAndCount(stringToPrint) // 被调用，函数的返回值被忽略
+//}
+//
+//printAndCount("hello world")
+
+// 多重返回值函数
+// 使用元组类型让多个值作为一个复合值从函数中返回
+
+//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)
+//}
+//print(minMax([2,5,6,8,0,74,85]))
+
+// 可选元组返回类型
+// 如果函数返回的元组类型有可能整个元组都没有值，则可以在元组的返回值的右括号中添加一个❓来表示该元组是一个可选的。
+
+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)
+}
+print(minMax([2,5,6,8,0,74,85]))
+// 可以使用可选绑定来检查minMax:函数返回的是一个实际的元组值还是nil
+
+
+// 函数参数名称
+
+// 函数参数都有有一个外部参数名和一个局部参数名，外部参数名用于在函数调用时标注传递给函数的参数，局部参数名在函数的实现内部使用
+//func someFunction(firstParameterName:Int,secondParameterName:Int) {
+//    
+//}
+//
+//someFunction(1, 2)
+
+// 指定外部参数名:在局部参数名前指定外部参数名，中间以空格分隔
+func say(to person:String,and anotherPerson:String) -> String {
+    return "hello \(person) and \(anotherPerson)"
+}
+print(say(to: "Bill", and: "Ted"))
+
+// 可变参数：一个可变参数可以接受零个或多个值。函数调用时， 你可以用可变参数来指定函数参数可以被传入不确定数量的输入值通过在变量名后面加入（...）的方式来定义可变参数。
+
+// 可变参数的传入值在函数体中变为此类型的一个数组。一个函数最多只有一个可变参数
+func arithmeticMean(numbers:Double...) -> Double {
+    var total:Double = 0
+    for number in numbers {
+        total += number
+    }
+    return total / Double(numbers.count)
+}
+arithmeticMean(1,2,3,4,5)
+
+
+// 常量参数和变量参数
+//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...amoutToPad {
+//        String = padstring + String
+//    }
+//    return String
+//}
+//
+//let originalString = "hello"
+//let paddedString = alignRight(originalString, 10, "-")
+
+// 输入输出参数
+// 如果你想要一个函数可以修改参数的值，并且想要在这些修改在函数调用结束后仍然存在，那么就应该把这个参数定义为输入输出参数.在参数定义前加input关键字,传入参数时，需要在参数名前加&符，表示这个值可以被修改
+func swapTwoInts(inout a:Int,inout b:Int){
+    let temporaryA = a
+    a = b
+    b = temporaryA
+}
+var someInt = 3
+var anotherInt = 107
+swapTwoInts(&someInt, &anotherInt)
+
+
+// 函数类型
+func addTwoInts(a:Int,b:Int) -> Int {
+    return a + b
+}
+
+func mulitiplyTwoInts(a:Int,b:Int) -> Int {
+    return a * b
+}
+
+// 使用函数类型
+// 在swift中，使用函数类型就想使用其他类型一样。可以定义一个类型为函数的常量或变量，并将适当的函数赋值给它
+var mathFunction:(Int,Int) -> Int = addTwoInts
+// 通过使用mathFunction来调用被赋值的函数
+print("\(mathFunction(2,3))")
+
+// 有相同匹配类型的不同函数可以被赋值给同一个变量
+mathFunction = mulitiplyTwoInts
+print("\(mathFunction(2,3))")
+
+// 函数类型作为参数类型
+func printMathResult(mathFunction:(Int,Int) -> Int,a
+    :Int,b:Int) -> Int {
+//        print("\(mathFunction(a,b))")
+        return mathFunction(a,b)
+}
+printMathResult(addTwoInts, 3, 4)
+
+// 函数类型作为返回类型
+// 在返回箭头后写一个完整的函数类型
+
+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 currentValue = 3
+let moveNearerToZero = chooseStepFunction(currentValue > 0)
+
+// 嵌套函数 : 在一个函数体中定义另一个函数，叫做嵌套函数
+// 默认情况下，嵌套函数是对外界不可见的，但是可以被它们的外围函数调用，一个外围函数也可以返回它的某一个嵌套函数，使得这个函数可以在其他领域中被调用
+
+
+
+
+
+
+
+
+
+
+
+