• Swift 各种闭包各种使用 && 设置参数,函数传值

    CategoryBottomView.swift文件里:

     override init(frame: CGRect) {

            super.init(frame: frame)

           

            var outGroups = [AnyObject]()

    //传入了outGroups参数

            YMNetworkTool.shareNetworkTool.loadCategoryGroup {  [weak self] (outGroups) in

                self!.outGroups = outGroups

                self!.setupUI()

            }

        }



      YMNetworkTool.swift文件里:


     func loadCategoryGroup(finishe:(outGroups: [AnyObject]) -> ()) {

                 //执行各种操作

    。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。省略


                            outGroups.append(inGroups)

                   //将得到的outGroups的数据传传递进去

                            finishe(outGroups: outGroups)

            }

        



    闭包的表达式语法

    闭包表达式语法有如下的一般形式:

    ?
    1
    2
    3
    { (parameters/接收的参数) -> (returntype/闭包返回值类型) in
     statements/保存在闭包中需要执行的代码
    }

    闭包根据你的需求是有类型的,闭包的类型 一般形式如下:

    (parameters/接收的参数) -> (return type/闭包返回值类型)

    利用typealias为闭包类型定义别名

    这里先介绍一下 typealias的使用 : typealias是Swift中用来为已经存在的类型重新定义名字的关键字(类似于OC语法中的 typedef),重新命名的新名字用来替代之前的类型,并且能够使代码变得更加清晰简单容易理解。typealias 的用法很简单,直接用 = 赋值就可以了:

    typealias <type name> = <type expression>

    这里我们可以用 typealias 来为看似较为复杂的闭包类型定义别名,这样以后我们就可以用别名直接去申明这样类型的闭包了,例子如下:

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    //为没有参数也没有返回值的闭包类型起一个别名
     typealias Nothing = () -> ()
     
     //如果闭包的没有返回值,那么我们还可以这样写,
     typealias Anything = () -> Void
     
     //为接受一个Int类型的参数不返回任何值的闭包类型 定义一个别名:PrintNumber
     typealias PrintNumber = (Int) -> ()
     
     //为接受两个Int类型的参数并且返回一个Int类型的值的闭包类型 定义一个别名:Add
     typealias Add = (Int, Int) -> (Int)

    闭包是否接受参数、接受几个参数、返回什么类型的值完全取决于你的需求。

    闭包的创建、赋值、调用

    闭包表达式语法能够使用常量形式参数、变量形式参数和输入输出形式参数,但不能提供默认值。可变形式参数也能使用,但需要在形式参数列表的最后面使用。元组也可被用来作为形式参数和返回类型。在闭包的中会用到一个关键字in,in 可以看做是一个分割符,他把该闭包的类型和闭包的函数体分开,in前面是该闭包的类型,in后面是具体闭包调用时保存的需要执行的代码。表示该闭包的形式参数类型和返回类型定义已经完成,并且闭包的函数体即将开始执行。这里总结了一下可能用到的几种形式实现闭包的创建、赋值、调用的过程。例子如下:

    方式一:利用typealias最完整的创建

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    //为(_ num1: Int, _ num2: Int) -> (Int) 类型的闭包定义别名:Add
     typealias Add = (_ num1: Int, _ num2: Int) -> (Int)
    //创建一个 Add 类型的闭包常量:addCloser1
     let addCloser1: Add
    //为已经创建好的常量 addCloser1 赋值
     addCloser1 = {
      (_ num1: Int, _ num2: Int) -> (Int) in
      returnnum1 + num2
     }
    //调用闭包并接受返回值
     let result = addCloser1(20, 10)

    形式二:闭包类型申明和变量的创建合并在一起

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    //创建一个 (_ num1: Int, _ num2: Int) -> (Int) 类型的闭包常量:addCloser1
     let addCloser1: (_ num1: Int, _ num2: Int) -> (Int)
    //为已经创建好的常量 addCloser1 赋值
     addCloser1 = {
       (_ num1: Int, _ num2: Int) -> (Int) in
       returnnum1 + num2
     }
     //调用闭包并接受返回值
     let result = addCloser1(20, 10)

    形式三:省略闭包接收的形参、省略闭包体中返回值

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    //创建一个 (Int, Int) -> (Int) 类型的闭包常量:addCloser1
     let addCloser1: (Int, Int) -> (Int)
    //为已经创建好的常量 addCloser1 赋值
     addCloser1 = {
       (num1, num2) in
       returnnum1 + num2
     }
    //调用闭包并接受返回值
     let result = addCloser1(20, 10)

    形式四:在形式三的基础上进一步精简

    ?
    1
    2
    3
    4
    5
    6
    7
    //创建一个 (Int, Int) -> (Int) 类型的闭包常量:addCloser1 并赋值
     let addCloser1: (Int, Int) -> (Int) = {
       (num1, num2) in
       returnnum1 + num2
      }
    //调用闭包并接受返回值
     let result = addCloser1(20, 10)

    形式五:如果闭包没有接收参数省略in

    ?
    1
    2
    3
    4
    5
    6
    //创建一个 () -> (String) 类型的闭包常量:addCloser1 并赋值
      let addCloser1: () -> (String) = {
       return"这个闭包没有参数,但是有返回值"
       }
     //调用闭包并接受返回值
      let result = addCloser1()

    形式六:简写的实际参数名

    ?
    1
    2
    3
    4
    5
    6
    //创建一个 (String, String) -> (String) 类型的闭包常量:addCloser1 并赋值
      let addCloser1: (String, String) -> (String) = {
       return"闭包的返回值是:\($0),\($1)"
       }
     //调用闭包并接受返回值
      let result = addCloser1("Hello","Swift!")

    说明: 得益于Swift的类型推断机制,我们在使用闭包的时候可以省略很多东西,而且Swift自动对行内闭包提供简写实际参数名,你也可以通过 $0, $1, $2 等名字来引用闭包的实际参数值。如果你在闭包表达式中使用这些简写实际参数名,那么你可以在闭包的实际参数列表中忽略对其的定义,并且简写实际参数名的数字和类型将会从期望的函数类型中推断出来。in关键字也能被省略,$0 和 $1 分别是闭包的第一个和第二个 String类型的 实际参数(引自文档翻译)。

    闭包常见的几种使用场景

    基本掌握闭包的概念后,我们就可以利用闭包做事情了,下面介绍一下闭包在开发中的可能被用到的场景。
    场景一:利用闭包传值
    开发过程中常常会有这样的需求:一个页面的得到的数据需要传递给前一个页面使用。这时候使用闭包可以很简单的实现两个页面之间传值。


    frameborder="0" allowtransparency="true" scrolling="no" vspace="0" hspace="0" style="display: block; position: static; padding: 0px; margin: 0px; border-style: none; vertical-align: baseline; width: 604px; height: 112px;">


    图片发自简书App

    场景再现:

    第一个界面中有一个用来显示文字的UILabel和一个点击进入到第二个界面的UIButton,第二个界面中有一个文本框UITextField和一个点击返回到上一个界面的UIButton,现在的需求是在第二个界面的UITextField中输入完文字后,点击返回按钮返回到第一个界面并且将输入的文字显示在第一个界面(当前页面)的UILabel中。

    实现代码:

    首先在第二个界面的控制器中定义一个( String) -> ()可选类型的闭包常量closer作为SecondViewController的属性。closer接收一个String类型的参数(就是输入的文字)并且没有返回值。然后在返回按钮的点击事件中传递参数执行闭包。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    import UIKit
    class SecondViewController: UIViewController {
     //输入文本框
     @IBOutlet weak var textField: UITextField!
     //为创建一个(String) -> () 的可选类型的闭包变量作为控制器的属性
     var closer: ((String) -> ())?
     //返回按钮的点击事件
     @IBAction func backButtonDidClick(_ sender: AnyObject) {
      //首先判断closer闭包是否已经被赋值,如果已经有值,直接调用该闭包,并将输入的文字传进去。
      if closer != nil {
       closer!(textField.text!)
      }
      navigationController?.popViewController(animated: true)
     }
    }

    这里有一个注意点:我们在为SecondViewController定义变量闭包属性的时候需要将类型申明为可选类型,闭包可选类型应该是((String) -> ())?而不是(String) -> ()?的,后者指的是闭包的返回值是可选类型。

    回到第一个界面的控制器中,我们需要拖线拿到UILabel的控件,然后重写prepare(for segue: UIStoryboardSegue, sender:Any?) { }方法,在这个跳转方法中拿到跳转的目标控制器SecondVC并为他的闭包属性赋值,当然如果你的跳转按钮的点击事件是自己处理的,直接在按钮的点击事件中这样做就OK了。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    import UIKit
    class FirstViewController: UIViewController {
     //显示文字的label
     @IBOutlet weak var label: UILabel!
     //重写这个方法
     override func prepare(for segue: UIStoryboardSegue, sender: Any?) {
      //拿到跳转的目标控制器
      let secondVC = segue.destination as! SecondViewController
      //为目标控制器的闭包属性赋值
      secondVC.closer = {
       //将闭包的参数(输入的文本内容)显示在label上
       self.label.text = $0
      }
     }
    }

    经过上面的处理,我们就可以实现两个页面之间的传值了(是不是很简单呢),当然在具体的开发中很可能不是传递文本内容这么简单,当需要传递更复杂的值时,我们可以将传递的值包装成一个模型,直接用闭包传递模型就好了。

    场景二:闭包作为函数的参数

    在OC语法中block可以作为函数的参数进行传递,在Swift中同样可以用闭包作为函数的参数,还记得上面利用typealias关键字定义别名吗,定义完的别名就是一个闭包类型,可以用它申明一个闭包常量或变量当做参数进行传递。一个最简单的闭包作为函数参数例子如下:

    1
    2
    3
    4
    5
    6
    //为接受一个Int类型的参数并且返回一个Int类型的值的闭包类型定义一个别名:Number
     typealias Number = (num1: Int) -> (Int)
     //定义一个接收Number类型的参数没有返回值的方法
     func Text(num: Number) {
      //code
     }

    闭包在作为函数的参数进行传递的时候根据函数接收参数的情况有很多种不同的写法。这里我们主要介绍一下尾随闭包的概念。

    首先看一下一般形式的闭包作为函数的参数传递:

    1
    2
    3
    4
    5
    6
    7
    8
    //拼接两个字符串和一个整数
     func combine(handle:(String, String) -> (Void), num: Int) {
       handle("hello", "world \(num)")
      }
    //方法调用
     combine(handle: { (text, text1) -> (Void) in
       print("\(text) \(text1)")
       }, num: 2016)

    可以看到上面的combine方法在主动调用的时候依旧是按照func(形参: 实参)这样的格式。当我们把闭包作为函数的最后一个参数的时候就引出了尾随闭包的概念。

    一,尾随闭包

    尾随闭包是指当需要将一个很长的闭包表达式作为函数最后一个实际参数传递给函数时,一个书写在函数形式参数的括号外面(后面)的闭包表达式:

    1
    2
    3
    4
    5
    6
    func combine1(num:Int, handle:(String, String)->(Void)) {
      handle("hello", "world \(num)")
    }
    combine1(num: 2016) { (text, text1) -> (Void) in
      print("\(text) \(text1)")
    }

    进一步:如果闭包表达式被用作函数唯一的实际参数并且你把闭包表达式用作尾随闭包,那么调用这个函数的时候函数名字的()都可以省略:

    1
    2
    3
    4
    5
    6
    func combine2(handle:(String, String)->(Void)) {
      handle("hello", "world")
    }
    combine2 { (text, text1) -> (Void) in
      print("\(text) \(text1)")
    }

    二,逃逸闭包

    如果一个闭包被作为一个参数传递给一个函数,并且在函数return之后才被唤起执行,那么我们称这个闭包的参数是“逃出”这个函数体外,这个闭包就是逃逸闭包。此时可以在形式参数前写 @escaping来明确闭包是允许逃逸的。
    闭包可以逃逸的一种方法是被储存在定义于函数外的变量里。比如说,很多函数接收闭包实际参数来作为启动异步任务的回调。函数在启动任务后返回,但是闭包要直到任务完成——闭包需要逃逸,以便于稍后调用。用我们最常用的网络请求举例来说:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    func request(methodType:RequestMethodType, urlString: String, parameters: [String : AnyObject], completed: @escaping (AnyObject?, NSError?) -> ()) {
      // 1.封装成功的回调
      let successCallBack = { (task : URLSessionDataTask?, result : Any?) -> Void in
       completed(result as AnyObject?, nil)
      }
      // 2.封装失败的回调
      let failureCallBack = { (task : URLSessionDataTask?, error : Error?) -> Void in
       completed(nil, error as NSError?)
      }
      //判断是哪种请求方式
      if methodType == .get {
       get(urlString, parameters: parameters, success: successCallBack, failure: failureCallBack)
      } else {
       post(urlString, parameters: parameters, success: successCallBack, failure: failureCallBack)
      }
     }

    这里的completed闭包被作为一个参数传递给request函数,并且在函数调用get或post后才会被调用。

    使用闭包可能引起的循环强引用
    Swift中不当的使用闭包可能会引起循环强引用,之所以称之为“强”引用,是因为它会将实例保持住,只要强引用还在,实例是不允许被销毁的。循环强引用会一直阻止类实例的释放,这就在你的应用程序中造成了内存泄漏。
    举个例子:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    import UIKit
    class ThirdViewController: UIViewController {
     var callBack: ((String) -> ())?
     override func viewDidLoad() {
      super.viewDidLoad()
      printString { (text) in
       print(text)
       //闭包中捕获了self
       self.view.backgroundColor = UIColor.red
      }
     }
     func printString(callBack:@escaping (String) -> ()) {
      callBack("这个闭包返回一段文字")
      //控制器强引用于着callBack
      self.callBack = callBack
     }
     deinit {
      print("ThirdViewController---释放了")
     }
    }


    frameborder="0" allowtransparency="true" scrolling="no" vspace="0" hspace="0" style="display: block; position: static; padding: 0px; margin: 0px; border-style: none; vertical-align: baseline; width: 604px; height: 112px;">
     

    当你在定义printString这个方法时执行self.callBack = callBack代码实际上是self对callBack闭包进行了强引用,到这里其实并没有产生循环引用,但是当你在调用printString方法的闭包里面又访问了self.view.backgroundColor属性,此时强引用就发生了,即self引用了callBack,而callBack内部又引用着self,谁都不愿意松手,我们就说这两者之间产生了循环强引用。

    使用闭包何时会出现循环强引用 :

    当你把一个闭包分配给类实例属性的时候,并且这个闭包中又捕获了这个实例。捕获可能发生于这个闭包函数体中访问了实例的某个属性,比如 self.someProperty ,或者这个闭包调用了一个实例的方法,例如 self.someMethod() 。这两种情况都导致了闭包捕获了self ,从而产生了循环强引用。

    闭包循环引用的本质是:

    闭包中循环强引用的产生,是因为闭包和类相似(还有一种两个类实例之间的循环强引用),都是引用类型。当你把闭包赋值给了一个属性,你实际上是把一个引用赋值给了这个闭包。两个强引用让彼此一直有效。

    如何解决闭包的循环强引用:

    方式一:类似于OC中使用__weak解决block的循环引用,Swift中支持使用weak关键字将类实例声明为弱引用类型(注意,弱引用类型总是可选类型),打破类实例对闭包的强引用,当对象销毁之后会自动置为nil,对nil进行任何操作不会有反应。

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    import UIKit
    classThirdViewController: UIViewController {
     var callBack: ((String) -> ())?
     override func viewDidLoad() {
      super.viewDidLoad()
      //将self申明为弱引用类型,打破循环引用
      weak var weakSelf = self
      printString { (text) in
       print(text)
       //闭包中铺捕获了self
       weakSelf?.view.backgroundColor = UIColor.red
      }
     }
     func printString(callBack:@escaping (String) -> ()) {
      callBack("这个闭包返回一段文字")
      //控制器强引用于着callBack
      self.callBack = callBack
     }
     deinit {
      print("ThirdViewController---释放了")
     }
    }

    方式二:作为第一种方式的简化操作,我们可以在闭包的第一个大括号后面紧接着插入这段代码[weak self],后面的代码直接使用self?也能解决循环引用的问题。

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    import UIKit
    classThirdViewController: UIViewController {
      var callBack: ((String) -> ())?
      override func viewDidLoad() {
        super.viewDidLoad()
        printString {[weak self] (text) in
          print(text)
          self?.view.backgroundColor = UIColor.red
        }
      }
      func printString(callBack:@escaping (String) -> ()) {
        callBack("这个闭包返回一段文字")
        //控制器强引用于着callBack
        self.callBack = callBack
      }
      deinit {
        print("ThirdViewController---释放了")
      }
    }

    方式三:在闭包和捕获的实例总是互相引用并且总是同时释放时,可以将闭包内的捕获定义为无主引用unowned。

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    import UIKit
    classThirdViewController: UIViewController {
      var callBack: ((String) -> ())?
      override func viewDidLoad() {
        super.viewDidLoad()
        printString {[unowned self] (text) in
          print(text)
          self?.view.backgroundColor = UIColor.red
        }
      }
      func printString(callBack:@escaping (String) -> ()) {
        callBack("这个闭包返回一段文字")
        //控制器强引用于着callBack
        self.callBack = callBack
      }
      deinit {
        print("ThirdViewController---释放了")
      }
    }

    注意:unowned是Swift中另外一种解决循环引用的申明无主引用类型的关键字,类似于OC中的__unsafe_unretained;大家都知道__weak和__unsafe_unretained的相同点是可以将该关键字修饰的对象变成弱引用解决可能存在的循环引用。不同点在于前者修饰的对象如果发现被销毁,那么指向该对象的指针会立即指向nil,而__unsafe_unretained修饰的对象如果发现被销毁,指向该对象的指针依然指向原来的内存地址,如果此时继续访问该对象很容易产生坏内存访问/野指针/僵尸对象访问。
    同样的道理Swift中也是一样的。和弱引用类似,无主引用不会牢牢保持住引用的实例。但是不像弱引用,总之,无主引用假定是永远有值的。因此,无主引用总是被定义为非可选类型。你可以在声明属性或者变量时,在前面加上关键字unowned 表示这是一个无主引用。由于无主引用是非可选类型,你不需要在使用它的时候将它展开。无主引用总是可以直接访问。不过 ARC 无法在实例被释放后将无主引用设为 nil ,因为非可选类型的变量不允许被赋值为 nil 。如果此时继续访问已经被释放实例很容易产生坏内存访问/野指针/僵尸对象访问。

    所以Swift建议我们如果被捕获的引用永远不为 nil ,应该用unowned而不是weak,相反,如果你不确定闭包中捕获的引用是不是存在为nil的可能,你应该使用weak。


    展开全文
  • RT A界面 接收B界面返回的时候的值 A界面  let vc = CZHourPicker()    vc.backClosure = {(backStr: String) -> Void in ... self.durationBtn.setTitle(backStr, for: UIControlS

    RT


    A界面 接收B界面返回的时候的值


    A界面


            let vc = CZHourPicker()
            
            vc.backClosure = {(backStr: String) -> Void in
                self.durationBtn.setTitle(backStr, for: UIControlState.normal)
                self.durationBtnT.setTitle(backStr, for: UIControlState.normal)
            }
            
            self.present(vc, animated: true, completion: nil)


    B界面

    //定义闭包类型(特定的函数类型函数类型)
    typealias InputClosureType = (String) -> Void


      //接收上个页面传过来的闭包块
        var backClosure: InputClosureType?




           self.backClosure!(resultStr)
           self.dismiss(animated: true, completion: nil)




    展开全文
  • Swift 传值之闭包传值

    2016-01-29 16:37:31
    Swift闭包传值和OC中的block传值非常相似 项目的建立和之前的属性传值和代理传值类似  属性传值:http://blog.csdn.net/zhangjitao_boke/article/details/50606185 代理传值:...

    Swift的闭包传值和OC中的block传值非常相似

    项目的建立和之前的属性传值和代理传值类似 

    属性传值:http://blog.csdn.net/zhangjitao_boke/article/details/50606185

    代理传值:http://blog.csdn.net/zhangjitao_boke/article/details/50606707

    闭包传值:http://blog.csdn.net/zhangjitao_boke/article/details/50607325

    通知传值:http://blog.csdn.net/zhangjitao_boke/article/details/50607818

    单例传值:http://blog.csdn.net/zhangjitao_boke/article/details/50608066

    直接上代码

    在FirstViewController中

    //
    // FirstViewController.swift
    // BiBaoPassValue
    //
    // Created by JT on 16/1/29.
    // Copyright © 2016年 JT. All rights reserved.
    //

    import UIKit

    class FirstViewController: UIViewController {

    @IBOutlet weak var firstTextField: UITextField!

    override func viewDidLoad() {
    super.viewDidLoad()
    }

    override func touchesBegan(touches: Set<UITouch>, withEvent event: UIEvent?) {
    let storyBoard = UIStoryboard.init(name: "Main", bundle: nil)
    let secondVC = storyBoard.instantiateViewControllerWithIdentifier("secondVC") as! SecondViewController
    // 给secondVC的闭包实现方法
    secondVC.passValue = { (text:String) -> Void in
    // 闭包方法传过来值
    self.firstTextField.text = text
    }

    self.navigationController?.pushViewController(secondVC, animated: true)
    }
    }

    SecondViewController中实现代码

    //
    // SecondViewController.swift
    // BiBaoPassValue
    //
    // Created by JT on 16/1/29.
    // Copyright © 2016年 JT. All rights reserved.
    //

    import UIKit

    // 定义一个闭包类型
    typealias passValueClosure = (String) -> Void


    class SecondViewController: UIViewController {

    @IBOutlet weak var secondTextField: UITextField!
    // 闭包变量
    var passValue:passValueClosure?


    override func viewDidLoad() {
    super.viewDidLoad()
    self.navigationItem.leftBarButtonItem = UIBarButtonItem(title: "", style: UIBarButtonItemStyle.Plain, target: self, action: "backAction")
    }

    func backAction() {
    // 如果闭包不为空
    if passValue != nil {
    self.passValue!(secondTextField.text!)
    }

    self.navigationController?.popViewControllerAnimated(true)
    }

    }

    这样就能实现闭包传值了,闭包传值记住几点

    1 声明闭包类型

    2 在要传值的界面定义闭包变量

    3 判断闭包变量是否为nil,如果不为nil的话,就执行闭包传值

    4 在接收的控制器里设置传值控制器闭包的方法,接收值。

    展开全文
  • B - > A 使用闭包进行反向回调传值Swift 使用闭包(Closure)传值的原理,与OC 中使用代码块(block)传值原理,基本类似按步骤可以如下理解: 1、定义闭包。 2、闭包赋值(传送) 3、闭包调用。至于定义闭包应该...

    实现例子由两个界面组成
    A - > B 使用属性传值
    B - > A 使用闭包进行反向回调传值

    Swift 使用闭包(Closure)传值的原理,与OC 中使用代码块(block)传值原理,基本类似

    按步骤可以如下理解:
    1、定义闭包。
    2、闭包赋值(传送)
    3、闭包调用。

    至于定义闭包应该在哪个页面定义?

    想对于当前界面上执行某个操作,就在当前界面上定义,
    比如:我想给通过 B 界面回调 给 A 界面上的文本框赋值,赋值操作是在 A 界面上执行的、那么闭包就应该定义在 A 界面上。既然定义在 A ,那么 B 界面就是调用闭包地方,。找准实现者,跟调用者,然后在调用者界面定义属性用于接收闭包即可;

    实现代码:

    一级界面 A :

    import UIKit
    
    class ViewController: UIViewController {
    
        var textLab:UILabel?
        override func viewDidLoad() {
            super.viewDidLoad()
            //创建一个文本显示lab
            textLab = UILabel(frame:CGRectMake(80, 50, 120, 40));
            textLab?.backgroundColor = UIColor.yellowColor();
            textLab?.textAlignment = NSTextAlignment.Center;
            self.view.addSubview(textLab!);
    
            //创建一个按钮用于添加事件 A->B 属性传值
            var nextBtn = UIButton(frame: CGRectMake(80, 120, 120, 40))
            nextBtn.setTitle("下一页", forState: UIControlState.Normal);
            nextBtn.backgroundColor = UIColor.redColor();
            nextBtn.addTarget(self, action: "nextBtnAction", forControlEvents: UIControlEvents.TouchUpInside);
            self.view.addSubview(nextBtn);
    
        }
        //定义一个带字符串参数的闭包
        func myClosure(testStr:String)->Void{
            //给textLab 赋值
            //这句话什么时候执行?,闭包类似于oc中的block或者可以理解成c语言中函数,只有当被调用的时候里面的内容才会执行
            textLab?.text = testStr;
        }
    
        func nextBtnAction(){
    
            //获取目标页面对象
            var secondVC:SecondViewController = SecondViewController();
            //属性赋值
            secondVC.str = "属性传值"
            //将闭包传递到二级界面,在二级界面中调用
            secondVC.testClosure = myClosure;
            //模态视图跳转
            self .presentViewController(secondVC, animated: true, completion: nil);
    
        }
    

    二级界面 B :

    import UIKit
    
    //类似于OC中的typedef
    typealias sendValueClosure=(string:String)->Void
    
    class SecondViewController: UIViewController {
    
        var str:String?
        //声明一个闭包
        var testClosure:sendValueClosure?
    
        override func viewDidLoad() {
            super.viewDidLoad()
    
            //创建一个文本显示lab
            var textLab = UILabel(frame:CGRectMake(80, 50, 120, 40));
            textLab.backgroundColor = UIColor.yellowColor();
            textLab.textAlignment = NSTextAlignment.Center;
            //给文本框赋值,这个值来自上一个界面
            textLab.text = str;
            self.view.addSubview(textLab);
    
            //创建一个按钮用于添加事件 B->A 闭包回调传值
            var backBtn = UIButton(frame: CGRectMake(80, 120, 120, 40))
            backBtn.setTitle("返回", forState: UIControlState.Normal);
            backBtn.backgroundColor = UIColor.redColor();
            backBtn.addTarget(self, action: "backBtnAction", forControlEvents: UIControlEvents.TouchUpInside);
            self.view.addSubview(backBtn);
        }
    
        func backBtnAction(){
    
            /**
            先判断闭包是否存在,然后再调用
            */
            if (testClosure != nil){
                testClosure!(string: "回调传值")
            }
    
            self .dismissViewControllerAnimated(true, completion: nil)
        }
    
    
    展开全文
  • Swift闭包类似于OC中的block,所以我理解的用法基本可以参照block 唯一需要注意的就是格式问题了,现在将我探索的格式分享给大家 定义一个Person类:import Cocoaclass Person: NSObject { public var name:...

    Swift的闭包类似于OC中的block,所以我理解的用法基本可以参照block 唯一需要注意的就是格式问题了,现在将我探索的格式分享给大家
    定义一个Person类:

    import Cocoa
    
    class Person: NSObject {
        public var name:String
        public var runBlock:((Void)->Void)?
        init(name:String) {
            self.name = name
            super.init()
        }
        public func personRun(){
            self.runBlock!()
        }
    
    }

    从其中可以看出一个闭包的简单类型定义和调用,我觉得将它定义为可选类型是因为觉得它有可能为空。
    接着定义一个Car类:

    import Cocoa
    
    class Car: NSObject {
        public var Carname:String
        init(Carname:String) {
            self.Carname = Carname
            super.init()
    
        }
    }

    接着在main 中创建两个对象,实现传值:

    let car = Car.init(Carname: "大众")
    let jack = Person.init(name: "jack")
    jack.runBlock = {(Void) in
        print("\(jack.name)开着\(car.Carname)在公路上行驶")
    }
    jack.personRun()
    

    闭包的赋值就在这里了,只要牢记这闭包的三个步骤:定义、调用、赋值三个的格式(写法)其他的跟block用起来应该还是类似的
    查看打印结果:
    这里写图片描述
    可以看到Person 对象和 Car对象之间并没有用属性关联起来,但是却完成了传值,这大概就是我们经常讲的弱耦合吧。
    最后呢,我的水平一般,如果有大神觉得我写的不对,一定要告诉我啊,我感激不尽。

    展开全文
  • Swift 闭包(block)传值

    2016-04-30 12:17:45
    这篇就介绍关于闭包传值的使用。在iOS常用的三种反向传值方式也就基本介绍完了。效果图具体使用步骤在SecondViewController里面 1.声明一个block/// 声明一个block typealias SecondViewControll
  • swift开发使用闭包传值开发中,从一个页面跳转到另一个页面的时候,有时候需要到跳转后的页面把值传回上一个页面,这里介绍一下swift开发中使用闭包传值 首先我们创建两个视图控制器分别为”ViewController“和”...
  • swift 闭包传值问题

    2018-10-30 17:09:40
    /* urlStr: 请求地址 outTime: 请求超时事件 info : 请求参数 finished : 请求成功的回调 finishedError : 请求不成功的回调 ...func requestData(urlStr : String,outTime : Double ,info : Dictionary&...
  • class ViewController: UIViewController { //声明一个控制器 let viControl = ggViewController() override func viewDidLoad() { super.viewDidLoad() ...
  • 闭包参考:http://c.biancheng.net/cpp/html/2285.html  闭包详解 ...Swift利用闭包(closure)来实现传值--&gt;前后两个控制器的反向传值   import UIKit class ZWRootViewController: UIVie...
  • Swift 的界面之间的传值,详细介绍3种传值方式》正向传值、协议传值闭包   1、 控制器界面间的正向传值   /*  《Swift 的界面之间的传值,详细介绍3种传值方式》  正向传值、协议传值、...
  • 使用闭包传值

    2018-04-02 20:20:16
    //2个界面传值反向 第一个界面 import UIKit //闭包 typealias TwoViewControllerClosure = (_ text:String) -&gt;Void class ViewController: UIViewController{ let textlable = UILabel(); let TwoVc ...
  • swift使用delegate和closure进行传值:类似oc的代理和block firstViewController.swift文件 // // firstViewController.swift // testPageControl // // Created by yinlinlin on 15/12/29. // C
  • Swift 闭包(Closures)传值

    2016-04-18 17:45:20
    // ViewController.swift // YlwDome // // Created by ylw on 16/2/18. // Copyright © 2016年 Ylw. All rights reserved. //import UIKitclass ViewControllerOne: UIViewController {var name:String
  • 随着Swift的日益完善,终究会取代OC的地位,就像Kotlin取代Java一样,不是时间的问题,而是使用者愿意不愿意被时代淘汰的问题首先是Swift中定义闭包
  • swift3.0 实现block属性反向传值,实现storyboard 拆分,防止storyboard多人开发出现代码冲突的问题。多线程GCD swift3.0 版本的简单实现。
  • 基本操作就是在第二个页面定义一个闭包函数,然后在第一个页面将定义好的函数,通过函数指针传递到第二个页面,然后就阔以了。废话不多说,直接上代码// // ViewController.swift // SwiftClosure // // Created by ...
  • Swift闭包(Closures)

    2015-10-28 15:20:49
    闭包是自包含的功能代码块,可以在代码中使用或者用来作为参数传值。 在Swift中的闭包与C、OC中的blocks和其它编程语言(如Python)中的lambdas类似。 闭包可以捕获和存储上下文中定义的的任何常量和变量的引用。...
  • swift2.0 用闭包表达式 和 protocol 传值回调 http://blog.csdn.net/lengshengren/article/details/4915643 swift协议代理的使用以及解决循环引用问题 http://blog.csdn.net/code_worm/article/details/48005313 ...
  • Swift5.1 闭包

    2019-11-27 11:24:42
    Swift 闭包
1 2 3 4 5 ... 20
收藏数 618
精华内容 247