iOS.OC靶场项目<基础配置的说明>

[toc]

前言

工欲善其事必先利其器
站在巨人的肩膀上，才能看得更远
面向信仰编程

一、目的

所有的项目根据这个根来进行统一配置和调用
将它作为所有项目的基类，做到全局的统一
千万要保证这个工程的编译通过，以后项目直接进行引用
作为某些代码实践的靶场，是非常有必要的
作为代码笔记，记录一些常用的代码，方便查阅
作为学习的资料，可以快速了解到一些常用的知识
作为项目的参考，可以快速的了解到项目的架构，代码规范，以及一些设计模式
示例Demo可能因为相关Api的升级没有覆盖处理会出现闪退。修复即可

二、特色

自主研发
- 公共的协议簇 BaseProtocol
- 统一的Block管理：JobsBlock
- 统一数据源的封装：UIViewModel
- UIButton兼容最新Api：UIButtonConfiguration
- 统一的UI组件库JobsOCBaseCustomizeUIKitCore
- 统一注册全局的 UICollectionViewCell、CollectionReusableView-Header、CollectionReusableView—Footer
- 不注册也可以使用UICollectionViewCell、CollectionReusableView-Header、CollectionReusableView—Footer
- 对UITabBarController和UITabBar的封装
- UserDefaults数据存储封装
- 对打开URL的兼容性封装
- 对KVC的封装
- 富文本的封装
- 对倒计时按钮的封装
- 统一的输入框封装
- 高仿蜜柚App的登录模块动态UI：JobsAppDoor
- 聊天功能：JobsIM
- 发帖功能：JobsPostVC （相册获取资源+存/取未完成字符串）
- 评论功能：JobsComment
- 搜索功能：JobsSearch
- 时间管理：JobsTimerVC
- 悬浮模块：JobsSuspend
- 下载流量监控：JobsBitsMonitor
- 让 **UIView**像 **UINavigationController**一样支持 push 和 pop
- 下拉列表：JobsDropDownListVC
UI层封装
- 对悬浮层的封装
- 对视频播放器的二次封装
- 统一的Toast封装
- 设备屏幕横竖屏适配
- 对调用系统相机、系统相册的功能性封装
- 高仿抖音：Douyin_ZFPlayer
- 3D Touch：长按Cell出菜单
- 卡片式滑动效果
- 图形验证码
- App图标切换
- 镂空特效
- 不规则的按钮
- 转场动画研究：JobsPresentingVC
- 特色UI：UITableViewCell
- 特色UI：UICollectionViewCell
  - UICollectionView实现重叠的卡包效果
- 特色UI：JX系列Demo
- 统一的WebView封装
数据层封装
- 网络模块Api
- Block 替换 @selector
- 统一的对手势的封装
- 多语言支持
- 防止多次推出同一控制器页面
- OC动态添加类、方法列表、属性列表
- 加密相关
  - 指纹识别
  - 手势解锁
  - 钥匙串管理
  - 设置手势密码
  - 图片字符串化（加盐）存取
  - 字符串解压缩
其他
- GitHub.workflow
- iOS手动打包/脚本打包成*.ipa
- iOS代码块
- 实用性脚本*.command
- 对info.plist的备份

三、几点重要说明

1、特别说明回到顶部

xcode对中文的兼容性非常好，所以可以中文命名路径（比如文件夹名称）
经实践证明，如果配置多语言化，那么xcode将会刷新Info.plist，导致里面的注释消失。正确的做法是，对Info.plist进行备份，随时进行替换
工程项目的Info.plist文件是对整个工程的配置说明，系统固定读取，所以必须在工程项目根目录的同名文件夹下。否则项目启动会出问题

2、在Apple芯片（目前是M系列）编译失败的解决方案回到顶部

禁用系统完整性保护 (System Integrity Protection, SIP) 如果不禁用，会对某些文件夹有读写权限控制
- 重启MacOS，长按开机键，直到🌏页面，进入恢复模式
- 在恢复模式的 macOS 实用工具窗口中，选择“实用工具”菜单，然后选择“终端”以打开终端窗口
```
csrutil disable
```
- 重启MacOS
- 在xcode里面做如下设置：每一个工程下都做检查 因为涉及到xcode的安全设置，所以下列操作只能手动操作，而不能用脚本进行。如果不做设置，很可能编译失败
- 文件夹授权
```
sudo chown -R $(whoami) 项目目录
sudo chmod -R u+rw 项目目录
```
- 在podfile文件里面，设置：
```
# 用于指定你的 Pod 项目应使用静态库而不是动态库。
# 这个选项主要用于解决某些与动态库相关的兼容性和性能问题。
use_frameworks! :linkage => :static
```
- 重新运行pod
```
pod install
```

3、iOS模拟器回到顶部

命令行唤起 iOS模拟器
```
open -a Simulator
```
如果更新或者删除xcode，那么下载的iOS模拟器将会丢失

模拟器文件通常存储在以下路径

open ~/Library/Developer/CoreSimulator/Volumes/

备份iOS模拟器文件夹到桌面Volumes

脚本自动化：【MacOS】备份iOS模拟器.command

#!/bin/bash

# 创建桌面上的Volumes文件夹（如果不存在）
mkdir -p ~/Desktop/Volumes
# 使用rsync复制目录并显示进度
sudo rsync -avh --progress /Library/Developer/CoreSimulator/Volumes/ ~/Desktop/Volumes/
echo "Volumes文件夹已成功复制到桌面。"

还原iOS模拟器（执行完毕后，需要重启xcode）

脚本自动化：【MacOS】恢复iOS模拟器.command

#!/bin/bash

# 确保目标目录存在
sudo mkdir -p /Library/Developer/CoreSimulator/Volumes
# 使用rsync复制目录并显示进度
sudo rsync -avh --progress ~/Desktop/Volumes/ /Library/Developer/CoreSimulator/Volumes/
echo "桌面的Volumes文件夹内容已成功复制到/Library/Developer/CoreSimulator/Volumes。"

4、`lldb`的使用回到顶部

(lldb) target list
Current targets:
* target #0: /Users/user/Library/Developer/CoreSimulator/Devices/E17E7DE8-7ADA-42FD-A743-A1A3A6CB7E42/data/Containers/Bundle/Application/C590303C-50A7-4BB2-826F-8598E5F3A66C/JobsOCBaseConfigDemo.app/JobsOCBaseConfigDemo ( arch=x86_64-apple-ios-simulator, platform=ios-simulator, pid=89318, state=stopped )
(lldb) target select 0
Current targets:
* target #0: /Users/user/Library/Developer/CoreSimulator/Devices/E17E7DE8-7ADA-42FD-A743-A1A3A6CB7E42/data/Containers/Bundle/Application/C590303C-50A7-4BB2-826F-8598E5F3A66C/JobsOCBaseConfigDemo.app/JobsOCBaseConfigDemo ( arch=x86_64-apple-ios-simulator, platform=ios-simulator, pid=89318, state=stopped )

5、`Command Line Tools` 回到顶部

查看Command Line Tools版本

Last login: Wed Jul 10 09:58:40 on ttys003
➜  Desktop pkgutil --pkg-info=com.apple.pkg.CLTools_Executables

package-id: com.apple.pkg.CLTools_Executables
version: 15.3.0.0.1.1708646388
volume: /
location: /
install-time: 1719293997

6、xcode 配置回到顶部

6.1、新工程配置

处理编译器警告：Unknown class in Interface Builder file
- 错误的原因通常是因为在Interface Builder中指定的类名与实际代码中的类名不匹配
- 在*.Storyboard或*.xib文件中，选择View Controller，查看Identity Inspector，确保Class字段中的类名拼写正确（这里的处理方式是删除），并且Module字段留空或选择正确的模块（通常是你的项目名）。

6.2、`Arguments Passed On Launch`标签设置

设置应用的语言环境
```
AppleLanguages ( "en" )
```
启用Core Data SQL语句调试日志
```
-com.apple.CoreData.SQLDebug 1
```
忽略应用的保存状态，强制应用在每次启动时都以初始状态运行 这个参数在调试应用启动问题时很有用
```
-ApplePersistenceIgnoreState YES
```
强制应用使用特定的用户界面风格（浅色模式或深色模式）
```
-UIUserInterfaceStyle Light
-UIUserInterfaceStyle Dark
```
启用 Firebase 调试日志
```
-FIRDebugEnabled
```
启用僵尸对象检测 帮助调试被释放的对象仍然被访问的问题
```
-NSZombieEnabled YES
```
启用视图对齐矩形的可视化 这可以帮助调试视图布局问题
```
-UIViewShowAlignmentRects YES
```
启用 Foundation 框架的调试描述
```
-NSDebugDescription YES
```
启用文档修订调试模式
```
-NSDocumentRevisionsDebugMode YES
```
启用 CFNetwork 诊断日志。 这对于调试网络请求问题非常有用
```
-CFNetworkDiagnosticsEnable 1
```
强制应用使用特定的文本方向（例如从左到右或从右到左）
```
-AppleTextDirection YES
```

6.3、`Environment Variables`标签

日志配置：添加一个新的环境变量。将 Name 设置为 IDEPreferLogStreaming，将 Value 设置为 YES

7、打印回到顶部

7.1、重写打印输出

关注文件：MacroDef_Log.h

使之能定位到具体文件行的输出

#pragma mark —— 控制台Log打印格式重写
#ifndef NSLog
#define NSLog(FORMAT, ...) fprintf(stderr,"\nfunction:%s line:%d content:%s\n", __FUNCTION__, __LINE__, [[NSString stringWithFormat:FORMAT, ##__VA_ARGS__] UTF8String]);
#endif

使之能简化打印结构体步骤

#pragma mark —— 打印结构体
#ifndef JobsLogCGPoint
#define JobsLogCGPoint(format, ...) NSLog(@"%s = %@", #format, NSStringFromCGPoint(__VA_ARGS__))
#endif

#ifndef JobsLogCGVector
#define JobsLogCGVector(format, ...) NSLog(@"%s = %@", #format, NSStringFromCGVector(__VA_ARGS__))
#endif

#ifndef JobsLogCGSize
#define JobsLogCGSize(format, ...) NSLog(@"%s = %@", #format, NSStringFromCGSize(__VA_ARGS__))
#endif

#ifndef JobsLogCGRect
#define JobsLogCGRect(format, ...) NSLog(@"%s = %@", #format, NSStringFromCGRect(__VA_ARGS__))
#endif

#ifndef JobsLogCGAffineTransform
#define JobsLogCGAffineTransform(format, ...) NSLog(@"%s = %@", #format, NSStringFromCGAffineTransform(__VA_ARGS__))
#endif

#ifndef JobsLogUIEdgeInsets
#define JobsLogUIEdgeInsets(format, ...) NSLog(@"%s = %@", #format, NSStringFromUIEdgeInsets(__VA_ARGS__))
#endif

#ifndef JobsLogDirectionalEdgeInsets
#define JobsLogDirectionalEdgeInsets(format, ...) NSLog(@"%s = %@", #format, NSStringFromDirectionalEdgeInsets(__VA_ARGS__))
#endif

#ifndef JobsLogOffset
#define JobsLogOffset(format, ...) NSLog(@"%s = %@", #format, NSStringFromUIOffset(__VA_ARGS__))
#endif

关注实现类：@interface UIView (Extras)

定义在View层

-(jobsByStringBlock _Nonnull)jobsLogFrame;
-(jobsByStringBlock _Nonnull)jobsLogPoint;
-(jobsByStringBlock _Nonnull)jobsLogSize;

相关调用

label.jobsLogFrame(@"打印的时候额外添加的标识字符");
label.jobsLogPoint(@"打印的时候额外添加的标识字符");
label.jobsLogSize(@"打印的时候额外添加的标识字符");

7.2、利用Runtime的机制打印类的内容

返回并打印成员变量列表

-(NSMutableArray <NSString *>*)printIvarList;

返回并打印属性列表

-(NSMutableArray <NSString *>*)printPropertyList;

返回并打印方法列表

-(NSMutableArray <NSString *>*)printMethodList;

返回并打印协议列表

-(NSMutableArray <NSString *>*)printProtocolList;

8、iOS xcode 代码块，提升编码效率必备之首选回到顶部

提升编码效率，快用快捷键调取代码块
脚本自动化：【MacOS】安装JobsCodeSnippets.command

9、手动打包`*.ipa`流程回到顶部

电脑桌面新建文件夹，并重命名为payload
真机运行项目（不同设备，不同芯片组，底层指令集不一致）
打开项目工程目录下Products，里面有个*.app
将这个*.app复制到刚才电脑桌面新建的payload文件夹
压缩电脑桌面新建的payload文件夹为zip格式的压缩包
将这个zip格式的压缩包，强行改名*.ipa
脚本自动化：【MacOS】放在iOS项目工程根目录下，自动打包并输出为ipa文件.command

10、`JobsBlock` 回到顶部

背景意义：统一全局的Block定义，减少冗余代码
特别说明：如果有外源（非系统Api）类参与到Block的定义，此时不能使用#import，因为会产生编译错误。此时正确的做法是使用@class

pod 'JobsBlock' # https://github.com/295060456/JobsBlock

因为CDN同步的原因，有些第三方pod并不能在cocoapods.org被成功的搜索到，这就导致如果pod install拉取不到代码，可能需要切换镜像，然后再进行操作。建议运行项目根目录下的2个脚本文件，自动获取
- 【MacOS】Pod_Install（适用于IOS工程根目录）.command
- 【MacOS】Pod_Update（适用于IOS工程根目录）.command

不定参数Block【使用示例】

[self GettingPicBlock:^(id firstArg, ...)NS_REQUIRES_NIL_TERMINATION{
    @jobs_strongify(self)
    if (firstArg) {
        // 取出第一个参数
        NSLog(@"%@", firstArg);
        // 定义一个指向个数可变的参数列表指针；
        va_list args;
        // 用于存放取出的参数
        id arg = nil;
        // 初始化变量刚定义的va_list变量，这个宏的第二个参数是第一个可变参数的前一个参数，是一个固定的参数
        va_start(args, firstArg);
        // 遍历全部参数 va_arg返回可变的参数(a_arg的第二个参数是你要返回的参数的类型)
        if ([firstArg isKindOfClass:NSNumber.class]) {
            NSNumber *num = (NSNumber *)firstArg;
            for (int i = 0; i < num.intValue; i++) {
                arg = va_arg(args, id);
//                    NSLog(@"KKK = %@", arg);
                if ([arg isKindOfClass:UIImage.class]) {
                    NSLog(@"");
                }else if ([arg isKindOfClass:PHAsset.class]){
                    NSLog(@"");
                }else if ([arg isKindOfClass:NSString.class]){
                    NSLog(@"");
                }else if ([arg isKindOfClass:NSArray.class]){
                    NSLog(@"");
                }else{
                    NSLog(@"");
                }
            }
        }else{
            NSLog(@"");
        }
        // 清空参数列表，并置参数指针args无效
        va_end(args);
    }
}];

11、`BaseProtocol` 相关继承结构关系图回到顶部

如果两个对象都继承了共同的协议，互相包含会造成编译器错误

classDiagram
    class BaseProtocol {
        <<protocol>>
    }
    class AppToolsProtocol {
        <<protocol>>
    }
    class XProtocol {
        <<protocol>>
    }
    class UITextFieldProtocol {
        <<protocol>>
    }
    class BaseButtonProtocol {
        <<protocol>>
    }
    class BaseLayerProtocol {
        <<protocol>>
    }
    class UILocationProtocol {
        <<protocol>>
    }
    class UIMarkProtocol {
        <<protocol>>
    }
    class UIPictureAndBackGroundCorProtocol {
        <<protocol>>
    }
    class UITextModelProtocol {
        <<protocol>>
    }
    class UIViewModelOthersProtocol {
        <<protocol>>
    }
    class UIViewModelProtocol {
        <<protocol>>
    }
    class BaseViewProtocol {
        <<protocol>>
    }
    class BaseViewControllerProtocol {
        <<protocol>>
    }
    class BaseCellProtocol {
        <<protocol>>
    }
    class UICollectionViewCellProtocol {
        <<protocol>>
    }
    class UITableViewCellProtocol {
        <<protocol>>
    }

    AppToolsProtocol --|> BaseProtocol
    XProtocol --|> BaseLayerProtocol
    XProtocol --|> UILocationProtocol
    XProtocol --|> UIMarkProtocol
    XProtocol --|> UIPictureAndBackGroundCorProtocol
    XProtocol --|> UITextModelProtocol
    XProtocol --|> UIViewModelOthersProtocol
    XProtocol --|> BaseButtonProtocol
    XProtocol --|> UITextFieldProtocol

    UIViewModelProtocol --|> XProtocol
    BaseViewProtocol --|> UIViewModelProtocol
    BaseViewControllerProtocol --|> BaseViewProtocol
    BaseCellProtocol --|> BaseViewProtocol
    UICollectionViewCellProtocol --|> BaseCellProtocol
    UITableViewCellProtocol --|> BaseCellProtocol

12、`UIViewModelFamily`（将持续更新）回到顶部

产生背景：页面之间传值，只需要瞄准1个数据束。当需要增删数据的时候，可以有效减少操作，方便管理
UIViewModel即是页面之间传值的这个数据束
UITextModel是专门针对文本的数据束
结合BaseProtocol进行封装
减少冗余代码，将公用头文件提升到协议进行定义

13、`JobsOCBaseCustomizeUIKitCore` 回到顶部

产生背景
- OC的基类是单继承
- 继承会产生很多基类，客观上造成代码的冗余
解决方案
- 继承和分类应该结合使用，功能各有优劣
- 分类即是"超级继承"，不需要产生额外的分类，方便管理和调用

14、度量衡回到顶部

手机屏幕尺寸大全
关注文件： MacroDef_Size.h

当设备横竖屏切换的时候，设备宽高定义会互相反转。即，此时（横屏）的屏幕宽即为垂直屏的高。同样的，此时（横屏）的屏幕高即为垂直屏的宽

寻找此设备真正的高

NS_INLINE CGFloat JobsDeviceRealHeight(void){
    return MAX(JobsMainScreen_WIDTH(), JobsMainScreen_HEIGHT());
}

寻找此设备真正的宽

NS_INLINE CGFloat JobsDeviceRealWidth(void){
    return MIN(JobsMainScreen_WIDTH(), JobsMainScreen_HEIGHT());
}

寻找当前屏幕真正的高

NS_INLINE CGFloat JobsRealHeight(void){
    return JobsAppTool.currentInterfaceOrientationMask == UIInterfaceOrientationMaskLandscape ? JobsDeviceRealWidth() :JobsDeviceRealHeight();
}

寻找当前屏幕真正的宽

NS_INLINE CGFloat JobsRealWidth(void){
    return JobsAppTool.currentInterfaceOrientationMask == UIInterfaceOrientationMaskLandscape ? JobsDeviceRealHeight() :JobsDeviceRealWidth();
}

当前设备是否是全面屏：
- 关注实现类：@interface UIDevice (XMUtils) 和 MacroDef_Size.h
```
+(BOOL)isFullScreen;
```

全局比例尺

NS_INLINE CGFloat JobsWidth(CGFloat width){
    return (JobsDeviceRealWidth() / 375) * width;
}

NS_INLINE CGFloat JobsHeight(CGFloat height){
    return (JobsDeviceRealHeight() / 743) * height;
}

安全距离

顶部的安全距离

NS_INLINE CGFloat JobsTopSafeAreaHeight(void){
    if (@available(iOS 11.0, *)) {
        return NSObject.mainWindow().safeAreaInsets.top;
    } else return 0.f;
}

底部的安全距离：全面屏手机为34pt，非全面屏手机为0pt

NS_INLINE CGFloat JobsBottomSafeAreaHeight(void){
    if (@available(iOS 11.0, *)) {
        return NSObject.mainWindow().safeAreaInsets.bottom;
    } else return 0.f;
}

状态栏高度

NS_INLINE CGFloat JobsStatusBarHeightByAppleIncData(void)

NS_INLINE CGFloat JobsRectOfStatusbar(void){
    SuppressWdeprecatedDeclarationsWarning(
        if (@available(iOS 13.0, *)){
            UIStatusBarManager *statusBarManager = NSObject.mainWindow().windowScene.statusBarManager;
            return statusBarManager.statusBarHidden ? 0 : statusBarManager.statusBarFrame.size.height;
        }else return UIApplication.sharedApplication.statusBarFrame.size.height;);
}

NS_INLINE CGFloat JobsStatusBarHeight(void){
    if (@available(iOS 11.0, *)) {
        return NSObject.mainWindow().safeAreaInsets.top;
    } else return JobsRectOfStatusbar();
}

导航栏高度

NS_INLINE CGFloat JobsNavigationHeight(UINavigationController * _Nullable navigationController){
    if (navigationController) {
        return navigationController.navigationBar.frame.size.height;
    }else return 44.f;
}

状态栏 + 导航栏高度

/// 非刘海屏：状态栏高度(20.f) + 导航栏高度(44.f) = 64.f
/// 刘海屏系列：状态栏高度(44.f) + 导航栏高度(44.f) = 88.f
NS_INLINE CGFloat JobsNavigationBarAndStatusBarHeight(UINavigationController * _Nullable navigationController){
    return JobsStatusBarHeight() + JobsNavigationHeight(navigationController);
}

TabBar高度：全面屏手机比普通手机多34的安全区域

NS_INLINE CGFloat JobsTabBarHeight(UITabBarController * _Nullable tabBarController){
    //因为tabbar可以自定义高度，所以这个地方返回系统默认的49像素的高度
    if (tabBarController) {
        return tabBarController.tabBar.frame.size.height;
    }else return 49.f;
}

包括了底部安全区域的TabBar高度，一般用这个

/// tabbar高度：【包括了底部安全区域的TabBar高度，一般用这个】
NS_INLINE CGFloat JobsTabBarHeightByBottomSafeArea(UITabBarController * _Nullable tabBarController){
    return JobsTabBarHeight(tabBarController) + JobsBottomSafeAreaHeight();
}

除开 tabBarController 和 navigationController 的内容可用区域的大小

#pragma mark ——  除开 tabBarController 和 navigationController 的内容可用区域的大小
NS_INLINE CGFloat JobsContentAreaHeight(UITabBarController * _Nullable tabBarController,
                                            UINavigationController * _Nullable navigationController){
    CGFloat tabBarHeightByBottomSafeArea = JobsTabBarHeightByBottomSafeArea(tabBarController);
    CGFloat navigationBarAndStatusBarHeight = JobsNavigationBarAndStatusBarHeight(navigationController);
    return JobsMainScreen_HEIGHT(nil) - tabBarHeightByBottomSafeArea - navigationBarAndStatusBarHeight;
}

15、字符串回到顶部

富文本字符串的优先级要高于普通字符串。也就意味着，如果调用了富文本字符串，即便将其设置为nil，普通字符串的设置依然不会奏效

-(UILabel *)titleLab{
    if(!_titleLab){
        @jobs_weakify(self)
        _titleLab = jobsMakeLabel(^(__kindof UILabel * _Nullable label) {
            @jobs_strongify(self)
            if(NavBarConfig.attributedTitle) label.attributedText = NavBarConfig.attributedTitle;
            label.text = NavBarConfig.title;
            label.font = NavBarConfig.font;
            label.textColor = NavBarConfig.titleCor;
            self.addSubview(label);
            [label mas_makeConstraints:^(MASConstraintMaker *make) {
                make.center.equalTo(self);
                make.height.mas_equalTo(self.height);
            }];label.makeLabelByShowingType(UILabelShowingType_03);
            self.refresh();
        });
    }return _titleLab;
}

15.1、字符串判空

判空（因为nil是不能唤起方法的，为了防止字符串是nil，所以此方法必须是类方法或者是内敛函数）

NS_INLINE BOOL isNull(NSString * _Nullable string){
    if(string == nil) return YES;
    if(string == NULL) return YES;
    if((NSNull *)string == NSNull.null) return YES;
    if([string isKindOfClass:NSNull.class]) return YES;
    if([string isKindOfClass:NSString.class]){
        NSString *str = (NSString *)string;
        if([str isEqualToString:@"(null)"]) return YES;
        if([str isEqualToString:@"null"]) return YES;
        if([str isEqualToString:@"<null>"]) return YES;
        if([str isEqualToString:@""]) return YES;
        /// 去掉两端的空格
        return ![str stringByTrimmingCharactersInSet:NSCharacterSet.whitespaceAndNewlineCharacterSet].length;
    }else{
        NSString *str = [NSString stringWithFormat:@"%@",string];
        /// 去掉两端的空格
        return ![str stringByTrimmingCharactersInSet:NSCharacterSet.whitespaceAndNewlineCharacterSet].length;
    }return NO;
}

有价值的字符串：nil、NSNull、@”“、@” “均为无意义的字符串

NS_INLINE BOOL isValue(NSString * _Nullable string){
    return !isNull(string);
}

15.2、字符串转化

关注头文件JobsString.h

基本数据类型转化成字符串类型

NS_INLINE NSString * _Nonnull toStringByInt(int i){
    return [NSString stringWithFormat:@"%d",i];
}

NS_INLINE NSString * _Nonnull toStringByFloat(float i){
    return [NSString stringWithFormat:@"%f",i];
}

NS_INLINE NSString * _Nonnull toStringByDouble(double i){
    return [NSString stringWithFormat:@"%f",i];
}

NS_INLINE NSString * _Nonnull toStringByNSInteger(NSInteger i){
    return [NSString stringWithFormat:@"%ld",(long)i];
}

NS_INLINE NSString * _Nonnull toStringByNSUInteger(NSUInteger i){
    return [NSString stringWithFormat:@"%lu",(unsigned long)i];
}

NS_INLINE NSString * _Nonnull toStringByLong(long i){
    return [NSString stringWithFormat:@"%ld",i];
}

NS_INLINE NSString * _Nonnull toStringByLongLong(long long i){
    return [NSString stringWithFormat:@"%lld",i];
}

15.3、字符串拼接

-(JobsReturnStringByStringBlock _Nonnull)add{
    @jobs_weakify(self)
    return ^NSMutableString *_Nullable(NSString *_Nonnull str) {
        @jobs_strongify(self)
        if(!str) str = @"";
        // 系统的stringByAppendingString方法在参数为nil的时候会崩溃
        return JobsMutableString([self stringByAppendingString:str]);/// 原始字符串不会改变，输出一个新的字符串
    };
}

config_01.targetString = JobsInternationalization(@"编译器自动管理内存地址").add(@"\n");

15.4、字符串比较

字符串相等

-(JobsReturnBOOLByIDBlock)isEqualToString{
    @jobs_weakify(self)
    return ^(NSString *data){
        @jobs_strongify(self)
        if ([data isKindOfClass:NSString.class]) {
            return [self isEqualToString:data];
        }return NO;
    };
}

字符串包含

-(JobsReturnBOOLByIDBlock)containsString{
    @jobs_weakify(self)
    return ^(NSString *data){
        @jobs_strongify(self)
        if ([data isKindOfClass:NSString.class]) {
            return [self containsString:data];
        }return NO;
    };
}

15.5、字符串转`NSURL *`

/**
 问题：直接其他地方复制过来的中文字进行网页搜索、或者中文字识别排序等情况的，会出现搜索不到的情况。
 解决方法：可能存在复制源里面的文字带了空白url编码%E2%80%8B，空白编码没有宽度，虽然看不到但是会影响结果无法正确匹配对应的中文字。可以把文字重新url编码即可。
 */
-(NSString *_Nonnull)urlProtect{
    if ([self containsString:@"\u200B"]) {
        return [self stringByReplacingOccurrencesOfString:@"\u200B" withString:JobsInternationalization(@"")];
    }else return self;
}
/// 返回文件路径相关的NSURL *
-(NSURL *_Nonnull)jobsFileUrl{
    return [NSURL fileURLWithPath:self];
}

@"http://47.243.60.31:9200".urlProtect;

15.6、字符串写文件

-(void)保留文字{
    if (isValue(self.inputDataString)) {
        JobsUserModel.sharedManager.postDraftURLStr = [NSObject saveData:self.inputDataString
                                                   withDocumentsChildDir:JobsInternationalization(@"发帖草稿数据临时文件夹")
                                                            fileFullname:@"发帖草稿数据.txt"
                                                                   error:nil];
    }else{
        FileFolderHandleTool.cleanFilesWithPath(JobsUserModel.sharedManager.postDraftURLStr);
    }
    NSLog(@"%@",JobsUserModel.sharedManager.postDraftURLStr);
    [self.view hx_showLoadingHUDText:nil];
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        BOOL success = [self.photoManager saveLocalModelsToFile];//保存图片
        dispatch_async(dispatch_get_main_queue(), ^{
            [self.view hx_handleLoading];
            if (success) {
                [self back:nil];
            }else {
                [self.view hx_showImageHUDText:JobsInternationalization(@"保存失败")];
            }
        });
    });
}

15.7、更多...

16、`UILabel`的自适应回到顶部

影响范围：UILabe 和 UIButton

关键代码

#ifndef JobsLabelDef_h
#define JobsLabelDef_h
typedef enum : NSInteger {
    /// 一行显示。定宽、定高、定字体。多余部分用…表示（省略号的位置由NSLineBreakMode控制）
    UILabelShowingType_01 = 1,
    /// 一行显示。定宽、定高、定字体。多余部分scrollerView
    UILabelShowingType_02,
    /// 一行显示。不定宽、定高、定字体。宽度自适应 【单行：ByFont】
    UILabelShowingType_03,
    /// 一行显示。定宽、定高。缩小字体方式全展示 【单行：ByWidth】
    UILabelShowingType_04,
    /// 多行显示。定宽、不定高、定字体 【多行：ByFont】
    UILabelShowingType_05,
} UILabelShowingType;// UILabel的显示样式
#endif /* JobsLabelDef_h */

作用于 UILabe 必须等UILabe *的Frame正确刷新加载以后，才可以使用以下方法
```
-(jobsByNSIntegerBlock _Nonnull)makeLabelByShowingType;
```
作用于 UIButton 必须等UIButton *的Frame正确刷新加载以后，才可以使用以下方法
```
-(jobsByNSIntegerBlock _Nonnull)makeBtnLabelByShowingType;
```

示例

-(UILabel *)titleLab{
    if(!_titleLab){
        @jobs_weakify(self)
        _titleLab = jobsMakeLabel(^(__kindof UILabel * _Nullable label) {
            @jobs_strongify(self)
            label.text = JobsInternationalization(@"LOGIN");
            label.font = bayonRegular(20);
            label.textColor = JobsCor(@"FFC700");
            [self addSubview:label];
            [label mas_makeConstraints:^(MASConstraintMaker *make) {
                make.centerX.equalTo(self);
                make.top.equalTo(self).offset(JobsWidth(13));
            }];label.makeLabelByShowingType(UILabelShowingType_03);
        });
    }return _titleLab;
}

17、文件介绍回到顶部

各项宏定义

#import "MacroDef_Size.h"
#import "MacroDef_App.h"
#import "MacroDef_Cor.h"
#import "MacroDef_Func.h"
#import "MacroDef_Sys.h"
#import "MacroDef_Font.h"
#import "MacroDef_String.h"
#import "MacroDef_Singleton.h"
#import "MacroDef_Time.h"
#import "MacroDef_QUEUE.h"
#import "JobsUserDefaultDefine.h"
#import "MacroDef_Strong@Weak.h"
#import "MacroDef_Notification.h"
#import "MacroDef_Log.h"

全局通知名字符串的管理

#import "JobsOCBaseConfigNotificationManager.h"

CocoaPods的头文件管理

#import "DDPods.h"
#import "DDPodsManual.h"

全局枚举定义
```
#import "JobsDefineAllEnumHeader.h"
```

**.pch**文件

#import "FMPrefixHeader.pch"
#import "JobsOCBaseConfigDemoPrefixHeader.pch"

储存key值的文件：
```
#import "APIKey.h"
```
网络请求的接口的文件
```
#import "NSObject+URLManager.h
```

18、输入框（`UITextField`）回到顶部

18.1、`UITextFieldDelegate`

在文本字段即将开始编辑时调用。返回YES表示允许编辑，返回NO则表示不允许编辑

/// 用途：您可以使用此方法进行输入验证或单元格选择，以决定是否允许用户开始编辑。
-(BOOL)textFieldShouldBeginEditing:(UITextField *)textField{
    return YES;
}

文本字段已经开始编辑时调用

/// 用途：在此方法中，您可以开始相应的操作，例如更新用户界面（UI），显示工具条等
-(void)textFieldDidBeginEditing:(UITextField *)textField{
    
}

在文本字段即将结束编辑时调用。返回YES表示允许结束编辑，返回NO则表示不允许结束编辑

/// 用途：您可以在这里执行验证，例如检查用户输入的有效性
-(BOOL)textFieldShouldEndEditing:(UITextField *)textField{
    return YES;
}

文本字段已经结束编辑时调用

/// 用途：在此方法中，可以处理输入完成后的操作，例如更新数据模型或用户界面的状态
-(void)textFieldDidEndEditing:(UITextField *)textField{
    
}

文本字段结束编辑时调用，并带有结束原因

/// 用途：可以根据不同的结束原因执行不同的操作
/// API_AVAILABLE(ios(10.0))
-(void)textFieldDidEndEditing:(UITextField *)textField
                        reason:(UITextFieldDidEndEditingReason)reason{
}

在文本字段的字符将要改变时调用，因为用户输入、删除或粘贴内容。返回YES允许更改，返回NO禁止更改
- 对于删除操作，此时的string是长度为0个字符单位的空字符
- 对于空格操作，此时的string是长度为1个字符单位的空字符
```
/// 用途：您可以用于限制输入的字符类型或长度，或实现某些格式化规则
-(BOOL)textField:(UITextField *)textField
shouldChangeCharactersInRange:(NSRange)range
replacementString:(NSString *)string{
    return YES;
}
```

在文本字段的选中文本发生改变时调用 API_AVAILABLE(ios(13.0), tvos(13.0))

/// 用途：可以用于实时更新相关UI或执行某些操作
-(void)textFieldDidChangeSelection:(UITextField *)textField{
    
}

在清除文本字段内容之前调用。返回YES允许清除，返回NO禁止清除

/// 用途：可以用于提示用户、确认清除操作或进行额外的验证。
-(BOOL)textFieldShouldClear:(UITextField *)textField{
    return YES;
}

在用户按下Return键时调用。返回YES表示处理当前输入（如关闭键盘），返回NO表示不处理

/// 用途：一般用于提交表单，关闭键盘，或进行下一步的输入
-(BOOL)textFieldShouldReturn:(UITextField *)textField{
    return YES;
}

在文本字段要展示编辑菜单时调用。可自定义菜单内容 API_AVAILABLE(ios(16.0))

/// 用途：可以提供自定义的剪切、复制、粘贴等操作选项
-(nullable UIMenu *)textField:(UITextField *)textField
  editMenuForCharactersInRange:(NSRange)range
              suggestedActions:(NSArray<UIMenuElement *> *)suggestedActions{
    return nil;
}

在文本字段即将展示编辑菜单时调用 API_AVAILABLE(ios(16.0)) API_UNAVAILABLE(tvos, watchos)

/// 用途：可以在菜单展示前进行动画处理或其他UI调整
-(void)textField:(UITextField *)textField
willPresentEditMenuWithAnimator:(id<UIEditMenuInteractionAnimating>)animator{
    
}

在文本字段即将消失编辑菜单时调用

/// 用途：可以在菜单消失前进行相关清理或动画效果
/// API_AVAILABLE(ios(16.0)) API_UNAVAILABLE(tvos, watchos)
-(void)textField:(UITextField *)textField
willDismissEditMenuWithAnimator:(id<UIEditMenuInteractionAnimating>)animator{
    
}

18.2、系统提供的修改接口（子类需要重写以下父类方法）

当前文本框聚焦时就会调用

-(BOOL)becomeFirstResponder{
    return [super becomeFirstResponder];
}

当前文本框失去焦点时就会调用

-(BOOL)resignFirstResponder{
    return [super resignFirstResponder];
}

重写来重置clearButton位置,改变size可能导致button的图片失真

-(CGRect)clearButtonRectForBounds:(CGRect)bounds{
	return [super clearButtonRectForBounds:bounds];
}

leftView——Rect 【键盘弹起会调用此方法】

-(CGRect)leftViewRectForBounds:(CGRect)bounds{
	return [super leftViewRectForBounds:bounds];
}

rightView——Rect 【键盘弹起会调用此方法】

- (CGRect)rightViewRectForBounds:(CGRect)bounds{
	return [super rightViewRectForBounds:bounds];
}

重写改变绘制占位符属性。重写时调用super可以按默认图形属性绘制;若自己完全重写绘制函数，就不用调用super了
```
-(void)drawPlaceholderInRect:(CGRect)rect{
	return [super drawPlaceholderInRect:rect];
}
```

重写来重置边缘区域

-(CGRect)borderRectForBounds:(CGRect)bounds{
    return [super borderRectForBounds:bounds];
}

重写来重置占位符区域【键盘弹起会调用此方法】

-(CGRect)placeholderRectForBounds:(CGRect)bounds{
    return [super placeholderRectForBounds:bounds];
}

重写来重置文字区域【未编辑状态下光标的起始位置】【键盘弹起会调用此方法】
```
-(CGRect)textRectForBounds:(CGRect)bounds{
    return [super textRectForBounds:bounds];
}
```
重写来重置编辑区域【编辑状态下的起始位置】、UIFieldEditor的位置大小【键盘弹起会调用此方法】
```
-(CGRect)editingRectForBounds:(CGRect)bounds{
    return [super editingRectForBounds:bounds];
}
```

18.3、有4+1个`TextField`可供继承使用（具体使用方式，查询相关头文件定义）

18.3.1、处理方式：将`UITextField`作为一个子视图加载到一个父容器视图

产生背景
- iOS系统的 UITextField 内部其实还有若干子视图，对于这些子视图原则上是不希望我们进行直接访问的，所以在设计之初就没有提供更多的Api对外暴露给我们使用
- 然而，当我们需要自定义一些UI的时候，因为在-(void)layoutSubviews等生命周期方法中是过程值（不准确，不是我们想要的），这个过程值又UI的展开有关，很难定位终值，就会对我们的布局产生纠缠，至少增加思维量和代码厚度，加大接入难度
- 键盘的弹起和回收也会对这些子视图的frame产生影响。这让情况变得更加错综复杂
- 特别的，如果要自定义光标的闪动位置、TextField.leftView.frame、TextField.rightView.frame、清除按钮的frame等功能的话，就会变得很吃力，甚至不可为
- 现在的做法是将系统的UITextField作为一个整体，不再去关心内部的子视图的实现及其布局调整
  - 外界传入的leftView替代系统的**TextField**.leftView
  - 外界传入的rightView替代系统的**TextField**.rightView
- 对**textField**我们只关心2个值
  - 当下输入的文本值
  - 当前**textField**的文本值
- placeholder是针对普通文本。系统原则上不希望我们在这个属性上去过多纠缠文本字体、文本色号，转而考虑attributedPlaceholder。但如果一定要对placeholder的文本字体、文本色号进行定义，则关注placeholderColor、placeholderFont

JobsTextField：BaseView

-(JobsTextField *)textField_phone{
    if(!_textField_phone){
        @jobs_weakify(self)
        _textField_phone = makeJobsTextField(^(__kindof JobsTextField * _Nullable data) {
            @jobs_strongify(self)
            data.backgroundColor = JobsBlackCor(0.5f);
            // 只针对真实的textField配置
            data.realTextFieldBgCor = JobsClearColor;
            data.titleCor = JobsCor(@"#FAFF00");
            data.leftViewByOutLineOffset = JobsWidth(4);
            data.leftViewByTextFieldOffset = JobsWidth(4);
            data.rightViewByTextFieldOffset = JobsWidth(4);
            data.rightViewByOutLineOffset = JobsWidth(14);
            data.returnKeyType = UIReturnKeyDefault;
            data.keyboardAppearance = UIKeyboardAppearanceDefault;
            data.keyboardType = UIKeyboardTypePhonePad;
            data.leftViewMode = UITextFieldViewModeNever;
            data.rightViewMode = UITextFieldViewModeNever;
            data.leftView = [self zoneCodeBtnByBlock:^(id _Nullable x) {
                @jobs_strongify(self)
                if (self.objBlock) self.objBlock(x);
            }];
            data.textFieldPlaceholder = JobsInternationalization(@"Validate phone no. starts with 0 and must be 11 digits");
            data.placeholderColor = JobsCor(@"#6A6A6A");
            data.placeholderFont = UIFontWeightSemiboldSize(10);
            data.layoutSubviewsRectCorner = UIRectCornerAllCorners;
            data.layoutSubviewsRectCornerSize = CGSizeMake(JobsWidth(8), JobsWidth(8));
            // 真实的textField，输入回调（每次输入的字符），如果要当前textField的字符，请取值textField.text
            [data actionObjBlock:^(id  _Nullable data) {
                JobsLog(@"ddf = %@",data);
            }];
            [self addSubview:data];;
            [data mas_makeConstraints:^(MASConstraintMaker *make) {
                make.size.mas_equalTo(CGSizeMake(JobsWidth(200), JobsWidth(32)));
                make.top.equalTo(self.titleLab_phone.mas_bottom);
                make.left.equalTo(self.titleLab_phone);
            }];
            data.jobsRichViewByModel(nil);
            // 最外层的UI-描边
            data.layerByBorderCor(JobsCor(@"#FFC700")).layerByBorderWidth(1);
            // 最外层的UI-切全角
            data.cornerCutToCircleWithCornerRadius(JobsWidth(8));
        });
    }return _textField_phone;
}

-(UIImageView *)textFieldLeftView{
    if(!_textFieldLeftView){
        _textFieldLeftView = jobsMakeImageView(^(__kindof UIImageView * _Nullable imageView) {
            imageView.image = JobsIMG(@"UserLogoTextFieldLeftImage");
            imageView.sizer = CGSizeMake(JobsWidth(15), JobsWidth(15));
        });
    }return _textFieldLeftView;
}

-(UIImageView *)textFieldRightView{
    if(!_textFieldRightView){
        _textFieldRightView = jobsMakeImageView(^(__kindof UIImageView * _Nullable imageView) {
            imageView.image = JobsIMG(@"UserLogoTextFieldRightImage");
            imageView.sizer = CGSizeMake(JobsWidth(16), JobsWidth(16));
        });
    }return _textFieldRightView;
}

18.3.2、处理方式：`UITextField`的子类

CJTextField：UITextField
HQTextField：CJTextField：UITextField

JobsMagicTextField：ZYTextField：UITextField

-(JobsMagicTextField *)textField{
    if (!_textField) {
        _textField = JobsMagicTextField.new;
        _textField.delegate = self;
        @jobs_weakify(self)
        [_textField jobsTextFieldEventFilterBlock:^BOOL(id _Nullable data) {
            @jobs_strongify(self)
            return self.returnBoolByIDBlock ? self.returnBoolByIDBlock(data) : YES;
        } subscribeNextBlock:^(id _Nullable x) {
            @jobs_strongify(self)
            NSLog(@"MMM = %@",x);
            [self block:self->_textField
                  value:x];
        }];
        [self addSubview:_textField];
        [_textField mas_makeConstraints:^(MASConstraintMaker *make) {
            make.left.top.bottom.equalTo(self);
            make.right.equalTo(self.imageCodeView.mas_left);
        }];
    }return _textField;
}

-(void)configTextField{
    _textField.leftView = [UIImageView.alloc initWithImage:self.doorInputViewBaseStyleModel.leftViewIMG];
    _textField.leftViewMode = self.doorInputViewBaseStyleModel.leftViewMode;
    _textField.returnKeyType = self.doorInputViewBaseStyleModel.returnKeyType;
    _textField.keyboardAppearance = self.doorInputViewBaseStyleModel.keyboardAppearance;
    _textField.placeholder = self.doorInputViewBaseStyleModel.placeHolderStr;
    _textField.keyboardType = self.doorInputViewBaseStyleModel.keyboardType;
    _textField.textColor = self.doorInputViewBaseStyleModel.titleStrCor;
    _textField.useCustomClearButton = self.doorInputViewBaseStyleModel.useCustomClearButton;
    _textField.isShowDelBtn = self.doorInputViewBaseStyleModel.isShowDelBtn;
    _textField.rightViewOffsetX = self.doorInputViewBaseStyleModel.rightViewOffsetX ? : JobsWidth(8);// 删除按钮的偏移量
    _textField.placeholderColor = self.doorInputViewBaseStyleModel.placeholderColor;
    _textField.leftViewOffsetX = self.doorInputViewBaseStyleModel.leftViewOffsetX ? : JobsWidth(17);
    _textField.placeholderFont = self.doorInputViewBaseStyleModel.placeholderFont;
    _textField.requestParams = self.textFieldInputModel;
    _textField.animationColor = self.doorInputViewBaseStyleModel.animationColor ? : Cor4;
    _textField.placeHolderAlignment = self.doorInputViewBaseStyleModel.placeHolderAlignment ? : NSTextAlignmentLeft;
    _textField.placeHolderOffset = self.doorInputViewBaseStyleModel.placeHolderOffset ? : JobsWidth(20);
    _textField.moveDistance = self.doorInputViewBaseStyleModel.moveDistance ? : JobsWidth(40);
    _textField.fieldEditorOffset = self.doorInputViewBaseStyleModel.fieldEditorOffset ? : JobsWidth(50);
}

ZYTextField： UITextField

-(ZYTextField *)textField{
   if (!_textField) {
       _textField = ZYTextField.new;
       _textField.delegate = self;
       _textField.textColor = JobsBlackColor;
       _textField.backgroundColor = RGBA_COLOR(245, 245, 245, 1);
       _textField.returnKeyType = UIReturnKeyDefault;
       _textField.keyboardAppearance = UIKeyboardAppearanceDefault;
       _textField.keyboardType = UIKeyboardTypeDefault;
       _textField.rightView = self.titleLab;
       _textField.rightViewMode = UITextFieldViewModeAlways;
       _textField.placeholder = JobsInternationalization(@"打赏的Mata值");
       _textField.placeholderColor = JobsCor(@"#333333");
       _textField.placeholderFont = UIFontWeightRegularSize(12);

       _textField.drawPlaceholderInRect = CGRectMake(0, 0, JobsWidth(255 - 20 - 40 - 5), JobsWidth(32));
       _textField.rightViewRectForBounds = CGRectMake(JobsWidth(255 - 20 - 40), JobsWidth(10), JobsWidth(40), JobsWidth(12));
       _textField.placeholderRectForBounds = CGRectMake(JobsWidth(10), JobsWidth(10), JobsWidth(255 - 20 - 40 - 5), JobsWidth(12));
       _textField.textRectForBounds = CGRectMake(JobsWidth(10), 0, JobsWidth(255 - 20 - 40 - 10), 100);
       _textField.editingRectForBounds = CGRectMake(JobsWidth(10), 0, JobsWidth(255 - 20 - 40 - 10), 100);

       @jobs_weakify(self)
       [_textField jobsTextFieldEventFilterBlock:^BOOL(id data) {
//            @jobs_strongify(self)
           return YES;
       } subscribeNextBlock:^(NSString * _Nullable x) {
           @jobs_strongify(self)
           self.textField.text = x;
           [self textFieldBlock:self.textField
                 textFieldValue:x];
       }];
       [_textField cornerCutToCircleWithCornerRadius:JobsWidth(8)];
       [self addSubview:_textField];
       [_textField mas_makeConstraints:^(MASConstraintMaker *make) {
           make.size.mas_equalTo(CGSizeMake(JobsWidth(255), JobsWidth(32)));
           make.centerX.equalTo(self);
           make.top.equalTo(self.titleView.mas_bottom).offset(JobsWidth(10));
       }];
   }return _textField;
}

18.4、字符过滤

一般情况下，如果要监控输入字符，需要实现相应的UITextFieldDelegate方法，某些情况下会比较繁琐，包括但不仅限于下列：
- 监控emoji字符（多个字符组成一个emoji字符，且emoji字符集还在随时扩充）
- 监控输入空格和删除操作

目前最好的字符过滤解决方案：利用ReactiveCocoa框架

对ReactiveCocoa框架的二次封装，方便对ReactiveCocoa框架不熟悉的使用者

-(RACDisposable *)jobsTextFieldEventFilterBlock:(JobsReturnBOOLByIDBlock)filterBlock
                             subscribeNextBlock:(jobsByIDBlock)subscribeNextBlock{
    return [[self.rac_textSignal filter:^BOOL(NSString * _Nullable value) {
        return filterBlock ? filterBlock(value) : YES;
    }] subscribeNext:^(NSString * _Nullable x) {
        if (subscribeNextBlock) subscribeNextBlock(x);
    }];
}

最外层的调用方式

 @jobs_weakify(self)
 [_textField jobsTextFieldEventFilterBlock:^BOOL(id data) {
//            @jobs_strongify(self)
     return YES;
 } subscribeNextBlock:^(NSString * _Nullable x) {
     @jobs_strongify(self)
     self.textField.text = x;
     [self textFieldBlock:self.textField
           textFieldValue:x];
 }];

18.5、禁止编辑

isUserInteractionEnabled：设置为 false 后，用户将无法与 UITextField 进行任何交互，包括无法选择文本、无法点击光标等
```
UITextField *textField = UITextField.new;
textField.isUserInteractionEnabled = NO;
```
enabled：设置为 false 后，UITextField 将变成白色，用户无法输入文字，但仍然可以选择和复制文本
```
UITextField *textField = UITextField.new;
textField.enabled = NO;
```

18.6、阻止键盘弹起（而是转向其他的操作）

// 实现代理方法
- (BOOL)textFieldShouldBeginEditing:(UITextField *)textField {
    // 在这里执行其他操作
    NSLog(@"TextField 被点击了，但不会弹出键盘");
    return NO; // 返回 NO，阻止键盘弹出
}

18.7、RAC监控输入框

制作信号

如果UITextField不可用

/// 则监控UITextField.text
-(NSArray<RACSignal *>*_Nonnull)makeSignals1{
   @jobs_weakify(self);
   return [jobsMakeMutArr(^(__kindof NSMutableArray * _Nullable data) {
       @jobs_strongify(self)
       /// 获取所有需要监控的输入框
//            data.add(textField1.realTextField);
//            data.add(textField2.realTextField);
   }).rac_sequence map:^id(UITextField *textField) {
       return [RACSignal merge:jobsMakeMutArr(^(__kindof NSMutableArray * _Nullable data) {
           data.add(textField.rac_textSignal);/// 监听用户输入
           data.add(RACObserve(textField, text));/// 监听直接设置的 text
       })];
   }].array;
}

如果UITextField可用

/// 创建每个输入框的信号：结合 `rac_textSignal` 和 KVO 信号
-(id<NSFastEnumeration>)makeSignals2{
   @jobs_weakify(self);
   return jobsMakeMutArr(^(__kindof NSMutableArray * _Nullable data) {
       @jobs_strongify(self)
       /// 获取所有需要监控的输入框
//        data.add(textField1.rac_textSignal);
//        data.add(textField2.rac_textSignal);
   });
}

处理信号

-(void)checkInput{
   @jobs_weakify(self);
   /// 合并信号并处理逻辑
   [[RACSignal combineLatest:self.makeSignals1 /// 或者 self.makeSignals2
                      reduce:^id(NSString *text1,
                                 NSString *text2) {
       /// 检查每个输入框是否有值
       return @(
           isValue(text1) &&
           isValue(text2)
       );
   }] subscribeNext:^(NSNumber *bothHaveText) {
       @jobs_strongify(self);
//        if (bothHaveText.boolValue) {
//            self.submitBtn.jobsResetBtnBgImage(JobsIMG(@"SUBMIT"));
//            self.submitBtn.enabled = YES;
//        } else {
//            self.submitBtn.jobsResetBtnBgImage(JobsIMG(@"SUBMIT（不可点击）"));
//            self.submitBtn.enabled = NO;
//        }
   }];
}

19、寻找系统关键变量回到顶部

**寻找当前控制器 **

获取window

获取iOS 13之前的 window

NS_INLINE UIWindow *_Nullable jobsGetMainWindowBefore13(void){
    UIWindow *window = nil;
    /// 使用UIApplication的windows属性来获取当前窗口：
    /// 这种方式获取窗口的方式在iOS 13之前是常用的做法
    if (UIApplication.sharedApplication.delegate.window) {
        window = UIApplication.sharedApplication.delegate.window;
    }
    
    if(!window){
        /// 这种获取窗口的方式在iOS 2.0到iOS 13.0版本之间都是可用的
        SuppressWdeprecatedDeclarationsWarning(
            if (UIApplication.sharedApplication.keyWindow) {
            window = UIApplication.sharedApplication.keyWindow;
        });
    }return window;
}

获取iOS 13之后的 window

NS_INLINE UIWindow *_Nullable jobsGetMainWindowAfter13(void){
    UIWindow *mainWindow = nil;
    if (@available(iOS 13.0, *)) {
        for (UIWindowScene* windowScene in UIApplication.sharedApplication.connectedScenes) {
            if (windowScene.activationState == UISceneActivationStateForegroundActive) {
                for (UIWindow *window in windowScene.windows) {
                    if (window.isKeyWindow) {
                        mainWindow = window;
                        break;
                    }
                }
            }
            if (mainWindow) {
                break; // 如果找到主窗口，退出循环
            }else{
                mainWindow = windowScene.windows.firstObject;
            }
        }
    }return mainWindow;
}

获取全系统是的 window

@implementation NSObject (Extras)

+(JobsReturnWindowByVoidBlock _Nonnull)mainWindow{
    return ^__kindof UIWindow *_Nullable(){
        UIWindow *mainWindowBefore13 = jobsGetMainWindowBefore13().landscape;
        UIWindow *mainWindowAfter13 = jobsGetMainWindowAfter13().landscape;
        UIWindow *resultWindow = UIDevice.currentDevice.systemVersion.floatValue >= 13.0 ? mainWindowAfter13 : mainWindowBefore13;
        
        if(resultWindow) return resultWindow;
        if(mainWindowBefore13) return mainWindowBefore13;
        if(mainWindowAfter13) return mainWindowAfter13;
        return nil;
    };
}

获取一个有Size的 window

NS_INLINE UIWindow *_Nullable jobsGetMainWindowWithSize(void){
    UIWindow *window = nil;
    window = NSObject.mainWindow();
    return CGSizeEqualToSize(CGSizeZero, window.size) ? jobsGetMainWindowBefore13() : window;
}

获取 keyWindowSceneiOS 13版本后可用

NS_INLINE UIWindowScene *_Nullable jobsGetkeyWindowScene(void) {
    if(@available(iOS 13.0, *)){
        UIWindowScene *keyWindowScene = (UIWindowScene *)UIApplication.sharedApplication.connectedScenes.allObjects.firstObject;
        return keyWindowScene;
    }else return nil;
}

寻找AppDelegate

NS_INLINE id<UIApplicationDelegate> _Nullable getSysAppDelegate(void){
    return UIApplication.sharedApplication.delegate;
}

AppDelegate *appDelegate;/// 声明，否则 extern AppDelegate *appDelegate;会崩溃
@interface AppDelegate ()

@end

extern AppDelegate *appDelegate;

寻找SceneDelegate

NS_INLINE id _Nullable getSysSceneDelegate(void){
    id sceneDelegate = nil;
    if (@available(iOS 13.0, *)) {
        sceneDelegate = UIApplication.sharedApplication.connectedScenes.allObjects.firstObject.delegate;
    }return sceneDelegate;
}

读写用户信息

/// 模拟用户数据
-(jobsByVoidBlock _Nonnull)simulateUserData{
    return ^(){
        self.saveUserInfo(jobsMakeUserModel(^(__kindof JobsUserModel<NSCoding> * _Nullable userModel) {
            userModel.userHeaderIMG = JobsIMG(@"用户默认头像");
            userModel.userName = @"张三丰";
            userModel.phone = @"13487878787".encryptedChineseTele;
        }));
        id f = self.readUserInfo;
        JobsLog(@"");
    };
}
/// 存取用户信息Demo
-(jobsByVoidBlock _Nonnull)saveAndReadUserInfoDemo{
    @jobs_weakify(self)
    return ^(){
        @jobs_strongify(self)
        self.saveUserInfo(jobsMakeUserModel(^(__kindof JobsUserModel<NSCoding> * _Nullable userModel) {
            userModel.token = @"12345";
            userModel.uid = @"54321";
        }));
//        JobsUserModel *f = self.readUserInfo;
//        JobsLog(@"");
    };
}

-(jobsByVoidBlock _Nonnull)loginByAccAndPwd{
    return ^(){
        FM_loginByVerificationCode_api *api = [FM_loginByVerificationCode_api.alloc initWithParameters:@{
            @"captcha_id": @"",
            @"captcha_key": @"",
            @"captcha_output": @"",
            @"countryCode": @"CN",/// 国家编码两位码(中国CN、越南VN)-国家的ISO 3166-1 Alpha-2代码
            @"domain": @"",
            @"gen_time": @"",
            @"inviteCode": @"",/// 代理邀请码
            @"lot_number": @"",
            @"mobile": @"09668536375",/// 手机号
            @"pass_token": @"",
            @"password": @"",/// 密码
            @"referCode": @"",
            @"smsCode": @"888",/// 短信验证码
            @"userName": @""/// 用户名
        }];
        if ([api loadCacheWithError:nil]) {
            NSDictionary *json = api.responseJSONObject;
            NSLog(@"json = %@", json);
            // show cached data
        }

        api.animatingText = JobsInternationalization(@"正在登录");
        api.animatingView = self;

        [api startWithCompletionBlockWithSuccess:^(YTKBaseRequest *request) {
            JobsResponseModel *responseModel = [JobsResponseModel mj_objectWithKeyValues:request.responseObject];
            if(responseModel.code == HTTPResponseCodeSuccess){
                NSLog(@"登录成功");
                FMLoginModel *model = [FMLoginModel mj_objectWithKeyValues:responseModel.data];
                self.jobsSaveUserInfo(model,FM用户数据);
                id f = self.readUserInfoByUserName(FMLoginModel.class,FM用户数据);
                if (self.objectBlock) self.objectBlock(self.login_btn);
            }
        } failure:^(YTKBaseRequest *request) {
            NSLog(@"failed");
        }];
    };
}

20、`JobsTabBarCtrl`-深层次自定义`UITabbar` 回到顶部

背景介绍
- 完全继承自系统Api，最大化兼容系统特色
- 扩展系统的一些方法，丰富使用
功能介绍
- 支持 Tabbaritem 在居中对齐的大前提下，图文相对位置的4个方向适配
- 自定义 UITabBar
- 支持单例模式
- 导航控制器包裹每一个子控制器，使得每一个子控制器具备push到其他控制器的能力
- 支持手势滑动切换子控制器。（等效于： - (void)tabBar:(UITabBar *)tabBar didSelectItem:(UITabBarItem *)item切换挂载的子控制器）
- 支持对某一特定的Tabbaritem向上凸起
- 支持自定义 UITabBar的高度
- Tabbaritem事件触发
  - 支持长按手势
    - 长按手势出菜单（高仿 Telegram）
  - 一些动画效果（比如：图片从小放大）
  - 点击震动
  - 点击声音
  - 支持lottie动画
  - 支持PPBadgeView
  - 支持强行自检跳转登录模块

21、iOS横竖屏切换回到顶部

相关文档：iOS 横竖屏切换
相关经验总结
- 横屏的时候，较之于竖屏，宽高会互换
- 系统通知UIDeviceOrientationDidChangeNotification也是需要服从界面UI的生命周期，否则取值不成功
- 其实系统有2个维度来读取是否横屏
  - 设备真实的方向（定义手机横卧为横屏）
  - 在AppDelegate里面，对- (UIInterfaceOrientationMask)application:(UIApplication *)application supportedInterfaceOrientationsForWindow:(UIWindow *)window进行了配置。因为是强制性的横屏呈现，所以优先级最高
- - (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions 的执行早于- (UIInterfaceOrientationMask)application:(UIApplication *)application supportedInterfaceOrientationsForWindow:(UIWindow *)window
- - (UIInterfaceOrientationMask)application:(UIApplication *)application supportedInterfaceOrientationsForWindow:(UIWindow *)window 会执行多次
- 如果配置了- (UIInterfaceOrientationMask)application:(UIApplication *)application supportedInterfaceOrientationsForWindow:(UIWindow *)window为横屏模式（默认为竖屏模式），但是终值为竖屏，则为错误读取
- 如果不配置- (UIInterfaceOrientationMask)application:(UIApplication *)application supportedInterfaceOrientationsForWindow:(UIWindow *)window为横屏模式（默认为竖屏模式），则以当前设备定位为准
- 对于页面，因为需要自适应调整，那么以靠后的生命周期读取值为准。比如在viewController里面-(void)viewDidAppear:(BOOL)animated的值为最终系统在综合各种因素后调整后的值。不要去关心中间值，以终值为准，这样方便定位我们从何时调用方法为有效调用
- 一般的架构是将UITabBarController及其子类作为根控制器，那么在呈现页面的时候，内部会去调整UI适配横竖屏。所以，UITabBarController及其子类以及挂载在上面的子控制器，均是需要在页面生命周期走完以后（即，-(void)viewDidAppear:(BOOL)animated以后）才能获取到正确的值
- 如果锚定UIDevice.currentDevice.orientation
  - UIDevice.currentDevice.orientation不是总是有效。在应用启动时，设备方向信息有时可能还没有完全初始化，这可能导致得到 UIDeviceOrientationUnknown
  - 不能配置 - (UIInterfaceOrientationMask)application:(UIApplication *)application supportedInterfaceOrientationsForWindow:(UIWindow *)window 因为竖屏检测会失败
  - 如果当前控制器为UITabBarController及其子类，-(void)viewDidAppear:(BOOL)animated生命周期以后（包含），方位数据才正常
  - 如果当前控制器为普通的UIViewController及其子类，则全部生命周期正常
- 如果锚定场景方向UIInterfaceOrientation，则需要在相关控制器的-(void)viewDidAppear:(BOOL)animated生命周期（包含）以后，才会获取到真正的UIInterfaceOrientation
- 如果锚定view.traitCollection.verticalSizeClass，则需要配置 - (UIInterfaceOrientationMask)application:(UIApplication *)application supportedInterfaceOrientationsForWindow:(UIWindow *)window 方可正常检测横竖屏

22、全局工具箱回到顶部

JobsAppTools （单例模式）
NSObject+AppTools （分类模式）

FileFolderHandleModel：文件夹操作

pod 'TXFileOperation' # 文件夹操作 https://github.com/xtzPioneer/TXFileOperation

#if __has_include(<TXFileOperation/TXFileOperation.h>)
#import <TXFileOperation/TXFileOperation.h>
#else
#import "TXFileOperation.h"
#endif

JobsLoadingImage：图片存取

23、`View` 和 `ViewController` 回到顶部

两者都是属于UI层
因为ViewController里面也包含了一部分数据层，不利于解耦。所以在Flutter中对UI层和数据层进行完全的剥离，即一个UI层带一个状态（State）
View层可以允许初始化方法带参（Frame）。而ViewController是控制器，通常铺满整个屏幕，所以不需要带参（Frame）初始化
两者的生命周期有很大区别。主要关系到UI布局和进数据
因为是继承，所以创建和销毁必须调用父类，否则异常。因为是ARC模式，所以-(void)dealloc方法不需要调用父类
一般View不会独立存在，会依附于ViewController。就要求ViewController需要观察是否正常销毁（即，退出页面是否执行-(void)dealloc方法）。如果对象没有成功销毁，会影响数据的写入，且下一次新建对象的时候，会优先执行上一个对象的-(void)dealloc方法

23.1、`ViewController`的生命周期

初始化方法-(instancetype)init：最早装载本页面数据的时机
- - (void)loadView：一般在此方法里面装载本页面的固定数据和刷新的数据（比如网络请求的数据）
- - (void)viewDidLoad：最晚装载本页面数据的时机。只要本页面没有被销毁，则此方法只执行一次
- -(void)viewWillAppear:(BOOL)animated：不建议在此生命周期方法及其以后装载本页面的一些固定的数据，刷新的数据（比如网络请求的数据）可以。只要出现本页面都会走一次
- -(void)viewDidAppear:(BOOL)animated：同上
- -(void)viewWillLayoutSubviews：页面UI进行调整的时候，都会执行（多次运行，直到UI布局）稳定。这里取值可能是过程值，有可能不准确
- -(void)viewDidLayoutSubviews ：同上
销毁流程
- -(void)viewWillDisappear:(BOOL)animated
- -(void)viewDidDisappear:(BOOL)animated
- -(void)dealloc

23.2、`View`的生命周期

初始化方法-(instancetype)init：最根本的初始化方法
- 初始化方法（带参Frame）-(instancetype)initWithFrame:(CGRect)frame
- - (void)layoutSubviews：只要布局UI，此方法会执行多次，直到UI布局稳定。这里取值可能是过程值，有可能不准确
- -(void)drawRect:(CGRect)rect：UI布局完成，进行绘制，只会执行一次
- - (void)layoutIfNeeded：如果利用Masonry进行布局，不可能马上得到Frame值。但是如果需要马上得到Frame值，就需要在最顶层的父View上执行layoutIfNeeded，在子View上执行得到的值为过程值，可能不准确。

销毁流程

如果当前View是单例模式，则需要

static JobsMenuView *JobsMenuViewInstance = nil;
static dispatch_once_t JobsMenuViewOnceToken;
+ (void)destroyInstance {
    JobsMenuViewOnceToken = 0;
    JobsMenuViewInstance = nil;
}

```
-(void)dealloc
```

24、AppDelegate 和 SceneDelegate 回到顶部

在iOS 13及更高版本中，Apple引入了多窗口支持，这意味着一个应用程序可以拥有多个场景（Scene），每个场景都有自己的生命周期和界面
这种多场景架构允许应用程序支持多窗口环境，特别是在iPad上，每个窗口可以有自己独立的生命周期和界面
一个iOS应用程序App的生命周期里面，只有一个AppDelegate实例存在，但是可能有多个SceneDelegate实例存在
- AppDelegate：应用程序的委托对象。整个应用程序在其生命周期中只有一个AppDelegate实例，负责处理应用程序级别的事件，例如应用程序的启动、终止、后台和前台切换等
- SceneDelegate：场景的委托对象。每个场景都有一个SceneDelegate实例，负责处理该场景级别的事件，例如场景的连接、断开、后台和前台切换等。在多窗口应用程序中，可能有多个SceneDelegate实例，每个实例对应一个场景

故，AppDelegate 可以设计成为单例

static AppDelegate *AppDelegateInstance = nil;
static dispatch_once_t AppDelegateOnceToken;
+(instancetype)sharedManager{
    dispatch_once(&AppDelegateOnceToken, ^{
        AppDelegateInstance = [super allocWithZone:NULL].init;
    });return AppDelegateInstance;
}
/// 单例的销毁
+(void)destroyInstance{
    AppDelegateOnceToken = 0;
    AppDelegateInstance = nil;
}
/// 防止外部使用 alloc/init 等创建新实例
+(instancetype)allocWithZone:(struct _NSZone *)zone{
    dispatch_once(&AppDelegateOnceToken, ^{
        AppDelegateInstance = [super allocWithZone:zone];
    });return AppDelegateInstance;
}

-(instancetype)copyWithZone:(NSZone *)zone{
    return self;
}

-(instancetype)mutableCopyWithZone:(NSZone *)zone{
    return self;
}

-(instancetype)init{
    if (self = [super init]) {

    }return self;
}

关于 **UIWindow ***
- 每个SceneDelegate实例都有自己的UIWindow，而不再是通过AppDelegate共享一个单独的UIWindow实例
- 即便是单场景App， SceneDelegate和 AppDelegate都有各自的UIWindow
- AppDelegate中的window属性在多场景应用中实际上不再被使用。这是为了向后兼容一些现有代码，但在多场景环境下，AppDelegate不会处理任何具体的窗口
- 在多场景架构下，SceneDelegate中的window是实际显示和管理UI的窗口，而AppDelegate中的window只是为了兼容老的单窗口应用

获取 AppDelegate

UIApplication.sharedApplication.delegate;

```
AppDelegate.sharedManager;
```

获取 SceneDelegate

if (@available(iOS 13.0, *)) {
	sceneDelegate = UIApplication.sharedApplication.connectedScenes.allObjects.firstObject.delegate;
}

26、`UIScrollView` 的滚动生命周期回到顶部

有2种方式驱动滚动效果

用户手动拖拽（拖拽过程的执行生命周期，由上至下。只会执行一次）

-(void)scrollViewWillBeginDragging:(UIScrollView *)scrollView;

-(void)scrollViewWillEndDragging:(UIScrollView *)scrollView 
                    withVelocity:(CGPoint)velocity
             targetContentOffset:(inout CGPoint *)targetContentOffset

-(void)scrollViewDidEndDragging:(UIScrollView *)scrollView
                 willDecelerate:(BOOL)decelerate

代码事件触发，改变UIScrollView.contentOffset

- (void)scrollViewDidScroll:(UIScrollView *)scrollView
- 不管是哪种方式驱动的滚动效果，最终都会汇集到这个方法里面
- 只要在滚动，这个方法一定会重复多次的调用
- 如果开启了分页滚动，即：UIScrollView.pagingEnabled = YES;。如果scrollView.contentOffset.x为负，最后在这个方法里面会被调整为0
- 因为这个方法会被反复调用多次，所以一般的逻辑处理，不建议在这里进行处理

25、对象间传值比较（通知/Block/协议）回到顶部

25.1、正向传值一般是通过初始化方法、属性等手段正向传入

25.2、一般重点关注对象的反向传值

通知
- 万能的上帝模式。但不建议过分的使用
- 有一定的系统开销，在最开始的iOS版本里面，通知的使用是有上限的。后期版本可以无限制的使用
- 如果对象释放的时候，不手动对其通知进行释放，可能会造成对象内存的溢出。所以，在iOS7以后，即便不写移除通知，系统帮我们解决
Block
- C语言底层的API，执行效率高。但是只能单项订阅，后出现的Block实现会覆盖掉之前的Block实现。即，如果需要多个地方接收到数据，则不行
- Block不一定开异步线程
- 可以实现类似于内部类的功能
- 如果数据的发出发和接收方之间存在若干对象，需要层层反向传值，比较冗余
- 依附于实例变量，需要关注循环引用的问题
协议
- 协议也可以提取公共的头文件，作为一个规范，而广泛遵守
- 引申出一个中间对象：代理（Delegate）。对代理检测和回调的封装
  - ```
  /// 代理用weak修饰，因为要调用NSObject层分类封装的方法，所以不能是id类型
  @property(nonatomic,weak)NSObject <MianTableViewCellDelegate>*delegate;
```
- @implementation NSObject (Extras)
```
  @jobs_weakify(self)
  self.delegate.jobsDelegate(@"mianTableViewCellScrollerDid:",^(){
  		@jobs_strongify(self)
      [self.delegate mianTableViewCellScrollerDid:scrollView];
  });
```
- 依附于实例变量。协议同样存在循环引用的问题
- 可以多点订阅，解决Block的痛点
- 容易造成代码割裂。如果修改协议方法的定义，对应的协议方法的实现不会有警告或者报错，会降格为普通方法，会造成代码业务逻辑的变更

25.3、总结

一般建议系统级别的，使用通知。例如：检测键盘、横竖屏...
对象间传值一般的业务场景是：需要传值的对象之间至多有一个中间对象。此时建议用Block
如果需要涉及到多点订阅，那么使用通知或者协议

26、数据解析回到顶部

26.1、对`json`数据的解析

对待data是数组

NSMutableArray <VideoTagModel *>*tags = [VideoTagModel mj_objectArrayWithKeyValuesArray:data];

对待data是字典

DDMyVipModel *myVipModel = [DDMyVipModel mj_objectWithKeyValues:data];

二次封装

@implementation NSObject (Data)
#pragma mark —— 关于数据（MJExtension）解析
/// 对待输入参数是含字典的数组
+(JobsReturnArrByArrBlock)byDataArr{
    @jobs_weakify(self)
    return ^__kindof NSArray *_Nullable(__kindof NSArray <NSDictionary *>*_Nullable data){
        @jobs_strongify(self)
        return [self.class mj_objectArrayWithKeyValuesArray:data];
    };
}
/// 对待输入参数是字典
+(JobsReturnIDByDicBlock)byDataDic{
    @jobs_weakify(self)
    return ^id _Nullable(__kindof NSDictionary *_Nullable data){
        @jobs_strongify(self)
        return [self.class mj_objectWithKeyValues:data];
    };
}
/// 万能解析
+(JobsReturnIDByIDBlock)byData{
    @jobs_weakify(self)
    return ^id _Nullable(id _Nullable data){
        @jobs_strongify(self)
        if(KindOfDicCls(data)) return [self.class mj_objectWithKeyValues:data];
        if(KindOfArrCls(data)) return [self.class mj_objectArrayWithKeyValuesArray:data];
        return nil;
    };
}

@end

字段替换：接口返回字段id和OC关键字id重合冲突，这里用jj替换id

+ (NSDictionary *)mj_replacedKeyFromPropertyName {
    return @{
        @"jj" : @"id"
    };
}

字段映射

**- (id)mj_newValueFromOldValue:(id)oldValue property:(MJProperty *)property **解析 JSON 数据时，对模型属性的值进行自定义处理。

可以通过重写这个方法，来实现对某些属性的特殊处理，比如数据转换或默认值设置

// 重写这个方法进行自定义数据处理
- (id)mj_newValueFromOldValue:(id)oldValue 
                     property:(MJProperty *)property {
    if ([property.name isEqualToString:@"age"]) {
        NSInteger age = [oldValue integerValue];
        if (age < 0) {
            return @(0); // 如果 age 小于 0，返回 0
        }
    } return oldValue;// 默认返回旧值
}

+ (NSDictionary *)mj_objectClassInArray 解析模型里面的数组

@property(nonatomic,strong)NSArray<FMGameListModel *> *gameList; 

// 告诉 MJExtension "gameList" 是一个 FMGameListModel 数组
+ (NSDictionary *)mj_objectClassInArray {
    return @{
        @"gameList" : FMGameListModel.class
    };
}

26.2、对图片URL数据的解析（对`SDWebImage`的二次封装）

pod 'SDWebImage' # https://github.com/SDWebImage/SDWebImage YES_SMP

#if __has_include(<SDWebImage/SDWebImage.h>)
#import <SDWebImage/SDWebImage.h>
#else
#import "SDWebImage.h"
#endif

@interface UIImageView (SDWebImage)

self.bgImageView
    .imageURL(model.url)
    .placeholderImage(model.bgImage)
    .options(SDWebImageRefreshCached)/// 强制刷新缓存
    .completed(^(UIImage * _Nullable image,
                 NSError * _Nullable error,
                 SDImageCacheType cacheType,
                 NSURL * _Nullable imageURL) {
        if (error) {
            NSLog(@"图片加载失败: %@-%@", error,imageURL);
        } else {
            NSLog(@"图片加载成功");
        }
    }).load();

@interface UIButton (SDWebImage）

 self.headBtn.imageURL(self.BaseUrl.add(model.iosImage).jobsUrl)
         .placeholderImage(model.image)
         .options(SDWebImageRefreshCached)/// 强制刷新缓存
         .completed(^(UIImage * _Nullable image,
                      NSError * _Nullable error,
                      SDImageCacheType cacheType,
                      NSURL * _Nullable imageURL) {
             if (error) {
                 NSLog(@"图片加载失败: %@-%@", error,imageURL);
             } else {
                 NSLog(@"图片加载成功");
             }
         }).normalLoad();

self.headBtn.imageURL(self.BaseUrl.add(self.loginModel.avatar).jobsUrl)
        .placeholderImage(self.loginModel.userDefaultHeadImage)
        .options(SDWebImageRefreshCached)/// 强制刷新缓存
        .completed(^(UIImage * _Nullable image,
                     NSError * _Nullable error,
                     SDImageCacheType cacheType,
                     NSURL * _Nullable imageURL) {
            if (error) {
                NSLog(@"图片加载失败: %@-%@", error,imageURL);
            } else {
                NSLog(@"图片加载成功");
            }
        }).bgNormalLoad();

27、竖形菜单方案回到顶部

27.1、左边的目录是UITableView，右边的内容是UIView

JobsMenuView

整体是一个大View
左侧菜单标题是**UIButton**

右侧的菜单内容是**UIScrollView**

@property(nonatomic,strong)JobsMenuView *menuView;

-(JobsMenuView *)menuView{
    if(!_menuView){
        _menuView = JobsMenuView.new;
//        _menuView.backgroundColor = JobsPurpleColor;
        [self.view addSubview:_menuView];
        _menuView.frame = CGRectMake(JobsWidth(59),
                                     0,
                                     [JobsMenuView viewSizeWithModel:nil].width,
                                     [JobsMenuView viewSizeWithModel:nil].height
                                     );
//        [_menuView mas_makeConstraints:^(MASConstraintMaker *make) {
//            make.size.mas_equalTo([_menuView viewSizeWithModel:nil]);
//            make.centerY.equalTo(self.view);
//            make.left.equalTo(self.view);
//        }];
//        _menuView.jobsRichElementsInViewWithModel(nil);
//        @jobs_weakify(self)
//        [_menuView actionObjectBlock:^(id  _Nullable x) {
//            @jobs_strongify(self)
//            if (self.objectBlock) self.objectBlock(x);
//        }];
    }return _menuView;
}

 - (void)viewDidLoad {
     [super viewDidLoad];
     self.setGKNav(nil);
     self.setGKNavBackBtn(nil);
 
     self.menuView.resetOriginY([TopBar viewSizeWithModel:nil].height);
     self.menuView.linkageMenuViewConfig.MENU_WIDTH = JobsWidth(139);
     self.menuView.alpha = JobsAppTool.currentInterfaceOrientationMask == UIInterfaceOrientationMaskLandscape;
//     self.menuView.alpha = JobsAppTool.jobsDeviceOrientation == DeviceOrientationLandscape;
     [self configMenuView];
 }
 
 -(void)configMenuView{
     self.menuView.titleMutArr = self.titleMutArr;
     self.menuView.subViewMutArr = self.subViewMutArr;
     self.menuView.normal_titleBgImageMutArr = self.normal_titleBgImageMutArr;
     self.menuView.select_titleBgImageMutArr = self.select_titleBgImageMutArr;
     self.menuView.jobsRichElementsInViewWithModel(nil);
     @jobs_weakify(self)
     [self.menuView actionObjectBlock:^(id _Nullable x) {
         @jobs_strongify(self)
         if([x isKindOfClass:UIButton.class]){
             UIButton *btn = (UIButton *)x;
             if([btn.titleForConfigurationAttributed isEqualToString:JobsInternationalization(@"TOP GAMES")]){
                 self.bgImageView.image = JobsIMG(@"TOP GAMES");
                 self.topImageView.image = JobsIMG(@"Top_Games");
             }
             
             if([btn.titleForConfigurationAttributed isEqualToString:JobsInternationalization(@"SLOT GAMES")]){
                 self.bgImageView.image = JobsIMG(@"SLOT GAMES");
                 self.topImageView.image = JobsIMG(@"Slot_Games");
             }
             
             if([btn.titleForConfigurationAttributed isEqualToString:JobsInternationalization(@"LIVE CASINO")]){
                 self.bgImageView.image = JobsIMG(@"LIVE CASINO");
                 self.topImageView.image = JobsIMG(@"Live_Casino");
             }
             
             if([btn.titleForConfigurationAttributed isEqualToString:JobsInternationalization(@"TABLE GAMES")]){
                 self.bgImageView.image = JobsIMG(@"TABLE GAMES");
                 self.topImageView.image = JobsIMG(@"Table_Games");
             }
             
             if([btn.titleForConfigurationAttributed isEqualToString:JobsInternationalization(@"SPORTS")]){
                 self.bgImageView.image = JobsIMG(@"SPORTS");
                 self.topImageView.image = JobsIMG(@"Sports");
             }
             
             if([btn.titleForConfigurationAttributed isEqualToString:JobsInternationalization(@"FINSHING")]){
                 self.bgImageView.image = JobsIMG(@"FINSHING");
                 self.topImageView.image = JobsIMG(@"Fishing");
             }
         }
     }];
 }

JobsVerticalMenuVC@0 强烈推荐

右边点选进行切换的子View一定要继承自 JobsVerticalMenuSubView，否则点选的时候无法移除。

#import "BaseViewController.h"

#import "TopBar.h"
#import "JobsHotRecommendView.h"

#import "FMMenuTBVCell.h"

#import "TopGamesView.h" /// 一定要继承自 JobsVerticalMenuSubView。否则点选的时候无法移除
#import "SlotGamesView.h" /// 一定要继承自 JobsVerticalMenuSubView。否则点选的时候无法移除
#import "LiveCasinoView.h" /// 一定要继承自 JobsVerticalMenuSubView。否则点选的时候无法移除
#import "TableGamesView.h" /// 一定要继承自 JobsVerticalMenuSubView。否则点选的时候无法移除
#import "SportsView.h" /// 一定要继承自 JobsVerticalMenuSubView。否则点选的时候无法移除
#import "FishingView.h" /// 一定要继承自 JobsVerticalMenuSubView。否则点选的时候无法移除

NS_ASSUME_NONNULL_BEGIN

@interface IncentiveVC : BaseViewController
<
UITableViewDelegate,
UITableViewDataSource
>

@end

import "FMIncentiveVC.h"
#define MenuWidth JobsWidth(159)
@interface FMIncentiveVC ()
/// UI
@property(nonatomic,strong)UITableView *tableView; /// 左侧的标题
@property(nonatomic,strong)UIImageView *topImageView;
/// Data
@property(nonatomic,copy)NSMutableArray <UIViewModel *>*titleMutArr;
@property(nonatomic,copy)NSMutableArray <__kindof UIView *>*subViewMutArr;/// 右侧的视图数组
@property(nonatomic,copy)NSMutableArray <UIImage *>*normal_titleBgImageMutArr;
@property(nonatomic,copy)NSMutableArray <UIImage *>*normal_titleImageMutArr;
@property(nonatomic,copy)NSMutableArray <UIImage *>*select_titleBgImageMutArr;
@property(nonatomic,copy)NSMutableArray <UIImage *>*bgImageMutArr1; /// 底图
@property(nonatomic,copy)NSMutableArray <UIImage *>*bgImageMutArr2; /// 最上面的小图

@end

@implementation FMIncentiveVC

- (void)dealloc{
    NSLog(@"%@",JobsLocalFunc);
    JobsRemoveNotification(self);
}

- (instancetype)init{
    if (self = [super init]) {
        NSLog(@"");
    }return self;
}

-(void)loadView{
    [super loadView];
    
    if ([self.requestParams isKindOfClass:UIViewModel.class]) {
        self.viewModel = (UIViewModel *)self.requestParams;
    }
    self.setupNavigationBarHidden = YES;
    self.viewModel.backBtnTitleModel.text = JobsInternationalization(@"INCENTIVE");
    self.viewModel.textModel.textCor = JobsWhiteColor;
    self.viewModel.textModel.text = JobsInternationalization(@"");
    self.viewModel.textModel.font = bayonRegular(JobsWidth(18));
    
    // 使用原则：底图有 + 底色有 = 优先使用底图数据
    // 以下2个属性的设置，涉及到的UI结论 请参阅父类（BaseViewController）的私有方法：-(void)setBackGround
    // self.viewModel.bgImage = JobsIMG(@"内部招聘导航栏背景图");
    self.viewModel.navBgCor = JobsClearColor.colorWithAlphaComponent(0);
//    self.viewModel.navBgImage = JobsIMG(@"导航栏左侧底图");
}

- (void)viewDidLoad {
    [super viewDidLoad];
    self.makeNavByAlpha(1);
    self.bgImageView.image = self.bgImageMutArr1[0];
    self.topImageView.alpha = 1;
    
    self.tableView.alpha = 1;
    
    self.displayView(self.subViewMutArr[0]);/// 显示指定的右侧视图
}

-(void)viewWillAppear:(BOOL)animated{
    [super viewWillAppear:animated];
    self.gk_navigationBar.hidden = YES;
}

-(void)viewDidAppear:(BOOL)animated{
    [super viewDidAppear:animated];
}

-(void)viewWillDisappear:(BOOL)animated{
    [super viewWillDisappear:animated];
}

- (void)viewDidDisappear:(BOOL)animated{
    [super viewDidDisappear:animated];
}
#pragma mark —— UITableViewDelegate, UITableViewDataSource
- (NSInteger)tableView:(__kindof UITableView *)tableView
 numberOfRowsInSection:(NSInteger)section {
    return self.titleMutArr.count;
}

- (__kindof UITableViewCell *)tableView:(__kindof UITableView *)tableView
                  cellForRowAtIndexPath:(NSIndexPath *)indexPath {
    FMMenuTBVCell *cell = FMMenuTBVCell.cellStyleDefaultWithTableView(tableView);
    cell.jobsRichElementsInCellWithModel(self.titleMutArr[indexPath.row]);
    return cell;
}

- (CGFloat)tableView:(__kindof UITableView *)tableView
heightForRowAtIndexPath:(NSIndexPath *)indexPath {
    return [FMMenuTBVCell cellHeightWithModel:nil];
}

- (void)tableView:(__kindof UITableView *)tableView
didSelectRowAtIndexPath:(NSIndexPath *)indexPath {
    self.displayView(self.subViewMutArr[indexPath.row]);
    FMMenuTBVCell *cell = [tableView cellForRowAtIndexPath:indexPath];

    for (int t = 0; t < tableView.visibleCells.count; t++) {
        FMMenuTBVCell *cell = tableView.visibleCells[t];
        UIViewModel *viewModel = self.titleMutArr[t];
        viewModel.isMark = NO;
        cell.jobsRichElementsInCellWithModel(viewModel);
    }
    
    self.bgImageView.image = self.bgImageMutArr1[indexPath.row];
    self.topImageView.image = self.bgImageMutArr2[indexPath.row];
    
    UIViewModel *viewModel = self.titleMutArr[indexPath.row];
    viewModel.isMark = YES;
    cell.jobsRichElementsInCellWithModel(viewModel);
    
//    self.refreshNewView(indexPath.row);
}
#pragma mark —— 一些私有方法
-(JobsReturnViewByClassBlock _Nonnull)makeSubViews{
    return ^UIView *_Nullable(Class _Nonnull cls){
        UIView *view = cls.new;
        view.frame = CGRectMake(MenuWidth,
                                0,
                                JobsRealWidth() - MenuWidth,
                                JobsRealHeight());
        view.jobsRichElementsInViewWithModel(nil);
        return view;
    };
}

-(jobsByNSIntegerBlock _Nonnull)refreshNewView{
    @jobs_weakify(self)
    return ^(NSInteger data){
        @jobs_strongify(self)
        JobsMenuBaseSubView *view = self.subViewMutArr[data];
        view.refreshNewView();
    };
}
/// 显示指定的右侧视图
- (jobsByViewBlock _Nonnull)displayView {
    @jobs_weakify(self)
    return ^(__kindof UIView *subview) {
        @jobs_strongify(self)
        /// 移除当前显示的视图
        for (UIView *subView in self.view.subviews) {
            if ([subView isKindOfClass:JobsVerticalMenuSubView.class]) {
                [subView removeFromSuperview];
            }
        }
        /// 添加新的视图
//        view.frame = CGRectMake(self.tableView.width,
//                                0,
//                                self.view.width - self.tableView.width,
//                                self.view.height);
        [self.view addSubview:subview];
        [subview mas_makeConstraints:^(MASConstraintMaker *make) {
            make.top.equalTo(self.tableView);
            make.bottom.equalTo(self.tableView);
            make.right.equalTo(self.view);
            make.width.mas_equalTo(JobsRealWidth() - MenuWidth);
        }];
        [self.view layoutIfNeeded];
    };
}
#pragma mark —— lazyLoad
-(UITableView *)tableView{
    if (!_tableView){
        _tableView = UITableView.initWithStylePlain;
        _tableView.backgroundColor = JobsClearColor.colorWithAlphaComponent(0);
        _tableView.dataLink(self);
        _tableView.showsVerticalScrollIndicator = NO;
        _tableView.separatorStyle = UITableViewCellSeparatorStyleNone;
        [self.view addSubview:_tableView];
        [_tableView mas_makeConstraints:^(MASConstraintMaker *make) {
            make.left.equalTo(self.view);
            make.top.equalTo(self.navBar.mas_bottom);
            make.bottom.equalTo(self.view);
            make.width.mas_equalTo(MenuWidth);
        }];
    }return _tableView;
}

-(UIImageView *)topImageView{
    if(!_topImageView){
        _topImageView = UIImageView.new;
        _topImageView.image = self.bgImageMutArr2[0];
        [self.bgImageView addSubview:_topImageView];
        [_topImageView mas_makeConstraints:^(MASConstraintMaker *make) {
            make.top.equalTo(self.view);
            make.centerX.equalTo(self.view);
            make.size.mas_equalTo(CGSizeMake(JobsWidth(182), JobsWidth(65)));
        }];
    }return _topImageView;
}

- (NSMutableArray<UIViewModel *> *)titleMutArr {
    if (!_titleMutArr) {
        /// 最初默认的数据
        _titleMutArr = jobsMakeMutArr(^(NSMutableArray * _Nullable data) {
            data.add(jobsMakeViewModel(^(__kindof UIViewModel * _Nullable viewModel) {
                viewModel.textModel.text = JobsInternationalization(@"ALL");
                viewModel.textModel.textCor = HEXCOLOR(0xB0B0B0);
                viewModel.image = self.normal_titleImageMutArr[0];
                viewModel.bgSelectedImage = self.select_titleBgImageMutArr[0];
                viewModel.isMark = YES;
            }));
            
            data.add(jobsMakeViewModel(^(__kindof UIViewModel * _Nullable viewModel) {
                viewModel.textModel.text = JobsInternationalization(@"SLOT GAMES");
                viewModel.textModel.textCor = HEXCOLOR(0xB0B0B0);
                viewModel.image = self.normal_titleImageMutArr[1];
                viewModel.bgSelectedImage = self.select_titleBgImageMutArr[1];
            }));

            data.add(jobsMakeViewModel(^(__kindof UIViewModel * _Nullable viewModel) {
                viewModel.textModel.text = JobsInternationalization(@"LIVE CASINO");
                viewModel.textModel.textCor = HEXCOLOR(0xB0B0B0);
                viewModel.image = self.normal_titleImageMutArr[2];
                viewModel.bgSelectedImage = self.select_titleBgImageMutArr[2];
            }));

            data.add(jobsMakeViewModel(^(__kindof UIViewModel * _Nullable viewModel) {
                viewModel.textModel.text = JobsInternationalization(@"SPORTS");
                viewModel.textModel.textCor = HEXCOLOR(0xB0B0B0);
                viewModel.image = self.normal_titleImageMutArr[3];
                viewModel.bgSelectedImage = self.select_titleBgImageMutArr[3];
            }));
            
            data.add(jobsMakeViewModel(^(__kindof UIViewModel * _Nullable viewModel) {
                viewModel.textModel.text = JobsInternationalization(@"OTHERS");
                viewModel.textModel.textCor = HEXCOLOR(0xB0B0B0);
                viewModel.image = self.normal_titleImageMutArr[4];
                viewModel.bgSelectedImage = self.select_titleBgImageMutArr[4];
            }));
        });
    }return _titleMutArr;
}

-(NSMutableArray<__kindof UIView *> *)subViewMutArr{
    if(!_subViewMutArr){
        @jobs_weakify(self)
        _subViewMutArr = jobsMakeMutArr(^(NSMutableArray * _Nullable data) {
            @jobs_strongify(self)
            data.add(self.makeSubViews(FMIncentiveAllView.class));
            data.add(self.makeSubViews(FMIncentiveSlotGamesView.class));
            data.add(self.makeSubViews(FMIncentiveLiveCasinoView.class));
            data.add(self.makeSubViews(FMIncentiveSportsView.class));
            data.add(self.makeSubViews(FMIncentiveOthersView.class));
        });
    }return _subViewMutArr;
}

-(NSMutableArray<UIImage *> *)normal_titleBgImageMutArr{
    if(!_normal_titleBgImageMutArr){
        _normal_titleBgImageMutArr = jobsMakeMutArr(^(NSMutableArray * _Nullable data) {
            data.add(JobsIMG(@"Top_Games_menu_未点击"));
            data.add(JobsIMG(@"Slot_Games_menu_未点击"));
            data.add(JobsIMG(@"Live_Casino_menu_未点击"));
            data.add(JobsIMG(@"Table_Games_menu_未点击"));
            data.add(JobsIMG(@"Sport_Menu_未点击"));
//            data.add(JobsIMG(@"Fishing_menu_未点击"));
        });
    }return _normal_titleBgImageMutArr;
}

-(NSMutableArray<UIImage *> *)normal_titleImageMutArr{
    if(!_normal_titleImageMutArr){
        _normal_titleImageMutArr = jobsMakeMutArr(^(NSMutableArray * _Nullable data) {
            data.add(JobsIMG(@"Top_Games_小图标_未点击"));
            data.add(JobsIMG(@"Slot_Games_小图标_未点击"));
            data.add(JobsIMG(@"Live_Casino_小图标_未点击"));
            data.add(JobsIMG(@"Table_Games_小图标_未点击"));
            data.add(JobsIMG(@"Sport_小图标_未点击"));
//            data.add(JobsIMG(@"Fishing_小图标_未点击"));
        });
    }return _normal_titleImageMutArr;
}

-(NSMutableArray<UIImage *> *)select_titleBgImageMutArr{
    if(!_select_titleBgImageMutArr){
        _select_titleBgImageMutArr = jobsMakeMutArr(^(NSMutableArray * _Nullable data) {
            data.add(JobsIMG(@"Top_Games_menu_已点击"));
            data.add(JobsIMG(@"Slot_Games_menu_已点击"));
            data.add(JobsIMG(@"Live_Casino_menu_已点击"));
            data.add(JobsIMG(@"Table_Games_menu_已点击"));
            data.add(JobsIMG(@"Sport_Menu_已点击"));
//            data.add(JobsIMG(@"Fishing_menu_已点击"));
        });
    }return _select_titleBgImageMutArr;
}
/// 底图
-(NSMutableArray<UIImage *> *)bgImageMutArr1{
    if(!_bgImageMutArr1){
        _bgImageMutArr1 = jobsMakeMutArr(^(NSMutableArray * _Nullable data) {
            data.add(JobsIMG(@"TOP GAMES"));
            data.add(JobsIMG(@"SLOT GAMES"));
            data.add(JobsIMG(@"LIVE CASINO"));
            data.add(JobsIMG(@"TABLE GAMES"));
            data.add(JobsIMG(@"SPORTS"));
//            data.add(JobsIMG(@"FINSHING"));
        });
    }return _bgImageMutArr1;
}
/// 最上面的小图
-(NSMutableArray<UIImage *> *)bgImageMutArr2{
    if(!_bgImageMutArr2){
        _bgImageMutArr2 = jobsMakeMutArr(^(NSMutableArray * _Nullable data) {
            data.add(JobsIMG(@"Top_Games"));
            data.add(JobsIMG(@"Slot_Games"));
            data.add(JobsIMG(@"Live_Casino"));
            data.add(JobsIMG(@"Table_Games"));
            data.add(JobsIMG(@"Sports"));
//            data.add(JobsIMG(@"Fishing"));
        });
    }return _bgImageMutArr2;
}
@synthesize backBtnModel = _backBtnModel;
-(UIButtonModel *)backBtnModel{
    if(!_backBtnModel){
        _backBtnModel = UIButtonModel.new;
//        _backBtnModel.backgroundImage = JobsIMG(@"返回");
//        _backBtnModel.selected_backgroundImage = JobsIMG(@"返回");
        _backBtnModel.normalImage = JobsIMG(@"返回");
        _backBtnModel.highlightImage = JobsIMG(@"返回");
        _backBtnModel.baseBackgroundColor = JobsClearColor.colorWithAlphaComponent(0);
        _backBtnModel.title = self.viewModel.backBtnTitleModel.text;
        _backBtnModel.titleFont = bayonRegular(JobsWidth(18));
        _backBtnModel.titleCor = JobsWhiteColor;
        _backBtnModel.selected_titleCor = JobsWhiteColor;
        _backBtnModel.roundingCorners = UIRectCornerAllCorners;
        _backBtnModel.imagePlacement = NSDirectionalRectEdgeLeading;
        _backBtnModel.imagePadding = JobsWidth(5);
        @jobs_weakify(self)
        _backBtnModel.longPressGestureEventBlock = ^id(id _Nullable weakSelf,
                                                       id _Nullable arg) {
            NSLog(@"按钮的长按事件触发");
            return nil;
        };
        _backBtnModel.clickEventBlock = ^id(BaseButton *x){
            @jobs_strongify(self)
            if (self.objectBlock) self.objectBlock(x);
            self.jobsBackBtnClickEvent(x);
            return nil;
        };
    }return _backBtnModel;
}

@end

JobsVerticalMenuVC@2
- 左侧的菜单标题是**UITableView**
- 右侧的菜单内容是**UICollectionView**

27.2、左边的目录是UITableView，右边的内容是UIViewController

JobsVerticalMenuVC@1 强烈推荐
JXCategoryView的垂直表达（目前没有做到很好的支持，只能通过取巧）不推荐

28、Excel方案：JobsExcelView 回到顶部

框架介绍

一横行用**UITableViewCell、每一个单元小格是UICollectionViewCell**
起始格子
- UI：JobsExcelView .titleL
- 数据：JobsExcelConfigureViewModel.contentStr_00
其他格子
- 左边第一竖排的标题：JobsExcelLeftListView，内含一个**UITableView，其中包含TableViewOneCell**
- 顶部第一横行的标题：JobsExcelTopHeadView，内含一个**UICollectionView，其中包含JobsTopViewItem**
- （中部的）内容数据：JobsExcelContentView，内含一个**UITableView，其中包含MainTableViewCell**
  - MainTableViewCell内含一个UICollectionView，其中包含MainTableViewCellItem
数据源
- Excel表格的总数据源：JobsExcelConfigureViewModel
- 对单个的小格子的数据源用：UITextModel
- 如果要设置Excel表的宽高，一定要在**JobsExcelView里面的viewSizeWithModel**方法里面进行设置

一些人性化进阶设置

MainTableViewCell

#pragma mark —— UIScrollViewDelegate
- (void)scrollViewDidScroll:(UIScrollView *)scrollView{
    NSLog(@"MainTableViewCell - scrollView.contentOffset.x = %f",scrollView.contentOffset.x);
    /// 防止在数据拉完的情况下，无意义的往右拉动👉🏻
    if (scrollView.contentOffset.x < 0) scrollView.contentOffset = CGPointMake(0, scrollView.contentOffset.y);
    if (scrollView.contentOffset.x >= 0) {
        /// 防止在数据拉完的情况下，无意义的往左拉动👈🏻
        CGFloat d = (self.viewModel_.rowNumber * self.viewModel_.itemW - self.viewModel_.XZExcelW) + self.viewModel_.itemW + self.viewModel_.scrollOffsetX;
        
        if(scrollView.contentOffset.x > d) scrollView.contentOffset = CGPointMake(d, scrollView.contentOffset.y);
        @jobs_weakify(self)
        self.delegate.jobsDelegate(@"mianTableViewCellScrollerDid:",^(){
            @jobs_strongify(self)
            [self.delegate mianTableViewCellScrollerDid:scrollView];
        });
    }
}

JobsExcelTopHeadView

#pragma mark —— UIScrollViewDelegate
- (void)scrollViewDidScroll:(UIScrollView *)scrollView{
    self.viewModel.jobsKVC(HorizontalScrollBegin,[NSValue valueWithCGPoint:scrollView.contentOffset]);
    NSLog(@"JobsExcelTopHeadView - scrollView.contentOffset.x = %f",scrollView.contentOffset.x)
    /// 防止在初始情况下，无意义的往右拉动👉🏻
    if (scrollView.contentOffset.x < 0) scrollView.contentOffset = CGPointMake(0, scrollView.contentOffset.y);
    /// 防止在初始情况下，无意义的往左拉动👈🏻
    CGFloat d = (self.viewModel.rowNumber * self.viewModel.itemW - self.viewModel.XZExcelW) + self.viewModel.itemW + self.viewModel.scrollOffsetX;
    if(scrollView.contentOffset.x > d) scrollView.contentOffset = CGPointMake(d, scrollView.contentOffset.y);
}

JobsExcelLeftListView

#pragma mark —— UIScrollViewDelegate
- (void)scrollViewDidScroll:(UIScrollView *)scrollView{
    NSLog(@"KKK3 = %f",scrollView.contentOffset.y);
    /// 防止在初始情况下，无意义的往下拉动👇🏻
    if (scrollView.contentOffset.y < 0) scrollView.contentOffset = CGPointMake(scrollView.contentOffset.x, 0);
    if (scrollView.contentOffset.y >= 0) {
        /// 防止在初始情况下，无意义的往上拉动👆🏻
        CGFloat d = ((self.viewModel.colNumber + 1) * self.viewModel.itemH - self.viewModel.XZExcelH) + self.viewModel.scrollOffsetY;
        if(scrollView.contentOffset.y > d) scrollView.contentOffset = CGPointMake(scrollView.contentOffset.x, d);
        if(scrollView.contentOffset.y <= d) self.viewModel.jobsKVC(VerticalScrollBegin,[NSValue valueWithCGPoint:scrollView.contentOffset]);
    }
}

完整调用

/// UI
@property(nonatomic,strong)JobsExcelView *excelView;
/// Data
@property(nonatomic,strong)JobsExcelConfigureViewModel *excelData;

-(JobsExcelView *)excelView{
    if(!_excelView){
        _excelView = JobsExcelView.new;
        _excelView.backgroundColor = JobsYellowColor;
        [self.view addSubview:_excelView];
        [_excelView mas_makeConstraints:^(MASConstraintMaker *make) {
            make.center.equalTo(self.view);
            make.size.mas_equalTo([JobsExcelView viewSizeWithModel:nil]);
        }];
        _excelView.jobsRichElementsInViewWithModel(self.excelData);
    }return _excelView;
}

-(JobsExcelConfigureViewModel *)excelData{
    if(!_excelData){
        _excelData = JobsExcelConfigureViewModel.new;
        _excelData.XZExcelH = [JobsExcelView viewSizeWithModel:nil].height;
        _excelData.XZExcelW = [JobsExcelView viewSizeWithModel:nil].width;
        
        _excelData.topHeaderTitles.add(JobsInternationalization(@"Order Time"));
        _excelData.topHeaderTitles.add(JobsInternationalization(@"Order No."));
        _excelData.topHeaderTitles.add(JobsInternationalization(@"Transaction Type"));
        _excelData.topHeaderTitles.add(JobsInternationalization(@"Amount"));
        _excelData.topHeaderTitles.add(JobsInternationalization(@"Method"));
        _excelData.topHeaderTitles.add(JobsInternationalization(@"Status"));
        
        _excelData.configureData();
    }return _excelData;
}

29、雪花算法（Snowflake ID或Snowflake Algorithm）回到顶部

29.1、什么是雪花算法

是一种分布式ID生成算法
由Twitter在2010年开源
主要用于在分布式系统中生成唯一的、时间排序的ID
这种算法生成的ID是一个64位的整数，保证了全局唯一性和高性能，适用于分布式系统的需要

29.2、雪花算法的特点

唯一性：生成的每一个ID都是唯一的，没有重复。
时间有序性：根据时间戳的增长，生成的ID也会按时间顺序递增，具有时间排序的特性。
高效率：生成ID的过程非常快，能够每秒生成数百万个ID。
分布式：支持在多个节点上并行生成ID，不会因为网络延迟等问题导致冲突。

29.3、雪花算法的ID结构

雪花算法生成的ID是一个64位的整数，具体结构如下：

| 1 bit (符号位) | 41 bits (时间戳) | 10 bits (机器ID) | 12 bits (序列号) |

1 bit 符号位：永远为0，不使用。
41 bits 时间戳：存储当前时间与一个初始时间的差值（通常是1970-01-01的时间戳起点），单位为毫秒。41位可以表示大约69年的时间。
10 bits 机器ID：用来区分不同的机器或节点。10位可以表示1024个不同的节点（5位工作节点ID + 5位数据中心ID）。
12 bits 序列号：在同一毫秒内生成多个ID的情况下，用于区分这些ID。12位可以表示4096个不同的序列号。

29.4、雪花算法的工作原理

时间戳生成：每次生成ID时获取当前时间戳，减去一个初始时间（纪元）得到相对时间戳。
机器ID：每个节点有唯一的机器ID，通过配置或计算获得。
序列号：在同一毫秒内生成多个ID时，序列号递增，最多支持4096个序列号；当序列号用尽时，等待下一毫秒再生成ID。
组合ID：将时间戳、机器ID和序列号组合成一个64位的整数，形成唯一ID。

29.5、雪花算法的评价

高效性：在本地内存中生成ID，不需要数据库等集中式服务的支持。
可扩展性：支持多个节点并行生成ID，无需担心ID冲突。
稳定性：不受网络环境的影响，即使在网络分区的情况下，仍能生成唯一的ID。
时间依赖：依赖于机器的时间戳，如果服务器的时间不准确或者发生了时间回拨，可能导致生成的ID不唯一或重复。
配置复杂：需要配置和管理机器ID，确保每个节点的ID是唯一的。

29.6、雪花算法的使用场景

数据库主键ID生成
消息队列ID生成
分布式存储系统中的对象ID生成
OC方法签名
...

29.7、雪花算法的OC实现（及使用示例）

通过ChatGPT 翻译自 https://github.com/DamonHu/SnowflakeSwift

#import <Foundation/Foundation.h>
#include <unistd.h>

@interface JobsSnowflake : NSObject

-(instancetype _Nonnull)initWithPublishMillisecond:(uint64_t)publishMillisecond
                                             IDCID:(uint32_t)IDC
                                         machineID:(uint32_t)machine;
-(nullable NSNumber *)nextID;
-(uint64_t)timeWithID:(uint64_t)id;
-(uint32_t)IDCWithID:(uint64_t)id;
-(uint32_t)machineWithID:(uint64_t)id;

@end

#import "JobsSnowflake.h"

static const uint32_t kSymbolBits = 1;
static const uint32_t kTimeBits = 41;
static const uint32_t kIDCBits = 5;
static const uint32_t kMachineBits = 5;
static const uint32_t kSequenceBits = 12;

@interface JobsSnowflake ()

@property(nonatomic,assign)uint32_t machine;
@property(nonatomic,assign)uint32_t IDC;
@property(nonatomic,assign)uint32_t sequence;
@property(nonatomic,assign)uint64_t publishMillisecond;
@property(nonatomic,assign)uint64_t lastGeneralMillisecond;

@end

@implementation JobsSnowflake
/// 初始化方法
/// - Parameters:
///   - publishMillisecond: 表示雪花算法开始生成 ID 的时间戳（以毫秒为单位）。这是生成 ID 时使用的基准时间。此参数设置生成雪花 ID 的起始时间点。例如，如果你希望雪花 ID 从某个特定的日期和时间开始生成，你需要提供该时刻的时间戳。
///   - IDC: 表示 IDC（数据中心）的标识符。用于唯一标识运行雪花算法的特定数据中心或集群。此参数帮助标识哪个数据中心或集群生成了某个雪花 ID。它允许你在多个数据中心中扩展 ID 生成而不会发生冲突。IDC 的值必须在算法配置允许的范围内（由 kIDCBits 定义）。
///   - machine: 表示数据中心内的机器或服务器的标识符。用于唯一标识生成雪花 ID 的特定机器或服务器。此参数帮助区分同一数据中心内不同机器生成的 ID。即使多台机器在生成 ID，每台机器生成的 ID 也将保持唯一。机器 ID 的值必须在算法配置允许的范围内（由 kMachineBits 定义）。
-(instancetype _Nonnull)initWithPublishMillisecond:(uint64_t)publishMillisecond
                                             IDCID:(uint32_t)IDC
                                         machineID:(uint32_t)machine{
    if (self = [super init]) {
        NSAssert(publishMillisecond <= ((uint64_t)1 << kTimeBits), @"time is too big");
        NSAssert(IDC <= ((uint32_t)1 << kIDCBits), @"IDC id is too big");
        NSAssert(machine <= ((uint32_t)1 << kMachineBits), @"machine id is too big");
        
        self.publishMillisecond = publishMillisecond;
        self.lastGeneralMillisecond = publishMillisecond;
        self.IDC = IDC & ((1 << kIDCBits) - 1);
        self.machine = machine & ((1 << kMachineBits) - 1);
        self.sequence = 0;
    }return self;
}

-(nullable NSNumber *)nextID{
    uint64_t currentTime = (uint64_t)NSDate.date.timeIntervalSince1970 * 1000;
    if (self.lastGeneralMillisecond < currentTime) {
        self.lastGeneralMillisecond = currentTime;
        self.sequence = 0;
    } else if (self.lastGeneralMillisecond == currentTime) {
        self.sequence = (self.sequence + 1) & ((1 << kSequenceBits) - 1);
        if (self.sequence == 0) {
            usleep(1000);
            currentTime = (uint64_t)NSDate.date.timeIntervalSince1970 * 1000;
            self.lastGeneralMillisecond = currentTime;
        }
    } else {
        // Clock rollback, should handle according to business logic
        return nil;
    }
    
    uint64_t timeParameter = self.lastGeneralMillisecond - self.publishMillisecond;
    uint64_t timeOffset = kIDCBits + kMachineBits + kSequenceBits;
    
    uint64_t idcParameter = self.IDC;
    uint64_t idcOffset = kMachineBits + kSequenceBits;
    
    uint64_t machineParameter = self.machine;
    uint64_t machineOffset = kSequenceBits;
    
    uint64_t result = (timeParameter << timeOffset) | (idcParameter << idcOffset) | (machineParameter << machineOffset) | self.sequence;
    return @(result);  // Return as NSNumber
}

- (uint64_t)timeWithID:(uint64_t)id {
    uint64_t timeOffset = kIDCBits + kMachineBits + kSequenceBits;
    return (id >> timeOffset) + self.publishMillisecond;
}

- (uint32_t)IDCWithID:(uint64_t)id {
    uint64_t step1 = id << (kTimeBits + kSymbolBits);
    return (uint32_t)(step1 >> (kTimeBits + kMachineBits + kSequenceBits + kSymbolBits));
}

- (uint32_t)machineWithID:(uint64_t)id {
    uint64_t step1 = id << (kTimeBits + kIDCBits + kSymbolBits);
    return (uint32_t)(step1 >> (kIDCBits + kTimeBits + kSequenceBits + kSymbolBits));
}

@end

 // 使用示例
-(NSNumber *_Nonnull)makeSnowflake{
    JobsSnowflake *snowflake = [JobsSnowflake.alloc initWithPublishMillisecond:self.currentUnixTimeStampInMilliseconds
                                                                         IDCID:1
                                                                     machineID:1];
    NSNumber *snowflakeID = snowflake.nextID;
    if (snowflakeID){
        NSLog(@"Generated Snowflake ID: %@", snowflakeID);
    }else{
        NSLog(@"Failed to generate Snowflake ID.");
    }return snowflakeID;
}

30、数据的归档和解档回到顶部

30.1、数据的序列化

数据的序列化是指将数据结构或对象状态转换为一种可以存储或传输的格式的过程。
序列化后的数据可以保存在文件、内存、数据库中，或者通过网络进行传输。
当数据需要恢复成原来的数据结构或对象状态时，反序列化（即反序列化过程）就会将数据从序列化格式恢复为其原始状态。
序列化的必要性
- 持久化存储
- 网络传输
- 缓存
- 跨语言互操作性：不同编程语言之间的数据交换需要统一的格式。通过序列化，数据可以转换为一种标准化的格式（如 JSON、XML、Protocol Buffers 等），从而实现跨语言的互操作性
- 复制和传递对象

30.2、iOS.OC 的数据归档/解档

需要归档/解档的类必须遵守编码协议和解码协议

在需要归档/解档的类的实现加入：

#pragma mark —— NSSecureCoding
/**
 方法的目的是告诉系统该类是否支持安全编码（NSSecureCoding）。
 通常情况下，为了确保数据的安全性，特别是在跨应用程序或跨设备之间传输数据时，您应该将其设置为 YES。这样可以确保在归档和解档过程中，只有指定的类可以被解档，从而防止潜在的安全风险。
 */
+(BOOL)supportsSecureCoding{
    return YES;
}

实现编码协议

对每个属性进行单独的处理

@property(nonatomic,copy)NSString *accessToken;
@property(nonatomic,copy)NSString *expireTime;

/// 解档
- (nullable instancetype)initWithCoder:(NSCoder *)coder {
    if (self = [super init]) {
        _accessToken = [coder decodeObjectOfClass:NSString.class forKey:@"accessToken"];
        _expireTime = [coder decodeObjectOfClass:NSString.class forKey:@"expireTime"];
        // 解码更多属性
    }return self;
}
/// 归档
- (void)encodeWithCoder:(NSCoder *)coder {
    [coder encodeObject:self.accessToken forKey:@"accessToken"];
    [coder encodeObject:self.expireTime forKey:@"expireTime"];
    // 编码更多属性
}

如果不希望对每个属性进行单独的处理，可以用以下的方法。但是控制台会有警告⚠️出现

/// 解档
- (nullable instancetype)initWithCoder:(NSCoder *)decoder {
//    _img = [coder decodeObjectOfClass:UIImage.class forKey:@"img"];
    if (self = [super initWithCoder:decoder]) {
        
        NSMutableSet <Class>*allowedClasses = NSMutableSet.set;
        allowedClasses.add(self.class);
        allowedClasses.add(NSString.class);
        allowedClasses.add(NSNumber.class);
        allowedClasses.add(NSArray.class);
        allowedClasses.add(NSDictionary.class);
        allowedClasses.add(UIImage.class);
        
        for (NSString *key in printPropertyListByClass(self.class)) {
            if ([self respondsToSelector:NSSelectorFromString(key)]) {
                id value = [decoder decodeObjectOfClasses:allowedClasses forKey:key];
                if (value) self.jobsKVC(key,value);
            }
        }
    }return self;
}
/// 归档
-(void)encodeWithCoder:(NSCoder *)encoder{
    [super encodeWithCoder:encoder];
    // 获取对象的属性列表
    NSLog(@"printPropertyListByClass = %@",printPropertyListByClass(self.class));
    for (NSString *key in printPropertyListByClass(self.class)) {
        // 检查是否实现了协议中的属性对应的setter方法
        NSLog(@"key.jobsCapitalCaseString = %@",@"set".add(key.jobsCapitalCaseString).add(@":"));
        NSLog(@"key = %@",key);
        if ([self respondsToSelector:NSSelectorFromString(@"set".add(key.jobsCapitalCaseString).add(@":"))]) {
            id value = [self valueForKey:key];
            [encoder encodeObject:value forKey:key];
        }
    }
}

最外层调用归档

+(jobsByUserDefaultModelBlock)updateWithModel{
    return ^(UserDefaultModel *_Nonnull userDefaultModel) {
        if (isValue(userDefaultModel.key)) {
            if (userDefaultModel.obj && ![userDefaultModel.obj isKindOfClass:NSNull.class]) {
                // 步骤1: 将NSObject对象归档为二进制数据
                NSError *error = nil;
                NSData *archivedData = [NSKeyedArchiver archivedDataWithRootObject:userDefaultModel.obj
                                                             requiringSecureCoding:YES
                                                                             error:&error];
                if (error) {
                    NSLog(@"归档失败: %@", error.localizedDescription);
                } else {
                    // 步骤2: 将归档数据存储到NSUserDefaults
                    JobsSetUserDefaultKeyWithObject(userDefaultModel.key, archivedData);
                    JobsUserDefaultSynchronize;
                    NSLog(@"%@",NSString.userDefaultsDir);
                    return;
                }
            }
            
            if (userDefaultModel.booLValue) {
                JobsSetUserBoolKeyWithBool(userDefaultModel.key, userDefaultModel.booLValue);
                JobsUserDefaultSynchronize;
                NSLog(@"%@",NSString.userDefaultsDir);
                return;
            }
        }
    };
}

最外层调用解档。需要加入需要进行归档/解档的类。否则解档出来为nil

如果没有加入需要进行归档/解档的类，那么需要进行归档/解档的目标类只会执行-(void)encodeWithCoder:(NSCoder *)encoder而不会执行- (nullable instancetype)initWithCoder:(NSCoder *)decoder

-(JobsReturnIDByClsAndSaltStrBlock)readUserInfoByUserName{
    return ^id _Nullable(Class _Nonnull cls,NSString *_Nullable userName){
        NSData *archivedData = NSUserDefaults.readWithKey(userName);
        if(HDDeviceSystemVersion.floatValue < 12.0){
            SuppressWdeprecatedDeclarationsWarning(return [NSKeyedUnarchiver unarchiveObjectWithData:archivedData];);
        }else{
            NSError *error = nil;
            /// 如果 JobsUserModel 中包含更多自定义类型或者你需要解码其他基本类型（例如 NSArray 或 NSDictionary），需要将这些类也加入到 allowedClasses 集合中。
            /// 确保在解码所有需要的类时，将其包含在 allowedClasses 集合中以避免警告和潜在的解码失败。例如
            NSMutableSet *allowedClasses = NSMutableSet.set;
            allowedClasses.add(JobsUserModel.class);
            allowedClasses.add(NSString.class);
            allowedClasses.add(NSNumber.class);
            allowedClasses.add(NSArray.class);
            allowedClasses.add(NSDictionary.class);
            allowedClasses.add(UIImage.class);
            allowedClasses.add(NSArray.class);
            allowedClasses.add(cls);
            
            id userModel = [NSKeyedUnarchiver unarchivedObjectOfClasses:allowedClasses
                                                               fromData:archivedData
                                                                  error:&error];
            if (!userModel) {
                NSLog(@"解档失败: %@", error.localizedDescription);
            }return userModel;
        }
    };
}

31、容器类的二次封装使用回到顶部

数组

@implementation NSMutableArray (Extra)

/// 清除数组元素
-(jobsByVoidBlock _Nonnull)clean{
    @jobs_weakify(self)
    return ^(){
        @jobs_strongify(self)
        [self removeAllObjects];
    };
}
/// 元素包含
-(JobsReturnBOOLByIDBlock)containsObject{
    return ^BOOL((id _Nullable data)){
        return [self containsObject:data];
    };
}
/// 数组取值（无法关联数组的泛型）
-(JobsReturnIDByUIntegerBlock _Nonnull)objectAt{
    @jobs_weakify(self)
    return ^id _Nullable(NSUInteger data){
        @jobs_strongify(self)
        return [self objectAtIndex:data];
    };
}
/// 数组取下标
-(JobsReturnNSUIntegerByIDBlock)indexBy{
    @jobs_weakify(self)
    return ^NSUInteger(id _Nullable data){
        @jobs_strongify(self)
        return [self indexOfObject:data];
    };
}
/// 阻止向可变数组添加空元素
-(JobsReturnIDByIDBlock _Nonnull)add{
    @jobs_weakify(self)
    return ^id (id _Nullable data) {
        @jobs_strongify(self)
        if(data){
            [self addObject:data];/// 向数组加入nil会崩
        }else{
            NSLog(@"数组被添加了一个空元素");
        }return self;
    };
}
/// 向数组加入一个从来没有没有过的元素，以保证数组元素的单一性
-(JobsReturnIDByIDBlock _Nonnull)jobsAddSoleObject{
    @jobs_weakify(self)
    return ^id (id _Nullable data) {
        @jobs_strongify(self)
        if(data){
            if (![self containsObject:data]) {
                [self addObject:data];
            }
        }else{
            NSLog(@"数组被添加了一个空元素");
        }return self;
    };
}

/// 可变数组的方便调用
NS_INLINE __kindof NSArray *_Nonnull jobsMakeMutArr(jobsByMutableArrayBlock _Nonnull block){
    NSMutableArray *data = NSMutableArray.array;
    if (block) block(data);
    return data;
}

集合

@implementation NSMutableSet (Extra)

/// 阻止向可变集合添加空元素
-(JobsReturnIDByIDBlock _Nonnull)add{
    @jobs_weakify(self)
    return ^id (id _Nullable data) {
        @jobs_strongify(self)
        if(data){
            /// 向集合加入nil会崩
            [self addObject:data];
        }else{
            NSLog(@"集合被添加了一个空元素");
        }return self;
    };
}

/// 可变集合的方便调用
NS_INLINE __kindof NSSet *_Nonnull jobsMakeMutSet(jobsBySetBlock _Nonnull block){
    NSMutableSet *data = NSMutableSet.set;
    if (block) block(data);
    return mutableSet;
}

32、协议属性的使用

协议的属性值无法在控制台用po进行打印输出，只能通过NSLog。因为当本类的成员变量列表已经部署完毕了以后，再部署以runtime的形式部署分类的属性
同一属性，不要@dynamic和@synthesize，容易出现一些异常。（比如，@synthesize修饰的属性，无法覆盖本类的子类）
就近原则：本类直接定义的属性 > @synthesize > @dynamic

在分类里面实现协议属性需要涉及到关键字@dynamic

copy：Jobs_setAssociatedCOPY_NONATOMIC、Jobs_setAssociatedCOPY

#pragma mark —— @property(nonatomic,copy)jobsByIDBlock makeBlock;
JobsKey(_makeBlock)
@dynamic makeBlock;
-(jobsByIDBlock)makeBlock{
    return Jobs_getAssociatedObject(_makeBlock);
}

-(void)setMakeBlock:(jobsByIDBlock)makeBlock{
    Jobs_setAssociatedCOPY_NONATOMIC(_makeBlock, makeBlock)
}

retain：Jobs_setAssociatedRETAIN_NONATOMIC、Jobs_setAssociatedRETAIN

#pragma mark —— @property(nonatomic,strong,nullable)UIViewModel *viewModel;
JobsKey(_viewModel)
@dynamic viewModel;
-(UIViewModel *)viewModel{
    UIViewModel *VM = Jobs_getAssociatedObject(_viewModel);
    if(!VM){
        VM = UIViewModel.new;
        VM.textModel.textCor = HEXCOLOR(0x3D4A58);
        VM.textModel.font = UIFontWeightRegularSize(16);
        Jobs_setAssociatedRETAIN_NONATOMIC(_viewModel, VM);
    }return VM;
}

-(void)setViewModel:(UIViewModel *)viewModel{
    Jobs_setAssociatedRETAIN_NONATOMIC(_viewModel, viewModel)
}

对基本数据类型，需要封装成NSNumber对象再进行存储

#pragma mark —— @property(nonatomic,assign)NSUInteger minimumNumberOfTouches API_UNAVAILABLE(tvos);
JobsKey(_minimumNumberOfTouches)
@dynamic minimumNumberOfTouches;
-(NSUInteger)minimumNumberOfTouches{
    return [Jobs_getAssociatedObject(_minimumNumberOfTouches) unsignedIntegerValue];
}

-(void)setMinimumNumberOfTouches:(NSUInteger)minimumNumberOfTouches{
    Jobs_setAssociatedRETAIN_NONATOMIC(_minimumNumberOfTouches, @(minimumNumberOfTouches))
}

assign：Jobs_setAssociatedASSIGN

weak对象

#pragma mark —— <BaseViewControllerProtocol> @property(nonatomic,weak)UIViewController *fromVC;
JobsKey(_fromVC)
@dynamic fromVC;
-(UIViewController *)fromVC{
    return Jobs_getAssociatedObject(_fromVC);
}

-(void)setFromVC:(UIViewController *)fromVC{
    Jobs_setAssociatedASSIGN(_fromVC, fromVC)
}

在具体子类里面实现协议属性需要涉及到关键字@synthesize

@synthesize viewModel = _viewModel;
-(UIViewModel *)viewModel{
    if (!_viewModel) {
        _viewModel = UIViewModel.new;
        _viewModel.textModel.textCor = HEXCOLOR(0x3D4A58);
        _viewModel.textModel.font = UIFontWeightRegularSize(16);
    }return _viewModel;
}

33、Runtime 获取.m文件的属性（指针）

WMZBannerControl *bannerControl = _bannerView.getObjByName(@"bannerControl");

-(void)Test{
    Ivar ivar = class_getInstanceVariable([BRDatePickerView class], "_monthNames");//必须是下划线接属性
    NSArray *_monthNames = @[@"一月份", @"二月份", @"三月份", @"四月份", @"五月份", @"六月份", @"七月份", @"八月份", @"九月份", @"十月份", @"十一月份", @"十二月份"];
    object_setIvar(self.datePickerView, ivar, _monthNames);
}

也可以用KVC。比方说有一个变量叫aaa，然后我用变量 = [对象 valueForKey：@"aaa"]来取.顺序是这样的：
- 看是否有-aaa{}，如果有就调用
- 看是否有**_aaa**变量，如果有，直接取
- 看是否有aaa变量，如果有，直接取
- 看是否有**_isAaa**变量，如果有，直接取
- 看是否有isAaa变量，如果有，直接取
- 返回nil

34、其他回到顶部

属性化的block可以用assign修饰，但是最好用copy
不要在属性上加__block。转而是在这个对象上使用__block
属性化的NSString *可以用assign修饰，但是最好用copy

/// 获取 GKPhotoBrowser 类的 layoutSubviews 方法。
Method method = class_getInstanceMethod(GKPhotoBrowser.class, sel_registerName("layoutSubviews"));
/// 获取到的方法实现转换为一个函数指针 super_func，并指定了函数的参数类型为 (id, SEL)。
void (*super_func)(id,SEL) = (void *)method_getImplementation(method);
/// 检查 super_func 是否为非空，即是否成功获取到 layoutSubviews 方法的实现。
/// 如果 super_func 不为空，它执行 super_func 函数，传递 self 和 sel_registerName("layoutSubviews") 作为参数，从而调用了 GKPhotoBrowser 类的 layoutSubviews 方法。
if (super_func) super_func(self, sel_registerName("layoutSubviews"));

[super layoutSubviews];

根据后端接口文档返回的字段类型为 number，建议在 iOS 的模型中使用 NSNumber，而不是 NSString 。原因如下：
1. 兼容多种数字类型：NSNumber 是一个对象类，可以存储 int、float、double 等数值类型，非常适合处理后端返回的 number 字段。
2. 方便与数值类型转换：NSNumber 可以方便地与数值类型进行转换，比如 intValue、floatValue、doubleValue，而 NSString 则需要额外的解析和转换操作。
3. 避免解析问题：如果使用 NSString 存储数字类型字段，在解析时需要手动转换，这可能会引入额外的复杂性和潜在的错误。NSNumber 则直接支持数值类型，无需额外处理。

将视图至于最底层

[cell insertSubview:imageView atIndex:0];

iOS 父视图透明度影响到子视图

父视图的透明度会影响到其子视图。跟着一起变得半透明
```
self.view.backgroundColor = UIColor.redColor;
self.view.alpha = 0.5f;
```

避免以上的情况的写法

self.view.backgroundColor = [UIColor.redColor colorWithAlphaComponent:0.5f];

nil vs NULL
NSObject *object = nil; // object 是一个空指针，不指向任何对象。
```
* ```c
int *ptr = NULL; // ptr 是一个空指针，不指向任何内存地址。
```
+ (void)load会在类或分类被加载到内存时自动调用。即使这个类或分类没有被直接引用，只要它被编译进目标程序并被加载，它的 + (void)load 方法仍然会被调用。通常早于 main() 函数的执行。相比 + (void)load，+ (void)initialize 只有在类首次使用时才会被调用
泛型
- 协变（__covariant）：如果 B 是 A 的子类，那么 Container<B> 可以被当作 Container<A> 来使用。这意味着子类型可以赋值给父类型。
- 逆变（__contravariant）：与协变相反，如果 B 是 A 的子类，那么 Container<A> 可以被当作 Container<B> 来使用。父类型可以被赋值给子类型。
- __covariant 和 __contravariant 是用于泛型类型的修饰符，无法直接用于局部变量或非泛型方法。
- 正确的写法（不能在分类中使用）
```
@interface MyGenericDictionary<__covariant KeyType, __covariant ObjectType> : NSObject

@end
```
在函数内部修改外部的值
- 如果你希望在函数内部能够修改外部变量的值，你可以使用指针的指针（UIView ** ），传递变量的地址来改变原变量的值。
```
NS_INLINE void destroyView(__strong __kindof UIView * _Nonnull * _Nonnull view) {
    [*view removeFromSuperview];
    *view = nil;
}

destroyView(&view);
```
```
/// 在 Objective-C 中，无法直接通过函数参数隐式传递对象的地址。
/// 如果希望在函数调用时自动传递对象的地址，只能通过宏来实现。
#ifndef DestroyView
#define DestroyView(view) destroyView(&(view))
#endif /* DestroyView */
```
- "Passing address of non-local object to __ autoreleasing parameter for write-back"警告的原因是 Objective-C 对指针操作的内存管理有一套特殊的机制，特别是涉及 __autoreleasing、__strong 等修饰符时
- 当你传递一个对象的指针（比如 UIView）时，编译器可能会将这个指针的参数视为 __autoreleasing。而你试图传递一个本地对象的地址给__autoreleasing 参数时，就会触发这个警告。简而言之，Objective-C 认为这样操作可能会引发内存管理上的问题。
- 要解决这个问题，首先可以强制指定参数为__strong 以避免自动推导为 __autoreleasing

CGRect 可能因为浮点数的精度问题或隐式转换，导致某些底层操作触发异常。在设备屏幕渲染中，整数更符合逻辑像素值的要求，因此不会触发异常。

(lldb) po stringWidth
628.1015625 

layer.frame = CGRectMake(0, 0, stringWidth, self.frame.size.height); /// 崩溃
layer.frame = CGRectMake(0, 0, 628, self.frame.size.height);/// 不崩溃

四、架构相关回到顶部

1、不使用 Storyboard + 使用自定义的控制器（ViewController@1） + 不使用多场景

给AppDelegate.h添加属性，作为渲染的window

#import <UIKit/UIKit.h>
#import "ViewController@1.h"

@interface AppDelegate : UIResponder <UIApplicationDelegate>
@property (strong, nonatomic) UIWindow *window;
@end

AppDelegate.m

- (BOOL)application:(UIApplication *)application
didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
    self.window = [UIWindow.alloc initWithFrame:UIScreen.mainScreen.bounds];
    // 创建并设置初始视图控制器为登录界面
    self.window.rootViewController = ViewController_1.new;
    [self.window makeKeyAndVisible];
    self.window.backgroundColor = UIColor.cyanColor;
    NSLog(@"qwer");
    return YES;
}

删除以下AppDelegate里面对多场景的支持代码

#pragma mark - UISceneSession lifecycle
- (UISceneConfiguration *)application:(UIApplication *)application
configurationForConnectingSceneSession:(UISceneSession *)connectingSceneSession
                              options:(UISceneConnectionOptions *)options {
    // Called when a new scene session is being created.
    // Use this method to select a configuration to create the new scene with.
    return [[UISceneConfiguration alloc] initWithName:@"Default Configuration" sessionRole:connectingSceneSession.role];
}


- (void)application:(UIApplication *)application
didDiscardSceneSessions:(NSSet<UISceneSession *> *)sceneSessions {
    // Called when the user discards a scene session.
    // If any sessions were discarded while the application was not running, this will be called shortly after application:didFinishLaunchingWithOptions.
    // Use this method to release any resources that were specific to the discarded scenes, as they will not return.
}

删除Info.plist中，关于多场景的键值对

<key>UIApplicationSceneManifest</key>
<dict>
  <key>UIApplicationSupportsMultipleScenes</key>
  <false/>
  <key>UISceneConfigurations</key>
  <dict>
    <key>UIWindowSceneSessionRoleApplication</key>
    <array>
      <dict>
        <key>UISceneConfigurationName</key>
        <string>Default Configuration</string>
        <key>UISceneDelegateClassName</key>
        <string>SceneDelegate</string>
        <key>UISceneStoryboardFile</key>
        <string>Main</string>
      </dict>
    </array>
  </dict>
</dict>

删除新建工程默认生成的ViewController (或者不包含进工程目录，防止进入编译期)
删除SceneDelegate.h和 SceneDelegate.m (或者不包含进工程目录，防止进入编译期)
处理：Unknown class ViewController in Interface Builder file.

2、iOS新建应用使用多场景

TODO

五、代码讲解

1、`UIButton.UIButtonConfiguration` 回到顶部

点我了解详情

苹果在后续的Api中推出了UIButtonConfiguration 来设置UIButton，但是这个新Api会存在几大问题
- 大多数开发者对这个Api不熟悉
- 用了新Api以后，老的Api的一些调用方式可能不会起效果。如果还是按照以前的方式创建，你会发现UIButton不正常出现
- 大多数时候，我们会涉及到富文本。而富文本和普通的文本之间对于控件有优先级。富文本的优先级最高
- 因为要做兼容处理，但是UIButtonConfiguration 的设置环节非常繁琐
所以，为了应对以上的问题，可以使用快捷键（init.JobsBtn）调取代码块来设置 UIButton。快捷键调取代码块
- 得出的 UIButton 是没有约束的，需要自己在外界加
- 关注实现类：@implementation UIButton (UI)
@interface UIButtonModel : BaseModel<BaseButtonProtocol>
- 可以对单个的UIButton进行配置
- 可以批量对UIButton进行配置（自带数据源）

对以**UIButton**为基底，里面的子控件进行配置（在创建后立即调用）

BaseButtonProtocol.h

@protocol BaseButtonProtocol <NSObject>
@optional
/// 为了迎合点语法而故意把下列方法属性化
/// UIButton + UI
#pragma mark —— 配置信息
/// 关于系统对于按钮的配置信息
Prop_strong(nullable)UIButtonConfiguration *buttonConfiguration API_AVAILABLE(ios(15.0), tvos(15.0)) API_UNAVAILABLE(watchos) NS_SWIFT_UI_ACTOR;/// 来自新Api的配置文件。UIButtonConfiguration.filledButtonConfiguration;
Prop_strong(nullable)UIBackgroundConfiguration *backgroundConfiguration API_AVAILABLE(ios(14.0), tvos(14.0)) API_UNAVAILABLE(watchos) NS_SWIFT_UI_ACTOR;/// 自定义按钮背景的配置
Prop_assign()UIControlContentHorizontalAlignment contentHorizontalAlignment API_UNAVAILABLE(watchos); /// 针对内容的横向对齐方式
Prop_assign()UIControlContentVerticalAlignment contentVerticalAlignment API_UNAVAILABLE(watchos); /// 针对内容的竖向对齐方式
Prop_assign()NSDirectionalEdgeInsets contentInsets API_AVAILABLE(ios(11.0),tvos(11.0),watchos(4.0)); /// 定位内边距的方向。iOS 15以后 结合UIButtonConfiguration 以替换属性：UIEdgeInsets
Prop_assign()UIEdgeInsets contentEdgeInsets;/// iOS 15以前可以用
Prop_strong(nullable)UIColor *baseBackgroundColor;/// 背景颜色
/// 关于按钮的图文关系
Prop_assign()CGFloat imagePadding;/// 图像与标题之间的间距
Prop_assign()CGFloat titlePadding;/// 标题和副标题标签之间的距离
Prop_assign()NSDirectionalRectEdge imagePlacement;/// ❤️图片和文字的位置关系❤️
/// 一些自定义的配置信息
Prop_assign()UILabelShowingType titleShowingType;/// 主标题的显示方式
Prop_assign()UILabelShowingType subTitleShowingType;/// 副标题的显示方式
Prop_assign()BOOL jobsSelected; /// 避免与系统方法冲突
Prop_assign()BOOL jobsEnabled; /// 避免与系统方法冲突
Prop_assign()CGSize imageSize;
Prop_assign()CGFloat contentSpacing;
Prop_assign()CGFloat btnWidth; /// 预设值，父视图的宽度不能大于这个值
#pragma mark —— 普通文本
Prop_copy(nullable)NSString *title; /// 主标题
Prop_copy(nullable)NSString *subTitle API_AVAILABLE(ios(16.0)); ///（新Api才有的）副标题
/**
 在 iOS 16 中，UIButtonConfiguration 使用 titleTextAttributesTransformer 来调整按钮标题的字体和颜色
 但直接访问字体并不像从 titleLabel 那样简单
 */
/// 普通文本的字体
Prop_strong(nullable)UIFont *titleFont;
Prop_strong(nullable)UIFont *subTitleFont API_AVAILABLE(ios(16.0));
/// 普通文本的文字颜色
Prop_strong(nullable)UIColor *titleCor;/// 主标题文字颜色
Prop_strong(nullable)UIColor *subTitleCor;/// 副标题文字颜色
/// 普通文本的对齐方式
Prop_assign()NSTextAlignment titleAlignment;/// 针对文本的对齐方式 UIButton.titleLabel.titleAlignment【老Api】。也对应新Api里面的title的对齐方式
Prop_assign()NSTextAlignment subTitleAlignment;/// 也对应新Api里面的subTitle的对齐方式
Prop_assign()UIButtonConfigurationTitleAlignment buttonConfigurationTitleAlignment API_AVAILABLE(ios(15.0)) API_UNAVAILABLE(watchos);/// 针对文本的对齐方式 UIButtonConfiguration.titleAlignment 【新Api】
/// 普通文本的换行方式
Prop_assign()NSLineBreakMode titleLineBreakMode;/// 主标题换行模式
Prop_assign()NSLineBreakMode subtitleLineBreakMode;///（新Api才有的）副标题换行模式
#pragma mark —— 图片
Prop_strong(nullable)UIImage *backgroundImage;/// 背景图片
Prop_strong(nullable)UIImage *normalImage;/// 正常情况下的image
Prop_strong(nullable)UIImage *highlightImage;/// = selected_Image 高亮情况下的image
#pragma mark —— 富文本
Prop_strong(nullable)NSAttributedString *attributedTitle;/// 主标题的富文本（优先级高于普通文本）。设置富文本，请关注：#import "NSObject+RichText.h"
Prop_strong(nullable)NSAttributedString *selectedAttributedTitle;///（只限于老Api，新Api里面没有）UIControlStateSelected状态下的标题富文本。设置富文本，请关注：#import "NSObject+RichText.h"
Prop_strong(nullable)NSAttributedString *attributedSubTitle;///（新Api才有的）副标题的富文本（优先级高于普通文本）。设置富文本，请关注：#import "NSObject+RichText.h"
#pragma mark —— 对UIButton子控件的约束
/// ⚠️执行return的顺序依照下列👇🏻属性的排序⚠️
///【组 1】UIButton 单独自定义设置系统自带控件的Frame【形成Frame后直接return，避免被其他中间过程修改】❤️与组2、3属性互斥❤️
Prop_assign()CGRect textLabelFrame;
Prop_assign()CGRect subTextLabelFrame;
Prop_assign()CGRect imageViewFrame;
///【组 2】UIButton 单独自定义设置系统自带控件的Size【形成Frame后直接return，避免被其他中间过程修改】❤️与组1、3属性互斥❤️
Prop_assign()CGSize textLabelSize;
Prop_assign()CGFloat textLabelFrameResetX;
Prop_assign()CGFloat textLabelFrameResetY;

Prop_assign()CGSize subTextLabelSize;
Prop_assign()CGFloat subTextLabelFrameResetX;
Prop_assign()CGFloat subTextLabelFrameResetY;

Prop_assign()CGSize imageViewSize;
Prop_assign()CGFloat imageViewFrameResetX;
Prop_assign()CGFloat imageViewFrameResetY;
///【组 3】UIButton 单独自定义设置系统自带控件的长宽【形成Frame后直接return，避免被其他中间过程修改】❤️与组1、2属性互斥❤️
Prop_assign()CGFloat textLabelWidth;
Prop_assign()CGFloat subTextLabelWidth;
Prop_assign()CGFloat imageViewWidth;
Prop_assign()CGFloat textLabelHeight;
Prop_assign()CGFloat subTextLabelHeight;
Prop_assign()CGFloat imageViewHeight;
/// UIButton 单独自定义设置系统自带控件的偏移量 ❤️与其他组属性不互斥❤️
/// 关于 textLabel 的偏移
Prop_assign()CGFloat textLabelFrameOffsetX;
Prop_assign()CGFloat textLabelFrameOffsetY;
Prop_assign()CGFloat textLabelFrameOffsetWidth;
Prop_assign()CGFloat textLabelFrameOffsetHeight;
/// 关于 subTextLabel 的偏移
Prop_assign()CGFloat subTextLabelFrameOffsetX;
Prop_assign()CGFloat subTextLabelFrameOffsetY;
Prop_assign()CGFloat subTextLabelFrameOffsetWidth;
Prop_assign()CGFloat subTextLabelFrameOffsetHeight;
/// 关于 imageView 的偏移
Prop_assign()CGFloat imageViewFrameOffsetX;
Prop_assign()CGFloat imageViewFrameOffsetY;
Prop_assign()CGFloat imageViewFrameOffsetWidth;
Prop_assign()CGFloat imageViewFrameOffsetHeight;
#pragma mark —— 用类方法定义
/// 具体由子类进行复写【数据定宽】【如果所传参数为基本数据类型，那么包装成对象NSNumber进行转化承接】
+(JobsReturnCGFloatByIDBlock _Nonnull)buttonWidthByModel;
/// 具体由子类进行复写【数据定高】【如果所传参数为基本数据类型，那么包装成对象NSNumber进行转化承接】
+(JobsReturnCGFloatByIDBlock _Nonnull)buttonHeightByModel;
/// 具体由子类进行复写【数据尺寸】【如果所传参数为基本数据类型，那么包装成对象NSNumber进行转化承接】
+(JobsReturnCGSizeByIDBlock _Nonnull)buttonSizeByModel;
/// 具体由子类进行复写【数据Frame】【如果所传参数为基本数据类型，那么包装成对象NSNumber进行转化承接】
+(JobsReturnCGRectByIDBlock _Nonnull)buttonFrameByModel;
#pragma mark —— 用实例方法定义
/// 具体由子类进行复写【数据定宽】【如果所传参数为基本数据类型，那么包装成对象NSNumber进行转化承接】
-(JobsReturnCGFloatByIDBlock _Nonnull)buttonWidthByModel;
/// 具体由子类进行复写【数据定高】【如果所传参数为基本数据类型，那么包装成对象NSNumber进行转化承接】
-(JobsReturnCGFloatByIDBlock _Nonnull)buttonHeightByModel;
/// 具体由子类进行复写【数据尺寸】【如果所传参数为基本数据类型，那么包装成对象NSNumber进行转化承接】
-(JobsReturnCGSizeByIDBlock _Nonnull)buttonSizeByModel;
/// 具体由子类进行复写【数据Frame】【如果所传参数为基本数据类型，那么包装成对象NSNumber进行转化承接】
-(JobsReturnCGRectByIDBlock _Nonnull)buttonFrameByModel;
/// 具体由子类进行复写【数据定UI】【如果所传参数为基本数据类型，那么包装成对象NSNumber进行转化承接】
-(jobsByIDBlock _Nonnull)richButtonByModel;

@end

系统配置文件

@interface UIButtonConfiguration : NSObject <NSCopying, NSSecureCoding>

@interface UIBackgroundConfiguration : NSObject <NSCopying, NSSecureCoding>

@interface UIImageConfiguration : NSObject <NSCopying, NSSecureCoding>

@interface UIImageSymbolConfiguration : UIImageConfiguration

新的Api（UIButtonConfiguration）不带状态。即以下的带状态的无法配置。全部由UIButtonConfiguration接管

typedef NS_OPTIONS(NSUInteger, UIControlState) {
    UIControlStateNormal       = 0,
    UIControlStateHighlighted  = 1 << 0,                  // used when UIControl isHighlighted is set
    UIControlStateDisabled     = 1 << 1,
    UIControlStateSelected     = 1 << 2,                  // flag usable by app (see below)
    UIControlStateFocused API_AVAILABLE(ios(9.0)) = 1 << 3, // Applicable only when the screen supports focus
    UIControlStateApplication  = 0x00FF0000,              // additional flags available for application use
    UIControlStateReserved     = 0xFF000000               // flags reserved for internal framework use
};

- (void)setTitle:(nullable NSString *)title forState:(UIControlState)state;                     // default is nil. title is assumed to be single line
- (void)setTitleColor:(nullable UIColor *)color forState:(UIControlState)state UI_APPEARANCE_SELECTOR; // default is nil. use opaque white
- (void)setTitleShadowColor:(nullable UIColor *)color forState:(UIControlState)state UI_APPEARANCE_SELECTOR; // default is nil. use 50% black
- (void)setImage:(nullable UIImage *)image forState:(UIControlState)state;                      // default is nil. should be same size if different for different states
- (void)setBackgroundImage:(nullable UIImage *)image forState:(UIControlState)state UI_APPEARANCE_SELECTOR; // default is nil
- (void)setPreferredSymbolConfiguration:(nullable UIImageSymbolConfiguration *)configuration forImageInState:(UIControlState)state UI_APPEARANCE_SELECTOR API_AVAILABLE(ios(13.0), tvos(13.0), watchos(6.0));
- (void)setAttributedTitle:(nullable NSAttributedString *)title forState:(UIControlState)state API_AVAILABLE(ios(6.0)); // default is nil. title is assumed to be single line

- (nullable NSString *)titleForState:(UIControlState)state;          // these getters only take a single state value
- (nullable UIColor *)titleColorForState:(UIControlState)state;
- (nullable UIColor *)titleShadowColorForState:(UIControlState)state;
- (nullable UIImage *)imageForState:(UIControlState)state;
- (nullable UIImage *)backgroundImageForState:(UIControlState)state;
- (nullable UIImageSymbolConfiguration *)preferredSymbolConfigurationForImageInState:(UIControlState)state API_AVAILABLE(ios(13.0), tvos(13.0), watchos(6.0));
- (nullable NSAttributedString *)attributedTitleForState:(UIControlState)state API_AVAILABLE(ios(6.0));

对配置文件的修改：必须对配置文件UIButtonConfiguration *configuration进行整体的替换

无效的修改

id A = button.configuration.background.image;
button.configuration.background.image = nil;
[button updateConfiguration];
id B = button.configuration.background.image;

有效的修改

id A = button.configuration;
button.configuration = nil;
[button updateConfiguration];
id B = button.configuration;

用新Api（UIButtonConfiguration）创建一个带富文本的UIButton

-(BaseButton *)applyNowBtn{
   if(!_applyNowBtn){
       _applyNowBtn = BaseButton.jobsInit()
           .bgColor(JobsWhiteColor)
           .jobsResetImagePlacement(NSDirectionalRectEdgeLeading)
           .jobsResetImagePadding(1)
           .jobsResetBtnImage(JobsIMG(@"APPLY NOW"))
           .jobsResetBtnBgImage(JobsIMG(@"APPLY NOW"))
           .jobsResetBtnTitleCor(JobsWhiteColor)
           .titleFont(UIFontWeightBoldSize(JobsWidth(12)))
           .jobsResetBtnTitle(JobsInternationalization(@"APPLY NOW"))
           .onClick(^(UIButton *x){
               NSLog(@"");
           }).onLongPressGesture(^(id data){
               NSLog(@"");
           });
       [self.bgImageView addSubview:_applyNowBtn];
       [_applyNowBtn mas_makeConstraints:^(MASConstraintMaker *make) {
           make.size.mas_equalTo(CGSizeMake(JobsWidth(99), JobsWidth(29)));
           make.right.equalTo(self.view).offset(JobsWidth(-166));
           make.bottom.equalTo(self.view).offset(JobsWidth(-127));
       }];
   }return _applyNowBtn;
}

UIButtonConfiguration + SDWebImage

_headBtn = BaseButton.jobsInit()
   .imageURL(@"".jobsUrl)
   .placeholderImage(JobsIMG(@"小狮子"))
   .options(SDWebImageRefreshCached)/// 强制刷新缓存
   .completed(^(UIImage * _Nullable image,
                NSError * _Nullable error,
                SDImageCacheType cacheType,
                NSURL * _Nullable imageURL) {
       if (error) {
           NSLog(@"图片加载失败: %@-%@", error,imageURL);
       } else {
           NSLog(@"图片加载成功");
       }
   }).onClick(^(UIButton *x){
       @jobs_strongify(self)
       if (self.objectBlock) self.objectBlock(x);
   }).onLongPressGesture(^(id data){
   NSLog(@"");
}).bgNormalLoad();

因为此Api过于冗长且较为繁琐，所以对上述Api的二次封装

-(BaseButton *)applyNowBtn{
    if(!_applyNowBtn){
        @jobs_weakify(self)
        _applyNowBtn = BaseButton.initByAttributedString(self.richTextWithDataConfigMutArr(jobsMakeMutArr(^(__kindof NSMutableArray * _Nullable data) {
            data.add(jobsMakeRichTextConfig(^(__kindof JobsRichTextConfig * _Nullable data1) {
                @jobs_strongify(self)
                data1.font = UIFontWeightRegularSize(14);
                data1.textCor = JobsCor(@"#666666");
                data1.targetString = self.richTextMutArr[0];
                data1.paragraphStyle = self.jobsParagraphStyleCenter;
            }));
            data.add(jobsMakeRichTextConfig(^(__kindof JobsRichTextConfig * _Nullable data1) {
                @jobs_strongify(self)
                data1.font = UIFontWeightRegularSize(14);
                data1.textCor = JobsCor(@"#BA9B77");
                data1.targetString = self.richTextMutArr[1];
                data1.paragraphStyle = self.jobsParagraphStyleCenter;
            }));
            data.add(jobsMakeRichTextConfig(^(__kindof JobsRichTextConfig * _Nullable data1) {
                @jobs_strongify(self)
                data1.font = UIFontWeightRegularSize(14);
                data1.textCor = JobsCor(@"#666666");
                data1.targetString = self.richTextMutArr[2];
                data1.paragraphStyle = self.jobsParagraphStyleCenter;
            }));
        }))).bgColor(JobsWhiteColor)
            .jobsResetImagePlacement(NSDirectionalRectEdgeLeading)
            .jobsResetImagePadding(1)
            .jobsResetBtnImage(JobsIMG(@"APPLY NOW"))
            .jobsResetBtnBgImage(JobsIMG(@"APPLY NOW"))
            .jobsResetBtnTitleCor(JobsWhiteColor)
            .jobsResetBtnTitleFont(UIFontWeightBoldSize(JobsWidth(12)))
            .jobsResetBtnTitle(JobsInternationalization(@"APPLY NOW"))
            .onClick(^(UIButton *x){
                @jobs_strongify(self)
                x.selected = !x.selected;
                if (self.objectBlock) self.objectBlock(x);
            }).onLongPressGesture(^(id data){
                NSLog(@"");
            });
    }return _applyNowBtn;
}

对按钮各项属性的设置

#pragma mark —— 一些通用修改（Api已做向下兼容）
/// 主标题是否多行显示
-(jobsByBOOLBlock _Nonnull)makeNewLineShows;
#pragma mark —— 一些通用修改.主标题（Api已做向下兼容）
///【兼容】重设Btn主标题的文字内容 优先级高于jobsResetTitle
-(JobsReturnButtonByStringBlock _Nonnull)jobsResetBtnTitle;
///【兼容】重设Btn主标题的文字颜色
-(JobsReturnButtonByColorBlock _Nonnull)jobsResetBtnTitleCor;
///【兼容】重设Btn的主标题字体
-(JobsReturnButtonByFontBlock _Nonnull)jobsResetBtnTitleFont;
///【兼容】重设Btn的主标题对其方式
-(JobsReturnButtonByNSIntegerBlock _Nonnull)jobsResetBtnTitleAlignment;
#pragma mark —— 一些通用修改.副标题
///【最新的Api】重设Btn副标题的文字内容
-(JobsReturnButtonByStringBlock _Nonnull)jobsResetBtnSubTitle API_AVAILABLE(ios(16.0));
///【最新的Api】重设Btn副标题的文字颜色
-(JobsReturnButtonByColorBlock _Nonnull)jobsResetBtnSubTitleCor API_AVAILABLE(ios(16.0));
///【兼容】重设Btn的副标题字体
-(JobsReturnButtonByFontBlock _Nonnull)jobsResetBtnSubTitleFont;
#pragma mark —— 一些通用修改.按钮图片
///【兼容】重设Btn.Image
-(JobsReturnButtonByImageBlock _Nonnull)jobsResetBtnImage;
#pragma mark —— 一些通用修改.按钮背景图片
///【兼容】重设Btn的背景图片
-(JobsReturnButtonByImageBlock _Nonnull)jobsResetBtnBgImage;
#pragma mark —— 一些通用修改.按钮颜色
///【兼容】重设Btn的背景颜色
-(JobsReturnButtonByColorBlock _Nonnull)jobsResetBtnBgCor;
#pragma mark —— 一些通用修改.Layer
///【合并】统一设置按钮Layer的线宽+颜色+圆切角
-(JobsReturnViewByLocationModelBlock _Nonnull)jobsResetBtnLayerBy;
///【兼容】重设Btn的圆切角
-(JobsReturnButtonByCGFloatBlock _Nonnull)jobsResetBtnCornerRadiusValue;
///【兼容】重设Btn的描边线段的颜色
-(JobsReturnButtonByColorBlock _Nonnull)jobsResetBtnLayerBorderCor;
///【兼容】重设Btn的描边线段的宽度
-(JobsReturnButtonByCGFloatBlock _Nonnull)jobsResetBtnLayerBorderWidth;
#pragma mark —— 一些通用修改.富文本
///【兼容】重设Btn主标题富文本
-(JobsReturnButtonByAttributedStringBlock _Nonnull)jobsResetBtnNormalAttributedTitle;
///【兼容】重设Btn副标题富文本
-(JobsReturnButtonByAttributedStringBlock _Nonnull)jobsResetBtnNormalAttributedSubTitle;
/// 用 UITextView 替换 UIButton.titleLabel
-(JobsReturnButtonByAttributedStringBlock _Nonnull)jobsResetBtnTextViewNormalAttributedTitle;
/// 用 UITextView 替换 UIButton.subtitleLabel
-(JobsReturnButtonByAttributedStringBlock _Nonnull)jobsResetBtnTextViewNormalAttributedSubTitle;
#pragma mark —— 一些通用修改.间距
///【兼容】重设Btn的图文间距和相对位置
-(JobsReturnButtonByImagePlacementAndPaddingBlock _Nonnull)jobsResetImagePlacement_Padding API_AVAILABLE(ios(16.0));
///【兼容】获取按钮图片（普通状态下）
-(UIImage *_Nullable)imageForNormalState;
///【兼容】获取按钮背景图片（普通状态下）
-(UIImage *_Nullable)backgroundImageForNormalState;
///【兼容】获取按钮富文本字符串内容
-(NSString *_Nullable)titleForConfigurationAttributedText;
///【兼容】获取按钮富文本内容（更通用）
-(NSAttributedString *_Nullable)titleForConfigurationAttributed;
///【兼容】获取按钮富文本内容（普通状态下）
-(NSAttributedString *_Nullable)attributedTitleForNormalState;
///【兼容】获取按钮主文字内容
-(NSString *_Nullable)titleForNormalState;
///【兼容】获取按钮主文字颜色
-(UIColor *_Nullable)titleColorForNormalState;

#pragma mark —— 对老Api进行二次封装
+(JobsReturnButtonByNSIntegerBlock _Nonnull)initByType;
+(__kindof UIButton *)initByCustomType;
+(__kindof UIButton *)initBySysType API_AVAILABLE(ios(7.0));
+(__kindof UIButton *)initByDetailDisclosureType;
+(__kindof UIButton *)initByInfoLightType;
+(__kindof UIButton *)initByInfoDarkType;
+(__kindof UIButton *)initByContactAddType;
+(__kindof UIButton *)initByPlainType API_AVAILABLE(tvos(11.0)) API_UNAVAILABLE(ios, watchos);
+(__kindof UIButton *)initByCloseType API_AVAILABLE(ios(13.0)) API_UNAVAILABLE(tvos, watchos);
#pragma mark —— 依靠单一数据进行简单创建
/// 仅仅依靠主标题内容（普通文本）进行创建
+(JobsReturnButtonByStringBlock _Nonnull)initByTitle;
/// 仅仅依靠主标题富文本内容进行创建
+(JobsReturnButtonByAttributedStringBlock _Nonnull)initByAttributedString;
/// 仅仅靠按钮图片进行创建
+(JobsReturnButtonByImageBlock _Nonnull)initByNormalImage;
/// 仅仅依靠按钮背景图进行创建
+(JobsReturnButtonByImageBlock _Nonnull)initByBackgroundImage;
#pragma mark —— 对副标题进行创建
/// 仅仅依靠（主/副）标题内容（普通文本）进行创建
+(JobsReturnButtonByTitlesBlock _Nonnull)initByTitles;
/// 仅仅依靠（主标题+副标题）富文本内容进行创建
+(JobsReturnButtonByAttributedStringsBlock _Nonnull)initByAttributedStrings;
#pragma mark —— 依靠多数据进行较为复杂的创建
/// 依靠标题内容和字体大小进行创建
+(JobsReturnButtonByStyle1Block _Nonnull)initByTitle_font;
/// 依靠标题内容（普通文本）、字体大小、文字颜色进行创建
+(JobsReturnButtonByStyle2Block _Nonnull)initByStyle1;
/// 依靠标题内容（普通文本）、字体大小、文字颜色、按钮图片进行创建
+(JobsReturnButtonByStyle3Block _Nonnull)initByStyle2;
/// 依靠标题内容（普通文本）、字体大小、文字颜色、按钮背景图片进行创建
+(JobsReturnButtonByStyle4Block _Nonnull)initByStyle3;
/// 依靠标题内容（普通文本）、字体大小、文字颜色、按钮图片、按钮背景图片进行创建
+(JobsReturnButtonByStyle5Block _Nonnull)initByStyle4;
/// 依靠文字内容、字体大小、文字颜色、按钮图片、图文距离进行创建
+(JobsReturnButtonByStyle3Block _Nonnull)initByStyle5;
/// 图文混排（图片在上边 ）
+(JobsReturnButtonByStyle3_1Block _Nonnull)initByStyleTop;
/// 图文混排（图片在左边 ）
+(JobsReturnButtonByStyle3_1Block _Nonnull)initByStyleLeft;
/// 图文混排（图片在下边 ）
+(JobsReturnButtonByStyle3_1Block _Nonnull)initByStyleBottom;
/// 图文混排（图片在右边 ）
+(JobsReturnButtonByStyle3_1Block _Nonnull)initByStyleRight;
#pragma mark —— 依靠数据束进行创建
+(JobsReturnButtonByVoidBlock _Nonnull)jobsInit;
/// 依靠UIViewModel进行创建
+(JobsReturnButtonByViewModelBlock _Nonnull)initByViewModel;
/// 依靠UIButtonModel进行创建
+(JobsReturnButtonByButtonModelBlock _Nonnull)initByButtonModel;
/// 依靠UITextModel进行创建
+(JobsReturnButtonByTextModelBlock _Nonnull)initByTextModel;
#pragma mark —— 一些公有方法
-(JobsReturnButtonByClickBlock _Nonnull)onClickBy;
-(JobsReturnButtonByClickBlock _Nonnull)onLongPressGestureBy;
-(JobsReturnButtonByTimerManagerBlock _Nonnull)heartBeatBy;
-(JobsReturnButtonByColorBlock _Nonnull)bgColorBy;
-(JobsReturnButtonByCGFloatBlock _Nonnull)cornerRadiusValueBy;

资料来源：
- UIButtonConfiguration
- Chat GPT 3.5

2、倒计时按钮的封装回到顶部

关注实现类 @interface UIButton (Timer)

调用示例

-(__kindof UIButton *)makeSendSMSCodeBtnByClickBlock:(jobsByBtnBlock _Nullable)clickBlock{
    return UIButton.initByConfig(jobsMakeButtonTimerConfigModel(^(__kindof ButtonTimerConfigModel * _Nullable data) {
        /// 一些通用的设置
        data.count = 10;
        data.showTimeType = ShowTimeType_SS;// 时间显示风格
        data.countDownBtnType = TimerStyle_anticlockwise;// 时间方向
        data.cequenceForShowTitleRuningStrType = CequenceForShowTitleRuningStrType_tail;//
        data.labelShowingType = UILabelShowingType_01;//【换行模式】
        data.secondStr = @" ".add(JobsInternationalization(@"S"));
        /// 计时器未开始【静态值】
        data.readyPlayValue = jobsMakeButtonModel(^(UIButtonModel * _Nullable model) {
            model.jobsSize = CGSizeMake(JobsWidth(80), JobsWidth(28));
            model.bgCor = JobsClearColor;
            model.layerBorderCor = JobsClearColor;
            model.titleCor = JobsWhiteColor;
            model.title = JobsInternationalization(@"GET CODE");
            model.titleFont = bayonRegular(JobsWidth(12));
            model.backgroundImage = JobsIMG(@"获取验证码背景图");
        });
        /// 计时器进行中【动态值】
        data.runningValue = jobsMakeButtonModel(^(UIButtonModel * _Nullable model) {
            model.jobsSize = CGSizeMake(JobsWidth(80), JobsWidth(28));
            model.bgCor = JobsClearColor;
            model.title = @"  ";
            model.layerBorderCor = JobsClearColor;
            model.titleCor = JobsWhiteColor;
            model.titleFont = bayonRegular(JobsWidth(12));
            model.backgroundImage = JobsIMG(@"获取验证码背景图");
        });
        /// 计时器结束【静态值】
        data.endValue = jobsMakeButtonModel(^(UIButtonModel * _Nullable model) {
            model.jobsSize = CGSizeMake(JobsWidth(80), JobsWidth(28));
            model.bgCor = JobsClearColor;
            model.titleCor = JobsWhiteColor;
            model.title = JobsInternationalization(@"GET CODE");
            model.titleFont = bayonRegular(JobsWidth(12));
            model.backgroundImage = JobsIMG(@"获取验证码背景图");
        });
    })).onClickBy(^(__kindof UIButton *x){
        /// 回调到外层取值，以满足后续业务需要
        if(clickBlock) clickBlock(x);
    }).onLongPressGestureBy(^(id data){
        JobsLog(@"");
    }).heartBeatBy(^(NSTimerManager *_Nullable data){
        JobsLog(@"❤️❤️❤️❤️❤️%f",data.anticlockwiseTime);
    });
}

倒计时事件触发

对倒计时按钮的倒计时功能进行控制

开始
```
self.countDownBtn.startTimer();
```
暂停
```
self.countDownBtn.timerSuspend();
```
继续
```
self.countDownBtn.timerContinue();
```
结束
```
self.countDownBtn.timerDestroy();
```

正常的按钮点击事件

主调用中的clickEventBlock:(JobsReturnIDByIDBlock _Nullable)clickEventBlock参数

和主调用进行剥离，可以在其他地方灵活实现

[self.countDownBtn jobsBtnClickEventBlock:^id(UIButton *x) {
   x.startTimer();//选择时机、触发启动
   NSLog(@"🪓🪓🪓🪓🪓 = 获取验证码");
   return nil;
}];

按钮的长按事件：

因为是低频需求，所以目前只封装在主调用上进行呈现

长按手势用RAC进行实现

/// 设置按钮的长按手势
-(void)jobsBtnLongPressGestureEventBlock:(JobsReturnIDByIDBlock _Nullable)longPressGestureEventBlock{
    if(longPressGestureEventBlock){
        self.userInteractionEnabled = YES;
        self.addGesture([jobsMakeLongPressGesture(^(UILongPressGestureRecognizer * _Nullable gesture) {
            /// 这里写手势的配置
        }) gestureActionBy:^{
            /// 这里写手势的触发
            if(longPressGestureEventBlock) longPressGestureEventBlock(self);
        }]);
    }
}

3、`Masonry` 的一些使用技巧回到顶部

pod 'Masonry' # https://github.com/SnapKit/Masonry NO_SMP

#if __has_include(<Masonry/Masonry.h>)
#import <Masonry/Masonry.h>
#else
#import "Masonry.h"
#endif

关注实现类：@interface UIView (Masonry)

统一设置内边距

[self.chatBubbleIMGV addSubview:_chatContentLab];
[_chatContentLab mas_makeConstraints:^(MASConstraintMaker *make) {
    make.edges.equalTo(self.chatBubbleIMGV).with.insets(UIEdgeInsetsMake(5, 5, 5, 5));
}];

对Masonry约束Block进行存储，一般一个View对应一个约束。先addSubview，再利用存储的约束进行绘制UI

-(JobsReturnViewByButtonModelBlock _Nonnull)showEmptyButtonBy{
    @jobs_weakify(self)
    return ^__kindof UIView *_Nullable(UIButtonModel *model){
        @jobs_strongify(self)
        if(self.hasData){
            self.cleanSubviewBy(BaseView.class);
            return nil;
        }else{
            return jobsMakeBaseView(^(__kindof BaseView *_Nullable view) {
                @jobs_strongify(self)
                view.frame = self.bounds;
                self.cleanSubviewBy(BaseView.class);
                self.addSubview(view);
                view.addSubview(UIButton.initByButtonModel(model ? : jobsMakeButtonModel(^(__kindof UIButtonModel * _Nullable data) {
                    data.title = JobsInternationalization(@"No Datas");
                    data.titleCor = JobsWhiteColor;
                    data.titleFont = bayonRegular(JobsWidth(30));
                    data.normalImage = JobsIMG(@"暂无数据");
                    data.baseBackgroundColor = JobsClearColor.colorWithAlphaComponentBy(0);
                })).setMasonryBy(^(MASConstraintMaker *make){
                    @jobs_strongify(self)
                    make.centerX.equalTo(self).offset(model.jobsOffsetX);
                    make.centerY.equalTo(self).offset(model.jobsOffsetY);
                    make.width.equalTo(self);
                }));
            });
        }
    };
}

将以前的约束全部清除，用最新的mas_remakeConstraints

如果在已有的约束基础上，再更新约束mas_updateConstraints

-(UIView *)pointView{
    if(!_pointView){
        _pointView = UIView.new;
        [self addSubview:_pointView];
        [_pointView mas_makeConstraints:^(MASConstraintMaker *make) {
            make.size.mas_equalTo(CGSizeMake(JobsWidth(8), JobsWidth(8)));
            make.top.equalTo(self);
            make.left.equalTo(self);
        }];
    }return _pointView;
}

-(void)updatePointViewPositionWithOffsetY:(CGFloat)y{
    [self.pointView mas_updateConstraints:^(MASConstraintMaker *make) {
        make.top.equalTo(self).offset(y);
    }];
    [self setNeedsLayout];
    [self layoutIfNeeded];
}

【开发笔记】Masonry 的 distributeViewsAlongAxis 方法

横向拉伸以均分

[self.btnMutArr mas_distributeViewsAlongAxis:MASAxisTypeHorizontal/// 在水平方向上分布这些视图
                            withFixedSpacing:20/// 指定每个视图之间的固定间距
                                 leadSpacing:5/// 指定第一个视图与父视图左边缘之间的距离
                                 tailSpacing:5];/// 指定最后一个视图与父视图右边缘之间的距离
[self.btnMutArr mas_makeConstraints:^(MASConstraintMaker *make) {
    make.top.equalTo(@60);
    make.height.equalTo(@60);
}];

纵向拉伸以均分

[self.btnMutArr mas_distributeViewsAlongAxis:MASAxisTypeVertical/// 在垂直方向上分布这些视图
                            withFixedSpacing:20/// 指定每个视图之间的固定间距
                                 leadSpacing:5/// 指定第一个视图与父视图顶部之间的距离
                                 tailSpacing:5];/// 指定最后一个视图与父视图底部之间的距离
[self.btnMutArr mas_makeConstraints:^(MASConstraintMaker *make) {
    make.left.equalTo(@0);
    make.width.equalTo(@60);
}];

纵向固定大小显示

[self.btnMutArr mas_distributeViewsAlongAxis:MASAxisTypeVertical/// 在垂直方向上分布这些视图
                         withFixedItemLength:30/// 指定每个视图之间的固定间距
                                 leadSpacing:30/// 指定第一个视图与父视图顶部之间的距离
                                 tailSpacing:200];/// 指定最后一个视图与父视图底部之间的距离
[self.btnMutArr mas_makeConstraints:^(MASConstraintMaker *make) {
    make.left.equalTo(@0);
    make.width.equalTo(@60);
}];

将上述进行封装以后的调用示例：

#import "NSArray+Tools.h"

@property(nonatomic,strong)NSMutableArray <UIImageView *>*subViewsMutArr;
self.subViewsMutArr.describe();

-(NSMutableArray<UIImageView *> *)subViewsMutArr{
    if(!_subViewsMutArr){
        @jobs_weakify(self)
        _subViewsMutArr = jobsMakeMutArr(^(__kindof NSMutableArray <__kindof UIView *>*_Nullable data) {
            @jobs_strongify(self)
            data.add(BonusEarnedView.JobsRichElementsInViewWithModel(nil));
            data.add(InvitedFriendsNumberView.JobsRichElementsInViewWithModel(nil));
            data.add(CopyLinkView.JobsRichElementsInViewWithModel(nil));
            data.add(DownloadQRCodeView.JobsRichElementsInViewWithModel(nil));
            for (UIView *view in data) {
                self.view.addSubview(view);
            }
        }).installByMasonryModel(jobsMakeMasonryModel(^(__kindof MasonryModel * _Nullable data) {
            data.axisType = MASAxisTypeHorizontal;
            data.fixedSpacing = JobsWidth(22);
            data.leadSpacing = JobsWidth(52);
            data.tailSpacing = JobsWidth(52);
            data.top = JobsWidth(90);
            data.height = [BonusEarnedView viewSizeWithModel:nil].height;
        }));
    }return _subViewsMutArr;
}

点我了解详情：Masonry约束动画

-(MSMineView2 *)view2{
    if(!_view2){
        _view2 = MSMineView2.new;
        _view2.jobsRichElementsInViewWithModel(nil);
        [self addSubview:_view2];
        [_view2 jobsMasonryBeforeBlock:^(MASConstraintMaker * _Nonnull make) {
            // 添加第一个 _view2 的约束
            make.width.mas_equalTo(0);
            make.height.mas_equalTo([MSMineView2 viewSizeWithModel:nil].height);
            make.right.equalTo(self).offset(JobsWidth(-10));
            make.top.equalTo(self).offset(JobsWidth(10));
        }
                     masonryAfterBlock:^(MASConstraintMaker * _Nonnull make) {
            // 添加第二个 _view2 的约束
            make.size.mas_equalTo([MSMineView2 viewSizeWithModel:nil]);
            make.centerX.equalTo(self);
            make.top.equalTo(self).offset(JobsWidth(10));
        }];
        [_view2 cornerCutToCircleWithCornerRadius:[MSMineView2 viewSizeWithModel:nil].height / 2];
    }return _view2;
}

4、退出`ViewController`的时候，需要做的操作回到顶部

点我了解详情

定义于BaseViewProtocol，因为是进数据，所以可以实现在控制器生命周期的任意处

 @jobs_weakify(self)
 self.jobsBackBlock = ^id _Nullable(id _Nullable data) {
     @jobs_strongify(self)
     NSLog(@"退出页面的逻辑");
     return nil;
 };

也可以在具体的子控制器覆写下列方法

-(void)backBtnClickEvent:(UIButton *_Nullable)sender;

-(jobsByBtnBlock _Nonnull)backBtnClickEvent{
    @jobs_weakify(self)
    return ^(UIButton *_Nullable sender) {
        @jobs_strongify(self)
        self.jobsBackBtnClickEvent(sender);
    };
}

-(jobsByBtnBlock _Nonnull)jobsBackBtnClickEvent{
    @jobs_weakify(self)
    return ^(__kindof UIButton *_Nullable sender) {
        @jobs_strongify(self)
        if (self.jobsBackBlock) self.jobsBackBlock(sender);
        UIViewController *vc = nil;
        if (KindOfVCCls(self)) {
            vc = (UIViewController *)self;
        }else if (KindOfViewCls(self)){
            UIView *view = (UIView *)self;
            vc = self.getViewControllerByView(view);
        }else return;
        
        switch (self.pushOrPresent) {
            case ComingStyle_PRESENT:{
                [vc dismissViewControllerAnimated:YES completion:nil];
            }break;
            case ComingStyle_PUSH:{
                vc.navigationController ? [vc.navigationController popViewControllerAnimated:YES] : [vc dismissViewControllerAnimated:YES completion:nil];
            }break;
                
            default:
                break;
        }
    };
}

5、实例对象的weak化，避免循环引用回到顶部

点我了解详情：相关定义

#ifndef MacroDef_Strong_Weak_h
#define MacroDef_Strong_Weak_h

/** 强弱引用
    Uses
    UIView *view;
    UIButton *btn;

    @jobs_weakify(view)
    weak_view.size;
    @jobs_weakify(btn)
    weak_btn.frame

 # 能用@符号进行调用的根本原因：来自GPT-3.5的回答
    在如下的宏定义中：
    @符号可以用于调用的原因是因为宏内部实际上不包含Objective-C代码块，而是包含了一个函数调用，
    这个函数调用是Objective-C代码中的一个有效表达式。
 */
#ifndef jobs_weakify
#if DEBUG
#if __has_feature(objc_arc)
#define jobs_weakify(self) autoreleasepool{} __weak __typeof__(self) weak##_##self = self;
#else
#define jobs_weakify(self) autoreleasepool{} __block __typeof__(self) block##_##self = self;
#endif
#else
#if __has_feature(objc_arc)
#define jobs_weakify(self) try{} @finally{} {} __weak __typeof__(self) weak##_##self = self;
#else
#define jobs_weakify(self) try{} @finally{} {} __block __typeof__(self) block##_##self = self;
#endif
#endif
#endif

#ifndef jobs_strongify
#if DEBUG
#if __has_feature(objc_arc)
#define jobs_strongify(self) autoreleasepool{} __typeof__(self) self = weak##_##self;
#else
#define jobs_strongify(self) autoreleasepool{} __typeof__(self) self = block##_##self;
#endif
#else
#if __has_feature(objc_arc)
#define jobs_strongify(self) try{} @finally{} __typeof__(self) self = weak##_##self;
#else
#define jobs_strongify(self) try{} @finally{} __typeof__(self) self = block##_##self;
#endif
#endif
#endif

#endif /* MacroDef_Strong_Weak_h */

点我了解详情：使用方式

@jobs_strongify(self)
@jobs_weakify(self)

6、使用block，对`@selector`的替代封装，避免方法割裂回到顶部

点我了解详情

typedef id _Nullable(^JobsReturnIDBySelectorBlock)(id _Nullable weakSelf, id _Nullable arg);
-(SEL _Nullable)jobsSelectorBlock:(JobsReturnIDBySelectorBlock)selectorBlock{
 return selectorBlocks(selectorBlock, MethodName(self), self);
}

/// 替代系统 @selector(selector) ,用Block的方式调用代码，使得代码逻辑和形式上不割裂
/// 类方法或全局函数，用于添加选择器
/// - Parameters:
///   - block: 最终的执行体
///   - selectorName: 实际调用的方法名（可不填），用于对外输出和定位调用实际使用的方法
///   - target: 执行目标
SEL _Nullable selectorBlocks(JobsReturnIDBySelectorBlock _Nullable block,
                             NSString *_Nullable selectorName,// MethodName(self)
                             NSObject *_Nonnull target) {
    if (!block) {
        toastErr(JobsInternationalization(@"方法不存在,请检查参数"));
        return NULL;
    }
    NSString *selName = @"selector"
        .add(@"_")
        .add(toStringByID(target.makeSnowflake))
        .add(@"_")
        .add(selectorName);
    JobsLog(@"selName = %@", selName);
    SEL sel = NSSelectorFromString(selName);
    /// 检查缓存
    static NSMutableDictionary *methodCache;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        methodCache = NSMutableDictionary.dictionary;
    });
    
    NSValue *cachedSelValue = methodCache[selName];
    if (cachedSelValue) {
        return cachedSelValue.pointerValue;
    }
    /**
     方法签名由方法名称和一个参数列表（方法的参数的顺序和类型）组成
     注意：方法签名不包括方法的返回类型。不包括返回值和访问修饰符
     第一个参数是在哪个类中添加方法
     第二个参数是所添加方法的编号SEL
     第三个参数是所添加方法的函数实现的指针IMP
     第四个参数是所添加方法的签名
     */
    /// 检查目标类是否已有该方法
    if (class_getInstanceMethod([target class], sel)) {
        JobsLog(@"方法曾经已经被成功添加，再次添加会崩溃");
        return sel;
    } else {
        /// 动态添加方法
        if (class_addMethod([target class], sel, (IMP)selectorImp, "v@:@@")) {
            objc_setAssociatedObject(target, sel, block, OBJC_ASSOCIATION_COPY_NONATOMIC);
            methodCache[selName] = NSValue.byPointer(sel);
        } else {
            [NSException raise:JobsInternationalization(@"添加方法失败")
                        format:@"%@ selectorBlock error", target];
        }
    }return sel;
}

6.1、对按钮点击事件的使用

6.2、对通知的使用

关注实现类：MacroDef_Notification.h @interface NSNotificationCenter (JobsBlock)

6.2.1、发通知

@implementation NSString (Notification)

-(jobsByIDBlock _Nonnull)postNotificationBy{
    @jobs_weakify(self)
    return ^(id _Nullable data){
        @jobs_strongify(self)
        [JobsNotificationCenter postNotificationName:self object:data];
    };
}

-(jobsByNotificationModelBlock _Nonnull)postNotificationByModel{
    @jobs_weakify(self)
    return ^(NotificationModel *_Nullable data){
        @jobs_strongify(self)
        [JobsNotificationCenter postNotificationName:self
                                              object:data.anObject
                                            userInfo:data.userInfo];
    };
}

@end

[JobsNotificationCenter postNotificationName:LanguageSwitchNotification object:@(NO)];


* ```objective-c
/// 在主线程上带参发通知
-(jobsByKey_ValueBlock _Nonnull)JobsPost{
    return ^(NSString *_Nonnull key,id _Nullable value){
        dispatch_async(dispatch_get_main_queue(), ^{
            key.postNotificationBy(value);
        });
    };
}
/// 在主线程上带参发通知
-(jobsByKeyValueModelBlock _Nonnull)JobsPostBy{
    return ^(JobsKeyValueModel *_Nullable data){
        dispatch_async(dispatch_get_main_queue(), ^{
            NSString *key = (NSString *)data.key;
            key.postNotificationBy(data.value);
        });
    };
}
/// 在主线程上不带参发通知
-(jobsByStringBlock _Nonnull)jobsPost{
    return ^(NSString *_Nonnull key){
        dispatch_async(dispatch_get_main_queue(), ^{
            key.postNotificationBy(nil);
        });
    };
}

/// 2.1、不带参数的发送通知
#ifndef JobsPostNotification
#define JobsPostNotification(NotificationName,Obj)\
[JobsNotificationCenter postNotificationName:(NotificationName) object:(Obj)];
#endif
/// 2.2、带参数的发送通知
#ifndef JobsPostNotificationUserInfo
#define JobsPostNotificationUserInfo(NotificationName,Obj,UserInfo)\
[JobsNotificationCenter postNotificationName:(NotificationName) \
                                      object:(Obj) \
                                    userInfo:(UserInfo)];
#endif
/// 2.3、在主线程上发送通知【建议】
#ifndef JobsPostNotificationOnMainThread
#define JobsPostNotificationOnMainThread(NotificationName, Obj, UserInfo)\
dispatch_async(dispatch_get_main_queue(), ^{\
    JobsPostNotificationUserInfo(NotificationName,Obj,UserInfo);\
});
#endif

6.2.2、接收通知

@jobs_weakify(self)
[self addNotificationName:kReachabilityChangedNotification
                    block:^(id _Nullable weakSelf,
                            id _Nullable arg) {
    @jobs_strongify(self)
    NSNotification *notification = (NSNotification *)arg;
    NSLog(@"通知传递过来的 = %@",notification.object);
}];

@jobs_weakify(self)
[JobsNotificationCenter addObserver:self
                           selector:selectorBlocks(^id _Nullable(id _Nullable weakSelf,
                                                                 id _Nullable arg) {
    NSNotification *notification = (NSNotification *)arg;
    if([notification.object isKindOfClass:NSNumber.class]){
        NSNumber *b = notification.object;
        NSLog(@"SSS = %d",b.boolValue);
    }
    NSLog(@"通知传递过来的 = %@",notification.object);
    return nil;
}, MethodName(self), self) name:JobsLanguageSwitchNotification object:nil];

[JobsNotificationCenter addObserverForName:GSUploadNetworkSpeedNotificationKey
                                    object:nil
                                     queue:nil
                                usingBlock:^(NSNotification * _Nonnull notification) {
    NSLog(@"%@",notification.object);
}];

6.2.3、移除通知

@implementation NSNotificationCenter (JobsBlock)

-(jobsByIDBlock _Nonnull)remove{
    return ^(id _Nullable data){
        [JobsNotificationCenter removeObserver:data];
    };
}

-(jobsByKey_ValueBlock _Nonnull)Remove{
    return ^(NSString *_Nonnull key,id _Nullable value){
        [JobsNotificationCenter removeObserver:value
                                          name:key
                                        object:nil];
    };
}

7、`UIViewModel`的使用回到顶部

将数据束UIViewModel绑定到UI中，包括一些UI交互事件

对 UICollectionView 点击事件的封UIViewModel+block

/// Data
@property(nonatomic,strong)NSMutableArray <UIViewModel *>*dataMutArr;

-(NSMutableArray<UIViewModel *> *)dataMutArr{
    if (!_dataMutArr) {
        @jobs_weakify(self)
        _dataMutArr = jobsMakeMutArr(^(__kindof NSMutableArray * _Nullable data) {
            data.add(jobsMakeViewModel(^(__kindof UIViewModel * _Nullable data1) {
                data1.textModel = jobsMakeTextModel(^(__kindof UITextModel * _Nullable data2) {
                    data2.text = JobsInternationalization(@"Hello");
                    data2.textCor = JobsRedColor;
                    data2.textAlignment = NSTextAlignmentCenter;
                });
                data1.jobsBlock = ^id(id param){
                    @jobs_strongify(self)
                    NSLog(@"Hello");
                    return nil;
                };
            }));
        });
    }return _dataMutArr;
}

/// collectionView 选中操作
- (void)collectionView:(UICollectionView *)collectionView
didSelectItemAtIndexPath:(NSIndexPath *)indexPath {
    NSLog(@"%s", __FUNCTION__);
    self.dataMutArr[indexPath.item].jobsBlock(nil);
    /**
     滚动到指定位置
     _collectionView.contentOffset = CGPointMake(0,-100);
     [_collectionView setContentOffset:CGPointMake(0, -200) animated:YES];// 只有在viewDidAppear周期 或者 手动触发才有效
     */
}

8、统一注册全局的 `UICollectionViewCell` 回到顶部

不注册相对应当UICollectionViewCell相关子类，使用时会崩溃
系统注册UICollectionViewCell相关子类，是利用字符串作为桥梁进行操作
注册不会开辟内存，只有当使用的时候才会开辟内存
对全局进行统一的UICollectionViewCell相关子类注册是很有必要的，方便管理，防止崩溃
关注实现类@implementation UICollectionView (JobsRegisterClass)
在每一个_collectionView创建的时候，加入以下这一段代码
```
[_collectionView registerCollectionViewClass];
```

9、全局的弹出框回到顶部

9.1、全局统一的提示弹出框

本质是对WHToast的二次封装。其实TFPopup也有同样的功能

接入方式：

Podfile

pod 'WHToast' # https://github.com/remember17/WHToast 一个轻量级的提示控件，没有任何依赖 NO_SMP

#if __has_include(<WHToast/WHToast.h>)
#import <WHToast/WHToast.h>
#else
#import "WHToast.h"
#endif

关注实现类：@implementation NSObject (WHToast)

#pragma mark —— 仅文字，展示在屏幕中间
+(jobsByStringBlock _Nonnull)jobsToastMsg;
-(jobsByStringBlock _Nonnull)jobsToastMsg;
#pragma mark —— 成功图标和文字，展示在屏幕中间
+(jobsByStringBlock _Nonnull)jobsToastSuccessMsg;
-(jobsByStringBlock _Nonnull)jobsToastSuccessMsg;
#pragma mark —— 失败图标和文字，展示在屏幕中间
+(jobsByStringBlock _Nonnull)jobsToastErrMsg;
-(jobsByStringBlock _Nonnull)jobsToastErrMsg;
#pragma mark —— 延时操作
+(jobsByStringBlock _Nonnull)jobsToastLoadingMsg;
-(jobsByStringBlock _Nonnull)jobsToastLoadingMsg;
#pragma mark —— 手动关闭WHToast，在主线程
+(jobsByVoidBlock _Nonnull)jobsToastHide;
-(jobsByVoidBlock _Nonnull)jobsToastHide;

关注实现类：MacroDef_Func.h

NS_INLINE void toast(NSString *_Nullable msg){
    if(!msg || ![msg isKindOfClass:NSString.class]){
        msg = JobsInternationalization(@"数据错误");
    }NSObject.jobsToastMsg(JobsInternationalization(msg));
}

9.2、`TFPopup`

最底层承接的是一个UIButton
弹窗消失的时候，挂载的视图一定要销毁，而不是隐藏

对其二次封装，方便使用。关注实现类：@implementation NSObject (TFPopup)

#pragma mark —— PopView
/// 出现的弹窗需要手动触发关闭——禁止点击背景消失弹框
-(jobsByViewBlock _Nonnull)show_view{
    @jobs_weakify(self)
    return ^(UIView *_Nonnull data) {
        @jobs_strongify(self)
        self.popupParameter.popupSize = data.viewSizeByModel(nil);
        self.popupParameter.dragEnable = YES;
        self.popupParameter.disuseBackgroundTouchHide = YES;/// 禁止点击背景消失弹框
        [self checkByView:data action:^{
            @jobs_strongify(self)
            [data tf_showSlide:MainWindow
                     direction:PopupDirectionContainerCenter
                    popupParam:self.popupParameter];
        }];
    };
}
/// 出现的弹窗需要手动触发关闭——允许点击背景消失弹框
-(jobsByViewBlock _Nonnull)show_view2{
    @jobs_weakify(self)
    return ^(UIView *_Nonnull data) {
        @jobs_strongify(self)
        self.popupParameter.popupSize = data.viewSizeByModel(nil);
        self.popupParameter.dragEnable = YES;
        self.popupParameter.backgroundColor = JobsBlackColor.colorWithAlphaComponent(.3f);
        self.popupParameter.disuseBackgroundTouchHide = NO;/// 允许点击背景消失弹框
        [self checkByView:data action:^{
            @jobs_strongify(self)
            [data tf_showSlide:MainWindow
                     direction:PopupDirectionContainerCenter
                    popupParam:self.popupParameter];
        }];
    };
}
/// 出现的弹窗自动触发关闭
-(jobsByViewBlock _Nonnull)show_tips{
    @jobs_weakify(self)
    return ^(UIView *_Nonnull data) {
        @jobs_strongify(self)
        self.tipsParameter.popupSize = data.viewSizeByModel(nil);
        [self checkByView:data action:^{
            @jobs_strongify(self)
            [data tf_showSlide:MainWindow
                     direction:PopupDirectionContainerCenter
                    popupParam:self.tipsParameter];
        }];
    };
}

接入方式

Podfile

pod 'TFPopup' # https://github.com/shmxybfq/TFPopup 不耦合view代码,可以为已创建过 / 未创建过的view添加弹出方式;只是一种弹出方式;

#if __has_include(<TFPopup/TFPopup.h>)
#import <TFPopup/TFPopup.h>
#else
#import "TFPopup.h"
#endif

出现

self.show_view(PopListBaseView
               .BySize(CGSizeMake(JobsWidth(328), JobsWidth(37 * 2)))
               .JobsRichViewByModel2(self.type_popList_dataMutArr)
               .JobsBlock1(^(UITableViewCell __kindof * _Nullable data){
                   @jobs_strongify(self)
                   self.type_textField.placeholder = data.viewModel.text;
               }));

消失（先消失，后展现）

[self tf_hide:^{
    ShowTips(ResetPWDSuccessPopView
             .BySize(ResetPWDSuccessPopView.viewSizeByModel(nil))
             .JobsRichViewByModel2(nil));
}];

10、关于`UIViewController`的一些配置回到顶部

10.1、`BaseViewController`

为了方便管理，理论上，全局只应有一个UIViewController。开发者不应该创建过多的子控制器
如果在BaseViewController无法满足的操作，应该提升到UIViewController的分类进行
最终形成BaseViewController背后是一系列的按照功能进行区分的子控制器。用户只需要对接BaseViewController即可
命名为BaseViewController也是充分考虑同业者的偏好习惯
正常情况下，在建立子控制器的时候，为了缩短命名，应该将ViewController命名为VC

在 BaseViewController 里面对导航栏进行二选一的使用

- (void)viewDidLoad {
    [super viewDidLoad];
#pragma mark —— JobsNavBar <BaseViewControllerProtocol> 仅做Demo演示
    self.makeNavBarConfig(nil,nil);
    self.navBar.backBtn.normalTitleColor(JobsWhiteColor);
    self.navBar.backBtn.jobsVisible = YES;
    self.navBar.jobsVisible = YES;
#pragma mark —— GKNavigationBar -(void)makeGKNavigationBarConfigure 仅做Demo演示
    self.gk_statusBarHidden = NO;
    self.setGKNav(nil);
    self.setGKNavBackBtn(nil);
    self.gk_navBackgroundColor = JobsWhiteColor;
    self.gk_navTitleFont = [UIFont systemFontOfSize:18 weight:UIFontWeightMedium];
    self.gk_navTitleColor = AppMainCor_01;
    self.gk_backStyle = GKNavigationBarBackStyleBlack;
    self.gk_navLineHidden = YES;
    self.gk_navRightBarButtonItem = JobsBarButtonItem(self.contactBtn);
    self.gk_navigationBar.jobsVisible = YES;
    @jobs_weakify(self)
    self.gk_navRightBarButtonItems = jobsMakeMutArr(^(NSMutableArray * _Nullable data) {
        @jobs_strongify(self)
        data.add(self.msgBtn);
        data.add(self.customerServiceBtn);
    });
}

classDiagram
    class BaseViewController
    class JobsBaseDataSettingVC
    class JobsDebugVC
    class JobsMonitorVC
    class JobsNavSettingVC
    class JobsStatusBarSetttingVC
    class JobsTabBarSettingVC
    class UIViewController

    BaseViewController <|-- JobsBaseDataSettingVC
    JobsBaseDataSettingVC <|-- JobsDebugVC
    JobsDebugVC <|-- JobsMonitorVC
    JobsMonitorVC <|-- JobsNavSettingVC
    JobsNavSettingVC <|-- JobsTabBarSettingVC

    UIViewController <|.. UIViewController_JXCategoryListContentViewDelegate
    UIViewController <|.. UIViewController_JXPagerViewListViewDelegate
    UIViewController <|.. UIViewController_XLBubbleTransition
    UIViewController <|.. UIViewController_MJRefresh
    UIViewController <|.. UIViewController_SafeTransition
    UIViewController <|.. UIViewController_JPImageresizerView
    UIViewController <|.. UIViewController_BackBtn
    UIViewController <|.. UIViewController_EmptyData
    UIViewController <|.. UIViewController_Shake
    UIViewController <|.. UIViewController_BaseVC
    UIViewController <|.. UIViewController_GifImageView
    UIViewController <|.. UIViewController_BaseNavigationBar
    UIViewController <|.. UIViewController_Lottie
    UIViewController <|.. UIViewController_SuspendBtn
    UIViewController <|.. UIViewController_TFPopupView

10.2、关于导航栏

10.2.1、`GKNavigationBar`

pod 'GKNavigationBar' # https://github.com/QuintGao/GKNavigationBar NO_SMP

#if __has_include(<GKNavigationBar/GKNavigationBar.h>)
#import <GKNavigationBar/GKNavigationBar.h>
#else
#import "GKNavigationBar.h"
#endif

self.setGKNav(nil);
self.setGKNavBackBtn(nil);
self.gk_navRightBarButtonItem = JobsBarButtonItem(self.contactBtn);
self.gk_navigationBar.jobsVisible = YES;

产生的背景和原因
- 系统原生的NavigationBar晦涩难懂不方便修改，很多人理解不深刻容易出问题
- 系统原生的NavigationBar有很多内部类（系统创建但不希望程序员进行直接访问的）。某些版本内部类的图层结构会用有所不同
- 第三方GKNavigationBar因为是分类实现，没有代码入侵性，更加的安全和方便
- 第三方GKNavigationBar更加契合国人的开发思维
一般情况下，需要禁用系统的UINavigationBar转而用 gk_navigationBar进行替代
分类实现，无代码入侵
gk_navigationBar没有做到对横屏模式的很好兼容，且没有办法自定义 gk_navigationBar的高度
对系统类做了扩充和兼容
- @interface UIBarButtonItem (GKNavigationBar)
- @interface UIImage (GKNavigationBar)
- @interface UINavigationController (GKNavigationBar)
- @interface UINavigationItem (GKNavigationBar)
- @interface UIViewController (GKNavigationBar)
- @interface GKCustomNavigationBar : UINavigationBar
在这个基础上进行的二次封装
- 关注实现类：@interface BaseViewController : UIViewController
- 关注实现类：@interface UIViewController (BaseVC)

10.2.2、`JobsNavBar`

适配横屏
内部含3个子控件：左按钮/中间的标题/右边的按钮。如果右边希望多个子控件按钮，获取JobsNavBar以后进行添加
可以自定义NavBar的高度
完全一个新的View，不涉及系统的UINavigationBar
以分类的方式集成在UIViewController层。关注实现类：@interface UIViewController (BaseVC)
以继承的方式集成在UIView层。关注实现类：@interface BaseView : UIView

配置并使用

self.makeNavBarConfig(nil,nil);
self.navBar.backBtn.normalTitleColor(JobsWhiteColor);
self.navBar.backBtn.jobsVisible = YES;
self.navBar.jobsVisible = YES;

-(UIButtonModel *)closeBtnModel{
    if(!_closeBtnModel){
        _closeBtnModel = UIButtonModel.new;
        _closeBtnModel.backgroundImage = JobsIMG(@"联系我们");
//        _closeBtnModel.selected_backgroundImage = JobsIMG(@"联系我们");
//        _closeBtnModel.normalImage = JobsIMG(@"联系我们");
//        _closeBtnModel.highlightImage = JobsIMG(@"联系我们");
//        _closeBtnModel.imagePadding = JobsWidth(5);
        _closeBtnModel.roundingCorners = UIRectCornerAllCorners;
        _closeBtnModel.baseBackgroundColor = JobsClearColor;
    }return _closeBtnModel;
}

/// 导航返回键的配置
-(UIButtonModel *)makeBackBtnModel{
    @jobs_weakify(self)
    return jobsMakeButtonModel(^(__kindof UIButtonModel * _Nullable data) {
        @jobs_strongify(self)
//        data.backgroundImage = JobsIMG(@"返回");
        data.selected_backgroundImage = JobsIMG(@"返回");
        data.highlightImage = JobsIMG(@"返回");
        data.normalImage = JobsIMG(@"返回");
        data.baseBackgroundColor = JobsClearColor.colorWithAlphaComponentBy(0);
        data.title = self.viewModel.backBtnTitleModel.text;
        data.font = self.viewModel.backBtnTitleModel.font;
        data.titleCor = JobsBlackColor;
        data.selected_titleCor = JobsBlackColor;
        data.roundingCorners = UIRectCornerAllCorners;
        data.imagePlacement = NSDirectionalRectEdgeLeading;
        data.imagePadding = JobsWidth(5);
    });
}

@synthesize backBtnModel = _backBtnModel;
-(UIButtonModel *)backBtnModel{
    if(!_backBtnModel){
        @jobs_weakify(self)
        _backBtnModel = self.makeBackBtnModel;
        _backBtnModel.titleFont = bayonRegular(JobsWidth(18));
        _backBtnModel.titleCor = JobsWhiteColor;
        _backBtnModel.selected_titleCor = JobsWhiteColor;
        _backBtnModel.longPressGestureEventBlock = ^id(__kindof UIButton *x) {
            JobsLog(@"按钮的长按事件触发");
            return nil;
        };
        _backBtnModel.clickEventBlock = ^id(BaseButton *x){
            @jobs_strongify(self)
            self.jobsBackBtnClickEvent(x);
            self.popToRootVCBy(YES);
            return nil;
        };
    }return _backBtnModel;
}

-(JobsReturnNavBarConfigByButtonModelBlock _Nonnull)makeNavBarConfig{
    @jobs_weakify(self)
    return ^(UIButtonModel *_Nullable backBtnModel,
             UIButtonModel *_Nullable closeBtnModel) {
        @jobs_strongify(self)
        JobsNavBarConfig *_navBarConfig = JobsNavBarConfig.new;
        _navBarConfig.bgCor = self.viewModel.navBgCor;
        _navBarConfig.bgImage = self.viewModel.navBgImage;
        _navBarConfig.attributedTitle = self.viewModel.backBtnTitleModel.attributedText;
        _navBarConfig.title = self.viewModel.textModel.text;
        _navBarConfig.font = self.viewModel.textModel.font;
        _navBarConfig.titleCor = self.viewModel.textModel.textCor;
        _navBarConfig.backBtnModel = backBtnModel ? : self.backBtnModel;
        _navBarConfig.closeBtnModel = closeBtnModel ? : self.closeBtnModel;
        self.navBarConfig = _navBarConfig;
        return _navBarConfig;
    };
}

10.3、推控制器

关注实现类：@interface NSObject (Extras)

/// 强制以Push的方式展现页面
/// @param toPushVC 需要进行展现的页面
/// @param requestParams 正向推页面传递的参数
/// 如果想用AppDelegate的自定义TabbarVC：
/// extern AppDelegate *appDelegate;
/// (UIViewController *)appDelegate.tabBarVC;
-(void)forceComingToPushVC:(UIViewController *_Nonnull)toPushVC
             requestParams:(id _Nullable)requestParams;
/// 强制以Present的方式展现页面
/// @param toPresentVC 需要进行展现的页面
/// @param requestParams 正向推页面传递的参数
/// @param completion 完成Present动作以后得动作
-(void)forceComingToPresentVC:(UIViewController *_Nonnull)toPresentVC
                requestParams:(id _Nullable)requestParams
                   completion:(void (^ __nullable)(void))completion;

关注实现类：@interface UIViewController (BaseVC)

#pragma mark —— present
/// 简洁版强制present展现一个控制器页面【不需要正向传参】
-(jobsByVCBlock _Nonnull)comingToPresentVC;
/// 简洁版强制present展现一个控制器页面【需要正向传参】
-(jobsByVCAndDataBlock _Nonnull)comingToPresentVCByRequestParams;
#pragma mark —— push
/// 简洁版强制push展现一个控制器页面【不需要正向传参】
-(jobsByVCBlock _Nonnull)comingToPushVC;
/// 简洁版强制push展现一个控制器页面【需要正向传参】
-(jobsByVCAndDataBlock _Nonnull)comingToPushVCByRequestParams;

/**
 ❤️【强制推控制器】❤️
 1、自定义是PUSH还是PRESENT展现控制器，如果自定义PUSH但是navigationController不存在，则换用PRESENT展现控制器
 2、定位于@implementation UINavigationController (SafeTransition)，交换系统的push方法，防止某些情况下系统资源紧张导致的多次推控制器
 @param fromVC 从A控制器（上一个页面）
 @param toVC  推到B控制器 （下一个页面）
 @param comingStyle 自定义展现的方式
 @param presentationStyle  如果是PRESENT情况下的一个系统参数设定
 @param requestParams  A控制器—>B控制器，正向传值
 @param hidesBottomBarWhenPushed 跳转子页面的时候隐藏tabbar
 @param animated  是否动画展现
 @param successBlock 在推控制器之前，反向block(B控制器），以便对B控制器的一些自定义修改
 */
+(instancetype _Nullable)comingFromVC:(UIViewController *_Nonnull)fromVC
                                 toVC:(UIViewController *_Nonnull)toVC
                          comingStyle:(ComingStyle)comingStyle
                    presentationStyle:(UIModalPresentationStyle)presentationStyle
                        requestParams:(id _Nullable)requestParams
             hidesBottomBarWhenPushed:(BOOL)hidesBottomBarWhenPushed
                             animated:(BOOL)animated
                              success:(jobsByIDBlock _Nullable)successBlock;

10.4、`UIViewController`转场动画的使用方法

关注实现类：@interface UIViewController (XLBubbleTransition)

10.5、悬浮视图

以分类的方式，定义在view层，针对全局所有的UIView *
- 关注实现类：@interface UIViewController (SuspendBtn)
- 关注实现类：@interface UIView (SuspendView)

使用方法

在需要作用的UIView的子类

关键代码（外界传进来的，父承接的VC）：self.vc = self.vcer;
关键代码（是否允许拖动手势 = isAllowDrag）：self.panRcognize.enabled = YES;

-(void)drawRect:(CGRect)rect{
     [super drawRect:rect];
	   //开启悬浮效果
     if (self.isSuspend) {
         self.vc = self.vcer;//外界传进来的，父承接的VC
         self.panRcognize.enabled = YES;
     }else{
         self.vc = nil;
     }
 }

在某个控制器上添加某个悬浮视图（按钮为例）

关键代码：self.view.vc = weak_self;
关键代码（悬浮效果必须要的参数）：SuspendBtn.isAllowDrag = YES;

-(JobsSuspendBtn *)suspendBtn{
    JobsSuspendBtn *SuspendBtn = Jobs_getAssociatedObject(_suspendBtn);
    if (!SuspendBtn) {
        SuspendBtn = JobsSuspendBtn.new;
        SuspendBtn.normalImage = JobsIMG(@"旋转");
        SuspendBtn.isAllowDrag = YES;//悬浮效果必须要的参数
        @jobs_weakify(self)
        [SuspendBtn jobsBtnClickEventBlock:^id(UIButton *x) {
            @jobs_strongify(self)
            x.selected = !x.selected;
            NSLog(@"%@",x.selected ? JobsInternationalization(@"开始旋转") : JobsInternationalization(@"停止旋转"));
//            [x rotateAnimation:x.selected];
            if (self.objectBlock) self.objectBlock(x);
            return nil;
        }];
        self.view.vc = weak_self;
        [self.view addSubview:SuspendBtn];
        SuspendBtn.frame = CGRectMake(JobsMainScreen_WIDTH(nil) - JobsWidth(50) - JobsWidth(5),
                                      JobsMainScreen_HEIGHT(nil) - JobsTabBarHeightByBottomSafeArea(nil) - JobsWidth(100),
                                      JobsWidth(50),
                                      JobsWidth(50));
        [SuspendBtn cornerCutToCircleWithCornerRadius:SuspendBtn.width / 2];
        Jobs_setAssociatedRETAIN_NONATOMIC(_suspendBtn, SuspendBtn)
    }return SuspendBtn;
}

10.6、防止过多的`presented`模态推出`UIViewController`

关注实现类：@interface UIViewController (SafeTransition)

10.7、寻找当前控制器

关注实现类：@interface NSObject (Extras)

/// 从一个视图（UIView）出发，获取它所在的视图控制器（UIViewController）
-(JobsReturnVCByView _Nonnull)getViewControllerByView;
/// 获得当前的控制器。对getCurrentViewController的再次封装
-(UIViewController *_Nullable)jobsGetCurrentViewController;
/// 获得当前的控制器
-(UIViewController *_Nullable)getCurrentViewController;
/// 获得当前控制器的根控制器
-(JobsReturnVCByVC _Nullable )getCurrentViewControllerByRootVC;

关注实现类：@interface UIView (ViewController)
```
-(UIViewController *_Nullable)currentController;
```

11、`KVC`的封装回到顶部

关注实现类：@interface NSObject (Extras)

存值

-(jobsByKey_ValueBlock _Nonnull)jobsKVC;

取值

-(JobsReturnIDByIDBlock _Nonnull)valueForKeyBlock;

使用方法

/// 存值
UIImageView *headIcon = UIImageView.new;
headIcon.jobsKVC(@"name", @"John Doe");
/// 取值
UIImageView *headIcon = self.valueForKeyBlock(@"headIcon");/// 账户头像

12、键盘监听回到顶部

关注实现类：@implementation NSObject (Extras)

-(void)keyboardByUpBlock:(jobsByNSNotificationKeyboardModelBlock _Nullable)upBlock
               downBlock:(jobsByNSNotificationKeyboardModelBlock _Nullable)downBlock{
    [self addNotificationName:UIKeyboardWillChangeFrameNotification
                        block:^(id _Nullable weakSelf,
                                id _Nullable arg) {
        NSNotification *notification = (NSNotification *)arg;
        NSLog(@"通知传递过来的 = %@",notification.object);
        NSNotificationKeyboardModel *model = jobsMakeNotificationKeyboardModel(^(NSNotificationKeyboardModel * _Nullable data) {
            data.userInfo = notification.userInfo;
            data.beginFrame = [notification.userInfo[UIKeyboardFrameBeginUserInfoKey] CGRectValue];
            data.endFrame = [notification.userInfo[UIKeyboardFrameEndUserInfoKey] CGRectValue];
            data.keyboardOffsetY = data.beginFrame.origin.y - data.endFrame.origin.y;// 正则抬起 ，负值下降
            data.notificationName = UIKeyboardWillChangeFrameNotification;
        });
        NSLog(@"KeyboardOffsetY = %f", model.keyboardOffsetY);
        if (model.keyboardOffsetY > 0) {
            NSLog(@"键盘抬起");
            if (upBlock) upBlock(model);
        }else if(model.keyboardOffsetY < 0){
            NSLog(@"键盘收回");
            if (downBlock) downBlock(model);
        }else{
            NSLog(@"键盘");
        }
    }];
}

[self keyboardByUpBlock:^(NSNotificationKeyboardModel * _Nullable data) {
    NSLog(@"");
} downBlock:^(NSNotificationKeyboardModel * _Nullable data) {
    NSLog(@"");
}];

13、iOS 状态栏颜色的修改回到顶部

13.1、颜色的修改

全局修改

在Info.plist里面加入如下键值对

<!-- iOS 状态栏颜色的修改【全局设置 全局是NO、局部是YES】View controller-based status bar appearance : NO-->
<key>UIViewControllerBasedStatusBarAppearance</key>
<false/>
<!-- iOS 状态栏颜色的修改【全局设置】Status bar style : Light Content-->
<key>UIStatusBarStyle</key>
<string>UIStatusBarStyleLightContent</string>

UIApplication.sharedApplication.statusBarStyle = UIStatusBarStyleLightContent;// iOS 13 后方法被标注废弃

局部修改

<!-- iOS 状态栏颜色的修改【全局设置 全局是NO、局部是YES】View controller-based status bar appearance : NO-->
<key>UIViewControllerBasedStatusBarAppearance</key>
<true/>

关注实现类：@interface BaseNavigationVC : UINavigationController

在 BaseNavigationVC.m里面写入

- (UIViewController *)childViewControllerForStatusBarStyle {
    return self.topViewController;
}

在具体的需要修改的VC.m里面写入

-(UIStatusBarStyle)preferredStatusBarStyle{
    return UIStatusBarStyleLightContent;
}

13.2、状态栏的隐藏（默认显示）

全局隐藏

UIViewControllerBasedStatusBarAppearance

UIStatusBarHidden


* 在某个特定的视图控制器中隐藏状态栏。重写视图控制器的`- (BOOL)prefersStatusBarHidden`方法

```objective-c
- (BOOL)prefersStatusBarHidden {
    return YES;
}

动态隐藏（已经在 iOS 9.0 后被废弃）

[UIApplication.sharedApplication setStatusBarHidden:YES withAnimation:UIStatusBarAnimationSlide];

13.3、状态栏高度的封装

14、对`NSUserDefaults.standardUserDefaults` 的二次封装回到顶部

14.1、使用宏定义对`NSUserDefaults.standardUserDefaults` 的二次封装

关注实现类：JobsUserDefaultDefine.h
存数据
- 设置 UserDefault 值（Value）
```
JobsSetUserDefaultKeyWithValue
```
- 设置 UserDefault 对象（Object）
```
JobsSetUserDefaultKeyWithObject
```
- 设置 UserDefault 布尔值（Bool）
```
JobsSetUserBoolKeyWithBool
```
- 设置 UserDefault 整数值（Integer）
```
JobsSetUserDefaultKeyWithInteger
```
- 设置 UserDefault 浮点数值（Float）
```
JobsSetUserDefaultKeyWithFloat
```
- 设置 UserDefault 双精度浮点数值（Double）
```
JobsSetUserDefaultKeyWithDouble
```
- 设置 UserDefault URL（URL）
```
JobsSetUserDefaultKeyWithURL
```
读取数据
- 获取 UserDefault 值（Value）
```
JobsGetUserDefaultValueForKey
```
- 获取 UserDefault 对象（Object）
```
JobsGetUserDefaultObjForKey
```
- 获取 UserDefault 布尔值（Bool）
```
JobsGetUserDefaultBoolForKey
```
- 获取 UserDefault 整数值（Integer）
```
JobsGetUserDefaultIntegerForKey
```
- 获取 UserDefault 浮点数值（Float）
```
JobsGetUserDefaultFloatForKey
```
- 获取 UserDefault 双精度浮点数值（Double）
```
JobsGetUserDefaultDoubleForKey
```
- 获取 UserDefault URL（URL）
```
JobsGetUserDefaultURLForKey
```
删除数据
```
JobsDeleUserDefaultWithKey
```

其他

单例对象
```
JobsUserDefaults
```
同步 NSUserDefaults
```
JobsUserDefaultSynchronize
```

14.2、以分类的形式对`NSUserDefaults.standardUserDefaults` 的二次封装

关注实现类：@interface NSUserDefaults (Manager)
存数据（包括父类直到NSObject的所有属性）。将数据封装到对象UserDefaultModel里面进行存取
```
+(jobsByUserDefaultModelBlock)updateWithModel;
```

读取数据

+(JobsReturnIDByStringBlock)readWithKey;

删除数据
```
+(jobsByStringBlock)deleteWithKey;
```

15、对小型本地化数据的读取（`NSUserDefaults`）回到顶部

产生背景：方便临时调试，避免打印输出
关注Demo实现类：@interface JobsShowObjInfoVC : BaseViewController
因为是小型化的一些临时数据，所以数据本地化方案选用的是NSUserDefaults.standardUserDefaults

数据来源JobsUserModel。用key = 用户信息进行存取

/// 读取用户信息
-(JobsReturnUserModelByVoidBlock)readUserInfo{
    @jobs_weakify(self)
    return ^() {
        @jobs_strongify(self)
        return [self readUserInfoByUserName:用户信息];
    };
}

16、视频播放器回到顶部

关注实现类：@interface UIView (ZFPlayer)

Podfile

pod 'ZFPlayer' # https://github.com/renzifeng/ZFPlayer
pod 'ZFPlayer/ControlView'
pod 'ZFPlayer/AVPlayer'
pod 'ZFPlayer/ijkplayer'
#  pod 'KTVHTTPCache' # 边下边播
#  pod 'VIMediaCache' # https://github.com/vitoziv/VIMediaCache 边下边播

17、动画相关回到顶部

Podfile

pod 'lottie-ios', '~> 2.5.3' # 这是OC终极版本 https://github.com/airbnb/lottie-ios

关注实现类：@interface UIView (Animation)

18、手势封装回到顶部

封装方式1：所有的手势都是在View上添加以及触发的

self.addGesture([jobsMakeTapGesture(^(UITapGestureRecognizer * _Nullable gesture) {
    ///  这里写手势的配置
}) gestureActionBy:^{
    /// 这里写手势的触发
}]);

封装方式2：

 UITapGestureRecognizer *tapGesture = UITapGestureRecognizer.rac_recognizer;
 [tapGesture.rac_gestureSignal subscribeNext:^(__kindof UIGestureRecognizer * _Nullable gesture) {
     NSLog(@"");
 }];
 self.topBar.addGesture(tapGesture);

封装方式3：

因为手势传递是在view层。所以对其进行了一次封装。关注实现类：@interface UIView (Gesture)

{
    _adView.numberOfTouchesRequired = 1;
    _adView.numberOfTapsRequired = 1;/// ⚠️注意：如果要设置长按手势，此属性必须设置为0⚠️
    _adView.minimumPressDuration = 0.1;
    _adView.numberOfTouchesRequired = 1;
    _adView.allowableMovement = 1;
    _adView.userInteractionEnabled = YES;
    _adView.target = self;/// ⚠️注意：任何手势这一句都要写

    {
        _adView.longPressGR_SelImp.selector = [self jobsSelectorBlock:^id _Nullable(id  _Nullable weakSelf,
                                                                                    UILongPressGestureRecognizer *  _Nullable arg) {
           NSLog(@"长按手势被触发");
           return nil;
        }];
        _adView.longPressGR.enabled = YES;/// 必须在设置完Target和selector以后方可开启执行
    }

    {
        _adView.tapGR_SelImp.selector = [self jobsSelectorBlock:^id _Nullable(id  _Nullable target,
                                                                              UITapGestureRecognizer *_Nullable arg) {
           NSLog(@"单击手势被触发");
           return nil;
        }];
        _adView.tapGR.enabled = YES;/// 必须在设置完Target和selector以后方可开启执行
    }

    {
        _adView.doubleTapGR_SelImp.selector = [self jobsSelectorBlock:^id _Nullable(id  _Nullable target, UITapGestureRecognizer *_Nullable arg) {
            NSLog(@"双击手势被触发");
            return nil;
        }];
        _adView.doubleTapGR.enabled = YES; // 必须在设置完Target和selector以后方可开启执行
    }
}

19、富文本回到顶部

富文本是告诉系统，某段文字的表达方式。其本质是一个带配置信息的字符串
关注实现类

#pragma mark —— 创建不可变富文本
NS_INLINE NSAttributedString *_Nonnull JobsAttributedString(NSString *_Nonnull data) {
    if (!data) data = @"";
    return [NSAttributedString.alloc initWithString:data];
}

NS_INLINE NSAttributedString *_Nonnull JobsAttributedStringByAttributes(NSString *_Nonnull data,
                                                                             NSDictionary<NSAttributedStringKey, id> *_Nullable attrs){
    if (!data) data = @"";
    return [NSAttributedString.alloc initWithString:data attributes:attrs];
}

NS_INLINE NSAttributedString *_Nonnull JobsAttributedStringByAttributeString(NSAttributedString *_Nullable data){
    if (!data) data = JobsAttributedString(@"");
    return [NSAttributedString.alloc initWithAttributedString:data];
}

NS_INLINE NSAttributedString *_Nonnull JobsAttributedStringByTextAttachment(NSTextAttachment *_Nonnull data) {
    if (!data) data = NSTextAttachment.alloc.init;
    return [NSAttributedString attributedStringWithAttachment:data];
}
#pragma mark —— 创建可变富文本
NS_INLINE NSMutableAttributedString *_Nonnull toMutAttributedString(NSAttributedString *_Nonnull data) {
    if(!data) data = JobsAttributedString(@"");
    return [NSMutableAttributedString.alloc initWithAttributedString:data];
}

NS_INLINE NSMutableAttributedString *_Nonnull JobsMutAttributedStringByAttributes(NSString *_Nonnull data,
                                                                             NSDictionary<NSAttributedStringKey, id> * _Nullable attrs){
    return toMutAttributedString(JobsAttributedStringByAttributes(data,attrs));
}

NS_INLINE NSMutableAttributedString *_Nonnull JobsMutAttributedString(NSString *_Nonnull data) {
    return toMutAttributedString(JobsAttributedString(data));
}

NS_INLINE NSMutableAttributedString *_Nonnull JobsMutAttributedStringByTextAttachment(NSTextAttachment *_Nonnull data) {
    if (!data) data = NSTextAttachment.alloc.init;
    return toMutAttributedString(JobsAttributedStringByTextAttachment(data));
}

富文本的简单调用（带段落信息）

@property(nonatomic,strong,nullable)NSAttributedString *attributedText API_AVAILABLE(ios(6.0));
#pragma mark —— 富文本
@synthesize attributedText = _attributedText;
-(NSAttributedString *)attributedText{
    if (!_attributedText) {
        @jobs_weakify(self)
        _attributedText = self.richTextWithDataConfigMutArr(jobsMakeMutArr(^(__kindof NSMutableArray <JobsRichTextConfig *>*_Nullable data) {
            data.add(jobsMakeRichTextConfig(^(__kindof JobsRichTextConfig * _Nullable data1) {
                @jobs_strongify(self)
                data1.font = UIFontWeightRegularSize(JobsWidth(12));
                data1.textCor = JobsBlueColor;
                data1.targetString = JobsInternationalization(@"编译器自动管理内存地址").add(@"\n");
                data1.textBgCor = JobsBrownColor;
                data1.paragraphStyle = jobsMakeParagraphStyle(^(NSMutableParagraphStyle * _Nullable data2) {
                    data2.alignment = NSTextAlignmentJustified;
                    data2.paragraphSpacing = 0;//段距，取值 float
                    data2.paragraphSpacingBefore = 0;//段首空间，取值 float
                    data2.firstLineHeadIndent = 0.0;//首行缩进，取值 float
                    data2.headIndent = 0.0;//整体缩进(首行除外)，取值 float
                    data2.lineSpacing = 0;//行距，取值 float
                });
            }));
            data.add(jobsMakeRichTextConfig(^(__kindof JobsRichTextConfig * _Nullable data1) {
                @jobs_strongify(self)
                data1.font = UIFontWeightSemiboldSize(JobsWidth(13));
                data1.textCor = JobsWhiteColor;
                data1.targetString = JobsInternationalization(@"让程序员更加专注于").add(@"\n");
                data1.textBgCor = JobsBrownColor;
                data1.paragraphStyle = jobsMakeParagraphStyle(^(NSMutableParagraphStyle * _Nullable data2) {
                    data2.alignment = NSTextAlignmentJustified;
                    data2.paragraphSpacing = 0;//段距，取值 float
                    data2.paragraphSpacingBefore = 0;//段首空间，取值 float
                    data2.firstLineHeadIndent = 0.0;//首行缩进，取值 float
                    data2.headIndent = 0.0;//整体缩进(首行除外)，取值 float
                    data2.lineSpacing = 0;//行距，取值 float
                });
            }));
            data.add(jobsMakeRichTextConfig(^(__kindof JobsRichTextConfig * _Nullable data1) {
                @jobs_strongify(self)
                data1.font = UIFontWeightUltraLightSize(JobsWidth(14));
                data1.textCor = JobsGreenColor;
                data1.targetString = JobsInternationalization(@"APP的业务。");
                data1.textBgCor = JobsBrownColor;
                data1.paragraphStyle = jobsMakeParagraphStyle(^(NSMutableParagraphStyle * _Nullable data2) {
                    data2.alignment = NSTextAlignmentJustified;
                    data2.paragraphSpacing = 0;//段距，取值 float
                    data2.paragraphSpacingBefore = 0;//段首空间，取值 float
                    data2.firstLineHeadIndent = 0.0;//首行缩进，取值 float
                    data2.headIndent = 0.0;//整体缩进(首行除外)，取值 float
                    data2.lineSpacing = 0;//行距，取值 float
                });
            }));
        }));
    }return _attributedText;
}

富文本的复杂调用：富文本实现文本前面有个小圆点的效果

公共部分

@property(nonatomic,strong)UILabel *label;
@property(nonatomic,strong)NSMutableParagraphStyle *paragraphStyle;

-(UILabel *)label{
    if(!_label){
        _label = UILabel.new;
        _label.backgroundColor = JobsRandomColor;
        _label.attributedText = self.attributedString;
        _label.numberOfLines = 0;
        [self.view addSubview:_label];
        [_label mas_makeConstraints:^(MASConstraintMaker *make) {
            make.width.mas_equalTo(200);
            make.center.equalTo(self.view);
        }];
        _label.makeLabelByShowingType(UILabelShowingType_05);
        [self.view addSubview:_label];
    }return _label;
}

-(NSMutableParagraphStyle *)paragtaphStyle{
    if (!_paragtaphStyle) {
        _paragtaphStyle = jobsMakeParagraphStyle(^(__kindof NSMutableParagraphStyle * _Nullable data) {
            data.alignment = NSTextAlignmentJustified;
            data.paragraphSpacing = 0;//段距，取值 float
            data.paragraphSpacingBefore = 0;//段首空间，取值 float
            data.firstLineHeadIndent = 0.0;//首行缩进，取值 float
            data.headIndent = 0.0;//整体缩进(首行除外)，取值 float
            data.lineSpacing = 0;//行距，取值 float
        });   
    }return _paragtaphStyle;
}

方法1：不能定义点的尺寸大小

@property(nonatomic,strong)NSMutableAttributedString *attributedString;
@property(nonatomic,copy)NSString *dot;

-(NSMutableAttributedString *)attributedString{
    if(!_attributedString){
        _attributedString = jobsMakeMutableAttributedString(^(__kindof NSMutableAttributedString *_Nullable data) {
            data.add(JobsAttributedString(self.dot
                                          .add(@"我是中国人我是中国人我是中国人我是中国人我是中国人我是中国人")
                                          .add(@"\n")));
                                                           
            data.add(JobsAttributedString(self.dot
                                          .add(@"你是日本人你是日本人你是日本人你是日本人你是日本人你是日本人")
                                          .add(@"\n")));
            /// 设置段落
            data.addAttributeNameByParagraphStyleModel(jobsMakeParagraphStyleModel(^(__kindof JobsParagraphStyleModel * _Nullable data) {
                data.value = jobsMakeParagraphStyle(^(NSMutableParagraphStyle * _Nullable data1) {
                    data1.headIndent = 10; // 设置文本的缩进，使其与圆点对齐
                    data1.firstLineHeadIndent = 0; // 第一行不缩进
                });
                data.range = NSMakeRange(0, self.attributedString.length);
            }));
            /// 设置小圆点的颜色
            data.addForegroundColorAttributeNameByParagraphStyleModel(jobsMakeParagraphStyleModel(^(__kindof JobsParagraphStyleModel * _Nullable data1) {
                data1.value = JobsRedColor;
                data1.range = NSMakeRange(0, 1);// 第一个圆点
            }));
            data.addForegroundColorAttributeNameByParagraphStyleModel(jobsMakeParagraphStyleModel(^(__kindof JobsParagraphStyleModel * _Nullable data1) {
                data1.value = JobsYellowColor;
                data1.range = NSMakeRange(@"我是中国人我是中国人我是中国人我是中国人我是中国人我是中国人".add(@"\n").length + 1, 1);// 第二个圆点
            }));
            /// 设置文本颜色
            data.addForegroundColorAttributeNameByParagraphStyleModel(jobsMakeParagraphStyleModel(^(__kindof JobsParagraphStyleModel * _Nullable data1) {
                data1.value = JobsCor(@"#D0D0D0");
                data1.range = NSMakeRange(1, data.length - 1);
            }));
            data.addFontAttributeNameByParagraphStyleModel(jobsMakeParagraphStyleModel(^(__kindof JobsParagraphStyleModel * _Nullable data1) {
                data1.value = UIFontWeightRegularSize(JobsWidth(12));
                data1.range = NSMakeRange(0, data.length);
            }));
        });
    }return _attributedString;
}

-(NSString *)dot{
    if(!_dot){
        _dot = @"\u2022";// @"⚫";
    }return _dot;
}

方法2：利用NSTextAttachment *，可以定义圆点的大小

@property(nonatomic,strong)NSMutableAttributedString *attributedString2;
@property(nonatomic,strong)NSTextAttachment *bulletAttachment;
@property(nonatomic,strong)NSMutableArray<NSString *> *items;/// 数据源

-(NSMutableAttributedString *)attributedString2{
    if(!_attributedString2){
        _attributedString2 = JobsMutAttributedString(@"");
        // 通过循环来创建每一行的富文本
        for (NSString *item in self.items) {
            // 添加小圆点
            NSAttributedString *bulletPoint = JobsAttributedStringByTextAttachment(self.bulletAttachment);
            _attributedString2.add(bulletPoint);
            // 添加空格后再添加文本
            NSAttributedString *space = JobsAttributedString(@" ");
            _attributedString2.add(space);
            // 添加对应的文本
            NSMutableAttributedString *text = JobsMutAttributedString(item);
            [text addAttribute:NSFontAttributeName
                         value:UIFontWeightRegularSize(JobsWidth(12))
                         range:NSMakeRange(0, text.length)];
            [text addAttribute:NSForegroundColorAttributeName
                         value:JobsCor(@"#D0D0D0")
                         range:NSMakeRange(0, text.length)];
            _attributedString2.add(text);
            // 添加换行符
            NSAttributedString *newline = JobsAttributedString(@"\n");
            _attributedString2.add(newline);
        }
        [_attributedString2 addAttribute:NSParagraphStyleAttributeName
                                   value:self.paragraphStyle
                                   range:NSMakeRange(0, _attributedString2.length)];
    }return _attributedString2;
}

-(NSTextAttachment *)bulletAttachment{
    if(!_bulletAttachment){
        _bulletAttachment = jobsMakeTextAttachment(^(NSTextAttachment * _Nullable data) {
            data.bounds = CGRectMake(0, 0, 10, 10); // 设置圆点的大小和位置
            
            UIGraphicsBeginImageContextWithOptions(data.bounds.size, NO, 0);
            [JobsRedColor setFill];// 设置圆点的颜色
            [[UIBezierPath bezierPathWithOvalInRect:data.bounds] fill];
            data.image = UIGraphicsGetImageFromCurrentImageContext();
            UIGraphicsEndImageContext();
        });
    }return _bulletAttachment;
}

-(NSMutableArray<NSString *> *)items{
    if(!_items){
        _items = jobsMakeMutArr(^(__kindof NSMutableArray * _Nullable data) {
            data.add(@"Your deposit will be successfully credited to your wallet once the transaction completed.");
            data.add(@"In case you meet any problem in deposit, please contact our CS.");
            data.add(@"Additional information can be found on our website.");
        });
    }return _items;
}

如果要实现富文本某段文字的点击事件的监听，此时的承接控件不能是**UILabel，而应该换成UITextView，并实现其相应的**方法

注意：**UITextView不像UITextField**一样有Placeholder，为了延续使用习惯则引入第三方

pod 'UITextView+Placeholder' # https://github.com/devxoul/UITextView-Placeholder A missing placeholder for UITextView.
#import "UITextView+Placeholder.h"

 -(UITextView *)tipsTextView{
     if (!_tipsTextView) {
         @jobs_weakify(self)
         _tipsTextView = jobsMakeTextView(^(__kindof UITextView * _Nullable textView) {
             @jobs_strongify(self)
             textView.delegate = self;
             textView.editable = NO;/// 必须禁止输入，否则点击将会弹出输入键盘
             textView.scrollEnabled = NO;/// 可选的，视具体情况而定
             textView.linkTextAttributes = @{NSForegroundColorAttributeName:HEXCOLOR(0xCCB17E)};/// 链接文字颜色
             textView.attributedText = self.attributedStringData;
             textView.userInteractionEnabled = YES;
             self.contentView.addSubview(textView);
             [textView mas_makeConstraints:^(MASConstraintMaker *make) {
                 make.size.mas_equalTo(CGSizeMake(JobsMainScreen_WIDTH(), JobsWidth(30)));
                 make.centerX.equalTo(self.contentView);
                 make.bottom.equalTo(self.contentView).offset(-JobsWidth(38));
             }];
         });
     }return _tipsTextView;
 }

UITextViewDelegate

iOS 17 之后弃用

/// 点击事件监听
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdeprecated-declarations"
-(BOOL)textView:(UITextView *)textView
shouldInteractWithURL:(NSURL *)URL
inRange:(NSRange)characterRange
interaction:(UITextItemInteraction)interaction {
    self.jobsToastMsg(JobsInternationalization(@"专属客服"));
    return YES;
}
#pragma clang diagnostic pop

iOS 17 之后使用

/// 如果你只需要在用户点击URL时执行一个动作，可以使用primaryActionForTextItem:方法。这个方法允许你为指定的文本项（如URL）提供自定义的操作。
- (nullable UIAction *)textView:(UITextView *)textView
       primaryActionForTextItem:(UITextItem *)textItem
                  defaultAction:(UIAction *)defaultAction {
    if (KindOfTextItemCls(textItem) && [textItem.link isEqual:@"你的URL".jobsUrl]) {
        return [UIAction actionWithTitle:@"专属客服"
                                   image:nil
                              identifier:nil
                                 handler:^(__kindof UIAction * _Nonnull action) {
            self.jobsToastMsg(JobsInternationalization(@"专属客服"));
        }];
    }return defaultAction; // 默认行为
}
/// 如果你希望显示一个自定义菜单而不是直接执行一个动作，可以使用menuConfigurationForTextItem:方法。
- (nullable UITextItemMenuConfiguration *)textView:(UITextView *)textView
                      menuConfigurationForTextItem:(UITextItem *)textItem
                                       defaultMenu:(UIMenu *)defaultMenu {
    if (KindOfTextItemCls(textItem) && [textItem.link isEqual:@"你的URL".jobsUrl]) {
        UIAction *customAction = [UIAction actionWithTitle:JobsInternationalization(@"专属客服")
                                                     image:nil
                                                identifier:nil
                                                   handler:^(__kindof UIAction * _Nonnull action) {
            self.jobsToastMsg(JobsInternationalization(@"专属客服"));
        }];
        UIMenu *customMenu = [UIMenu menuWithTitle:@"" children:@[customAction]];
        return [UITextItemMenuConfiguration configurationWithMenu:customMenu];
    }return nil; // 默认菜单
}

20、时间戳的处理回到顶部

时间为2024-12-05 15:30:00（北京时间，UTC+8）。秒级时间戳：1701761400 毫秒级别时间戳：1701761400000 其对应的 NSTimeInterval timeInterval : 1701761400.0

字符串时间戳转化为可读

@"1701761400000".readableTimeByFormatter(@"yyyy-MM-dd");
@"1701761400".readableTimeByFormatter(@"yyyy-MM-dd");

NSDate类型的时间转化为可读

NSDate.date.toReadableTime(jobsMakeDateFormatter(^(__kindof NSDateFormatter * _Nullable dateFormatter) {
              data.dateFormat = @"yyyy"
                  .add(@"-")
                  .add(@"MM");
          }));

NSDate.date.toReadableTimeBy(@"yyyy".add(@"-").add(@"MM"));

NSTimeInterval 类型的时间转化为可读（无论是秒级还是毫秒级时间戳，经过必要的处理后，最终的 NSTimeInterval 都是相同的）
```
self.toReadableTimeBy(timeInterval);
或者:
self.dateByTimeInterval(111).toReadableTime(nil);
```

21、字符串定义回到顶部

在*.h文件中定义

FOUNDATION_EXTERN NSString *const 皇冠符号;

在*.m文件中定义

NSString *const 皇冠符号 = @"♚　♛　♝　♞　♜　♟　♔　♕　♗　♘　♖　♟";

在*.h文件中定义

extern NSString *const UserDefaultKey_AppLanguage;

在*.m文件中定义

NSString *const UserDefaultKey_AppLanguage = @"AppLanguage";

22、万物回调回到顶部

产生背景：点击事件的带参回调
关注实现类：@interface NSObject (CallBackInfoByBlock)

调用情况

-(void)touchesBegan:(NSSet<UITouch *> *)touches
          withEvent:(UIEvent *)event{
    if (self.objectBlock) self.objectBlock(@1);
}

@jobs_weakify(self)
[headerView actionObjectBlock:^(id data) {
  @jobs_strongify(self)
}];

23、系统相机相册调取回到顶部

借助第三方HXPhotoPicker

pod 'HXPhotoPicker' # 相册选择 https://github.com/SilenceLove/HXPhotoPicker

#if __has_include(<HXPhotoPicker/HXPhotoPicker.h>)
#import <HXPhotoPicker/HXPhotoPicker.h>
#else
#import "HXPhotoPicker.h"
#endif

对第三方HXPhotoPicker的数据层进行二次封装，方便调用
- 关注实现类：@interface HXPhotoPickerModel : NSObject
- 关注实现类：@interface NSObject (HXPhotoPicker)

需要对info.plist 文件进行相应字段的配置。系统需要主动索取用户权限。如果未授权，则以下代码将会调用失败

<string>$(NSPhotoLibraryAddUsageDescription)</string><!-- 我们需要获取你的相册权限以完成选择本地图片功能 -->
<key>NSPhotoLibraryUsageDescription</key>
<string>$(NSPhotoLibraryUsageDescription)</string><!-- 我们需要获取你的相册权限以完成选择本地图片功能 -->
<key>NSRemindersUsageDescription</key>

调取系统相册

@property(nonatomic,strong)NSMutableArray <UIImage *>*photosImageMutArr;

[_photoAlbumBtn jobsBtnClickEventBlock:^id(id data) {
    /// 调取系统相册
    @jobs_weakify(self)
    [self invokeSysPhotoAlbumSuccessBlock:^(HXPhotoPickerModel *data) {
        self.photoManager = data.photoManager;
        [data.photoList hx_requestImageWithOriginal:NO
                                         completion:^(NSArray<UIImage *> * _Nullable imageArray,
                                                      NSArray<HXPhotoModel *> * _Nullable errorArray) {
            @jobs_strongify(self)
            self.photosImageMutArr = [NSMutableArray arrayWithArray:imageArray];
            self.imageView.image = (UIImage *)self.photosImageMutArr.lastObject;/// 永远值显示最后选择的图
        }];
    } failBlock:^(HXPhotoPickerModel *data) {
        @jobs_strongify(self)
    }];return nil;
}];

调取系统相机（没有兼容横屏）

@jobs_weakify(self)
[_cameraBtn jobsBtnClickEventBlock:^id(id data) {
    /// 调取系统相机（没有兼容横屏）
    [self invokeSysCameraSuccessBlock:^(HXPhotoPickerModel *data) {
        @jobs_strongify(self)
        self.imageView.image = data.photoModel.previewPhoto;
    } failBlock:^(HXPhotoPickerModel *data) {
        @jobs_strongify(self)
    }];return nil;
}];

24、完整的单例写法回到顶部

在 OC中，static 关键字用于声明静态变量。这些变量在整个应用程序的生命周期内只会被初始化一次，并且它们的作用域仅限于定义它们的文件
在单例实现中，如果覆盖了 allocWithZone:应该确保初始化方法也使用这个覆盖的方法进行实例化
单例宏：关注文件 MacroDef_Singleton.h

以GCD的方式实现

dispatch_once_t 是 GCD（Grand Central Dispatch）提供的一种机制，用于确保某段代码在应用程序的生命周期内只执行一次。它是线程安全的，适用于多线程环境
JobsCustomTabBarVCOnceToken为0才会进dispatch_once

static JobsCustomTabBarVC *JobsCustomTabBarVCInstance = nil;
static dispatch_once_t JobsCustomTabBarVCOnceToken;

+ (instancetype)sharedManager {
    dispatch_once(&JobsCustomTabBarVCOnceToken, ^{
				if(!JobsCustomTabBarVCInstance){
            JobsCustomTabBarVCInstance = [super allocWithZone:NULL].init;
        }
    });return JobsCustomTabBarVCInstance;
}

+ (void)destroyInstance {
    JobsCustomTabBarVCInstance = nil;
    JobsCustomTabBarVCOnceToken = 0;
}
/// 防止外部使用 alloc/init 等创建新实例
+ (instancetype)allocWithZone:(struct _NSZone *)zone {
    return [self sharedManager];
}
/// 防止外部使用 alloc/init 等创建新实例
- (instancetype)copyWithZone:(NSZone *)zone {
    return self;
}
/// 防止外部调用copy
- (instancetype)mutableCopyWithZone:(NSZone *)zone {
    return self;
}

以@synchronized的方式实现

@synchronized关键字用于实现线程安全,它确保一段代码在同一时间内只能被一个线程执行，从而防止多个线程同时访问和修改共享资源，避免数据竞争和不一致性问题

static JobsCustomTabBarVC *JobsCustomTabBarVCInstance = nil;

+ (instancetype)sharedManager {
    @synchronized (self) {
        if (JobsCustomTabBarVCInstance == nil) {
            JobsCustomTabBarVCInstance = [[super allocWithZone:NULL] init];
        }
    }
    return JobsCustomTabBarVCInstance;
}

+ (void)destroyInstance {
    @synchronized (self) {
        JobsCustomTabBarVCInstance = nil;
    }
}

/// 防止外部使用 alloc/init 等创建新实例
+ (instancetype)allocWithZone:(struct _NSZone *)zone {
    return [self sharedManager];
}
/// 防止外部使用 alloc/init 等创建新实例
- (instancetype)copyWithZone:(NSZone *)zone {
    return self;
}
/// 防止外部调用copy
- (instancetype)mutableCopyWithZone:(NSZone *)zone {
    return self;
}
// 初始化代码可以放在这里
- (instancetype)init {
    if (self = [super init]) {
        // Initialization code
    }return self;
}

25、打开`URL` 回到顶部

关注实现类：@interface NSObject (OpenURL)
处理警告，向下兼容API
URL兼容NSString * 和 NSURL *
丰富打开失败后的操作

具体代码调用

            [self jobsOpenURL:self.redirectURL
successCompletionHandlerBlock:^(id  _Nullable data) {

            } failCompletionHandlerBlock:^(id  _Nullable data) {

            }];

26、数据库回到顶部

FMDB

需要写SQL

#if __has_include(<FMDB/FMDB.h>)
#import <FMDB/FMDB.h>
#else
#import "FMDB.h"
#endif

/// 建表
- (void)createTable {
    [self.databaseQueue inDatabase:^(FMDatabase * _Nonnull db) {
        NSString *createTableQuery = @"CREATE TABLE IF NOT EXISTS Users (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT, age INTEGER)";
        BOOL success = [db executeUpdate:createTableQuery];
        if (success) {
            NSLog(@"Table created successfully.");
        } else {
            NSLog(@"Failed to create table.");
        }
    }];
}
/// 插入数据
- (void)insertUserWithName:(NSString *)name age:(NSInteger)age {
    [self.databaseQueue inDatabase:^(FMDatabase * _Nonnull db) {
        NSString *insertQuery = @"INSERT INTO Users (name, age) VALUES (?, ?)";
        BOOL success = [db executeUpdate:insertQuery, name, @(age)];
        if (success) {
            NSLog(@"User inserted successfully.");
        } else {
            NSLog(@"Failed to insert user.");
        }
    }];
}
/// 查询数据
- (NSArray *)fetchAllUsers {
    NSMutableArray *users = NSMutableArray.array;
    [self.databaseQueue inDatabase:^(FMDatabase * _Nonnull db) {
        NSString *selectQuery = @"SELECT * FROM Users";
        FMResultSet *result = [db executeQuery:selectQuery];
        while (result.next) {
            NSDictionary *user = @{
                @"id": @([result intForColumn:@"id"]),
                @"name": [result stringForColumn:@"name"],
                @"age": @([result intForColumn:@"age"])
            };
            [users addObject:user];
        }
    }];return users;
}
/// 更新/改正 数据
- (void)updateUserWithID:(NSInteger)userID
                 newName:(NSString *)newName
                  newAge:(NSInteger)newAge {
    [self.databaseQueue inDatabase:^(FMDatabase * _Nonnull db) {
        NSString *updateQuery = @"UPDATE Users SET name = ?, age = ? WHERE id = ?";
        BOOL success = [db executeUpdate:updateQuery, newName, @(newAge), @(userID)];
        if (success) {
            NSLog(@"User updated successfully.");
        } else {
            NSLog(@"Failed to update user.");
        }
    }];
}
/// 删除数据
- (void)deleteUserWithID:(NSInteger)userID {
    [self.databaseQueue inDatabase:^(FMDatabase * _Nonnull db) {
        NSString *deleteQuery = @"DELETE FROM Users WHERE id = ?";
        BOOL success = [db executeUpdate:deleteQuery, @(userID)];
        if (success) {
            NSLog(@"User deleted successfully.");
        } else {
            NSLog(@"Failed to delete user.");
        }
    }];
}

Realm

不需要写SQL，pod一键集成
model需要继承自RLMObject

#if __has_include(<Realm/Realm.h>)
#import <Realm/Realm.h>
#else
#import "Realm.h"
#endif

/// 插入数据
- (void)insertUserWithName:(NSString *)name age:(NSInteger)age {
    RLMRealm *realm = RLMRealm.defaultRealm;
    [realm transactionWithBlock:^{
        User *newUser = User.new;
        newUser.name = name;
        newUser.age = age;
        [realm addObject:newUser];
    }];
}
/// 查询数据
- (NSArray *)fetchAllUsers {
    RLMResults<User *> *results = User.allObjects;
    NSMutableArray *users = NSMutableArray.array;
    for (User *user in results) {
        [users addObject:user];
    }return users;
}
/// 更新/改正 数据
- (void)updateUser:(User *)user
           newName:(NSString *)newName
            newAge:(NSInteger)newAge {
    RLMRealm *realm = RLMRealm.defaultRealm;
    [realm transactionWithBlock:^{
        user.name = newName;
        user.age = newAge;
    }];
}
/// 删除数据
- (void)deleteUser:(User *)user {
    RLMRealm *realm = RLMRealm.defaultRealm;
    [realm transactionWithBlock:^{
        [realm deleteObject:user];
    }];
}

Core Data

不需要写SQL，但是需要在xcode上进行配置，比较繁琐
Info.plist中，添加一个新的键 NSPersistentStoreTypeKey，并将值设置为 SQLite
创建Core Data模型文件.xcdatamodeld，并在其中创建一个实体 User，并添加两个属性：
- name (String)
- age (Integer 32)

AppDelegate设置Core Data堆栈

#import <UIKit/UIKit.h>
#import <CoreData/CoreData.h>

@interface AppDelegate : UIResponder <UIApplicationDelegate>

@property (strong, nonatomic) UIWindow *window;
@property (readonly, strong) NSPersistentContainer *persistentContainer;

- (void)saveContext;

@end

#import "AppDelegate.h"

@interface AppDelegate ()

@end

@implementation AppDelegate

@synthesize persistentContainer = _persistentContainer;

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
    return YES;
}

- (NSPersistentContainer *)persistentContainer {
    @synchronized (self) {
        if (_persistentContainer == nil) {
            _persistentContainer = [[NSPersistentContainer alloc] initWithName:@"ModelName"];
            [_persistentContainer loadPersistentStoresWithCompletionHandler:^(NSPersistentStoreDescription *storeDescription, NSError *error) {
                if (error != nil) {
                    NSLog(@"Unresolved error %@, %@", error, error.userInfo);
                    abort();
                }
            }];
        }
    }
    return _persistentContainer;
}

- (void)saveContext {
    NSManagedObjectContext *context = self.persistentContainer.viewContext;
    if ([context hasChanges]) {
        NSError *error = nil;
        if (![context save:&error]) {
            NSLog(@"Unresolved error %@, %@", error, error.userInfo);
            abort();
        }
    }
}

@end

增删查改

#import "ViewController.h"
#import "AppDelegate.h"
#import <CoreData/CoreData.h>

@interface ViewController ()

@property (nonatomic, strong) NSManagedObjectContext *context;

@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    
    self.context = ((AppDelegate *)[UIApplication sharedApplication].delegate).persistentContainer.viewContext;
    
    // 插入数据
    [self insertUserWithName:@"Alice" age:25];
    [self insertUserWithName:@"Bob" age:30];
    
    // 获取所有用户
    NSArray *users = [self fetchAllUsers];
    NSLog(@"Users: %@", users);
    
    // 更新用户
    if (users.count > 0) {
        NSManagedObject *user = users[0];
        [self updateUser:user newName:@"Alice Smith" newAge:26];
    }
    
    // 删除用户
    if (users.count > 1) {
        NSManagedObject *user = users[1];
        [self deleteUser:user];
    }
    
    // 获取更新后的用户列表
    users = [self fetchAllUsers];
    NSLog(@"Updated Users: %@", users);
}

- (void)insertUserWithName:(NSString *)name age:(NSInteger)age {
    NSManagedObject *newUser = [NSEntityDescription insertNewObjectForEntityForName:@"User" inManagedObjectContext:self.context];
    [newUser setValue:name forKey:@"name"];
    [newUser setValue:@(age) forKey:@"age"];
    [self saveContext];
}

- (NSArray *)fetchAllUsers {
    NSFetchRequest *fetchRequest = [NSFetchRequest fetchRequestWithEntityName:@"User"];
    NSError *error = nil;
    NSArray *result = [self.context executeFetchRequest:fetchRequest error:&error];
    if (error) {
        NSLog(@"Error fetching users: %@", error);
    }
    return result;
}

- (void)updateUser:(NSManagedObject *)user newName:(NSString *)newName newAge:(NSInteger)newAge {
    [user setValue:newName forKey:@"name"];
    [user setValue:@(newAge) forKey:@"age"];
    [self saveContext];
}

- (void)deleteUser:(NSManagedObject *)user {
    [self.context deleteObject:user];
    [self saveContext];
}

- (void)saveContext {
    NSError *error = nil;
    if ([self.context hasChanges] && ![self.context save:&error]) {
        NSLog(@"Unresolved error %@, %@", error, error.userInfo);
        abort();
    }
}

@end

27、指纹识别回到顶部

关注实现类：@interface TouchID : NSObject

28、创建`UICollectionView` 回到顶部

28.1、关于`UICollectionView`

设置为NO，使得UICollectionView只能上拉，不能下拉
```
_collectionView.bounces = NO;
```

UICollectionView必须执行注册机制。当且仅当用字符串获取UICollectionViewCell的时候才开辟内存

_collectionView.registerCollectionViewClass();

_collectionView.registerCollectionElementKindSectionHeaderClass(TMSWalletCollectionReusableView.class);
_collectionView.registerCollectionElementKindSectionFooterClass(TMSWalletCollectionReusableView.class);

_collectionView.registerCollectionElementKindSectionHeaderClass(TMSWalletCollectionReusableView.class);
_collectionView.registerCollectionElementKindSectionFooterClass(TMSWalletCollectionReusableView.class);

滚动到指定位置

_collectionView.contentOffset = CGPointMake(0,-100);

[_collectionView setContentOffset:CGPointMake(0, -200) animated:YES];// 只有在viewDidAppear周期 或者 手动触发才有效

增加**UICollectionView** 的可滚动区域（contentInset）

_collectionView.contentInset = UIEdgeInsetsMake(0, 0, JobsBottomSafeAreaHeight(), 0);

支持水平方向的左拉加载和右拉刷新 XZMRefresh

pod 'XZMRefresh' # https://github.com/xiezhongmin/XZMRefresh

#if __has_include(<XZMRefresh/XZMRefresh.h>)
#import <XZMRefresh/XZMRefresh.h>
#else
#import "XZMRefresh.h"
#endif

[self layoutIfNeeded];
@jobs_weakify(self)
[_collectionView xzm_addNormalHeaderWithTarget:self
                                        action:selectorBlocks(^id _Nullable(id _Nullable weakSelf,
                                                                            id _Nullable arg) {
    NSLog(@"KKK加载新的数据，参数: %@", arg);
    /// 在需要结束刷新的时候调用（只能调用一次）
    /// _collectionView.endRefreshing();
    return nil;
}, MethodName(self), self)];

[_collectionView xzm_addNormalFooterWithTarget:self
                                        action:selectorBlocks(^id _Nullable(id _Nullable weakSelf,
                                                                            id _Nullable arg) {
    NSLog(@"KKK加载新的数据，参数: %@", arg);
    /// 在需要结束刷新的时候调用（只能调用一次）
    /// _collectionView.endRefreshing();
    return nil;
}, MethodName(self), self)];

[_collectionView.xzm_header beginRefreshing];

支持垂直方向上的上拉加载和下拉刷新 MJRefresh

pod 'MJRefresh' # https://github.com/CoderMJLee/MJRefresh

_tableView.mj_header = self.view.MJRefreshNormalHeaderBy(jobsMakeRefreshConfigModel(^(__kindof MJRefreshConfigModel * _Nullable data) {
    data.stateIdleTitle = JobsInternationalization(@"下拉可以刷新");
    data.pullingTitle = JobsInternationalization(@"下拉可以刷新");
    data.refreshingTitle = JobsInternationalization(@"松开立即刷新");
    data.willRefreshTitle = JobsInternationalization(@"刷新数据中");
    data.noMoreDataTitle = JobsInternationalization(@"下拉可以刷新");
    data.automaticallyChangeAlpha = YES;/// 根据拖拽比例自动切换透明度
    data.loadBlock = ^id _Nullable(id _Nullable data) {
        @jobs_strongify(self)
        /// 下拉刷新
        self.feedbackGenerator();//震动反馈
        self->_tableView.endRefreshing(YES);
        return nil;
    };
}));

_tableView.mj_footer = self.view.MJRefreshFooterBy(jobsMakeRefreshConfigModel(^(__kindof MJRefreshConfigModel * _Nullable data) {
    data.stateIdleTitle = JobsInternationalization(@"");
    data.pullingTitle = JobsInternationalization(@"");
    data.refreshingTitle = JobsInternationalization(@"");
    data.willRefreshTitle = JobsInternationalization(@"");
    data.noMoreDataTitle = JobsInternationalization(@"");
    data.loadBlock = ^id _Nullable(id _Nullable data){
        @jobs_strongify(self)
        self->_tableView.endRefreshing(YES);
        return nil;
    };
}));

支持lottie动画

pod 'lottie-ios', '~> 2.5.3' # 这是OC终极版本 https://github.com/airbnb/lottie-ios

#if __has_include(<lottie-ios/Lottie.h>)
#import <lottie-ios/Lottie.h>
#else
#import "Lottie.h"
#endif

_tableView.mj_header = self.LOTAnimationMJRefreshHeaderBy(jobsMakeRefreshConfigModel(^(__kindof MJRefreshConfigModel * _Nullable data) {
  data.stateIdleTitle = JobsInternationalization(@"下拉刷新数据");
  data.pullingTitle = JobsInternationalization(@"下拉刷新数据");
  data.refreshingTitle = JobsInternationalization(@"正在刷新数据");
  data.willRefreshTitle = JobsInternationalization(@"刷新数据中");
  data.noMoreDataTitle = JobsInternationalization(@"下拉刷新数据");
  data.loadBlock = ^id _Nullable(id  _Nullable data) {
      @jobs_strongify(self)
      NSLog(@"下拉刷新");
      self.tableView.endRefreshing(self.jobsIMListMutArr.count);
      return nil;
  };
}));

**UICollectionView**的无数据占位方案

静态图 LYEmptyView

pod 'LYEmptyView' # https://github.com/dev-liyang/LYEmptyView iOS一行代码集成空白页面占位图(无数据、无网络占位图)

#if __has_include(<LYEmptyView/LYEmptyViewHeader.h>)
#import <LYEmptyView/LYEmptyViewHeader.h>
#else
#import "LYEmptyViewHeader.h"
#endif

_collectionView.ly_emptyView = [LYEmptyView emptyViewWithImageStr:JobsInternationalization(@"暂无数据")
                                                         titleStr:JobsInternationalization(@"暂无数据")
                                                        detailStr:JobsInternationalization(@"")];

_collectionView.ly_emptyView.titleLabTextColor = JobsLightGrayColor;
_collectionView.ly_emptyView.contentViewOffset = JobsWidth(-180);
_collectionView.ly_emptyView.titleLabFont = UIFontWeightMediumSize(16);

动画 TABAnimated

pod 'TABAnimated' # https://github.com/tigerAndBull/TABAnimated

#if __has_include(<TABAnimated/TABAnimated.h>)
#import <TABAnimated/TABAnimated.h>
#else
#import "TABAnimated.h"
#endif

#pragma mark —— 全局配置 TABAnimated
-(jobsByVoidBlock _Nonnull)makeTABAnimatedConfig{
    return ^(){
        [TABAnimated.sharedAnimated initWithOnlySkeleton];
        /// 是否开启控制台Log提醒，默认不开启
        TABAnimated.sharedAnimated.openLog = YES;
        ///开启后，会在每一个动画元素上增加一个红色的数字，该数字表示该动画元素所在的下标，方便快速定位某个动画元素。
//        TABAnimated.sharedAnimated.openAnimationTag = YES;
//        TABAnimated.sharedAnimated.animationType;/// 全局动画类型
//        TABAnimated.sharedAnimated.animatedHeightCoefficient;/// 动画高度与视图原有高度的比例系数，该属性仅仅对`UILabel`生效。
//        TABAnimated.sharedAnimated.animatedColor;/// 全局动画内容颜色，默认值为0xEEEEEE
        TABAnimated.sharedAnimated.animatedBackgroundColor = JobsLightGrayColor;/// 全局动画背景颜色，默认值为UIColor.whiteColor
//        TABAnimated.sharedAnimated.useGlobalCornerRadius;/// 是否开启全局圆角。开启后，全局圆角默认值为: 动画高度/2.0
//        TABAnimated.sharedAnimated.animatedCornerRadius;/// 全局圆角的值。优先级：此属性 < view自身的圆角
//        TABAnimated.sharedAnimated.useGlobalAnimatedHeight;/// 是否需要全局动画高度
//        TABAnimated.sharedAnimated.animatedHeight;/// 全局动画高度
//        TABAnimated.sharedAnimated.scrollEnabled;/// 是否可以在滚动，默认可以滚动
//        TABAnimated.sharedAnimated.closeCache;/// 关闭缓存功能，默认开启
//        TABAnimated.sharedAnimated.darkAnimatedBackgroundColor;/// 暗黑模式下，动画背景色
//        TABAnimated.sharedAnimated.darkAnimatedColor;/// 暗黑模式下，动画内容的颜色
//        TABAnimated.sharedAnimated.darkModeType;/// 暗黑模式选择，跟随系统、强制普通模式、强制暗黑模式
//        TABAnimated.sharedAnimated.classicAnimation;/// 经典动画全局配置
//        TABAnimated.sharedAnimated.dropAnimation;/// 下坠动画全局配置
//        TABAnimated.sharedAnimated.binAnimation;/// 呼吸灯动画全局配置
//        TABAnimated.sharedAnimated.shimmerAnimation;/// 闪光灯动画全局配置
    };
}

NSArray *classArray = @[
                        DDCollectionViewCell_Style2.class,
                        DDCollectionViewCell_Style3.class,
                        DDCollectionViewCell_Style4.class,
                        ];
NSArray *sizeArray = @[
                       [NSValue valueWithCGSize:[DDCollectionViewCell_Style2 cellSizeWithModel:nil]],
                       [NSValue valueWithCGSize:[DDCollectionViewCell_Style3 cellSizeWithModel:nil]],
                       [NSValue valueWithCGSize:[DDCollectionViewCell_Style4 cellSizeWithModel:nil]]
                       ];

_collectionView.tabAnimated = [TABCollectionAnimated animatedWithCellClassArray:classArray
                                                                  cellSizeArray:sizeArray
                                                             animatedCountArray:@[@(1),@(1),@(1)]];

[_collectionView.tabAnimated addHeaderViewClass:BaseCollectionReusableView_Style1.class
                                       viewSize:[BaseCollectionReusableView_Style1 collectionReusableViewSizeWithModel:nil]
                                      toSection:0];
[_collectionView.tabAnimated addHeaderViewClass:BaseCollectionReusableView_Style1.class
                                       viewSize:[BaseCollectionReusableView_Style2 collectionReusableViewSizeWithModel:nil]
                                      toSection:2];

_collectionView.tabAnimated.containNestAnimation = YES;
_collectionView.tabAnimated.superAnimationType = TABViewSuperAnimationTypeShimmer;
_collectionView.tabAnimated.canLoadAgain = YES;
[_collectionView tab_startAnimation];   // 开启动画

_collectionView.tabAnimated = [TABCollectionAnimated animatedWithCellClass:HomeCVCell.class
                                                                  cellSize:HomeCVCell.cellSizeByModel(nil)];
_collectionView.tabAnimated.superAnimationType = TABViewSuperAnimationTypeBinAnimation;
_collectionView.tabAnimated.canLoadAgain = YES;
_collectionView.tabAnimated.animatedBackViewCornerRadius = JobsWidth(8);
//_collectionView.tabAnimated.animatedBackgroundColor = JobsRedColor;
[_collectionView tab_startAnimation];   // 开启动画

28.2、关于`UICollectionViewFlowLayout`

UICollectionView 的一个布局对象，用于定义网格布局

  @jobs_weakify(self)
  _collectionView = BaseCollectionView.initByLayout(jobsMakeCollectionViewFlowLayout(^(UICollectionViewFlowLayout * _Nullable data) {
      @jobs_strongify(self)
      data = self.verticalLayout;
  //  data.itemSize = CGSizeMake(100, 100);  // 设置单元格尺寸
  //  data.minimumLineSpacing = 10;  // 设置行间距
  //  data.minimumInteritemSpacing = 10;  // 设置单元格之间的间距
  //  data.sectionInset = UIEdgeInsetsMake(20, 20, 20, 20);  // 设置 section 的内边距
  }));

在UICollectionViewFlowLayout和UICollectionViewDelegateFlowLayout协议方法中设置布局属性时，UICollectionViewDelegateFlowLayout协议方法的优先级更高。也就是说，如果你同时在UICollectionViewFlowLayout对象和UICollectionViewDelegateFlowLayout方法中设置了布局属性，集合视图将优先使用UICollectionViewDelegateFlowLayout方法中提供的值

28.3、`UICollectionView`实现重叠的卡包效果

28.4、关于`UICollectionView`的注册机制

注册的时候不开辟内存，只有当用字符串进行取值的时候才开辟内存
UICollectionView 本身并没有直接提供公开的 API 来检查某个 reuseIdentifier 是否已经注册。如果通过字符串索取不到**UICollectionView**（未注册），会直接崩溃

可以用方法交换去插入一个自定义标志位（NSMutableSet），如果没有在集合里面的即为未注册的**UICollectionView**，此时进入注册流程。关注实现类：@interface UICollectionView (RegistrationTracking)

正常情况下，如果用字符串无法取**UICollectionViewCell会直接崩溃，即collectionViewCellClass无意义。但是添加了上述的方法交换以后这里不会崩溃，其作用机制是：利用方法交换，在进行复用时候，先检测标志位里面是否包含已经注册的对象索引，如果没有即进行注册，再进行复用。所以第一步得到的Cell**一定会存在，不会出现nil的情况。而保留!cell写法的作用更多是向下兼容，同时方便代码的阅读。同时，这个字符串是根据需要注册的cell的类名字符串化得到的，为了避免可能得命名冲突，保证全局的唯一性，在必要的时候，可以通过"加盐"的形式进行字符串拼接。（注意在用字符串进行索取的时候，也对应需要"加盐"）
涉及到的方法交换

+ (void)load {
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
#pragma mark —— registerClass:forCellWithReuseIdentifier:
        Method originalMethod = class_getInstanceMethod(self,
            @selector(registerClass:forCellWithReuseIdentifier:));
        Method swizzledMethod = class_getInstanceMethod(self,
            @selector(swizzled_registerClass:forCellWithReuseIdentifier:));
        method_exchangeImplementations(originalMethod, swizzledMethod);
#pragma mark —— registerClass:forSupplementaryViewOfKind:withReuseIdentifier:
        Method originalSupplementaryMethod = class_getInstanceMethod(self, @selector(registerClass:forSupplementaryViewOfKind:withReuseIdentifier:));
        Method swizzledSupplementaryMethod = class_getInstanceMethod(self, @selector(swizzled_registerClass:forSupplementaryViewOfKind:withReuseIdentifier:));
        method_exchangeImplementations(originalSupplementaryMethod, swizzledSupplementaryMethod);
#pragma mark —— dequeueReusableCellWithReuseIdentifier:forIndexPath:
        Method originalMethod1 = class_getInstanceMethod(self.class, @selector(dequeueReusableCellWithReuseIdentifier:forIndexPath:));
        Method swizzledMethod1 = class_getInstanceMethod(self.class, @selector(swizzled_dequeueReusableCellWithReuseIdentifier:forIndexPath:));
        method_exchangeImplementations(originalMethod1, swizzledMethod1);
#pragma mark —— dequeueReusableSupplementaryViewOfKind:withReuseIdentifier:forIndexPath:
        Method originalMethod2 = class_getInstanceMethod(self.class, @selector(dequeueReusableSupplementaryViewOfKind:withReuseIdentifier:forIndexPath:));
        Method swizzledMethod2 = class_getInstanceMethod(self.class, @selector(swizzled_dequeueReusableSupplementaryViewOfKind:withReuseIdentifier:forIndexPath:));
        method_exchangeImplementations(originalMethod2, swizzledMethod2);
    });
}

+(instancetype)cellWithCollectionView:(nonnull UICollectionView *)collectionView
                         forIndexPath:(nonnull NSIndexPath *)indexPath{
    JobsBtnStyleCVCell *cell = (JobsBtnStyleCVCell *)[collectionView collectionViewCellClass:JobsBtnStyleCVCell.class forIndexPath:indexPath];
    if (!cell) {
        collectionView.registerCollectionViewCellClass(JobsBtnStyleCVCell.class,@"");
        cell = (JobsBtnStyleCVCell *)[collectionView collectionViewCellClass:JobsBtnStyleCVCell.class forIndexPath:indexPath];
    }
    
    // UICollectionViewCell圆切角
//    cell.contentView.layer.cornerRadius = cell.layer.cornerRadius = JobsWidth(8);
//    cell.contentView.layer.borderWidth = cell.layer.borderWidth = JobsWidth(1);
//    cell.contentView.layer.borderColor = cell.layer.borderColor = RGBA_COLOR(255, 225, 144, 1).CGColor;
//    cell.contentView.layer.masksToBounds = cell.layer.masksToBounds = YES;

    cell.indexPath = indexPath;
    
    return cell;
}

28.5、一些用做基类的`UICollectionViewCell`

BaseCollectionViewCell
JobsBaseCollectionViewCell
JobsBtnStyleCVCell：只在**BaseCollectionViewCell完整的盖一个Button，其目的是利用Button**丰富的图文展示效果
JobsBtnsStyleCVCell：左右两边各有一个**Button**
JobsImageViewStyleCVCell：只在**BaseCollectionViewCell完整的盖一个ImageView**
JobsTextFieldStyleCVCell：只在**BaseCollectionViewCell完整的盖一个TextField**

28.6、`UICollectionView`的完整调用

点我查看

@interface JobsImageNumberViewCVCell ()

@property(nonatomic,strong)UIImageView *textIMGV;

@end

@implementation JobsImageNumberViewCVCell
#pragma mark —— UICollectionViewCellProtocol
+(instancetype)cellWithCollectionView:(nonnull UICollectionView *)collectionView
                         forIndexPath:(nonnull NSIndexPath *)indexPath{
    JobsImageNumberViewCVCell *cell = (JobsImageNumberViewCVCell *)[collectionView collectionViewCellClass:JobsImageNumberViewCVCell.class forIndexPath:indexPath];
    if (!cell) {
        collectionView.registerCollectionViewCellClass(JobsImageNumberViewCVCell.class,@"");
        cell = (JobsImageNumberViewCVCell *)[collectionView collectionViewCellClass:JobsImageNumberViewCVCell.class forIndexPath:indexPath];
    }
    cell.indexPath = indexPath;
    return cell;
}
#pragma mark —— BaseCellProtocol
/// 具体由子类进行复写【数据定UI】【如果所传参数为基本数据类型，那么包装成对象NSNumber进行转化承接】
-(jobsByIDBlock _Nonnull)richElementsInCellWithModel{
    @jobs_weakify(self)
    return ^(id _Nullable model) {
        @jobs_strongify(self)
        self.backgroundColor = self.contentView.backgroundColor = JobsClearColor;
        self.textIMGV.image = model;
    };
}
////具体由子类进行复写【数据定高】【如果所传参数为基本数据类型，那么包装成对象NSNumber进行转化承接】
//+(CGFloat)cellHeightWithModel:(id _Nullable)model;
//具体由子类进行复写【数据尺寸】【如果所传参数为基本数据类型，那么包装成对象NSNumber进行转化承接】
+(CGSize)cellSizeWithModel:(UIImage *_Nullable)model{
    if ([model isEqual:JobsIMG(@"小数点")]) {
        return CGSizeMake(JobsWidth(15), JobsWidth(28));
    }return CGSizeMake(JobsWidth(19), JobsWidth(28));
}
#pragma mark —— lazyLoad
-(UIImageView *)textIMGV{
    if (!_textIMGV) {
        _textIMGV = UIImageView.new;
        [self.contentView addSubview:_textIMGV];
        [_textIMGV mas_makeConstraints:^(MASConstraintMaker *make) {
            make.edges.equalTo(self.contentView);
        }];
    }return _textIMGV;
}

@end

@property(nonatomic,strong)BaseCollectionView *collectionView;

-(BaseCollectionView *)collectionView{
    if (!_collectionView) {
        @jobs_weakify(self)
        _collectionView = BaseCollectionView.initByLayout(jobsMakeCollectionViewFlowLayout(^(UICollectionViewFlowLayout * _Nullable data) {
            @jobs_strongify(self)
            data = self.verticalLayout;
//            data.itemSize = CGSizeMake(100, 100);  // 设置单元格尺寸
//            data.minimumLineSpacing = 10;  // 设置行间距
//            data.minimumInteritemSpacing = 10;  // 设置单元格之间的间距
//            data.sectionInset = UIEdgeInsetsMake(20, 20, 20, 20);  // 设置 section 的内边距
        }));
        _collectionView.backgroundColor = JobsCor(@"#FFFFFF");
        _collectionView.dataLink(self);
        _collectionView.showsVerticalScrollIndicator = NO;
        _collectionView.showsHorizontalScrollIndicator = NO;
        _collectionView.bounces = NO;
        
        _collectionView.registerCollectionViewClass();
        _collectionView.registerCollectionViewCellClass(MSMineView6CVCell.class,@"");
        
        {
            _collectionView.mj_header = self.MJRefreshNormalHeaderBy(jobsMakeRefreshConfigModel(^(__kindof MJRefreshConfigModel * _Nullable data) {
                data.stateIdleTitle = JobsInternationalization(@"下拉可以刷新");
                data.pullingTitle = JobsInternationalization(@"下拉可以刷新");
                data.refreshingTitle = JobsInternationalization(@"松开立即刷新");
                data.willRefreshTitle = JobsInternationalization(@"刷新数据中");
                data.noMoreDataTitle = JobsInternationalization(@"下拉可以刷新");
                data.automaticallyChangeAlpha = YES; /// 根据拖拽比例自动切换透明度
                data.loadBlock = ^id _Nullable(id  _Nullable data) {
                    @jobs_strongify(self)
                    self.feedbackGenerator();//震动反馈
                    self->_collectionView.endRefreshing(YES);
                    return nil;
                };
            }));
            _collectionView.mj_footer = self.MJRefreshBackNormalFooterBy(jobsMakeRefreshConfigModel(^(__kindof MJRefreshConfigModel * _Nullable data) {
                data.stateIdleTitle = JobsInternationalization(@"");
                data.pullingTitle = JobsInternationalization(@"");
                data.refreshingTitle = JobsInternationalization(@"");
                data.willRefreshTitle = JobsInternationalization(@"");
                data.noMoreDataTitle = JobsInternationalization(@"");
                data.loadBlock = ^id _Nullable(id  _Nullable data) {
                    @jobs_strongify(self)
                    self->_collectionView.endRefreshing(YES);
                    return nil;
                };
            }));
        }
      
        {
            _collectionView.tabAnimated = [TABCollectionAnimated animatedWithCellClass:HomeCVCell.class
                                                                              cellSize:HomeCVCell.cellSizeByModel(nil)];
            _collectionView.tabAnimated.superAnimationType = TABViewSuperAnimationTypeBinAnimation;
            _collectionView.tabAnimated.canLoadAgain = YES;
            _collectionView.tabAnimated.animatedBackViewCornerRadius = JobsWidth(8);
//            _collectionView.tabAnimated.animatedBackgroundColor = JobsRedColor;
            [_collectionView tab_startAnimation];   // 开启动画
        }
        
        [self addSubview:_collectionView];
        [_collectionView mas_makeConstraints:^(MASConstraintMaker *make) {
            make.top.left.right.equalTo(self);
            make.height.mas_equalTo(JobsWidth(102));
        }];
    }return _collectionView;
}

#pragma mark - UICollectionViewDataSource
- (NSInteger)numberOfSectionsInCollectionView:(UICollectionView *)collectionView {
    return 1;
}

- (nonnull __kindof UICollectionViewCell *)collectionView:(nonnull UICollectionView *)collectionView
                                   cellForItemAtIndexPath:(nonnull NSIndexPath *)indexPath {
    JobsImageNumberViewCVCell *cell = [JobsImageNumberViewCVCell cellWithCollectionView:collectionView
                                                                   forIndexPath:indexPath];
    cell.richElementsInCellWithModel(self.dataMutArr[indexPath.row]);
    return cell;
}

- (NSInteger)collectionView:(nonnull UICollectionView *)collectionView
     numberOfItemsInSection:(NSInteger)section {
    return self.dataMutArr.count;
}
#pragma mark —— UICollectionViewDelegate
//允许选中时，高亮
-(BOOL)collectionView:(UICollectionView *)collectionView
shouldHighlightItemAtIndexPath:(NSIndexPath *)indexPath {
    NSLog(@"%s", __FUNCTION__);
    return YES;
}
// 高亮完成后回调
-(void)collectionView:(UICollectionView *)collectionView
didHighlightItemAtIndexPath:(NSIndexPath *)indexPath {
    NSLog(@"%s", __FUNCTION__);
}
// 由高亮转成非高亮完成时的回调
-(void)collectionView:(UICollectionView *)collectionView
didUnhighlightItemAtIndexPath:(NSIndexPath *)indexPath {
    NSLog(@"%s", __FUNCTION__);
}
// 设置是否允许选中
-(BOOL)collectionView:(UICollectionView *)collectionView
shouldSelectItemAtIndexPath:(NSIndexPath *)indexPath {
    NSLog(@"%s", __FUNCTION__);
    return YES;
}
// 设置是否允许取消选中
-(BOOL)collectionView:(UICollectionView *)collectionView
shouldDeselectItemAtIndexPath:(NSIndexPath *)indexPath {
    NSLog(@"%s", __FUNCTION__);
    return YES;
}
// 选中操作
- (void)collectionView:(UICollectionView *)collectionView
didSelectItemAtIndexPath:(NSIndexPath *)indexPath {
    NSLog(@"%s", __FUNCTION__);
}
// 取消选中操作
-(void)collectionView:(UICollectionView *)collectionView
didDeselectItemAtIndexPath:(NSIndexPath *)indexPath {
    NSLog(@"%s", __FUNCTION__);
}
#pragma mark —— UICollectionViewDelegateFlowLayout
- (CGSize)collectionView:(UICollectionView *)collectionView
                  layout:(UICollectionViewLayout *)collectionViewLayout
  sizeForItemAtIndexPath:(NSIndexPath *)indexPath {
    return [JobsImageNumberViewCVCell cellSizeWithModel:self.dataMutArr[indexPath.row]];
}
/// 定义的是元素垂直之间的间距
- (CGFloat)collectionView:(UICollectionView *)collectionView
                   layout:(UICollectionViewLayout *)collectionViewLayout
minimumLineSpacingForSectionAtIndex:(NSInteger)section {
    return 0;
}
/// 定义的是UICollectionViewScrollDirectionVertical下，元素水平之间的间距。
/// UICollectionViewScrollDirectionHorizontal下，垂直和水平正好相反
/// Api自动计算一行的Cell个数，只有当间距小于此定义的最小值时才会换行，最小执行单元是Section（每个section里面的样式是统一的）
- (CGFloat)collectionView:(UICollectionView *)collectionView
                   layout:(UICollectionViewLayout *)collectionViewLayout
minimumInteritemSpacingForSectionAtIndex:(NSInteger)section{
    return 0;
}
///内间距
-(UIEdgeInsets)collectionView:(UICollectionView *)collectionView
                       layout:(UICollectionViewLayout*)collectionViewLayout
       insetForSectionAtIndex:(NSInteger)section {
    return jobsSameEdgeInset(JobsWidth(0));
}

29、创建`UITableView` 回到顶部

29.1、关于`UITableView`

**UITableView**的生命周期

UITableView 可以不用像**UICollectionView**一样执行注册机制。注册机制的生命周期有别于普通的生命周期
对于"三问一答"，如果**UITableViewCell的高度为0，压根就不会执行UITableViewCell**的绘制，即：- (__kindof UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath。所以利用这一点，我们在进数据源的时候，可以在- (CGFloat)tableView:(UITableView *)tableView heightForRowAtIndexPath:(NSIndexPath *)indexPath这里面对数据源所需的高度进行计算和反馈

在**UITableViewCell**将要出现的时候，进行最后的绘制

- (void)tableView:(UITableView *)tableView
  willDisplayCell:(UITableViewCell *)cell
forRowAtIndexPath:(NSIndexPath *)indexPath{
    /// 隐藏最后一个单元格的分界线
    [tableView hideSeparatorLineAtLast:indexPath
                                  cell:cell];
    /// 自定义 UITableViewCell 的箭头
    cell.img = JobsIMG(@"向右的箭头（大）");
    @jobs_weakify(self)
    [cell customAccessoryView:^(id data) {
        @jobs_strongify(self)
        JobsBaseTableViewCell *cell = (JobsBaseTableViewCell *)data;
        NSLog(@"MMM - %ld",cell.index);
    }];
    /// 以section为单位，每个section的第一行和最后一行的 UITableViewCell 圆角化处理
    [cell cutFirstAndLastTableViewCellWithBackgroundCor:HEXCOLOR(0xFFFFFF)
                                          bottomLineCor:HEXCOLOR(0xFFFFFF) 
                                         cellOutLineCor:HEXCOLOR(0xEEE2C8)
                                       cornerRadiusSize:CGSizeMake(JobsWidth(8), JobsWidth(8))
                                            borderWidth:JobsWidth(10)
                                                     dx:JobsWidth(0)
                                                     dy:JobsWidth(0)];
}

UITableView 的初始化方法
- ```
BaseTableView.initWithStylePlain;
```
- 会在每个section分组的时候，自动产生组与组之间的距离
```
BaseTableView.initWithStyleGrouped;
```

对父类**UIScrollView三要素（contentOffset、contentSize、contentInset**）的封装设置。关注实现类@interface UIView (Measure)

#pragma mark —— UIScrollView.contentSize
-(jobsBySizeBlock _Nullable)resetContentSize;
-(jobsByCGFloatBlock _Nullable)resetContentSizeWidth;
-(jobsByCGFloatBlock _Nullable)resetContentSizeHeight;
-(jobsByCGFloatBlock _Nullable)resetContentSizeOffsetWidth;
-(jobsByCGFloatBlock _Nullable)resetContentSizeOffsetHeight;

#pragma mark —— UIScrollView.contentOffset
-(jobsByPointBlock _Nullable)resetContentOffset;
-(jobsByCGFloatBlock _Nullable)resetContentX;
-(jobsByCGFloatBlock _Nullable)resetContentY;
-(jobsByCGFloatBlock _Nullable)resetContentOffsetX;
-(jobsByCGFloatBlock _Nullable)resetContentOffsetY;

#pragma mark —— UIScrollView.contentInset
-(jobsByEdgeInsetBlock _Nullable)resetContentInset;
-(jobsByCGFloatBlock _Nullable)resetContentInsetTop;
-(jobsByCGFloatBlock _Nullable)resetContentInsetLeft;
-(jobsByCGFloatBlock _Nullable)resetContentInsetBottom;
-(jobsByCGFloatBlock _Nullable)resetContentInsetRight;
-(jobsByCGFloatBlock _Nullable)resetContentInsetOffsetTop;
-(jobsByCGFloatBlock _Nullable)resetContentInsetOffsetLeft;
-(jobsByCGFloatBlock _Nullable)resetContentInsetOffsetBottom;
-(jobsByCGFloatBlock _Nullable)resetContentInsetOffsetRight;

增加**UITableView** 的可滚动区域（contentInset）

_tableView.contentInset = UIEdgeInsetsMake(0, 0, JobsBottomSafeAreaHeight(), 0);

滚动到指定行

NSInteger s = self.tableView.numberOfSections;/// 有多少组
if (s < 1) return;
NSInteger r = [self.tableView numberOfRowsInSection:s - 1];/// 最后一组有多少行
if (r < 1) return;
NSIndexPath *indexPath = [NSIndexPath indexPathForRow:r - 1 inSection:s - 1];/// 取最后一行数据
[self.tableView scrollToRowAtIndexPath:indexPath
                      atScrollPosition:UITableViewScrollPositionBottom
                              animated:YES];/// 滚动到最后一行

NSIndexPath *indexPath = [NSIndexPath indexPathForRow:0 inSection:0];/// 取第一行数据
[self.tableView scrollToRowAtIndexPath:indexPath
                      atScrollPosition:UITableViewScrollPositionTop
                              animated:YES];/// 滚动到第一行

tableHeaderView也会随着**UITableView**的滚动而滚动
UITableView 的可折叠效果。第三方分类实现，关注：@interface UITableView (WWFoldableTableView)
```
_tableView.ww_foldable = YES;
```

**UITableView**的无数据占位方案

静态图 LYEmptyView

pod 'LYEmptyView' # https://github.com/dev-liyang/LYEmptyView iOS一行代码集成空白页面占位图(无数据、无网络占位图)

#if __has_include(<LYEmptyView/LYEmptyViewHeader.h>)
#import <LYEmptyView/LYEmptyViewHeader.h>
#else
#import "LYEmptyViewHeader.h"
#endif

_tableView.ly_emptyView = [LYEmptyView emptyViewWithImageStr:JobsInternationalization(@"暂无数据")
                                                    titleStr:JobsInternationalization(@"暂无数据")
                                                   detailStr:JobsInternationalization(@"")];

_tableView.ly_emptyView.titleLabTextColor = JobsLightGrayColor;
_tableView.ly_emptyView.contentViewOffset = JobsWidth(-180);
_tableView.ly_emptyView.titleLabFont = UIFontWeightLightSize(16);

动画 TABAnimated

pod 'TABAnimated' # https://github.com/tigerAndBull/TABAnimated

#if __has_include(<TABAnimated/TABAnimated.h>)
#import <TABAnimated/TABAnimated.h>
#else
#import "TABAnimated.h"
#endif

// 可以不进行手动初始化，将使用默认属性
_tableView.tabAnimated = [TABTableAnimated animatedWithCellClass:JobsBaseTableViewCell.class
                                                      cellHeight:JobsBaseTableViewCell.cellHeightByModel(nil)];
_tableView.tabAnimated.superAnimationType = TABViewSuperAnimationTypeShimmer;
[_tableView tab_startAnimation];   // 开启动画

支持垂直方向的上拉加载和下拉刷新 MJRefresh

pod 'MJRefresh' # https://github.com/CoderMJLee/MJRefresh NO_SMP 不支持横向刷新

#if __has_include(<MJRefresh/MJRefresh.h>)
#import <MJRefresh/MJRefresh.h>
#else
#import "MJRefresh.h"
#endif

{
            _tableView.mj_header = self.view.MJRefreshNormalHeaderBy(jobsMakeRefreshConfigModel(^(__kindof MJRefreshConfigModel * _Nullable data) {
                data.stateIdleTitle = JobsInternationalization(@"下拉可以刷新");
                data.pullingTitle = JobsInternationalization(@"下拉可以刷新");
                data.refreshingTitle = JobsInternationalization(@"松开立即刷新");
                data.willRefreshTitle = JobsInternationalization(@"刷新数据中");
                data.noMoreDataTitle = JobsInternationalization(@"下拉可以刷新");
                data.automaticallyChangeAlpha = YES;/// 根据拖拽比例自动切换透明度
                data.loadBlock = ^id _Nullable(id _Nullable data) {
                    @jobs_strongify(self)
                    /// 下拉刷新
                    self.feedbackGenerator();//震动反馈
                    self->_tableView.endRefreshing(YES);
                    return nil;
                };
            }));
            _tableView.mj_footer = self.view.MJRefreshFooterBy(jobsMakeRefreshConfigModel(^(__kindof MJRefreshConfigModel * _Nullable data) {
                data.stateIdleTitle = JobsInternationalization(@"");
                data.pullingTitle = JobsInternationalization(@"");
                data.refreshingTitle = JobsInternationalization(@"");
                data.willRefreshTitle = JobsInternationalization(@"");
                data.noMoreDataTitle = JobsInternationalization(@"");
                data.loadBlock = ^id _Nullable(id _Nullable data){
                    @jobs_strongify(self)
                    self->_tableView.endRefreshing(YES);
                    return nil;
                };
            }));
        }

支持水平方向的左拉加载和右拉刷新 XZMRefresh

pod 'XZMRefresh' # https://github.com/xiezhongmin/XZMRefresh

#if __has_include(<XZMRefresh/XZMRefresh.h>)
#import <XZMRefresh/XZMRefresh.h>
#else
#import "XZMRefresh.h"
#endif

[self layoutIfNeeded];
@jobs_weakify(self)
[_tableView xzm_addNormalHeaderWithTarget:self
                                   action:selectorBlocks(^id _Nullable(id _Nullable weakSelf,
                                                                       id _Nullable arg) {
    NSLog(@"KKK加载新的数据，参数: %@", arg);
    /// 在需要结束刷新的时候调用（只能调用一次）
    /// _collectionView.endRefreshing();
    return nil;
}, MethodName(self), self)];

[_tableView xzm_addNormalFooterWithTarget:self
                                   action:selectorBlocks(^id _Nullable(id _Nullable weakSelf,
                                                                                    id _Nullable arg) {
    NSLog(@"KKK加载新的数据，参数: %@", arg);
    /// 在需要结束刷新的时候调用（只能调用一次）
    /// _collectionView.endRefreshing();
    return nil;
}, MethodName(self), self)];

[_tableView.xzm_header beginRefreshing];

切角

关于UITableViewCell和UICollectionViewCell圆切角+Cell的偏移量

以section为单位，每个section的第一行和最后一行的UITableViewCell圆角化处理【UITableViewCell之间没有分割线】

作用于：- (void)tableView:(UITableView *)tableView willDisplayCell:(UITableViewCell *)cell forRowAtIndexPath:(NSIndexPath *)indexPath

[cell cutFirstAndLastTableViewCellWithBackgroundCor:HEXCOLOR(0xFFFFFF)
                                      bottomLineCor:HEXCOLOR(0xFFFFFF) 
                                     cellOutLineCor:HEXCOLOR(0xEEE2C8)
                                   cornerRadiusSize:CGSizeMake(JobsWidth(8), JobsWidth(8))
                                        borderWidth:JobsWidth(10)
                                                 dx:JobsWidth(0)
                                                 dy:JobsWidth(0)];

其他

隐藏最后一个单元格的分界线

-(void)hideSeparatorLineAtLast:(NSIndexPath *)indexPath
                          cell:(UITableViewCell *)cell{
    /// 判断是否是该 section 的最后一行
    if (indexPath.row == [self numberOfRowsInSection:indexPath.section] - 1){
        cell.separatorInset = UIEdgeInsetsMake(0, 0, 0, cell.bounds.size.width);
    }
}

自定义**UITableViewCell**的箭头

使用前提：必须UITableViewCell.accessoryType = UITableViewCellAccessoryDisclosureIndicator; 打开后才可以启用

作用于：- (void)tableView:(UITableView *)tableView willDisplayCell:(UITableViewCell *)cell forRowAtIndexPath:(NSIndexPath *)indexPath

-(void)customAccessoryView:(jobsByIDBlock)customAccessoryViewBlock{
    /// 不用系统自带的箭头
    if (self.accessoryType == UITableViewCellAccessoryDisclosureIndicator) {
        @jobs_weakify(self)
        BaseButton *btn = BaseButton.initByBackgroundImage(self.img)
            .bgColor(JobsClearColor.colorWithAlphaComponent(0))
            .onClick(^(__kindof UIButton *x){
                @jobs_strongify(self)
            if (self.objectBlock) self.objectBlock(x);
            if (customAccessoryViewBlock) customAccessoryViewBlock(self);
        });
        /// 特比注意:如果这个地方是纯view（UIView、UIIMageView...）就可以不用加size，UIButton是因为受到了UIControl，需要接收一个size，否则显示不出来
        btn.Size = self.Size;
        btn.resetByOffsetWidth(JobsWidth(5));
        self.accessoryView = btn;
    }
}

UITableView的完整调用

#pragma mark —— UI
@property(nonatomic,strong)BaseTableView *tableView;
// 分组的 cell
@property(nonatomic,strong)NSMutableArray <NSMutableArray <__kindof UITableViewCell *>*>*tbvSectionRowCellMutArr;
// 不分组的 cell
@property(nonatomic,strong)NSMutableArray <__kindof UITableViewCell *>*rowCellMutArr;
// sectionView
@property(nonatomic,strong)NSMutableArray <__kindof UITableViewHeaderFooterView *>*tbvHeaderFooterViewMutArr;
#pragma mark —— Data
// 分组的 Data
@property(nonatomic,strong)NSMutableArray <NSMutableArray <UIViewModel *>*>*dataMutArr;
// 不分组的 Data
@property(nonatomic,strong)NSMutableArray <UIViewModel *>*rowDataMutArr;

/// BaseViewProtocol
@synthesize tableView = _tableView;
-(BaseTableView *)tableView{
    if (!_tableView) {
        @jobs_weakify(self)
        _tableView = BaseTableView.initWithStylePlain;
        _tableView.dataLink(self);
        _tableView.backgroundColor = JobsClearColor.colorWithAlphaComponent(0);
        _tableView.separatorStyle = UITableViewCellSeparatorStyleNone;
        _tableView.separatorColor = JobsClearColor;
        _tableView.showsVerticalScrollIndicator = NO;
        _tableView.scrollEnabled = YES;
        _tableView.tableHeaderView = jobsMakeFMTableHeaderView1(^(__kindof FMTableHeaderView1 * _Nullable tableHeaderView) {
            @jobs_strongify(self)
            tableHeaderView.sizer = FMTableHeaderView1.viewSizeByModel(nil);
            tableHeaderView.jobsRichViewByModel(@(self.kyc_State));
        });/// 这里接入的就是一个UIView的派生类。只需要赋值Frame，不需要addSubview
        _tableView.tableFooterView = jobsMakeView(^(__kindof UIView * _Nullable view) {
            /// 这里接入的就是一个UIView的派生类。只需要赋值Frame，不需要addSubview
        });
        
        if(@available(iOS 11.0, *)) {
            _tableView.contentInsetAdjustmentBehavior = UIScrollViewContentInsetAdjustmentNever;
        }
        
        {
            _tableView.mj_header = self.MJRefreshNormalHeaderBy(jobsMakeRefreshConfigModel(^(__kindof MJRefreshConfigModel * _Nullable data) {
                data.stateIdleTitle = JobsInternationalization(@"下拉可以刷新");
                data.pullingTitle = JobsInternationalization(@"下拉可以刷新");
                data.refreshingTitle = JobsInternationalization(@"松开立即刷新");
                data.willRefreshTitle = JobsInternationalization(@"刷新数据中");
                data.noMoreDataTitle = JobsInternationalization(@"下拉可以刷新");
                data.automaticallyChangeAlpha = YES;/// 根据拖拽比例自动切换透明度
                data.loadBlock = ^id _Nullable(id  _Nullable data) {
                    @jobs_strongify(self)
                    self.feedbackGenerator();//震动反馈
                    return nil;
                };
            }));
            _tableView.mj_footer = self.MJRefreshFooterBy(jobsMakeRefreshConfigModel(^(__kindof MJRefreshConfigModel * _Nullable data) {
                data.stateIdleTitle = JobsInternationalization(@"");
                data.pullingTitle = JobsInternationalization(@"");
                data.refreshingTitle = JobsInternationalization(@"");
                data.willRefreshTitle = JobsInternationalization(@"");
                data.noMoreDataTitle = JobsInternationalization(@"");
                data.loadBlock = ^id _Nullable(id  _Nullable data) {
                    return nil;
                };
            }));
        }
        
        {
            _tableView.buttonModelEmptyData = jobsMakeButtonModel(^(__kindof UIButtonModel * _Nullable data) {
                data.title = JobsInternationalization(@"NO DATA FOUND");
                data.titleCor = JobsWhiteColor;
                data.titleFont = bayonRegular(JobsWidth(30));
                data.normalImage = JobsIMG(@"暂无数据");
                data.baseBackgroundColor = JobsClearColor.colorWithAlphaComponent(0);
            });
        }
        
        {// 设置tabAnimated相关属性
            _tableView.tabAnimated = [TABTableAnimated animatedWithCellClass:JobsBaseTableViewCell.class
                                                                  cellHeight:JobsBaseTableViewCell.cellHeightByModel(nil)];
            _tableView.tabAnimated.superAnimationType = TABViewSuperAnimationTypeBinAnimation;
            _tableView.tabAnimated.canLoadAgain = YES;
//            _tableView.tabAnimated.animatedBackViewCornerRadius = JobsWidth(8);
//            _tableView.tabAnimated.animatedBackgroundColor = JobsRedColor;
            [_tableView tab_startAnimation];   // 开启动画
        }

        [self addSubview:_tableView];
        [_tableView mas_makeConstraints:^(MASConstraintMaker *make) {
            make.top.equalTo(self.stepView.mas_bottom).offset(JobsWidth(5));
            make.left.equalTo(self).offset(JobsWidth(10));
            make.bottom.equalTo(self).offset(-JobsWidth(105));
            make.width.mas_equalTo(JobsWidth(420));
        }];

    }return _tableView;
}

#import "BaseView.h"

NS_ASSUME_NONNULL_BEGIN

@interface FMTableHeaderView1 : BaseView

@end

NS_ASSUME_NONNULL_END

// sectionView
-(NSMutableArray<__kindof UITableViewHeaderFooterView *> *)tbvHeaderFooterViewMutArr{
    if(!_tbvHeaderFooterViewMutArr){
        _tbvHeaderFooterViewMutArr = NSMutableArray.array;
        _tbvHeaderFooterViewMutArr.add(self.tableView.tableViewHeaderFooterView(FMTBVHeaderFooterView1.class,@""));
        _tbvHeaderFooterViewMutArr.add(self.tableView.tableViewHeaderFooterView(FMTBVHeaderFooterView2.class,@""));
        _tbvHeaderFooterViewMutArr.add(self.tableView.tableViewHeaderFooterView(FMTBVHeaderFooterView2.class,@""));
    }return _tbvHeaderFooterViewMutArr;
}
// 不分组的 cell
-(NSMutableArray<__kindof UITableViewCell *> *)rowCellMutArr{
    if(!_rowCellMutArr){
        _rowCellMutArr = NSMutableArray.array;
        _rowCellMutArr.add([FMTableViewCellStyle4 cellStyleValue1WithTableView:self.tableView]);
    }return _rowCellMutArr;
}
// 分组的 cell
-(NSMutableArray<NSMutableArray<__kindof UITableViewCell *> *> *)tbvSectionRowCellMutArr{
    if(!_tbvSectionRowCellMutArr){
        _tbvSectionRowCellMutArr = NSMutableArray.array;
        {
            NSMutableArray<__kindof UITableViewCell *> *rowCellMutArr = NSMutableArray.array;
            rowCellMutArr.add([FMTableViewCellStyle4 cellStyleValue1WithTableView:self.tableView]);
            rowCellMutArr.add([FMTableViewCellStyle3 cellStyleValue1WithTableView:self.tableView]);
            rowCellMutArr.add([FMTableViewCellStyle2 cellStyleValue1WithTableView:self.tableView]);
            rowCellMutArr.add([FMTableViewCellStyle4 cellStyleValue1WithTableView:self.tableView]);
            rowCellMutArr.add([FMTableViewCellStyle3 cellStyleValue1WithTableView:self.tableView]);
            rowCellMutArr.add([FMTableViewCellStyle3 cellStyleValue1WithTableView:self.tableView]);
            _tbvSectionRowCellMutArr.add(rowCellMutArr);
        }
        
        {
            NSMutableArray <__kindof UITableViewCell *>*rowCellMutArr = NSMutableArray.array;
            rowCellMutArr.add([FMTableViewCellStyle3 cellStyleValue1WithTableView:self.tableView]);
            rowCellMutArr.add([FMTableViewCellStyle1 cellStyleValue1WithTableView:self.tableView]);
            _tbvSectionRowCellMutArr.add(rowCellMutArr);
        }
        
        {
            NSMutableArray <__kindof UITableViewCell *>*rowCellMutArr = NSMutableArray.array;
            rowCellMutArr.add([FMTableViewCellStyle3 cellStyleValue1WithTableView:self.tableView]);
            rowCellMutArr.add([FMTableViewCellStyle1 cellStyleValue1WithTableView:self.tableView]);
            _tbvSectionRowCellMutArr.add(rowCellMutArr);
        }
        
    }return _tbvSectionRowCellMutArr;
}

// 不分组的 Data
-(NSMutableArray<UIViewModel *> *)rowDataMutArr{
    if(!_rowDataMutArr){
        _rowDataMutArr = NSMutableArray.array;
        
        {
            UIViewModel *viewModel = UIViewModel.new;
            viewModel.text = JobsInternationalization(@"Please fill out your Personal Information completely");
            viewModel.textCor = JobsCor(@"#FFC700");
            viewModel.font = bayonRegular(JobsWidth(20));
            _rowDataMutArr.data = viewModel;
        }
        
        {
            UIViewModel *viewModel = UIViewModel.new;
            viewModel.text = JobsInternationalization(@"Nationality");
            viewModel.textCor = JobsCor(@"#FFFFFF");
            viewModel.font = UIFontWeightRegularSize(14);
            viewModel.placeholder = JobsInternationalization(@"Philippines");
            _rowDataMutArr.add(viewModel);
        }
        
        {
            UIViewModel *viewModel = UIViewModel.new;
            viewModel.text = JobsInternationalization(@"Nationality");
            viewModel.textCor = JobsCor(@"#FFFFFF");
            viewModel.font = UIFontWeightRegularSize(14);
            viewModel.placeholder = JobsInternationalization(@"Philippines");
            _rowDataMutArr.add(viewModel);
        }
    }return _rowDataMutArr;
}
// 分组的 Data
-(NSMutableArray<NSMutableArray<UIViewModel *> *> *)dataMutArr{
    if(!_dataMutArr){
        _dataMutArr = NSMutableArray.array;
        {
            NSMutableArray <UIViewModel *>*temp = NSMutableArray.array;
            {
                UIViewModel *viewModel = UIViewModel.new;
                viewModel.text = JobsInternationalization(@"Please fill out your Personal Information completely");
                viewModel.textCor = JobsCor(@"#FFC700");
                viewModel.font = bayonRegular(JobsWidth(20));
                temp.data = viewModel;
            }
            
            {
                UIViewModel *viewModel = UIViewModel.new;
                viewModel.text = JobsInternationalization(@"Full Name");
                viewModel.textCor = JobsCor(@"#FFFFFF");
                viewModel.font = UIFontWeightRegularSize(14);
                viewModel.placeholder = JobsInternationalization(@"This Name must match the name on any IDs or any bank accounts");
                temp.add(viewModel);
            }
            {
                UIViewModel *viewModel = UIViewModel.new;
                viewModel.text = JobsInternationalization(@"Nationality");
                viewModel.textCor = JobsCor(@"#FFFFFF");
                viewModel.font = UIFontWeightRegularSize(14);
                viewModel.placeholder = JobsInternationalization(@"Philippines");
                temp.add(viewModel);
            }
            {
                UIViewModel *viewModel = UIViewModel.new;
                viewModel.text = JobsInternationalization(@"Date of Birth");
                viewModel.textCor = JobsCor(@"#FFFFFF");
                viewModel.font = UIFontWeightRegularSize(14);
                viewModel.subText = JobsInternationalization(@"21 / 09 / 2021");
                viewModel.subTextCor = JobsCor(@"#FFFFFF");
                viewModel.subFont = UIFontWeightRegularSize(14);
                temp.add(viewModel);
            }
            {
                UIViewModel *viewModel = UIViewModel.new;
                viewModel.text = JobsInternationalization(@"Place of Birth");
                viewModel.textCor = JobsCor(@"#FFFFFF");
                viewModel.font = UIFontWeightRegularSize(14);
                temp.add(viewModel);
            }
            {
                UIViewModel *viewModel = UIViewModel.new;
                viewModel.text = JobsInternationalization(@"Nature of Work");
                viewModel.textCor = JobsCor(@"#FFFFFF");
                viewModel.font = UIFontWeightRegularSize(14);
                temp.add(viewModel);
            }
            {
                UIViewModel *viewModel = UIViewModel.new;
                viewModel.text = JobsInternationalization(@"Source of Income");
                viewModel.textCor = JobsCor(@"#FFFFFF");
                viewModel.font = UIFontWeightRegularSize(14);
                temp.add(viewModel);
            }
            
            _dataMutArr.add(temp);
        }
        {
            NSMutableArray <UIViewModel *>*temp = NSMutableArray.array;
           {
               UIViewModel *viewModel = UIViewModel.new;
               viewModel.text = JobsInternationalization(@"Current Address");
               viewModel.textCor = JobsCor(@"#FFC700");
               viewModel.font = bayonRegular(JobsWidth(20));
               temp.data = viewModel;
           }
           
           {
               UIViewModel *viewModel = UIViewModel.new;
               viewModel.text = JobsInternationalization(@"Province/City");
               viewModel.textCor = JobsCor(@"#FFFFFF");
               viewModel.font = UIFontWeightRegularSize(14);
               temp.add(viewModel);
           }
           {
               UIViewModel *viewModel = UIViewModel.new;
               temp.add(viewModel);
          }
  
           _dataMutArr.add(temp);
       }
       {
           NSMutableArray <UIViewModel *>*temp = NSMutableArray.array;
           {
               UIViewModel *viewModel = UIViewModel.new;
               viewModel.text = JobsInternationalization(@"Permanent Address");
               viewModel.textCor = JobsCor(@"#FFC700");
               viewModel.font = bayonRegular(JobsWidth(20));
               temp.data = viewModel;
           }
           
           {
               UIViewModel *viewModel = UIViewModel.new;
               viewModel.text = JobsInternationalization(@"Province/City");
               viewModel.textCor = JobsCor(@"#FFFFFF");
               viewModel.font = UIFontWeightRegularSize(14);
               temp.add(viewModel);
           }
           {
               UIViewModel *viewModel = UIViewModel.new;
               temp.add(viewModel);
           }
           _dataMutArr.add(temp);
      }
}return _dataMutArr;
}

-(NSMutableArray<UIViewModel *> *)rowDataMutArr{
    if(!_rowDataMutArr){
        _rowDataMutArr = NSMutableArray.array;
        
        {
           UIViewModel *viewModel = UIViewModel.new;
           viewModel.text = JobsInternationalization(@"Please fill out your Personal Information completely");
           viewModel.textCor = JobsCor(@"#FFC700");
           viewModel.font = bayonRegular(JobsWidth(20));
           _rowDataMutArr.data = viewModel;
       }
       
       {
           UIViewModel *viewModel = UIViewModel.new;
           viewModel.text = JobsInternationalization(@"Nationality");
           viewModel.textCor = JobsCor(@"#FFFFFF");
           viewModel.font = UIFontWeightRegularSize(14);
           viewModel.placeholder = JobsInternationalization(@"Philippines");
           _rowDataMutArr.add(viewModel);
       }
       
       {
           UIViewModel *viewModel = UIViewModel.new;
           viewModel.text = JobsInternationalization(@"Nationality");
           viewModel.textCor = JobsCor(@"#FFFFFF");
           viewModel.font = UIFontWeightRegularSize(14);
           viewModel.placeholder = JobsInternationalization(@"Philippines");
           _rowDataMutArr.add(viewModel);
       }
  }return _rowDataMutArr;
}

#pragma mark —— UITableViewDelegate,UITableViewDataSource
- (void)tableView:(UITableView *)tableView
commitEditingStyle:(UITableViewCellEditingStyle)editingStyle
forRowAtIndexPath:(NSIndexPath *)indexPath{
    
}
/// 编辑模式下，点击取消左边已选中的cell的按钮
- (void)tableView:(UITableView *)tableView
didDeselectRowAtIndexPath:(NSIndexPath *)indexPath{
    
}

- (void)tableView:(UITableView *)tableView
didSelectRowAtIndexPath:(NSIndexPath *)indexPath{
		UITableViewCell *cell = [tableView cellForRowAtIndexPath:indexPath];
    for (UITableViewCell *visibleCell in tableView.visibleCells) {
        
    }
}

- (NSInteger)numberOfSectionsInTableView:(UITableView *)tableView {
    return self.tbvSectionRowCellMutArr.count;
}

- (CGFloat)tableView:(UITableView *)tableView
heightForRowAtIndexPath:(NSIndexPath *)indexPath{
    return JobsWidth(36);
}

- (NSInteger)tableView:(UITableView *)tableView
 numberOfRowsInSection:(NSInteger)section{
    return self.tbvSectionRowCellMutArr[section].count;
}

- (__kindof UITableViewCell *)tableView:(UITableView *)tableView
            	    cellForRowAtIndexPath:(NSIndexPath *)indexPath{
   JobsBaseTableViewCell *cell = self.tbvSectionRowCellMutArr[indexPath.section][indexPath.row];
   cell.accessoryType = UITableViewCellAccessoryDisclosureIndicator;
   cell.indexPath = indexPath;
   cell.richElementsInCellWithModel(self.dataMutArr[indexPath.section][indexPath.row]);
   return cell;
}

- (CGFloat)tableView:(UITableView *)tableView
heightForHeaderInSection:(NSInteger)section{
   return JobsWidth(36);
}
/// 这里涉及到复用机制，return出去的是UITableViewHeaderFooterView的派生类
- (UIView *)tableView:(UITableView *)tableView
viewForHeaderInSection:(NSInteger)section{
   UITableViewHeaderFooterView *headerView = self.tbvHeaderFooterViewMutArr[section];
   // 不写这三句有悬浮
   headerView.headerFooterViewStyle = JobsHeaderViewStyle;
   headerView.tableView = tableView;
   headerView.section = section;
   headerView.jobsRichElementsInViewWithModel(self.dataMutArr[section].data);
   @jobs_weakify(self)
   [headerView actionObjectBlock:^(id data) {
       @jobs_strongify(self)
   }];return headerView;
}

- (void)tableView:(UITableView *)tableView
 willDisplayCell:(UITableViewCell *)cell
forRowAtIndexPath:(NSIndexPath *)indexPath{
   /// 隐藏最后一个单元格的分界线
   [tableView hideSeparatorLineAtLast:indexPath
                                 cell:cell];
   /// 自定义 UITableViewCell 的箭头
   cell.img = JobsIMG(@"向右的箭头（大）");
   @jobs_weakify(self)
   [cell customAccessoryView:^(id data) {
       @jobs_strongify(self)
       JobsBaseTableViewCell *cell = (JobsBaseTableViewCell *)data;
       NSLog(@"MMM - %ld",cell.index);
   }];
   /// 以section为单位，每个section的第一行和最后一行的cell圆角化处理【cell之间没有分割线】
   [cell cutFirstAndLastTableViewCellWithBackgroundCor:HEXCOLOR(0xFFFFFF)
                                         bottomLineCor:HEXCOLOR(0xFFFFFF) 
                                        cellOutLineCor:HEXCOLOR(0xEEE2C8)
                                      cornerRadiusSize:CGSizeMake(JobsWidth(8), JobsWidth(8))
                                           borderWidth:JobsWidth(10)
                                                    dx:JobsWidth(0)
                                                    dy:JobsWidth(0)];
}
#pragma mark —— UIScrollViewDelegate
- (void)scrollViewDidScroll:(UIScrollView *)scrollView {
   /// 关闭悬停效果
   CGFloat sectionHeaderHeight = JobsWidth(36); /// header的高度
   if (scrollView.contentOffset.y <= sectionHeaderHeight && scrollView.contentOffset.y >= 0) {
       scrollView.resetContentInsetTop(-scrollView.contentOffset.y);
   } else if (scrollView.contentOffset.y >= sectionHeaderHeight) {
       scrollView.resetContentInsetTop(-sectionHeaderHeight);
   }
   scrollView.resetContentInsetOffsetBottom(200);/// 额外增加的可滑动区域距离
}

29.2、关于`UITableViewHeaderFooterView`（`viewForHeaderInSection`）

**UICollectionView**没有类型相关的东西，有如下替代方案
- 使用 UICollectionReusableView 作为头视图
系统默认布局
- 如果同时设置了sectionHeaderHeight和sectionFooterHeight ，=> 那么在每一个sectionHeader距离上一组的尾部，总会有一段距离（这个距离是22）
- 如果只设置sectionHeaderHeight（或者不管这个值设置的有多小），而不设置sectionFooterHeight ，=> 那么在每一个sectionHeader距离上一组的尾部，总会有一段距离（这个距离是22）
- 如果不设置sectionHeaderHeight，只设置sectionFooterHeight ，=> 那么每个组之间无缝隙丝滑相接

高度的优先级 => 协议方法的优先级 > 属性的优先级

如果同时实现，则协议方法会覆盖属性配置

- (CGFloat)tableView:(UITableView *)tableView heightForHeaderInSection:(NSInteger)section;
- (CGFloat)tableView:(UITableView *)tableView heightForFooterInSection:(NSInteger)section;

_tableView.sectionFooterHeight;
_tableView.sectionHeaderHeight;

UITableViewHeaderFooterView 的背景色

默认情况下，UITableViewHeaderFooterView.backgroundView 是 nil

self.backgroundColor 
  和 
self.contentView.backgroundColor 
  
均是无效操作❌

只有 
self.backgroundView.backgroundColor 
是有效操作✅

视图结构
- 悬浮的时候：UITableViewHeaderFooterView→_UISystemBackgroundView(系统内部类)→UIVisualEffectView(系统内部类)→_UIVisualEffectBackdropView（系统内部类）→_UIVisualEffectContentView（系统内部类）→_UITableViewHeaderFooterContentView（系统内部类）
- 未悬浮的时候：UITableViewHeaderFooterView→_UISystemBackgroundView（系统内部类） →UIView→_UITableViewHeaderFooterContentView（系统内部类）
- 结论
  - _UIVisualEffectBackdropView带背景色
  - 悬浮的时候，视图结构会发生变化。关注点：新产生的视图的背景色
  - 也就意味着，当视图内部进行调整的时候，会执行
```
- (void)layoutSubviews{
    [super layoutSubviews];
    NSLog(@"");
}
```
- 解决方案
  - 在具体的UITableViewHeaderFooterView *子类，执行
    
    此时，设置背景色是无效的
```
- (void)layoutSubviews{
    [super layoutSubviews];
    NSLog(@"");
    // 遍历子视图，找到UIVisualEffectView
      for (UIView *subview in self.subviews) {
          if([subview isKindOfClass:NSClassFromString(@"_UISystemBackgroundView")]){
              // subview.backgroundColor = JobsClearColor; 设置成透明色，无效
              subview.jobsVisible = NO;
          }
      }
}
```

UITableView 取消viewForHeaderInSection 产生的悬停效果

如果使用BaseTableView.initWithStylePlain;则会产生悬停效果

方法一：viewForHeaderInSection 有值有高度 强烈推荐

假设 viewForHeaderInSection 的高度为 JobsWidth(36)，需要实现如下父类协议关闭悬停效果

#pragma mark - UIScrollViewDelegate
- (void)scrollViewDidScroll:(UIScrollView *)scrollView {
    /// 关闭悬停效果
    CGFloat sectionHeaderHeight = JobsWidth(36); /// header的高度
    if (scrollView.contentOffset.y <= sectionHeaderHeight && scrollView.contentOffset.y >= 0) {
        scrollView.resetContentInsetTop(-scrollView.contentOffset.y);
    } else if (scrollView.contentOffset.y >= sectionHeaderHeight) {
        scrollView.resetContentInsetTop(-sectionHeaderHeight);
    }
    scrollView.resetContentInsetOffsetBottom(200);/// 额外增加的可滑动区域距离
}

方法二：强烈推荐

用了方法二，就可以不用方法一
资料来源

继承自基类**BaseTableViewHeaderFooterView**

只能在基类实现。不可在分类实现

/**
 #import "UITableViewHeaderFooterView+Attribute.h"
 在具体的子类实现，实现控制UITableViewHeaderFooterView是否悬停
 资料来源：https://github.com/Zydhjx/HeaderDemo
 */
- (void)setFrame:(CGRect)frame {
    if (self.headerFooterViewStyle == JobsHeaderViewStyle) {
        [super setFrame:[self.tableView rectForHeaderInSection:self.section]];
    }else if (self.headerFooterViewStyle == JobsFooterViewStyle){
        [super setFrame:[self.tableView rectForFooterInSection:self.section]];
    }else{}
}

关注实现类：@interface BaseTableViewHeaderFooterView : UITableViewHeaderFooterView + @interface UITableViewHeaderFooterView (Attribute)

/// 这里涉及到复用机制，return出去的是UITableViewHeaderFooterView的派生类
- (UIView *)tableView:(UITableView *)tableView
viewForHeaderInSection:(NSInteger)section{
    UITableViewHeaderFooterView *headerView = self.tbvHeaderFooterViewMutArr[section];
    {
        /**
         如果不是继承自BaseTableViewHeaderFooterView，那么在UITableViewHeaderFooterView的派生类中，添加：
         @synthesize headerFooterViewStyle = _headerFooterViewStyle;
         */
        // 不写这三句有悬浮
        headerView.headerFooterViewStyle = JobsHeaderViewStyle;
        headerView.tableView = tableView;
        headerView.section = section;
    }
    headerView.jobsRichElementsInViewWithModel(self.dataMutArr[section].data);
    @jobs_weakify(self)
    [headerView actionObjectBlock:^(id data) {
        @jobs_strongify(self)
    }];return headerView;
}

方法三：取巧，不推荐

#pragma mark - UITableViewDelegate
- (CGFloat)tableView:(UITableView *)tableView heightForHeaderInSection:(NSInteger)section {
    return CGFLOAT_MIN; // 设置 header 高度为非常小的值
}

- (UIView *)tableView:(UITableView *)tableView viewForHeaderInSection:(NSInteger)section {
    return UIView.new; // 返回一个空的 UIView
}

如果使用BaseTableView.initWithStyleGrouped;，则不会产生悬停效果

如果需要在整个TableView的首尾出现一个大View，则用下面的代码。注意和**viewForHeaderInSection**进行区分
```
_tableView.tableHeaderView;
_tableView.tableFooterView;
```

注册（注册不开辟内存，通过全局唯一的字符串进行取值的时候才开辟内存）

_tableView.registerHeaderFooterViewClass(FMTBVHeaderFooterView1.class,@"");
_tableView.registerHeaderFooterViewClass(FMTBVHeaderFooterView2.class,@"");

这里涉及到复用机制，return出去的是**UITableViewHeaderFooterView**的派生类

- (UIView *)tableView:(UITableView *)tableView
viewForHeaderInSection:(NSInteger)section{
    if(section == 0){
        FMTBVHeaderFooterView1 *headerView = tableView.tableViewHeaderFooterView(FMTBVHeaderFooterView1.class,@"");
        if(!headerView){
//            headerView = FMTBVHeaderFooterView1.jobsInitWithReuseIdentifier(@"");// 不要用这个
            tableView.registerHeaderFooterViewClass(FMTBVHeaderFooterView1.class,@"");
            headerView = tableView.tableViewHeaderFooterView(FMTBVHeaderFooterView1.class,@"");
        }
        headerView.backgroundColor = JobsRedColor;
        // 不写这三句有悬浮
        headerView.headerFooterViewStyle = JobsHeaderViewStyle;
        headerView.tableView = tableView;
        headerView.section = section;
        headerView.jobsRichElementsInViewWithModel(self.dataMutArr[section].data);
        @jobs_weakify(self)
        [headerView actionObjectBlock:^(id data) {
            @jobs_strongify(self)
        }];return headerView;
    }else if (section == 1){
        FMTBVHeaderFooterView2 *headerView = tableView.tableViewHeaderFooterView(FMTBVHeaderFooterView2.class,@"");
        if(!headerView){
//            headerView = FMTBVHeaderFooterView2.jobsInitWithReuseIdentifier(@"");// 不要用这个
            tableView.registerHeaderFooterViewClass(FMTBVHeaderFooterView2.class,@"");
            headerView = tableView.tableViewHeaderFooterView(FMTBVHeaderFooterView2.class,@"");
        }
        headerView.backgroundColor = JobsBlueColor;
        {
            /**
             如果不是继承自BaseTableViewHeaderFooterView，那么在UITableViewHeaderFooterView的派生类中，添加：
             @synthesize headerFooterViewStyle = _headerFooterViewStyle;
             */
            // 不写这三句有悬浮
            headerView.headerFooterViewStyle = JobsHeaderViewStyle;
            headerView.tableView = tableView;
            headerView.section = section;
        }
        headerView.jobsRichElementsInViewWithModel(self.dataMutArr[section].data);
        @jobs_weakify(self)
        [headerView actionObjectBlock:^(id data) {
            @jobs_strongify(self)
        }];return headerView;
    }else if (section == 2){
        FMTBVHeaderFooterView2 *headerView = tableView.tableViewHeaderFooterView(FMTBVHeaderFooterView2.class,@"");
        if(!headerView){
//            headerView = FMTBVHeaderFooterView2.jobsInitWithReuseIdentifier(@"");// 不要用这个
            tableView.registerHeaderFooterViewClass(FMTBVHeaderFooterView2.class,@"");
            headerView = tableView.tableViewHeaderFooterView(FMTBVHeaderFooterView2.class,@"");
        }
        headerView.backgroundColor = JobsYellowColor;
        // 不写这三句有悬浮
        headerView.headerFooterViewStyle = JobsHeaderViewStyle;
        headerView.tableView = tableView;
        headerView.section = section;
        headerView.jobsRichElementsInViewWithModel(self.dataMutArr[section].data)
        @jobs_weakify(self)
        [headerView actionObjectBlock:^(id data) {
            @jobs_strongify(self)
        }];return headerView;
    }else return UIView.new;
}

/// 这里涉及到复用机制，return出去的是UITableViewHeaderFooterView的派生类
- (nullable UIView *)tableView:(UITableView *)tableView
        viewForFooterInSection:(NSInteger)section{
    if(self.viewModel.usesTableViewFooterView){
        BaseTableViewHeaderFooterView *tbvFooterView = tableView.tableViewHeaderFooterView(BaseTableViewHeaderFooterView.class,@"");
        {
            // 不写这三句有悬浮
 						tbvFooterView.headerFooterViewStyle = JobsHeaderViewStyle;
      		  tbvFooterView.tableView = tableView;
       		  tbvFooterView.section = section;
        }
        tbvFooterView.backgroundColor = HEXCOLOR(0xEAEBED);
        tbvFooterView.backgroundView.backgroundColor = HEXCOLOR(0xEAEBED);
        tbvFooterView.jobsRichElementsInViewWithModel(nil);
        @jobs_weakify(self)
        [tbvFooterView actionObjectBlock:^(id data) {
            @jobs_strongify(self)
        }];return tbvFooterView;
    }return nil;
}

- (CGFloat)tableView:(UITableView *)tableView
heightForHeaderInSection:(NSInteger)section{
    return JobsWidth(36);
}

- (CGFloat)tableView:(UITableView *)tableView
heightForFooterInSection:(NSInteger)section{
    return JobsWidth(10);
}

对 UITableView.section的header和footer高度设置

不实现 footer、header 设置方法，默认无 header、footer
footer 设置同 header 设置
iOS 11 设置 header 高度必须同时实现 viewForHeaderInSection 和 heightForHeaderInSection
iOS 11 之前版本只设置 heightForHeaderInSection 即可设置 header 高度，只是在 UITableViewStyleGrouped 时无法设置 header 高度为0，设置0时高度为系统默认高度

UITableViewStylePlain	iOS 11	< iOS 11
`viewForHeaderInSection`	只实现此方法 header 高度为系统默认	只实现此方法 header 设置无效
`heightForHeaderInSection`	只实现此方法 header 设置无效	只实现此方法 header 高度设置有效
同时实现 `viewForHeaderInSection` 和 `heightForHeaderInSection`	header 高度设置有效	header 高度设置有效

UITableViewStyleGrouped	iOS 11	< iOS 11
`viewForHeaderInSection`	只实现此方法 header 高度为系统默认	只实现此方法 header 高度为系统默认
`heightForHeaderInSection`	只实现此方法 header 高度为系统默认	实现此方法 header 高度设置有效，不可为0
同时实现 `viewForHeaderInSection` 和 `heightForHeaderInSection`	header 高度设置有效	header 高度设置有效

**UITableViewHeaderFooterView**的子类

#import "BaseViewProtocol.h"
#import "UIViewModelOthersProtocol.h"

NS_ASSUME_NONNULL_BEGIN

@interface FMTBVHeaderFooterView1 : UITableViewHeaderFooterView
<BaseViewProtocol,UIViewModelOthersProtocol>
@end

NS_ASSUME_NONNULL_END

#import "FMTBVHeaderFooterView1.h"

@interface FMTBVHeaderFooterView1 ()
/// UI
@property(nonatomic,strong)UILabel *titleLab;

@end

@implementation FMTBVHeaderFooterView1
@synthesize viewModel = _viewModel;
/// 具体由子类进行复写【数据定UI】【如果所传参数为基本数据类型，那么包装成对象NSNumber进行转化承接】
-(jobsByIDBlock)jobsRichElementsInViewWithModel{
    @jobs_weakify(self)
    return ^(id _Nullable model) {
        @jobs_strongify(self)
  		  self.contentView.backgroundColor = self.backgroundColor = JobsClearColor.colorWithAlphaComponent(0);
        if([model isKindOfClass:UIViewModel.class]){
           self.viewModel = (UIViewModel *)model;
    }self.titleLab.alpha = 1;
  };
}
#pragma mark —— lazyLoad
-(UILabel *)titleLab{
    if(!_titleLab){
        _titleLab = UILabel.new;
        _titleLab.text = self.viewModel.text;
        _titleLab.font = self.viewModel.font;
        _titleLab.textColor = self.viewModel.textCor;
        [self.contentView addSubview:_titleLab];
        [_titleLab mas_makeConstraints:^(MASConstraintMaker *make) {
            make.edges.equalTo(self.contentView);
        }];
    }return _titleLab;
}

@end

29.3、`UITableViewCell`

**UITableViewCell**的自带样式。关注实现类：@implementation UITableViewCell (UITableViewCellProtocol)

UITableViewCellStyleDefault

+(JobsReturnTableViewCellByTableViewBlock _Nonnull)cellStyleDefaultWithTableView{
    @jobs_weakify(self)
    return ^(UITableView * _Nonnull tableView) {
        @jobs_strongify(self)
        UITableViewCell *cell = tableView.tableViewCellClass(self.class,@"");
        if (!cell) {
            cell = [self initTableViewCell:self
                                 withStyle:UITableViewCellStyleDefault];
            cell.settingForTableViewCell();
        }return cell;
    };
}

UITableViewCellStyleSubtitle

+(JobsReturnTableViewCellByTableViewBlock _Nonnull)cellStyleSubtitleWithTableView{
    @jobs_weakify(self)
    return ^(UITableView * _Nonnull tableView) {
        @jobs_strongify(self)
        UITableViewCell *cell = (UITableViewCell *)tableView.tableViewCellClass(self.class,@"");
        if (!cell) {
            cell = [self initTableViewCell:self
                                 withStyle:UITableViewCellStyleSubtitle];
            cell.settingForTableViewCell();
        }return cell;
    };
}

UITableViewCellStyleValue1

+(JobsReturnTableViewCellByTableViewBlock _Nonnull)cellStyleValue1WithTableView{
    @jobs_weakify(self)
    return ^(UITableView * _Nonnull tableView) {
        @jobs_strongify(self)
        UITableViewCell *cell = tableView.tableViewCellClass(self.class,@"");
        if (!cell) {
            cell = [self initTableViewCell:self
                                 withStyle:UITableViewCellStyleValue1];
            cell.settingForTableViewCell();
        }return cell;
    };
}

UITableViewCellStyleValue2

+(JobsReturnTableViewCellByTableViewBlock _Nonnull)cellStyleValue2WithTableView{
    @jobs_weakify(self)
    return ^(UITableView * _Nonnull tableView) {
        @jobs_strongify(self)
        UITableViewCell *cell = tableView.tableViewCellClass(self.class,@"");
        if (!cell) {
            cell = [self initTableViewCell:self
                                 withStyle:UITableViewCellStyleValue2];
            cell.settingForTableViewCell();
        }return cell;
    };
}

一些用做基类的**UITableViewCell**
- JobsBaseTableViewCell：用于内部子控件的重定义Frame
- JobsBtnStyleTBVCell：将一个按钮整体覆盖在TableViewCell之上，利用按钮内部图文进行布局
  - JobsImageStyleTBVCell：将一个图像整体覆盖在TableViewCell之上
- JobsTextStyleTBVCell：将一个文本整体覆盖在TableViewCell之上
  - JobsBtnsStyleTBVCell：左右两边各有一个UIButton
UITableViewCell.registerClass
- 使用registerClass注册UITableViewCell与直接创建UITableViewCell实例之间的主要区别在于单元格的重用机制
- 生命周期
  - 注册阶段
    
    当调用 registerClass 方法时，UITableView 会提前为指定的重用标识符（CellIdentifier）注册一个 UITableViewCell 类。这样，当需要显示单元格时，UITableView 可以快速创建单元格实例。
```
[self.tableView registerClass:UITableViewCell.class forCellReuseIdentifier:@"CellIdentifier"];
```
  - 创建阶段
```
UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:@"CellIdentifier"];
if (cell == nil) {
    cell = [[UITableViewCell alloc] initWithStyle:UITableViewCellStyleDefault reuseIdentifier:@"CellIdentifier"];
```
    - 在 tableView:cellForRowAtIndexPath: 方法中，当需要显示某一行时，调用 dequeueReusableCellWithIdentifier: 方法
    - 如果有可重用的单元格存在（即之前已经创建并离开屏幕的单元格），则返回该重用单元格
    - 如果没有可重用的单元格存在，UITableView 会使用 registerClass 注册的类来创建一个新的单元格实例
  - 配置阶段
    - 调用 cellForRowAtIndexPath: 方法时，获取重用或新创建的单元格实例，并配置其内容
  - 显示阶段
    - 将配置好的单元格显示在屏幕上
  - 重用阶段
    - 当单元格滑出屏幕时，系统会将其放入重用队列，以便后续使用

示例代码

使用 registerClass 注册 UITableViewCell

- (void)viewDidLoad {
    [super viewDidLoad];
    [self.tableView registerClass:[UITableViewCell class] forCellReuseIdentifier:@"CellIdentifier"];
}

- (__kindof UITableViewCell *)tableView:(UITableView *)tableView 
                  cellForRowAtIndexPath:(NSIndexPath *)indexPath{
    UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:@"CellIdentifier" forIndexPath:indexPath];
    cell.textLabel.text = [NSString stringWithFormat:@"Row %ld", (long)indexPath.row];
    return cell;
}

不使用 registerClass 直接创建 UITableViewCell

- (__kindof UITableViewCell *)tableView:(UITableView *)tableView
                  cellForRowAtIndexPath:(NSIndexPath *)indexPath{
    UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:@"CellIdentifier"];
    if (cell == nil) {
        cell = [[UITableViewCell alloc] initWithStyle:UITableViewCellStyleDefault reuseIdentifier:@"CellIdentifier"];
    }
    cell.textLabel.text = [NSString stringWithFormat:@"Row %ld", (long)indexPath.row];
    return cell;
}

编辑模式

- (void)tableView:(UITableView *)tableView
commitEditingStyle:(UITableViewCellEditingStyle)editingStyle
forRowAtIndexPath:(NSIndexPath *)indexPath{
    
}

/// 编辑模式下，点击取消左边已选中的cell的按钮
- (void)tableView:(UITableView *)tableView
didDeselectRowAtIndexPath:(NSIndexPath *)indexPath{
    
}

MGSwipeTableCell 滑动的**TableViewCell**

pod 'MGSwipeTableCell' # https://github.com/MortimerGoro/MGSwipeTableCell 滑动tableViewCell

#if __has_include(<MGSwipeTableCell/MGSwipeTableCell.h>)
#import <MGSwipeTableCell/MGSwipeTableCell.h>
#else
#import "MGSwipeTableCell.h"
#endif

29.4、锚定点击的控件下方（动画）出现的下拉菜单`JobsDropDownListView`

内部用**UITableView**创建

- (void)dealloc{
    NSLog(@"%@",JobsLocalFunc);
//    JobsRemoveNotification(self);;
    [self endDropDownListView];
}

-(UIButton *)btn{
    if(!_btn){
        @jobs_weakify(self)
        _btn = [BaseButton.alloc jobsInitBtnByConfiguration:nil
                                                 background:nil
                                 buttonConfigTitleAlignment:UIButtonConfigurationTitleAlignmentAutomatic
                                              textAlignment:NSTextAlignmentCenter
                                           subTextAlignment:NSTextAlignmentCenter
                                                normalImage:nil
                                             highlightImage:nil
                                            attributedTitle:nil
                                    selectedAttributedTitle:nil
                                         attributedSubtitle:nil
                                                      title:JobsInternationalization(@"点击按钮弹出下拉列表")
                                                   subTitle:nil
                                                  titleFont:UIFontWeightRegularSize(12)
                                               subTitleFont:nil
                                                   titleCor:JobsWhiteColor
                                                subTitleCor:nil
                                         titleLineBreakMode:NSLineBreakByWordWrapping
                                      subtitleLineBreakMode:NSLineBreakByWordWrapping
                                        baseBackgroundColor:JobsOrangeColor
                                            backgroundImage:nil
                                               imagePadding:JobsWidth(0)
                                               titlePadding:JobsWidth(0)
                                             imagePlacement:NSDirectionalRectEdgeNone
                                 contentHorizontalAlignment:UIControlContentHorizontalAlignmentCenter
                                   contentVerticalAlignment:UIControlContentVerticalAlignmentCenter
                                              contentInsets:jobsSameDirectionalEdgeInsets(0)
                                          cornerRadiusValue:JobsWidth(8)
                                            roundingCorners:UIRectCornerAllCorners
                                       roundingCornersRadii:CGSizeZero
                                             layerBorderCor:nil
                                                borderWidth:JobsWidth(1)
                                              primaryAction:nil
                                 longPressGestureEventBlock:^(id  _Nullable weakSelf,
                                                              id  _Nullable arg) {
            NSLog(@"按钮的长按事件触发");
     }
                                            clickEventBlock:^id(BaseButton *x){
            @jobs_strongify(self)
            if (self.objectBlock) self.objectBlock(x);
            NSLog(@"AAA = %@",self.dropDownListView);
            x.selected = !x.selected;
            if (x.selected) {
                /// ❤️只能让它执行一次❤️
                self.dropDownListView = [self motivateFromView:x
                                 jobsDropDownListViewDirection:self.dropDownListViewDirection
                                                          data:self.listViewData
                                            motivateViewOffset:JobsWidth(5)
                                                   finishBlock:^(UIViewModel *data) {
                    NSLog(@"data = %@",data);
                }];
            }else{
                [self endDropDownListView];
            }return nil;
         return nil;
        }];
        [self.view addSubview:_btn];
        [_btn mas_makeConstraints:^(MASConstraintMaker *make) {
            make.center.equalTo(self.view);
//            make.size.mas_equalTo(CGSizeMake(JobsWidth(120), JobsWidth(25)));
            make.height.mas_equalTo(JobsWidth(30));
        }];
        _btn.makeBtnLabelByShowingType(UILabelShowingType_03);
    }return _btn;
}

30、`JobsStepView` 回到顶部

-(JobsStepView *)stepView{
    if(!_stepView){
        _stepView = jobsMakeStepView(^(__kindof JobsStepView * _Nullable stepView) {
            stepView.backgroundColor = JobsClearColor;
            stepView.offset = JobsWidth(10);
            self.addSubview(stepView);
            [stepView mas_makeConstraints:^(MASConstraintMaker *make) {
                make.top.equalTo(self).offset(JobsWidth(20));
                make.left.equalTo(self).offset(JobsWidth(10));
                make.size.mas_equalTo(stepView.viewSizeByModel(nil));
            }];stepView.jobsRichViewByModel(jobsMakeMutArr(^(__kindof NSMutableArray * _Nullable data) {
                data.add(jobsMakeButtonModel(^(__kindof UIButtonModel * _Nullable data1) {
                    data1.title = JobsInternationalization(@"Unverified");
                    data1.titleCor = JobsWhiteColor;
                    data1.titleFont = UIFontWeightRegularSize(14);
                    data1.normalImage = JobsIMG(@"正在进行第一步");
                    data1.imagePlacement = NSDirectionalRectEdgeTop;
                    data1.imagePadding = JobsWidth(8);
                    data1.roundingCorners = UIRectCornerAllCorners;
                    data1.leftViewWidth = JobsWidth(80);
                    data1.rightViewWidth = JobsWidth(80);
                    data1.baseBackgroundColor = JobsClearColor;
                    data1.selected = YES;
                }));
                data.add(jobsMakeButtonModel(^(__kindof UIButtonModel * _Nullable data1) {
                    data1.title = JobsInternationalization(@"Verifiying");
                    data1.titleCor = JobsWhiteColor;
                    data1.titleFont = UIFontWeightRegularSize(14);
                    data1.normalImage = JobsIMG(@"还未进行第二步");
                    data1.imagePlacement = NSDirectionalRectEdgeTop;
                    data1.imagePadding = JobsWidth(8);
                    data1.roundingCorners = UIRectCornerAllCorners;
                    data1.leftViewWidth = JobsWidth(80);
                    data1.rightViewWidth = JobsWidth(80);
                    data1.baseBackgroundColor = JobsClearColor;
                    data1.selected = YES;
                }));
                data.add(jobsMakeButtonModel(^(__kindof UIButtonModel * _Nullable data1) {
                    data1.title = JobsInternationalization(@"Verified");
                    data1.titleCor = JobsWhiteColor;
                    data1.titleFont = UIFontWeightRegularSize(14);
                    data1.normalImage = JobsIMG(@"还未进行第三步");
                    data1.imagePlacement = NSDirectionalRectEdgeTop;
                    data1.imagePadding = JobsWidth(8);
                    data1.roundingCorners = UIRectCornerAllCorners;
                    data1.leftViewWidth = JobsWidth(80);
                    data1.rightViewWidth = JobsWidth(80);
                    data1.baseBackgroundColor = JobsClearColor;
                    data1.selected = YES;
                }));
            }));
        });
    }return _stepView;
}

31、关于`UITabBarController` 回到顶部

31.1、架构说明

JobsTabBarVC：UITabBarController
- JobsTabBarItemConfig：NSObject
- UITabBarItem
  - JobsTabBarItem：UITabBarItem
  - UITabBarItem+TLAnimation
- UITabBar
  - UITabBar+Ex
  - UITabBar+TLAnimation
  - JobsTabBar：UITabBar
JobsCustomTabBarVC：UITabBarController
- JobsCustomTabBarConfig：NSObject
- JobsCustomTabBar：UIView
- JobsCustomTabBarButton：UIButton
LZTabBarController：UITabBarController
- LZTabBar：UIView
- LZTabBarConfig ：NSObject
- LZTabBarItem：UIView

31.2、自定义 `UITabBarController`

x

32、切角回到顶部

切整个View的4个角为统一的切角参数

-(JobsReturnViewByFloatBlock _Nonnull)cornerCutToCircleWithCornerRadius{
    @jobs_weakify(self)
    return ^(CGFloat cornerRadiusValue) {
        @jobs_strongify(self)
        self.layer.cornerRadius = cornerRadiusValue;
        self.layer.masksToBounds = YES;
        return self;
    };
}

指定圆切角

⚠️这种写法存在一定的弊端：如果在某个View上添加子View，并对这个View使用如下方法的圆切角，则这个View上的子视图不可见⚠️

-(void)appointCornerCutToCircleByRoundingCorners:(UIRectCorner)corners cornerRadii:(CGSize)cornerRadii{
    // 设置切哪个直角
    //    UIRectCornerTopLeft     = 1 << 0,  左上角
    //    UIRectCornerTopRight    = 1 << 1,  右上角
    //    UIRectCornerBottomLeft  = 1 << 2,  左下角
    //    UIRectCornerBottomRight = 1 << 3,  右下角
    //    UIRectCornerAllCorners  = ~0UL     全部角
    /// 得到view的遮罩路径
    UIBezierPath *maskPath = [UIBezierPath bezierPathWithRoundedRect:self.bounds
                                                   byRoundingCorners:corners
                                                         cornerRadii:cornerRadii];
    @jobs_weakify(self)
    self.layer.mask = jobsMakeCAShapeLayer(^(__kindof CAShapeLayer * _Nullable data) {
        @jobs_strongify(self)
        data.frame = self.bounds;
        data.path = maskPath.CGPath;
    });
}

33、刷新控件回到顶部

都是锚定在其公共父类UIScrollView

33.1、纵向的刷新 MJRefresh

集成方式

pod 'MJRefresh' # https://github.com/CoderMJLee/MJRefresh NO_SMP 不支持横向刷新

#if __has_include(<MJRefresh/MJRefresh.h>)
#import <MJRefresh/MJRefresh.h>
#else
#import "MJRefresh.h"
#endif

相关继承关系图

classDiagram
    UIView <|-- MJRefreshComponent
    MJRefreshComponent <|-- MJRefreshHeader
    MJRefreshComponent <|-- MJRefreshFooter
    MJRefreshHeader <|-- MJRefreshStateHeader
    MJRefreshStateHeader <|-- MJRefreshGifHeader
    MJRefreshStateHeader <|-- MJRefreshNormalHeader
    MJRefreshFooter <|-- MJRefreshAutoFooter
    MJRefreshFooter <|-- MJRefreshBackFooter
    MJRefreshAutoFooter <|-- MJRefreshAutoStateFooter
    MJRefreshAutoStateFooter <|-- MJRefreshAutoGifFooter
    MJRefreshAutoStateFooter <|-- MJRefreshAutoNormalFooter
    MJRefreshBackFooter <|-- MJRefreshBackStateFooter
    MJRefreshBackStateFooter <|-- MJRefreshBackGifFooter
    MJRefreshBackStateFooter <|-- MJRefreshBackNormalFooter

    class UIView {
    }

    class MJRefreshComponent {
    }

    class MJRefreshHeader {
    }

    class MJRefreshFooter {
    }

    class MJRefreshStateHeader {
    }

    class MJRefreshGifHeader {
    }

    class MJRefreshNormalHeader {
    }

    class MJRefreshAutoFooter {
    }

    class MJRefreshBackFooter {
    }

    class MJRefreshAutoStateFooter {
    }

    class MJRefreshAutoGifFooter {
    }

    class MJRefreshAutoNormalFooter {
    }

    class MJRefreshBackStateFooter {
    }

    class MJRefreshBackGifFooter {
    }

    class MJRefreshBackNormalFooter {
    }

使用方式
对UITableView的使用方式
对UICollectionView的使用方式

33.2、水平方向的刷新 XZMRefresh

集成方式

pod 'XZMRefresh' # https://github.com/xiezhongmin/XZMRefresh

#if __has_include(<XZMRefresh/XZMRefresh.h>)
#import <XZMRefresh/XZMRefresh.h>
#else
#import "XZMRefresh.h"
#endif

相关继承关系图

classDiagram
    UIView <|-- XZMBaseRefreshView
    XZMBaseRefreshView <|-- XZMRefreshHeader
    XZMBaseRefreshView <|-- XZMRefreshFooter
    XZMRefreshHeader <|-- XZMRefreshNormalHeader
    XZMRefreshHeader <|-- XZMRefreshGifHeader
    XZMRefreshFooter <|-- XZMRefreshNormalFooter
    XZMRefreshFooter <|-- XZMRefreshGifFooter
    
    class UIView{
    }

    class XZMBaseRefreshView{
    }

    class XZMRefreshHeader{
    }

    class XZMRefreshNormalHeader{
    }

    class XZMRefreshGifHeader{
    }

    class XZMRefreshFooter{
    }

    class XZMRefreshNormalFooter{
    }

    class XZMRefreshGifFooter{
    }

值得注意

需要在母控件正确得出Frame值以后，XZMRefresh方可生效。否则可能出现xzm_header或者xzm_footer的Frame值不正确（比如，高为0）
- ```
[self layoutIfNeeded];
```
- ```
[self.view layoutIfNeeded];
```

如果母控件是**UICollectionView，需要使用XZMLayout**

#import <UIKit/UIKit.h>
@interface XZMLayout : UICollectionViewFlowLayout
@end

@implementation XZMLayout

-(instancetype)init{
    if (self = [super init]) {
        
    }return self;
}
/**
 * 当collectionView的显示范围发生改变的时候，是否需要重新刷新布局
 * 一旦重新刷新布局，就会重新调用下面的方法：
 1.prepareLayout
 2.layoutAttributesForElementsInRect:方法
 */
- (BOOL)shouldInvalidateLayoutForBoundsChange:(CGRect)newBounds{
    return YES;
}
/// 用来做布局的初始化操作（不建议在init方法中进行布局的初始化操作）
- (void)prepareLayout{
    [super prepareLayout];
    // 水平滚动
    self.scrollDirection = UICollectionViewScrollDirectionHorizontal;
    CGFloat inset = (self.collectionView.frame.size.width - self.itemSize.width) * 0.5;
    /** 设置内边距 */
    self.sectionInset = UIEdgeInsetsMake(0, inset, 0, inset);
}
/**
 UICollectionViewLayoutAttributes *attrs;
 1.一个cell对应一个UICollectionViewLayoutAttributes对象
 2.UICollectionViewLayoutAttributes对象决定了cell的frame
 */
/// 这个方法的返回值是一个数组（数组里面存放着rect范围内所有元素的布局属性）
/// 这个方法的返回值决定了rect范围内所有元素的排布（frame）
- (NSArray *)layoutAttributesForElementsInRect:(CGRect)rect{
    // 获得super已经计算好的布局属性
    NSArray *array = [super layoutAttributesForElementsInRect:rect];
    // 计算collectionView最中心点的x值
    CGFloat centerX = self.collectionView.contentOffset.x + self.collectionView.frame.size.width * 0.5;
    // 在原有布局属性的基础上，进行微调
    for (UICollectionViewLayoutAttributes *attrs in array) {
        // cell的中心点x 和 collectionView最中心点的x值 的间距
        CGFloat delta = ABS(attrs.center.x - centerX);
        // 根据间距值 计算 cell的缩放比例
        CGFloat scale = 1 - delta / self.collectionView.frame.size.width * 0.15;
        // 设置缩放比例
        attrs.transform = CGAffineTransformMakeScale(scale, scale);
    }return array;
}
/// 这个方法的返回值，就决定了collectionView停止滚动时的偏移量
- (CGPoint)targetContentOffsetForProposedContentOffset:(CGPoint)proposedContentOffset
                                 withScrollingVelocity:(CGPoint)velocity{
    // 计算出最终显示的矩形框
    CGRect rect;
    rect.origin.y = 0;
    rect.origin.x = proposedContentOffset.x;
    rect.size = self.collectionView.frame.size;
    // 获得super已经计算好的布局属性
    NSArray *array = [super layoutAttributesForElementsInRect:rect];
    // 计算collectionView最中心点的x值
    CGFloat centerX = proposedContentOffset.x + self.collectionView.frame.size.width * 0.5;
    // 存放最小的间距值
    CGFloat minDelta = MAXFLOAT;
    for (UICollectionViewLayoutAttributes *attrs in array) {
        if (ABS(minDelta) > ABS(attrs.center.x - centerX)) {
            minDelta = attrs.center.x - centerX;
        }
    }
    // 修改原有的偏移量
    proposedContentOffset.x += minDelta;
    return proposedContentOffset;
}

@end

使用方式（以UICollectionView为例，UITableView同理）

UICollectionView + 默认刷新

-(void)example01{
    @jobs_weakify(self)
    [_collectionView xzm_addNormalHeaderWithTarget:self
                                            action:selectorBlocks(^id _Nullable(id _Nullable weakSelf,
                                                                                id _Nullable arg) {
        NSLog(@"SSSS加载新的数据，参数: %@", arg);
        @jobs_strongify(self)
        /// 在需要结束刷新的时候调用（只能调用一次）
        /// _collectionView.endRefreshing();
        return nil;
    }, MethodName(self), self)];

    [_collectionView xzm_addNormalFooterWithTarget:self
                                            action:selectorBlocks(^id _Nullable(id _Nullable weakSelf,
                                                                                id _Nullable arg) {
        NSLog(@"SSSS加载新的数据，参数: %@", arg);
        @jobs_strongify(self)
        /// 在需要结束刷新的时候调用（只能调用一次）
        /// _collectionView.endRefreshing();
        return nil;
    }, MethodName(self), self)];

    [_collectionView.xzm_header beginRefreshing];
}

UICollectionView + 隐藏时间

-(void)example02{
    @jobs_weakify(self)
    [_collectionView xzm_addNormalHeaderWithTarget:self
                                            action:selectorBlocks(^id _Nullable(id _Nullable weakSelf,
                                                                                id _Nullable arg) {
        NSLog(@"SSSS加载新的数据，参数: %@", arg);
        @jobs_strongify(self)
        /// 在需要结束刷新的时候调用（只能调用一次）
        /// _collectionView.endRefreshing();
        return nil;
    }, MethodName(self), self)];

    [_collectionView xzm_addNormalFooterWithTarget:self
                                            action:selectorBlocks(^id _Nullable(id _Nullable weakSelf,
                                                                                id _Nullable arg) {
        NSLog(@"SSSS加载新的数据，参数: %@", arg);
        @jobs_strongify(self)
        /// 在需要结束刷新的时候调用（只能调用一次）
        /// _collectionView.endRefreshing();
        return nil;
    }, MethodName(self), self)];
    // 隐藏时间
    _collectionView.xzm_header.updatedTimeHidden = YES;
    [_collectionView.xzm_header beginRefreshing];
}

UICollectionView + 动图刷新

-(void)example04{
    @jobs_weakify(self)
    [_collectionView xzm_addGifHeaderWithTarget:self
                                         action:selectorBlocks(^id _Nullable(id _Nullable weakSelf,
                                                                             id _Nullable arg) {
        NSLog(@"KKK加载新的数据，参数: %@", arg);
        // 模拟延迟加载数据，因此2秒后才调用）
        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)),
                       dispatch_get_main_queue(), ^{
            @jobs_strongify(self)
            self->_collectionView.endRefreshing();
        });return nil;
    }, MethodName(self), self)];

    [_collectionView xzm_addGifFooterWithTarget:self
                                         action:selectorBlocks(^id _Nullable(id _Nullable weakSelf,
                                                                             id _Nullable arg) {
        NSLog(@"SSSS加载新的数据，参数: %@", arg);
        @jobs_strongify(self)
        // 模拟延迟加载数据，因此2秒后才调用）
        dispatch_after(dispatch_time(DISPATCH_TIME_NOW,(int64_t)(2.0 * NSEC_PER_SEC)),
                       dispatch_get_main_queue(), ^{
            @jobs_strongify(self)
            self->_collectionView.endRefreshing();
        });return nil;
    }, MethodName(self), self)];
    // 隐藏时间
    _collectionView.xzm_gifHeader.updatedTimeHidden = YES;
    // 隐藏状态
    _collectionView.xzm_gifHeader.stateHidden = YES;
    _collectionView.xzm_gifFooter.stateHidden = YES;
    // 设置普通状态的动画图片
    NSMutableArray <UIImage *>*idleImages = jobsMakeMutArr(^(__kindof NSMutableArray * _Nullable data) {
        for (NSUInteger i = 1; i<=60; i++) {
            data.add(JobsIMG([NSString stringWithFormat:@"dropdown_anim__000%zd", i]));
        }
    });

    [_collectionView.xzm_gifHeader setImages:idleImages forState:XZMRefreshStateNormal];
    [_collectionView.xzm_gifFooter setImages:idleImages forState:XZMRefreshStateNormal];
    // 设置正在刷新状态的动画图片
    NSMutableArray <UIImage *>*refreshingImages = jobsMakeMutArr(^(__kindof NSMutableArray * _Nullable data) {
        for (NSUInteger i = 1; i<=3; i++) {
            data.add(JobsIMG([NSString stringWithFormat:@"dropdown_loading_0%zd", i]));
        }
    });

    [_collectionView.xzm_gifHeader setImages:refreshingImages forState:XZMRefreshStateRefreshing];
    [_collectionView.xzm_gifFooter setImages:refreshingImages forState:XZMRefreshStateRefreshing];
    // 马上进入刷新状态
    [_collectionView.xzm_gifHeader beginRefreshing];
}

UICollectionView + 动图刷新 + 隐藏文字

-(void)example04{
    @jobs_weakify(self)
    [_collectionView xzm_addGifHeaderWithTarget:self
                                         action:selectorBlocks(^id _Nullable(id _Nullable weakSelf,
                                                                             id _Nullable arg) {
        NSLog(@"KKK加载新的数据，参数: %@", arg);
        // 模拟延迟加载数据，因此2秒后才调用）
        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)),
                       dispatch_get_main_queue(), ^{
            @jobs_strongify(self)
            self->_collectionView.endRefreshing();
        });return nil;
    }, MethodName(self), self)];

    [_collectionView xzm_addGifFooterWithTarget:self
                                         action:selectorBlocks(^id _Nullable(id _Nullable weakSelf,
                                                                             id _Nullable arg) {
        NSLog(@"SSSS加载新的数据，参数: %@", arg);
        @jobs_strongify(self)
        // 模拟延迟加载数据，因此2秒后才调用）
        dispatch_after(dispatch_time(DISPATCH_TIME_NOW,(int64_t)(2.0 * NSEC_PER_SEC)),
                       dispatch_get_main_queue(), ^{
            @jobs_strongify(self)
            self->_collectionView.endRefreshing();
        });return nil;
    }, MethodName(self), self)];
    // 隐藏时间
    _collectionView.xzm_gifHeader.updatedTimeHidden = YES;
    // 隐藏状态
    _collectionView.xzm_gifHeader.stateHidden = YES;
    _collectionView.xzm_gifFooter.stateHidden = YES;
    // 设置普通状态的动画图片
    NSMutableArray <UIImage *>*idleImages = jobsMakeMutArr(^(__kindof NSMutableArray * _Nullable data) {
        for (NSUInteger i = 1; i<=60; i++) {
            data.add(JobsIMG([NSString stringWithFormat:@"dropdown_anim__000%zd", i]));
        }
    });

    [_collectionView.xzm_gifHeader setImages:idleImages forState:XZMRefreshStateNormal];
    [_collectionView.xzm_gifFooter setImages:idleImages forState:XZMRefreshStateNormal];
    // 设置正在刷新状态的动画图片
    NSMutableArray <UIImage *>*refreshingImages = jobsMakeMutArr(^(__kindof NSMutableArray * _Nullable data) {
        for (NSUInteger i = 1; i<=3; i++) {
            data.add(JobsIMG([NSString stringWithFormat:@"dropdown_loading_0%zd", i]));
        }
    });

    [_collectionView.xzm_gifHeader setImages:refreshingImages forState:XZMRefreshStateRefreshing];
    [_collectionView.xzm_gifFooter setImages:refreshingImages forState:XZMRefreshStateRefreshing];
    // 马上进入刷新状态
    [_collectionView.xzm_gifHeader beginRefreshing];
}

UICollectionView + 自定义文字

-(void)example05{
    @jobs_weakify(self)
    [_collectionView xzm_addNormalHeaderWithTarget:self
                                            action:selectorBlocks(^id _Nullable(id _Nullable weakSelf,
                                                                                id _Nullable arg) {
        NSLog(@"SSSS加载新的数据，参数: %@", arg);
        @jobs_strongify(self)
        /// 在需要结束刷新的时候调用（只能调用一次）
        /// _collectionView.endRefreshing();
        return nil;
    }, MethodName(self), self)];

    [_collectionView xzm_addNormalFooterWithTarget:self
                                            action:selectorBlocks(^id _Nullable(id _Nullable weakSelf,
                                                                                id _Nullable arg) {
        NSLog(@"SSSS加载新的数据，参数: %@", arg);
        @jobs_strongify(self)
        /// 在需要结束刷新的时候调用（只能调用一次）
        /// _collectionView.endRefreshing();
        return nil;
    }, MethodName(self), self)];
    // 设置header文字
    [_collectionView.xzm_header setTitle:JobsInternationalization(@"滑动可以刷新") forState:XZMRefreshStateNormal];
    [_collectionView.xzm_header setTitle:JobsInternationalization(@"释放立即刷新") forState:XZMRefreshStatePulling];
    [_collectionView.xzm_header setTitle:JobsInternationalization(@"正在刷新中 ...") forState:XZMRefreshStateRefreshing];
    // 设置字体
    _collectionView.xzm_header.font = UIFontWeightRegularSize(15);
    // 设置颜色
    _collectionView.xzm_header.textColor = JobsRedColor;
    // 设置footer文字
    [_collectionView.xzm_footer setTitle:JobsInternationalization(@"滑动可以刷新") forState:XZMRefreshStateNormal];
    [_collectionView.xzm_footer setTitle:JobsInternationalization(@"释放立即刷新") forState:XZMRefreshStatePulling];
    [_collectionView.xzm_footer setTitle:JobsInternationalization(@"正在加载中数据 ...") forState:XZMRefreshStateRefreshing];
    // 设置字体
    _collectionView.xzm_footer.font = UIFontWeightRegularSize(17);
    // 设置颜色
    _collectionView.xzm_footer.textColor = JobsBlueColor;
    // 自动刷新(一进入程序就下拉刷新)
    [_collectionView.xzm_header beginRefreshing];
}

34、网络请求框架回到顶部

-(void)基础的网络请求示例{
   [AFHTTPSessionManager.manager GET:@"http://172.24.135.12/CommentData.json"
                          parameters:nil
                             headers:nil
                            progress:^(NSProgress * _Nonnull downloadProgress) {
   } success:^(NSURLSessionDataTask * _Nonnull task,
               id  _Nullable responseObject) {
       NSLog(@"%@",responseObject);
   } failure:^(NSURLSessionDataTask * _Nullable task,
               NSError * _Nonnull error) {
       NSLog(@"%@",error);
   }];
}

34.1、猿题库的网络框架（强烈推荐使用）

集成

pod 'YTKNetwork' # https://github.com/yuantiku/YTKNetwork

#if __has_include(<YTKNetwork/YTKNetwork.h>)
#import <YTKNetwork/YTKNetwork.h>
#else
#import "YTKNetwork.h"
#endif

公共配置：下列配置一般体现在AppDelegate

YTKNetworkConfig *config = YTKNetworkConfig.sharedConfig;
config.baseUrl = self.BaseUrl;
config.cdnUrl = JobsInternationalization(@"");
//config.urlFilters = nil;
//config.cacheDirPathFilters = nil;
config.securityPolicy = [AFSecurityPolicy policyWithPinningMode:AFSSLPinningModeNone];
config.debugLogEnabled = YES;
config.sessionConfiguration = NSURLSessionConfiguration.defaultSessionConfiguration;

YTKUrlArgumentsFilter *urlFilter = [YTKUrlArgumentsFilter filterWithArguments:@{@"version": self.appVersion}];
[config addUrlFilter:urlFilter];

请求的配置（请求的方式、请求的URL、是否使用CND...）

所有的Api均需要继承此类

#import <Foundation/Foundation.h>
#import "YTKNetworkToolsHeader.h"

NS_ASSUME_NONNULL_BEGIN

@interface JobsBaseApi : BaseRequest

@end

NS_ASSUME_NONNULL_END

//
//  JobsBaseApi.m
//  FM
//
//  Created by User on 9/12/24.
//

#import "JobsBaseApi.h"

@implementation JobsBaseApi
#pragma mark —— 需要在很具体子类进行实现的
/// URL
-(NSString *)requestUrl{
    return @"";
}
/// 请求方式
-(YTKRequestMethod)requestMethod {
    return YTKRequestMethodPOST;
}
#pragma mark —— （本类）父类实现的
/// Body 参数
-(id _Nullable)requestArgument{
    return self.parameters;
}
/// 限定接收到的字段类型，如果不匹配则外层block走Failure
-(id)jsonValidator{
    return nil;
}

-(NSInteger)cacheTimeInSeconds{
    return 60 * 3;
}
/// 设置自定义的 HTTP Header
-(NSDictionary<NSString *, NSString *> *)requestHeaderFieldValueDictionary {
    // 在这里添加你想要的 HTTP header
    FMLoginModel *loginModel = self.readUserInfoByUserName(FMLoginModel.class,FM用户数据);
    return @{
        @"Content-Type": @"application/json", // 设置 Content-Type
        @"Authorization": loginModel.accessToken ? : @"" // 设置 Authorization
    };
}

- (NSURLRequest *)buildCustomUrlRequest{
    NSMutableURLRequest *request = self.request(self.requestUrl.jobsUrl);
    for (NSString *key in self.requestHeaderFieldValueDictionary) {
        JobsRequestBuilder.initByURLRequest(request)
            .httpHeaderField(key)
            .value(self.requestHeaderFieldValueDictionary[key]);
    }
    request.HTTPMethod = httpMethod(self.requestMethod);
    if(self.requestMethod != YTKRequestMethodGET){
        request.HTTPBody = self.dataByJSONObject(self.parameters);//body 数据
    }
    self.printRequestMessage(request);
    return request;
}

@end

一般的请求

#import "JobsBaseApi.h"

NS_ASSUME_NONNULL_BEGIN

@interface FM_favoriteGames_delete_api : JobsBaseApi

@end

NS_ASSUME_NONNULL_END

@implementation FM_favoriteGames_delete_api
/// 请求的完整URL：游戏大厅喜爱的游戏-删除【POST】
-(NSString *)requestUrl{
    return self.BaseUrl.add(self.post_game_home_favoriteGames_delete.url);
}
/// 请求方式
-(YTKRequestMethod)requestMethod {
    return YTKRequestMethodPOST;
}

@end

图片上载

#import <UIKit/UIKit.h>
#import "JobsBaseApi.h"

@interface UploadImageApi : JobsBaseApi

+(JobsReturnIDByImageBlock)initByImage;
-(instancetype)initWithImage:(UIImage *)image;
-(NSString *)responseImageId;

@end

#import "UploadImageApi.h"

@interface UploadImageApi ()

@property(nonatomic,strong)UIImage *image;

@end

@implementation UploadImageApi

+(JobsReturnIDByImageBlock)initByImage{
    @jobs_weakify(self)
    return ^id(UIImage *_Nullable data){
        @jobs_strongify(self)
        return [self.class.alloc initWithImage:data];
    };
}

-(instancetype)initWithImage:(UIImage *)image {
    if (self = [super init]) {
        self.image = image;
    }return self;
}
/// 请求的完整URL：
-(NSString *)requestUrl {
    return self.BaseUrl.add(@"/iphone/image/upload");
}
/// 请求方式
-(YTKRequestMethod)requestMethod {
    return YTKRequestMethodPOST;
}

-(AFConstructingBlock)constructingBodyBlock {
    @jobs_weakify(self)
    return ^(id<AFMultipartFormData> formData) {
        @jobs_strongify(self)
        NSData *data = UIImageJPEGRepresentation(self->_image, 0.9);
        NSString *name = @"image";
        NSString *formKey = @"image";
        NSString *type = @"image/jpeg";
        [formData appendPartWithFileData:data
                                    name:formKey
                                fileName:name
                                mimeType:type];
    };
}

-(id)jsonValidator {
    return @{@"imageId": NSString.class};
}

-(NSString *)responseImageId {
    NSDictionary *dict = self.responseJSONObject;
    return dict[@"imageId"];
}

@end

打印**YTKBaseRequest**

-(void)checkRequest:(YTKBaseRequest *_Nonnull)request{
    NSLog(@"request.error = %@\n",request.error);
    NSLog(@"request.requestArgument = %@\n",request.requestArgument);
    NSLog(@"request.requestUrl = %@\n",request.requestUrl);
    NSLog(@"request.baseUrl = %@\n",request.baseUrl);
}

请求方式

普通的单个请求

/// 普通的单个请求
-(jobsByVoidBlock)loadCacheData{
    return ^(){
        GetCustomerContactApi *api = [GetCustomerContactApi.alloc initWithParameters:nil];
        if ([api loadCacheWithError:nil]) {
            NSDictionary *json = api.responseJSONObject;
            NSLog(@"json = %@", json);
            // show cached data
        }

        api.animatingText = JobsInternationalization(@"正在加载");
        api.animatingView = self.view;

        [api startWithCompletionBlockWithSuccess:^(YTKBaseRequest *request) {
            NSLog(@"update ui");
            /// 以下是我们需要的值
            request.responseObject;
        } failure:^(YTKBaseRequest *request) {
            NSLog(@"failed");
        }];
    };
}

多请求

同步请求

/// 同步请求
-(jobsByVoidBlock)sendBatchRequest{
    return ^(){
        GetImageApi *a = [GetImageApi.alloc initWithParameters:nil];
        GetImageApi *b = [GetImageApi.alloc initWithParameters:nil];
        GetImageApi *c = [GetImageApi.alloc initWithParameters:nil];
        GetUserInfoApi *d = [GetUserInfoApi.alloc initWithParameters:nil];
        
        YTKBatchRequest *batchRequest = [YTKBatchRequest.alloc initWithRequestArray:@[a, b, c, d]];
        [batchRequest startWithCompletionBlockWithSuccess:^(YTKBatchRequest *batchRequest) {
            NSLog(@"succeed");
            NSArray *requests = batchRequest.requestArray;
            GetImageApi *a = (GetImageApi *)requests[0];
            GetImageApi *b = (GetImageApi *)requests[1];
            GetImageApi *c = (GetImageApi *)requests[2];
            GetUserInfoApi *user = (GetUserInfoApi *)requests[3];
            ///deal with requests result ...
            NSLog(@"%@, %@, %@, %@", a, b, c, user);
            
            /// 以下是我们需要的值
            a.responseObject;
            b.responseObject;
            c.responseObject;
            user.responseObject;
            
        } failure:^(YTKBatchRequest *batchRequest) {
            NSLog(@"failed");
        }];
    };
}

链式请求

/// 链式请求的结果集体现在<YTKChainRequestDelegate>
-(jobsByVoidBlock)sendChainRequest{
    @jobs_weakify(self)
    return ^(){
        @jobs_strongify(self)
        RegisterApi *reg = [RegisterApi.alloc initWithParameters:nil];
        YTKChainRequest *chainReq = YTKChainRequest.new;
        [chainReq addRequest:reg
                    callback:^(YTKChainRequest *chainRequest,
                               YTKBaseRequest *baseRequest) {
            
            RegisterApi *result = (RegisterApi *)baseRequest;
            /// 在链式请求中，下一个请求的参数来源于上一个请求的结果
            GetUserInfoApi *api = [GetUserInfoApi.alloc initWithParameters:@{@"KKK":result.userId}];
            [chainRequest addRequest:api callback:nil];
        }];
        chainReq.delegate = self;
        [chainReq start];// start to send request
    };
}

链式请求的结果集体现在 YTKChainRequestDelegate

#pragma mark —— YTKChainRequestDelegate
-(void)chainRequestFinished:(YTKChainRequest *)chainRequest{
    NSLog(@"all requests are done");
}

-(void)chainRequestFailed:(YTKChainRequest *)chainRequest
        failedBaseRequest:(YTKBaseRequest*)request{
    NSLog(@"some one of request is failed");
}

34.2、ZBNetworking

集成

pod 'ZBNetworking', :git => 'https://github.com/Suzhibin/ZBNetworking.git'

#if __has_include(<ZBNetworking/ZBNetworking.h>)
#import <ZBNetworking/ZBNetworking.h>
#else
#import "ZBNetworking.h"
#endif

一些拓展

JobsNetworkingAPI

@interface JobsNetworkingAPI : NSObject
#pragma mark —— 普通的网络请求
/// 【只有Body参数、不需要错误回调】
+(void)requestApi:(NSString *_Nonnull)requestApi
       parameters:(id _Nullable)parameters
     successBlock:(jobsByIDBlock _Nullable)successBlock;
///【只有Body参数、需要错误回调的】
+(void)requestApi:(NSString *_Nonnull)requestApi
       parameters:(id _Nullable)parameters
     successBlock:(jobsByIDBlock _Nullable)successBlock
     failureBlock:(jobsByIDBlock _Nullable)failureBlock;
#pragma mark —— 特殊的上传文件的网络请求
/// 上传【图片】文件的网络请求
+(void)requestApi:(NSString *_Nonnull)requestApi
uploadImagesParamArr:(NSArray *_Nullable)uploadImagesParamArr
     successBlock:(jobsByIDBlock _Nullable)successBlock
     failureBlock:(jobsByIDBlock _Nullable)failureBlock;
/// 上传【视频】文件的网络请求
+(void)requestApi:(NSString *_Nonnull)requestApi
uploadVideosParamArr:(NSArray *_Nullable)uploadVideosParamArr
     successBlock:(jobsByIDBlock _Nullable)successBlock
     failureBlock:(jobsByIDBlock _Nullable)failureBlock;
/// 请求成功的处理代码
+(void)networkingSuccessHandleWithData:(JobsResponseModel *_Nullable)responseObject
                               request:(ZBURLRequest *_Nullable)request
                          successBlock:(jobsByIDBlock _Nullable)successBlock
                          failureBlock:(jobsByIDBlock _Nullable)failureBlock;
#pragma mark —— 错误处理
+(void)handleError:(id)error;

@end

普通的请求（POST、GET）：请求方法配置在如下的单个的api里面

NSString *appInterfaceTesting;
+(void)appInterfaceTesting:(id)parameters
              successBlock:(jobsByIDBlock _Nullable)successBlock
              failureBlock:(jobsByIDBlock _Nullable)failureBlock{
//    NSDictionary *parameterss = @{};
//    NSDictionary *headers = @{};
    
    [ZBRequestManager requestWithConfig:^(ZBURLRequest * _Nullable request) {

        request.server = self.BaseUrl;
        request.url = request.server.add(self.appInterfaceTesting.url);
        
        NSLog(@"request.URLString = %@",request.url);
        
        request.methodType = ZBMethodTypeGET;//默认为GET
        request.apiType = ZBRequestTypeRefresh;//（默认为ZBRequestTypeRefresh 不读取缓存，不存储缓存）
        request.parameters = parameters;//与公共配置 Parameters 兼容
//        request.headers = headers;//与公共配置 Headers 兼容
        request.retryCount = 1;//请求失败 单次请求 重新连接次数 优先级大于 全局设置，不影响其他请求设置
        request.timeoutInterval = 10;//默认30 //优先级 高于 公共配置,不影响其他请求设置
        if (!DataManager.sharedInstance.tag.nullString) {
            request.userInfo = @{@"info":DataManager.sharedInstance.tag};//与公共配置 UserInfo 不兼容 优先级大于 公共配置
        };//与公共配置 UserInfo 不兼容 优先级大于 公共配置
        
        {
//            request.filtrationCacheKey = @[JobsInternationalization(@"")];//与公共配置 filtrationCacheKey 兼容
//            request.requestSerializer = ZBJSONRequestSerializer; //单次请求设置 请求格式 默认JSON，优先级大于 公共配置，不影响其他请求设置
//            request.responseSerializer = ZBJSONResponseSerializer; //单次请求设置 响应格式 默认JSON，优先级大于 公共配置,不影响其他请求设置
           
            /**
             多次请求同一个接口 保留第一次或最后一次请求结果 只在请求时有用  读取缓存无效果。默认ZBResponseKeepNone 什么都不做
             使用场景是在 重复点击造成的 多次请求，如发帖，评论，搜索等业务
             */
//            request.keepType=ZBResponseKeepNone;
        }//一些临时的其他的配置
        
    }progress:^(NSProgress * _Nullable progress){
        NSLog(@"进度 = %f",progress.fractionCompleted * 100);
    }success:^(id  _Nullable responseObject,
               ZBURLRequest * _Nullable request){
        [JobsNetworkingAPI networkingSuccessHandleWithData:responseObject
                                                 request:request
                                            successBlock:successBlock
                                            failureBlock:failureBlock];
    }failure:^(NSError * _Nullable error){
        NSLog(@"error = %@",error);
        if (failureBlock) {
            failureBlock(error);
        }
    }finished:^(id  _Nullable responseObject,
                NSError * _Nullable error,
                ZBURLRequest * _Nullable request){
        NSLog(@"请求完成 userInfo:%@",request.userInfo);
    }];
}

调用示例

一般的网络请求，只带body参数，最多也就是自定义header

 -(void)networking_messageSecondClassListGET{
     NSLog(@"当前是否有网：%d 状态：%ld",[ZBRequestManager isNetworkReachable],(long)[ZBRequestManager networkReachability]);
     DataManager.sharedInstance.tag = [ReuseIdentifier stringByAppendingString:NSStringFromSelector(_cmd)];
     [RequestTool setupPublicParameters];//公共配置、插件机制、证书设置
     @jobs_weakify(self)
     NSDictionary *parameters = @{};
     [JobsNetworkingAPI requestApi:NSObject.messageSecondClassListGET.funcName
                      parameters:parameters
                    successBlock:^(id data) {
         @jobs_strongify(self)
     }failureBlock:^(id data) {
         @jobs_strongify(self)
     }];
 }

 /// 邀请好友
 +(void)userInfoInviteFriendPOST:(id)parameters
                    successBlock:(jobsByIDBlock _Nullable)successBlock{
 //    NSDictionary *parameterss = @{};
 //    NSDictionary *headers = @{};
     
     [ZBRequestManager requestWithConfig:^(ZBURLRequest * _Nullable request) {

         request.server = NSObject.BaseUrl;
         request.url = [request.server stringByAppendingString:NSObject.userInfoInviteFriendPOST.url];
         
         NSLog(@"request.URLString = %@",request.url);
         
         request.methodType = ZBMethodTypePOST;//默认为GET
         request.apiType = ZBRequestTypeRefresh;//（默认为ZBRequestTypeRefresh 不读取缓存，不存储缓存）
         request.parameters = parameters;//与公共配置 Parameters 兼容
 //        request.headers = headers;//与公共配置 Headers 兼容
         request.retryCount = 1;//请求失败 单次请求 重新连接次数 优先级大于 全局设置，不影响其他请求设置
         request.timeoutInterval = 10;//默认30 //优先级 高于 公共配置,不影响其他请求设置
         if (!DataManager.sharedInstance.tag.nullString) {
             request.userInfo = @{@"info":DataManager.sharedInstance.tag};//与公共配置 UserInfo 不兼容 优先级大于 公共配置
         };//与公共配置 UserInfo 不兼容 优先级大于 公共配置
         
         {
 //            request.filtrationCacheKey = @[JobsInternationalization(@"")];//与公共配置 filtrationCacheKey 兼容
 //            request.requestSerializer = ZBJSONRequestSerializer; //单次请求设置 请求格式 默认JSON，优先级大于 公共配置，不影响其他请求设置
 //            request.responseSerializer = ZBJSONResponseSerializer; //单次请求设置 响应格式 默认JSON，优先级大于 公共配置,不影响其他请求设置
            
 /// 多次请求同一个接口 保留第一次或最后一次请求结果 只在请求时有用  读取缓存无效果。默认ZBResponseKeepNone 什么都不做。使用场景是在 重复点击造成的 多次请求，如发帖，评论，搜索等业务
 //            request.keepType=ZBResponseKeepNone;
         }//一些临时的其他的配置
         
     }progress:^(NSProgress * _Nullable progress){
         NSLog(@"进度 = %f",progress.fractionCompleted * 100);
     }success:^(id  _Nullable responseObject,
                ZBURLRequest * _Nullable request){
         if (successBlock) {
             successBlock(responseObject);
         }
     }failure:^(NSError * _Nullable error){
         NSLog(@"error = %@",error);
     }finished:^(id  _Nullable responseObject,
                 NSError * _Nullable error,
                 ZBURLRequest * _Nullable request){
         NSLog(@"请求完成 userInfo:%@",request.userInfo);
     }];
}

特殊的网络请求：可以body里面携带参数，也可以自定义header，并且表单模式post传输data数据

传输图片

-(void)networking_postUploadImagePOST{
 NSLog(@"当前是否有网：%d 状态：%ld",[ZBRequestManager isNetworkReachable],(long)[ZBRequestManager networkReachability]);
 DataManager.sharedInstance.tag = [ReuseIdentifier stringByAppendingString:NSStringFromSelector(_cmd)];

 [RequestTool setupPublicParameters];//公共配置、插件机制、证书设置
 @jobs_weakify(self)
 NSDictionary *parameters = @{};
 [JobsNetworkingAPI requestApi:NSObject.postUploadImagePOST.funcName
        uploadImagesParamArr:@[parameters,
                               self.photosImageMutArr]
                successBlock:^(id data) {
     @jobs_strongify(self)
     NSLog(@"data = %@",data);
 }
                failureBlock:^(id data) {
     @jobs_strongify(self)
     NSLog(@"data = %@",data);
 }];
}

+(void)postUploadImagePOST:(id)parameters
       uploadImageDatas:(NSMutableArray<UIImage *> *)uploadImageDatas
           successBlock:(jobsByIDBlock _Nullable)successBlock
           failureBlock:(jobsByIDBlock _Nullable)failureBlock{
 
 NSMutableArray *uploadDatas = NSMutableArray.array;
 for (int i = 0; i < uploadImageDatas.count; i++) {
     UIImage *image = uploadImageDatas[i];
     NSData *imageData = UIImageJPEGRepresentation(image, 1.0);
     NSInteger time = NSDate.date.timeIntervalSince1970 * 1000;
     NSString *fileName = [NSString stringWithFormat:@"%ld_%u.jpeg",time,arc4random() / 1000];
     ZBUploadData *zbdata = [ZBUploadData formDataWithName:@"file"
                                                  fileName:fileName
                                                  mimeType:@"image/jpeg"
                                                  fileData:imageData];
     [uploadDatas addObject:zbdata];
 }
 [ZBRequestManager requestWithConfig:^(ZBURLRequest * request) {
     request.server = NSObject.BaseUrl;
     request.url = [request.server stringByAppendingString:NSObject.postUploadImagePOST.url];
     NSLog(@"request.URLString = %@",request.url);
     request.methodType = ZBMethodTypeUpload;
     request.apiType = ZBRequestTypeRefresh;//（默认为ZBRequestTypeRefresh 不读取缓存，不存储缓存）
//        request.parameters = parameters;//与公共配置 Parameters 兼容
//        request.headers = headers;//与公共配置Headers 兼容
     request.retryCount = 1;//请求失败 单次请求 重新连接次数 优先级大于 全局设置，不影响其他请求设置
     request.timeoutInterval = 120;//默认30 //优先级 高于 公共配置,不影响其他请求设置
     request.requestSerializer = ZBHTTPRequestSerializer;
     request.uploadDatas = uploadDatas;
     if (!DataManager.sharedInstance.tag.nullString) {
         request.userInfo = @{@"info":DataManager.sharedInstance.tag};//与公共配置 UserInfo 不兼容 优先级大于 公共配置
     };//与公共配置 UserInfo 不兼容 优先级大于 公共配置
 } progress:^(NSProgress * _Nullable progress) {
     NSLog(@"onProgress: %.2f", 100.f * progress.completedUnitCount/progress.totalUnitCount);
 } success:^(id  responseObject,ZBURLRequest * request) {
     NSLog(@"responseObject: %@", responseObject);
     if (successBlock) {
         successBlock(responseObject);
     }
 } failure:^(NSError * _Nullable error) {
     NSLog(@"error: %@", error);
     if (failureBlock) {
         failureBlock(error);
     }
 }];
}

传输视频

/// 帖子视频上传 POST
-(void)networking_postuploadVideoPOST{
 NSLog(@"当前是否有网：%d 状态：%ld",[ZBRequestManager isNetworkReachable],(long)[ZBRequestManager networkReachability]);
 DataManager.sharedInstance.tag = [ReuseIdentifier stringByAppendingString:NSStringFromSelector(_cmd)];

 [RequestTool setupPublicParameters];//公共配置、插件机制、证书设置
 @jobs_weakify(self)
 NSDictionary *parameters = @{};
 
 extern NSString *postuploadVideoPOST;
 extern NSString *preproccess;
 
 [JobsNetworkingAPI requestApi:NSObject.postuploadVideoPOST.funcName
        uploadVideosParamArr:@[parameters,
                               self.videosData]
                successBlock:^(id data) {
     @jobs_strongify(self)
     NSLog(@"data = %@",data);
 }
                failureBlock:^(id data) {
     @jobs_strongify(self)
     NSLog(@"data = %@",data);
 }];
}

 NSString *postuploadVideoPOST;
 +(void)postuploadVideoPOST:(id)parameters
                uploadVideo:(NSMutableArray <NSData *>*)videoDatas
               successBlock:(jobsByIDBlock _Nullable)successBlock
               failureBlock:(jobsByIDBlock _Nullable)failureBlock{
     NSMutableArray *uploadDatas = NSMutableArray.array;
     for (int i = 0; i < videoDatas.count; i++) {
         NSInteger time = NSDate.date.timeIntervalSince1970 * 1000;
         NSString *fileName = [NSString stringWithFormat:@"%ld_%u.mp4", time, arc4random() / 1000];

         ZBUploadData *zbdata = [ZBUploadData formDataWithName:@"file"
                                                      fileName:fileName
                                                      mimeType:@"video/mp4"
                                                      fileData:videoDatas[i]];
         
     //    ZBUploadData *zbdata = [ZBUploadData formDataWithName:@"file"
     //                                                 fileName:fileName
     //                                                 mimeType:@"video/mp4"
     //                                                  fileURL:videoURL];
         [uploadDatas addObject:zbdata];
     }
     
     [ZBRequestManager requestWithConfig:^(ZBURLRequest * request) {
         request.server = NSObject.BaseUrl;
         request.url = [request.server stringByAppendingString:NSObject.postuploadVideoPOST.url];
         NSLog(@"request.URLString = %@",request.url);
         request.methodType = ZBMethodTypeUpload;
         request.apiType = ZBRequestTypeRefresh;//（默认为ZBRequestTypeRefresh 不读取缓存，不存储缓存）
 //        request.parameters = parameters;//与公共配置 Parameters 兼容
 //        request.headers = headers;//与公共配置Headers 兼容
         request.retryCount = 1;//请求失败 单次请求 重新连接次数 优先级大于 全局设置，不影响其他请求设置
         request.timeoutInterval = 120;//默认30 //优先级 高于 公共配置,不影响其他请求设置
         request.requestSerializer = ZBHTTPRequestSerializer;
         request.uploadDatas = uploadDatas;
         if (!DataManager.sharedInstance.tag.nullString) {
             request.userInfo = @{@"info":DataManager.sharedInstance.tag};//与公共配置 UserInfo 不兼容 优先级大于 公共配置
         };//与公共配置 UserInfo 不兼容 优先级大于 公共配置
     } progress:^(NSProgress * _Nullable progress) {
         NSLog(@"onProgress: %.2f", 100.f * progress.completedUnitCount/progress.totalUnitCount);
         [WHToast toastLoadingMsg:@"视频上传中...请稍后"];
     } success:^(id  responseObject,ZBURLRequest * request) {
         NSLog(@"responseObject: %@", responseObject);
         [WHToast toastHide];
         if (successBlock) {
             successBlock(responseObject);
         }
     } failure:^(NSError * _Nullable error) {
         NSLog(@"error: %@", error);
         [WHToast toastHide];
         if (failureBlock) {
             failureBlock(error);
         }
     }];
 }

35、数据容器 = 数组 + 字典 + 集合回到顶部

从底层开始，有且只有如下的容器类

数组（NSArray、NSMutableArray）

/// 阻止向可变数组添加空元素
-(JobsReturnIDByIDBlock _Nonnull)add{
    @jobs_weakify(self)
    return ^id (id _Nullable data) {
        @jobs_strongify(self)
        if(data){
            /// 向数组加入nil会崩
            [self addObject:data];
        }else{
            NSLog(@"数组被添加了一个空元素");
        }return self;
    };
}
/// 向数组加入一个从来没有没有过的元素，以保证数组元素的单一性
-(JobsReturnIDByIDBlock _Nonnull)jobsAddSoleObject{
    @jobs_weakify(self)
    return ^id (id _Nullable data) {
        @jobs_strongify(self)
        if(data){
            if (![self containsObject:data]) {
                [self addObject:data];
            }
        }else{
            NSLog(@"数组被添加了一个空元素");
        }return self;
    };
}

字典（NSDictionary、NSMutableDictionary）
- 在php语言中，没有字典的概念，转而用数组进行替代。即，数组下标做为key进行存取
集合（NSSet、NSMutableSet）

**原则上，是不希望在数据容器上用继承关系的。因为这样可能会导致一些未知错误的发生。**但是可以用分类的方式，定义一些算法方面的方法，减少应用层的负担

36、第三方验证码回到顶部

36.1、网易验证码的二次封装

pod 'NTESVerifyCode' # 网易验证码 https://github.com/yidun/NTESVerifyCode https://support.dun.163.com/documents/15588062143475712?docId=150442931089756160

#if __has_include(<VerifyCode/NTESVerifyCodeManager.h>)
#import <VerifyCode/NTESVerifyCodeManager.h>
#else
#import "NTESVerifyCodeManager.h"
#endif

-(void)verifyCode_simpleCall{
    // 显示验证码
    [self.verifyCodeManager openVerifyCodeView:nil];
}

关注实现类 @interface NSObject (NTESVerifyCodeManager)

36.2、极验验证码的二次封装

关注实现类 @interface NSObject (GTCaptcha4)

#import "NSObject+GTCaptcha4.h"

#if __has_include(<GTCaptcha4/GTCaptcha4.h>)
#import <GTCaptcha4/GTCaptcha4.h>
#else
#import "GTCaptcha4.h"
#endif

// 显示验证码
-(jobsByVoidBlock _Nonnull)show_verifyCode_GTCaptcha4{
    @jobs_weakify(self)
    return ^(){
        @jobs_strongify(self)
        [self.captchaSession verify];
    };
}

37、让 `UIView`像 `UINavigationController`一样支持 push 和 pop 回到顶部

pop

if(self.navigator) self.navigator.popViewAnimated(YES);

发起点为**UIViewController *，在UIView ***中进行push 和 pop

在**UIViewController ***中的配置（以下几种操作等价）

/// 一些必要配置
JobsViewNavigator *navigator = JobsViewNavigator.new;
navigator.frame = self.view.bounds;
self.pushView.navigator = navigator;
[self.view addSubview:navigator];
/// push 页面
navigator.pushView(self.pushView,YES);

/// 一些必要配置
self.view.configViewNavigatorByPushview(self.pushView);
/// push 页面
self.view.navigator.pushView(self.pushView,YES);

/// 一些必要配置
self.pushView.configViewNavigatorBySuperview(self.view);
/// push 页面
self.view.navigator.pushView(self.pushView,YES);

/// 一些必要配置
self.configViewNavigatorBySuperviewAndView(self.view,self.pushView);
/// push 页面
self.view.navigator.pushView(self.pushView,YES);

在**UIView ***中的配置（以下几种操作等价）

/// 一些必要配置
/// 完全新的一个 navigator
JobsViewNavigator *navigator = JobsViewNavigator.new;
navigator.frame = self.bounds;
self.pushView.navigator = navigator;
[self addSubview:navigator];
/// push 页面
navigator.pushView(self.pushView,YES);

/// 一些必要配置
self.navigator.frame = self.bounds;
self.pushView.navigator = self.navigator;// 承接的上个控制器页面带来的 navigator
/// push 页面
self.navigator.pushView(self.pushView,YES);

/// 一些必要配置
self.configViewNavigatorByPushview_(self.pushView);//（内含）承接的上个控制器页面带来的 navigator
/// push 页面
self.navigator.pushView(self.pushView,YES);

/// 一些必要配置
self.pushView.configViewNavigatorBySuperview_(self);//（内含）承接的上个控制器页面带来的 navigator
/// push 页面
self.navigator.pushView(self.pushView,YES);

/// 一些必要配置
self.configViewNavigatorBySuperviewAndView_(self,self.pushView);//（内含）承接的上个控制器页面带来的 navigator
/// push 页面
self.navigator.pushView(self.pushView,YES);

发起点为**UIView *，在UIView ***中进行push 和 pop

在发起点**UIView ***中的配置

/// 一些必要配置
JobsViewNavigator *navigator = JobsViewNavigator.new;
navigator.frame = self.bounds;
self.pushView.navigator = navigator;
[self addSubview:navigator];
/// push 页面
navigator.pushView(self.pushView,YES);

/// 一些必要配置
self.configViewNavigatorByPushview(self.pushView);
/// push 页面
self.navigator.pushView(self.pushView,YES);

/// 一些必要配置
self.pushView.configViewNavigatorBySuperview(self);
/// push 页面
self.navigator.pushView(self.pushView,YES);

/// 一些必要配置
self.configViewNavigatorBySuperviewAndView(self,self.pushView);
/// push 页面
self.navigator.pushView(self.pushView,YES);

在push的**UIView ***中的配置（以下几种操作等价）

/// 一些必要配置
/// 完全新的一个 navigator
JobsViewNavigator *navigator = JobsViewNavigator.new;
navigator.frame = self.bounds;
self.pushView.navigator = navigator;
[self addSubview:navigator];
/// push 页面
navigator.pushView(self.pushView,YES);

/// 一些必要配置
self.navigator.frame = self.bounds;
self.pushView.navigator = self.navigator;// 承接的上个页面带来的 navigator
/// push 页面
self.navigator.pushView(self.pushView,YES);

/// 一些必要配置
self.configViewNavigatorByPushview_(self.pushView);//（内含）承接的上个页面带来的 navigator
/// push 页面
self.navigator.pushView(self.pushView,YES);

/// 一些必要配置
self.pushView.configViewNavigatorBySuperview_(self);//（内含）承接的上个页面带来的 navigator
/// push 页面
self.navigator.pushView(self.pushView,YES);

self.configViewNavigatorBySuperviewAndView_(self,self.pushView);//（内含）承接的上个页面带来的 navigator
/// push 页面
self.navigator.pushView(self.pushView,YES);

38、轮播图 WMZBanner 回到顶部

作者停止维护
文字过长会出现问题。跑马灯功能需要另辟蹊径

WMZBanner的完整调用

pod 'WMZBanner' # https://github.com/wwmz/WMZBanner 轻量级轮播图+卡片样式+自定义样式 ⚠️作者停止维护

#if __has_include(<WMZBanner/WMZBannerView.h>)
#import <WMZBanner/WMZBannerView.h>
#else
#import "WMZBannerView.h"
#endif

/// UI
@property(nonatomic,strong)WMZBannerView *bannerView;
/// Data
@property(nonatomic,strong)WMZBannerParam *bannerParam;
@property(nonatomic,strong)NSMutableArray <FMBannerAdsModel *>*subViewModelMutArr;

/// 具体由子类进行复写【数据定UI】【如果所传参数为基本数据类型，那么包装成对象NSNumber进行转化承接】
-(jobsByIDBlock)jobsRichElementsInViewWithModel{
    @jobs_weakify(self)
    return ^(UIViewModel *_Nullable model) {
        @jobs_strongify(self)
        /// 用默认数据渲染原始的UI
        self.bannerView.alpha = 1;
        /// 用请求到的最新的数据渲染最新的UI
        [self promotionAdsInfoList:^(JobsResponseModel *_Nullable responseModel) {
            @jobs_strongify(self)
            self.subViewModelMutArr = FMBannerAdsModel.byData((responseModel.data));
            for (FMBannerAdsModel *model in self.subViewModelMutArr) {
                model.image = JobsIMG(@"个人中心广告");
            }
        }];
    };
}

@synthesize subViewModelMutArr = _subViewModelMutArr;
-(void)setSubViewModelMutArr:(NSMutableArray<FMBannerAdsModel *> *)subViewModelMutArr{
    _subViewModelMutArr = subViewModelMutArr;
    _bannerParam = nil;
    DestroyView(_bannerView);
    [self.bannerView updateUI];
}

-(NSMutableArray<FMBannerAdsModel *> *)subViewModelMutArr{
    if(!_subViewModelMutArr){
        _subViewModelMutArr = jobsMakeMutArr(^(__kindof NSMutableArray <FMBannerAdsModel *>* _Nullable data) {
            {
                FMBannerAdsModel *model = FMBannerAdsModel.new;
                model.image = JobsIMG(@"个人中心广告");
                data.add(model);
            }
            {
                FMBannerAdsModel *model = FMBannerAdsModel.new;
                model.image = JobsIMG(@"个人中心广告");
                data.add(model);
            }
            {
                FMBannerAdsModel *model = FMBannerAdsModel.new;
                model.image = JobsIMG(@"个人中心广告");
                data.add(model);
            }
        });
    }return _subViewModelMutArr;
}

-(WMZBannerView *)bannerView{
    if (!_bannerView) {
        _bannerView = [WMZBannerView.alloc initConfigureWithModel:self.bannerParam];
        [self addSubview:_bannerView];
        [_bannerView mas_makeConstraints:^(MASConstraintMaker *make) {
            make.size.mas_equalTo(CGSizeMake(JobsWidth(148), JobsWidth(284)));
            make.top.equalTo(self).offset(JobsWidth(0));
            make.left.equalTo(self.tableView.mas_right).offset(JobsWidth(10));
        }];
        [_bannerView updateUI];
    }return _bannerView;
}

-(WMZBannerParam *)bannerParam{
    @jobs_weakify(self)
    if (!_bannerParam) {
        _bannerParam = BannerParam()//
        //自定义视图必传
        .wMyCellClassNameSet(JobsBaseCollectionViewCell.class.description)
        .wMyCellSet(^UICollectionViewCell *(NSIndexPath *indexPath,
                                            UICollectionView *collectionView,
                                            FMBannerAdsModel *model,
                                            UIImageView *bgImageView,
                                            NSArray *dataArr) {
           @jobs_strongify(self)
            //自定义视图
            JobsBaseCollectionViewCell *cell = [JobsBaseCollectionViewCell cellWithCollectionView:collectionView forIndexPath:indexPath];
            cell.backgroundColor = cell.contentView.backgroundColor = JobsClearColor.colorWithAlphaComponent(0);
            NSString *urlStr = @"";
            cell.backgroundImageView
                .imageURL(self.BaseUrl.add(urlStr).jobsUrl)
                .placeholderImage(model.image)
                .options(SDWebImageRefreshCached)/// 强制刷新缓存
                .completed(^(UIImage *_Nullable image,
                             NSError *_Nullable error,
                             SDImageCacheType cacheType,
                             NSURL *_Nullable imageURL) {
                    if (error) {
                        NSLog(@"图片加载失败: %@-%@", error,imageURL);
                    } else {
                        NSLog(@"图片加载成功");
                    }
                }).load();
            return cell;
        })
        .wEventClickSet(^(id anyID, NSInteger index) {
            NSLog(@"点击 %@ %ld",anyID,index);
        })
        .wEventCenterClickSet(^(id anyID,
                                NSInteger index,
                                BOOL isCenter,
                                UICollectionViewCell *cell) {
            NSLog(@"判断居中点击");
        })
        .wFrameSet(CGRectMake(0,
                              0,
                              JobsWidth(148),
                              JobsWidth(284)))
        //图片铺满
        .wImageFillSet(YES)
        //循环滚动
        .wRepeatSet(YES)
        //自动滚动时间
        .wAutoScrollSecondSet(5)
        //自动滚动
        .wAutoScrollSet(YES)
        //cell的位置
        .wPositionSet(BannerCellPositionCenter)
        //分页按钮的选中的颜色
        .wBannerControlSelectColorSet(JobsWhiteColor)
        //分页按钮的未选中的颜色
        .wBannerControlColorSet(JobsLightGrayColor)
        //分页按钮的圆角
        .wBannerControlImageRadiusSet(5)
        //自定义圆点间距
        .wBannerControlSelectMarginSet(3)
        //隐藏分页按钮
        .wHideBannerControlSet(NO)
        //能否拖动
        .wCanFingerSlidingSet(YES);
        _bannerParam.wDataSet(self.subViewModelMutArr);
    }return _bannerParam;
}

39、`UIScrollView` 回到顶部

如果需要将**UIScrollView拖动到某个地方，就不能拖动了，需要配置其contentSize**属性

-(UIScrollView *)scrollView{
    if (!_scrollView) {
        @jobs_weakify(self)
        _scrollView = self.addSubview(jobsMakeScrollView(^(__kindof UIScrollView * _Nullable scrollView) {
            @jobs_strongify(self)
            scrollView.delegate = self;
            scrollView.frame = self.bounds;
            scrollView.resetContentSizeWidth(1000);
            scrollView.showsVerticalScrollIndicator = NO;
            scrollView.showsHorizontalScrollIndicator = NO;
        }));
    }return _scrollView;
}

要获取 UIScrollView 滑动的距离，你可以使用 contentOffset 属性。contentOffset 表示 UIScrollView 的内容视图的原点相对于 **UIScrollView**自身边界的偏移量。

40、自动布局回到顶部

SDAutoLayout 和 Masonry 一起使用时可能会导致冲突
一个工程项目用一个自动布局框架即可

等价

self.mainV.sd_layout
.topSpaceToView(self.view,260)
.leftSpaceToView(self.view,15)
.rightSpaceToView(self.view,15)
.heightIs(200);

[self.mainV mas_makeConstraints:^(MASConstraintMaker *make) {
    make.top.equalTo(self.view).offset(260);
    make.left.equalTo(self.view).offset(15);
    make.right.equalTo(self.view).offset(-15);
    make.height.mas_equalTo(200);
}];

_tableV.sd_layout.spaceToSuperView(UIEdgeInsetsMake(0, 0, 0, 0));

[_tableV mas_makeConstraints:^(MASConstraintMaker *make) {
    make.edges.equalTo(self).insets(UIEdgeInsetsMake(0, 0, 0, 0));
}];

40.1、`Masonry`

基于自动布局的轻量级封装，允许通过链式语法设置约束

pod 'Masonry' # https://github.com/SnapKit/Masonry NO_SMP

#if __has_include(<Masonry/Masonry.h>)
#import <Masonry/Masonry.h>
#else
#import "Masonry.h"
#endif

所有的约束必须依托于
```
- (void)addSubview:(UIView *)view;
- (void)insertSubview:(UIView *)view belowSubview:(UIView *)siblingSubview;
- (void)insertSubview:(UIView *)view aboveSubview:(UIView *)siblingSubview;
```
- 也就意味着：如果执行- (void)removeFromSuperview;即便之后再将这些子视图加载到父视图，约束也需要重新加载，否则约束会有问题

40.2、`SDAutoLayout`

基于链式语法的简单自动布局框架

pod 'SDAutoLayout' # https://github.com/gsdios/SDAutoLayout

#if __has_include(<SDAutoLayout/SDAutoLayout.h>)
#import <SDAutoLayout/SDAutoLayout.h>
#else
#import "SDAutoLayout.h"
#endif

41、颜色透明度

手动提取颜色的 RGB 分量并创建一个新的颜色对象，这样可以更加灵活地控制颜色的生成过程
```
JobsBlackCor(0.5);
```
调用 UIColor 自带的方法，不改变颜色的 RGB 值，只调整透明度
```
JobsBlackColor.colorWithAlphaComponent(0.5f);
```

42、数据模型的封装调用回到顶部

42.1、封装系统Api（关注`JobsMakes.h`）

42.2、封装自建Api（持续更新中...）

NS_INLINE ButtonTimerConfigModel *_Nonnull jobsMakeButtonTimerConfigModel(jobsByButtonTimerConfigModelBlock _Nonnull block){
    ButtonTimerConfigModel *model = ButtonTimerConfigModel.alloc.init;
    if (block) block(model);
    return model;
}

NS_INLINE __kindof JobsNavBarConfig *_Nonnull jobsMakeNavBarConfig(jobsByNavBarConfigBlock _Nonnull block){
    JobsNavBarConfig *data = JobsNavBarConfig.alloc.init;
    if (block) block(data);
    return data;
}

NS_INLINE __kindof UIButtonModel *_Nonnull jobsMakeButtonModel(jobsByButtonModelBlock _Nonnull block){
    UIButtonModel *data = UIButtonModel.alloc.init;
    if (block) block(data);
    return data;
}

NS_INLINE __kindof UITextModel *_Nonnull jobsMakeTextModel(jobsByTextModelBlock _Nonnull block){
    UITextModel *data = UITextModel.alloc.init;
    if (block) block(data);
    return data;
}

NS_INLINE __kindof UIViewModel *_Nonnull jobsMakeViewModel(jobsByViewModelBlock _Nonnull block){
    UIViewModel *data = UIViewModel.alloc.init;
    if (block) block(data);
    return data;
}

NS_INLINE __kindof JobsParagraphStyle *_Nonnull jobsMakeParagraphStyler(jobsByParagraphStyleBlock _Nonnull block){
    JobsParagraphStyle *data = JobsParagraphStyle.alloc.init;
    if (block) block(data);
    return data;
}

NS_INLINE __kindof JobsRichTextConfig *_Nonnull jobsMakeRichTextConfig(jobsByRichTextConfigBlock _Nonnull block){
    JobsRichTextConfig *data = JobsRichTextConfig.alloc.init;
    if (block) block(data);
    return data;
}

NS_INLINE __kindof JobsTabBarItemConfig *_Nonnull jobsMakeTabBarItemConfig(jobsByTabBarItemConfigBlock _Nonnull block){
    JobsTabBarItemConfig *data = JobsTabBarItemConfig.alloc.init;
    if (block) block(data);
    return data;
}

NS_INLINE __kindof LZTabBarConfig *_Nonnull jobsMakeLZTabBarConfig(jobsByLZTabBarConfigBlock _Nonnull block){
    LZTabBarConfig *data = LZTabBarConfig.alloc.init;
    if (block) block(data);
    return data;
}

NS_INLINE __kindof MJRefreshConfigModel *_Nonnull jobsMakeRefreshConfigModel(jobsByRefreshConfigModelBlock _Nonnull block){
    MJRefreshConfigModel *model = MJRefreshConfigModel.alloc.init;
    if (block) block(model);
    return model;
}

NS_INLINE __kindof JobsParagraphStyleModel *_Nonnull jobsMakeParagraphStyleModel(jobsByParagraphStyleModelBlock _Nonnull block){
    JobsParagraphStyleModel *data = JobsParagraphStyleModel.alloc.init;
    if (block) block(data);
    return data;
}

NS_INLINE __kindof MasonryModel *_Nonnull jobsMakeMasonryModel(jobsByMasonryModelBlock _Nonnull block){
    MasonryModel *data = MasonryModel.alloc.init;
    if (block) block(data);
    return data;
}

NS_INLINE __kindof JobsTimeModel *_Nonnull jobsMakeTimeModel(jobsByTimeModelBlock _Nonnull block){
    JobsTimeModel *data = JobsTimeModel.alloc.init;
    if (block) block(data);
    return data;
}

NS_INLINE __kindof JobsTimeFormatterModel *_Nonnull jobsMakeTimeFormatterModel(jobsByTimeFormatterModelBlock _Nonnull block){
    JobsTimeFormatterModel *data = JobsTimeFormatterModel.alloc.init;
    if (block) block(data);
    return data;
}

NS_INLINE __kindof PopListBaseView *_Nonnull jobsMakePopListBaseView(jobsByPopListBaseViewBlock _Nonnull block){
    PopListBaseView *data = PopListBaseView.alloc.init;
    if (block) block(data);
    return data;
}

NS_INLINE __kindof JobsExcelConfigureViewModel *_Nonnull jobsMakeExcelConfigureViewModel(jobsByExcelConfigureViewModelBlock _Nonnull block){
    JobsExcelConfigureViewModel *data = JobsExcelConfigureViewModel.alloc.init;
    if (block) block(data);
    return data;
}

NS_INLINE __kindof NSNotificationKeyboardModel *_Nonnull jobsMakeNotificationKeyboardModel(jobsByNSNotificationKeyboardModelBlock _Nonnull block){
    NSNotificationKeyboardModel *data = NSNotificationKeyboardModel.alloc.init;
    if (block) block(data);
    return data;
}

NS_INLINE __kindof VideoModel_Core *_Nonnull jobsMakeVideoModelCore(jobsByVideoModelCoreBlock _Nonnull block){
    VideoModel_Core *data = VideoModel_Core.alloc.init;
    if (block) block(data);
    return data;
}

42.3、`UIAlertController` + `UIAlertAction`

UIAlertController 的标题和消息属性仅支持简单的字符串 (NSString) 类型，而不直接支持富文本 (NSAttributedString)

self.getCurrentViewController.comingToPresentVC(self.makeAlertControllerByAlertModel(jobsMakeAlertModel(^(JobsAlertModel * _Nullable data) {
     data.alertControllerTitle = @"主标题";
     data.message = @"副标题";
     data.preferredStyle = UIAlertControllerStyleAlert;
     data.alertActionTitle = @"OK";
     data.alertActionStyle = UIAlertActionStyleDefault;
     data.alertActionBlock = ^(__kindof UIAlertAction * _Nullable action) {
         NSLog(@"OK");
     };
     data.cancelAlertActionTitle = @"取消";
     data.cancelAlertActionStyle = UIAlertActionStyleCancel;
     data.cancelAlertActionBlock = ^(__kindof UIAlertAction * _Nullable action) {
         NSLog(@"Cancel");
     };
 })));

Test

点我了解详情

OC代码实验室
```
/// TODO
```

六、马甲包回到顶部

1、相关资料

https://github.com/520coding/confuse/blob/master/README_ZH.md

2、相关工具

confuse

七、一些文档和资料 回到顶部

1、配置相关

2、面试相关

3、功能相关

4、相关研究

4.1、架构问题

路由

4.2、语法糖问题

4.3、算法问题

4.4、加密体系相关

4.4.1、加密（编码）算法

4.4.2、HASH 信息摘要

5、其他研究

6、课外阅读

7、TODO

将时间按照【年-月份】分组集成到靶场项目里
完善 iOS功能：跳转其他App,如果本机不存在,则进行下载（需要补充）
iOS.热更新
iOS.Widget
Demo里面有些因为Api升级而没有来得及对齐的，目前打开会崩溃
对多场景SceneDelegate的深入研究和支持
JobsPostVC报错解决
DebugLogDescription 会崩溃：id value = self.valueForKeyBlock(name) ? : @"nil";//默认值为nil字符串
侧滑菜单：JXCategoryView垂直表达
其他

八、打开苹果的反馈助理回到顶部

浏览器打开并输入
```
feedbackassistant://
```

License

295060456/JobsOCBaseConfigDemo

About

Resources

License

Stars

Watchers

Forks

Releases

Packages 0

Languages

Packages