SDK 集成

Bugly提供两种集成方式供iOS开发者选择：

• 通过CocoaPods集成
• 手动集成

如果您是从Bugly 2.0以下版本升级过来的，请查看iOS SDK 升级指南

Bugly iOS SDK 最低兼容系统版本 iOS 7.0

通过CocoaPods集成

在工程的Podfile里面添加以下代码：

pod 'Bugly'

保存并执行pod install,然后用后缀为.xcworkspace的文件打开工程。

注意:
命令行下执行pod search Bugly,如显示的Bugly版本不是最新的，则先执行pod repo update操作更新本地repo的内容
关于CocoaPods的更多信息请查看 CocoaPods官方网站。

手动集成

• 下载 Bugly iOS SDK
• 拖拽Bugly.framework文件到Xcode工程内(请勾选Copy items if needed选项)
• 添加依赖库
  • SystemConfiguration.framework
  • Security.framework
  • libz.dylib 或 libz.tbd
  • libc++.dylib 或 libc++.tbd

初始化SDK

导入头文件

在工程的AppDelegate.m文件导入头文件

#import <Bugly/Bugly.h>

如果是Swift工程，请在对应bridging-header.h中导入

初始化Bugly

在工程AppDelegate.m的application:didFinishLaunchingWithOptions:方法中初始化：

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
    [Bugly startWithAppId:@"此处替换为你的AppId"];
    return YES;
}

默认Debug模式,是不会生成dSYM文件,需要开启.重新编译CMD+B，修改配置如下图

Bugly后台显示异常数据

dSYM文件 
iOS平台中，dSYM文件是指具有调试信息的目标文件，文件名通常为：xxx.app.dSYM。

• 为了方便找回Crash对应的dSYM文件和还原堆栈，建议每次构建或者发布APP版本的时候，备份好dSYM文件。

生成后,在哪里可以找到dSYM文件?

保存log到本地,并上传到Bugly管理后台

1.遵守代理协议

@interface AppDelegate ()<BuglyDelegate>

2.设置代理对象

BuglyConfig *config = [[BuglyConfig alloc] init];
 config.delegate = self;
 [Bugly startWithAppId:@"你的AppId" config:config];

3.实现代理方法attachmentForException

#pragma mark - Bugly代理 - 捕获异常,回调(@return 返回需上报记录，随 异常上报一起上报)
- (NSString *)attachmentForException:(NSException *)exception {

    #ifdef DEBUG // 调试
    return [NSString stringWithFormat:@"我是携带信息:%@",[self redirectNSLogToDocumentFolder]];
    #endif

    return nil;
}

#pragma mark - 保存日志文件
- (NSString *)redirectNSLogToDocumentFolder{
    //如果已经连接Xcode调试则不输出到文件
    if(isatty(STDOUT_FILENO)) {
        return nil;
    }
    UIDevice *device = [UIDevice currentDevice];
    if([[device model] hasSuffix:@"Simulator"]){
        //在模拟器不保存到文件中
        return nil;
    }
    //获取Document目录下的Log文件夹，若没有则新建
    NSArray *paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
    NSString *logDirectory = [[paths objectAtIndex:0] stringByAppendingPathComponent:@"Log"];
    NSFileManager *fileManager = [NSFileManager defaultManager];
    BOOL fileExists = [fileManager fileExistsAtPath:logDirectory];
    if (!fileExists) {
        [fileManager createDirectoryAtPath:logDirectory  withIntermediateDirectories:YES attributes:nil error:nil];
    }
    NSDateFormatter *formatter = [[NSDateFormatter alloc] init];
    [formatter setLocale:[[NSLocale alloc] initWithLocaleIdentifier:@"zh_CN"]];
    [formatter setDateFormat:@"yyyy-MM-dd HH:mm:ss"]; //每次启动后都保存一个新的日志文件中
    NSString *dateStr = [formatter stringFromDate:[NSDate date]];
    NSString *logFilePath = [logDirectory stringByAppendingFormat:@"/%@.txt",dateStr];
    // freopen 重定向输出输出流，将log输入到文件
    freopen([logFilePath cStringUsingEncoding:NSASCIIStringEncoding], "a+", stdout);
    freopen([logFilePath cStringUsingEncoding:NSASCIIStringEncoding], "a+", stderr);

    return [[NSString alloc] initWithContentsOfFile:logFilePath encoding:NSUTF8StringEncoding error:nil];

}

Bugly iOS 符号表配置

什么是符号表？

符号表是内存地址与函数名、文件名、行号的映射表。符号表元素如下所示：

<起始地址> <结束地址> <函数> [<文件名:行号>]

为什么要配置符号表？ 
为了能快速并准确地定位用户APP发生Crash的代码位置，Bugly使用符号表对APP发生Crash的程序堆栈进行解析和还原。

自动配置：XCode + sh脚本

使用文档中的方式一进行配置（默认方式）

配置Xcode编译执行脚本

• 在Xcode工程对应Target的Build Phases中新增Run Scrpit Phase

打开工具包中的dSYM_upload.sh，复制所有内容，在新增的Run Scrpit Phase中粘贴

修改新增的Run Scrpit中的 <YOUR_APP_ID> 为您的App ID，<YOUR_APP_KEY>为您的App Key，<YOUR_BUNDLE_ID> 为App的Bundle Id

脚本默认在Debug模式及模拟器编译情况下不会上传符号表，在需要上传的时候，请修改下列选项

• Debug模式编译是否上传，1＝上传 0＝不上传，默认不上传

UPLOAD_DEBUG_SYMBOLS=0

• 模拟器编译是否上传，1＝上传 0＝不上传，默认不上传

UPLOAD_SIMULATOR_SYMBOLS=0

一、前言

性能问题极大程度的会影响到用户的体验，对于我们开发者和测试同学要随时随地保证我们app的质量，避免不好的体验带来用户的流失。本篇文章我们来讲一下，性能监控的几款工具的技术实现。主要包括，帧率监控、CPU监控、内存监控、流量监控、卡顿监控和自定义监控这几个功能。

有人说帧率、CPU和内存这些信息我们都可以在Xcode中的Instruments工具进行联调的时候可以查看，为什么还要在客户端中打印出来呢？

1. 第一、很多测试同学比较关注App质量，但是他们却没有Xcode运行环境，他们对于质量数据无法很有效的查看。
2. 第二、App端实时的查看App的质量数据，不依赖IDE，方便快捷直观。
3. 第三、实时采集性能数据，为后期结合测试平台产生性能数据报表提供数据来源。

二、技术实现

3.1：帧率展示

app的流畅度是最直接影响用户体验的，如果我们app持续卡顿，会严重影响我们app的用户留存度。所以对于用户App是否流畅进行监控，能够让我们今早的发现我们app的性能问题。对于App流畅度最直观最简单的监控手段就是对我们App的帧率进行监控。

帧率（FPS）是指画面每秒传输帧数，通俗来讲就是指动画或视频的画面数。FPS是测量用于保存、显示动态视频的信息数量。每秒钟帧数愈多，所显示的动作就会越流畅。对于我们App开发来说，我们要保持FPS高于50以上，用户体验才会流畅。

在YYKit Demo工程中有一个工具类叫YYFPSLabel，它是基于CADisplayLink这个类做FPS计算的，CADisplayLink是CoreAnimation提供的另一个类似于NSTimer的类，它会在屏幕每次刷新回调一次。既然CADisplayLink可以以屏幕刷新的频率调用指定selector，而且iOS系统中正常的屏幕刷新率为60Hz（60次每秒），那只要在这个方法里面统计每秒这个方法执行的次数，通过次数/时间就可以得出当前屏幕的刷新率了。

大致实现思路如下：

- (void)startRecord{
    if (_link) {
        _link.paused = NO;
    }else{
        _link = [CADisplayLink displayLinkWithTarget:self selector:@selector(trigger:)];
        [_link addToRunLoop:[NSRunLoop mainRunLoop] forMode:NSRunLoopCommonModes];
        _record = [DoraemonRecordModel instanceWithType:DoraemonRecordTypeFPS];
        _record.startTime = [[NSDate date] timeIntervalSince1970];
    }
}
 
- (void)trigger:(CADisplayLink *)link{
    if (_lastTime == 0) {
        _lastTime = link.timestamp;
        return;
    }
    
    _count++;
    NSTimeInterval delta = link.timestamp - _lastTime;
    if (delta < 1) return;
    _lastTime = link.timestamp;
    CGFloat fps = _count / delta;
    _count = 0;
    
    NSInteger intFps = (NSInteger)(fps+0.5);
    // 0~60   对应 高度0~200
    [self.record addRecordValue:fps time:[[NSDate date] timeIntervalSince1970]];
    [_oscillogramView addHeightValue:fps*200./60. andTipValue:[NSString stringWithFormat:@"%zi",intFps]];
}

值得注意的是基于CADisplayLink实现的 FPS 在生产场景中只有指导意义，不能代表真实的 FPS，因为基于CADisplayLink实现的 FPS 无法完全检测出当前 Core Animation 的性能情况，它只能检测出当前 RunLoop 的帧率。但要真正定位到准确的性能问题所在，最好还是通过Instrument来确认。

3.2：CPU展示

CPU是移动设备的运算核心和控制核心，如果我们的App的使用率长时间处于高消耗的话，我们的手机会发热，电量使用加剧，导致App产生卡顿，严重影响用户体验。所以对于CPU使用率进行实时的监控，也有利于及时的把控我们App的整体质量，阻止不合格的功能上线。

对于app使用率的获取，网上的方案还是比较统一的。

1. 使用task_threads函数，获取当前App行程中所有的线程列表。
2. 对于第一步中获取的线程列表进行遍历，通过thread_info函数获取每一个非闲置线程的cpu使用率，进行相加。
3. 使用vm_deallocate函数释放资源。

代码实现如下：

+ (CGFloat)cpuUsageForApp {
    kern_return_t kr;
    thread_array_t         thread_list;
    mach_msg_type_number_t thread_count;
    thread_info_data_t     thinfo;
    mach_msg_type_number_t thread_info_count;
    thread_basic_info_t basic_info_th;
    
    // get threads in the task
    //  获取当前进程中 线程列表
    kr = task_threads(mach_task_self(), &thread_list, &thread_count);
    if (kr != KERN_SUCCESS)
        return -1;
 
    float tot_cpu = 0;
    
    for (int j = 0; j < thread_count; j++) {
        thread_info_count = THREAD_INFO_MAX;
        //获取每一个线程信息
        kr = thread_info(thread_list[j], THREAD_BASIC_INFO,
                         (thread_info_t)thinfo, &thread_info_count);
        if (kr != KERN_SUCCESS)
            return -1;
        
        basic_info_th = (thread_basic_info_t)thinfo;
        if (!(basic_info_th->flags & TH_FLAGS_IDLE)) {
            // cpu_usage : Scaled cpu usage percentage. The scale factor is TH_USAGE_SCALE.
            //宏定义TH_USAGE_SCALE返回CPU处理总频率：
            tot_cpu += basic_info_th->cpu_usage / (float)TH_USAGE_SCALE;
        }
        
    } // for each thread
    
    // 注意方法最后要调用 vm_deallocate，防止出现内存泄漏
    kr = vm_deallocate(mach_task_self(), (vm_offset_t)thread_list, thread_count * sizeof(thread_t));
    assert(kr == KERN_SUCCESS);
    
    return tot_cpu;
}

测试结果基本和Xcode测量出来的cpu使用率是一样的，还是比较准确的。

3.3：内存展示

设备内存和CPU一样都是系统中最稀少的资源，也是最有可能产生竞争的资源，应用内存跟app的性能直接相关。如果一个app在前台消耗内存过多，会引起系统强杀，这种现象叫做OOM。表现跟crash一样，而且这种crash事件无法被捕获到的。

获取app消耗的内存，刚开始使用的是获取使用的物理内存大小resident_size,网上大部分也是这种方案。

//当前app消耗的内存
+ (NSUInteger)useMemoryForApp{
    task_vm_info_data_t vmInfo;
    mach_msg_type_number_t count = TASK_VM_INFO_COUNT;
    kern_return_t kernelReturn = task_info(mach_task_self(), TASK_VM_INFO, (task_info_t) &vmInfo, &count);
    if(kernelReturn == KERN_SUCCESS)
    {
        int64_t memoryUsageInByte = (int64_t) vmInfo.phys_footprint;
        return memoryUsageInByte/1024/1024;
    }
    else
    {
        return -1;
    }
}
 
//设备总的内存
+ (NSUInteger)totalMemoryForDevice{
    return [NSProcessInfo processInfo].physicalMemory/1024/1024;
}

3.4：流量监控

在线下开发阶段，我们开发要和服务端联调结果，我们需要Xcode断点调试服务器返回的结果是否正确。测试阶段，测试同学会通过Charles设置代理查看结果，这些操作都需要依赖第三方工具才能实现流量监控。能不能有一个工具，能够随身携带，对流量进行监控拦截，能够方便我们很多。我们DoraemonKit就做了这件事。

对于流量监控，业界基本有以上几个方案:

• 方案1 : 腾讯GT的方案，监控系统的上行流量和下行流量。这样监控的话，力度太粗了，不能得到每一个app的流量统计，更不能的得到每一个接口的流量和统计，不符合我们的需求。

• 方案2 : 浸入业务方自己的网路库，做流量统计，这种方案可以做的非常细节，但是不是特别通用。我们公司内部omega监控平台就是这么做的，omega的流量监控代码是写在OneNetworking中的。不是特别通用。比如我们杭州团队的网路库是自研的，如果要接入omega的网络监控功能，就需要在自己的网络库中，写流量统计代码。

• 方案3 : hook系统底层网络库，这种方式比较通用，但是非常繁琐，需要hook很多个类和方法。阿里有篇文档化介绍了他们流量监控的方案，就是采用这种，下面这张图我截取过来的，看一下，还是比较复杂的。

  
  

• 方案4 : 也是DoraemonKit采用的方案，使用iOS中一个非常强大的类，叫NSURLProtocol，这个类可以拦截NSURLConnection、NSUrlSession、UIWebView中所有的网络请求，获取每一个网络请求的request和response对象。但是这个类无法拦截tcp的请求，这个是他的缺点。美团的内部监控工具赫兹就是基于该类进行处理的。

下面就是DoraemonKit中NSURLProtocol的具体实现：

@interface DoraemonNSURLProtocol()<NSURLConnectionDelegate,NSURLConnectionDataDelegate>
 
@property (nonatomic, strong) NSURLConnection *connection;
@property (nonatomic, assign) NSTimeInterval startTime;
@property (nonatomic, strong) NSURLResponse *response;
@property (nonatomic, strong) NSMutableData *data;
@property (nonatomic, strong) NSError *error;
 
@end
 
@implementation DoraemonNSURLProtocol
 
+ (BOOL)canInitWithRequest:(NSURLRequest *)request{
    if ([NSURLProtocol propertyForKey:kDoraemonProtocolKey inRequest:request]) {
        return NO;
    }
    if (![DoraemonNetFlowManager shareInstance].canIntercept) {
        return NO;
    }
    if (![request.URL.scheme isEqualToString:@"http"] &&
        ![request.URL.scheme isEqualToString:@"https"]) {
        return NO;
    }
    //NSLog(@"DoraemonNSURLProtocol == %@",request.URL.absoluteString);
    return YES;
}
 
+ (NSURLRequest *)canonicalRequestForRequest:(NSURLRequest *)request{
    //NSLog(@"canonicalRequestForRequest");
    NSMutableURLRequest *mutableReqeust = [request mutableCopy];
    [NSURLProtocol setProperty:@YES forKey:kDoraemonProtocolKey inRequest:mutableReqeust];
    return [mutableReqeust copy];
}
 
- (void)startLoading{
    //NSLog(@"startLoading");
    self.connection = [[NSURLConnection alloc] initWithRequest:[[self class] canonicalRequestForRequest:self.request] delegate:self];
    [self.connection start];
    self.data = [NSMutableData data];
    self.startTime = [[NSDate date] timeIntervalSince1970];
}
 
- (void)stopLoading{
    //NSLog(@"stopLoading");
    [self.connection cancel];
    DoraemonNetFlowHttpModel *httpModel = [DoraemonNetFlowHttpModel dealWithResponseData:self.data response:self.response request:self.request];
    if (!self.response) {
        httpModel.statusCode = self.error.localizedDescription;
    }
    httpModel.startTime = self.startTime;
    httpModel.endTime = [[NSDate date] timeIntervalSince1970];
    
    httpModel.totalDuration = [NSString stringWithFormat:@"%f",[[NSDate date] timeIntervalSince1970] - self.startTime];
    [[DoraemonNetFlowDataSource shareInstance] addHttpModel:httpModel];
}
 
 
#pragma mark - NSURLConnectionDelegate
- (void)connection:(NSURLConnection *)connection didFailWithError:(NSError *)error{
    [[self client] URLProtocol:self didFailWithError:error];
    self.error = error;
}
 
- (BOOL)connectionShouldUseCredentialStorage:(NSURLConnection *)connection {
    return YES;
}
 
- (void)connection:(NSURLConnection *)connection didReceiveAuthenticationChallenge:(NSURLAuthenticationChallenge *)challenge {
    [[self client] URLProtocol:self didReceiveAuthenticationChallenge:challenge];
}
 
- (void)connection:(NSURLConnection *)connection didCancelAuthenticationChallenge:(NSURLAuthenticationChallenge *)challenge {
    [[self client] URLProtocol:self didCancelAuthenticationChallenge:challenge];
}
 
#pragma mark - NSURLConnectionDataDelegate
- (void)connection:(NSURLConnection *)connection didReceiveResponse:(NSURLResponse *)response{
    [[self client] URLProtocol:self didReceiveResponse:response cacheStoragePolicy:NSURLCacheStorageAllowed];
    self.response = response;
}
 
- (void)connection:(NSURLConnection *)connection didReceiveData:(NSData *)data{
    [[self client] URLProtocol:self didLoadData:data];
    [self.data appendData:data];
}
 
- (NSCachedURLResponse *)connection:(NSURLConnection *)connection willCacheResponse:(NSCachedURLResponse *)cachedResponse{
    return cachedResponse;
}
 
- (void)connectionDidFinishLoading:(NSURLConnection *)connection {
    [[self client] URLProtocolDidFinishLoading:self];
}

3.5：自定义监控

以上所有的操作都是针对于单个指标，无法提供一套全面的监控数据，自定义监控可以选择你需要监控的数据，目前包括帧率、CPU使用率、内存使用量和流量监控，这些监控没有波形图进行显示，均在后台进行监控，测试完毕，会把这些数据上传到我们后台进行分析。

因为目前后台是基于我们内部平台上开发的，暂时不提供开源。不过后续的话，我们也会考虑将后台的功能的功能对外提供，请大家拭目以待。对于开源版本的话，目前性能测试的结果保存在沙盒Library/Caches/DoraemonPerformance中，使用者可以使用沙盒浏览器功能导出来之后自己进行分析。

DoraemonKit项目地址：github.com/didi/Doraem…

摘自：https://blog.csdn.net/weixin_33847182/article/details/91472599

一、前言

一个比较成熟的App，经历了多个版本的迭代之后，为了方便调式和测试，往往会积累一些工具来应付这些场景。最近我们组就开源了一款适用于iOS App线下开发、测试、验收阶段，内置在App中的工具集合。使用DoraemonKit，你无需连接电脑，就可以对于App的信息进行快速的查看。一键接入、使用方便，提高开发、测试、视觉同学的工作效率，提高我们App上线的完整度和稳定性。

目前DoraemonKit拥有的功能大概分为以下几点：

1. 常用工具 : App信息展示，沙盒浏览、MockGPS、H5任意门、子线程UI检查、日志显示。
2. 性能工具 : 帧率监控、CPU监控、内存监控、流量监控、自定义监控。
3. 视觉工具 : 颜色吸管、组件检查、对齐标尺。
4. 业务专区 : 支持业务测试组件接入到DoraemonKit面板中。

拿我们App接入效果如下：

 上面两行是业务线自定义的工具，接入方可以自定义。除此之外都是内置工具集合

因为里面功能比较多，大概会分三篇文章介绍DoraemonKit的使用和技术实现，这是第一篇主要介绍常用工具集中的几款工具实现。

二、技术实现

2.1：App信息展示

我们要看一些手机信息或者App的一些基本信息的时候，需要到系统设置去找，比较麻烦。特别是权限信息，在我们app装的比较多的时候，我们很难快速找到我们app的权限信息。而这些信息从代码角度都是比较容易获取的。我们把我们感兴趣的信息列表出来直接查看，避免了去手机设置里查看或者查看源代码的麻烦。

获取手机型号

我们从手机设置里面是找不到我们的手机具体是哪一款的文字表述的，比如我的手机是iphone8 Pro，在手机型号里面显示的是MQ8E2CH/A。对于iPhone不熟悉的人很难从外表对iphone进行区分。而手机型号，我们从代码角度就很好获取。

+ (NSString *)iphoneType{
    struct utsname systemInfo;
    uname(&systemInfo);
    NSString *platform = [NSString stringWithCString:systemInfo.machine encoding:NSUTF8StringEncoding];
    
    //iPhone
    if ([platform isEqualToString:@"iPhone1,1"]) return @"iPhone 1G";
     ...
     //其他对应关系请看下面对应表    
    return platform;
}

获取手机系统版本

//获取手机系统版本
NSString *phoneVersion = [[UIDevice currentDevice] systemVersion];
复制代码

获取App BundleId

一个app分为测试版本、企业版本、appStore发售版本，每一个app长得都一样，如何对他们进行区分呢，那就要用到BundleId这个属性了。

//获取bundle id
NSString *bundleId = [[NSBundle mainBundle] bundleIdentifier];

获取App 版本号

//获取App版本号
NSString *bundleVersionCode = [[[NSBundle mainBundle]infoDictionary] objectForKey:@"CFBundleVersion"];

权限信息查看

当我们发现App运行不正常，比如无法定位，网络一直失败，无法收到推送信息等问题的时候，我们第一个反应就是去手机设置里面去看我们app相关的权限有没有打开。DoraemonKit集成了对于地理位置权限、网络权限、推送权限、相机权限、麦克风权限、相册权限、通讯录权限、日历权限、提醒事项权限的查询。

由于代码比较多，这里就不一一贴出来了。大家可以去DorameonKit/Core/Plugin/AppInfo中自己去查看。这里讲一下，权限查询结果几个值的意义。

• NotDetermined => 用户还没有选择。
• Restricted => 该权限受限，比如家长控制。
• Denied => 用户拒绝使用该权限。
• Authorized => 用户同意使用该权限。

2.2：沙盒浏览

以前如果我们要去查看App缓存、日志信息，都需要访问沙盒。由于iOS的封闭性，我们无法直接查看沙盒中的文件内容。如果我们要去访问沙盒，基本上有两种方式，第一种使用Xcode自带的工具，从Windows-->Devices进入设备管理界面，通过Download Container的方式导出整个app的沙盒。第二种方式，就是自己写代码，访问沙盒中指定文件，然后使用NSLog的方式打印出来。这两种方式都比较麻烦。

DoraemonKit给出的解决方案：就是自己做一个简单的文件浏览器，通过NSFileManager对象对沙盒文件进行遍历，同时支持对于文件和文件夹的删除操作。对于文件支持本地预览或者通过airdrop的方式或者其他分享方式发送到PC端进行更加细致的操作。

怎么用NSFileManager对象遍历文件和删除文件这里就不说了，大家可以参考DorameonKit/Core/Plugin/Sanbox中的代码。这里讲一下：如何将手机中的文件快速上传到Mac端？刚开始我们还绕了一点路，我们在手机端搭了一个微服务，mac通过浏览器去访问它。后来和同事聊天的时候知道了UIActivityViewController这个类，可以十分便捷地吊起系统分享组件或者是其他注册到系统分享组件中的分享方式，比如微信、钉钉。实现代码非常简单，如下所示：

- (void)shareFileWithPath:(NSString *)filePath{
    
    NSURL *url = [NSURL fileURLWithPath:filePath];
    NSArray *objectsToShare = @[url];
 
    UIActivityViewController *controller = [[UIActivityViewController alloc] initWithActivityItems:objectsToShare applicationActivities:nil];
    NSArray *excludedActivities = @[UIActivityTypePostToTwitter, UIActivityTypePostToFacebook,
                                    UIActivityTypePostToWeibo,
                                    UIActivityTypeMessage, UIActivityTypeMail,
                                    UIActivityTypePrint, UIActivityTypeCopyToPasteboard,
                                    UIActivityTypeAssignToContact, UIActivityTypeSaveToCameraRoll,
                                    UIActivityTypeAddToReadingList, UIActivityTypePostToFlickr,
                                    UIActivityTypePostToVimeo, UIActivityTypePostToTencentWeibo];
    controller.excludedActivityTypes = excludedActivities;
 
    [self presentViewController:controller animated:YES completion:nil];
}

2.3：MockGPS

我们有些业务会根据地理位置不同，而有不同的业务处理逻辑。而我们开发或者测试，当然不可能去每一个地址都测试一遍。这种情况下，测试同学一般会找到我们让我们手动改掉系统获取经纬度的回调，或者修改GPX文件，然后再重新打一个包。这样也非常麻烦。

DoraemonKit给出的解决方案：提供一套地图界面，支持在地图中滑动选择或者手动输入经纬度，然后自动替换掉我们App中返回的当前经纬度信息。这里的难点是如何不需要重新打包自动替换掉系统返回的当前经纬度信息？

CLLocationManager的delegate中有一个方法如下：

/*
 *  locationManager:didUpdateLocations:
 *
 *  Discussion:
 *    Invoked when new locations are available.  Required for delivery of
 *    deferred locations.  If implemented, updates will
 *    not be delivered to locationManager:didUpdateToLocation:fromLocation:
 *
 *    locations is an array of CLLocation objects in chronological order.
 */
- (void)locationManager:(CLLocationManager *)manager
	 didUpdateLocations:(NSArray<CLLocation *> *)locations API_AVAILABLE(ios(6.0), macos(10.9));

我们通常是在这个函数中获取当前系统的经纬度信息。我们如果想要没有侵入式的修改这个函数的默认实现方式，想到的第一个方法就是Method Swizzling。但是真正在实现过程中，你会发现Method Swizzling需要当前实例和方法，方法是- (void)locationManager:(CLLocationManager *)manager didUpdateLocations:(NSArray<CLLocation *> *)locations 我们有了，但是实例，每一个app都有自己的实现，无法做到统一处理。我们就换了一个思路，如何能获取该实现了该定位方法的实例呢？就是使用Method Swizzling Hook住CLLocationManager的setDelegate方法，就能获取具体是哪一个实例实现了- (void)locationManager:(CLLocationManager *)manager didUpdateLocations:(NSArray<CLLocation *> *)locations 方法。

具体方法如下：

第一步： 生成一个CLLocationManager的分类CLLocationManager(Doraemon),在这个分类中，实现- (void)doraemon_swizzleLocationDelegate:(id)delegate这个方法，用来进行方法交换。

- (void)doraemon_swizzleLocationDelegate:(id)delegate {
    if (delegate) {
        //1、让所有的CLLocationManager的代理都设置为[DoraemonGPSMocker shareInstance]，让他做中间转发
        [self doraemon_swizzleLocationDelegate:[DoraemonGPSMocker shareInstance]];
        //2、绑定所有CLLocationManager实例与delegate的关系，用于[DoraemonGPSMocker shareInstance]做目标转发用。
        [[DoraemonGPSMocker shareInstance] addLocationBinder:self delegate:delegate];
        
        //3、处理[DoraemonGPSMocker shareInstance]没有实现的selector，并且给用户提示。
        Protocol *proto = objc_getProtocol("CLLocationManagerDelegate");
        unsigned int count;
        struct objc_method_description *methods = protocol_copyMethodDescriptionList(proto, NO, YES, &count);
        NSMutableArray *array = [NSMutableArray array];
        for(unsigned i = 0; i < count; i++)
        {
            SEL sel = methods[i].name;
            if ([delegate respondsToSelector:sel]) {
                if (![[DoraemonGPSMocker shareInstance] respondsToSelector:sel]) {
                    NSAssert(NO, @"你在Delegate %@ 中所使用的SEL %@，暂不支持，请联系DoraemonKit开发者",delegate,sel);
                }
            }
        }
        free(methods);
        
    }else{
        [self doraemon_swizzleLocationDelegate:delegate];
    }
}

在这个函数中主要做了三件事情，1、将所有的定位回调统一交给[DoraemonGPSMocker shareInstance]处理 2、[DoraemonGPSMocker shareInstance]绑定了所有CLLocationManager与它的delegate的一一对应关系。3、处理[DoraemonGPSMocker shareInstance]没有实现的selector，并且给用户提示。

