iOS开发之一篇文章学会页面传值详解 - 十种页面传值方法大全 swift 版本

1、最简单AB面正向传值

效果如下：

最简单的正向传值.gif

首先我们先创建两个视图控制器ViewController.swift和SubViewController.swift

设置第一个界面

首先在第一个界面创建好一个TextFeild，用来写我们要传的文字

import UIKit

class ViewController: UIViewController {

    let textField = UITextField()

    override func viewDidLoad() {
        super.viewDidLoad()

        self.view.backgroundColor = UIColor.whiteColor()
        textField.frame = CGRectMake(7, 100, 400, 50)
        textField.borderStyle = .RoundedRect
        self.view.addSubview(textField)
    }
}

在这里我们设置当点击屏幕跳转到第二个界面
并且执行传值操作

在SubViewController里设置一个公开的属性去接收数据

var string: String?

在ViewController里设置点击屏幕时传值

 //当点击屏幕时执行该方法
 override func touchesBegan(touches: Set<UITouch>, withEvent event: UIEvent?) { 

         //MARK:创建第二个界面的对象
        let svc = SubViewController()
        //MARK：通过属性来进行正向传值
        svc.string = self.textField.text


        //跳转到第二个界面
        self.presentViewController(svc, animated: true, completion: nil)

    }

在第二个界面里创建好一个label用来接收值

