iOS

前言

• 页面传值：

  • 复合传值

  • 单例传值

  • userDefaults 传值

  • 代理传值

  • Block/闭包传值

1、复合传值

• 复合 － 正向传值

  • 1、接收方，头文件中创建可存放传递值的属性变量
  • 2、发送方，包含接收方的头文件
  • 3、发送方，实例化接收方对象，并设置其属性变量的值
  • 4、接收方，将此属性变量的值输出

• Objective-C

  • Page2.h

    	// 1、接收方，头文件中创建可存放传递值的 “属性变量”
    	@property(nonatomic, copy)NSString *receiveText;
    

  • Page1.m

    	// 2、发送方，包含接收方的头文件
    	#import "Page2.h"
    
    	// 3、发送方，实例化接收方对象，并设置其 “属性变量” 的值
    	Page2 *pvc2 = [[Page2 alloc] init];
    
    	pvc2.receiveText = sendTextFiled.text;
    

  • Page2.m

    	// 4、接收方，将此 “属性变量” 的值输出
    	receiveLabel.text = self.receiveText;
    

• Swift

  • Page2.swift

    	// 1、接收方，头文件中创建可存放传递值的 “属性变量”
    	var receiveText:String?
    

  • Page1.swift

    	// 3、发送方，实例化接收方对象，并设置其 “属性变量” 的值
    	let pvc2 = Page2()
    
    	pvc2.receiveText = sendTextFiled.text;
    

  • Page2.swift

    	// 4、接收方，将此 “属性变量” 的值输出
    	receiveLabel.text = self.receiveText
    

2、单例传值

• 单例 - 正/反向传值

  • 1、创建单例类，并在其头文件中创建可存放传递值的属性变量

  • 2、发送方，包含单例类头文件

  • 3、发送方，创建单例类对象，并为其属性变量赋值

  • 4、接收方，包含单例类头文件

  • 5、接收方，创建单例类对象，取其属性变量的值，输出

• Objective-C

  • 创建单例类

    • SingleClass.h

      	#import <Foundation/Foundation.h>
      
      	@interface SingleClass : NSObject
      
      	// 1、创建单例类，并在其头文件中创建可存放传递值的 “属性变量”
      	@property (nonatomic, copy)NSString *singleText;
      
      	+ (SingleClass *)sharedSingleClass;
      
      	@end
      

    • SingleClass.m

      	#import "SingleClass.h"
      
      	@implementation SingleClass
      
      	+ (SingleClass *)sharedSingleClass {
          
          	static SingleClass *single = nil;
          
          	static dispatch_once_t onceToken;
          	dispatch_once(&onceToken, ^{
             	single = [[SingleClass alloc] init];
          	});
          	return single;
      	}
      
      	@end
      

  • Page3.m

    	// 2、发送方，包含单例类头文件
    	#import "SingleClass.h"
    
    	// 3、发送方，创建单例类对象，并为其 “属性变量” 赋值
    	[SingleClass sharedSingleClass].singleText = sendTextFiled.text;
    

  • Page4.m

    	// 4、接收方，包含单例类头文件
    	#import "SingleClass.h"
    
    	// 5、接收方，创建单例类对象，取其 “属性变量” 的值，输出
    	receiveLabel.text = [SingleClass sharedSingleClass].singleText;
    

• Swift

  • 创建单例类

    • SingleClass.swift

      	import UIKit
      
      	class SingleClass {
          
         	// 1、创建单例类，并创建可存放传递值的 “属性变量”
          	var singleText:String?
          
          	static let sharedSingleClass = SingleClass()
          	private init() {}
      	}
      

  • Page3.swift

    	// 3、发送方，创建单例类对象，并为其 “属性变量” 赋值
    	SingleClass.sharedSingleClass.singleText = sendTextFiled.text
    

  • Page4.swift

    	// 5、接收方，创建单例类对象，取其 “属性变量” 的值，输出
    	receiveLabel.text = SingleClass.sharedSingleClass.singleText
    

3、NSUserDefaults 传值

• NSUserDefaults - 正/反向传值

  • 1、发送方，创建 userDefaults，并以一个固定的 key 值存储数据，发送传递值

  • 2、发送方，创建 userDefaults 同步数据

  • 3、接收方，创建 userDefaults，并以相同的 key 值读取数据，接收传递值

• Objective-C

  • Page5.m

    	// 1、发送方，创建 userDefaults，并以一个固定的 key 值存储数据，发送传递值
    	[[NSUserDefaults standardUserDefaults] setObject:sendTextFiled.text forKey:@"userDefaultsText"];
    
    	// 2、发送方，创建 userDefaults 同步数据
    	[[NSUserDefaults standardUserDefaults] synchronize];
    

  • Page6.m

    	// 3、接收方，创建 userDefaults，并以相同的 key 值读取数据，接收传递值
    	receiveLabel.text = [[NSUserDefaults standardUserDefaults] objectForKey:@"userDefaultsText"];
    

