swift4基础学习（3）- 函数

import UIKit

var str = "Hello, playground"

//函数

//1.无返回值的函数

func method(){
    print("无返回值")
}

method()

//2 有参数，有返回值
/*  方法名：returnMethod
    参数名:number ，number2
    参数类型：Int，Int
    -> 后面代表返回类型 Int
 */
func returnMethod(number: Int, number2: Int)-> Int{
    
    return number + number2
}

//3 使用元组返回多个值
//该函数使用元组，返回数组中的最大值，最小值，总数
func calculateMethod(arrayNumber: Array<Int>)-> (max: Int, min: Int,sum :Int){
    
    var max = Int.min //Int.min Int中最小的值
    var min = Int.max  //nt.max Int中最大的值
    var sum = 0
    
    for number in arrayNumber {
        
        if max < number {
            max = number
        }
        
        if min > number {
            min = number
        }
        sum += number
    }
    return (max,min,sum)
}

let numbera = [10,20,1,9,29]

let (maxs,mins,sum) = calculateMethod(arrayNumber: numbera)

print(maxs,mins,sum)


//4.定义函数外部参数名，写在局部参数名之前，用空格隔开

func outFunctionName(first str1: String,second str2: String)-> String{
    return str1
}

outFunctionName(first: "1", second: "2")
// 如果提供了外部参数名，那函数在调用时必须使用外部参数名
// 左作用是增加可读性

//5. 使用 _ 忽略参数名
func ingroFunctionName(_ str1: String,_ str2: String)-> String{
    return String(format: "第一个参数:%@，第二个参数:%@",str1,str2)
}

let newStr = ingroFunctionName("1", "2")
print(newStr)

//6.给参数设置默认值
func defaultValueForParam(str1: String,str2: String="default")->String{
    
    return str1 + str2
}

//此时会有两个方法
let st1 = defaultValueForParam(str1: "1 ") //第二个参数使用的是默认值
let st2 = defaultValueForParam(str1: "1", str2: "2")

print(st1)
print(st2)
/*
 注意：将带有默认值的参数放在函数参数列表的最后
 */

//7. 可变参数数量： 不确定数量的输入参数   使用...

func sumCount(mutableParam: Int...) -> Int {
    var sum = 0
    
    for i in mutableParam {
        sum += i
    }
    
    return sum
}

print(sumCount(mutableParam: 1,2,3,4,5))
//注意：一个函数只能有一个可变参数，也只能在函数参数列表的最后面


//8. inout
// 如果想要一个函数的参数和外部传过来的是同一个参数，
//即 函数内部对参数进行修改，就是对外部参数进行的修改
//类似于引用传递
func swapParam(num1: inout Int , num2: inout Int){
    let temp = num1
    num1 = num2
    num2 = temp
}

var number1 = 20
var number2 = 10
swapParam(num1: &number1, num2: &number2)

print(number1,number2)
//注意： 输入与输出参数不能有默认值


//9. 函数类型
// 每个函数都有特定的函数类型，函数的参数类型和返回的参数类型

func functionType(num1: Int , num2: Int)-> Int{
    return num1 + num2
}

//methodVar就是一个函数类型
let methodVar:(Int,Int)-> Int = functionType

print(methodVar(2,4))
//没有参数，没有返回值的的函数类型  ()->()

//10 使用函数类型就像使用其他类型一样，可以声明一个变量或者常量，将函数赋值给它
let methodVars = functionType
print(methodVars(4, 9))
//在赋值的时候就已经在推断函数是什么类型的

//11.函数类型做为参数
//与c#中的delegate很像

let ArrayMath = [2,3]

//创建一个加法函数
func mathAdd( num1:Int, num2:Int) -> Int{
    return num1 + num2
}

//不关心传入函数如何实现的，只关心函数类型是否正确
func mathResult(caulate:(Int,Int)->Int){
    
    let result = caulate(ArrayMath[0],ArrayMath[1])
    
    print(result)
}

//第一种实现方式：传一个函数
mathResult(caulate: mathAdd(num1:num2:))

//第二种实现方式:
mathResult { (i, j) -> Int in
    return i * j
}

//12.函数类型作为返回值

func forward(_ input:Int) -> Int{
    return input + 1
}

func backward(_ input:Int) -> Int{
    return input - 1
}

//(Int)-> Int 返回类型
func choose(_ condition:Bool) -> (Int)-> Int{
    return condition ? backward : forward
}

var currentValue = 10
let lastValue = choose(currentValue>0)

while currentValue != 0 {
    currentValue = lastValue(currentValue)
    print(currentValue)
}


// 函数内部嵌套函数
// 嵌套函数是对外部不可见的
func outSide(_ condition:Bool) -> (Int)->Int{
    
    func one(_ input:Int) -> Int{
        return input + 1
    }
    
    func two(_ input:Int) -> Int{
        return input - 1
    }
    
    return condition ? one : two
}