这个问题在Stack Overflow上似乎很流行，所以我想我会尝试给出一个更好的答案，以帮助像我这样在iOS世界起步的人。

转发数据

将数据从另一个视图控制器转发到视图控制器。如果您想将对象/值从一个视图控制器传递到另一个视图控件，并将其推送到导航堆栈，则可以使用此方法。

对于本例，我们将使用ViewControllerA和ViewControllerB

要将BOOL值从ViewControllerA传递到ViewControllerB，我们将执行以下操作。

在ViewControllerB.h中为BOOL创建一个属性@属性（非原子，赋值）BOOL是SomethingEnabled；在ViewControllerA中，您需要告诉它ViewControllerB，所以使用#import“ViewControllerB.h”

然后，如果要加载视图，例如didSelectRowAtIndex或某个IBAction，则需要在将其推到导航堆栈之前在ViewControllerB中设置属性。

    ViewControllerB *viewControllerB = [[ViewControllerB alloc] initWithNib:@"ViewControllerB" bundle:nil];
    viewControllerB.isSomethingEnabled = YES;
    [self pushViewController:viewControllerB animated:YES];

这会将ViewControllerB中的isSomethingEnabled设置为BOOL值YES。

使用Segues转发数据

如果您使用的是情节提要，则很可能使用segue，需要使用此过程来传递数据。这与上述类似，但不是在推送视图控制器之前传递数据，而是使用名为

-(void)prepareForSegue:(UIStoryboardSegue *)segue sender:(id)sender

因此，要将BOOL从ViewControllerA传递到ViewControllerB，我们将执行以下操作：

在ViewControllerB.h中为BOOL创建一个属性@属性（非原子，赋值）BOOL是SomethingEnabled；在ViewControllerA中，您需要告诉它ViewControllerB，因此使用#import“ViewControllerB.h”在情节提要上创建从ViewControllerA到ViewControllerB的片段，并为其提供标识符。在本例中，我们将其称为“showDetailSegue”接下来，我们需要将该方法添加到ViewControllerA，在执行任何segue时调用该方法。因此，我们需要检测调用了哪个segue，然后采取措施。在我们的示例中，我们将检查“showDetailSegue”，如果执行了，我们将把BOOL值传递给ViewControllerB-（void）准备segue:（UIStoryboardSegue*）segue发件人：（id）发件人{if（[segue.identifier isEqualToString:@“showDetailSegue”]）{ViewControllerB*控制器=（ViewControllerB*）segue.destinationViewController；controller.isSomethingEnabled=是；}}

如果在导航控制器中嵌入了视图，则需要将上面的方法稍微更改为以下方法

    -(void)prepareForSegue:(UIStoryboardSegue *)segue sender:(id)sender{
        if([segue.identifier isEqualToString:@"showDetailSegue"]){
            UINavigationController *navController = (UINavigationController *)segue.destinationViewController;
            ViewControllerB *controller = (ViewControllerB *)navController.topViewController;
            controller.isSomethingEnabled = YES;
        }
    }

这会将ViewControllerB中的isSomethingEnabled设置为BOOL值YES。

传回数据

要将数据从ViewControllerB传递回ViewControllerA，需要使用协议和委托或块，后者可以用作回调的松耦合机制。

为此，我们将使ViewControllerA成为ViewControllerB的委托。这允许ViewControllerB向ViewControllerA发回消息，使我们能够发回数据。

要使ViewControllerA成为ViewControllerB的委托，它必须符合我们必须指定的ViewControllerC协议。这告诉ViewControllerA它必须实现哪些方法。

在ViewControllerB.h中，在#import下方，但在@interface上方，指定协议。@类ViewControllerB；@协议ViewControllerBDLegate<NSObject>-（void）addItemViewController:（ViewControllerB*）控制器didFinishEnteringItem:（NSString*）项；@完接下来仍然在ViewControllerB.h中，您需要设置委托属性并在ViewController B.m中进行合成@属性（非原子，弱）id<ViewControllerBDLegate>委托；在ViewControllerB中，当我们弹出视图控制器时，我们调用代理上的消息。NSString*itemToPassBack=@“将此值传递回ViewControllerA”；[self.delegate addItemViewController:self-didFinishEnteringItem:itemToPassBack]；这就是ViewControllerB。现在在ViewControllerA.h中，告诉ViewControllerA导入ViewControllerB并遵守其协议。#import“ViewControllerB.h”@界面ViewControllerA:UIViewController<ViewControllerBDLegate>在ViewControllerA.m中，根据我们的协议实现以下方法-（void）addItemViewController:（ViewControllerB*）控制器didFinishEnteringItem:（NSString*）项{NSLog（@“这是从ViewControllerB%@返回的”，项）；}在将viewControllerB推送到导航堆栈之前，我们需要告诉viewControllerB ViewControllerA是它的委托，否则我们将得到一个错误。ViewControllerB*ViewControllerB=[[ViewControllerB alloc]initWithNib:@“ViewControllerA”捆绑包：nil]；viewControllerB.delegate=自身[[self-navigationController]pushViewController:viewControllerB动画：是]；