• Swift

  • Page5.swift

    	// 1、发送方，创建 userDefaults，并以一个固定的 key 值存储数据，发送传递值
    	NSUserDefaults.standardUserDefaults().setObject(sendTextFiled.text, forKey: "userDefaultsText")
    
    	// 2、发送方，创建 userDefaults 同步数据
    	NSUserDefaults.standardUserDefaults().synchronize()
    

  • Page6.swift

    	// 3、接收方，创建 userDefaults，并以相同的 key 值读取数据，接收传递值
    	receiveLabel.text = NSUserDefaults.standardUserDefaults().objectForKey("userDefaultsText") as? String
    

4、代理传值

4.1 代理反向传值

• 代理 - 反向传值

  • 1、创建代理协议，并在协议中创建协议方法

  • 2、委托方：发送方，包含协议头文件

  • 3、委托方：发送方，创建代理人属性变量

  • 4、委托方：发送方，调用协议方法，发送传递值

  • 5、代理方：接收方，遵守代理协议

  • 6、代理方：接收方，实例化发送方对象，并设置其代理人为 self

  • 7、代理方：接收方，实现代理协议中的方法，接收传递值

• Objective-C

  • 创建协议

    • PageDelegate1.h

      	#import <Foundation/Foundation.h>
      
      	@protocol PageDelegate1 <NSObject>
      
      	// 1、创建代理协议，并在协议中创建协议方法
      	- (void)setLabelWithText:(NSString *)protocolText;
      
      	@end
      

  • Page8.h

    	// 2、委托方：发送方，包含协议头文件
    	#import "PageDelegate1.h"
    
    	// 3、委托方：发送方，创建代理人属性变量
    	@property(nonatomic, weak)id<PageDelegate1> delegate;
    

  • Page8.m

    	if ([self.delegate respondsToSelector:@selector(setLabelWithText:)]) {
        
        	// 4、委托方：发送方，调用协议方法，发送传递值
        	[self.delegate setLabelWithText:sendTextFiled.text];
    	}
    

  • Page7.m

    	// 5、代理方：接收方，遵守代理协议
    	@interface Page7 () <PageDelegate1>
    
    	// 6、代理方：接收方，实例化发送方对象，并设置其代理人为 self
    	Page8 *pvc8 = [[Page8 alloc] init];
    
    	pvc8.delegate = self;
    
    	// 7、代理方：接收方，实现代理协议中的方法，接收传递值
    	- (void)setLabelWithText:(NSString *)protocolText {
        
        	receiveLabel.text = protocolText;
    	}
    

