函数 function

var str = "Hello,playground"
// 定义函数 func 关键字
func printStr (){
    print(str)
}

// 调用函数,函数名+()

printStr()

有参数有返回值的函数

// 传入一个字符串,返回字符串的字符的个数

// 函数的声明 + (参数名:参数类型)->(返回值类型)
// str 即是外部参数,也是内部参数
func lenthOfString(str:String)->(Int){
    return str.characters.count
}
let len = lenthOfString(str: "zhangsan")
print(len)

多参函数

// 求和函数

func sum(a:Int,b:Int)->(Int){
    return a + b

}
print(sum(a:5,b:6))

利用元组实现多返回值

func minAndMac(a:Int,b:Int)->(min:Int,max:Int){
    let min = a < b ? a : b
    let max = a > b ? a : b
    return(min,max)
}

print(minAndMac(a: 10,b: 20))

可选类型作为参数或者返回值

func maxAndmin(a :Int?,b:Int?)->(max:Int,min:Int)?{ // 输入的参数为可选类型,所以用值绑定来接收一下输入的值,如果输入的值不为空,就将输入的值强制解包,并执行下面的代码
  if let a = a,let b = b {
    let max = a > b ? a : b
    let min = a < b ? a : b
    return (max,min)
    } // 如果输入的值为空,则不进行比较,直接返回
    return nil
}
 // 返回值也有可能为空,进行只绑定,如果返回值不为空,就将返回值强制解包,并执行下面括号中的代码,如果为空就直接执行 else 中的代码

let result = maxAndmin(a: 20,b: nil )
if let result = result{
    print(result)
}else{
    print("返回值为空")
}

参数标签

// 参数标签 是放在参数名前面的另一个参数名作为参数标签,这个标签相当于外部参数名



func printName2(yourName name: String){
    print(name)
}

printName2(yourName: "zhangsan")


// 不制定参数标签的时候,参数名就默认为参数标签
func printName1(name: String){
    print(name)
}
printName1(name: "lisi") //


// 参数名前面加_来忽略外部参数名,即:忽略参数标签
func printName3(_ name: String){
    print(name)
}
printName3("lisi")

新特性,默认参数值

func sayhello(name: String = "wangxiao"){
    print("name =\(name)")
}
// 传入值的时候,就打印传入的值
sayhello(name:"ceshi")
//什么都不传的时候,打印默认值
sayhello()

//:## 可变参数 // 是指参数的个数不确定可能是多个参数 // 比如求任意几个数的和
func sum(_ numbers:Int...)->Int{
    var sum = 0
    for number in numbers{
        sum += number

    }
    return sum

}
sum(1,3,5,7)
print(sum(2,4,6))

输入输出参数 关键字 inout

//:## 参数值修改
var a = 23
func changeNumber(a:Int){
    //error: left side of mutating operator isn't mutable: 'a' is a 'let' constant
    // 参数默认都是常量 let 修饰的,在函数内部,不能改变函数外部的值,函数内部修改的值,都是值拷贝
    var a = a
    a += 2
    print(a)

}
changeNumber(a: a )
print(a)
 // 比如交换两个变量的值
var numbera = 10
var numberb = 20

func swapNumber(a:inout Int,b:inout Int){
    let c = a
    a = b
    b = c
}
swapNumber(a: &numbera,b: &numberb)
print("numbera = \(numbera),numberb = \(numberb)" )

函数类型

// 可以将函数当做一种数据类型,或者当做变量
//第一个函数
func sum3(a :Int,b:Int)->Int{
    return a + b
}
//第二个函数
func minus3(a :Int,b:Int)->Int{
    return a - b
}
// 这两个函数有个共同特点,参数都是两个 int 类型参数,返回值也是 int,所以可以定义一个变量代表这个函数类型

var hanshuStyle : (Int,Int)-> Int

// 这时候,就可以将这种类型的函数,赋值给这个变量了
hanshuStyle = sum
hanshuStyle(5,5)


// 函数类型的变量作为参数
func style(a : Int,b:Int,operation: (Int,Int)-> Int )->Int{
    return operation(a,b)
}
style(a: 33,b: 33,operation: sum3)
style(a: 33,operation: minus3 )

// 函数类型作为返回值

func getOperation(key:String)->((Int,Int)->Int){ switch key { case "+": return sum3 default: return minus3 } } //这个时候,函数返回的就是一个加法的函数类型,f 就相当于一个加法的函数 var f = getOperation(key: "+") f(25,23)