第二步：当有一个定位回调过来的时候，我们先传给[DoraemonGPSMocker shareInstance]，然后[DoraemonGPSMocker shareInstance]再转发给它绑定过的所有的delegate。那我们App为例，绑定关系如下：{

    "0x2800a07a0_binder" = "<CLLocationManager: 0x2800a07a0>";
    "0x2800a07a0_delegate" = "<MAMapLocationManager: 0x2800a04d0>";
    "0x2800b59a0_binder" = "<CLLocationManager: 0x2800b59a0>";
    "0x2800b59a0_delegate" = "<KDDriverLocationManager: 0x2829d3bf0>";
}

由此可见，我们App的统一定位KDDriverLocationManager和苹果地图的定位MAMapLocationManager都是使用都是CLLocationManager提供的。

具体 DoraemonGPSMocker这个类如何实现，请参考DorameonKit/Core/Plugin/GPS中的代码。

2.4：H5任意门

有的时候Native和H5开发同时开发一个功能，H5依赖native提供入口，而这个时候Native还没有开发好，这个时候H5开发就没法在App上看到效果。再比如，有些H5页面处于的位置比较深入，就像我们代驾司机端，做单流程比较多，有的H5界面需要很繁琐的操作才能展示到App上，不方便我们查看和定位问题。 这个时候我们可以为app做一个简单的浏览器，输入url，使用自带的容器进行跳转。因为每一个app的H5容器基本上都是自定义过得，都会有自己的bridge定制化，所以这个H5容器没有办法使用系统原生的UIWebView或者WKWebView，就只能交给业务方自己去完成。我们在DorameonKit初始化的时候，提供了一个回调让业务方用自己的H5容器去打开这个Url：

[[DoraemonManager shareInstance] addH5DoorBlock:^(NSString *h5Url) {
              //使用自己的H5容器打开这个链接
 }];

2.5：子线程UI检查

在iOS中是不允许在子线程中对UI进行操作和渲染的，不然会造成未知的错误和问题，甚至会导致crash。我们在最近几个版本中发现新增了一些crash，调查原因就是在子线程中操作UI导致的。为了对于这种情况可以提早被我们发现，我在在DorameonKit中增加了子线程UI渲染检查查询。

具体事项思路，我们hook住UIView的三个必须在主线程中操作的绘制方法。1、setNeedsLayout 2、setNeedsDisplay 3、setNeedsDisplayInRect:。然后判断他们是不是在子线程中进行操作,如果是在子线程进行操作的话，打印出当前代码调用堆栈，提供给开发进行解决。具体代码如下：

@implementation UIView (Doraemon)
 
+ (void)load{
    [[self  class] doraemon_swizzleInstanceMethodWithOriginSel:@selector(setNeedsLayout) swizzledSel:@selector(doraemon_setNeedsLayout)];
    [[self class] doraemon_swizzleInstanceMethodWithOriginSel:@selector(setNeedsDisplay) swizzledSel:@selector(doraemon_setNeedsDisplay)];
    [[self class] doraemon_swizzleInstanceMethodWithOriginSel:@selector(setNeedsDisplayInRect:) swizzledSel:@selector(doraemon_setNeedsDisplayInRect:)];
}
 
- (void)doraemon_setNeedsLayout{
    [self doraemon_setNeedsLayout];
    [self uiCheck];
}
 
- (void)doraemon_setNeedsDisplay{
    [self doraemon_setNeedsDisplay];
    [self uiCheck];
}
 
- (void)doraemon_setNeedsDisplayInRect:(CGRect)rect{
    [self doraemon_setNeedsDisplayInRect:rect];
    [self uiCheck];
}
 
- (void)uiCheck{
    if([[DoraemonCacheManager sharedInstance] subThreadUICheckSwitch]){
        if(![NSThread isMainThread]){
            NSString *report = [BSBacktraceLogger bs_backtraceOfCurrentThread];
            NSDictionary *dic = @{
                                  @"title":[DoraemonUtil dateFormatNow],
                                  @"content":report
                                  };
            [[DoraemonSubThreadUICheckManager sharedInstance].checkArray addObject:dic];
        }
    }
}
 
@end

2.6：日志显示

这个主要是方便我们查看本地日志，以前我们如果要查看日志，需要自己写代码，访问沙盒导出日志文件，然后再查看。也是比较麻烦的。

DoraemonKit的解决方案是：我们每一次触发日志的时候，都把日志内容显示到界面上，方便我们查看。 如何实现的呢？因为我们这个工具并不是一个通用性的工具，只针对于底层日志库是CocoaLumberjack的情况。稍微讲一下的CocoaLumberjack原理，所有的log都会发给DDLog对象，其运行在自己的一个GCD队列中，之后，DDLog会将log分发给其下注册的一个或者多个Logger中，这一步在多核下面是并发的，效率很高。每一个Logger处理收到的log也是在它们自己的GCD队列下做的，它们询问其下的Formatter，获取Log消息格式，然后根据Logger的逻辑，将log消息分发到不同的地方。系统自带三个Logger处理器，DDTTYLogger，主要将日志发送到Xcode控制台；DDASLLogger，主要讲日志发送到苹果的日志系统Console.app; DDFileLogger，主要将日志发送到文件中保存起来，也是我们开发用到最多的。但是自带的Logger并不满足我们的需求，我们的需求是将日志显示到UI界面中，所以我们需要新建一个类DoraemonLogger，继承于DDAbstractLogger，然后重写logMessage方法，将每一条传过来的日志打印到UI界面中。

DoraemonKit项目地址：github.com/didi/Doraem…

转自：https://blog.csdn.net/weixin_33737134/article/details/91469113

通过iOS性能优化 我们知道，简单来说App卡顿，就是FPS达不到60帧率，丢帧现象，就会卡顿。但是很多时候，我们只知道丢帧了。具体为什么丢帧，却不是很清楚，那么我们要怎么监控呢，首先我们要明白，要找出卡顿，就是要找出主线程做了什么，而线程消息，是依赖RunLoop的，所以我们可以使用RunLoop来监控。

RunLoop是用来监听输入源，进行调度处理的。如果RunLoop的线程进入睡眠前方法的执行时间过长而导致无法进入睡眠，或者线程唤醒后接收消息时间过长而无法进入下一步，就可以认为是线程受阻了。如果这个线程是主线程的话，表现出来的就是出现了卡顿。

RunLoop和信号量

我们可以使用CFRunLoopObserverRef来监控NSRunLoop的状态,通过它可以实时获得这些状态值的变化。

runloop

关于runloop,可以参照 RunLoop详解之源码分析 这篇文章详细了解。这里简单总结一下:

runloop的状态

/* Run Loop Observer Activities */
typedef CF_OPTIONS(CFOptionFlags, CFRunLoopActivity) {
    kCFRunLoopEntry = (1UL << 0),           // 即将进入Loop
    kCFRunLoopBeforeTimers = (1UL << 1),    //即将处理Timer
    kCFRunLoopBeforeSources = (1UL << 2),   //即将处理Source
    kCFRunLoopBeforeWaiting = (1UL << 5),   //即将进入休眠
    kCFRunLoopAfterWaiting = (1UL << 6),    //刚从休眠中唤醒
    kCFRunLoopExit = (1UL << 7),            //即将退出Loop
    kCFRunLoopAllActivities = 0x0FFFFFFFU   //所有状态改变
};

CFRunLoopObserverRef 的使用流程
设置Runloop observer的运行环境

CFRunLoopObserverContext context = {0, (__bridge void *)self, NULL, NULL};

2. 创建Runloop observer对象

第一个参数：用于分配observer对象的内存
第二个参数：用以设置observer所要关注的事件
第三个参数：用于标识该observer是在第一次进入runloop时执行还是每次进入runloop处理时均执行
第四个参数：用于设置该observer的优先级
第五个参数：用于设置该observer的回调函数
第六个参数：用于设置该observer的运行环境
 // 创建Runloop observer对象
   _observer = CFRunLoopObserverCreate(kCFAllocatorDefault,
                                       kCFRunLoopAllActivities,
                                       YES,
                                       0,
                                       &runLoopObserverCallBack,
                                       &context);



3. 将新建的observer加入到当前thread的runloop

CFRunLoopAddObserver(CFRunLoopGetMain(), _observer, kCFRunLoopCommonModes);


4. 将observer从当前thread的runloop中移除

CFRunLoopRemoveObserver(CFRunLoopGetMain(), _observer, kCFRunLoopCommonModes);


5. 释放 observer

CFRelease(_observer); _observer = NULL;

信号量
关于信号量，可以详细参考 GCD信号量-dispatch_semaphore_t
简单来说,主要有三个函数

dispatch_semaphore_create(long value); // 创建信号量
dispatch_semaphore_signal(dispatch_semaphore_t deem); // 发送信号量
dispatch_semaphore_wait(dispatch_semaphore_t dsema, dispatch_time_t timeout); // 等待信号量

dispatch_semaphore_create(long value);和GCD的group等用法一致，这个函数是创建一个dispatch_semaphore_类型的信号量，并且创建的时候需要指定信号量的大小。
dispatch_semaphore_wait(dispatch_semaphore_t dsema, dispatch_time_t timeout); 等待信号量。如果信号量值为0，那么该函数就会一直等待，也就是不返回（相当于阻塞当前线程），直到该函数等待的信号量的值大于等于1，该函数会对信号量的值进行减1操作，然后返回。
dispatch_semaphore_signal(dispatch_semaphore_t deem); 发送信号量。该函数会对信号量的值进行加1操作。
通常等待信号量和发送信号量的函数是成对出现的。并发执行任务时候，在当前任务执行之前，用dispatch_semaphore_wait函数进行等待（阻塞），直到上一个任务执行完毕后且通过dispatch_semaphore_signal函数发送信号量（使信号量的值加1），dispatch_semaphore_wait函数收到信号量之后判断信号量的值大于等于1，会再对信号量的值减1，然后当前任务可以执行，执行完毕当前任务后，再通过dispatch_semaphore_signal函数发送信号量（使信号量的值加1），通知执行下一个任务……如此一来，通过信号量，就达到了并发队列中的任务同步执行的要求。

监控卡顿
原理: 利用观察Runloop各种状态变化的持续时间来检测计算是否发生卡顿
一次有效卡顿采用了“N次卡顿超过阈值T”的判定策略，即一个时间段内卡顿的次数累计大于N时才触发采集和上报：举例，卡顿阈值T=500ms、卡顿次数N=1，可以判定为单次耗时较长的一次有效卡顿；而卡顿阈值T=50ms、卡顿次数N=5，可以判定为频次较快的一次有效卡顿

主要代码

// minimum
static const NSInteger MXRMonitorRunloopMinOneStandstillMillisecond = 20;
static const NSInteger MXRMonitorRunloopMinStandstillCount = 1;

// default
// 超过多少毫秒为一次卡顿
static const NSInteger MXRMonitorRunloopOneStandstillMillisecond = 50;
// 多少次卡顿纪录为一次有效卡顿
static const NSInteger MXRMonitorRunloopStandstillCount = 1;

@interface YZMonitorRunloop(){
    CFRunLoopObserverRef _observer;  // 观察者
    dispatch_semaphore_t _semaphore; // 信号量
    CFRunLoopActivity _activity;     // 状态
}
@property (nonatomic, assign) BOOL isCancel; //f是否取消检测
@property (nonatomic, assign) NSInteger countTime; // 耗时次数
@property (nonatomic, strong) NSMutableArray *backtrace;

-(void)registerObserver{
//    1. 设置Runloop observer的运行环境
    CFRunLoopObserverContext context = {0, (__bridge void *)self, NULL, NULL};
    // 2. 创建Runloop observer对象
  
//    第一个参数：用于分配observer对象的内存
//    第二个参数：用以设置observer所要关注的事件
//    第三个参数：用于标识该observer是在第一次进入runloop时执行还是每次进入runloop处理时均执行
//    第四个参数：用于设置该observer的优先级
//    第五个参数：用于设置该observer的回调函数
//    第六个参数：用于设置该observer的运行环境
    _observer = CFRunLoopObserverCreate(kCFAllocatorDefault,
                                        kCFRunLoopAllActivities,
                                        YES,
                                        0,
                                        &runLoopObserverCallBack,
                                        &context);
    // 3. 将新建的observer加入到当前thread的runloop
    CFRunLoopAddObserver(CFRunLoopGetMain(), _observer, kCFRunLoopCommonModes);
    // 创建信号  dispatchSemaphore的知识参考：https://www.jianshu.com/p/24ffa819379c
    _semaphore = dispatch_semaphore_create(0); ////Dispatch Semaphore保证同步
    
    __weak __typeof(self) weakSelf = self;
    
    //    dispatch_queue_t queue = dispatch_queue_create("kadun", NULL);
    
    // 在子线程监控时长
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        //      dispatch_async(queue, ^{
        __strong __typeof(weakSelf) strongSelf = weakSelf;
        if (!strongSelf) {
            return;
        }
        while (YES) {
            if (strongSelf.isCancel) {
                return;
            }
            // N次卡顿超过阈值T记录为一次卡顿
            // 等待信号量：如果信号量是0，则阻塞当前线程；如果信号量大于0，则此函数会把信号量-1，继续执行线程。此处超时时间设为limitMillisecond 毫秒。
            // 返回值：如果线程是唤醒的，则返回非0，否则返回0
            long semaphoreWait = dispatch_semaphore_wait(self->_semaphore, dispatch_time(DISPATCH_TIME_NOW, strongSelf.limitMillisecond * NSEC_PER_MSEC));
            
            if (semaphoreWait != 0) {
                
                // 如果 RunLoop 的线程，进入睡眠前方法的执行时间过长而导致无法进入睡眠(kCFRunLoopBeforeSources)，或者线程唤醒后接收消息时间过长(kCFRunLoopAfterWaiting)而无法进入下一步的话，就可以认为是线程受阻。
                //两个runloop的状态，BeforeSources和AfterWaiting这两个状态区间时间能够监测到是否卡顿
                if (self->_activity == kCFRunLoopBeforeSources || self->_activity == kCFRunLoopAfterWaiting) {
                    
                    if (++strongSelf.countTime < strongSelf.standstillCount){
                        NSLog(@"%ld",strongSelf.countTime);
                        continue;
                    }
                    [strongSelf logStack];
                    [strongSelf printLogTrace];
                    
                    NSString *backtrace = [YZCallStack yz_backtraceOfMainThread];
                    NSLog(@"++++%@",backtrace);
                    
                    [[YZLogFile sharedInstance] writefile:backtrace];
                    
                    if (strongSelf.callbackWhenStandStill) {
                        strongSelf.callbackWhenStandStill();
                    }
                }
            }
            strongSelf.countTime = 0;
        }
    });
}

demo测试
我把demo放在了github demo地址

使用时候，只需要

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
    // Override point for customization after application launch.
    
    [[YZMonitorRunloop sharedInstance] startMonitor];
    [YZMonitorRunloop sharedInstance].callbackWhenStandStill = ^{
        NSLog(@"eagle.检测到卡顿了");
    };
    return YES;
}

控制器中，每次点击屏幕，休眠1秒钟，如下

#import "ViewController.h"

@interface ViewController ()

@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    
}
- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event{
     usleep(1 * 1000 * 1000); // 1秒
   
}

@end

点击屏幕之后，打印如下

YZMonitorRunLoopDemo[10288:1915706] ==========检测到卡顿之后调用堆栈==========
 (
    "0   YZMonitorRunLoopDemo                0x00000001022c653c -[YZMonitorRunloop logStack] + 96",
    "1   YZMonitorRunLoopDemo                0x00000001022c62a0 __36-[YZMonitorRunloop registerObserver]_block_invoke + 484",
    "2   libdispatch.dylib                   0x00000001026ab6f0 _dispatch_call_block_and_release + 24",
    "3   libdispatch.dylib                   0x00000001026acc74 _dispatch_client_callout + 16",
    "4   libdispatch.dylib                   0x00000001026afad4 _dispatch_queue_override_invoke + 876",
    "5   libdispatch.dylib                   0x00000001026bddc8 _dispatch_root_queue_drain + 372",
    "6   libdispatch.dylib                   0x00000001026be7ac _dispatch_worker_thread2 + 156",
    "7   libsystem_pthread.dylib             0x00000001b534d1b4 _pthread_wqthread + 464",
    "8   libsystem_pthread.dylib             0x00000001b534fcd4 start_wqthread + 4"
) 

libsystem_kernel.dylib          0x1b52ca400 __semwait_signal + 8
libsystem_c.dylib               0x1b524156c nanosleep + 212
libsystem_c.dylib               0x1b5241444 usleep + 64
YZMonitorRunLoopDemo            0x1022c18dc -[ViewController touchesBegan:withEvent:] + 76
UIKitCore                       0x1e1f4fcdc <redacted> + 336
UIKitCore                       0x1e1f4fb78 <redacted> + 60
UIKitCore                       0x1e1f5e0f8 <redacted> + 1584
UIKitCore                       0x1e1f5f52c <redacted> + 3140
UIKitCore                       0x1e1f3f59c <redacted> + 340
UIKitCore                       0x1e2005714 <redacted> + 1768
UIKitCore                       0x1e2007e40 <redacted> + 4828
UIKitCore                       0x1e2001070 <redacted> + 152
CoreFoundation                  0x1b56bf018 <redacted> + 24
CoreFoundation                  0x1b56bef98 <redacted> + 88
CoreFoundation                  0x1b56be880 <redacted> + 176
CoreFoundation                  0x1b56b97

即可定位到卡顿位置
-[ViewController touchesBegan:withEvent:]
卡顿日志写入本地
上面已经监控到了卡顿，和调用堆栈。如果是debug模式下，可以直接看日志，如果想在线上查看的话，可以写入本地，然后上传到服务器

写入本地数据库
创建本地路径

-(NSString *)getLogPath{
    NSArray *paths  = NSSearchPathForDirectoriesInDomains(NSCachesDirectory,NSUserDomainMask,YES);
    NSString *homePath = [paths objectAtIndex:0];
    
    NSString *filePath = [homePath stringByAppendingPathComponent:@"Caton.log"];
    return filePath;
}

如果是第一次写入，带上设备信息，手机型号等信息

NSString *filePath = [self getLogPath];
   NSFileManager *fileManager = [NSFileManager defaultManager];
   
   if(![fileManager fileExistsAtPath:filePath]) //如果不存在
   {
       NSString *str = @"卡顿日志";
       NSString *systemVersion = [NSString stringWithFormat:@"手机版本: %@",[YZAppInfoUtil iphoneSystemVersion]];
       NSString *iphoneType = [NSString stringWithFormat:@"手机型号: %@",[YZAppInfoUtil iphoneType]];
       str = [NSString stringWithFormat:@"%@\n%@\n%@",str,systemVersion,iphoneType];
       [str writeToFile:filePath atomically:YES encoding:NSUTF8StringEncoding error:nil];
       
   }

如果本地文件已经存在，就先判断大小是否过大，决定是否直接写入，还是先上传到服务器

float filesize = -1.0;
 if ([fileManager fileExistsAtPath:filePath]) {
            NSDictionary *fileDic = [fileManager attributesOfItemAtPath:filePath error:nil];
            unsigned long long size = [[fileDic objectForKey:NSFileSize] longLongValue];
            filesize = 1.0 * size / 1024;
  }
        
 NSLog(@"文件大小 filesize = %lf",filesize);
 NSLog(@"文件内容 %@",string);
 NSLog(@" ---------------------------------");
        
if (filesize > (self.MAXFileLength > 0 ? self.MAXFileLength:DefaultMAXLogFileLength)) {
     // 上传到服务器
       NSLog(@" 上传到服务器");
       [self update];
       [self clearLocalLogFile];
       [self writeToLocalLogFilePath:filePath contentStr:string];
   }else{
        NSLog(@"继续写入本地");
        [self writeToLocalLogFilePath:filePath contentStr:string];
   }

压缩日志，上传服务器
因为都是文本数据，所以我们可以压缩之后，打打降低占用空间，然后进行上传，上传成功之后，删除本地，然后继续写入，等待下次写日志

压缩工具
使用 SSZipArchive具体使用起来也很简单，

// Unzipping
NSString *zipPath = @"path_to_your_zip_file";
NSString *destinationPath = @"path_to_the_folder_where_you_want_it_unzipped";
[SSZipArchive unzipFileAtPath:zipPath toDestination:destinationPath];
// Zipping
NSString *zippedPath = @"path_where_you_want_the_file_created";
NSArray *inputPaths = [NSArray arrayWithObjects:
                       [[NSBundle mainBundle] pathForResource:@"photo1" ofType:@"jpg"],
                       [[NSBundle mainBundle] pathForResource:@"photo2" ofType:@"jpg"]
                       nil];
[SSZipArchive createZipFileAtPath:zippedPath withFilesAtPaths:inputPaths];

代码中

NSString *zipPath = [self getLogZipPath];
  NSString *password = nil;
  NSMutableArray *filePaths = [[NSMutableArray alloc] init];
  [filePaths addObject:[self getLogPath]];
  BOOL success = [SSZipArchive createZipFileAtPath:zipPath withFilesAtPaths:filePaths withPassword:password.length > 0 ? password : nil];
  
  if (success) {
      NSLog(@"压缩成功");
      
  }else{
      NSLog(@"压缩失败");
  }

具体如果上传到服务器，使用者可以用AFN等将本地的 zip文件上传到文件服务器即可，就不赘述了。
至此，我们做到了，用runloop，监控卡顿，写入日志，然后压缩上传服务器，删除本地的过程。
详细代码见demo地址

转自：https://www.jianshu.com/p/05ae5ff5a9c1

前言

最近项目需要，引入Protocol Buffer来做对象序列化。

正文
Protocol Buffer是Google出的序列化数据格式，下面简称pb。
我们更常用的序列化数据格式应该是json，json和pb本质上都是对象的序列化和反序列化，在项目中json也是前后端通信的主要数据格式。
在本地存储时，我们可以使用YYModel将对象转成json对应的NSData，也可以使用NSKeyedArchiver结合实现NSCoding协议把对象转成NSData，进而将二进制数据存储在沙盒中或者数据库。
那么为什么不使用json，而要用pb？
因为项目中序列化数据到沙盒是一个高频场景，尝试过数据库、NSCoding+NSKeyedArchiver、YYModel等方法都有各自瓶颈：数据内容比较大数据库会造成体积膨胀过快不便管理，NSCoding+NSKeyedArchiver在序列化数据量较大的情况下性能不佳，YYModel在变动的时候不太友好。

相对而言，pb有以下特点：

• pb是一种可扩展的序列化数据数据格式，新老版本的数据可以相互读取；

• pb是使用字节流方式进行序列化，体积小速度快；（相对而言json是用字符串表示的，光表示字符串的""符号就有很多）

• pb的代码是由描述文件proto生成，proto是文本文件便于做版本管理；

pb的使用

使用pb首先要定义proto的数据结构，语法非常简单，可以直接上手写：

syntax = "proto3";
message LYItemData {
    uint32 itemId = 1;
    string itemContentStr = 2;
}

这里定义一个最简单的message，第一行是声明proto的版本，然后添加两个属性itemId和itemContentStr；
使用的时候，用[LYItemData parseFromData:data error:nil];可以将NSData转换成对象，访问LYItemData类的data属性，可以拿到其序列化之后的二进制数据；
代码很简单， 序列化和反序列化都只有一行，使用样例：

NSString *path = [NSHomeDirectory() stringByAppendingPathComponent:@"test_data"];
    NSData *data = [[NSData alloc] initWithContentsOfFile:path];
    LYItemData *itemData;
    if (data) {
        itemData = [LYItemData parseFromData:data error:nil]; // 反序列化
    }
    else {
        itemData = [LYItemData new];
        itemData.itemId = (int)time(NULL);
        itemData.itemContentStr = [self timeStampConversionNSString:itemData.itemId];
        [[NSFileManager defaultManager] createFileAtPath:path contents:itemData.data attributes:nil]; // 访问itemData.data属性时会做一次序列化
    }

message可以定义容器类型，包括数组、map等；
定义数组使用repeated，表示该元素是重复的，数量从0到若干个不等；
定义字典使用map，map里面带两个参数，分别表示key和value的type；

message LYArrayData {
    repeated LYItemData items = 1;
    map<int32, string> idToContentStrMap = 2;
}

也可以在message中声明另外一个message 的属性

message LYProtobufLocalData {
    uint64 dataId = 1;
    string dataContentStr = 2;
    uint32 updateTime = 3;
    LYArrayData arrData = 4;
}

了解这些常见的message定义方式，就可以满足大多数开发，其他用到再学也不迟。
其他使用方式例如any、oneof、reserved、enum、import、package可以自行探究，我们项目中没有使用到。
不管哪种定义方式，在定义成员属性的时候，都需要指定一个数字，这个数字是tag，需要保证在类中是唯一的。
tag是属性的唯一标识符，pb会在存储和读取的时候用到这个属性。

了解这些常见的message定义方式，就可以满足大多数开发，其他用到再学也不迟。
其他使用方式例如any、oneof、reserved、enum、import、package可以自行探究，我们项目中没有使用到。
不管哪种定义方式，在定义成员属性的时候，都需要指定一个数字，这个数字是tag，需要保证在类中是唯一的。
tag是属性的唯一标识符，pb会在存储和读取的时候用到这个属性。

代码生成
代码生成可以和Xcode结合，在每次编译之后自动生成。
在 Build Phases 里面添加一段脚本（下图中的Run Proto）：先cd到proto所在的目录，然后运行脚本即可。

cd ${SOURCE_ROOT}/LearnProtoBuf/PB/
./protoc ProtobufData.proto --objc_out=./

如果项目中有多个proto，此处可以使用sh脚本，把路径名作为参数传入，在sh脚本里面分别对每个proto文件做代码生成。
如果不想使用这种方式，也可以按照传统方法先安装protobuf，网上教程比较多，这里不再赘述。

总结
在Restful架构逐渐被RPC架构淘汰的现在，pb取代json作为前后端的通信数据格式也是时代的潮流。
json最大的优势或许是后端已有的很多服务都是用json通信，一时间无法完全替换。
pb简单易用，对持续变更更加友好。
一次定义，多端使用；
版本更迭，格式兼容。

附录
官方参考文档--OC代码生成
PB-Github
二进制encode原理

转自：https://www.jianshu.com/p/e2baa9bb4f5e

从表面上看，SWIFT 5.2在新的语言特性方面肯定是一个小版本，因为这个新版本的大部分重点是提高SWIFT底层基础结构的速度和稳定性，例如如何报告编译器错误，以及如何解决构建级依赖。

然而，斯威夫特5.2总数新的语言特性可能相对较小，它确实包括两个新功能，它们可能会对SWIFT的整体功能产生相当大的影响。函数式程序设计语言.

本周，让我们探讨这些特性，以及我们如何可能使用它们来接受一些在函数式编程世界中非常流行的不同范例--在面向对象的SWIFT代码库中，它们可能会感觉更加一致和熟悉。

在我们开始之前，作为Xcode 11.4的一部分，SWIFT5.2仍然处于测试版，请注意，本文是一篇非常探索性的文章，代表了我对这些新语言特性的第一印象。随着我在生产中使用新特性获得更多经验，我的观点可能会发生变化，尽管我将尝试在这种情况下更新这篇文章，但我建议您使用本文作为灵感，亲自探索这些新特性，而不是直接使用以原样呈现的解决方案。

有了这个小小的免责声明，让我们开始探索吧！

一个开发者，有一个学习的氛围跟一个交流圈子特别重要，这是一个我的iOS交流群：1012951431， 分享BAT,阿里面试题、面试经验，讨论技术， 大家一起交流学习成长！希望帮助开发者少走弯路。

调用类型为函数