• Swift

  • 创建协议

    • PageDelegate1.swift

      	import Foundation
      
      	protocol PageDelegate1 {
          
          	// 1、创建代理协议，并在协议中创建协议方法
          	func setLabelWithText(protocolText:String?)
      	}
      

  • Page8.swift

    	// 3、委托方：发送方，创建代理人属性变量
    	var delegate:PageDelegate1!
    
    	if self.delegate != nil {
        
        	// 4、委托方：发送方，调用协议方法，发送传递值
        	self.delegate.setLabelWithText(sendTextFiled.text)
    	}
    

  • Page7.swift

    	// 5、代理方：接收方，遵守代理协议
    	class Page7: UIViewController, PageDelegate1 {
    
    	// 6、代理方：接收方，实例化发送方对象，并设置其代理人为 self
    	let pvc8 = Page8()
    
    	pvc8.delegate = self
    
    	// 7、代理方：接收方，实现代理协议中的方法，接收传递值
    	func setLabelWithText(protocolText: String?) {
        
        	receiveLabel.text = protocolText
    	}
    

4.2 代理反向传值封装

• 代理 - 反向传值，代理封装

  • 1、创建代理协议，并在协议中创建协议方法

  • 2、委托方：发送方，包含协议头文件

  • 3、委托方：发送方，创建代理人属性变量

  • 4、委托方：发送方，声明重构的 init 初始化方法

  • 5、委托方：发送方，重构 init 初始化方法

  • 6、委托方：发送方，调用协议方法，发送传递值

  • 7、代理方：接收方，遵守代理协议

  • 8、代理方：接收方，用重构初始化方法实例化委托方对象，并设置其代理人为 self

  • 9、代理方：接收方，实现代理协议中的方法，接收传递值

• Objective-C

  • 创建协议

    • PageDelegate2.h

      	#import <Foundation/Foundation.h>
      
      	@protocol PageDelegate2 <NSObject>
      
      	// 1、创建代理协议，并在协议中创建协议方法
      	- (void)setLabelWithText:(NSString *)protocolText;
      
      	@end
      

  • Page10.h

    	// 2、委托方：发送方，包含协议头文件
    	#import "PageDelegate2.h"
    
    	// 3、委托方：发送方，创建代理人属性变量
    	@property(nonatomic, weak)id<PageDelegate2> delegate;
    
    	// 4、委托方：发送方，声明重构的 init 初始化方法
    	- (instancetype)initWithTarget:(id<PageDelegate2>) delegate;
    

  • Page10.m

    	// 重构的 init 初始化方法
    	// 5、委托方：发送方，重构 init 初始化方法
    	- (instancetype)initWithTarget:(id<PageDelegate2>)delegate {
        
        	if (self = [super init]) {
            
            	self.delegate = delegate;
        	}
        	return self;
    	}
    
    	if ([self.delegate respondsToSelector:@selector(setLabelWithText:)]) {
        
        	// 6、委托方：发送方，调用协议方法，发送传递值
        	[self.delegate setLabelWithText:sendTextFiled.text];
    	}
    

  • Page9.m

    	// 7、代理方：接收方，遵守代理协议
    	@interface Page9 () <PageDelegate2>
    
    	// 8、代理方：接收方，用重构初始化方法实例化委托方对象，并设置其代理人为 self
    	Page10 *pvc10 = [[Page10 alloc] initWithTarget:self];
    
    	// 9、代理方：接收方，实现代理协议中的方法，接收传递值
    	- (void)setLabelWithText:(NSString *)protocolText {
        
        	receiveLabel.text = protocolText;
    	}
    

• Swift

  • 创建协议

    • PageDelegate2.swift

      	import Foundation
      
      	protocol PageDelegate2 {
      	    
      	  	// 1、创建代理协议，并在协议中创建协议方法
          	func setLabelWithText(protocolText:String?)
      	}
      

  • Page10.swift

    	// 3、委托方：发送方，创建代理人属性变量
    	var delegate:PageDelegate2!
    
    	// 重构的 init 初始化方法
    	// 5、委托方：发送方，重构 init 初始化方法
    	init(target delegate:PageDelegate2) {
    
        	// 在 ViewController 中不能使用 super.init()
        	super.init(nibName: nil, bundle: nil)
        
        	self.delegate = delegate
    	}
    
    	if self.delegate != nil {
        
        	// 6、委托方：发送方，调用协议方法，发送传递值
        	self.delegate.setLabelWithText(sendTextFiled.text)
    	}
    

  • Page9.swift

    	// 7、代理方：接收方，遵守代理协议
    	class Page9: UIViewController, PageDelegate2 {
    
    	// 8、代理方：接收方，实例化发送方对象，并设置其代理人为 self
    	let pvc10 = Page10(target: self)
    
    	// 9、代理方：接收方，实现代理协议中的方法，接收传递值
    	func setLabelWithText(protocolText: String?) {
        
        	receiveLabel.text = protocolText
    	}
    

4.3 代理双向传值

• 代理 - 双向传值

• Objective-C

  • 创建协议

    • PageDelegate3.h

      	#import <Foundation/Foundation.h>
      
      	@protocol PageDelegate3 <NSObject>
      
      	// 带返回值
      	- (NSString *)setLabelWithText:(NSString *)protocolText;
      
      	@end
      

  • Page16.h

    	#import "PageDelegate3.h"
    
    	@property(nonatomic, weak)id<PageDelegate3> delegate;
    

  • Page16.m

    	- (void)viewDidLoad {
    	
    		if ([self.delegate respondsToSelector:@selector(setLabelWithText:)]) {
    			
    			// 接收数据
    			receiveLabel.text = [self.delegate setLabelWithText:nil];
    		}
    	}
    	
    	// 返回上一页
    	- (void)sendClick {
    		
    		if ([self.delegate respondsToSelector:@selector(setLabelWithText:)]) {
    		
    			// 返回数据
    			[self.delegate setLabelWithText:sendTextFiled.text];
    		}
    		
    		[self dismissViewControllerAnimated:YES completion:nil];
    	}
    

  • Page15.m

    	@interface Page15 () <PageDelegate3>
    
    	Page16 *pvc16 = [[Page16 alloc] init];
    
    	pvc16.delegate = self;
    
    	- (NSString *)setLabelWithText:(NSString *)protocolText {
    
    		// 接收返回的数据
    		receiveLabel.text = protocolText;
    
    		// 正向发送数据
    		return sendTextFiled.text;
    	}
    

5、Block/闭包 传值

5.1 block/闭包反向传值

• block/闭包 - 反向传值

  • 1、发送方：创建 block/闭包 类型的变量

  • 2、发送方：调用 block/闭包，发送传递值

  • 3、接收方：实例化发送方对象，并实现其 block/闭包，接收传递值

• Objective-C

  • Page12.h

    	// 1、发送方：创建 block 类型的变量，变量名为 passDataBlock
    	@property (nonatomic, copy)void (^passDataBlock)(NSString *);
    

  • Page12.m

    	if (self.passDataBlock) {
        
    		// 2、发送方：调用 block，发送传递值 
        	self.passDataBlock(sendTextFiled.text);
    	}
    

  • Page11.m

    	// 3、接收方：实例化发送方对象，并实现其 block，接收传递值
    	Page12 *pvc12 = [[Page12 alloc] init];
    
    	pvc12.passDataBlock = ^(NSString *blockText){
        
        	receiveLabel.text = blockText;
    	};
    

• Swift

  • Page12.swift

    	// 1、发送方：创建闭包类型的变量
    	var passDataClosure:((String?) -> Void)!
    
    	if self.passDataClosure != nil {
        
        	// 2、发送方：调用闭包，发送传递值
        	self.passDataClosure(sendTextFiled.text)
    	}
    

  • Page11.swift

    	// 3、接收方：实例化发送方对象，并实现其闭包，接收传递值
    	let pvc12 = Page12()
    
    	pvc12.passDataClosure = { (closureText:String?) in
        
        	self.receiveLabel.text = closureText
    	}
    

5.2 block/闭包反向传值封装

• block/闭包 - 反向传值，block/闭包 封装

  • 1、发送方：创建 block/闭包 类型的变量

  • 2、发送方：声明重构 init 初始化方法

  • 3、发送方：重构 init 初始化方法

  • 4、发送方：调用 block/闭包，发送传递值

  • 5、接收方：用重构初始化方法实例化发送方对象，并实现其 block/闭包，接收传递值

• Objective-C

  • Page14.h

    	typedef void (^pagePassDataBlock)(NSString *);
    
    	// 1、发送方：创建 block 类型的变量，变量名为 passDataBlock
    	@property (nonatomic, copy)pagePassDataBlock passDataBlock;
    
    	// 2、发送方：声明重构 init 初始化方法
    	- (instancetype)initWithBlock:(pagePassDataBlock)dataBlock;
    

  • Page14.m

    	// 重构 init 初始化方法
    	// 3、发送方：重构 init 初始化方法
    	- (instancetype)initWithBlock:(pagePassDataBlock)dataBlock {
        
        	if (self = [super init]) {
            
            	self.passDataBlock = dataBlock;
        	}
        	return self;
    	}
    
    	if (self.passDataBlock) {
        
        	// 4、发送方：调用 block，发送传递值
        	self.passDataBlock(sendTextFiled.text);
    	}
    

  • Page13.m

    	// 5、接收方：用重构初始化方法实例化发送方对象，并实现其 block，接收传递值
    	Page14 *pvc14 = [[Page14 alloc] initWithBlock:^(NSString *blockText) {
        
        	receiveLabel.text = blockText;
    	}];
    

• Swift

  • Page14.swift

    	// 1、发送方：创建闭包类型的变量
    	var passDataClosure:((String?) -> Void)!
    
    	// 重构 init 初始化方法
    	// 3、发送方：重构 init 初始化方法
    	init(closure:((String?) -> Void)) {
        
        	super.init(nibName: nil, bundle: nil)
        
        	self.passDataClosure = closure
    	}
    
    	if self.passDataClosure != nil {
        
        	// 4、发送方：调用闭包，发送传递值
        	self.passDataClosure(sendTextFiled.text)
    	}
    

  • Page13.swift

    	let pvc14 = Page14 { (closureText:String?) in
    
    		// 5、接收方：用重构初始化方法实例化发送方对象，并实现其 block/闭包，接收传递值
        	self.receiveLabel.text = closureText
    	}
    

5.3 block/闭包双向传值

• block/闭包 - 双向传值

• Objective-C

  • Page18.h

    	// 带返回值
    	@property (nonatomic, copy)NSString * (^passDataBlock)(NSString *);
    

  • Page18.m

    	- (void)viewDidLoad {
    		[super viewDidLoad];
    		
    		if (self.passDataBlock) {
    		
    			// 接收数据
    			receiveLabel.text = self.passDataBlock(nil);
    		}
    	}
    	
    	// 返回上一页
    	- (void)sendClick {
    	    
    		if (self.passDataBlock) {
    		
    			// 返回数据
    			self.passDataBlock(sendTextFiled.text);
    		}
    	    
    		[self dismissViewControllerAnimated:YES completion:nil];
    	}
    

  • Page17.m

    	Page18 *pvc18 = [[Page18 alloc] init];
    	    
    	pvc18.passDataBlock = ^(NSString * blockText){
    	    
    		// 接收返回的数据
    		receiveLabel.text = blockText;
    	    
    		// 正向发送数据
    		return sendTextFiled.text;
    	};