初学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(,)
 println(temp)

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

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

 func returnMoreValue_1(t1:(Double,Double),t2:(Double,Double)) ->(Double,Double) {
     return (abs(t1.-t2.),abs(t1.-t2.))
 }
 //函数的内部参数和外部参数
 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) = (,)
 let p1 : (Double,Double) = (,)
 let p_v=returnMoreValue(p0,p1)
 println(p_v.width)
 //调用 函数传递外部参数
 println(returnMoreValue_2(t1: 3.3, t2: 2.3))
 println(returnMoreValue_3(t1: , 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=
 var y=
 swap1(&x, &y) //& 表示传递变量地址
 println("\(x),\(y)")

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

 var temp1=add1(,,,,,,,)
 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(,))
 calFunc = m_sum
 println(calFunc(,))

 //闭包 可以理解为匿名函数 有参数有返回值 没有函数名称
 //嵌套函数
 /*
 闭包表达式语法
 {
     (参数) -> 返回值类型 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(,))

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

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

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

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

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

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

 优化:
 {
     $0 > $1
 }

 */

 //尾随闭包
 //当闭包表达式是函数的最后一个参数时可以用尾随闭包的书写方式，即将闭包表达式写在函数后面，如
 bubbleSort1(&array_b1){
     let a = $ , b = $
     if a>b{
         return -
     }else if a<b {
         return
     }else {
         return
     }
 }
 println(array_b1)
 //优化尾随闭包
 bubbleSort1(&array_b1){
     if $>${
         return -
     }else if $<$ {
         return
     }
     return
 }
 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 =
     func incFunc(v: Int) -> Int{
         mt++
         return inc+v+mt
     }
     return incFunc
 }
 let incFunc1=get_value()//声明一个变量，调用get_value函数，得到闭包 即该变量是一个闭包
 println(incFunc1())//调用闭包

 let incFunc2=get_value1()
 println(incFunc2())
 println(incFunc2())