尽管SWIFT并不是一种严格的函数式编程语言，但毫无疑问，函数在其总体设计和使用中扮演着非常重要的角色。从闭包如何作为异步回调使用，到集合如何大量使用典型的函数模式(如map和reduce-职能无处不在。

SWIFT5.2的有趣之处在于它开始模糊函数和类型之间的界限。尽管我们一直能够将任何给定类型的实例方法作为函数传递(因为SWIFT支持一级函数)，我们现在能够调用某些类型，就好像它们本身是函数一样。.

让我们先来看看一个使用Cache我们内置的类型“SWIFT中的缓存”-这提供了一个更多的“快速友好”包装上的APINSCache:

class Cache {
    private let wrapped = NSCache()
    private let dateProvider: () -> Date
    private let entryLifetime: TimeInterval
    
    ...

    func insert(_ value: Value, forKey key: Key) {
        ...
    }
}

假设我们想要向上面的类型添加一个方便的API--让我们自动使用插入值的id作为它的缓存键，以防当前Value类型符合标准库的Identifiable协议。虽然我们可以简单地命名新的apiinsert还有，我们要给它起一个非常特别的名字-callAsFunction:

extension Cache where Value: Identifiable, Key == Value.ID {
    func callAsFunction(_ value: Value) {
        insert(value, forKey: value.id)
    }
}

这似乎是一种奇怪的命名约定，但通过这样命名我们的新方便方法，我们实际上已经给出了Cache输入一个有趣的新功能--它现在可能被称为函数--如下所示：

let document: Document = ...
let cache = Cache()

// We can now call our 'cache' variable as if it was referencing a
// function or a closure:
cache(document)

可以说，这既很酷，也很奇怪。但问题是-它有什么用呢？让我们继续探索，看看DocumentRenderer协议，它为用于呈现的各种类型定义了一个公共接口。Document应用程序中的实例：

protocol DocumentRenderer {
    func render(_ document: Document,
                in context: DocumentRenderingContext,
                enableAnnotations: Bool)
}

类似于我们之前向我们的Cache类型，让我们在这里做同样的事情-只是这一次，我们将扩展上面的协议，以允许任何符合的类型被调用为一个函数，其中包含一组默认参数：

extension DocumentRenderer {
    func callAsFunction(_ document: Document) {
        render(document,
            in: .makeDefaultContext(),
            enableAnnotations: false
        )
    }
}

上述两个变化在孤立的情况下看起来可能不那么令人印象深刻，但是如果我们将它们放在一起，我们就可以看到为一些更复杂的类型提供基于功能的方便API的吸引力。例如，我们在这里构建了一个DocumentViewController-使用我们的Cache类型，以及基于核心动画的DocumentRenderer协议--在加载文档时，这两种协议现在都可以简单地作为函数调用：

class DocumentViewController: UIViewController {
    private let cache: Cache
    private let render: CoreAnimationDocumentRenderer
    
    ...

    private func documentDidLoad(_ document: Document) {
        cache(document)
        render(document)
    }
}

这很酷，特别是如果我们的目标是轻量级API设计或者如果我们在建造某种形式的领域专用语言。虽然通过传递实例方法来实现类似的结果一直是可能的好像它们是封闭的-通过允许直接调用我们的类型，我们都避免了手动传递这些方法，并且能够保留API可能使用的任何外部参数标签。

例如，假设我们还想做一个PriceCalculator变成一个可调用的类型。为了维护原始API的语义，我们将保留for外部参数标签，即使在声明callAsFunction执行情况-如下：

extension PriceCalculator {
    func callAsFunction(for product: Product) -> Int {
        calculatePrice(for: product)
    }
}

下面是上述方法与存储对类型的引用的比较calculatePrice方法-请注意第一段代码是如何丢弃参数标签的，而第二段代码是如何保留参数标签的：

// Using a method reference:
let calculatePrice = PriceCalculator().calculatePrice
...
calculatePrice(product)

// Calling our type directly:
let calculatePrice = PriceCalculator()
...
calculatePrice(for: product)

让类型像函数一样被调用是一个非常有趣的概念，但也许更有趣的是，它还使我们能够走相反的方向--并将函数转换为适当的类型。

面向对象的函数式编程
虽然在许多函数式编程概念中有着巨大的威力，但当使用大量面向对象的框架(就像大多数Apple的框架一样)时，应用这些概念和模式往往是很有挑战性的。让我们看看SWIFT5.2的新可调用类型功能是否可以帮助我们改变这种状况。
后续精彩内容请转到我的博客继续观看

转自：https://www.jianshu.com/p/c8f0f4ae63e5

软件介绍

一个能几乎实现所有 App 各种类型筛选菜单的控件，可悬浮。目前已实现 闲鱼 / 美团 / Boss直聘 / 京东 / 饿了么 / 淘宝 / 拼多多 / 赶集网 / 美图外卖 等等的筛选菜单，可以自由调用代理实现自己想组装的筛选功能和 UI，且控件的生命周期自动管理，悬浮自动管理。

• 组合自定义功能
• 支持自定义多选|单选|复选
• 支持自定义弹出的动画 (目前已实现向下,向左全屏,向右全屏,拼多多对话框弹出,boss直聘全屏弹出)
• 支持自定义tableView/collectionView头尾视图
• 支持自定义全局头尾视图
• 支持自定义collectionCell/tableViewCell视图
• 支持自定义标题
• 支持自定义点击回收视图
• 支持自定义回收列表
• 支持任意级的联动(由于数据比较庞杂,暂时自动适配不了无限级的联动,所以需要你调用一个方法更新数据传给我,详情看Demo)
• 支持嵌套使用,即两个筛选菜单可以连着使用
• 支持放在放在任意视图上,tableviewHeadView毫无疑问支持且无须写其他代码只要放上去即可
• 支持控制器消失自动关闭视图，无须再控制器消失方法里手动关闭
• 链式实现所有配置的自定义修改 (总之，你想要的基本都有,不想要的也有)

效果图

用法：

组装全在一些代理里,代理方法可能有点多~ ~,不过只有两个是必实现的,其他的都是可选的）

WMZDropMenuDelegate 
@required 一定实现的方法
*/
- (NSArray*)titleArrInMenu:(WMZDropDownMenu *)menu;
/*
*返回WMZDropIndexPath每行 每列的数据
*/
- (NSArray*)menu:(WMZDropDownMenu *)menu 
dataForRowAtDropIndexPath:(WMZDropIndexPath*)dropIndexPath;
@optional 可选实现的方法
/*
*返回setion行标题有多少列 默认1列
*/
- (NSInteger)menu:(WMZDropDownMenu *)menu numberOfRowsInSection: 
 (NSInteger)section;
 /*
 *自定义tableviewCell内容 默认WMZDropTableViewCell 如果要使用默认的 
  cell返回 nil
 */
 - (UITableViewCell*)menu:(WMZDropDownMenu *)menu 
 cellForUITableView:(WMZDropTableView*)tableView AtIndexPath: 
 (NSIndexPath*)indexpath dataForIndexPath:(WMZDropTree*)model;
 /*
 *自定义tableView headView
 */
 - (UITableViewHeaderFooterView*)menu:(WMZDropDownMenu *)menu 
 headViewForUITableView:(WMZDropTableView*)tableView 
 AtDropIndexPath:(WMZDropIndexPath*)dropIndexPath;
 /*
 *自定义tableView footView
 */
 - (UITableViewHeaderFooterView*)menu:(WMZDropDownMenu *)menu 
 footViewForUITableView:(WMZDropTableView*)tableView 
 AtDropIndexPath:(WMZDropIndexPath*)dropIndexPath;

 /*
 *自定义collectionViewCell内容
 */
 - (UICollectionViewCell*)menu:(WMZDropDownMenu *)menu 
 cellForUICollectionView:(WMZDropCollectionView*)collectionView
 AtDropIndexPath:(WMZDropIndexPath*)dropIndexPath AtIndexPath: 
(NSIndexPath*)indexpath dataForIndexPath:(WMZDropTree*)model;
 /*
*自定义collectionView headView
*/
- (UICollectionReusableView*)menu:(WMZDropDownMenu *)menu 
headViewForUICollectionView:(WMZDropCollectionView*)collectionView 
AtDropIndexPath:(WMZDropIndexPath*)dropIndexPath AtIndexPath: 
(NSIndexPath*)indexpath;

/*
*自定义collectionView footView
*/
- (UICollectionReusableView*)menu:(WMZDropDownMenu *)menu 
footViewForUICollectionView:(WMZDropCollectionView*)collectionView 
AtDropIndexPath:(WMZDropIndexPath*)dropIndexPath AtIndexPath: 
(NSIndexPath*)indexpath;

/*
*headView标题
*/
- (NSString*)menu:(WMZDropDownMenu *)menu 
titleForHeadViewAtDropIndexPath:(WMZDropIndexPath*)dropIndexPath;
/*
*footView标题
*/
- (NSString*)menu:(WMZDropDownMenu *)menu 
titleForFootViewAtDropIndexPath:(WMZDropIndexPath*)dropIndexPath;


/*
*返回WMZDropIndexPath每行 每列 indexpath的cell的高度 默认35
*/
- (CGFloat)menu:(WMZDropDownMenu *)menu heightAtDropIndexPath: 
 (WMZDropIndexPath*)dropIndexPath AtIndexPath: 
 (NSIndexPath*)indexpath;
 /*
*自定义headView高度 collectionView默认35
*/
- (CGFloat)menu:(WMZDropDownMenu *)menu 
heightForHeadViewAtDropIndexPath:(WMZDropIndexPath*)dropIndexPath;
/*
*自定义footView高度
*/
 - (CGFloat)menu:(WMZDropDownMenu *)menu 
heightForFootViewAtDropIndexPath:(WMZDropIndexPath*)dropIndexPath;

#pragma -mark 自定义用户交互的每行的头尾视图
/*
 *自定义每行全局头部视图 多用于交互事件
 */
 - (UIView*)menu:(WMZDropDownMenu *)menu 
userInteractionHeadViewInSection:(NSInteger)section;
 /*
 *自定义每行全局尾部视图 多用于交互事件
 */
 - (UIView*)menu:(WMZDropDownMenu *)menu 
 userInteractionFootViewInSection:(NSInteger)section;
#pragma -mark 样式动画相关代理
 /*
*返回WMZDropIndexPath每行 每列的UI样式  默认MenuUITableView
 注:设置了dropIndexPath.section 设置了 MenuUITableView 那么row则全部 
 为MenuUITableView 保持统一风格
 */
 - (MenuUIStyle)menu:(WMZDropDownMenu *)menu 
 uiStyleForRowIndexPath:(WMZDropIndexPath*)dropIndexPath;
  /*
  *返回section行标题数据视图出现的动画样式   默认 
  MenuShowAnimalBottom
  注:最后一个默认是筛选 弹出动画为 MenuShowAnimalRight
  */
  - (MenuShowAnimalStyle)menu:(WMZDropDownMenu *)menu 
  showAnimalStyleForRowInSection:(NSInteger)section;
  /*
  *返回section行标题数据视图消失的动画样式   默认 MenuHideAnimalTop
  注:最后一个默认是筛选 消失动画为 MenuHideAnimalLeft
   */
   - (MenuHideAnimalStyle)menu:(WMZDropDownMenu *)menu 
  hideAnimalStyleForRowInSection:(NSInteger)section;
  /*
  *返回WMZDropIndexPath每行 每列的编辑类型 单选|多选  默认单选
  */
  - (MenuEditStyle)menu:(WMZDropDownMenu *)menu 
  editStyleForRowAtDropIndexPath:(WMZDropIndexPath*)dropIndexPath;
  /*
  *返回WMZDropIndexPath每行 每列 显示的个数
   注:
   样式MenuUITableView         默认4个
   样式MenuUICollectionView    默认1个 传值无效
   */
   - (NSInteger)menu:(WMZDropDownMenu *)menu 
  countForRowAtDropIndexPath:(WMZDropIndexPath*)dropIndexPath;
  /*
  *WMZDropIndexPath是否显示收缩功能 default >参数 
   wCollectionViewSectionShowExpandCount 显示
    */
   - (BOOL)menu:(WMZDropDownMenu *)menu 
  showExpandAtDropIndexPath:(WMZDropIndexPath*)dropIndexPath;

  /*
  *WMZDropIndexPath上的内容点击 是否关闭视图 default YES
  */
  - (BOOL)menu:(WMZDropDownMenu *)menu 
  closeWithTapAtDropIndexPath:(WMZDropIndexPath*)dropIndexPath;

  /*
  *是否关联 其他标题 即选中其他标题 此标题会不会取消选中状态 default 
  YES 取消，互不关联
  */
  - (BOOL)menu:(WMZDropDownMenu *)menu 
 dropIndexPathConnectInSection:(NSInteger)section;

 #pragma -mark 交互自定义代理
 /*
 *cell点击方法
 */
  - (void)menu:(WMZDropDownMenu *)menu 
 didSelectRowAtDropIndexPath:(WMZDropIndexPath *)dropIndexPath
 dataIndexPath:(NSIndexPath*)indexpath data:(WMZDropTree*)data;
 /*
 *标题点击方法
 */
 - (void)menu:(WMZDropDownMenu *)menu didSelectTitleInSection: 
(NSInteger)section btn:(WMZDropMenuBtn*)selectBtn;
 /*
 *确定方法 多个选择
  selectNoramalData 转化后的的模型数据
 selectData 字符串数据
 */
 - (void)menu:(WMZDropDownMenu *)menu didConfirmAtSection: 
(NSInteger)section selectNoramelData:( 
NSMutableArray*)selectNoramalData selectStringData: 
(NSMutableArray*)selectData;


  /*
  *自定义标题按钮视图  返回配置 参数说明
  offset       按钮的间距
  y            按钮的y坐标   自动会居中
 */
 - (NSDictionary*)menu:(WMZDropDownMenu *)menu  
 customTitleInSection: 
 (NSInteger)section withTitleBtn:(WMZDropMenuBtn*)menuBtn;

 /*
*自定义修改默认collectionView尾部视图
*/
- (void)menu:(WMZDropDownMenu *)menu  
customDefauultCollectionFootView:(WMZDropConfirmView*)confirmView;

下载地址：https://gitee.com/mirrors/WMZDropDownMenu

1.安装

第一种方式 使用 cocoapods

pod 'YBImageBrowser'    

注意：请尽量使用最新版本（1.1.2）；若搜索不到库，可使用rm ~/Library/Caches/CocoaPods/search_index.json移除本地索引然后再执行安装，或者更新一下 cocoapods 版本。

第二种方式 手动导入

直接将该 Demo 的 YBImageBrowser 文件夹拖入你的工程中，并在你的 Podfile 里面添加：

pod 'SDWebImage', '~> 4.3.3'
pod 'FLAnimatedImage', '~> 1.0.12'

2.使用

我这里是采用代理数据源的方式，完整代码如下：

#import "ViewController.h"
#import "YBImageBrowser.h"
#import 
@interface ViewController (){
    NSArray *imageArray;
    NSMutableArray *imageViewArray;
    NSInteger currentIndex;
}
@end
@implementation ViewController
- (void)viewDidLoad {
    [super viewDidLoad];
    imageViewArray = [[NSMutableArray alloc]init];
    imageArray = @[
                     @"https://timgsa.baidu.com/timg?image&quality=80&size=b9999_10000&sec=1524118687954&di=d92e4024fe4c2e4379cce3d3771ae105&imgtype=0&src=http%3A%2F%2Fimg3.duitang.com%2Fuploads%2Fitem%2F201605%2F18%2F20160518181939_nCZWu.gif",
                     @"https://timgsa.baidu.com/timg?image&quality=80&size=b9999_10000&sec=1524118772581&di=29b994a8fcaaf72498454e6d207bc29a&imgtype=0&src=http%3A%2F%2Fimglf2.ph.126.net%2F_s_WfySuHWpGNA10-LrKEQ%3D%3D%2F1616792266326335483.gif",
                     @"https://timgsa.baidu.com/timg?image&quality=80&size=b9999_10000&sec=1524118803027&di=beab81af52d767ebf74b03610508eb36&imgtype=0&src=http%3A%2F%2Fe.hiphotos.baidu.com%2Fbaike%2Fpic%2Fitem%2F2e2eb9389b504fc2995aaaa1efdde71190ef6d08.jpg",
                     @"https://timgsa.baidu.com/timg?image&quality=80&size=b9999_10000&sec=1524118823131&di=aa588a997ac0599df4e87ae39ebc7406&imgtype=0&src=http%3A%2F%2Fimg3.duitang.com%2Fuploads%2Fitem%2F201605%2F08%2F20160508154653_AQavc.png",
                     @"https://ss0.bdstatic.com/70cFvHSh_Q1YnxGkpoWK1HF6hhy/it/u=722693321,3238602439&fm=27&gp=0.jpg",
                     @"https://timgsa.baidu.com/timg?image&quality=80&size=b9999_10000&sec=1524118892596&di=5e8f287b5c62ca0c813a548246faf148&imgtype=0&src=http%3A%2F%2Fwx1.sinaimg.cn%2Fcrop.0.0.1080.606.1000%2F8d7ad99bly1fcte4d1a8kj20u00u0gnb.jpg",
                     @"https://timgsa.baidu.com/timg?image&quality=80&size=b9999_10000&sec=1524118914981&di=7fa3504d8767ab709c4fb519ad67cf09&imgtype=0&src=http%3A%2F%2Fimg5.duitang.com%2Fuploads%2Fitem%2F201410%2F05%2F20141005221124_awAhx.jpeg",
                     @"https://timgsa.baidu.com/timg?image&quality=80&size=b9999_10000&sec=1524118934390&di=fbb86678336593d38c78878bc33d90c3&imgtype=0&src=http%3A%2F%2Fi2.hdslb.com%2Fbfs%2Farchive%2Fe90aa49ddb2fa345fa588cf098baf7b3d0e27553.jpg",
                     @"https://timgsa.baidu.com/timg?image&quality=80&size=b9999_10000&sec=1524118984884&di=7c73ddf9d321ef94a19567337628580b&imgtype=0&src=http%3A%2F%2Fimg5q.duitang.com%2Fuploads%2Fitem%2F201506%2F07%2F20150607185100_XQvYT.jpeg"
                     ];
    [self initUI];
    // Do any additional setup after loading the view, typically from a nib.
}
-(void)initUI{
    NSInteger rowCount = 3;
    CGFloat width = self.view.bounds.size.width;
    CGFloat imgW = width/rowCount;
    CGFloat imgH = imgW;
    CGFloat xPoint = 0;
    CGFloat yPoint = 100;
    NSInteger index = 0;
    for (NSString *imgUrl in imageArray) {
        UIButton *button = [[UIButton alloc] initWithFrame:CGRectMake(xPoint, yPoint, imgW, imgH)];
        button.userInteractionEnabled = YES;
        button.tag = index;
        //点击图片放大
        [button addTarget:self action:@selector(imgViewClick:) forControlEvents:UIControlEventTouchUpInside];
        UIImageView *img = [[UIImageView alloc] initWithFrame:CGRectMake(0, 0, imgW, imgH)];
        [button addSubview:img];
 
        [img sd_setImageWithURL:[NSURL URLWithString:imgUrl] placeholderImage:[UIImage imageNamed:@"no_img.png"]];
        [imageViewArray addObject:img];
        
        xPoint += imgW;
        if ((index+1)%rowCount==0) {
            yPoint += imgH;
            xPoint = 0;
        }
        [self.view addSubview:button];
        index++;
    }
}
-(void)imgViewClick:(UIButton *)btn{
    currentIndex = btn.tag;
    YBImageBrowser *browser = [YBImageBrowser new];
    browser.dataSource = self;
    browser.currentIndex = btn.tag;
    //展示
    [browser show];
}
//YBImageBrowserDataSource 代理实现赋值数据
- (NSInteger)numberInYBImageBrowser:(YBImageBrowser *)imageBrowser {
    return imageArray.count;
}
- (YBImageBrowserModel *)yBImageBrowser:(YBImageBrowser *)imageBrowser modelForCellAtIndex:(NSInteger)index {
    NSString *urlStr = [imageArray objectAtIndex:index];
    YBImageBrowserModel *model = [YBImageBrowserModel new];
    model.url = [NSURL URLWithString:urlStr];
    //model.sourceImageView = [imageViewArray objectAtIndex:index];
    return model;
}
- (UIImageView *)imageViewOfTouchForImageBrowser:(YBImageBrowser *)imageBrowser {
    return [imageViewArray objectAtIndex:currentIndex];
}
- (void)didReceiveMemoryWarning {
    [super didReceiveMemoryWarning];
    // Dispose of any resources that can be recreated.
}
@end

3.效果

git地址：https://github.com/indulgeIn/YBImageBrowser

目录
  1. 示例
  2. 详细说明

Podfile中导入
  pod 'JXPagingView/Pager'
  pod 'JXCategoryView'

1. 示例

VC

// 头部View高
#define JXTableHeaderViewHeight (kIs_iPhoneX?200+44:200)
// 菜单项View高
#define JXheightForHeaderInSection 40


#import <JXPagingView/JXPagerView.h>
#import <JXCategoryView/JXCategoryView.h>
<JXPagerViewDelegate, JXCategoryViewDelegate>

/**
 顶部View（自定义View）
 */
@property (nonatomic,strong) ZYTeamplayerHeadView *teamplayerHeadV;
/**
 菜单项View
 */
@property (nonatomic,strong) JXCategoryTitleView *categoryView;
/**
 内容View
 */
@property (nonatomic, strong) JXPagerView *pagingView;
/**
 内容View,建议这里使用控制器
 */
@property (nonatomic, strong) NSArray <ZYTeamplayerContentView *> *listViewArray;
/**
 菜单项标题数组
 */
@property (nonatomic,copy) NSArray *itemArr;

-(void)viewDidLoad{
    [super viewDidLoad];
    [self.view addSubview:self.pagingView];
}

#pragma mark - JXPagingViewDelegate
/**
 自定义头部视图
 */
- (UIView *)tableHeaderViewInPagerView:(JXPagerView *)pagerView {
    return self.teamplayerHeadV;
}
/**
 自定义头部视图高

 @param pagerView pagerView
 @return 头部视图高
 */
- (NSUInteger)tableHeaderViewHeightInPagerView:(JXPagerView *)pagerView {
    return JXTableHeaderViewHeight;
}
/**
 菜单项View
 
 @param pagerView pagerView
 @return 菜单项View
 */
- (UIView *)viewForPinSectionHeaderInPagerView:(JXPagerView *)pagerView {
    return self.categoryView;
}
/**
 菜单项View高

 @param pagerView pagerView
 @return 菜单项View高
 */
- (NSUInteger)heightForPinSectionHeaderInPagerView:(JXPagerView *)pagerView {
    return JXheightForHeaderInSection;
}
/**
 内容子视图数组

 @param pagerView pagerView
 @return 内容子视图数组
 */
- (NSArray<UIView<JXPagerViewListViewDelegate> *> *)listViewsInPagerView:(JXPagerView *)pagerView {
    return self.listViewArray;
}
/**
 上下滚动后调用
 */
- (void)mainTableViewDidScroll:(UIScrollView *)scrollView {
    //计算偏移量
    CGFloat P = scrollView.contentOffset.y/(JXTableHeaderViewHeight-kNavBarAndStatusBarHeight);
}

#pragma mark - JXCategoryViewDelegate
/**
 选中菜单项后调用

 @param categoryView 菜单项View
 @param index 下表
 */
- (void)categoryView:(JXCategoryBaseView *)categoryView didSelectedItemAtIndex:(NSInteger)index {
    self.navigationController.interactivePopGestureRecognizer.enabled = (index == 0);
}
/**
 滑动并切换内容视图后调用

 @param categoryView 菜单项View
 @param index 下表
 */
- (void)categoryView:(JXCategoryBaseView *)categoryView didScrollSelectedItemAtIndex:(NSInteger)index{
}


#pragma mark 懒加载
/**
总视图
 */
-(JXPagerView *)pagingView{
    if(!_pagingView){
        //
        _pagingView = [[JXPagerView alloc] initWithDelegate:self];
        _pagingView.frame = self.view.bounds;
    }
    return _pagingView;
}
/**
 自定义头部视图
 */
-(ZYTeamplayerHeadView *)teamplayerHeadV{
    if(!_teamplayerHeadV){
        _teamplayerHeadV=[ZYTeamplayerHeadView new];
        [_teamplayerHeadV setFrame:CGRectMake(0, 0, kScreenWidth, JXTableHeaderViewHeight)];
    }
    return _teamplayerHeadV;
}
/**
 菜单项视图View
 */
-(JXCategoryTitleView *)categoryView{
    if(!_categoryView){
        //
        _categoryView = [[JXCategoryTitleView alloc] initWithFrame:CGRectMake(0, 0, kScreenWidth, JXheightForHeaderInSection)];
        // dele
        _categoryView.delegate = self;
        // 设置菜单项标题数组
        _categoryView.titles = self.itemArr;
        // 背景色
        _categoryView.backgroundColor = [UIColor whiteColor];
        // 标题色、标题选中色、标题字体、标题选中字体
        _categoryView.titleColor = kTitleColor;
        _categoryView.titleSelectedColor = kTintClolor;
        _categoryView.titleFont=kFont(16);
        _categoryView.titleSelectedFont=kFontBold(16);
        // 标题色是否渐变过渡
        _categoryView.titleColorGradientEnabled = YES;

        // 下划线
        JXCategoryIndicatorLineView *lineView = [[JXCategoryIndicatorLineView alloc] init];
        // 下划线颜色
        lineView.indicatorLineViewColor = kTintClolor;
        // 下划线宽度
        lineView.indicatorLineWidth = 35;
        _categoryView.indicators = @[lineView];

        // 联动（categoryView和pagingView）
        _categoryView.contentScrollView = self.pagingView.listContainerView.collectionView;
        // 返回上一页侧滑手势（仅在index==0时有效）
        self.navigationController.interactivePopGestureRecognizer.enabled = (_categoryView.selectedIndex == 0);
    }
    
    return _categoryView;
}
/**
 内容视图数组
 */
-(NSArray<ZYTeamplayerContentView *> *)listViewArray{
    if(!_listViewArray){
        // 内容视图（通过PageType属性区分页面）
        CGRect rect=CGRectMake(0, 0, kScreenWidth, kScreenHeight-kNavBarAndStatusBarHeight-JXTableHeaderViewHeight-JXheightForHeaderInSection);
        ZYTeamplayerContentView *playerView = [[ZYTeamplayerContentView alloc] initWithFrame:rect];
        [playerView setPageType:ZYTeamplayerContentViewTypePlayer];
        ZYTeamplayerContentView *infoView = [[ZYTeamplayerContentView alloc] initWithFrame:rect];
        [infoView setPageType:ZYTeamplayerContentViewTypeTeam];
        _listViewArray = @[playerView, infoView];
    }
    return _listViewArray;
}
/**
 菜单项标题数组
 */
-(NSArray *)itemArr{
    if(!_itemArr){
        _itemArr=@[@"球员",@"信息"];
    }
    return _itemArr;
}

添加下拉刷新

    __weak typeof(self)weakSelf = self;
    self.pagingView.mainTableView.mj_header = [MJRefreshNormalHeader headerWithRefreshingBlock:^{
        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
            // 修改
//            [self.categoryView reloadData];
//            [self.pagingView reloadData];
            [weakSelf.pagingView.mainTableView.mj_header endRefreshing];
        });
    }];

自定义内容视图View

#import "JXPagerView.h"

typedef enum{
    ZYTeamplayerContentViewTypePlayer,  // 球员
    ZYTeamplayerContentViewTypeTeam,    // 信息
}ZYTeamplayerContentViewType;

<JXPagerViewListViewDelegate>
/**
 页面类型
 */
@property (nonatomic,assign) ZYTeamplayerContentViewType pageType;

@property (nonatomic, copy) void(^scrollCallback)(UIScrollView *scrollView);
// 必须加（用于联动）
- (void)scrollViewDidScroll:(UIScrollView *)scrollView {
    self.scrollCallback(scrollView);
}


#pragma mark - JXPagingViewListViewDelegate
- (UIView *)listView {
    return self;
}
/**
返回一个可滚动的视图
*/
- (UIScrollView *)listScrollView {
    return self.contentTableView; 
}
/**
用于联动
*/
- (void)listViewDidScrollCallback:(void (^)(UIScrollView *))callback {
    self.scrollCallback = callback;
}


-(void)layoutSubviews{
    [self.contentTableView setFrame:self.bounds];
}
-(UITableView *)contentTableView{
    if(!_contentTableView){
        _contentTableView=[[UITableView alloc]initWithFrame:CGRectZero style:UITableViewStyleGrouped];
        [_contentTableView setDelegate:self];
        [_contentTableView setDataSource:self];
        [_contentTableView setSeparatorStyle:UITableViewCellSeparatorStyleNone];
        [_contentTableView setBackgroundColor:[UIColor whiteColor]];
        [_contentTableView setContentInset:UIEdgeInsetsMake(0, 0, kNavBarAndStatusBarHeight, 0)];  // 
        [self addSubview:_contentTableView];
        [_contentTableView mas_makeConstraints:^(MASConstraintMaker *make) {
            make.left.right.top.bottom.mas_equalTo(0);
        }];
    }
    return _contentTableView;
}

2. 详细说明

菜单项

JXCategoryTitleView 文本菜单项

@interface JXCategoryTitleView : JXCategoryIndicatorView
/**
 菜单项标题数组
 */
@property (nonatomic, strong) NSArray <NSString *>*titles;

/**
 标题项标题行数    （默认：1）
 */
@property (nonatomic, assign) NSInteger titleNumberOfLines;
/**
 标题项标题颜色
 默认：[UIColor blackColor]
 */
@property (nonatomic, strong) UIColor *titleColor;
/**
 标题项标题字体
 默认：[UIFont systemFontOfSize:15]
 */
