初学swift笔记 函数（六）

 

import Foundation
/*
func 函数名 (参数名:参数类型) {

}
func 函数名 (参数名:参数类型) ->Void{

}
func 函数名 (参数名:参数类型) ->返回类型{

}
*/
func show_Array(tempArray: [Int]){
    for a in tempArray {
        println("\(a)")
    }
    
}
func show_Arrays(tempArray:Array<Any>){
    for a in tempArray {
        println("\(a)")
    }
    
}
//show_Array([2,3,4,5,6,2,1,3,2])
//show_Arrays([2,3,"abc"])
func maxOfValue(start : Int ,end : Int)->Int {
    if start>end {
        return start
    }
    return end
}
var temp = maxOfValue(9,2)
println(temp)

func showHello(){
    println("Hello World")
}
showHello()

//返回多个值 即返回一个元组类型
func returnMoreValue(t1:(Double,Double),t2:(Double,Double)) ->(width:Double,height:Double) {
    return (abs(t1.0-t2.1),abs(t1.1-t2.0))
}

func returnMoreValue_1(t1:(Double,Double),t2:(Double,Double)) ->(Double,Double) {
    return (abs(t1.0-t2.1),abs(t1.1-t2.0))
}
//函数的内部参数和外部参数
func returnMoreValue_2(t1 a: Double,t2 b: Double) ->Double {
    //使用时只能用内部参数
    return a/b
}
//函数的内部参数和外部参数 与 returnMoreValue_2相同
func returnMoreValue_3(#t1: Double,#t2: Double) ->Double {
    //使用时只能用内部参数
    return t1/t2
}

let p0 : (Double,Double) = (0,0)
let p1 : (Double,Double) = (4,4)
let p_v=returnMoreValue(p0,p1)
println(p_v.width)
//调用 函数传递外部参数
println(returnMoreValue_2(t1: 3.3, t2: 2.3))
println(returnMoreValue_3(t1: 4, t2: 6.6))

//默认参数
func joinString(s1: String ,toString s2: String ,joiner s3: String = " && ")->String {
    
    return s1+s3+s2
}
func joinString1(s1: String ,toString s2: String ,joiner: String = " && ")->String {
    
    return s1+joiner+s2
}

let str=joinString("hello", toString: "world", joiner: "#")
println(str)

let stra=joinString("hello", toString: "world")
println(stra)
joinString1("lsq", toString: "Liu", joiner: "#")
joinString1("lsq", toString: "Liu")

//参数的常量和变量
//传递给函数的参数默认是常量，不可以修改 如果想修改参数的值，需要在参数定义的时候指定参数变量形式 var
func swap(a: Int ,var b: Int) {
    let t=b
    b=a
}
//输入输出 函数inout 类似于c#中的值类型与引用类型
func swap1(inout a : Int ,inout b : Int){
    let t=a
    a=b
    b=t
}

var x=10
var y=11
swap1(&x, &y) //& 表示传递变量地址
println("\(x),\(y)")

//变参函数
//不确定参数的个数
//通常写法
func add(array: [Int])->Int{
    var sum=0
    for i in array {
        sum+=i
    }
    return sum
}
//标准写法 参数个数不确定多时候 变量名: 类型...
func add1(array: Int...)->Int{
    var sum=0
    for i in array {
        sum+=i
    }
    return sum
}
var temp_t = add([2,1,3,4,12,3])
println(temp_t)

var temp1=add1(2,3,3,4,1,23,1,44)
println(temp1)

//函数的类型
//给函数总结一下类型 (Int,Int)->Int
func m_add(a: Int ,b: Int)->Int{
    return a+b
}
func m_sum(a: Int,b: Int)->Int{
    return a-b
}
//定义函数类型的变量
var calFunc:(Int,Int)->Int = m_add;
//定义了参数 那么调用函数
println(calFunc(3,2))
calFunc = m_sum
println(calFunc(4,6))

//闭包 可以理解为匿名函数 有参数有返回值 没有函数名称
//嵌套函数
/*
闭包表达式语法
{
    (参数) -> 返回值类型 in
        执行语句
}

in 用来分割类型及执行语句

*/
//定义一个闭包表达式常量
let sayHello = {
        println("无参数无返回值的匿名函数，即闭包表达式")
}
//调用
sayHello()

