Swift 闭包

一天学习一点,慢慢前进

加油:

闭包:简单地说,就是将一个代码块封装在一起

code+注释:

//
//  ViewController.swift
//  闭包
//
//  Created by NapoleonBai on 14-11-24.
//  Copyright (c) 2014年 NapoleonBai. All rights reserved.
//

import UIKit

class ViewController: UIViewController {

    override func viewDidLoad() {
        super.viewDidLoad()
        // Do any additional setup after loading the view, typically from a nib.
        managerClosure()
    }
    
    //管理闭包函数
    func managerClosure(){
        //闭包:OC本来就有的一种函数,那么在Swift中,又该怎么操作了,基本操作都很类似
        //闭包函数一般表达式:
        /*
        {
            (parameters) -> returnType int
                statements
        }
        
        当然了,这里的参数可以是常量/变量/inout类型的或者元组等等都可以
        */
        //eg:
        
        var datas = ["NapoleonBai","XiaoBaiYang","DaBaiCai","HuiTaiLang"]
        
        //嵌套函数,实现字符串比较
        func compareName(strA : String , strB : String) -> Bool{
            return strA > strB;
            //这里说明一下:Swift中String类型定义了运算符"<" ">"的字符串比较函数,所以,这里可以这么使用
        }
        
        var sortArray = datas.sorted(compareName)
        //为什么这里可以直接使用compareName,可以不传参数呢?
        //这是因为函数也是一种特殊的闭包,所以,这里就将compareName函数作为数组排序的闭包类型参数
        
        //那么,是不是已经排序好了呢?
        //eg:
        
        for temStr in sortArray{
            println("the tempStr = \(temStr)")
            /*
            the tempStr = XiaoBaiYang
            the tempStr = NapoleonBai
            the tempStr = HuiTaiLang
            the tempStr = DaBaiCai
            果然,倒序排列了一把.
            */
        }
        
        //那么,如果我们使用闭包来取代compareName函数怎么做呢?
        //eg:
        
        sortArray = datas.sorted({(strA : String ,strB : String) -> Bool in
            return strA < strB;
        })
        
        for temStr in sortArray{
            println("the tempStr = \(temStr)")
            /*
            the tempStr = DaBaiCai
            the tempStr = HuiTaiLang
            the tempStr = NapoleonBai
            the tempStr = XiaoBaiYang
            这样,就实现了,重新升序排列了一次
            */
        }
        
        datas.append("Hello")
        
        
        //那么,闭包函数是不是可以简化呢?是的,答案是可行的
        //如果,闭包体只有一句可执行代码,那么return是可以省略的,当然参数类型也可以省略
        //eg:
        
        sortArray = sorted(datas, {strA , strB in strA < strB})
        
        
        for temStr in sortArray{
            println("the tempStr = \(temStr)")
            /*
            the tempStr = DaBaiCai
            the tempStr = Hello
            the tempStr = HuiTaiLang
            the tempStr = NapoleonBai
            the tempStr = XiaoBaiYang
            这样,就实现了,重新升序排列了一次
            */
        }
        //当然了,也可以只省略类型,或者return,或者'()' /返回类型,当然,可以做做就了解了
        
        //不过,还有一种简单方式,这九类似于通过下标访问数组的形式了
        //eg:
        sortArray = sorted(datas, {$0 < $1})
        
        for temStr in sortArray{
            println("the tempStr = \(temStr)")
            /*
            the tempStr = DaBaiCai
            the tempStr = Hello
            the tempStr = HuiTaiLang
            the tempStr = NapoleonBai
            the tempStr = XiaoBaiYang
            这样,就实现了,重新升序排列了一次
            */
        }
        //这里的$0,$1...就代替了传入的参数1,参数2 ... 当然了,如果这样使用,就必须省略in关键字
        //不过由于这里的< > 是字符串比较的一个函数,所以,排序最后可以简化为
        //eg:
        
        sortArray = datas.sorted(>)
        for temStr in sortArray{
            println("the tempStr = \(temStr)")
            /*
            the tempStr = XiaoBaiYang
            the tempStr = NapoleonBai
            the tempStr = HuiTaiLang
            the tempStr = Hello
            the tempStr = DaBaiCai
            */
        }
        //怎么样,见识到闭包的强大了吧.嘻嘻...
        //当然了,还有一个也必须提到,那就是trailing闭包
        //这样的类型主要是用在使用闭包作为参数,并且这个参数的的表达式很长,那么就使用这个trailing闭包
        //eg:
        
        func getUser(closure : () -> ()){
            println("No value")
        }
        //调用方法1 采用trailing闭包,当然了,如果表达式只有一行,那么是可以省略()滴
        getUser(){
            //这里只想闭包方法
        }
        
        //调用方法2
        getUser({
            //这里执行闭包方法
        })
        /* 
        总结:
        闭包（Closures）
         闭包是自包含的功能代码块，可以在代码中使用或者用来作为参数传值。
         在Swift中的闭包与C、OC中的blocks和其它编程语言（如Python）中的lambdas类似。
         闭包可以捕获和存储上下文中定义的的任何常量和变量的引用。这就是所谓的变量和变量的自封闭，
         因此命名为”闭包“("Closures）").Swift还会处理所有捕获的引用的内存管理。
        
         全局函数和嵌套函数其实就是特殊的闭包。
         闭包的形式有：
         （1）全局函数都是闭包，有名字但不能捕获任何值。
         （2）嵌套函数都是闭包，且有名字，也能捕获封闭函数内的值。
         （3）闭包表达式都是无名闭包，使用轻量级语法，可以根据上下文环境捕获值。
        
         Swift中的闭包有很多优化的地方:
         (1)根据上下文推断参数和返回值类型
         (2)从单行表达式闭包中隐式返回（也就是闭包体只有一行代码，可以省略return）
         (3)可以使用简化参数名，如$0, $1(从0开始，表示第i个参数...)
         (4)提供了尾随闭包语法(Trailing closure syntax)
        */

        
    }
    
    
    

    override func didReceiveMemoryWarning() {
        super.didReceiveMemoryWarning()
        // Dispose of any resources that can be recreated.
    }


}