---

工具书类

在《视图控制器编程指南》中使用委派与其他视图控制器通信代理模式

NS通知中心

这是传递数据的另一种方式。

// Add an observer in controller(s) where you want to receive data
[[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(handleDeepLinking:) name:@"handleDeepLinking" object:nil];

-(void) handleDeepLinking:(NSNotification *) notification {
    id someObject = notification.object // Some custom object that was passed with notification fire.
}

// Post notification
id someObject;
[NSNotificationCenter.defaultCenter postNotificationName:@"handleDeepLinking" object:someObject];

将数据从一个类传递回另一个类（类可以是任何控制器、网络/会话管理器、UIView子类或任何其他类）

块是匿名函数。

此示例将数据从控制器B传递到控制器A

定义块

@property void(^selectedVoucherBlock)(NSString *); // in ContollerA.h

添加块处理程序（侦听器）

需要值的地方（例如，需要ControllerA中的API响应，或者需要a上的ContorlerB数据）

// In ContollerA.m

- (void)viewDidLoad {
    [super viewDidLoad];
    __unsafe_unretained typeof(self) weakSelf = self;
    self.selectedVoucherBlock = ^(NSString *voucher) {
        weakSelf->someLabel.text = voucher;
    };
}

转到控制器B

UIStoryboard *storyboard = [UIStoryboard storyboardWithName:@"Main" bundle:nil];
ControllerB *vc = [storyboard instantiateViewControllerWithIdentifier:@"ControllerB"];
vc.sourceVC = self;
    [self.navigationController pushViewController:vc animated:NO];

防火砖

-(void)tableView:(UITableView *)tableView didSelectRowAtIndexPath:
(NSIndexPath *)indexPath {
    NSString *voucher = vouchersArray[indexPath.row];
    if (sourceVC.selectVoucherBlock) {
        sourceVC.selectVoucherBlock(voucher);
    }
    [self.navigationController popToViewController:sourceVC animated:YES];
}

块的另一个工作示例

有很多方法可以做到这一点，选择正确的方法很重要。可能最大的架构决策之一在于如何在整个应用程序中共享或访问模型代码。

不久前，我写了一篇关于这一点的博客文章：共享模型代码。下面是一个简短的总结：

共享数据

一种方法是在视图控制器之间共享指向模型对象的指针。

在视图控制器（在导航或选项卡栏控制器中）上强制迭代以设置数据在prepareForSegue（如果是故事板）或init（如果是编程的）中设置数据

因为准备segue是最常见的，这里有一个例子：

override func prepareForSegue(segue: UIStoryboardSegue, sender: AnyObject?) {
    var next = segue.destinationViewController as NextViewController
    next.dataSource = dataSource
}

独立访问

另一种方法是一次处理满屏数据，而不是将视图控制器彼此耦合，将每个视图控制器耦合到它们可以独立访问的单个数据源。

我看到的最常见的方法是单例实例。因此，如果单例对象是DataAccess，则可以在UIViewController的viewDidLoad方法中执行以下操作：

func viewDidLoad() {
    super.viewDidLoad()
    var data = dataAccess.requestData()
}

还有其他工具也有助于传递数据：

关键价值观察NS通知核心数据NSFetchedResults控制器数据源

核心数据

核心数据的优点在于它具有相反的关系。因此，如果你只想给NotesViewController一个notes对象，你可以这样做，因为它与笔记本等其他东西有相反的关系。如果需要NotesViewController中笔记本上的数据，可以通过执行以下操作返回对象图：

let notebookName = note.notebook.name

在我的博客文章：共享模型代码中了解更多信息

在为iOS创建应用程序时，您必须始终遵循MVC概念。

有两种情况下，您可能希望将数据从ViewController传递到另一个：

当层次结构中有一个“A”ViewContoller，并且您希望将一些数据发送到“B”，这是下一个视图控制器。在这种情况下，您必须使用Segue。只需为segue设置一个标识符，然后在“A”VC中编写以下代码：override func prepare（segue:UIStoryboardSegue，sender:Any？）{如果segue.identifier==“A到B segue-identifier”{让bViewController=segue.destination为！UIDocumentBrowserViewControllerbViewController.data=某些数据}}当有一个A将B作为模态（或嵌入）打开时。现在，B视图控制器应该对其父对象视而不见。因此，将数据发送回A的最佳方法是使用委派。在B视图控制器和委托属性中创建委托协议。因此，B将向其代表报告（发送数据）。在A视图控制器中，我们实现了B视图控制器的委托协议，并将在prepare（forSegue:）方法中将self设置为B视图控制器中的委托属性。

这就是它应该正确实现的方式。

我建议使用块/闭包和自定义构造函数。

假设您必须将字符串从FirstViewController传递到SecondViewController。

您的第一个视图控制器。

class FirstViewController : UIViewController {

    func moveToViewControllerB() {

        let second_screen = SecondViewController.screen(string: "DATA TO PASS", call_back: {
            [weak self] (updated_data) in
            ///This closure will be called by second view controller when it updates something
        })
        self.navigationController?.pushViewController(second_screen, animated: true)
    }


}

第二个视图控制器

class SecondViewController : UIViewController {

    var incoming_string : String?
    var call_back : ((String) -> Void)?

    class func screen(string: String?, call_back : ((String) -> Void)?) -> SecondViewController {

        let me = SecondViewController(nibName: String(describing: self), bundle: Bundle.main);
        me.incoming_string = string
        me.call_back = call_back
        return me
    }

    // Suppose its called when you have to update FirstViewController with new data.
    func updatedSomething() {

        //Executing block that is implemented/assigned by the FirstViewController.
        self.call_back?("UPDATED DATA")
    }

}

对于SwiftUI

将@EnvironmentObject视为在许多视图上使用@ObservedObject的更聪明、更简单的方法。您不必在视图A中创建一些数据，然后将其传递给视图B、视图C和视图D，然后再最终使用它，而是可以在视图中创建数据并将其放入环境中，以便视图B、C和D可以自动访问它。

注意：环境对象必须由祖先视图提供–如果SwiftUI找不到正确类型的环境对象，则会导致崩溃。这也适用于预览，所以要小心。

例如，这里有一个存储用户设置的可观察对象：

class UserSettings: ObservableObject {
     @Published var score = 0
}

在给出的许多答案中都有一些很好的信息，但没有一个完全解决这个问题。

该问题询问如何在视图控制器之间传递信息。给出的具体示例要求在视图之间传递信息，但考虑到iOS自称的新颖性，原始海报可能是指视图控制器之间，而不是视图之间（没有viewControllers的任何参与）。似乎所有的答案都集中在两个视图控制器上，但如果应用程序发展到需要在信息交换中包含两个以上的视图控制器，该怎么办？

最初的海报还询问了Singleton和AppDelegate的使用。这些问题需要回答。

为了帮助其他人看这个问题，谁想要一个完整的答案，我将尝试提供它。

应用场景

与其进行高度假设、抽象的讨论，不如考虑具体的应用。为了帮助定义两个视图控制器情形和两个以上视图控制器情形，我将定义两个具体的应用场景。

场景一：最多需要两个视图控制器共享信息。

见图一。

应用程序中有两个视图控制器。有一个ViewControllerA（数据输入表单）和一个ViewController B（产品列表）。产品列表中选择的项目必须与数据输入表单中文本框中显示的项目相匹配。在这种情况下，ViewControllerA和ViewControllerB必须彼此直接通信，而不能与其他视图控制器通信。

场景二：两个以上的视图控制器需要共享相同的信息。

见图二。

应用程序中有四个视图控制器。这是一个基于选项卡的应用程序，用于管理家庭库存。三个视图控制器显示相同数据的不同过滤视图：

ViewControllerA-奢侈品ViewControllerB-非保险项目ViewControllerC-整个住宅库存ViewControllerD-添加新项目表单

无论何时创建或编辑单个项目，它也必须与其他视图控制器同步。例如，如果我们在ViewControllerD中添加了一条船，但它还没有投保，那么当用户转到ViewControllerA（豪华物品）和ViewControllerC（整个住宅库存）时，船必须出现，但当用户转到ViewControllerB（非投保物品）时则不会出现。我们不仅需要关注添加新项目，还需要关注删除项目（可以从四个视图控制器中的任何一个中删除），或编辑现有项目（可以在“添加新项目表单”中允许，将其重新用于编辑）。

由于所有视图控制器都需要共享相同的数据，所以所有四个视图控制器都必须保持同步，因此，每当任何单个视图控制器更改基础数据时，都需要与所有其他视图控制器进行某种通信。很明显，在这种情况下，我们不希望每个视图控制器直接与其他视图控制器通信。如果不明显，考虑我们是否有20个不同的视图控制器（而不是4个）。每当一个视图控制器发生更改时，通知其他19个视图控制器中的每一个会有多困难和容易出错？

解决方案：代表和观察者模式，以及Singleton

在场景一中，我们有几个可行的解决方案，正如其他答案所给出的

赛格牌手表代表直接设置视图控制器上的财产NSUserDefaults（实际上是一个糟糕的选择）

在场景2中，我们还有其他可行的解决方案：

观察者模式单身者

单例是类的一个实例，该实例是其生命周期中唯一存在的实例。单例的名字来源于它是一个实例。通常，使用singleton的开发人员有特殊的类方法来访问它们。

+ (HouseholdInventoryManager*) sharedManager; {
    static dispatch_once_t onceQueue;
    static HouseholdInventoryManager* _sharedInstance;

    // dispatch_once is guaranteed to only be executed
    // once in the lifetime of the application
    dispatch_once(&onceQueue, ^{
        _sharedInstance = [[self alloc] init];
    });
    return _sharedInstance;
}

现在我们了解了单例是什么，让我们讨论单例如何适合观察者模式。观察者模式用于一个对象响应另一个对象的变化。在第二个场景中，我们有四个不同的视图控制器，他们都想知道底层数据的更改。“底层数据”应该属于单个实例，即单例。“了解更改”是通过观察对单例所做的更改来实现的。

家庭库存应用程序将具有一个类的单个实例，该类旨在管理库存项目列表。经理将管理一系列家庭用品。以下是数据管理器的类定义：

#import <Foundation/Foundation.h>

@class JGCHouseholdInventoryItem;

@interface HouseholdInventoryManager : NSObject
/*!
 The global singleton for accessing application data
 */
+ (HouseholdInventoryManager*) sharedManager;


- (NSArray *) entireHouseholdInventory;
- (NSArray *) luxuryItems;
- (NSArray *) nonInsuredItems;

- (void) addHouseholdItemToHomeInventory:(JGCHouseholdInventoryItem*)item;
- (void) editHouseholdItemInHomeInventory:(JGCHouseholdInventoryItem*)item;
- (void) deleteHoueholdItemFromHomeInventory:(JGCHouseholdInventoryItem*)item;
@end

当主库存项的集合发生更改时，视图控制器需要了解此更改。上面的类定义并没有说明这将如何发生。我们需要遵循观察者模式。视图控制器必须正式遵守sharedManager。有两种方法可以观察另一个对象：

关键值观察（KVO）NSNotificationCenter。

在场景2中，我们没有使用KVO可以观察到的HouseholdInventoryManager的单个属性。因为我们没有一个易于观察的属性，所以在这种情况下，必须使用NSNotificationCenter实现观察者模式。四个视图控制器中的每一个都将订阅通知，sharedManager将在适当的时候向通知中心发送通知。库存管理器不需要知道任何关于视图控制器或任何其他类的实例的信息，这些类可能有兴趣知道库存项集合何时发生变化；NSNotificationCenter负责这些实施细节。视图控制器只需订阅通知，数据管理器只需发布通知。

许多初学者程序员利用了这样一个事实，即在应用程序的生命周期中始终只有一个应用程序委托，它是全局可访问的。初级程序员利用这一事实将对象和功能填充到appDelegate中，以方便从应用程序中的任何其他位置进行访问。仅仅因为AppDelegate是单例并不意味着它应该替换所有其他单例。这是一个糟糕的实践，因为它给一个类带来了太多负担，打破了良好的面向对象实践。每个类都应该有一个易于解释的明确角色，通常只需通过类的名称。

每当您的应用程序代理开始变得臃肿时，就开始将功能删除到单例中。例如，核心数据堆栈不应该留在AppDelegate中，而是应该放在它自己的类coreDataManager类中。

工具书类

管理视图控制器之间的数据流在视图控制器之间传递数据Objective-C中的异步JSON请求