swift 内部函数 swift函数参数

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
}