添加一个label控件

 //控件不公开
    private let textLabel = UILabel()
    override func viewDidLoad() {
        super.viewDidLoad()

        self.view.backgroundColor = UIColor.cyanColor()
        textLabel.frame = CGRectMake(7, 200, 400, 50)
        textLabel.textAlignment = .Center
        self.view.addSubview(textLabel)

在视图将要显示的时候将传进来的值赋值给控件

    override func viewWillAppear(animated: Bool) {
        super.viewWillAppear(animated)
        //在视图将要显示的时候，去将传进来的值，赋给控件
        self.textLabel.text = string
    }

当点击屏幕时，返回第一个界面

    override func touchesBegan(touches: Set<UITouch>, withEvent event: UIEvent?) {
        //返回上一页面
        self.dismissViewControllerAnimated(true, completion: nil)
    }

2、利用属性进行AB页面的反向传值

效果如下：

简单反向传值.gif

首先我们先创建两个视图控制器ViewController.swift和SubViewController.swift

第一步

在ViewController里面设置好一个固定的Label,设置显示的文字为：Location Services，和一个显示状态的statusLabel

第二步

在SubViewController里定义一个属性，去接收返回值的目标对象

var vc: ViewController?

然后放置一个UISwitch，设置开关的相应方法

    //设置开关的响应方法
    func swAction(sw:UISwitch){

        //判断状态
        if sw.on {

        //MARK:此步骤实现反向传值，将状态值回传给A页面
            self.vc?.lsStatusLabel.text = "ON"
        }else{
            self.vc?.lsStatusLabel.text = "OFF"
        }

    }

第三步

在ViewController里面设置touchBegan方法

      override func touchesBegan(touches: Set<UITouch>, withEvent event: UIEvent?) {
          //MARK:实例化一个第二个界面的对象
        let svc = SubViewController()

        //给B页面传值，告诉B回传数据的目标是谁
        svc.vc = self

        //点击屏幕时跳转到第二个界面
        self.presentViewController(svc, animated: true, completion: nil)
    }

3、利用NSUserDefult双向传值

效果如下：

NSUserDefault.gif

原理：NSUserDefaults是系统对plist文件封装好的一个类，我们可以通过这个类对文件进行读写，在在HomeDirectory/Library/preferences/XXX.userdefaults.plist下。利用NSUserDefaults的特性，将某一个界面要传出的值存入到plist文件中，然后再另一个界面从plist文件读出来，就完成了传值操作

第一步

创建好ViewController和SubViewController

在ViewController中布局好Label的位置

第二步

在SubViewController中创建好5个按钮，为每个按钮添加tag值，并且实现交替选中效果，代码如下：

 for i in 0..<5 {
            let button = UIButton(type: .System)
            button.setTitle("第\(i + 1)个按钮", forState: .Normal)
            button.frame = CGRectMake(7, CGFloat(150 + i * 100), 400, 100)
            //为每一个button设置tag值
            button.tag = 100 + i
            //点击事件
            button.addTarget(self, action: #selector(self.buttonAction(_:)), forControlEvents: .TouchUpInside)
            self.view.addSubview(button)
        }

设置点击事件,实现交替选中效果

 for i in 0..<5 {
            let btn = self.view.viewWithTag(100 + i) as! UIButton
            btn.selected = false
        }
        sender.selected = true

在点击事件中同时使用NSUserDefaults将该按钮的tag值写入plist文件，做成数据记录
首先获取NSUserDefaults对象，这个对象是一个单例对象

let userDefaults = NSUserDefaults.standardUserDefaults()

将按钮的tag值做成数据记录

let selectedIndex = String(sender.tag)

写入plist文件

userDefaults.setObject(selectedIndex, forKey: "selectedIndex")

回写文件

userDefaults.synchronize()

第三步

从ViewController的viewWillAppear函数中我们读取plist文件，并完成反向传值

首先获取NSUserDefaults的对象
let userDefaults = NSUserDefaults.standardUserDefaults()

读取出数据,获取出SubViewController中对应button的tag值

let si = userDefaults.objectForKey("selectedIndex")

此时的si是AnyObject类型，我们将他转化成int类型

let tag = si?.intValue

然后修改ViewController中的label的文字

self.label.text = "第\(tag! - 99)个按钮是选中转态"

到这儿，就完成了反向传值的过程，第二个界面的哪个button被选中在第一个界面就会显示出来，效果如下

NSUserDefaults正向.gif

但是，再次从第一个界面跳回第二个界面是，按钮就变成全部为未选中状态，下面就是实现执行正向传值

同样是获取NSUserDefaults对象，然后读取数据，最后获取tag值找到对象button，设置该button为选中状态，在这儿还需读者自行去完成接下来的内容

4、使用系统闭包反向传值

这种方式是使用系统自带的闭包

  self.presentViewController(UIViewController, animated: Bool) { 
            code
        }

这种传值方式传值会有延迟，因为是在执行完页面切换后再去进行传值
效果如下：

系统闭包传值.gif

第一步

首先创建好ViewController和SubViewController
viewController中布局好一个label用来显示接收到数据，在SubViewController中布局好一个TextFeild用来写数据

第二步

在SubViewController中创建一个接收属性

var vc: ViewController?

第三步

在ViewController中写touchBegan方法
获取第SubViewController对象，在presentViewController方法中打开闭包，在将ViewController传给SubViewController的vc

 override func touchesBegan(touches: Set<UITouch>, withEvent event: UIEvent?) {
        let svc = SubViewController()
        //将视图控制器本身传过去，方便回传使用
        self.presentViewController(svc, animated: true) { 
            //这个方法是在弹出下一页面后执行
            svc.vc = self
        }
    }

第四步

在SubViewController中写touchBegan方法
在self.dismissViewControllerAnimated方法中打开闭包将属性tf中的文字回传给属性vc的textLabel

 override func touchesBegan(touches: Set<UITouch>, withEvent event: UIEvent?) {
        self.dismissViewControllerAnimated(true) {
            //利用这个闭包来回传数据
            self.vc!.textLabel.text = self.tf.text

        }
    }

5、自定义闭包传值

和使用系统闭包传值的思想相同，自定义闭包传值就是自己声明一个闭包，通过这个闭包来进行页面之间的相互传值
效果同第4种

第一步

创建好ViewController和SubViewController
分别在vc和subvc中布局好一个label和textFeild

在SubViewController中声明一个闭包

var backValueClusore:((text:String)->Void)?

第二步

在ViewController中写touchBegan方法
获取第SubViewController对象，在presentViewController方法中打开闭包，在将ViewController传给SubViewController的vc

 override func touchesBegan(touches: Set<UITouch>, withEvent event: UIEvent?) {
        let svc = SubViewController()
        self.presentViewController(svc, animated: true, completion: nil)

        //MARK:将闭包中的text赋值给self.textLabel
        svc.backValueclusore = {(text:String)->Void in
            self.textLabel.text = text

    }

第三步

在SubViewController中写touchBegan方法
在self.dismissViewControllerAnimated方法中打开闭包将属性tf中的文字回传给属性vc的textLabel

 override func touchesBegan(touches: Set<UITouch>, withEvent event: UIEvent?) {
         //MARK:直接执行闭包
        self.dismissViewControllerAnimated(true, completion: nil)

        self.backValueclusore!(text:self.tf.text!)

6、代理委托实现页面之间的反向传值

这一种方法就是运用协议实现传值，这种方式也是在工程中常用的一种传值方法。首先创建好ViewController和SubViewController，在ViewController中创建好一个展示信息的Label，在SubViewController中创建好一个TextFeild,我们实现在第二个界面点击屏幕时，将TextFeild中的文字传到第一个界面，然后让背景颜色变色。

效果如下：

代理传值.gif

第一步：

首先我们要弄清楚ViewController和SubViewController谁是代理方，谁是委托方。委托方制订协议，并且拥有一个代理，代理方准守协议，并且实现协议中的方法。因为是从SubViewController中向ViewController中传递信息，SubViewController需要让代理完成传值的动作，所以这里SubViewController便是委托方

在SubViewController中我们指定一个协议BackValueProtocol：

extension ViewController:BackValueProtocol {
    func backValue(text: String, color: UIColor){}
}

因为我们要传递文字和颜色，所以协议里的方法带有text：String 和color：UIColor 两个参数

第二步：

制定好协议之后，我们还要给SubViewController添加一个代理属性

var delegate: BackValueProtocol?

第三步：

然后就是给SubViewController指定一个代理人，当然，这里就是ViewController了
我们设置当点击屏幕时跳转到第二个界面，并且告诉第二个界面，ViewController就是他的代理方

 override func touchesBegan(touches: Set<UITouch>, withEvent event: UIEvent?) {

         //获取第二个界面
        let svc = SubViewController()
        self.presentViewController(svc, animated: true, completion: nil)
        //MARK:告诉第二个界面ViewController就是他的代理
        svc.delegate = self
    }

第四步：

接下来就是在ViewController中实现协议中的方法了

extension ViewController:BackValueProtocol {
    func backValue(text: String, color: UIColor) {
    //让label的文字显示为传过来的 文字
        textLabel.text = text

        //让背景颜色改变为传过来的颜色
        self.view.backgroundColor = color
    }
}
效果如下：

第五步

最后就是执行传值操作了，我们设置在点击第二个界面时传值所以，在SubViewController的touchBegan里开始传值

 override func touchesBegan(touches: Set<UITouch>, withEvent event: UIEvent?) {

        //B页面根部不需要考虑传值的目标和方法具体是谁，直接去调用自己的属性即可
        //这种方式称为回调，让目标调用目标方法，参数为我传入的TextField的值
        let color  = UIColor.redColor()

        //MARK:让自己的代理去执行传值操作
        self.delegate?.backValue(self.tf.text!, color: color)
        self.dismissViewControllerAnimated(true, completion: nil)
    }

到此为止，整个的反向传值就完成了，整个步骤如下：

1. 想好谁是委托方谁是代理方，委托方制定协议并拥有一个代理属性
2. 代理方遵守协议并实现协议中的方法
3. 告诉委托方谁是代理
4. 委托方告诉代理方去执行协议中的方法

7、使用TargetAction实现传值

这种传值方式和使用代理传值有相似之处，大致的思想就是在有数据的界面进行传值开始的指令，在接收数据的界面完成实质的传值操作

效果如下：

TargetAction传值.gif

首先，同样ViewController和SubViewController，并分别设置好label和TextFeild

第一步

在SubViewController中我们设置两个属性：target和action

 //设置两个属性接收传值目标和方法
    //用来去接收传值的目标是任意目标
    var target: AnyObject?

    //用来去接收传值的方法
    var action: Selector?

第二步

在SubViewController中,当点击屏幕时发送传值指令

 override func touchesBegan(touches: Set<UITouch>, withEvent event: UIEvent?) {

//B页面根部不需要考虑传值的目标和方法具体是谁，直接去调用自己的属性即可
        //MARK:这种方式称为回调，让目标调用目标方法，参数为我传入的TextField的值

        self.target?.performSelector(self.action!, withObject: self.tf.text )


        self.dismissViewController

第三步

在ViewController中我们要给SubViewController指定是指真正的target，真正的 action是什么。

同样。我们设置当点击屏幕时，将这些信息告诉给SubVIewController，显然，target是ViewController，action则是我们指定的某个实现方法

那么，我们首先要设定一个用来回传数据的方法

    //定义一个用来去回传数据的方法
    func backValue(string:String) {
        //通过传进来的参数，给label赋值
        textLabel.text = string
    }

然后将target和action告诉SubViewController

    override func touchesBegan(touches: Set<UITouch>, withEvent event: UIEvent?) {
        //获取SubViewController
        let svc = SubViewController()
        //通过正向传值，来告诉B页面回调时需要用到的参数
        svc.target = self

   //MARK:将action告诉SubViewController

   //NSSelectorFromString 方法是将一个字符串方法转换成真正的方法名
        svc.action = NSSelectorFromString("backValue:")
        self.presentViewController(svc, animated: true, completion: nil)
    }

到此为止，当点击ViewController屏幕时，将taget和action告诉了第二个界面，在第二个界面点击屏幕时，执行了target action命令，实现了backValue方法，完成了完整的传值操作

8、使用系统单例去传值

这个方法就厉害了我的哥！使用UIApplication这个单例类去完成数据的存储，将需要传输的数据存储到一个公共的数据源中，任何一个界面的任何地方都可以使用里面的资源

效果图如下：

系统单例传值.gif

在工程中，我们对AppDelegate.swift文件都不陌生，这个文件配置好了window层，并且可以设置指定的很视图控制器，在AppDelegate中我们知道它遵守了UIResponder和UIApplicationDelegate协议，而UIApplication便是一个系统提供的单例类，AppDelegate虽然不是单例类 ，但是共享的数据可以存放到这个类中

第一步

在AppDelegate声明一个用来去和共享数据的数组，然后配置一个带有的VC1,VC2和VC3的TabBarController做为根视图控制器

import UIKit

@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {

    var window: UIWindow?
    //用来去共享数据的数组
    var datas = [String]()

    func application(application: UIApplication, didFinishLaunchingWithOptions launchOptions: [NSObject: AnyObject]?) -> Bool {
        //给数组里加一个原始数据
        datas.append("AD")

        //配置window
        window?.frame = UIScreen.mainScreen().bounds
        window?.backgroundColor = UIColor.whiteColor()

        let vc = ViewController()
        vc.view.backgroundColor = UIColor.redColor()
        let vc1 = ViewController1()
        vc1.view.backgroundColor = UIColor.yellowColor()
        let vc2 = ViewController2()
        vc2.view.backgroundColor = UIColor.blueColor()

        //设置标题
        vc.title = "视图1"
        vc1.title = "视图2"
        vc2.title = "视图3"

        let tvc = UITabBarController()
        tvc.viewControllers = [vc,vc1,vc2]
        window?.rootViewController = tvc
        window?.makeKeyAndVisible()
        return true
    }

第二步

当点击屏幕时，添加数据到公共的数据源中并且读取出来
因为在VC1,VC2,VC3中的任何一个界面都可以完成相同操作，在这里只拿一个做展示

1. 首先我们获取UIApplication的单例类
2. 通过单例类获取AppDelegate
3. 通过AppDelegate操作共享的数组

代码如下：

 override func touchesBegan(touches: Set<UITouch>, withEvent event: UIEvent?) {

        //获取单例
        let application = UIApplication.sharedApplication()

        //通过这个单例获取AppDelegate这个对象
        let appDelegate = application.delegate as! AppDelegate

        //通过这个AppDelegate来操作共享的datas数组
        appDelegate.datas.append("VC-\(n + 1)")
        print(appDelegate.datas)
    }

当点击屏幕时，我们可以看到控制台中打印出来了我们设置的初始值“AD”和新加入的值“VC-2”,

同样在VC2中我们使用同样的放法获取数据

import UIKit

class ViewController1: UIViewController {
    var n = 1
    override func viewDidLoad() {
        super.viewDidLoad()

        // Do any additional setup after loading the view.
    }

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

    override func touchesBegan(touches: Set<UITouch>, withEvent event: UIEvent?) {
        //UIApplication 是一个单例类
        //AppDelegate并不是单例类，但是共享的数据放到了这个类里

        //获取单例
        let application = UIApplication.sharedApplication()

        //通过这个单例获取AppDelegate这个对象
        let appDelegate = application.delegate as! AppDelegate

        //铜鼓这个APPDelegate来操作共享的datas数组
        appDelegate.datas.append("VC1-\(n + 1)")
        print(appDelegate.datas)
    }
}

在控制台中我们看到VC1传入的数据和VC2自己传入的数据，实现了页面之间的传值

9、使用自定义的单例实现页面之间的传值

本方法和第8中方法的实质原理是一样的，共享一个公共的数据源数组，任何一个界面都可以通过单例找到这个数据源进而进行写入和读取的操作，只不过，这里我们使用了自己的单例。

首先将根视图控制器设置为带有三个界面的标签控制器

1、自定义一个单例

在工程中我们继承于NSObject新建一个SingleInstance单例类，在单例类中我们声明一个公共的数据源，并且提供一个公开用来去获取单例的方法

不会创建单例的小伙伴点这儿

//创建一个单例类
class SingleInstance: NSObject {


    //在单例类中，有一个用来共享数据的数组
    var datas = [String]()
    //创建一个静态或者全局变量，保存当前单例实例值
    private static let singleInstance = SingleInstance()
    //私有化构造方法
    private override init() {
        //给数组加一个原始数据
        datas.append("SI")
    }

    //提供一个公开的用来去获取单例的方法
    class func defaultSingleInstance() ->SingleInstance {
        //返回初始化好的静态变量值
        return singleInstance
    }
}

2、在VC1中写入并读取数据

当点击屏幕时，将数据传入公共数据源，并读出

class ViewController1: UIViewController {

    override func viewDidLoad() {
        super.viewDidLoad()

    }

    //MARK:-当点击屏幕时写入并读取数据
    override func touchesBegan(touches: Set<UITouch>, withEvent event: UIEvent?) {
        //获取单例对象
        let si = SingleInstance.defaultSingleInstance()
        //给单例中的数组加一个数据
        si.datas.append("VC1")
        print(si.datas)
    }
}

3、在VC2中写入并读取数据

class ViewController2: UIViewController {

    override func viewDidLoad() {
        super.viewDidLoad()

        // Do any additional setup after loading the view.
    }

    override func touchesBegan(touches: Set<UITouch>, withEvent event: UIEvent?) {
        //获取单例对象
        let si = SingleInstance.defaultSingleInstance()
        //给单例中的数组加一个数据
        si.datas.append("VC2")
        print(si.datas)
    }
}

在VC2中同样可以通过单例找到数据源，并且实现了页面之间的传值

10、通过通知中心NSNotificationCenter传值

在这里我们实现用通知中心的方法实现从VC中向VC1和VC2中传值

通知传值类似于广播和接收信号的过程，我们在AppDelegate中共享一个公共的数据源，在传值的界面设置了一个公共的广播站，并且获取这个数据源，需要接收数据的页面就相当于一个收音机，一旦收到广播站的信号，便去执行相应的方法

1、在AppDelegate中我们共享一个数据源

class AppDelegate: UIResponder, UIApplicationDelegate {

    var window: UIWindow?
    //用来保存共享数据的数组
    var datas = [Int]()

    func application(application: UIApplication, didFinishLaunchingWithOptions launchOptions: [NSObject: AnyObject]?) -> Bool {
          window = UIWindow()
        window?.frame = UIScreen.mainScreen().bounds
        window?.backgroundColor = UIColor.whiteColor()

        let vc = ViewController()
        vc.title = "VC"

        let vc1 = ViewController1()
        vc1.title = "VC1"

        let vc2 = ViewController2()
        vc2.title = "VC2"

        let tvc = UITabBarController()
        tvc.viewControllers = [vc,vc1,vc2]
        window?.rootViewController = tvc
        window?.makeKeyAndVisible()
        return true
    }

2、在VC1和VC2中扩展一个成为观察者的方法，并设置接收到数据后需要执行的动作

扩展为观察者的方法

extension ViewController1{
    //成为观察者的方法
    func becomeObserver(){
        //先去获取通知中心的单例
        let notificationCenter = NSNotificationCenter.defaultCenter()
        //向通知中心去加入观察者
        notificationCenter.addObserver(self, selector: #selector(ViewController1.sum), name: "又有新数据啦!", object: nil)
    }
}

接收到信号后执行的动作

 //观察者的响应方法
    func sum(){
        let datas = ((UIApplication.sharedApplication().delegate)as!AppDelegate).datas
        var sum = 0
        for i in datas{
            sum += i
        }
        print("VC1计算求和得：\(sum)")
    }

完整代码如下：

class ViewController1: UIViewController {

    override func viewDidLoad() {
        super.viewDidLoad()
    }
}
extension ViewController1{
    //成为观察者的方法
    func becomeObserver(){
        //先去获取通知中心的单例
        let notificationCenter = NSNotificationCenter.defaultCenter()
        //向通知中心去加入观察者
        notificationCenter.addObserver(self, selector: #selector(ViewController1.sum), name: "又有新数据啦!", object: nil)
    }
    //观察者的响应方法
    func sum(){
        let datas = ((UIApplication.sharedApplication().delegate)as!AppDelegate).datas
        var sum = 0
        for i in datas{
            sum += i
        }
        print("VC1计算求和得：\(sum)")
    }

}

3、回到AppDelegate中将VC1和VC2注册成为观察者

  //让vc1，注册成为观察者
  vc1.becomeObserver()
  //让vc2，注册成为观察者
  vc2.becomeObserver()

4、当点击VC屏幕时写入数据并发送通知

override func touchesBegan(touches: Set<UITouch>, withEvent event: UIEvent?) {
     //在这里，向数据源中去增加数据，并发送通知

        //随机生成一个数字
        let num = arc4random_uniform(100)

        //通过UIApplication获取单例类并获取数据
        ((UIApplication.sharedApplication().delegate) as! AppDelegate).datas.append(Int(num))

        //MARK-获取通知中心
        let nc = NSNotificationCenter.defaultCenter()
        //发送通知
         nc.postNotificationName("又有新数据啦!", object: nil)

    }

在控制台中我们就可以看见当点击VC的时候，VC1和VC2都执行了响应的方法

效果如下：

通知中心传值.gif

---

到此，页面传值的10种方法全部介绍完了，文中有描述不当之处希望大家包涵和指正，有需要源代码的伙伴们可以点击这儿下载！

文／Demoer（简书作者）
原文链接：http://www.jianshu.com/p/f1d3a7d0c00d
著作权归作者所有，转载请联系作者获得授权，并标注“简书作者”。