@property (nonatomic, strong) UIFont *titleFont;
/**
 标题项标题选中颜色
 默认：[UIColor redColor]
 */
@property (nonatomic, strong) UIColor *titleSelectedColor;
/**
 标题项标题选中字体
 默认：[UIFont systemFontOfSize:15]
 */
@property (nonatomic, strong) UIFont *titleSelectedFont;

/**
 默认：NO，title的颜色是否渐变过渡
 */
@property (nonatomic, assign) BOOL titleColorGradientEnabled;
/**
 默认：NO，titleLabel是否遮罩过滤。
 */
@property (nonatomic, assign) BOOL titleLabelMaskEnabled;

//---------------titleLabelZoomEnabled(忽略选中后字体)------------------//

/**
 默认为NO。
 为YES时titleSelectedFont失效，以titleFont为准。
 */
@property (nonatomic, assign) BOOL titleLabelZoomEnabled;
/**
 默认1.2。
 titleLabelZoomEnabled为YES才生效。
 是对字号的缩放，比如titleFont的pointSize为10，放大之后字号就是10*1.2=12。
 */
@property (nonatomic, assign) CGFloat titleLabelZoomScale;    //
/**
 手势滚动中，是否需要更新zoom状态。默认为YES
 */
@property (nonatomic, assign) BOOL titleLabelZoomScrollGradientEnabled;

//---------------titleLabelStrokeWidth(忽略选中后字体)--------------------//

/**
 是否使用Stroke，用于控制字体的粗细（底层通过NSStrokeWidthAttributeName实现）
 默认：NO
 */
@property (nonatomic, assign) BOOL titleLabelStrokeWidthEnabled;
/**
 默认：-3。
 使用该属性，务必让titleFont和titleSelectedFont设置为一样的！！！
 */
@property (nonatomic, assign) CGFloat titleLabelSelectedStrokeWidth;

//----------------------titleLabel缩放锚点中心位置-----------------------//

/**
 titleLabel锚点位置（用于调整titleLabel缩放时的基准位置）
 
 typedef NS_ENUM(NSUInteger, JXCategoryTitleLabelAnchorPointStyle) {
    JXCategoryTitleLabelAnchorPointStyleCenter, 默认
    JXCategoryTitleLabelAnchorPointStyleTop,
    JXCategoryTitleLabelAnchorPointStyleBottom,
 };
 */
@property (nonatomic, assign) JXCategoryTitleLabelAnchorPointStyle titleLabelAnchorPointStyle;
/**
 titleLabel锚点垂直方向的位置偏移，数值越大越偏离中心，默认为：0
 */
@property (nonatomic, assign) CGFloat titleLabelVerticalOffset;
@end

@interface JXCategoryImageView : JXCategoryIndicatorView

/**
 未选中图片源（本地）
 */
@property (nonatomic, strong) NSArray <NSString *>*imageNames;
/**
 未选中图片源（url）
 */
@property (nonatomic, strong) NSArray <NSURL *>*imageURLs;
/**
 选中图片源（本地）
 */
@property (nonatomic, strong) NSArray <NSString *>*selectedImageNames;
/**
 选中图片源（url）
 */
@property (nonatomic, strong) NSArray <NSURL *>*selectedImageURLs;
/**
 使用imageURL从远端下载图片进行加载，建议使用SDWebImage等第三方库进行下载。
 */
@property (nonatomic, copy) void(^loadImageCallback)(UIImageView *imageView, NSURL *imageURL);

/**
 图片大小
 默认CGSizeMake(20, 20)
 */
@property (nonatomic, assign) CGSize imageSize;
/**
 图片圆角
 */
@property (nonatomic, assign) CGFloat imageCornerRadius;
/**
 是否使用缩放效果
 默认为NO
 */
@property (nonatomic, assign) BOOL imageZoomEnabled;     
/**
 缩放比例
 默认1.2，
 imageZoomEnabled为YES才生效
 */
@property (nonatomic, assign) CGFloat imageZoomScale;
@end

@interface JXCategoryTitleImageView : JXCategoryTitleView
/**
 未选中图片源（本地）
 */
@property (nonatomic, strong) NSArray <NSString *>*imageNames;
/**
 选中图片源（本地）
 */
@property (nonatomic, strong) NSArray <NSString *>*selectedImageNames;
/**
 未选中图片源（url）
 通过loadImageCallback回调加载
 */
@property (nonatomic, strong) NSArray <NSURL *>*imageURLs;
/**
 选中图片源（url）
 通过loadImageCallback回调加载
 */
@property (nonatomic, strong) NSArray <NSURL *>*selectedImageURLs;
/**
 图片源为url时使用
 */
@property (nonatomic, copy) void(^loadImageCallback)(UIImageView *imageView, NSURL *imageURL);

/**
 默认@[JXCategoryTitleImageType_LeftImage...]
 */
@property (nonatomic, strong) NSArray <NSNumber *> *imageTypes;
/**
 图片大小
 默认CGSizeMake(20, 20)
 */
@property (nonatomic, assign) CGSize imageSize;
/**
 titleLabel和ImageView的间距，默认5
 */
@property (nonatomic, assign) CGFloat titleImageSpacing;
/**
 图片是否缩放。默认为NO
 */
@property (nonatomic, assign) BOOL imageZoomEnabled;
/**
 图片缩放的最大scale。默认1.2，
 imageZoomEnabled为YES才生效
 */
@property (nonatomic, assign) CGFloat imageZoomScale;
@end

@interface JXCategoryNumberView : JXCategoryTitleView
/**
 需要与titles的count对应
 */
@property (nonatomic, strong) NSArray <NSNumber *> *counts;
/**
 block内默认不会格式化数字，直接转成字符串显示。
 如果业务需要数字超过999显示999+，可以通过该block实现。
 */
@property (nonatomic, copy) NSString *(^numberStringFormatterBlock)(NSInteger number);

/**
 numberLabel的font
 默认：[UIFont systemFontOfSize:11]
 */
@property (nonatomic, strong) UIFont *numberLabelFont;
/**
 数字的背景色
 默认：[UIColor colorWithRed:241/255.0 green:147/255.0 blue:95/255.0 alpha:1]
 */
@property (nonatomic, strong) UIColor *numberBackgroundColor;
/**
 数字的title颜色
 默认：[UIColor whiteColor]
 */
@property (nonatomic, strong) UIColor *numberTitleColor;
/**
 numberLabel的宽度补偿，默认：10
 总宽度=文字内容的宽度+补偿的宽度
 */
@property (nonatomic, assign) CGFloat numberLabelWidthIncrement;
/**
 numberLabel的高度
 默认：14
 */
@property (nonatomic, assign) CGFloat numberLabelHeight;
@end

@interface JXCategoryDotView : JXCategoryTitleView
/**
 相对于titleLabel的位置，
 默认：JXCategoryDotRelativePosition_TopRight
 */
@property (nonatomic, assign) JXCategoryDotRelativePosition relativePosition;

/**
 @[@(布尔值)]数组，控制红点是否显示
 */
@property (nonatomic, strong) NSArray <NSNumber *> *dotStates;
/**
 红点的尺寸。
 默认：CGSizeMake(10, 10)
 */
@property (nonatomic, assign) CGSize dotSize;
/**
 红点的圆角值。
 默认：JXCategoryViewAutomaticDimension（self.dotSize.height/2）
 */
@property (nonatomic, assign) CGFloat dotCornerRadius;
/**
 红点的颜色。
 默认：[UIColor redColor]
 */
@property (nonatomic, strong) UIColor *dotColor;
@end

@interface JXCategoryIndicatorView : JXCategoryBaseView
/**
下划线
 */
@property (nonatomic, strong) NSArray <UIView<JXCategoryIndicatorProtocol> *> *indicators;

//----------------------菜单项背景色-----------------------//
/**
 是否开启背景色
 默认：NO
 */
@property (nonatomic, assign) BOOL cellBackgroundColorGradientEnabled;
/**
 未选中背景色
 默认：[UIColor clearColor]
 前提：cellBackgroundColorGradientEnabled为true
 */
@property (nonatomic, strong) UIColor *cellBackgroundUnselectedColor;
/**
 选中背景色
 默认：[UIColor grayColor]
 前提：cellBackgroundColorGradientEnabled为true
 */
@property (nonatomic, strong) UIColor *cellBackgroundSelectedColor;

//----------------------separatorLine-----------------------//
/**
 是否显示分割线。默认为NO
 */
@property (nonatomic, assign) BOOL separatorLineShowEnabled;
/**
 分割线颜色。默认为[UIColor lightGrayColor]
 前提；separatorLineShowEnabled为true
 */
@property (nonatomic, strong) UIColor *separatorLineColor;
/**
 分割线的size
 默认为CGSizeMake(1/[UIScreen mainScreen].scale, 20)
 前提；separatorLineShowEnabled为true
 */
@property (nonatomic, assign) CGSize separatorLineSize;

/**
 当contentScrollView滚动时候，处理跟随手势的过渡效果。
 根据cellModel的左右位置、是否选中、ratio进行过滤数据计算。
 
 @param leftCellModel 左边的cellModel
 @param rightCellModel 右边的cellModel
 @param ratio 从左往右方向计算的百分比
 */
- (void)refreshLeftCellModel:(JXCategoryBaseCellModel *)leftCellModel rightCellModel:(JXCategoryBaseCellModel *)rightCellModel ratio:(CGFloat)ratio NS_REQUIRES_SUPER;
@end

@interface JXCategoryBaseView : UIView
/**
 菜单项视图
 */
@property (nonatomic, strong, readonly) JXCategoryCollectionView *collectionView;
/**
 需要关联的内容视图
 */
@property (nonatomic, strong) UIScrollView *contentScrollView;

@property (nonatomic, strong) NSArray <JXCategoryBaseCellModel *> *dataSource;
/**
 dele<JXCategoryViewDelegate>
 */
@property (nonatomic, weak) id<JXCategoryViewDelegate> delegate;
/**
 初始化选中index
 */
@property (nonatomic, assign) NSInteger defaultSelectedIndex;   //
/**
 当前选中index（只读）
 */
@property (nonatomic, assign, readonly) NSInteger selectedIndex;
/**
 默认为YES，
 只有当delegate未实现`- (void)categoryView:(JXCategoryBaseView *)categoryView didClickedItemContentScrollViewTransitionToIndex:(NSInteger)index`代理方法时才有效
 */
@property (nonatomic, assign) BOOL contentScrollViewClickTransitionAnimationEnabled;

/**
 整体左边距
 默认JXCategoryViewAutomaticDimension（等于cellSpacing）
 */
@property (nonatomic, assign) CGFloat contentEdgeInsetLeft;
/**
 整体右边距
 默认JXCategoryViewAutomaticDimension（等于cellSpacing）
 */
@property (nonatomic, assign) CGFloat contentEdgeInsetRight;
/**
 菜单项之间的间距
 默认20
 */
@property (nonatomic, assign) CGFloat cellSpacing;
/**
 当collectionView.contentSize.width小于JXCategoryBaseView的宽度，是否将cellSpacing均分。
 默认为YES。
 */
@property (nonatomic, assign) BOOL averageCellSpacingEnabled;
/**
 菜单项宽度
 默认：JXCategoryViewAutomaticDimension
 */
@property (nonatomic, assign) CGFloat cellWidth;
/**
 菜单项宽度补偿（总宽度=宽度+k补偿宽度）
 默认：0
 */
@property (nonatomic, assign) CGFloat cellWidthIncrement;


//----------------cellWidthZoomEnabled（菜单项缩放）---------------//
/**
 菜单项的宽度是否缩放
 默认为NO
 */
@property (nonatomic, assign) BOOL cellWidthZoomEnabled;
/**
 默认1.2，
 cellWidthZoomEnabled为YES才生效
 */
@property (nonatomic, assign) CGFloat cellWidthZoomScale;
/**
 手势滚动过程中，是否需要更新菜单项的宽度。
 默认为YES
 */
@property (nonatomic, assign) BOOL cellWidthZoomScrollGradientEnabled;
/**
 是否开启选中动画。
 默认为NO。
 自定义的菜单项选中动画需要自己实现。
 */
@property (nonatomic, assign) BOOL selectedAnimationEnabled;
/**
 菜单项选中动画的时间。
 默认0.25
 */
@property (nonatomic, assign) NSTimeInterval selectedAnimationDuration;

/**
 选中目标index的item
 
 @param index 目标index
 */
- (void)selectItemAtIndex:(NSInteger)index;
/**
 初始化的时候无需调用。
 重新配置categoryView，需要调用该方法进行刷新。
 */
- (void)reloadData;
/**
 刷新指定的index的菜单项
 内部会触发`- (void)refreshCellModel:(JXCategoryBaseCellModel *)cellModel index:(NSInteger)index`方法进行cellModel刷新
 
 @param index 指定cell的index
 */
- (void)reloadCellAtIndex:(NSInteger)index;


#pragma mark - Subclass use
- (CGRect)getTargetCellFrame:(NSInteger)targetIndex;
#pragma mark - Subclass Override
- (void)initializeData NS_REQUIRES_SUPER;
- (void)initializeViews NS_REQUIRES_SUPER;

/**
 reloadData方法调用，重新生成数据源赋值到self.dataSource
 */
- (void)refreshDataSource;
/**
 reloadData方法调用，根据数据源重新刷新状态；
 */
- (void)refreshState NS_REQUIRES_SUPER;
/**
 reloadData时，返回每个菜单项的宽度
 
 @param index 目标index
 @return cellWidth
 */
- (CGFloat)preferredCellWidthAtIndex:(NSInteger)index;
/**
 refreshState时调用，重置cellModel的状态
 
 @param cellModel 待重置的cellModel
 @param index cellModel在数组中的index
 */
- (void)refreshCellModel:(JXCategoryBaseCellModel *)cellModel index:(NSInteger)index;
/**
 选中某个item时，刷新将要选中与取消选中的cellModel
 
 @param selectedCellModel 将要选中的cellModel
 @param unselectedCellModel 取消选中的cellModel
 */
- (void)refreshSelectedCellModel:(JXCategoryBaseCellModel *)selectedCellModel unselectedCellModel:(JXCategoryBaseCellModel *)unselectedCellModel NS_REQUIRES_SUPER;
/**
 关联的contentScrollView的contentOffset发生了改变时调用
 
 @param contentOffset 偏移量
 */
- (void)contentOffsetOfContentScrollViewDidChanged:(CGPoint)contentOffset NS_REQUIRES_SUPER;
/**
 选中某一个item的时候调用，该方法用于子类重载。
 如果外部要选中某个index，请使用`- (void)selectItemAtIndex:(NSUInteger)index;`
 
 @param index 选中的index
 @param selectedType JXCategoryCellSelectedType
 @return 返回值为NO，表示触发内部某些判断（点击了同一个cell），子类无需后续操作。
 */
- (BOOL)selectCellAtIndex:(NSInteger)index selectedType:(JXCategoryCellSelectedType)selectedType NS_REQUIRES_SUPER;


/**
 返回自定义菜单项的class
 
 @return cell class
 */
- (Class)preferredCellClass;
@end

@protocol JXCategoryViewDelegate <NSObject>
@optional
/**
 点击选中或者滚动选中都会调用该方法。
 适用于只关心选中事件，不关心具体是点击还是滚动选中的。
 
 @param categoryView categoryView description
 @param index 选中的index
 */
- (void)categoryView:(JXCategoryBaseView *)categoryView didSelectedItemAtIndex:(NSInteger)index;
/**
 点击选中的情况才会调用该方法
 
 @param categoryView categoryView description
 @param index 选中的index
 */
- (void)categoryView:(JXCategoryBaseView *)categoryView didClickSelectedItemAtIndex:(NSInteger)index;
/**
 滚动选中的情况才会调用该方法
 
 @param categoryView categoryView description
 @param index 选中的index
 */
- (void)categoryView:(JXCategoryBaseView *)categoryView didScrollSelectedItemAtIndex:(NSInteger)index;
/**
 正在滚动中的回调
 
 @param categoryView categoryView description
 @param leftIndex 正在滚动中，相对位置处于左边的index
 @param rightIndex 正在滚动中，相对位置处于右边的index
 @param ratio 从左往右计算的百分比
 */
- (void)categoryView:(JXCategoryBaseView *)categoryView scrollingFromLeftIndex:(NSInteger)leftIndex toRightIndex:(NSInteger)rightIndex ratio:(CGFloat)ratio;
@end

@interface JXCategoryIndicatorLineView : JXCategoryIndicatorComponentView
/**
 lineStyle

    JXCategoryIndicatorLineStyle_Normal             = 0,默认
    JXCategoryIndicatorLineStyle_Lengthen           = 1,
    JXCategoryIndicatorLineStyle_LengthenOffset     = 2,
 */
@property (nonatomic, assign) JXCategoryIndicatorLineStyle lineStyle;
/**
 line滚动时x的偏移量，默认为10；
 lineStyle为JXCategoryIndicatorLineStyle_LengthenOffset有用；
 */
@property (nonatomic, assign) CGFloat lineScrollOffsetX;
/**
 lineView的高度。
 默认：3
 */
@property (nonatomic, assign) CGFloat indicatorLineViewHeight;
/**
 lineView的宽度。
 默认JXCategoryViewAutomaticDimension（与cellWidth相等）
 */
@property (nonatomic, assign) CGFloat indicatorLineWidth;
/**
 lineView的圆角值。
 默认JXCategoryViewAutomaticDimension （等于self.indicatorLineViewHeight/2）
 */
@property (nonatomic, assign) CGFloat indicatorLineViewCornerRadius;
/**
 lineView的颜色。
 默认为[UIColor redColor]
 */
@property (nonatomic, strong) UIColor *indicatorLineViewColor;
@end

@interface JXCategoryIndicatorTriangleView : JXCategoryIndicatorComponentView
/**
 三角形的尺寸。
 默认：CGSizeMake(14, 10)
 */
@property (nonatomic, assign) CGSize triangleViewSize;
/**
 三角形的颜色值。
 默认：[UIColor redColor]
 */
@property (nonatomic, strong) UIColor *triangleViewColor;
@end

TZImagePickerControllerDemo

项目介绍

TZImagePickerControllerDemo

Podfile新增行 pod 'TZImagePickerController'

使用之前导入头文件 #import <TZImagePickerController.h>

使用说明

1. 定义 类变量：
  UIImagePickerController* picker_library_;
2.实现 UIImagePickerControllerDelegate 这个delegate，还需要UINavigationControllerDelegate 这个代理
3. 以模态的方式，显示 图片选取器

picker_library_ = [[UIImagePickerController alloc] init];  
        picker_library_.sourceType = UIImagePickerControllerSourceTypePhotoLibrary;  
        picker_library_.allowsEditing = YES;  
        picker_camera_.allowsImageEditing=YES;  
        picker_library_.delegate = self;  
        [self presentModalViewController: picker_library_  
                                animated: YES];

其中，sourceType 指定了 几种 图片的来源：
UIImagePickerControllerSourceTypePhotoLibrary：表示显示所有的照片
UIImagePickerControllerSourceTypeCamera：表示从摄像头选取照片
UIImagePickerControllerSourceTypeSavedPhotosAlbum：表示仅仅从相册中选取照片。
allowEditing和allowsImageEditing 设置为YES，表示 允许用户编辑图片，否则，不允许用户编辑。

选照片

//MaxImagesCount  可以选着的最大条目数
    TZImagePickerController *imagePicker = [[TZImagePickerController alloc] initWithMaxImagesCount:1 delegate:self];
    
    // 是否显示可选原图按钮
    imagePicker.allowPickingOriginalPhoto = NO;
    // 是否允许显示视频
    imagePicker.allowPickingVideo = NO;
    // 是否允许显示图片
    imagePicker.allowPickingImage = YES;
    
    // 这是一个navigation 只能present
    [self presentViewController:imagePicker animated:YES completion:nil];

选择照片的回调

// 选择照片的回调
-(void)imagePickerController:(TZImagePickerController *)picker
      didFinishPickingPhotos:(NSArray<UIImage *> *)photos
                sourceAssets:(NSArray *)assets
       isSelectOriginalPhoto:(BOOL)isSelectOriginalPhoto{
    
}

选视频

//MaxImagesCount  可以选着的最大条目数
    TZImagePickerController *imagePicker = [[TZImagePickerController alloc] initWithMaxImagesCount:2 delegate:self];
    
    // 是否显示可选原图按钮
    imagePicker.allowPickingOriginalPhoto = NO;
    // 是否允许显示视频
    imagePicker.allowPickingVideo = YES;
    // 是否允许显示图片
    imagePicker.allowPickingImage = NO;
    
    // 这是一个navigation 只能present
    [self presentViewController:imagePicker animated:YES completion:nil];

选择视频的回调

// 选择视频的回调
-(void)imagePickerController:(TZImagePickerController *)picker
       didFinishPickingVideo:(UIImage *)coverImage
                sourceAssets:(PHAsset *)asset{
    
}

看开发文档中，涉及到六种基础的提示框

typedef NS_ENUM(NSInteger, MBProgressHUDMode) {
	/**使用UIActivityIndicatorView显示进度。这是菊花默认值。 */
	MBProgressHUDModeIndeterminate,
	/** 使用圆形的饼图来显示进度。 */
	MBProgressHUDModeDeterminate,
	/** 使用水平进度条显示进度 */
	MBProgressHUDModeDeterminateHorizontalBar,
	/** 使用圆环进度视图显示进度。*/
	MBProgressHUDModeAnnularDeterminate,
	/** 自定义的view*/
	MBProgressHUDModeCustomView,
	/** 仅显示标签 */
	MBProgressHUDModeText
};

使用函数

+ (void)showToast:(NSString *)title withView:(UIView *)view {
    MBProgressHUD *hud = [MBProgressHUD showHUDAddedTo:view animated:YES];
    hud.mode = MBProgressHUDModeIndeterminate;
    hud.labelText = title;
    [hud hide:YES afterDelay:1];
}

运行例子：

//1,设置背景框的透明度  默认0.8
  	hud.opacity = 1;

    //2,设置背景框的背景颜色和透明度， 设置背景颜色之后opacity属性的设置将会失效
    hud.color = [UIColor redColor];
    hud.color = [HUD.color colorWithAlphaComponent:1];

    //3,设置背景框的圆角值，默认是10
    hud.cornerRadius = 20.0;

    //4,设置提示信息 信息颜色，字体
    hud.labelColor = [UIColor blueColor];
    hud.labelFont = [UIFont systemFontOfSize:13];
    hud.labelText = @"Loading...";

    //5,设置提示信息详情 详情颜色，字体
    hud.detailsLabelColor = [UIColor blueColor];
    hud.detailsLabelFont = [UIFont systemFontOfSize:13];
    hud.detailsLabelText = @"LoadingLoading...";

    //6，设置菊花颜色  只能设置菊花的颜色
    hud.activityIndicatorColor = [UIColor blackColor];

    //7,设置一个渐变层
    hud.dimBackground = YES;

    //9，设置提示框的相对于父视图中心点的便宜，正值 向右下偏移，负值左上
    hud.xOffset = -80;
    hud.yOffset = -100;

    //10，设置各个元素距离矩形边框的距离
    hud.margin = 0;

    //11，背景框的最小大小
    hud.minSize = CGSizeMake(50, 50);

    //12设置背景框的实际大小   readonly
    CGSize size = HUD.size;

    //13,是否强制背景框宽高相等
    hud.square = YES;

一. WKWebView处理window.open问题

• WKWebView加载页面, 当页面使用window.open跳转时候, 无响应, 需要实现WKUIDelegate协议实现

-(WKWebView *)webView:(WKWebView *)webView createWebViewWithConfiguration:(WKWebViewConfiguration *)configuration forNavigationAction:(WKNavigationAction *)navigationAction windowFeatures:(WKWindowFeatures *)windowFeatures{

    WKFrameInfo *frameInfo = navigationAction.targetFrame;
    if (![frameInfo isMainFrame]) {
         //1. 本页跳转
        [webView loadRequest:navigationAction.request];

        //2. 获取url 打开新的 vc 实现跳转到新页面
        //NSString *urlStr = [[navigationAction.request URL] absoluteString];
    }
    return nil;
}

注意 :
1- 使用 window.open 在移动端可能引发兼容问题, 建议前端对移动端标签使用location.href处理
2- ajax 处理window.open时候, 同步时可以响应跳转, 异步时不会响应跳转

$.ajax({
      url: '',
      async: true,
      complete: function (xhr) {          
          window.open("http://www.baidu.com");
      }                   
});

二. WKWebView处理a标签问题

方案1: 不建议使用