//定义一个闭包表达式的常量 ，add_b类型是(Int,Int)->Int
let add_b = {(a: Int,b: Int)-> Int in
    return a+b
}
//调用
println(add_b(4,6))

//闭包表达式 回调用法 常用用法 将闭包作为一个函数的回调


func showArray(array : [Int]) {
    for a in array {
        //print("\(a) ")
    }
    println(array)
}

//普通的 冒泡排序
func bubbleSort(inout array: [Int]){
    let cnt=array.count
    for var i = 1; i < cnt; i++ {
        for var j = 0; j < cnt-i; j++ {
            if (array[j] > array[j+1]) {
                var t = array[j]
                array[j] = array[j+1]
                array[j+1] = t
            }
        }
    }
}
var array: Array<Int>=[9,8,7,6,5,10,4,2,1]
show_Array(array)
bubbleSort(&array)
println(array)

//用闭包改造
func bubbleSort1(inout array: [Int],cmp:(Int,Int) -> Int){
    let cnt=array.count
    for var i = 1; i < cnt; i++ {
        for var j = 0; j < cnt-i; j++ {
            if (cmp(array[j],array[j+1]) == -1) {
                var t = array[j]
                array[j] = array[j+1]
                array[j+1] = t
            }
        }
    }
}
var array_b1=[9,8,7,6,5,10,4,2,1]
//定义一个比较 闭包
let intCmp = {
    (a: Int,b: Int) -> Int in
    if a>b{
        return -1
    }else if a<b {
        return 1
    }else {
        return 0
    }
}
//可以这么调用
bubbleSort1(&array_b1,intCmp)
//也可以这么调用 这种方式较多人用
bubbleSort1(&array_b1,{
    (a: Int,b: Int) -> Int in
    if a>b{
        return -1
    }else if a<b {
        return 1
    }else {
        return 0
    }
})
println(array_b1)

/*
闭包表达式的优化
1.类型 返回值 让编译器去推断
*/
bubbleSort1(&array_b1,{
    (a,b) in
    if a>b{
        return -1
    }else if a<b {
        return 1
    }else {
        return 0
    }
})
println(array_b1)
/*
2.变量名称优化缩写
第一个参数 $0 后面的参数以此类推 $1 $2 $3 ...
*/
bubbleSort1(&array_b1,{
    let a = $0 , b = $1
    if a>b{
        return -1
    }else if a<b {
        return 1
    }else {
        return 0
    }
})
println(array_b1)
//3.简单的闭包表达式代码可以更简洁

/*
{
  (a: Int,b: Int) -> Bool in
    return a > b
}
优化：
{
    return $0 > $1
}

优化:
{
    $0 > $1
}

*/

//尾随闭包
//当闭包表达式是函数的最后一个参数时可以用尾随闭包的书写方式，即将闭包表达式写在函数后面，如
bubbleSort1(&array_b1){
    let a = $0 , b = $1
    if a>b{
        return -1
    }else if a<b {
        return 1
    }else {
        return 0
    }
}
println(array_b1)
//优化尾随闭包
bubbleSort1(&array_b1){
    if $0>$1{
        return -1
    }else if $0<$1 {
        return 1
    }
    return 0
}
println(array_b1)


//嵌套函数  值捕获

//定义一个函数，范围值是一个闭包类型  函数中定义一个函数，函数中返回一个函数
func get_value(inc: Int) -> (Int)->Int {
    func incFunc(v: Int) -> Int{
        return inc+v
    }
    return incFunc
}

func get_value1(inc: Int) -> (Int)->Int {
    var mt = 0
    func incFunc(v: Int) -> Int{
        mt++
        return inc+v+mt
    }
    return incFunc
}
let incFunc1=get_value(7)//声明一个变量，调用get_value函数，得到闭包 即该变量是一个闭包
println(incFunc1(10))//调用闭包

let incFunc2=get_value1(7)
println(incFunc2(10))
println(incFunc2(10))