- (void)webView:(WKWebView *)webView didFinishNavigation:(null_unspecified WKNavigation *)navigation{
    // 将a标签 跳转方式全部改为本页
    [webView evaluateJavaScript:@"var aArr = document.getElementsByTagName('a');for(var i=0;i}

方案2: WKNavigationDelegate协议实现

-(void)webView:(WKWebView *)webView decidePolicyForNavigationAction:(WKNavigationAction *)navigationAction decisionHandler:(void (^)(WKNavigationActionPolicy))decisionHandler{
    // webview 本页重新加载
    if (navigationAction.targetFrame == nil) {
        [webView loadRequest:navigationAction.request];
    }
    decisionHandler(WKNavigationActionPolicyAllow);
    return;

}

方案3: WKUIDelegate协议实现

-(WKWebView *)webView:(WKWebView *)webView createWebViewWithConfiguration:(WKWebViewConfiguration *)configuration forNavigationAction:(WKNavigationAction *)navigationAction windowFeatures:(WKWindowFeatures *)windowFeatures{

    WKFrameInfo *frameInfo = navigationAction.targetFrame;
    if (![frameInfo isMainFrame]) {

     // 可创建新页面打开 [WebView new]
     // 也可重新加载本页面 [webView loadRequest:navigationAction.request];
     
    }
    return nil;

}

注意 : 如果方案2与方案3 代码中均实现, 程序会先执行方案2

三. WKWebView处理alert 问题

• WKWebView加载页面, 当页面使用alert()、confirm()和prompt(),默认无响应. 若要正常使用这三个方法，需要实现WKUIDelegate中的三个方法模拟JS的这三个方法

JS 处理实现方法
function showAlert() {
     alert("js_alertMessage");
}

function showConfirm() {
     confirm("js_confirmMessage");
}

function showPrompt() {
     prompt("js_prompt", "js_prompt_defaultMessage");
}

 App 处理
//! alert(message)
- (void)webView:(WKWebView *)webView runJavaScriptAlertPanelWithMessage:(NSString *)message initiatedByFrame:(WKFrameInfo *)frame completionHandler:(void (^)(void))completionHandler {
     completionHandler();
}

//! confirm(message)
- (void)webView:(WKWebView *)webView runJavaScriptConfirmPanelWithMessage:(NSString *)message initiatedByFrame:(WKFrameInfo *)frame completionHandler:(void (^)(BOOL))completionHandler {
     completionHandler();
}

//! prompt(prompt, defaultText)
- (void)webView:(WKWebView *)webView runJavaScriptTextInputPanelWithPrompt:(NSString *)prompt defaultText:(NSString *)defaultText initiatedByFrame:(WKFrameInfo *)frame completionHandler:(void (^)(NSString *))completionHandler {
      completionHandler();
}

注意: completionHandler();需要被执行, 不然会引发crash.

四. WKWebView与JS简单交互

• -WKWebView加载页面, 当需要给js简单交互, 可如下处理

// JS 处理
document.getElementById("btn").onclick =  function () {
                
    var url = "APP://action?params";
    window.location.href = url;
}

// App 处理
-(void)webView:(WKWebView *)webView decidePolicyForNavigationAction:(WKNavigationAction *)navigationAction decisionHandler:(void (^)(WKNavigationActionPolicy))decisionHandler{

    if ([navigationAction.request.URL.scheme caseInsensitiveCompare:@"APP"] == NSOrderedSame) {
        // 进行业务处理
        decisionHandler(WKNavigationActionPolicyCancel);
    }else{
         if (navigationAction.targetFrame == nil) {
             [webView loadRequest:navigationAction.request];
         }
         decisionHandler(WKNavigationActionPolicyAllow);
    }
    return;
}

// App 处理
NSString *func = [NSString stringWithFormat:@"loadData('%@', '%@')", @"aaa", @"bbb"];
[webView evaluateJavaScript:func completionHandler:nil];

// JS 处理
function loadData(action, params){
                
    document.getElementById("returnValue").innerHTML = action + '?' + params;
}

注意:
1 webView调用 evaluateJavaScript:completionHandler:方法, 要确保前端的JS方法不在闭包中, 如window.onload = function() {} 中的方法就无法调用.
2 如果交互复杂 可以使用 WebViewJavascriptBridge 实现

五. WKWebView相关文档

WKWebView 那些坑

让 WKWebView 支持 NSURLProtocol

转自：https://www.jianshu.com/p/b9a88a537d87

1. OC 的消息机制

消息机制可以分为三个部分

1. 消息传递

• 当我么调用方法的时候，方法的调用都会转化为objc_msgSend这样来传递。

• 第一步会根据对象的isa指针找到所属的类(也就是类对象)

• 第二步，会根据类对象里面的catch里面查找。catch是个散列表，是根据@selector(方法名)来获取对应的IMP，从而开始调用

• 第三步，如果第二步没有找到，会继续查找到类对象里面的class_rw_t里面的methods(方法列表)，从而遍历，找到方法所属的IMP，如果查找到则会添加到catch表里面

• 第四步，如果第三部也没有找到，会根据类对象里面的superclass指针，查找super的catch,如果也是没有查找，会继续查找到superclass里面的class_rw_t里面的methods(方法列表)，从而遍历，找到方法所属的IMP，如果查找到则会添加到catch表里面

• 第五步，如果第四部还是没有查找到，此时会根据类的superclass,继续第四部操作

.......

• 第六步。如果一直查找到基类都没有找到响应的方法，则会进入动态解析里面

2. 动态解析

• 当消息传递，没有找到对应的IMP的时候，会进入的动态解析中

• 此时会根据方法是类方法，还是实例方法分别调用+(BOOL)resolveClassMethod:(SEL)sel、+(BOOL)resolveInstanceMethod:(SEL)sel

• 我们可以实现这两个方法，使用Runtime的class_addMethod来添加对应的IMP

• 如果添加后，返回true,没有添加则调用父类方法

• 注意：其实返回true或者false,结果都是一样的，再次掉消息传递步骤
  

3. 消息转发

• 如果我们没有实现动态解析方法，就会走到消息转发这里

• 第一步，会调用-(id)forwardingTargetForSelector:(SEL)aSelector方法，我们可以在这里，返回一个响应aSelector的对象。当返回不为nil时候，系统会继续再次走消息转发，继续查找对应的IMP

• 第二步，如果第一步返回nil或者self(自己),此时系统会继续走这里-(NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector,需要返回aSelector的一个签名

• 第三步，如果返回了签名，就会到这里-(void)forwardInvocation:(NSInvocation *)anInvocation,相应的我们可以根据anInvocation,可以获取到参数、target、方法名等，再次操作的空间就很多了，看你需求喽。此时我们什么都不操作也是没问题的，

• 注意：当我们是类方法的时候，其实我们可以将以上方法的-改为+，即可实现了类方法的转发

2.weak表是如何存储__weak指针的

• weak关键字，我们都知道，当对象销毁的时候，也会将指针赋值为nil，而weak的底层也是将指针和对象以键值对的形式存储在哈希表里面

• 当使用__weak修饰的时候，底层会调用id objc_storeWeak(id *location, id newObj)传递两个参数

        第一个参数为指针,第二个参数为所指向的对象

• 第二步，继续调用storeWeak(location, (objc_object *)newObj)

     1. 第一个参数是指针，第二个参数是对象的地址

     2. 再次方法里面会根据对象地址生成一个SideTables对象

• 第三步，调用id weak_register_no_lock(weak_table_t *weak_table, id referent_id, id *referrer_id, bool crashIfDeallocating)

     1. weak_table则为SideTables的一个属性，referent_id为对象，referrer_id则为那个弱引用的指针

     2. 在此里面会根据对象地址和指针生成一个weak_entry_t

• 第四步，会继续调用static void weak_entry_insert(weak_table_t *weak_table, weak_entry_t *new_entry)

     重点：在此方法里面会根据对象 & weak_table->mask(表示weak表里面可以存储的大小减一，例如：表可以存储10个对象，那么mask就是9), 生成对应的index，如果index对应已经存储上对象，则会index++的方式找到未存储的对应，并将new_entry存储进去，储存在weak_table里的weak_entries属                    性里面

• 注意：当一个对象多个weak指针指向的时候，生成的也是一个entry，多个指针时保存在entry里面referrers属性里面

• 以下为简易的源码：

id
objc_storeWeak(id *location, id newObj)
{
    return storeWeak
        (location, (objc_object *)newObj);
}
static id 
storeWeak(id *location, objc_object *newObj) {
  // 根据对象生成新的SideTable
  SideTable *newTable = &SideTables()[newObj];
  newObj = (objc_object *)
  weak_register_no_lock(&newTable->weak_table, (id)newObj, location,  crashIfDeallocating);
}
id 
weak_register_no_lock(weak_table_t *weak_table, id referent_id, 
                      id *referrer_id, bool crashIfDeallocating){
  objc_object *referent = (objc_object *)referent_id;
  objc_object **referrer = (objc_object **)referrer_id;
  
  // 根据对象和指针生成一个entry
  weak_entry_t new_entry(referent, referrer);
  // 检查是是否该去扩容
  weak_grow_maybe(weak_table);
  // 将新的entry 插入到表里面
  weak_entry_insert(weak_table, &new_entry);
}
static void weak_entry_insert(weak_table_t *weak_table, weak_entry_t *new_entry)
{
    weak_entry_t *weak_entries = weak_table->weak_entries;

    size_t begin = hash_pointer(new_entry->referent) & (weak_table->mask);
    size_t index = begin;
    size_t hash_displacement = 0;
    while (weak_entries[index].referent != nil) {
        index = (index+1) & weak_table->mask;
        if (index == begin) bad_weak_table(weak_entries);
        hash_displacement++;
    }
    weak_entries[index] = *new_entry;
    weak_table->num_entries++;
}

weak_table的扩容，根据存储条数 >= 最大存储条数的3/4时，就会按照两倍的方式进行扩容，并且会将已经有的条目再次生成新的index(因为扩容后，weak_table的mask发生了改变)。进行保存

• 以下为简易的源码：

static void weak_grow_maybe(weak_table_t *weak_table)
{
    size_t old_size = (weak_table->mask ? weak_table->mask + 1 : 0);
    if (weak_table->num_entries >= old_size * 3 / 4) {
        weak_resize(weak_table, old_size ? old_size*2 : 64);
    }
}
static void weak_resize(weak_table_t *weak_table, size_t new_size)
{
    size_t old_size = TABLE_SIZE(weak_table);
    weak_entry_t *old_entries = weak_table->weak_entries;
    // calloc 分配新的控件
    weak_entry_t *new_entries = (weak_entry_t *)
        calloc(new_size, sizeof(weak_entry_t));
    // mask 就是大小减一
    weak_table->mask = new_size - 1;
    weak_entry_t *entry;
    weak_entry_t *end = old_entries + old_size;
    for (entry = old_entries; entry < end; entry++) {
        if (entry->referent) {
           weak_entry_insert(weak_table, entry);
        }
    }
}

3. 方法catch表是如何存储方法的

• 我们都是知道调用方法的时候，会根据对象的isa查找到对象类对象，并开始在catch表里面查询对应的IMP

• 其实catch是个散列表,是根据方法的@selector(方法名) & catch->mask(catck表最大数量 - 1)得到index，如果index已经存储了新的方法，那么就会index++，如果index对应的值为nil时，将响应的方法，插入到catch表里面

• 核心代码

static void cache_fill_nolock(Class cls, SEL sel, IMP imp, id receiver) {
  // 获取类对象的catch地址
  cache_t *cache = &cls->cache
  // 获取key
  cache_key_t key = (cache_key_t)sel;
  // 找到bucket
  bucket_t *bucket = cache->find(key, receiver);
}

bucket_t * cache_t::find(cache_key_t k, id receiver)
{
    // catch表的buckets属性
    bucket_t *b = buckets();
    // catch 表示的mask 最大值 - 1
    mask_t m = mask();
    
    mask_t begin = cache_hash(k, m);
    mask_t i = begin;
    do {
        if (b[i].key() == 0  ||  b[i].key() == k) {
            return &b[i];
        }
    } while ((i = cache_next(i, m)) != begin);
}
static inline mask_t cache_next(mask_t i, mask_t mask) {
    return (i+1) & mask;
}

注意：catch表的扩容，同样也是和weak_table一样按照2倍的方式进行扩容，但是注意：扩容后，以前缓存的方法则会被删除掉。

简易代码

void cache_t::expand() {
    uint32_t oldCapacity = capacity();
    uint32_t newCapacity = oldCapacity ? oldCapacity*2 : INIT_CACHE_SIZE;
    reallocate(oldCapacity, newCapacity);
}

void cache_t::reallocate(mask_t oldCapacity, mask_t newCapacity)
{
    // 获取旧的oldBuckets
    bucket_t *oldBuckets = buckets();
    // 重新分配新的
    bucket_t *newBuckets = allocateBuckets(newCapacity);
    // free 掉旧的
    cache_collect_free(oldBuckets, oldCapacity);
}

4. 优化后isa指针是什么样的？存储都有哪些内容？

• 最新的Objective-C的对象里面的isa指针已经不是单单的指向所属类的地址了的指针了，而时变成了一个共用体,并且使用位域来存储更多的信息

5. App启动流程，以及如何优化？

• 启动顺序

     1. dyld，Apple的动态连接器，可以用来装载Mach-O文件(可执行文件、动态库)

       1.1、装载App的可执行文件，同事递归加载所有依赖的动态库

       1.2 、当dyld把可执行文件、动态库装载完毕后，会通知Runtime进行下一步的处理

• Runtime

     1. 调用map_images进行可执行文件内容的解析和处理

     2. 在load_images里面调用call_load_methods,调用所有class和category的+load方法

     3. 进行各种objc结构的初始化(注册Objc类，初始化类对象等等)

     4. 到目前未知，可执行文件和动态库中所有的符号(Class,Protocol,Selector,IMP..)都已经按照格式成功加载到内存中，被runtime管理

• main函数调用

     1. 所有初始化工作结束后，dyld就会调用main函数

     2. 截下来就是UIApplicationMan函数，AppDelegate的application:didFinishLaunchingWithOptions:的

• App启动速度优化
  

      1. dyld

       1.1、减少动态库，合并一些自定义的动态库，以及定期清理一些不需要的动态库

       1.2、较少Objc类、category的数量、以及定期清理一些不必要的类和分类

       1.3、Swift尽量使用struct

     2. Runtime

       2.1、使用+initialize和dispatch_once取代Objc的+load方法、C++的静态构造器

     3. main

       3.1、再不印象用户体验的情况下面，尽可能的将一些操作延迟，不要全部放到finishLaunching

       3.2、一些网络请求

       3.3、一些第三方的注册

       3.4、以及window的rootViewController 的viewDidload方法，也别做耗时操作

     4. 注意：我们可以添加环境变量可以打印出App的启动时间分析(Edit scheme -> Run -> Arguments)

       4.1、DYLD_PRINT_STATISTICS设置为1，可以打印出来每个阶段的时间

       4.2、如果需要更详细的信息，那就设置DYLD_PRINT_STATISTICS_DETAILS为1

6. App瘦身

• 资源(图片、音频、视频等)

    1. 可以采取无损压缩

     2. 使用LSUnusedResources去除没有用的资源 LSUnusedResources

• 可执行文件瘦身

     1. Strip Linked Product、Make Strings Read-Only、Symbols Hidden by Default设置为true

     2. 去掉一些异常支持 Enable C++ Exceptions、Enable Objective-C Exceptions设置为false

     3. 使用AppCode检测未使用的代码：菜单栏 -> Code -> Inspect Code，等编译完成后，会看到未使用的类

• 生成LinkMap文件，可以查看可执行文件的具体组成

     1. 可借助第三方工具解析LinkMap文件LinkMap

     Link Map解析结果

1. ARC帮我们做了什么？

• 使用LLVM + Runtime 结合帮我管理对象的生命周期

• LLVM 帮我们在代码合适的地方添加release、retarn、autorelease等添加计数器或者减少计数器操作

• Runtime 帮我们像__weak、copy等关键字的操作

2.initialize和load是如何调用的？它们会多次调用吗？

• load方法说在应用加载的时候，Runtime直接拿到load的IMP直接去调用的，而不是像其他方式根据objc_msgSend(消息机制)来调用方法的

• load方法调用的顺序是根据类的加载的前后进行调用的，但是每个类调用的顺序是superclass->class->category顺序调用的，每个load方法只会调用一次(手动调用不算)

• 一下为Runtime源码的主要代码：

load_images(const char *path __unused, const struct mach_header *mh) {
  // 准备class 和category
  prepare_load_methods((const headerType *)mh);
  // 调用load方法
  call_load_methods();
}

void prepare_load_methods(const headerType *mhdr) {
  classref_t *classlist = 
      _getObjc2NonlazyClassList(mhdr, &count);
  for (i = 0; i < count; i++) {
      schedule_class_load(remapClass(classlist[i]));
  }
  category_t **categorylist = _getObjc2NonlazyCategoryList(mhdr, &count);
  for (i = 0; i < count; i++) {
      category_t *cat = categorylist[i];
      add_category_to_loadable_list(cat);
  }
}

static void schedule_class_load(Class cls) {
  // 开始递归，加载superclass
  schedule_class_load(cls->superclass);
  add_class_to_loadable_list(cls);
}

void call_load_methods(void) {
  do {
      while (loadable_classes_used > 0) {
          call_class_loads();
      }
      more_categories = call_category_loads();
  } while (loadable_classes_used > 0  ||  more_categories);
}

static void call_class_loads(void) {
  // 在此add_class_to_loadable_list 里面准备了所有重写load的方法的类
  struct loadable_class *classes = loadable_classes;
  // Call all +loads for the detached list.
  for ( int i = 0; i < used; i++) {
      Class cls = classes[i].cls;
      // 获取到load 方法的imp
      load_method_t load_method = (load_method_t)classes[i].method;
      // 调用laod 方法
      (*load_method)(cls, SEL_load);
  }
}

static bool call_category_loads(void) {
  // 在prepare_load_methods 方法里面准备了所有重新load方法的category
  struct loadable_category *cats = loadable_categories;
  for (int i = 0; i < used; i++) {
      // 获取到catgegory
      Category cat = cats[i].cat;
      // 获取category 的load 方法的IMP实现
      load_method_t load_method = (load_method_t)cats[i].method;
      cls = _category_getClass(cat);
      if (cls  &&  cls->isLoadable()) {
          // 调用load方法
          (*load_method)(cls, SEL_load);
      }
  }
}

• initialize方法的调用其实和其他方法调用一样的，objc_msgSend(消息机制)来调用的。调用的数序是：没有初始话的superclass -> 实现initialize的categort 或者 实现了initialize的class，如果class没有实现initialize 方法，则会调用superclass的initialize,因为initialize的底层是使用了objc_msgSend

• 看下Runtime底层调用_class_initialize的源码

void _class_initialize(Class cls) {
    supercls = cls->superclass;
    if (supercls  &&  !supercls->isInitialized()) {
        // 又是个递归
        _class_initialize(supercls);
    }
    // 调用 initialize方法
    callInitialize(cls);
  }
  // objc_msgSend 调用 initialize 方法
  void callInitialize(Class cls) {
    // **注意：因为使用了objc_msgSend,有可能调用class的 initialize **
    objc_msgSend(cls, SEL_initialize);
  }

总结:
load方法一个类只会调用一次(除去手动调用)，而调用的数序是，从superclass -> class -> category,category里面的顺序是先编译，先调用
initialize方法，一个类可能会调用多次，如果子类没有实现initialize方法，当第一次使用此类的时候，会调用superclass。而调用的顺序是，superclass -> 实现initialize的category 或者 实现了initialize方法(没有category实现initialize) 或者 superclass的initialize (没有子类和category实现initialize方法)

3.说下autoreleasepool

• 在MRC下，当对象调用autorerelease方法时候，会将对象加入到对象前面的哪一个autoreleasepool里面,并且当autoreleasepool作用域释放的时候，会对里面的所有的对象进行一次release操作。

• autoreleasepool底层是使用了AutoreleasePoolPage对象来管理的，AutoreleasePoolPage是一个双向的链表,每个AutoreleasePoolPage都有4096个字节，除了用来存放内部的成员变量，剩下的控件都会用来存放autorelease对象的地址

/// AutoreleasePoolPage 的简化的结构
class AutoreleasePoolPage {
  magic_t const magic;
  // 下一次可以存储对象的地址
  id *next;
  pthread_t const thread;
  // 标识上一个page对象
  AutoreleasePoolPage * const parent;
  // 标识下一个page对昂
  AutoreleasePoolPage *child;
  uint32_t const depth;
  uint32_t hiwat;
}

• 当autoreleasepool开始的时候，会调用AutorelasePoolPage的push方法，会讲一个标识POOL_BOUNDARY添加到AutoreleasePoolPage对象里面，并且返回POOL_BOUNDARY的地址r1(暂且这样叫)

• 当对像进行relase的时候，会将对象的地址添加到当前AutorelasePoolPage里面，依次添加。

• 当autoreleasepool作用域结束的时候，会调用AutorelasePoolPage的pop(r1)方法(r1为当前aotoreleasepool开始的加入标识POOL_BOUNDARY的地址)，AutorelasePoolPage则会将里面保存的对象的从左后一个开始进行release操作，当碰到r1时候，标识当前那个autoreleasepool里面所有的对象都进行了一次release操作。

@autoreleasepool {
  // 此处会调用
   void *ctxt = AutoreleasePoolPage::push();
  // 添加到最近的一个autoreleasepool中
  [[[NSObject alloc]init] autorelease];
  //移除作用域的时候调用
  AutoreleasePoolPage:pop(ctxt)
}
// autoreleasepool 作用域开始会调用AutoreleasePoolPage::push()
static inline void *push() {
  id *dest;
  if (DebugPoolAllocation) {
    // 创建一个心的page对象
    dest = autoreleaseNewPage(POOL_BOUNDARY);
  } else {
    // 已经有了page对象，讲`pool_boundary`添加进去
    dest = autoreleaseFast(POOL_BOUNDARY);
  }
}
static inline id *autoreleaseFast(id obj)
{
  // 获取正在使用的page对昂
  AutoreleasePoolPage *page = hotPage();
  // page还没有装满
  if (page && !page->full()) {
    return page->add(obj);
  } else if (page) {
    // 已经添加满了
    return autoreleaseFullPage(obj, page);
  } else {
    // 没有page对象，创建心的page对象
    return autoreleaseNoPage(obj);
  }
}
// 对象调用release 的简介源码
id objc_object::rootAutorelease2() {
  return AutoreleasePoolPage::autorelease((id)this);
}
static inline id autorelease(id obj) {
  // 同样也是添加进去
  id *dest = autoreleaseFast(obj);
  return obj;
}
// page调用pop简介源码 *token 表示结束的标识
static inline void pop(void *token) {
  AutoreleasePoolPage *page;
  id *stop;
  page = pageForPointer(token);
  stop = (id *)token;
  page->releaseUntil(stop);
}
// 释放对象的源码
void releaseUntil(id *stop) {
  // next 标识当前page可以存储对象的下一个地址
  while (this->next != stop) {
    AutoreleasePoolPage *page = hotPage();
    // 因为page是个双向链表，当page为空的时候，需要往上查找parent的page对象里面存储的睇相
    while (page->empty()) {
      page = page->parent;
      setHotPage(page);
    }
    id obj = *--page->next;
    if (obj != POOL_BOUNDARY) {// obj 不是刚开始传入的POOL_BOUNDARY及表示对象，所以需要调用一次操作
      objc_release(obj);
    }
  }
}

autoreleasepool和runloop的关系

• runloop里面会注册两个Observer来监听runloop的状态变化

• 其中一个Observer监听的状态为kCFRunLoopEntry进入runloop的状态，则会调用AutoreleasePoolPage::push()方法

• 另外中一个Observer监听的状态为kCFRunLoopBeforeWaiting、kCFRunLoopExit,即将休眠和退出当前的runloop。

• 在kCFRunLoopBeforeWaiting的回掉里面会调用AutoreleasePoolPage::pop(ctxt)和AutoreleasePoolPage::(push)方法，释放上一个autoreleasepool里面添加的对象，并开启下一个autoreleasepool。

• 在kCFRunLoopExit的Observer回掉里面会调用AutoreleasePoolPage::(push)释放autoreleasepool里面的对象

4.category属性是存储在那里？

• 我们都知道可以使用Runtime的objc_setAssociatedObject、objc_getAssociatedObject两个方法给category的属性重写get、set方法，而此属性的值是存储在那里呢？

• 其实此属性的值保存在一个AssociationsManager里面。

• 我们也是可以根据源码看一下

void _object_set_associative_reference(id object, void *key, id value, uintptr_t policy) {
   // 一下为精简的代码
    id new_value = value ? acquireValue(value, policy) : nil;
    {
        AssociationsManager manager;
        AssociationsHashMap &associations(manager.associations());
        disguised_ptr_t disguised_object = DISGUISE(object);
        if (new_value) {
          ObjectAssociationMap *refs = new ObjectAssociationMap;
          associations[disguised_object] = refs;
          (*refs)[key] = ObjcAssociation(policy, new_value);
        }
    }
}

5.category方法是如何添加的？

• 当我们给分类添加相同的方法的时候，会调用category里面的方法，而不是调用我们class里面的方法

• 当编译器编译的时候，编译器会将category编译成category_t这样的结构体，等类初始化的时候，会将分类的信息同步到class_rw_t里面,包含：method、property、protocol等，同步的时候会将category里面的信息添加到class的前面(而不是替换掉class里面的方法)，而方法调用的时候，而是遍历class_rw_t里面的方法，所以找到分类里面的IMP则返回。 

• 使用memmove,将类方法移动到后面
• 使用memcpy,将分类的方法copy到前面
• 当多个分类有相同的方法的时候，调用的顺序是后编译先调用
• 当类初始化同步category的时候，会使用while(i--)的倒序循环，将后编译的category添加到最前面。
       

一：第三方插件

1:基于响应式编程思想的oc

地址：https://github.com/ReactiveCocoa/ReactiveCocoa

2：hud提示框

地址：https://github.com/jdg/MBProgressHUD

3：XML/HTML解析

地址：https://github.com/topfunky/hpple

4：有文字输入时，能根据键盘是否弹出来调整自身显示内容的位置

地址：https://github.com/michaeltyson/TPKeyboardAvoiding

5：状态栏提示框

地址：https://github.com/jaydee3/JDStatusBarNotification

6：block工具包。将很多需要用delegate实现的方法整合成了block的形式

地址：https://github.com/zwaldowski/BlocksKit

7：图片加载

地址：https://github.com/rs/SDWebImage

8：正则表达式

地址：https://github.com/wezm/RegexKitLite

9：Masonry代码布局

地址：https://github.com/SnapKit/Masonry

10：弹出窗

地址：https://github.com/sberrevoets/SDCAlertView

11:Button的样式

地址：https://github.com/mattlawer/BButton

12：验证网络连接状态

地址：https://github.com/tonymillion/Reachability

13：自动计算表格行高

地址：https://github.com/forkingdog/UITableView-FDTemplateLayoutCell

14：动画效果的启动页

地址：https://github.com/IFTTT/JazzHands

15：iOS快速简单集成国内三大平台分享

地址：https://github.com/xumeng/XMShareModule

16：五项能力值展示的五边形

地址：https://github.com/dsxNiubility/SXFiveScoreShow

17：自动识别网址号码邮箱和表情的label

地址：https://github.com/molon/MLEmojiLabel

18：IM对话功能的封装

地址：https://github.com/ZhipingYang/UUChatTableView

19：字典转模型框架

地址：https://github.com/CoderMJLee/MJExtension

20：下拉上拉刷数据

地址：https://github.com/CoderMJLee/MJRefresh

21：表格行左右划动菜单

地址：https://github.com/MortimerGoro/MGSwipeTableCell

22:图文混搭

地址:https://github.com/zhouande/TLAttributedLabel

23:可以简单展示在UINavigationBar下方，类似Music app的播放列表视图，弹出菜单视图

地址：https://github.com/DrummerB/BFNavigationBarDrawer

24：比如筛选、模糊、优化、蒙版、调整大小、旋转以及保存等等。同时还提供了一个UIImageView子类从URL异步加载图片，并在下载完毕时展示图片。

地址：https://github.com/Nyx0uf/NYXImagesKit

25：底部TabBar

地址：https://github.com/robbdimitrov/RDVTabBarController

26:表情面版

地址：https://github.com/ayushgoel/AGEmojiKeyboard

27:记录框架

地址：https://github.com/CocoaLumberjack/CocoaLumberjack

28：IOS与javascript交互

地址：https://github.com/marcuswestin/WebViewJavascriptBridge

29：图表统计展示

地址：https://github.com/kevinzhow/PNChart

30:appStore评分

地址：https://github.com/arashpayan/appirater

31：iOS-Categories 扩展类大全

地址：https://github.com/shaojiankui/IOS-Categories

32：扫描二维码，仿微信效果，带有扫描条

地址：https://github.com/JxbSir/JxbScanQR

33:动效弹出视图(弹出窗里面为文字，可以定义弹出的方向，及显示的时间)--AMPopTip

地址：https://github.com/andreamazz/AMPopTip

34:基于Masonry自动计算行高扩展

地址：https://github.com/632840804/HYBMasonryAutoCellHeight

 35:模仿新浪微博弹出菜单

地址：https://github.com/wwdc14/HyPopMenuView

 36:搜索历史标签

地址：https://github.com/zhiwupei/SearchHistory

 37：快速集成新手引导的类库

地址：https://github.com/StrongX/XSportLight

38：设置页面的封装

地址：https://github.com/renzifeng/ZFSetting

39：带箭头的弹出视图插件

地址：https://github.com/xiekw2010/DXPopover

40：下拉菜单插件

地址：https://github.com/dopcn/DOPDropDownMenu/

41：表格空白提示插件

地址：https://github.com/dzenbot/DZNEmptyDataSet

42:给任意UIView视图四条边框加上阴影，可以自定义阴影的颜色、粗细程度、透明程度以及位置（上下左右边框）

地址：https://github.com/Seitk/UIView-Shadow-Maker

43:不错的日期时间插件

地址：https://github.com/CoderXL/UUDatePicker

44:底部弹出选择

地址：https://github.com/skywinder/ActionSheetPicker-3.0

45:比较不错的引导页面插件

地址：https://github.com/ealeksandrov/EAIntroView

46:两个APP跳转的插件

地址：https://github.com/usebutton/DeepLinkKit

47:本地存取NSUserDefaults插件

地址：https://github.com/gangverk/GVUserDefaults

48:NSArray 和 NSDictionary关于LINQ的操作方式，封装一些常用的操作

地址：https://github.com/ColinEberhardt/LinqToObjectiveC

49:可以监控网络请求的内容

地址：https://github.com/coderyi/NetworkEye

50：时间帮助插件，可以快速获取时间，比较，增加等操作

地址：https://github.com/MatthewYork/DateTools

51: 不错的链式动作

地址：https://github.com/jhurray/JHChainableAnimations

52:弹出层视图，背景效果（可以自定义视图的内容）

地址：https://github.com/HJaycee/JCAlertView

53:圆形进度条的显示，中间可显示值

地址：https://github.com/mdinacci/MDRadialProgress

54:很帅的数据加载动画（可以用于数据列表加载的展现）

地址：https://github.com/NghiaTranUIT/FeSpinner 

55:一个开源的AFnetworking上层的封装（猿题库等运用）

地址：https://github.com/yuantiku/YTKNetwork

56:CBStoreHouseRefreshControl：一个效果很酷炫的下拉刷新控件

地址：https://github.com/coolbeet/CBStoreHouseRefreshControl

57:AFNetworking-RACExtensions:针对ReactiveCocoa的AF封装

地址：https://github.com/CodaFi/AFNetworking-RACExtensions

58:模糊效果（毛玻璃）

地址：https://github.com/nicklockwood/FXBlurView

二：源代码实例

1:Coding.net客户端

地址：https://coding.net/u/coding/p/Coding-iOS/git

2:高仿美团iOS版

地址：https://github.com/lookingstars/meituan

3:模仿网易新闻做的精仿网易新闻

地址：https://github.com/dsxNiubility/SXNews

4:支付宝高仿版

地址：https://github.com/gsdios/GSD_ZHIFUBAO

5:高仿百度传课iOS版

地址：https://github.com/lookingstars/chuanke

6：模仿一元云购

地址：https://github.com/JxbSir/YiYuanYunGou

7：wordpress源代码

地址：https://github.com/wordpress-mobile/WordPress-iOS

8：v2ex源代码（文章类型，若报SVProgressHUD错，则把Podfile中的SVProgressHUD移除）

地址：https://github.com/singro/v2ex

9:PHPHub客户端(IOS8.0以上)

地址：https://github.com/Aufree/phphub-ios

10:快速搭建项目源代码

地址：https://github.com/wujunyang/MobileProject

三：辅助软件

1：XCODE文档注解插件VVDocumenter

地址：https://github.com/onevcat/VVDocumenter-Xcode

2：将JSON格式化输出为模型的属性

地址：https://github.com/EnjoySR/ESJsonFormat-Xcode

3：图片提示插件

地址：https://github.com/ksuther/KSImageNamed-Xcode

4：图片转换插件

地址：https://github.com/rickytan/RTImageAssets

ios数据存储的5种方式

1. NSUserDefaults（Preference偏好设置）
2. plist存储
3. 归档
4. SQLite3
5. CoreData

Document:适合存储重要的数据， iTunes同步应用时会同步该文件下的内容,（比如游戏中的存档）
Library/Caches：适合存储体积大，不需要备份的非重要数据，iTunes不会同步该文件
Library/Preferences:通常保存应用的设置信息, iTunes会同步
tmp:保存应用的临时文件，用完就删除，系统可能在应用没在运行时删除该目录下的文件，iTunes不会同步

获取沙盒路径

Document:

NSArray *paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
NSString *documentFilePath = paths.firstObject;

NSuserDefault

NSuserDefault适合存储轻量级的本地数据，支持的数据类型有：NSNumber，NSString，NSDate，NSArray，NSDictionary，BOOL，NSData

沙盒路径为 Library/Preferences
文件格式为 .plist

优点：

1. 不需要关心文件名
2. 快速进行键值对存储
3. 直接存储基本数据类型

缺点：

1. 不能存储自定义数据
2. 取出的数据都是不可变的

- (IBAction)userDefaultSave:(id)sender {
    NSArray *testArray = @[@"test1", @"test2", @"test3"];
    [[NSUserDefaults standardUserDefaults] setObject:testArray forKey:@"arrayKey"];
    [[NSUserDefaults standardUserDefaults] synchronize];
}

- (IBAction)userDefaultLoad:(id)sender {
    NSArray *testArray = [[NSUserDefaults standardUserDefaults] objectForKey:@"arrayKey"];
    NSLog(@"%@", testArray);
}

plist支持的数据类型：

NSArray;
NSMutableArray;
NSDictionary;
NSMutableDictionary;
NSData;
NSMutableData;
NSString;
NSMutableString;
NSNumber;
NSDate;
不支持BOOL
而且最外层好像要用`NSArray 或 NSDictionary，偷个懒还没验证

- (IBAction)plistSave:(id)sender {
    NSString *cachePath = NSSearchPathForDirectoriesInDomains(NSCachesDirectory, NSUserDomainMask, YES).firstObject;
    NSString *filePath = [cachePath stringByAppendingPathComponent:@"testPlist.plist"];
    
    NSMutableDictionary *dict = [NSMutableDictionary dictionary];
    [dict setObject:@"ran" forKey:@"name"];
    [dict setObject:@"18" forKey:@"age"];
    [dict writeToFile:filePath atomically:YES];
}
 
- (IBAction)plistLoad:(id)sender {
    NSString *cachePath = NSSearchPathForDirectoriesInDomains(NSCachesDirectory, NSUserDomainMask, YES).firstObject;
    NSString *filePath = [cachePath stringByAppendingPathComponent:@"testPlist.plist"];
    
    NSDictionary *t = [NSDictionary dictionaryWithContentsOfFile:filePath];
    NSLog(@"%@",t);
}

归档

存储自定义对象

1. 首先新建Person类，并遵守NSCoding协议

@interface Person : NSObject<NSCoding>
 
@property(nonatomic, strong)NSString *name;
@property(nonatomic, strong)NSString *age;
 
@end

@implementation Person
 
- (instancetype)initWithCoder:(NSCoder *)coder
{
    self = [super init];
    if (self) {
        _name = [coder decodeObjectForKey:@"name"];
        _age = [coder decodeObjectForKey:@"age"];
    }
    return self;
}
 
- (void)encodeWithCoder:(NSCoder *)coder
{
 
    [coder encodeObject:self.name forKey:@"name"];
    [coder encodeObject:self.age forKey:@"age"];
 
}
@end

- (IBAction)archive:(id)sender {
    NSArray *paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
    NSString *documentFilePath = paths.firstObject;
    NSString *filePath = [documentFilePath stringByAppendingPathComponent:@"personModel"];
    
    Person *p1 = [[Person alloc] init];
    p1.name = @"ran";
    p1.age = @"18";
    
    [NSKeyedArchiver archiveRootObject:p1 toFile:filePath];
}
 
- (IBAction)unarchive:(id)sender {
    NSArray *paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
    NSString *documentFilePath = paths.firstObject  ;
    NSString *filePath = [documentFilePath stringByAppendingPathComponent:@"personModel"];
    
    Person *p1 = [NSKeyedUnarchiver unarchiveObjectWithFile:filePath] ;
    
    NSLog(@"%@", p1.name);
    NSLog(@"%@", p1.age);
}

- (IBAction)archiveManyObject:(id)sender {
    NSArray *paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
    NSString *documentFilePath = paths.firstObject  ;
    NSString *filePath = [documentFilePath stringByAppendingPathComponent:@"personModel"];
    
    NSMutableData *data = [[NSMutableData alloc] init];
    NSKeyedArchiver *archiver =  [[NSKeyedArchiver alloc] initForWritingWithMutableData:data]; //将数据区连接到NSKeyedArchiver对象
    
    Person *p1 = [[Person alloc] init];
    p1.name = @"ran1";
    p1.age = @"18";
    [archiver encodeObject:p1 forKey:@"person1"];
    
    Person *p2 = [[Person alloc] init];
    p2.name = @"ran2";
    p2.age = @"19";
    [archiver encodeObject:p2 forKey:@"person2"];
 
    [archiver finishEncoding];
    
    [data writeToFile:filePath atomically:YES];
}
 
- (IBAction)unarchiveManyObject:(id)sender {
    NSArray *paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
    NSString *documentFilePath = paths.firstObject  ;
    NSString *filePath = [documentFilePath stringByAppendingPathComponent:@"personModel"];
    NSData *data = [NSData dataWithContentsOfFile:filePath];
    
    NSKeyedUnarchiver *unarchiver = [[NSKeyedUnarchiver alloc] initForReadingWithData:data];
    Person *p1 =  [unarchiver decodeObjectForKey:@"person1"];
    Person *p2 =  [unarchiver decodeObjectForKey:@"person2"];
    [unarchiver finishDecoding];
    
    NSLog(@"%@", p1.name);
    NSLog(@"%@", p2.name);
}

数据库(splite):
splite是一个轻量级,跨平台的小型数据库,可移植性比较高,有着和MySpl几乎相同的数据库语句,以及无需服务器即可使用的优点:

数据库的优点:

#import "SqliteVC.h"
#import "Person.h"
@interface SqliteVC() {
    
    sqlite3 *_db;
 
}
@end
 
@implementation SqliteVC
 
- (void)viewDidLoad {
    [super viewDidLoad];
    
    NSString *fileName = [[NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES) lastObject] stringByAppendingPathComponent:@"student.sqlite"];
    NSLog(@"fileName = %@",fileName);
    
    int result = sqlite3_open(fileName.UTF8String, &_db); //创建(打开)数据库,如果数据库不存在，会自动创建  数据库文件的路径必须以C字符串(而非NSString)传入
    
    if (result == SQLITE_OK) {
        NSLog(@"成功打开数据库");
        
        char *errorMesg = NULL;
        const char *sql = "create table if not exists t_person (id integer primary key autoincrement, name text, age integer);";
        int result = sqlite3_exec(_db, sql, NULL, NULL, &errorMesg); //sqlite3_exec()可以执行任何SQL语句，比如创表、更新、插入和删除操作。但是一般不用它执行查询语句，因为它不会返回查询到的数据
        
        if (result == SQLITE_OK) {
            NSLog(@"成功创建t_person表");
        } else {
            NSLog(@"创建t_person表失败:%s",errorMesg);
        }
        
    } else {
        NSLog(@"打开数据库失败");
    }
}
- (IBAction)insert:(id)sender {
    for (int i = 0; i < 30; i++) {
        
        NSString *name = [NSString stringWithFormat:@"person-%d",arc4random()0];
        int age = arc4random() % 100;
        
        char *errorMesg = NULL;
        NSString *sql = [NSString stringWithFormat:@"insert into t_person (name,age) values ('%@',%d);",name, age];
        int result = sqlite3_exec(_db, sql.UTF8String, NULL, NULL, &errorMesg);
        
        if (result == SQLITE_OK) {
            NSLog(@"添加数据成功");
        } else {
            NSLog(@"添加数据失败");
        }
    }
}
 
- (IBAction)delete:(id)sender {
    char *errorMesg = NULL;
    NSString *sql = @"delete from t_person where age >= 0";
    int result = sqlite3_exec(_db, sql.UTF8String, NULL, NULL, &errorMesg);
    
    if (result == SQLITE_OK) {
        NSLog(@"删除成功");
    }else {
        NSLog(@"删除失败");
    }
}
 
- (IBAction)query:(id)sender {
    const char *sql = "select id, name, age from t_person;";  //"select id, name, age from t_person where age >= 50;"
    sqlite3_stmt *stmt = NULL;  //定义一个stmt存放结果集
    int result = sqlite3_prepare_v2(_db, sql, -1, &stmt, NULL); //检测SQL语句的合法性
    
    if (result == SQLITE_OK) {
        NSLog(@"查询语句合法");
        
        while (sqlite3_step(stmt) == SQLITE_ROW) {
            
            int ID = sqlite3_column_int(stmt, 0);
            const unsigned char *sname = sqlite3_column_text(stmt, 1);
            NSString *name = [NSString stringWithUTF8String:(const char *)sname];
            int age = sqlite3_column_int(stmt, 2);
            
            NSLog(@"%d %@ %d",ID, name, age);
        }
    } else {
        NSLog(@"查询语句非法");
    }
}
 
- (IBAction)update:(id)sender {
    NSString *sql = @"update t_person set name = '哈哈' where age > 60";
    char *errorMesg = NULL;
    int result = sqlite3_exec(_db, sql.UTF8String, NULL, NULL, &errorMesg);
    
    if (result == SQLITE_OK) {
        NSLog(@"更改成功");
    }else {
        
        NSLog(@"更改失败");
    }
}

coreData是苹果官方在iOS5之后推出的综合性数据库,其使用了对象关系映射技术,将对象转换成数据,将数据存储在本地的数据库中
coreData为了提高效率,需要将数据存储在不同的数据库中,比如:在使用的时候,最好是将本地的数据保存到内存中,这样的目的是访问速度比较快.

CoreData与SQLite进行对比

SQLite
1、基于C接口，需要使用SQL语句，代码繁琐
2、在处理大量数据时，表关系更直观
3、在OC中不是可视化，不易理解
 
 
CoreData
1、可视化，且具有undo/redo能力
2、可以实现多种文件格式：
    * NSSQLiteStoreType
    * NSBinaryStoreType
    * NSInMemoryStoreType
    * NSXMLStoreTyp
3、苹果官方API支持，与iOS结合更紧密

CoreData核心类与结构

NSManagedObjectContext(数据上下文)

• 对象管理上下文，负责数据的实际操作(重要)
• 作用：插入数据，查询数据，删除数据，更新数据

NSPersistentStoreCoordinator(持久化存储助理)

• 相当于数据库的连接器
• 作用：设置数据存储的名字，位置，存储方式，和存储时机

NSManagedObjectModel(数据模型)

• 数据库所有表格或数据结构，包含各实体的定义信息
• 作用：添加实体的属性，建立属性之间的关系
• 操作方法：视图编辑器，或代码

NSManagedObject(被管理的数据记录)

• 数据库中的表格记录

NSEntityDescription(实体结构)

• 相当于表格结构

NSFetchRequest(数据请求)

• 相当于查询语句

后缀为.xcdatamodeld的包

• 里面是.xcdatamodel文件，用数据模型编辑器编辑
• 编译后为.momd或.mom文件

类关系图

开始创建coredata

步骤：
1.创建模型文件 ［相当于一个数据库］
2.添加实体 ［一张表］
3.创建实体类 [相当模型--表结构]
4.生成上下文 关联模型文件生成数据库

1.创建模型文件

New File -> iOS -> Core Data ->Data Model

2.创建实体

Codegen

3.创建实体类

创建结果如图所示：

1.生成上下文 关联模型文件生成数据库，进行增删查改操作

#import "coredataVC.h"
#import <CoreData/CoreData.h>
#import "Student+CoreDataProperties.h"
 
@interface coredataVC ()
 
@property(nonatomic, strong)NSManagedObjectContext *context;
 
@end
 
@implementation coredataVC
 
- (void)viewDidLoad {
    [super viewDidLoad];
 
    //entity 记得勾选 language:objective-c 和 codegen:manual/none
    [self createSql];
}
 
- (void)createSql {
    //获取模型路径
    NSURL *modelURL = [[NSBundle mainBundle] URLForResource:@"Person" withExtension:@"momd"];
    //根据模型文件创建模型对象
    NSManagedObjectModel *model = [[NSManagedObjectModel alloc] initWithContentsOfURL:modelURL];
    
    //利用模型对象创建持久化存储助理
    NSPersistentStoreCoordinator *store = [[NSPersistentStoreCoordinator alloc] initWithManagedObjectModel:model];
    
    //数据库的名称和路径
    NSString *docStr = [NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES) lastObject];
    NSString *sqlPath = [docStr stringByAppendingPathComponent:@"coreData.sqlite"];
    NSURL *sqlUrl = [NSURL fileURLWithPath:sqlPath];
    NSLog(@"数据库 path = %@", sqlPath);
    
    NSError *error = nil; //设置数据库相关信息 添加一个持久化存储库并设置类型和路径，NSSQLiteStoreType：SQLite作为存储库
    [store addPersistentStoreWithType:NSSQLiteStoreType configuration:nil URL:sqlUrl options:nil error:&error];
    
    if (error) {
        NSLog(@"添加数据库失败:%@",error);
    } else {
        NSLog(@"添加数据库成功");
    }
    
    //3、创建上下文 保存信息 对数据库进行操作 关联持久化助理
    NSManagedObjectContext *context = [[NSManagedObjectContext alloc] initWithConcurrencyType:NSMainQueueConcurrencyType];
    context.persistentStoreCoordinator = store;
    _context = context;
}

增

- (IBAction)insertClick:(id)sender {
    Student * student = [NSEntityDescription  insertNewObjectForEntityForName:@"Student"  inManagedObjectContext:_context];
    student.name = [NSString stringWithFormat:@"stu-%d",arc4random()0];
    student.age = arc4random()%30;
    
    NSError *error = nil;
    if ([_context save:&error]) {
        NSLog(@"数据插入到数据库成功");
    }else{
        NSLog(@"数据插入到数据库失败");
    }
}

删

- (IBAction)deleteClick:(id)sender {
    //创建删除请求
    NSFetchRequest *deleRequest = [NSFetchRequest fetchRequestWithEntityName:@"Student"];
    
    //删除条件 没有任何条件就是读取所有的数据
    //NSPredicate *pre = [NSPredicate predicateWithFormat:@"age < %d", 10];
    //deleRequest.predicate = pre;
    
    //返回需要删除的对象数组
    NSArray *deleArray = [_context executeFetchRequest:deleRequest error:nil];
    
    //从数据库中删除
    for (Student *stu in deleArray) {
        [_context deleteObject:stu];
    }
    
    NSError *error = nil;
    if ([_context save:&error]) {
        NSLog(@"删除数据成功");
    }else{
        NSLog(@"删除数据失败, %@", error);
    }
}

查

- (IBAction)queryClick:(id)sender {
    //创建查询请求
    NSFetchRequest *request = [NSFetchRequest fetchRequestWithEntityName:@"Student"];
    
    //查询条件 没有任何条件就是读取所有的数据
    NSPredicate *pre = [NSPredicate predicateWithFormat:@"age >= 0"];
    request.predicate = pre;
    
    // 从第几页开始显示 通过这个属性实现分页
    //request.fetchOffset = 0;
    // 每页显示多少条数据
    //request.fetchLimit = 6;
    
    //发送查询请求
    NSArray *resArray = [_context executeFetchRequest:request error:nil];
    
    //打印查询结果
    for (Student *stu in resArray) {
        NSLog(@"name=%@, age=%d",stu.name, stu.age);
    }
}

改

- (IBAction)updateClick:(id)sender {
    //创建查询请求
    NSFetchRequest *request = [NSFetchRequest fetchRequestWithEntityName:@"Student"];
    
    NSPredicate *pre = [NSPredicate predicateWithFormat:@"age >= 0"];
    request.predicate = pre;
    
    //发送请求
    NSArray *resArray = [_context executeFetchRequest:request error:nil];
    
    //修改
    for (Student *stu in resArray) {
        stu.name = @"ran";
    }
    
    NSError *error = nil;
    if ([_context save:&error]) {
        NSLog(@"更新数据成功");
    }else{
        NSLog(@"更新数据失败, %@", error);
    }
}
 
@end

转自：https://blog.csdn.net/u013712343/article/details/106698848

一、WebView加载

可以通过WebView加载本地Gif图和网络Gif图，但图片大小不能自适应控件大小，也不能设置Gif图播放时间。使用如下：

// 1、WebView加载
- (void)webViewShowGif {
    UIWebView *webView = self.viewArr[0];
    
    // 本地地址
    NSString *imagePath = [[NSBundle mainBundle] pathForResource:@"hello" ofType:@"gif"];
    // 网路地址
//    NSString *imagePath = @"http://qq.yh31.com/tp/zjbq/201711092144541829.gif";
    
    NSURL *imageUrl = [NSURL URLWithString:imagePath];
    NSURLRequest *request = [NSURLRequest requestWithURL:imageUrl];
    [webView loadRequest:request];
}

二、UIImageView加载多图动画

把动态图拆分成一张张图片，将一系列帧添加到animationImages数组里面，然后设置animation一系列属性，如动画时间，动画重复次数。例：

// 2、UIImageView加载多张图片，播放
- (void)imageViewStartAnimating {
    UIImageView *imageView = self.viewArr[1];
    
    NSMutableArray *imageArr = [NSMutableArray arrayWithCapacity:3];
    for (int i = 0; i<3; i++) {
        NSString *imageStr = [NSString stringWithFormat:@"import_progress%d",i + 1];
        UIImage *image = [UIImage imageNamed:imageStr];
        [imageArr addObject:image];
    }
    imageView.animationImages = imageArr;
    imageView.animationDuration = 2;
    [imageView startAnimating];
}

三、SDWebImage加载本地GIF

在SDWebImage这个库里有一个UIImage+GIF的类别，使用sd_animatedGIFWithData方法可以将GIF图片数据专为图片。例：

// 3、SDWebImage加载本地GIF
- (void)imageViewLocalGif {
    NSString *imagePath = [[NSBundle mainBundle] pathForResource:@"happy" ofType:@"gif"];
    NSData *imageData = [NSData dataWithContentsOfFile:imagePath];
    UIImage *image = [UIImage sd_animatedGIFWithData:imageData];

    UIImageView *imageView = self.viewArr[2];
    imageView.image = image;
}

四、SDWebImage加载网络GIF

首先将网络gif图下载到本地，然后再用sd_animatedGIFWithData方法，转为可用的图片，下载gif图的方式有两种

方式一：采用SDWebImageDownloader下载，回调里面会有NSData。只是，你会发现采用SDWebImageDownloader下载，界面显示就是没有sd_setImageWithURL方法流畅，这是因为sd_setImageWithURL里面对cache和线程做了很多处理，保证了UI的流畅。

NSString *imageStr = @"http://qq.yh31.com/tp/zjbq/201711142021166458.gif";
    NSURL *imgeUrl = [NSURL URLWithString:imageStr];
    SDWebImageDownloaderOptions options = 0;
    UIImageView *imageView = self.viewArr[3]; 
    
    // 方法一 SDWebImageDownloader下载
    SDWebImageDownloader *downloader = [SDWebImageDownloader sharedDownloader];
    [downloader downloadImageWithURL:imgeUrl
                             options:options
                            progress:^(NSInteger receivedSize, NSInteger expectedSize, NSURL * _Nullable targetURL) {

                            } completed:^(UIImage * _Nullable image, NSData * _Nullable data, NSError * _Nullable error, BOOL finished) {
                                imageView.image = [UIImage sd_animatedGIFWithData:data];
                            }];

方式二、sd_setImageWithURL下载，回调的时候不用image，去直接读cache。(首先要了解sd_setImageWithURL里的内部逻辑，下载完之后先入cache，再执行block，这才保证外面可以直接读取到)，取出来的就是NSData。首次下载成功时，可能获取data失败，因为这次图片可能还没存储成功，有延迟。

// 方法二 sd_setImageWithURL下载
    SDWebImageOptions opt = SDWebImageRetryFailed | SDWebImageAvoidAutoSetImage;
    [imageView sd_setImageWithURL:imgeUrl
                 placeholderImage:nil
                          options:opt
                        completed:^(UIImage * _Nullable image, NSError * _Nullable error, SDImageCacheType cacheType, NSURL * _Nullable imageURL) {
                            
                            if (image.images && image.images.count) {
                                NSString *path = [[SDImageCache sharedImageCache] defaultCachePathForKey:imageURL.absoluteString];
                                NSData *data = [NSData dataWithContentsOfFile:path];
                                UIImage *gifImage = [UIImage sd_animatedGIFWithData:data];
                                imageView.image = gifImage;
                            }
                        }];

五、FLAnimatedImage使用  

FLAnimatedImage 是由Flipboard开源的iOS平台上播放GIF动画的一个优秀解决方案，在内存占用和播放体验都有不错的表现。FLAnimatedImage项目的流程比较简单，FLAnimatedImage就是负责GIF数据的处理，然后提供给FLAnimatedImageView一个UIImage对象。FLAnimatedImageView拿到UIImage对象显示出来就可以了。 例：

// 5、FLAnimatedImage使用
- (void)animatedImageViewShowGif {
    FLAnimatedImageView *imageView = self.viewArr[4];
    
    NSURL *url = [[NSBundle mainBundle] URLForResource:@"weiwei" withExtension:@"gif"];
    NSData *data = [NSData dataWithContentsOfURL:url];
    FLAnimatedImage *animatedImage = [FLAnimatedImage animatedImageWithGIFData:data];
    imageView.animatedImage = animatedImage;
}

六、YYImage使用

1.显示本地gif 

//load loacle gif image
- (void)loadLocaleGifImage{    
    //yyImage show gif image
    [self labelFactoryWithFrame:CGRectMake(0, kScreenHeight/2 - 20, kScreenWidth, 20) title:@"yyImage"];
    YYImage *yyimage = [YYImage imageNamed:@"test.gif"];
    YYAnimatedImageView *yyImageView = [[YYAnimatedImageView alloc] initWithImage:yyimage];
    yyImageView.frame = CGRectMake(0, kScreenHeight/2, kScreenWidth, kScreenHeight/3);
    [self.view addSubview:yyImageView];
}

 2.加载网络gif图

//download network gif image
- (void)downloadNetworkGifImage{
  

    //yyImage show gif image
    [self labelFactoryWithFrame:CGRectMake(0, kScreenHeight/2 - 20, kScreenWidth, 20) title:@"yyImage"];
    YYImage *yyimage = [YYImage imageWithData:[NSData dataWithContentsOfURL:[NSURL URLWithString:@"http://photocdn.sohu.com/20151214/mp48444247_1450092561460_10.gif"]]];
    YYAnimatedImageView *yyImageView = [[YYAnimatedImageView alloc] initWithImage:yyimage];
    yyImageView.frame = CGRectMake(0, kScreenHeight/2, kScreenWidth, kScreenHeight/3);
    [self.view addSubview:yyImageView];
}

- (void)labelFactoryWithFrame:(CGRect)frame title:(NSString *)title{
    
    UILabel *label = [[UILabel alloc] initWithFrame:frame];
    label.textAlignment = NSTextAlignmentCenter;
    label.textColor = [UIColor blackColor];
    label.font = [UIFont systemFontOfSize:14];
    label.text = title;
    [self.view addSubview:label];
}

现在iPhone手机屏幕越来越多, 屏幕适配也越来越重要. Masonry就是为屏幕适配而生的三方框架.

Masonry基础API

mas_makeConstraints()    添加约束
mas_remakeConstraints()  移除之前的约束，重新添加新的约束
mas_updateConstraints()  更新约束，写哪条更新哪条，其他约束不变

equalTo()       参数是对象类型，一般是视图对象或者mas_width这样的坐标系对象
mas_equalTo()   和上面功能相同，参数可以传递基础数据类型对象，可以理解为比上面的API更强大

width()         用来表示宽度，例如代表view的宽度
mas_width()     用来获取宽度的值。和上面的区别在于，一个代表某个坐标系对象，一个用来获取坐标系对象的值

更新约束和布局

Masonry本质上就是对系统AutoLayout进行的封装，包括里面很多的API，都是对系统API进行了一次二次包装。
typedef NS_OPTIONS(NSInteger, MASAttribute) {
    MASAttributeLeft = 1 << NSLayoutAttributeLeft,
    MASAttributeRight = 1 << NSLayoutAttributeRight,
    MASAttributeTop = 1 << NSLayoutAttributeTop,
    MASAttributeBottom = 1 << NSLayoutAttributeBottom,
    MASAttributeLeading = 1 << NSLayoutAttributeLeading,
    MASAttributeTrailing = 1 << NSLayoutAttributeTrailing,
    MASAttributeWidth = 1 << NSLayoutAttributeWidth,
    MASAttributeHeight = 1 << NSLayoutAttributeHeight,
    MASAttributeCenterX = 1 << NSLayoutAttributeCenterX,
    MASAttributeCenterY = 1 << NSLayoutAttributeCenterY,
    MASAttributeBaseline = 1 << NSLayoutAttributeBaseline,
};

Masonry示例代码

Masonry本质上就是对系统AutoLayout进行的封装，包括里面很多的API，都是对系统API进行了一次二次包装。
typedef NS_OPTIONS(NSInteger, MASAttribute) {
    MASAttributeLeft = 1 << NSLayoutAttributeLeft,
    MASAttributeRight = 1 << NSLayoutAttributeRight,
    MASAttributeTop = 1 << NSLayoutAttributeTop,
    MASAttributeBottom = 1 << NSLayoutAttributeBottom,
    MASAttributeLeading = 1 << NSLayoutAttributeLeading,
    MASAttributeTrailing = 1 << NSLayoutAttributeTrailing,
    MASAttributeWidth = 1 << NSLayoutAttributeWidth,
    MASAttributeHeight = 1 << NSLayoutAttributeHeight,
    MASAttributeCenterX = 1 << NSLayoutAttributeCenterX,
    MASAttributeCenterY = 1 << NSLayoutAttributeCenterY,
    MASAttributeBaseline = 1 << NSLayoutAttributeBaseline,
};

常用方法

设置内边距

/** 
 设置yellow视图和self.view等大，并且有10的内边距。
 注意根据UIView的坐标系，下面right和bottom进行了取反。所以不能写成下面这样，否则right、bottom这两个方向会出现问题。
 make.edges.equalTo(self.view).with.offset(10);
 
 除了下面例子中的offset()方法，还有针对不同坐标系的centerOffset()、sizeOffset()、valueOffset()之类的方法。
 */
[self.yellowView mas_makeConstraints:^(MASConstraintMaker *make) {
    make.left.equalTo(self.view).with.offset(10);
    make.top.equalTo(self.view).with.offset(10);
    make.right.equalTo(self.view).with.offset(-10);
    make.bottom.equalTo(self.view).with.offset(-10);
}];

通过insets简化设置内边距的方式

// 下面的方法和上面例子等价，区别在于使用insets()方法。
[self.blueView mas_makeConstraints:^(MASConstraintMaker *make) {
    // 下、右不需要写负号，insets方法中已经为我们做了取反的操作了。
    make.edges.equalTo(self.view).with.insets(UIEdgeInsetsMake(10, 10, 10, 10));
}];

更新约束

// 设置greenView的center和size，这样就可以达到简单进行约束的目的
[self.greenView mas_makeConstraints:^(MASConstraintMaker *make) {
    make.center.equalTo(self.view);
    // 这里通过mas_equalTo给size设置了基础数据类型的参数，参数为CGSize的结构体
    make.size.mas_equalTo(CGSizeMake(300, 300));
}];

// 为了更清楚的看出约束变化的效果，在显示两秒后更新约束。
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.f * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
    // 指定更新size，其他约束不变。
    [self.greenView mas_updateConstraints:^(MASConstraintMaker *make) {
        make.size.mas_equalTo(CGSizeMake(100, 100));
    }];
});

大于等于和小于等于某个值的约束

[self.textLabel mas_makeConstraints:^(MASConstraintMaker *make) {
    make.center.equalTo(self.view);
    // 设置宽度小于等于200
    make.width.lessThanOrEqualTo(@200);
    // 设置高度大于等于10
    make.height.greaterThanOrEqualTo(@(10));
}];

self.textLabel.text = @"这是测试的字符串。能看到1、2、3个步骤，第一步当然是上传照片了，要上传正面近照哦。上传后，网站会自动识别你的面部，如果觉得识别的不准，你还可以手动修改一下。左边可以看到16项修改参数，最上面是整体修改，你也可以根据自己的意愿单独修改某项，将鼠标放到选项上面，右边的预览图会显示相应的位置。";

textLabel只需要设置一个属性即可

self.textLabel.numberOfLines = 0;

使用基础数据类型当做参数

/** 
 如果想使用基础数据类型当做参数，Masonry为我们提供了"mas_xx"格式的宏定义。
 这些宏定义会将传入的基础数据类型转换为NSNumber类型，这个过程叫做封箱(Auto Boxing)。

 "mas_xx"开头的宏定义，内部都是通过MASBoxValue()函数实现的。
 这样的宏定义主要有四个，分别是mas_equalTo()、mas_offset()和大于等于、小于等于四个。
 */
[self.redView mas_makeConstraints:^(MASConstraintMaker *make) {
    make.center.equalTo(self.view);
    make.width.mas_equalTo(100);
    make.height.mas_equalTo(100);
}];

设置约束优先级

/** 
 Masonry为我们提供了三个默认的方法，priorityLow()、priorityMedium()、priorityHigh()，这三个方法内部对应着不同的默认优先级。
 除了这三个方法，我们也可以自己设置优先级的值，可以通过priority()方法来设置。
 */
[self.redView mas_makeConstraints:^(MASConstraintMaker *make) {
    make.center.equalTo(self.view);
    make.width.equalTo(self.view).priorityLow();
    make.width.mas_equalTo(20).priorityHigh();
    make.height.equalTo(self.view).priority(200);
    make.height.mas_equalTo(100).priority(1000);
}];

Masonry也帮我们定义好了一些默认的优先级常量，分别对应着不同的数值，优先级最大数值是1000。
static const MASLayoutPriority MASLayoutPriorityRequired = UILayoutPriorityRequired;
static const MASLayoutPriority MASLayoutPriorityDefaultHigh = UILayoutPriorityDefaultHigh;
static const MASLayoutPriority MASLayoutPriorityDefaultMedium = 500;
static const MASLayoutPriority MASLayoutPriorityDefaultLow = UILayoutPriorityDefaultLow;
static const MASLayoutPriority MASLayoutPriorityFittingSizeLevel = UILayoutPriorityFittingSizeLevel;

设置约束比例

// 设置当前约束值乘以多少，例如这个例子是redView的宽度是self.view宽度的0.2倍。
[self.redView mas_makeConstraints:^(MASConstraintMaker *make) {
    make.center.equalTo(self.view);
    make.height.mas_equalTo(30);
    make.width.equalTo(self.view).multipliedBy(0.2);
}];

小练习

子视图等高/等宽练习

/**
     下面的例子是通过给equalTo()方法传入一个数组，设置数组中子视图及当前make对应的视图之间等高。
     
     需要注意的是，下面block中设置边距的时候，应该用insets来设置，而不是用offset。
     因为用offset设置right和bottom的边距时，这两个值应该是负数，所以如果通过offset来统一设置值会有问题。
     */
    
    CGFloat padding = 10;
    
    UIView *redView = [[UIView alloc]init];
    redView.backgroundColor = [UIColor redColor];
    [self.view addSubview:redView];
    
    UIView *blueView = [[UIView alloc]init];
    blueView.backgroundColor = [UIColor blueColor];
    [self.view addSubview:blueView];
    
    UIView *yellowView = [[UIView alloc]init];
    yellowView.backgroundColor = [UIColor yellowColor];
    [self.view addSubview:yellowView];

    /**********  等高   ***********/
    [redView mas_makeConstraints:^(MASConstraintMaker *make) {
        make.left.right.top.equalTo(self.view).insets(UIEdgeInsetsMake(padding, padding, 0, padding));
        make.bottom.equalTo(blueView.mas_top).offset(-padding);
    }];
    [blueView mas_makeConstraints:^(MASConstraintMaker *make) {
        make.left.right.equalTo(self.view).insets(UIEdgeInsetsMake(0, padding, 0, padding));
        make.bottom.equalTo(yellowView.mas_top).offset(-padding);
    }];

    /**
     下面设置make.height的数组是关键，通过这个数组可以设置这三个视图高度相等。其他例如宽度之类的，也是类似的方式。
     */
    [yellowView mas_makeConstraints:^(MASConstraintMaker *make) {
        make.left.right.bottom.equalTo(self.view).insets(UIEdgeInsetsMake(0, padding, padding, padding));
        make.height.equalTo(@[blueView, redView]);
    }];

    /**********  等宽   ***********/
    [redView mas_makeConstraints:^(MASConstraintMaker *make) {
        make.top.left.bottom.equalTo(self.view).insets(UIEdgeInsetsMake(padding, padding, padding, 0));
        make.right.equalTo(blueView.mas_left).offset(-padding);
    }];
    [blueView mas_makeConstraints:^(MASConstraintMaker *make) {
        make.top.bottom.equalTo(self.view).insets(UIEdgeInsetsMake(padding, 0, padding, 0));
        make.right.equalTo(yellowView.mas_left).offset(-padding);
    }];
    [yellowView mas_makeConstraints:^(MASConstraintMaker *make) {
        make.top.bottom.right.equalTo(self.view).insets(UIEdgeInsetsMake(padding, 0, padding, padding));
        make.width.equalTo(@[redView, blueView]);
    }];

子视图垂直居中练习

CGFloat padding = 10;
    
    UIView *redView = [[UIView alloc]init];
    redView.backgroundColor = [UIColor redColor];
    [self.view addSubview:redView];
    
    UIView *blueView = [[UIView alloc]init];
    blueView.backgroundColor = [UIColor blueColor];
    [self.view addSubview:blueView];
    
    [redView mas_makeConstraints:^(MASConstraintMaker *make) {
        make.centerY.equalTo(self.view);
        make.left.equalTo(self.view).mas_offset(padding);
        make.right.equalTo(blueView.mas_left).mas_offset(-padding);
        //make.width.equalTo(blueView);
        make.height.mas_equalTo(150);
    }];
    
    [blueView mas_makeConstraints:^(MASConstraintMaker *make) {
        make.centerY.equalTo(self.view);
        make.right.equalTo(self.view).mas_offset(-padding);
        make.width.equalTo(redView);
        make.height.mas_equalTo(150);
    }];

转自：https://www.jianshu.com/p/587efafdd2b3

适配暗夜模式

iOS13新出现了暗夜模式，苹果新增了一些API方便我们来做适配。这里不做深入，只是稍微总结下。

适配暗夜模式，无非就是界面显示上的一些变化，暗夜模式下，主题由默认的白色调变为了深色调，相应的，我们的APP在显示上也需要做相应调整。主要包括两个方面：颜色的变化（视图颜色色，字体颜色等)和图片的改变；

• 关于颜色改变:UIcolor新增了一个分类\color{red}{UIColor (DynamicColors)}，提供了动态color的API。通过特征收集器traitCollection，可以动态判断当前手机的一些界面特征信息。

/*使用时可以做下进一步封装。*/
  [UIColor colorWithDynamicProvider:^UIColor * _Nonnull(UITraitCollection * _Nonnull traitCollection) {
        UIColor *color = [UIColor lightGrayColor];
        if (@available(iOS 13.0,*)) {
            if (traitCollection.userInterfaceStyle ==UIUserInterfaceStyleDark ) {
                color =[UIColor blackColor];//dark
            }else if(traitCollection.userInterfaceStyle ==UIUserInterfaceStyleLight){
                 color =[UIColor lightGrayColor];//light
            }
        }
        return color;
    }];

• 关于图片:可以在Assets.xcassets中给每一套图片设置对应的模式，系统自动根据当前的模式取用相应的图片；

• 监听模式的改变:做好以上两点只能部分满足需求，很多时候我们需要确切的知道当前的模式，并且知道用户什么时候切换的模式；

- (void)traitCollectionDidChange:(UITraitCollection *)previousTraitCollection{
    [super traitCollectionDidChange:previousTraitCollection];
    if ([UITraitCollection currentTraitCollection].userInterfaceStyle !=previousTraitCollection.userInterfaceStyle ) {
        NSLog(@"用户切换了模式，在这里做适配工作");
    }else{
        NSLog(@"用户没有切换模式");
    }
}

关于这种适配方式的几点看法：

• 工作繁琐，代码杂乱。界面如果需要做一些定制化的改变，就需要监听模式的改变，可能出现一个界面适配的代码出现在好几个地方。

• 扩展性不高。现在出现了一个暗夜模式，将来会不会再有其他模式？如果APP本来就有几套主题，那么适配起来更加繁琐杂乱。

• 细细想来，适配暗夜模式，不就是切换主题吗，单独给暗夜模式弄一套对应皮肤就完了。下面看看，如何给APP便捷高效、扩展性性高地换肤。

动态换肤（DynamicSkin）
代码简洁，便于维护；
自动适配暗夜模式，不需要自己每个界面去监听模式的切换；

使用步骤
1.引入框架，导入头文件
手动引入或者通过CocoaPods

pod 'DynamicSkin'

#import "DPDynamicTheme.h"

2.配置模型
继承DPThemeConfig，根据自己的需求，配置相应字段即可。

#import "DPThemeConfig.h"

NS_ASSUME_NONNULL_BEGIN

@interface TestConfig : DPThemeConfig
@property(nonatomic,copy)NSString*color1;
@property(nonatomic,copy)NSString*color2;
@property(nonatomic,copy)NSString*img1;
@property(nonatomic,copy)NSString*tabOne;
@property(nonatomic,copy)NSString*tabTwo;
@property(nonatomic,copy)NSString*tabThree;
@property(nonatomic,copy)NSString*tabTextColorNormal;
@property(nonatomic,copy)NSString*tabTextColorSelect;
@property(nonatomic,copy)NSString*state;
@end

NS_ASSUME_NONNULL_END

3.设置默认主题

__weak typeof (self)weakSelf = self;
//用户切换暗夜模式，或则主动切换pushCurrentThemme:，会触发该回调
    [self tz_dynamicTheme:^(TestConfig * _Nullable config) {
        [weakSelf.image sd_setImageWithURL:[NSURL URLWithString:config.img1]];
        weakSelf.statelabel.text = config.state;
    } WithIdentifier:NSStringFromClass([self class])];
}

4.数据绑定

__weak typeof (self)weakSelf = self;
//用户切换暗夜模式，或则主动切换pushCurrentThemme:，会触发该回调
    [self tz_dynamicTheme:^(TestConfig * _Nullable config) {
        [weakSelf.image sd_setImageWithURL:[NSURL URLWithString:config.img1]];
        weakSelf.statelabel.text = config.state;
    } WithIdentifier:NSStringFromClass([self class])];
}

5.销毁不需要的回调

-(void)dealloc{
  //identifer需要和当前界面绑定的保持一致
    [[DPThemeManager manager] removeUpdateWithIdentifer:NSStringFromClass([self class])];
}

转自：https://www.jianshu.com/p/50f24d5af4cd

一、SDWebImage的使用

1、SDWebImage的安装集成有2种方式：

（1）直接到github地址下载，链接https://github.com/rs/SDWebImage        

（2）用cocoapods安装，在文件夹生成的podfile文件中添加pod 'SDWebImage' ，终端cd + 文件位置，然后pod install即可

2、UITableView中导入头文件UIImageView+WebCache.h

[cell.imageView sd_setImageWithURL:[NSURL URLWithString:@"http://www.domain.com/path/to/image.jpg"] placeholderImage:[UIImage imageNamed:@"placeholder.png"]];

如果在加载完图片后，需要做些其他操作，可以使用block回调

[cell.imageView sd_setImageWithURL:[NSURL URLWithString:@"http://www.domain.com/path/to/image.jpg"]
                      placeholderImage:[UIImage imageNamed:@"placeholder.png"]
                             completed:^(UIImage *image, NSError *error, SDImageCacheType cacheType, NSURL *imageURL) {
                                 ... completion code here ...
                             }];

3、SDWebImageManager的使用

UIImageView(WebCache) 分类的核心在于 SDWebImageManager 的下载和缓存处理，SDWebImageManager将图片下载和图片缓存组合起来了。SDWebImageManager也可以单独使用。

SDWebImageManager *manager = [SDWebImageManager sharedManager];
[manager loadImageWithURL:imageURL
                      options:0
                     progress:^(NSInteger receivedSize, NSInteger expectedSize) {
                         // progression tracking code
                     }
                    completed:^(UIImage *image, NSError *error, SDImageCacheType cacheType, BOOL finished, NSURL *imageURL) {
                        if (image) {
                            // do something with image
                        }
                    }];

4、单独使用SDWebImageDownloader异步下载图片

我们还可以单独使用 SDWebImageDownloader 来下载图片，但是图片内容不会缓存。

SDWebImageDownloader *downloader = [SDWebImageDownloader sharedDownloader];
[downloader downloadImageWithURL:imageURL
                             options:0
                            progress:^(NSInteger receivedSize, NSInteger expectedSize) {
                                // progression tracking code
                            }
                           completed:^(UIImage *image, NSData *data, NSError *error, BOOL finished) {
                               if (image && finished) {
                                   // do something with image
                               }
                           }];

5、单独使用SDImageCache异步缓存图片

SDImageCache 支持内存缓存和异步的磁盘缓存（可选），如果你想单独使用 SDImageCache 来缓存数据的话，可以使用单例，也可以创建一个有独立命名空间的 SDImageCache 实例。

添加缓存的方法：

[[SDImageCache sharedImageCache] storeImage:myImage forKey:myCacheKey];

默认情况下，图片数据会同时缓存到内存和磁盘中，如果你想只要内存缓存的话，可以使用下面的方法：

[[SDImageCache sharedImageCache] storeImage:myImage forKey:myCacheKey toDisk:NO];

读取缓存时可以使用 queryDiskCacheForKey:done: 方法，图片缓存的 key 是唯一的，通常就是图片的 absolute URL。

SDImageCache *imageCache = [[SDImageCache alloc] initWithNamespace:@"myNamespace"];
[imageCache queryDiskCacheForKey:myCacheKey done:^(UIImage *image) {
        // image is not nil if image was found
    }];

6、自定义缓存key

有时候，一张图片的 URL 中的一部分可能是动态变化的（比如获取权限上的限制），所以我们只需要把 URL 中不变的部分作为缓存用的 key。

SDWebImageManager.sharedManager.cacheKeyFilter = ^(NSURL *url) {
            url = [[NSURL alloc] initWithScheme:url.scheme host:url.host path:url.path];
            return [url absoluteString];
        };

二、使用过程中常见问题

问题 1：使用 UITableViewCell 中的 imageView 加载不同尺寸的网络图片时会出现尺寸缩放问题。

解决方案： 

自定义 UITableViewCell，重写 -layoutSubviews 方法，调整位置尺寸； 
或者直接弃用 UITableViewCell 的 imageView，自己添加一个 imageView 作为子控件。

问题 2：图片刷新问题：SDWebImage 在进行缓存时忽略了所有服务器返回的 caching control 设置，并且在缓存时没有做时间限制，这也就意味着图片 URL 必须是静态的了，要求服务器上一个 URL 对应的图片内容不允许更新。但是如果存储图片的服务器不由自己控制，也就是说 图片内容更新了，URL 却没有更新，这种情况怎么办？

解决方案：在调用 sd_setImageWithURL: placeholderImage: options:方法时设置 options 参数为 SDWebImageRefreshCached，这样虽然会降低性能，但是下载图片时会照顾到服务器返回的 caching control。

问题 3：在加载图片时，如何添加默认的 progress indicator ？ 

解决方案：在调用 -sd_setImageWithURL:方法之前，先调用下面的方法：

[imageView sd_setShowActivityIndicatorView:YES]; 

[imageView sd_setIndicatorStyle:UIActivityIndicatorViewStyleGray];

问题4：如果在加载图片的过程中出现程序报错(App Transport Security has blocked a cleartext HTTP (http://) resource load since it is insecure. Temporary exceptions can be configured via your app's Info.plist file.)

你需要操作如下--------
(1)、在Info.plist中添加 NSAppTransportSecurity 类型 Dictionary ;

(2)、在 NSAppTransportSecurity 下添加 NSAllowsArbitraryLoads 类型Boolean ,值设为 YES;

三、SDWebImage底层原理

1）当我门需要获取网络图片的时候，我们首先需要的便是URL，获得URL后我们SDWebImage实现的并不是直接去请求网路，而是检查图片缓存中有没有和URl相关的图片，如果有则直接返回image，如果没有则进行下一步。

2）当图片缓存中没有图片时，SDWebImage依旧不会直从网络上获取，而是检查沙盒中是否存在图片，如果存在，则把沙盒中对应的图片存进image缓存中，然后按着第一步的判断进行。

3）如果沙盒中也不存在，则显示占位图，然后根据图片的下载队列缓存判断是否正在下载，如果下载则等待，避免二次下载。如果不存则创建下载队列，下载完毕后将下载操作从队列中清除，并且将image存入图片缓存中。

4）刷新UI（当然根据实际情况操作）将image存入沙盒缓存。

四、SDWebImage源码实现步骤

常见的四种加载方式

1、无占位图直接加载(如果缓存中存在改图片则直接获取无需重新下载增加磁盘缓存)

- (void)sd_setImageWithURL:(nullable NSURL *)url {
    [self sd_setImageWithURL:url placeholderImage:nil options:0 progress:nil completed:nil];
}

2、有占位图直接加载(如果URL加载不到则展示占位图,如果缓存中存在改图片则直接获取无需重新下载增加磁盘缓存)

- (void)sd_setImageWithURL:(nullable NSURL *)url placeholderImage:(nullable UIImage *)placeholder {
    [self sd_setImageWithURL:url placeholderImage:placeholder options:0 progress:nil completed:nil];
}

3、有占位图直接加载，并且实现图片加载完之后的Block可以继续完成下一步操作(如果URL加载不到则展示占位图,如果缓存中存在改图片则直接获取无需重新下载增加磁盘缓存)

- (void)sd_setImageWithURL:(nullable NSURL *)url placeholderImage:(nullable UIImage *)placeholder completed:(nullable SDExternalCompletionBlock)completedBlock {
    [self sd_setImageWithURL:url placeholderImage:placeholder options:0 progress:nil completed:completedBlock];
}

4、可以选择options的形式加载图片，(如果URL加载不到则展示占位图,如果缓存中存在改图片则直接获取无需重新下载增加磁盘缓存)

- (void)sd_setImageWithURL:(nullable NSURL *)url placeholderImage:(nullable UIImage *)placeholder options:(SDWebImageOptions)options {
    [self sd_setImageWithURL:url placeholderImage:placeholder options:options progress:nil completed:nil];
}

/*使用可更换optionsType的加载方式
 
                    -------------Options 枚举下的加载方式-----------
 SDWebImageRetryFailed 默认情况下，当URL无法下载时，URL就会被列入黑名单，这样库就不会继续尝试了。此标记禁用此黑名单。
 SDWebImageLowPriority  默认情况下，图像下载是在UI交互过程中启动的，这标志禁用该特性，导致在UIScrollView减速方面延迟下载。
 SDWebImageCacheMemoryOnly  此标记禁用磁盘缓存
 SDWebImageProgressiveDownload 此标志可以进行渐进式下载，在下载过程中，图像会逐步显示，就像浏览器所做的那样。默认情况下，图像只显示一次完全下载。
 SDWebImageRefreshCached  即使缓存了映像，也要尊重HTTP响应缓存控制，并在需要的情况下从远程位置刷新映像。磁盘缓存将由NSURLCache来处理，而不是使用SDWebImage，这会导致轻微的性能下降。这个选项有助于处理在同一个请求URL后面更改的图像，例如Facebook图形api概要图。如果刷新了缓存的图像，那么完成块就会被缓存的图像和最后的图像再次调用一次。只有当你不能用嵌入的缓存破坏参数使你的url静态时，才使用这个标志。
 SDWebImageContinueInBackground  在iOS 4+中，如果应用程序进入后台，可以继续下载图片。这是通过请求系统在后台获得额外的时间来完成请求完成的。如果后台任务过期，操作将被取消。
 SDWebImageHandleCookies 通过设置NSMutableURLRequest来处理存储在NSHTTPCookieStore中的cookie。HTTPShouldHandleCookies =是的;
 SDWebImageAllowInvalidSSLCertificates  启用不受信任的SSL证书。用于测试目的。在生产中使用谨慎。
 SDWebImageHighPriority 默认情况下，图像按顺序装载在队列中。这个标志把它们移到队列的前面。
 SDWebImageDelayPlaceholder  默认情况下，在图像加载时加载占位符图像。此标志将延迟加载占位符图像，直到图像完成加载。
 SDWebImageTransformAnimatedImage   我们通常不会在动画图像上调用transformdownloade昏暗委托方法，因为大多数转换代码会把它搞砸。无论如何，使用这个标志来转换它们。* /
 SDWebImageAvoidAutoSetImage  默认情况下，图像会在下载后添加到imageView中。但是在某些情况下，我们想要在设置图像之前有手(例如，应用一个过滤器或将它添加到交叉衰减动画中)使用这个标记如果你想在成功完成时手工设置图像
 SDWebImageScaleDownLargeImages  默认情况下，图像会被解码，以尊重它们原来的大小。在iOS上，这一标志将把图像缩小到与设备受限内存兼容的大小。*如果“SDWebImageProgressiveDownload”标志设置禁用缩减。
 */

以上四个常用方法，点击进去查看内部实现代码时，你会发现所有方法都指向------>

源码注释解释的含义是

用url、占位符和自定义选项设置imageView图像。下载是异步的和缓存的。
@param url是图像的url。
@param占位符将首先设置的图像，直到图像请求完成。
@param选择在下载图像时使用的选项。
@参见SDWebImageOptions用于可能的值。
@param progressBlock在下载@note时，在后台队列
@param completedBlock的后台进程中执行进程块，该块是在操作完成时被调用的。这个块没有返回值，并将所请求的UIImage作为第一个参数。在出现错误时，图像参数为nil，第二个参数可能包含一个NSError。第三个参数是一个布尔值，指示是否从本地缓存或网络检索图像。第四个参数是原始图像url。

下面是图解(上面展示了每句话的备注)

1、设置展位图，并且取消当前下载任务

2、创建一个新的下载操作

3、下载操作代码（判断流是否存在，如果不存在则将其存在失效列表中，防止重复下载无效流）-----在这里他对NSString和NSURL的转换做了判断。原因是(非常常见的错误是使用NSString对象而不是NSURL发送URL。出于某种奇怪的原因，Xcode不会对这种类型的不匹配发出任何警告。在这里，我们通过允许url作为NSString传递来确保这个错误。)括号当中是文档给出的解释，所以这里做了强制转换。

4、利用唯一生成的key,到缓存--->内存---->磁盘中分别寻找。

5、寻找的顺序 缓存---->磁盘---->在没有就下载

下载流程之后就是清理缓存(种类) 1、清理所有内存缓存镜像 2、清理所有磁盘缓存镜像3、清理过期的缓存映像从磁盘中删除

/*
     异步清除所有磁盘缓存映像。非阻塞方法-立即返回。@param完成一个应该在缓存过期后执行的块(可选)
     
     注意:这里要注意[[SDImageCache sharedImageCache] clearDisk];方法会报错，下面clearDiskOnCompletion的方法会替代上面的方法
     */
    [[SDImageCache sharedImageCache] clearDiskOnCompletion:^{
        
    }];
    
    /*
     Clear all memory cached images --->清除所有缓存镜像
     */
    [[SDImageCache sharedImageCache] clearMemory];
    
    /*
     异步将所有过期的缓存映像从磁盘中删除。非阻塞方法-立即返回。@param completionBlock在缓存过期后执行(可选)--->故名思义他是不能删除你当前缓存的大小的
     */
    [[SDImageCache sharedImageCache] deleteOldFilesWithCompletionBlock:^{
        
    }];

五、总结

SDWebImage加载图片的流程：
1. 入口 setImageWithURL:placeholderImage:options: 会先把 placeholderImage显示，然后 SDWebImageManager 根据 URL 开始处理图片。

2. 进入 SDWebImageManager-downloadWithURL:delegate:options:userInfo:，交给 SDImageCache 从缓存查找图片是否已经下载 queryDiskCacheForKey:delegate:userInfo:.

3. 先从内存图片缓存查找是否有图片，如果内存中已经有图片缓存，SDImageCacheDelegate回调 imageCache:didFindImage:forKey:userInfo: 到 SDWebImageManager。

4. SDWebImageManagerDelegate 回调 webImageManager:didFinishWithImage: 到 UIImageView+WebCache等前端展示图片。

5. 如果内存缓存中没有，生成 NSInvocationOperation添加到队列开始从硬盘查找图片是否已经缓存。

6. 根据 URLKey在硬盘缓存目录下尝试读取图片文件。这一步是在 NSOperation 进行的操作，所以回主线程进行结果回调 notifyDelegate:。

7. 如果上一操作从硬盘读取到了图片，将图片添加到内存缓存中（如果空闲内存过小，会先清空内存缓存）。SDImageCacheDelegate回调 imageCache:didFindImage:forKey:userInfo:。进而回调展示图片。

8. 如果从硬盘缓存目录读取不到图片，说明所有缓存都不存在该图片，需要下载图片，回调 imageCache:didNotFindImageForKey:userInfo:。

9. 共享或重新生成一个下载器 SDWebImageDownloader 开始下载图片。

10. 图片下载由 NSURLConnection来做，实现相关 delegate 来判断图片下载中、下载完成和下载失败。

11. connection:didReceiveData: 中利用 ImageIO做了按图片下载进度加载效果。

12. connectionDidFinishLoading: 数据下载完成后交给 SDWebImageDecoder 做图片解码处理。

13. 图片解码处理在一个 NSOperationQueue完成，不会拖慢主线程 UI。如果有需要对下载的图片进行二次处理，最好也在这里完成，效率会好很多。

14. 在主线程 notifyDelegateOnMainThreadWithInfo: 宣告解码完成，imageDecoder:didFinishDecodingImage:userInfo: 回调给 SDWebImageDownloader。

15. imageDownloader:didFinishWithImage: 回调给 SDWebImageManager告知图片下载完成

16. 通知所有的 downloadDelegates下载完成，回调给需要的地方展示图片。

17. 将图片保存到 SDImageCache中，内存缓存和硬盘缓存同时保存。写文件到硬盘也在以单独 NSInvocationOperation 完成，避免拖慢主线程。

18. SDImageCache 在初始化的时候会注册一些消息通知，在内存警告或退到后台的时候清理内存图片缓存，应用结束的时候清理过期图片。

19. SDWI 也提供了 UIButton+WebCache 和 MKAnnotationView+WebCache，方便使用。

20. SDWebImagePrefetcher 可以预先下载图片，方便后续使用。

原文链接：https://blog.csdn.net/qq_16146389/article/details/88355852

AFNetworking是封装的NSURLSession的网络请求。

AFNetworking由五个模块组成：

分别由NSURLSession,Security,Reachability,Serialization,UIKit五部分组成

NSURLSession：网络通信模块(核心模块) 对应 AFNetworking中的 AFURLSessionManager和对HTTP协议进行特化处理的AFHTTPSessionManager,AFHTTPSessionManager是继承于AFURLSessionmanager的
Security：网络通讯安全策略模块  对应 AFSecurityPolicy
Reachability：网络状态监听模块 对应AFNetworkReachabilityManager
Seriaalization：网络通信信息序列化、反序列化模块 对应 AFURLResponseSerialization
UIKit：对于IOSUIKit的扩展库

网络请求的过程：

创建NSURLSessionConfig对象--用创建的config对象配置初始化NSURLSession--创建NSURLSessionTask对象并resume执行，用delegate或者block回调返回数据。

AFURLSessionManager封装了上述网络交互功能

AFURLSessionManager请求过程

1.初始化AFURLSessionManager。

2.获取AFURLSessionManager的Task对象

3.启动Task

AFURLSessionManager会为每一个Task创建一个AFURLSessionmanagerTaskDelegate对象，manager会让其处理各个Task的具体事务，从而实现了manager对多个Task的管理

初始化好manager后，获取一个网络请求的Task，生成一个Task对象，并创建了一个AFURLSessionmanagerTaskDelegate并将其关联，设置Task的上传和下载delegate，通过KVO监听download进度和upload进度

NSURLSessionDelegate的响应

因为AFURLSessionmanager所管理的AFURLSession的delegate指向其自身，因此所有的NSURLSessiondelegate的回调地址都是AFURLSessionmanager，而AFURLSessionmanager又会根据是否需要具体处理会将AFdelegate所响应的delegate，传递到对应的AFdelegate去

面试相关：

AFN调用流程分析:

AFHTTPSessionManager: 发起网络请求(例如GET);
AFHTTPSessionManager内部调用dataTaskWithHTTPMethod:方法(内部处理requestSerializer);
dataTaskWithHTTPMethod内部调用父类AFURLSessionManager的dataTaskWithRequest: uploadProgress: downloadProgress: completionHandler方法;
AFURLSessionManager中的dataTaskWithRequest方法内部设置全局session和创建task;
AFURLSessionManager中的dataTaskWithRequest方法内部给task设置delegate(AFURLSessionManagerTaskDelegate);
taskDelegate代理的初始化: 绑定task / 存储task下载的数据 / 下载或上传进度 / 进度与task同步(KVO)
task对应的AFURLSessionManagerTaskDelegate实现对进度处理、Block调用、Task完成返回数据的拼装的功能等;
setDelegate: forTask: 加锁设置通过一个字典处理Task与之代理方法关联; 添加对Task开始、重启、挂起状态的通知的接收.
[downloadTask resume]后执行开始, 走代理回调方法(内部其实是NSURLSession的各种代理的实现);
task完成后走URLSession: task: didCompleteWithError: 回调对返回的数据进行封装;
同时移除对应的task; removeDelegateForTask: 加锁移除8中的字典和通知;

AFN请求过程梳理

首先我们是初始化了AFHTTPSessionManager类（往往创建单例）初始化时候指定请求回调的代理是父类（AFURLSessionManager）。之后当我们发出一个请求后，先创建一个AFURLSessionManagerTaskDelegate对象来保存请求结果回调。并把该对象放到一个全局字典中来保存（以task.taskIdentifier为key），再启动请求。当AFURLSessionManager类收到了请求结果后根据task.taskIdentifier从全局字典中取出当前请求的AFURLSessionManagerTaskDelegate对象。然后调用AFURLSessionManagerTaskDelegate的对象方法处理请求，完成回调。之后再从全局字典中移除该AFURLSessionManagerTaskDelegate对象。

AFN是怎样来解决循环引用的

首先我们用AFN时候往往是用单例，因此调用类不会直接持有该AFHTTPSessionManager对象。
该AFHTTPSessionManager对象持有block，该AFHTTPSessionManager对象持有全局字典，该全局字典持有AFURLSessionManagerTaskDelegate对象，该AFURLSessionManagerTaskDelegate对象持有block，这是一个循环引用。
当AFURLSessionManagerTaskDelegate对象block进行回调后，从全局字典中移除该对象。从而打破引用环。

1、AFN2.x为什么添加一条常驻线程？

AFN2.0里面把每一个网络请求的发起和解析都放在了一个线程里执行。正常来说，一个线程执行完任务后就退出了。开启runloop是为了防止线程退出。一方面避免每次请求都要创建新的线程；另一方面，因为connection的请求是异步的，如果不开启runloop，线程执行完代码后不会等待网络请求完的回调就退出了，这会导致网络回调的代理方法不执行。
这是一个单例，用NSThread创建了一个线程，并且为这个线程添加了一个runloop，并且加了一个NSMachPort，来防止runloop直接退出。 这条线程就是AF用来发起网络请求，并且接受网络请求回调的线程，仅仅就这一条线程

2、AFN3.x为什么不再需要常驻线程？

NSURLConnection的一大痛点就是：发起请求后，这条线程并不能随风而去，而需要一直处于等待回调的状态。
苹果也是明白了这一痛点，从iOS9.0开始 deprecated 了NSURLConnection。 替代方案就是NSURLSession。

3、为什么AF3.0中需要设置self.operationQueue.maxConcurrentOperationCount = 1;而AF2.0却不需要？

功能不一样：AF3.0的operationQueue是用来接收NSURLSessionDelegate回调的，鉴于一些多线程数据访问的安全性考虑，设置了maxConcurrentOperationCount = 1来达到串行回调的效果。
而AF2.0的operationQueue是用来添加operation并进行并发请求的，所以不要设置为1。

AFNetworking3.0

在AFNetworking 3.0之前，底层是通过封装NSURLConnection来实现的。
在AFNetworking 3.0之后，也就是在iOS 9.0 之后，NSURLConnection被弃用，苹果推荐使用NSURLSession来管理网络请求，所以AFNetworking 3.0之后，底层是通过封装NSURLSession来实现的。

从AFNetworking 3.0中之后，下面三个方法被弃用了。
AFURLConnectionOperation
AFHTTPRequestOperation
AFHTTPRequestOperationManager

依次被下面三个类代替了，同时请求方法也跟着改变了，所以AFNetworking 3.0以后发生了很大的变化。
AFURLSessionManager
AFHTTPSessionManager
AFNetworkReachabilityManager

参考链接：https://blog.csdn.net/songzhuo1991/article/details/104883981

参考链接：https://blog.csdn.net/weixin_39638526/article/details/111748124

一. YYModel逻辑结构 

1.Model 属性名和 JSON 中的 Key 不相同

// JSON:
{
    "n":"Harry Pottery",
    "p": 256,
    "ext" : {
        "desc" : "A book written by J.K.Rowing."
    },
    "ID" : 100010
}
 
// Model:
@interface Book : NSObject
@property NSString *name;
@property NSInteger page;
@property NSString *desc;
@property NSString *bookID;
@end
@implementation Book
//返回一个 Dict，将 Model 属性名对映射到 JSON 的 Key。
+ (NSDictionary *)modelCustomPropertyMapper {
    return @{@"name" : @"n",
             @"page" : @"p",
             @"desc" : @"ext.desc",
             @"bookID" : @[@"id",@"ID",@"book_id"]};
}
@end

你可以把一个或一组 json key (key path) 映射到一个或多个属性。如果一个属性没有映射关系，那默认会使用相同属性名作为映射。
在 json->model 的过程中：如果一个属性对应了多个 json key，那么转换过程会按顺序查找，并使用第一个不为空的值。

在 model->json 的过程中：如果一个属性对应了多个 json key (key path)，那么转换过程仅会处理第一个 json key (key path)；如果多个属性对应了同一个 json key，则转换过过程会使用其中任意一个不为空的值。

2.Model 包含其他 Model

// JSON
{
    "author":{
        "name":"J.K.Rowling",
        "birthday":"1965-07-31T00:00:00+0000"
    },
    "name":"Harry Potter",
    "pages":256
}
 
// Model: 什么都不用做，转换会自动完成
@interface Author : NSObject
@property NSString *name;
@property NSDate *birthday;
@end
@implementation Author
@end
 
@interface Book : NSObject
@property NSString *name;
@property NSUInteger pages;
@property Author *author; //Book 包含 Author 属性
@end
@implementation Book
@end

3.容器类属性

@class Shadow, Border, Attachment;
 
@interface Attributes
@property NSString *name;
@property NSArray *shadows; //Array
@property NSSet *borders; //Set
@property NSMutableDictionary *attachments; //Dict
@end
 
@implementation Attributes
// 返回容器类中的所需要存放的数据类型 (以 Class 或 Class Name 的形式)。
+ (NSDictionary *)modelContainerPropertyGenericClass {
    return @{@"shadows" : [Shadow class],
             @"borders" : Border.class,
             @"attachments" : @"Attachment" };
}
@end

在实际使用过过程中，[Shadow class]，Border.class，@"Attachment"没有明显的区别。
这里仅仅是创建作者有说明，实际使用时，需要对其遍历，取出容器中得字典，然后继续字典转模型。

（YYModel的核心是通过runtime获取结构体中得Ivars的值，将此值定义为key,然后给key赋value值，所以我们需要自己遍历容器（NSArray，NSSet，NSDictionary），获取每一个值，然后KVC）。

具体的代码实现如下：

NSDictionary *json =[self getJsonWithJsonName:@"ContainerModel"];
ContainerModel *containModel = [ContainerModel yy_modelWithDictionary:json];
NSDictionary *dataDict = [containModel valueForKey:@"data"];
//定义数组，接受key为list的数组
self.listArray = [dataDict valueForKey:@"list"]; 
 //遍历数组
[self.listArray enumerateObjectsUsingBlock:^(id  _Nonnull obj, NSUInteger idx, BOOL * _Nonnull stop) {
        NSDictionary *listDict = obj;
        //获取数组中得字典
        List *listModel = [List yy_modelWithDictionary:listDict];
        //获取count 和 id
        NSString *count = [listModel valueForKey:@"count"];
        NSString *id = [listModel valueForKey:@"id"];

4.黑名单与白名单

@interface User
@property NSString *name;
@property NSUInteger age;
@end
 
@implementation Attributes
// 如果实现了该方法，则处理过程中会忽略该列表内的所有属性
+ (NSArray *)modelPropertyBlacklist {
    return @[@"test1", @"test2"];
}
// 如果实现了该方法，则处理过程中不会处理该列表外的属性。
+ (NSArray *)modelPropertyWhitelist {
    return @[@"name"];
}
@end

5.数据校验与自定义转换

实际这个分类的目的比较简单和明确。
就是对判断是否为时间戳，然后对时间戳进行处理，调用
_createdAt = [NSDate dateWithTimeIntervalSince1970:timestamp.floatValue];
获取时间。

// JSON:
{
    "name":"Harry",
    "timestamp" : 1445534567     //时间戳
}
 
// Model:
@interface User
@property NSString *name;
@property NSDate *createdAt;
@end
 
@implementation User
// 当 JSON 转为 Model 完成后，该方法会被调用。
// 你可以在这里对数据进行校验，如果校验不通过，可以返回 NO，则该 Model 会被忽略。
// 你也可以在这里做一些自动转换不能完成的工作。
- (BOOL)modelCustomTransformFromDictionary:(NSDictionary *)dic {
    NSNumber *timestamp = dic[@"timestamp"];
    if (![timestamp isKindOfClass:[NSNumber class]]) return NO;
    _createdAt = [NSDate dateWithTimeIntervalSince1970:timestamp.floatValue];
    return YES;
}
 
// 当 Model 转为 JSON 完成后，该方法会被调用。
// 你可以在这里对数据进行校验，如果校验不通过，可以返回 NO，则该 Model 会被忽略。
// 你也可以在这里做一些自动转换不能完成的工作。
- (BOOL)modelCustomTransformToDictionary:(NSMutableDictionary *)dic {
    if (!_createdAt) return NO;
    dic[@"timestamp"] = @(n.timeIntervalSince1970);
    return YES;
}
@end

• 需要注意的时，如果用插件，对时间戳类型或默认创建为NSUInteger类型，需要将其更改为NSDate类型。

以下方法都是YYModel的简单封装，实际使用过程和系统方法区别不大。对其感兴趣的可以点进方法内部查看。

@interface YYShadow :NSObject 
@property (nonatomic, copy) NSString *name;
@property (nonatomic, assign) CGSize size;
@end
 
@implementation YYShadow
// 直接添加以下代码即可自动完成
- (void)encodeWithCoder:(NSCoder *)aCoder { 
 [self yy_modelEncodeWithCoder:aCoder]; 
}
- (id)initWithCoder:(NSCoder *)aDecoder {
  self = [super init];
  return [self yy_modelInitWithCoder:aDecoder]; 
}
- (id)copyWithZone:(NSZone *)zone { 
 return [self yy_modelCopy]; 
}
- (NSUInteger)hash { 
 return [self yy_modelHash]; 
}
- (BOOL)isEqual:(id)object { 
 return [self yy_modelIsEqual:object]; 
}
- (NSString *)description { 
 return [self yy_modelDescription]; 
}
@end

原文链接：https://blog.csdn.net/huhui168/article/details/80541387

数据结构的分类

数据结构是指相互之间存在着一种或多种关系的数据元素的集合和该集合中数据元素之间的关系组成

简单来说：数据结构是以某种特定的布局方式存储数据的容器。这种“布局方式”决定了数据结构对于某些操作是高效的，而对于其他操作则是低效的。首先我们需要理解各种数据结构，才能在处理实际问题时选取最合适的数据结构。

常用的数据结构有：数组，栈，链表，队列，树，图，堆，散列表等

1、数组

数组是可以再内存中连续存储多个元素的结构，在内存中的分配也是连续的，数组中的元素通过数组下标进行访问，数组下标从0开始

NSArray *array = [NSArray arrayWithObjects:@"1",@"2",@"3",@"4", nil];
//    NSArray *array = @[@"1",@"2",@"3",@"4"];
NSLog(@"%@",array[0]);

优点：

• 1、按照索引查询元素速度快
• 2、按照索引遍历数组方便

缺点：

• 1、数组的大小固定后就无法扩容了
• 2、数组只能存储一种类型的数据
• 3、添加，删除的操作慢，因为要移动其他的元素。

适用场景：

• 频繁查询，对存储空间要求不大，很少增加和删除的情况。

2、栈

栈是一种特殊的线性表，仅能在线性表的一端操作，栈顶允许操作，栈底不允许操作。栈的特点是：先进后出，或者说是后进先出，从栈顶放入元素的操作叫入栈，取出元素叫出栈

线性表是最基本、最简单、也是最常用的一种数据结构。线性表（linear list）是数据结构的一种，一个线性表是n个具有相同特性的数据元素的有限序列。

线性表中数据元素之间的关系是一对一的关系，即除了第一个和最后一个数据元素之外，其它数据元素都是首尾相接的（注意，这句话只适用大部分线性表，而不是全部。比如，循环链表逻辑层次上也是一种线性表（存储层次上属于链式存储），但是把最后一个数据元素的尾指针指向了首位结点）

3、队列

队列与栈一样，也是一种线性表，不同的是，队列可以在一端添加元素，在另一端取出元素，也就是：先进先出。从一端放入元素的操作称为入队，取出元素为出队

4、链表

链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构，操作复杂。由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时间，而线性表和顺序表相应的时间复杂度分别是O(logn)和O(1)。

根据指针的指向，链表能形成不同的结构，例如单链表，双向链表，循环链表等。

双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。

、

链表的优点：

• 链表是很常用的一种数据结构，不需要初始化容量，可以任意加减元素；
• 添加或者删除元素时只需要改变前后两个元素结点的指针域指向地址即可，所以添加，删除很快；

缺点：

• 因为含有大量的指针域，占用空间较大；
• 查找元素需要遍历链表来查找，非常耗时。

适用场景：

• 数据量较小，需要频繁增加，删除操作的场景

5、树

树是一种数据结构，它是由n（n>=1）个有限节点组成一个具有层次关系的集合。把它叫做 “树” 是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点：

6、散列表

散列表，也叫哈希表，是根据关键码和值 (key和value) 直接进行访问的数据结构，通过key和value来映射到集合中的一个位置，这样就可以很快找到集合中的对应元素。

记录的存储位置=f(key)

• 这里的对应关系f 成为散列函数，又称为哈希 (hash函数)，而散列表就是把Key通过一个固定的算法函数既所谓的哈希函数转换成一个整型数字，
• 然后就将该数字对数组长度进行取余，取余结果就当作数组的下标
• 将value存储在以该数字为下标的数组空间里
• 这种存储空间可以充分利用数组的查找优势来查找元素，所以查找的速度很快。

哈希表在应用中也是比较常见的，就如Java中有些集合类就是借鉴了哈希原理构造的，例如HashMap，HashTable等，利用hash表的优势，，对于集合的查找元素时非常方便的，然而，因为哈希表是基于数组衍生的数据结构，在添加删除元素方面是比较慢的，所以很多时候需要用到一种数组链表来做，也就是拉链法。拉链法是数组结合链表的一种结构，较早前的hashMap底层的存储就是采用这种结构，直到jdk1.8之后才换成了数组加红黑树的结构.iOS中weak表（弱引用表）就是典型的哈希表

• 左边很明显是个数组，数组的每个成员包括一个指针，指向一个链表的头，
• 当然这个链表可能为空，也可能元素很多。
• 我们根据元素的一些特征把元素分配到不同的链表中去，
• 也是根据这些特征，找到正确的链表，再从链表中找出这个元素。

堆是一种比较特殊的数据结构，可以被看做一棵树的数组对象，具有以下的性质：

• 堆中某个节点的值总是不大于或不小于其父节点的值；
• 堆总是一棵完全二叉树。

将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。常见的堆有二叉堆、斐波那契堆等。

堆的定义如下：n个元素的序列{k1,k2,ki,…,kn}当且仅当满足下关系时，称之为堆。

(ki <= k2i,ki <= k2i+1)或者(ki >= k2i,ki >= k2i+1), (i = 1,2,3,4…n/2)，
满足前者的表达式的成为小顶堆，满足后者表达式的为大顶堆，这两者的结构图可以用完全二叉树排列出来

8、图

图型结构也称图案，指个体目标重复排列的空间形式。图案反映了地物的空间分布特征，它可以是自然的，也可以是人为构造的 [1] 图形结构，简称“图”，是一种复杂的数据结构。图形结构中，每个结点的前驱结点数和后续结点数可以任意多个。

数据元素间的关系是任意的。其他数据结构(如树、线性表等)都有明确的条件限制，而图形结构中任意两个数据元素间均可相关联。常用来研究生产流程、施工计划、各种网络建设等问题。

前言
这一篇博客是很早之前写的，是关于一些链表和二叉树面试相关的问题，算是整理吧，网上这部分的答案也很多，希望能给大家一些帮助。
注意:本文中一些异常情况都是没有做处理的,例如NULL等等,只是给出了基本的解决方案.大家参考一下.

链表部分
问题:定义并且创建一个链表.
解题方案:
我们首先要如何定义一个结构体,下面的构造方案我是使用的递归的形式来构造一个结构体,注意不要忘记分配内存.其他的方面都比较简单,难度较低.
代码示例:

#include <stdio.h>

typedef struct ListNode {
    int data;
    struct ListNode*nextNode;
}ListNode;

ListNode* createListNodeAction(int *listArray, int index, int length) {
    ListNode *listNode = (ListNode *) malloc(sizeof (ListNode) );
    ListNode *nextNode = NULL;
    int i = listArray[index];
    listNode->data = i;
    if (index != length - 1) {
        nextNode = (ListNode*) malloc(sizeof (ListNode));
        nextNode = createListNodeAction(listArray, index + 1, length);
    }
    listNode->nextNode = nextNode;
    return listNode;
}

问题:不通过遍历删除链表中的非尾节点.

解题方案:
首先我们要知道我们如何通过遍历删除链表中的某个节点? 通过遍历我们可以知道要删除的链表节点前驱(也就是前一个节点),然后我们把前驱的nextNode指向要删除的节点的nextNode,释放要删除的节点即可.示意图如下所示.

那么我们对于上面的那个题目,我们该如何解决呢?由于前驱不通过遍历我们是拿不到的,所以我们只能通过覆盖的形式,用nextNode节点的属性覆盖掉需要删除的节点,然后释放nextNode节点,这样就完成了删除工作,由于前驱的nextNode指针属性不通过遍历修改不了,所以不能删除尾节点.否则就会有野指针问题出现.

void deleteListNodeNotTail(ListNode *deleteNode) {
  
    ListNode *deleteNextNode = deleteNode->nextNode;
    deleteNode->data = deleteNextNode->data;
    deleteNode->nextNode = deleteNextNode->nextNode;
    free(deleteNextNode);
}

问题:只遍历一次就找到链表中的中间节点.

解题方案:
撇开题目不谈,我们首先要清楚如何确定链表中的中间节点?由于链表没有长度的属性,所以暴力法的做法就是先遍历一次确定链表的长度,然后再次遍历链表找到中间节点.时间复杂度为O(logn+n).
那么如何通过一次遍历来找到链表中的中间节点呢?我们的解决方案是我们需要一快一慢两个移动节点fathNode和slowNode,fathNode的偏移速度是slowNode的两倍,,所以当fathNode == NULL,slowNode正好处于中心节点上.时间复杂度为O(logn).
代码示例:

ListNode* getListHalfNode(ListNode *listNode) {
    
    ListNode *fathNode = listNode->nextNode;
    ListNode *slowNode = listNode;

    while (fathNode) {
        fathNode = fathNode->nextNode->nextNode;
        slowNode = slowNode->nextNode;
    }
    return slowNode;
}

问题:如何找到单向链表中的倒数第i个节点(i >= 1).

解题方案:
暴力法该如何解决这种问题呢?我们先遍历一遍确定链表的长度length,再次遍历链表取得下标位置在length-1-k的节点就是我们要的节点.时间复杂度为O(logn+n).
那没有有没有优化方式呢?这是有的,仍然借助上一个问题的解决方案,我们需要一快一慢两个移动节点fathNode和slowNode,fathNode先偏移i个位置,然后两个节点同时进行移动,所以当fathNode == NULL,slowNode正好处于倒数.时间复杂度为O(2logn).
代码示例:

ListNode* getListNodeWithLast(ListNode *listNode,int i) {
    
    ListNode *fathNode = listNode;
    ListNode *slowNode = listNode;
    
    while (i) {
        fathNode = fathNode->nextNode;
        i--;
    }
    
    while (fathNode) {
        fathNode = fathNode->nextNode;
        slowNode = slowNode->nextNode;
    }
    return slowNode;
}

问题:删除倒数第i个结点(i>=1),不能用替换删除法.

解题方案:
上面我们已经了解了替换删除法,不需要知道前驱,我们就可以使用覆盖替换的方式删除节点,而这次我们可以是知道前驱节点的,而且结合上一次的快慢节点的方式,我们只需要先找到前驱节点即可.也就是fathNode节点需要先移动i + 1 次,具体代码如下所示.
代码示例:

void deleteListNodeWithLast(ListNode *listNode,int i) {
    
    ListNode *fathNode = listNode;
    ListNode *slowNode = listNode;
    
    while (i + 1) {
        fathNode = fathNode->nextNode;
        i--;
    }
    
    while (fathNode) {
        fathNode = fathNode->nextNode;
        slowNode = slowNode->nextNode;
    }
    
    ListNode *deleteNode = slowNode->nextNode;
    ListNode *deleteNextNode = deleteNode->nextNode;
    slowNode->nextNode = deleteNextNode;
    free(deleteNode);
}

问题:约瑟夫问题

约瑟夫环(约瑟夫问题)是一个数学的应用问题：已知n个人(以编号1，2，3…n分别表示)围坐在一张圆桌周围。从编号为k的人开始报数，数到m的那个人出列;他的下一个人又从1开始报数，数到m的那个人又出列;依此规律重复下去，直到圆桌周围的人全部出列。通常解决这类问题时我们把编号从0~n-1，最后结果+1即为原问题的解。
解题方案:
使用链表该如何解决约瑟夫问题呢?我们需要把链表做成一个环,也就是我们需要遍历一遍找到尾节点,并且制定尾节点的nextNode指针指向链表的第一个节点,这样我们就把链表做成了一个环.
然后我们假设每i次删除一个节点,这样返回的删除,直到只剩最后一个节点就是我们要求的解.
代码示例:

ListNode* JocephCircle(ListNode *firstNode, int k) {
    
    ListNode *endNode = firstNode;
    ListNode *resultNode = firstNode;
    ListNode *deleteNode = NULL;
    
    // 做环
    while (endNode->nextNode) {
        endNode = endNode->nextNode;
    }
    endNode->nextNode = firstNode;

    // 自身的nextNode指向自身的时候,就只剩下一个元素了
    while (resultNode->nextNode != resultNode) {
        
        //删除节点 ,先找到前驱节点,然后找到删除节点
        //由于先执行赋值操作,再进行i-1操作,所以k-1,由于是找删除节点的前驱节点,所以还需要-1.
        int i = (k-1)-1;
        while (i) {
            resultNode = resultNode->nextNode;
            i--;
        }
        
        // 重新指向并且释放删除节点
        deleteNode = resultNode->nextNode;
        resultNode->nextNode = resultNode->nextNode->nextNode;
        free(deleteNode);
        resultNode = resultNode->nextNode;
    }
    
    return resultNode;
}

问题:单链表的冒泡排序问题

解题方案:
仿照普通的数组遍历,这里两个while进行实现简单的冒泡排序.判断条件为nextNode节点是否为NULL,即可知道是否已经到达了单链表的尾节点.这个问题如果不做任何优化的话就如同下面代码演示的即可.其他优化方式就不过多阐述,上网查询即可.
代码示例:

void sortNodeListAction(ListNode *firstNode) {
 
    ListNode *nowNode = firstNode;
    ListNode *exchangeNode = (ListNode *)malloc(sizeof(ListNode));
    
    while (nowNode->nextNode) {
        ListNode *nowNextNode = nowNode;
        while (nowNextNode) {
            if (nowNextNode->data < nowNode->data) {
                exchangeNode->data = nowNextNode->data;
                nowNextNode->data = nowNode->data;
                nowNode->data = exchangeNode->data;
            }
            nowNextNode = nowNextNode->nextNode;
            if (!nowNextNode) {
                continue;
            }
        }
        nowNode = nowNode->nextNode;
    }
    free(exchangeNode);
}

问题:判断链表是否带环；若带环，求环的长度和入口点

解题方案:
这里我们要首先明白什么叫做带环,如下图所示,不管是哪种表现形式,我们都说当前链表是带环的链表.

我们了解了什么叫链表带环.在代码中,我们该如何判断当前的链表是否带环呢?网上有一种方案就是使用快慢节点解决,设置fathNode和slowNode,fathNode的偏移速度是slowNode的两倍,所以当fathNode == NULL,那么可以断定链表不带环,假设在某一个时刻fathNode==slowNode,说明两个节点重合,也就是说链表带环.
那么带环的链表我们该如何判断其环的长度呢?首先我们要知道fathNode偏移速度是slowNode的两倍,也就是说相同时间内,fathNode偏移距离是slowNode的2倍.
我们要说明两个节点交汇的情况,两者的情况肯定是慢节点在换上走不到一圈就会进行交汇,有人会问这是为什么呢?因为fathNode偏移速度是slowNode的两倍,所以在两者起点相同的情况下slowNode走完一圈fathNode走完两圈内,两者是必然相交的.
根据上面的两种情形,如下图所示.当两点相交时,我们有以下的结论,fathNode走过的路程为L + (C + A) + A,slowNode走过的路程为L + A, 我们得出 (L + A) x 2 = L + (C + A) + A;所以L = C.这时候我们继续定义一个新的节点enterNode从头开始出发,slowNode同时出发,两者速度相同,同时L = C;所以我们知道两者相交的节点必然是环的入口点.这时候enterNode再走到b点,就可以计算出环的长度了.

代码示例:

// 判断是否有环
bool isExistLoop(ListNode* firstNode)  {  
    ListNode *fastNode;
    ListNode * slowNode;
    fastNode = slowNode = firstNode;
    while (slowNode != NULL && fastNode -> next != NULL)  {  
        slowNode = slowNode -> next ;
        fastNode = fastNode -> next -> next ; 
        if (slowNode == fastNode) 
            return true ;  
    }  
    return false ;  
}

// 判断环的长度
int getLoopLength(ListNode* firstNode){
    ListNode* slowNode = firstNode;
    ListNode* fastNode = firstNode;
    while ( fastNode && fastNode ->next ){
        slowNode = slowNode->next;
        fastNode = fastNode->next->next;
        if ( slowNode== fastNode) {
            break;
         }
    }
    slowNode= slowNode->next;
    fastNode = fastNode->next->next;
    int length = 1; 
    while ( fastNode != slowNode)
    {
        slowNode = slowNode->next;
        fastNode = fastNode->next->next;
        length ++; 
    }
    return length;
}

// 找到环中的相遇节点
ListNode* getMeetingNode(ListNode* firstNode) {
    ListNode* fastNode;
    ListNode* slowNode;
    slowNode = fastNode = firstNode;
    while (slowNode != NULL && fastNode-> next != NULL) {  
        slowNode = slowNode-> next ;
        fastNode = fastNode-> next -> next ;
        if (slowNode == fastNode)
            return slowNode;  
    }  

    //到达末尾仍然没有相遇，则不存在环
    return NULL ;
}
// 找出环的入口节点
ListNode* getEntryNodeOfLoop(ListNode* firstNode) {
    ListNode* meetingNode = getMeetingNode(firstNode); // 先找出环中的相遇节点
    if (meetingNode == NULL)
        return NULL;
    ListNode* p1 = meetingNode;
    ListNode* p2 = pHead;
    while (p1 != p2) {
        p1 = p1->next;
        p2 = p2->next;
    }
    return p1;
}

如果可以使用字典或者集合的话,那就更简单了;数组也是可以解决,但是效率不是太高.需要多次遍历.

总结

OK,写到这里基本上就结束了，先整理这些后期会持续更新，欢迎大家指导批评，谢谢。。。

转自：https://www.jianshu.com/p/cf89d05c8f30

Xcode：Version 11.3.1 (11C504)
Swift：5.0
iOS项目地址
Flutter项目创建

cd some/path/
flutter create --template module flutter_yyframework