react的组件设计有很多模式。下面列举几种常见的：

完全受控组件

这种组件设计的特点是，组件的所有state和action都来自props，组件自身没有状态，只负责展示UI层。model层完全交给全局状态管理库比如redux或mobx。不推荐这种组件设计，因为后期不好维护。这是典型的滥用全局状态管理库的现象。

什么叫滥用全局状态管理库？

就是没有认识到状态管理库的作用，或者说我们什么时候需要状态管理库？

拿 react 来说，react 是有组内状态的，状态可以通过 props 传递。但是，但当 app 比较庞大的时候，兄弟组件，远亲组件这些的交流就变得困难起来，
它们必须依赖相同的父组件来完成信息的传递。这时，就是我们使用状态管理库的时候。

但是，很多人把所有状态都往 redux 里面丢，虽然这方便了开发，但缺点却很明显:

1. 组件很难复用：因为状态只有一份。
2. 耦合度高：根据高内聚低耦合的设计原则，一个模块应该有独立的功能，不依赖外部，在内部实现复杂度，只暴露接口来与外界交流。但如果把组内的一些状态放在全局 model，就提供了让其他组件修改的能力，并且代码没有内聚。

非受控组件

划分好状态的等级，尽量把状态放在组件内。当遇到共享组内状态困难的场景时，提升状态到全局状态管理库。

这种组件，有view层、model层、services层。因为它是有独立功能的，然后通过向外界暴露api来提供自己的能力，同时把复杂度隐藏在内部。

例如一个列表组件：

// 方案一

// ListDemo.jsx

import React,{useEffect} from 'react';

import {getData} from 'services/api';



export default function ListDemo({requestId}){

  // model

  const [data,setData] = useState([]);

  const [visible,setVisible] = useState(false);



  useEffect(()=>{

    // services 层

    getData().then(data=>{

      setData(data)

    });

    /**

     * 当requestId变化时，列表会重新请求

     * 这里的requestId是组件向外界暴露的一个api

     **/

  },[requestId])



  useEffect(()=>{

    if(visible===true){

      // clearState

      setVisible(false);

    }

  },[requestId])



  return (

    // view

    <div>

      {

        data.map(item=><li>{item}</li>

      }

      {

        visible && (

          <div>

            this is a modal

          </div>

        )

      }

    </div>

    )

  )

}



// app.jsx

<ListDemo />

这种组件设计的特点是，组件可以重置自身状态的时机是由自身控制的。如果你觉得这样麻烦，你可以把重置自身状态的时机交给外部，通过key来 “销毁组件”=>“重新渲染组件”。上面的代码可以简化成：

// 方案二

// ListDemo.jsx

import React,{useEffect} from 'react';

import {getData} from 'services/api';



export default function ListDemo({requestId}){

  // model

  const [data,setData] = useState([]);

  const [visible,setVisible] = useState(false);



  useEffect(()=>{

    // services 层

    getData().then(data=>{

      setData(data)

    });

  },[])



  return (

    // view

    <div>

      {

        data.map(item=><li>{item}</li>

      }

      {

        visible && (

          <div>

            this is a modal

          </div>

        )

      }

    </div>

    )

  )

}



// app.jsx

/*

*当requestId变化时，ListDemo会重新渲染

*/

<ListDemo key={requestId} />

方案二的代码比较整洁，且出错率比方案一低，但是方案二存在重新渲染组件的一个环节，性能开支会比方案一多一点点（大部分情况你都可以忽略不计）。

很多情况下，我们应该采用方案二。

原文：https://zhuanlan.zhihu.com/p/88593781

本篇为转译，原出处。

当你在代码中写了var moment = require('moment') 然后再用webpack打包, 打出来的包会比你想象中的大很多，因为打包结果包含了各地的local文件.

解决方案是下面的两个webpack插件，任选其一:

1. IgnorePlugin
2. ContextReplacementPlugin

方案一：使用 IgnorePlugin插件

IgnorePlugin的原理是会移除moment的所有本地文件，因为我们很多时候在开发中根本不会使用到。 这个插件的使用方式如下：

const webpack = require('webpack');

module.exports = {

  //...

  plugins: [

    // 忽略 moment.js的所有本地文件

    new webpack.IgnorePlugin(/^\.\/locale$/, /moment$/),

  ],

};

那么你可能会有疑问，所有本地文件都被移除了，但我想要用其中的一个怎么办。不用担心，你依然可以在代码中这样使用：

const moment = require('moment');

require('moment/locale/ja');



moment.locale('ja');

...

这个方案被用在 create-react-app.

方案二：使用 ContextReplacementPlugin

这个方案其实跟方案一有点像。原理是我们告诉webpack我们会使用到哪个本地文件，具体做法是在插件项中这样添加ContextReplacementPlugin：

const webpack = require('webpack');

module.exports = {

  //...

  plugins: [

    // 只加载 `moment/locale/ja.js` 和 `moment/locale/it.js`

    new webpack.ContextReplacementPlugin(/moment[/\\]locale$/, /ja|it/),

  ],

};

值得注意的是，这样你就不需要在代码中再次引入本地文件了：

const moment = require('moment');

// 不需要

moment.locale('ja');

...

体积对比

对比条件：

• webpack: v3.10.0
• moment.js: v2.20.1

具体表现：

可见，处理后的体积小了很多。

原文链接：https://zhuanlan.zhihu.com/p/90748774

manifest.json

manifest.json经常被用在PWA，用来 告知浏览器 关于PWA应用的一些信息如应用图标、启动应用的画面。举例：

{

  "short_name": "React App",

  "name": "Create React App Sample",

  "icons": [

    {

      "src": "favicon.ico",

      "sizes": "64x64 32x32 24x24 16x16",

      "type": "image/x-icon"

    },

    {

      "src": "logo192.png",

      "type": "image/png",

      "sizes": "192x192"

    },

    {

      "src": "logo512.png",

      "type": "image/png",

      "sizes": "512x512"

    }

  ],

  "start_url": ".",

  "display": "standalone",

  "theme_color": "#000000",

  "background_color": "#ffffff"

}

assets-manifest.json

assets-manifest.json经常会在create-react-app这个脚手架的打包文件上看到，由webpack-manifest-plugin这个webpack插件产生。举例：

{

  "files": {

    "main.css": "/static/css/main.491bee12.chunk.css",

    "main.js": "/static/js/main.14bfbead.chunk.js",

    "main.js.map": "/static/js/main.14bfbead.chunk.js.map",

    "runtime-main.js": "/static/js/runtime-main.e89362ac.js",

    "runtime-main.js.map": "/static/js/runtime-main.e89362ac.js.map",

    "static/js/2.017bb613.chunk.js": "/static/js/2.017bb613.chunk.js",

    "static/js/2.017bb613.chunk.js.map": "/static/js/2.017bb613.chunk.js.map",

    "index.html": "/index.html",

    "precache-manifest.33b41575e0c64a21bca1a6091e8a5c6d.js": "/precache-manifest.33b41575e0c64a21bca1a6091e8a5c6d.js",

    "service-worker.js": "/service-worker.js",

    "static/css/main.491bee12.chunk.css.map": "/static/css/main.491bee12.chunk.css.map",

    "static/media/logo.svg": "/static/media/logo.25bf045c.svg"

  },

  "entrypoints": [

    "static/js/runtime-main.e89362ac.js",

    "static/js/2.017bb613.chunk.js",

    "static/css/main.491bee12.chunk.css",

    "static/js/main.14bfbead.chunk.js"

  ]

}

wepack-mainfest-plugin对它自身的介绍是：

This will generate amanifest.jsonfile in your root output directory with a mapping of all source file names to their corresponding output file。

意思就是assets-manifest.json其实只是源文件和加哈希后文件的一个对比表，仅此而已。它不会对应用的运行产生任何影响，浏览器也不会去请求它。

precache-manifest.js

这个文件由workbox-webpack-plugin插件生成， 用来告诉workbox哪些静态文件可以缓存。例如：

/**

 * The workboxSW.precacheAndRoute() method efficiently caches and responds to

 * requests for URLs in the manifest.

 * See https://goo.gl/S9QRab

 */

self.__precacheManifest = [].concat(self.__precacheManifest || []);

workbox.precaching.precacheAndRoute(self.__precacheManifest, {});

其中self.__precacheManifest的值就是precache-manifest.js的内容。

 原文链接：https://zhuanlan.zhihu.com/p/90829472

一：第三方插件

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

谈一下个人认为的react hooks的优缺点，通过和传统的React.Component进行对比得出。

#优点

一、更容易复用代码

这点应该是react hooks最大的优点，它通过自定义hooks来复用状态，从而解决了类组件有些时候难以复用逻辑的问题。hooks是怎么解决这个复用的问题呢，具体如下：

1. 每调用useHook一次都会生成一份独立的状态，这个没有什么黑魔法，函数每次调用都会开辟一份独立的内存空间。
2. 虽然状态(from useState)和副作用(useEffect)的存在依赖于组件，但它们可以在组件外部进行定义。这点是class component做不到的，你无法在外部声明state和副作用（如componentDidMount）。

上面这两点，高阶组件和renderProps也同样能做到。但hooks实现起来的代码量更少，以及更直观（代码可读性）。

举个例子，经常使用的antd-table，用的时候经常需要维护一些状态 ，并在合适的时机去更改它们:

componentDidMount(){

 this.loadData();

}



loadData = ()=>{

   this.setState({

     current: xxx,

     total: xxx,

     pageSize: xxx,

     dataSource: xxx[]

   })

}



onTableChange = ()=>{

   this.setState({

     current: xxx,

     total: xxx,

     pageSize: xxx,

   })

}



render(){

 const {total,pageSize,current,dataSource} = this.state;

 return <Table

  dataSource={dataSource}

  pagination={{total,pageSize,current}

  onChange={this.onTableChange}

 />

}

每个table都要写一些这种逻辑，那还有啥时间去摸鱼。这些高度类似的逻辑，可以通过封装一个高阶组件来抽象它们。这个高阶组件自带这些状态，并可以自动调用server去获取remote data。

用高阶组件来实现的话会是这样：

import { Table } from 'antd'

import server from './api'



function useTable(server) {

  return function (WrappedComponent) {

    return class HighComponent extends React.Component {

      state = {

        tableProps: xxx, 

      };

      render() {

        const { tableProps } = this.state;

        return <WrappedComponent tableProps={tableProps} />;

      }

    };

  };

}





@useTable(server)

class App extends Component{

  render(){

/**

 * 高阶组件/renderProps是通过增强组件的props（赋予一个新的属性或者方法到组件的props属性），

 * 实现起来比较隐式。你难以区分这个props是来自哪个高阶组件（特别是使用了较多的高阶组件时），

 * 或者还是来自业务的父组件。

 */

    const { tableProps } = this.props;

    return (

      <Table 

        columns={[...]}

      // tableProps包含pagination, onChange, dataSource等属性。

        {...tableProps}

      />

    )

  }

}

如果用hooks来实现的话，会是：

import { Table } from 'antd'

import server from './api'



function useTable(server) {

  const [tableProps, setTableProps] = useState(xxx);

  return tableProps;

}



function App {

    const { tableProps } = useTable();

    return (

      <Table 

        columns={[...]}

      // tableProps包含pagination, onChange, dataSource等属性

        {...tableProps}

      />

    )

}

/*

相对比高阶组件“祖父=>父=>子”的层层嵌套，

hooks是这样的：  

const { brother1 } = usehook1; 

const { brother2} = usehook2;

*/

可以看到，hooks的逻辑更清晰，可读性更好。

二、清爽的代码风格+代码量更少

1. 函数式编程风格，函数式组件、状态保存在运行环境、每个功能都包裹在函数中，整体风格更清爽，更优雅。

2. 对IDE更友好，对比类组件，函数组件里面的unused状态和unused-method更容易被编辑器发现。

3. 使用typescript的话，类型声明也变得更容易。

class Example{

   hello: string;

   constructor(){

      this.hello = 'hello world'

   }

}



// 代码量更少

function Example(){

   const hello:string = 'hello world'

}

4. 向props或状态取值更加方便，函数组件的取值都从当前作用域直接获取变量，而类组件需要先访问实例this，再访问其属性或者方法，多了一步。

5. 更改状态也变得更加简单, `this.setState({ count:xxx })`变成 `setCount(xxx)`。

因为减少了很多模板代码，特别是小组件写起来更加省事，人们更愿意去拆分组件。而组件粒度越细，被复用的可能性越大。所以，hooks也在不知不觉中改变人们的开发习惯，提高项目的组件复用率。

#缺点

一、响应式的useEffect

写函数组件时，你不得不改变一些写法习惯。你必须清楚代码中useEffect和useCallback的“依赖项数组”的改变时机。有时候，你的useEffect依赖某个函数的不可变性，这个函数的不可变性又依赖于另一个函数的不可变性，这样便形成了一条依赖链。一旦这条依赖链的某个节点意外地被改变了，你的useEffect就被意外地触发了，如果你的useEffect是幂等的操作，可能带来的是性能层次的问题，如果是非幂等，那就糟糕了。

所以，对比componentDidmount和componentDidUpdate，useEffect带来的心智负担更大。

二、hooks不擅长异步的代码（旧引用问题）

函数的运行是独立的，每个函数都有一份独立的作用域。函数的变量是保存在运行时的作用域里面。当我们有异步操作的时候，经常会碰到异步回调的变量引用是之前的，也就是旧的（这里也可以理解成闭包）。比如下面的一个例子（codesandbox）：

import React, { useState } from "react";



const Counter = () => {

  const [counter, setCounter] = useState(0);



  const onAlertButtonClick = () => {

    setTimeout(() => {

      alert("Value: " + counter);

    }, 3000);

  };



  return (

    <div>

      <p>You clicked {counter} times.</p>

      <button onClick={() => setCounter(counter + 1)}>Click me</button>

      <button onClick={onAlertButtonClick}>

        Show me the value in 3 seconds

      </button>

    </div>

  );

};



export default Counter;

当你点击Show me the value in 3 seconds的后，紧接着点击Click me使得counter的值从0变成1。三秒后，定时器触发，但alert出来的是0（旧值），但我们希望的结果是当前的状态1。

这个问题在class component不会出现，因为class component的属性和方法都存放在一个instance上，调用方式是：this.state.xxx和this.method()。因为每次都是从一个不变的instance上进行取值，所以不存在引用是旧的问题。

其实解决这个hooks的问题也可以参照类的instance。用useRef返回的immutable RefObject（把值保存在current属性上）来保存state，然后取值方式从counter变成了： counterRef.current。如下：

import React, { useState, useRef, useEffect } from "react";



const Counter = () => {

  const [counter, setCounter] = useState(0);

  const counterRef = useRef(counter);



  const onAlertButtonClick = () => {

    setTimeout(() => {

      alert("Value: " + counterRef.current);

    }, 3000);

  };



  useEffect(() => {

    counterRef.current = counter;

  });



  return (

    <div>

      <p>You clicked {counter} times.</p>

      <button onClick={() => setCounter(counter + 1)}>Click me</button>

      <button onClick={onAlertButtonClick}>

        Show me the value in 3 seconds

      </button>

    </div>

  );

};



export default Counter;

结果如我们所期待，alert的是当前的值1。

我们可以把这个过程封装成一个custom hook，如下：

import { useEffect, useRef, useState } from "react";



const useRefState = <T>(

  initialValue: T

): [T, React.MutableRefObject<T>, React.Dispatch<React.SetStateAction<T>>] => {

  const [state, setState] = useState<T>(initialValue);

  const stateRef = useRef(state);

  useEffect(() => {

    stateRef.current = state;

  }, [state]);

  return [state, stateRef, setState];

};



export default useRefState;

尽管这个问题被巧妙地解决了，但它不优雅、hack味道浓，且丢失了函数编程风格。

三、custom hooks有时严重依赖参数的不可变性

import {useState, useEffect} from 'react'



export function() useData(api){

  const [data, setDate] = useState([]);

  useEffect(()=>{ 

    api().then(res=>setData(res.data)) ;

    // 这里要求传入的api是immutable的，被useCallback/useMemo所包裹。不然每次api一变，

    // 都会非预期地多调用一次useEffect。

  },[api])

}

对于这点，除了在团队约定参数的不可变性，还可以对useCallback/useMemo进行魔改：

import React from "react";



let useCallback = React.useCallback;



if (__DEV__) {

  useCallback = (fn, arr) => {

    fn.__useCallback__ = true;

    return useCallback(fn, arr);

  };

}



export default useCallback;

然后在run-time中去检查是否存在__useCallback__这个属性:

import {useState, useEffect} from 'react'



function checkFn(fn){

  if(__DEV__){

    if(!fn.__useCallback__){

      throw Error('请用团队封装的useCallback来包裹fn')

    }

  }

}



export function() useData(api){

  const [data, setDate] = useState([]);



  checkFn(api);

  

  useEffect(()=>{ 

    api().then(res=>setData(res.data)) ;

    // 这里要求传入的api是immutable的，被useCallback/useMemo所包裹。不然每次api一变，

    // 都会非预期地多调用一次useEffect。

  },[api])

}

也有其他的方案：比如用eslint插件去检查。

#怎么避免react hooks的常见问题

1. 不要在useEffect里面写太多的依赖项，划分这些依赖项成多个单一功能的useEffect。其实这点是遵循了软件设计的“单一职责模式”。
2. 如果你碰到状态不同步的问题，可以考虑下手动传递参数到函数。如：

   // showCount的count来自父级作用域 

   const [count,setCount] = useState(xxx); 

   function showCount(){ console.log(count) } 

   

   // showCount的count来自参数 

   const [count,setCount] = useState(xxx); 

   function showCount(c){ console.log(c) }

但这个也只能解决一部分问题，很多时候你不得不使用上述的useRef方案。

3. 拆分组件，细化组件的粒度。复杂业务场景中使用hooks，应尽可能地细分组件，使得组件的功能尽可能单一，这样的hooks组件更好维护。

#感想

hooks很好用很强大，但它不擅长异步。但在有太多异步逻辑的代码时，class比它更适合、更稳、更好维护。

原文链接：https://zhuanlan.zhihu.com/p/88593858

适配暗夜模式

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

我们大部分 React 类组件可以保存状态，而函数组件不能？ 并且类组件具有生命周期，而函数组件却不能？

React 早期版本，类组件可以通过继承PureComponent来优化一些不必要的渲染，相对于函数组件，React 官网没有提供对应的方法来缓存函数组件以减少一些不必要的渲染，直接 16.6 出来的 React.memo函数。

React 16.8 新出来的Hook可以让React 函数组件具有状态，并提供类似 componentDidMount和componentDidUpdate等生命周期方法。

类被会替代吗？

Hooks不会替换类，它们只是一个你可以使用的新工具。React 团队表示他们没有计划在React中弃用类，所以如果你想继续使用它们，可以继续用。

我能体会那种总有新东西要学的感觉有多痛苦，不会就感觉咱们总是落后一样。Hooks 可以当作一个很好的新特性来使用。当然没有必要用 Hook 来重构原来的代码, React团队也建议不要这样做。

Go Go

来看看Hooks的例子,咱们先从最熟悉的开始:函数组件。

以下 OneTimeButton 是函数组件，所做的事情就是当我们点击的时候调用 sayHi 方法。

import React from 'react';
import { render } from 'react-dom';

function OneTimeButton(props) {
  return (
    <button onClick={props.onClick}>
        点我点我
    </button>
  )
}

function sayHi() {
  console.log('yo')
}

render(
  <OneTimeButton onClick={sayHi}/>,
  document.querySelector('#root')
)

我们想让这个组件做的是，跟踪它是否被点击，如果被点击了，禁用按钮，就像一次性开关一样。

但它需要一个state，因为是一个函数，它不可能有状态(React 16.8之前)，所以需要重构成类。

函数组件转换为类组件的过程中大概有5个阶段：

• 否认：也许它不需要是一个类，我们可以把 state 放到其它地方。

• 实现： 废话，必须把它变成一个class，不是吗？

• 接受：好吧，我会改的。

• 努力加班重写：首先 写 class Thing extends React.Component，然后 实现 render等等 。

• 最后：添加state。

  ---

class OneTimeButton extends React.Component {
  state = {
    clicked: false
  }

  handleClick = () => {
    this.props.onClick();

    // Ok, no more clicking.
    this.setState({ clicked: true });
  }

  render() {
    return (
      <button
        onClick={this.handleClick}
        disabled={this.state.clicked}
      >
        You Can Only Click Me Once
      </button>
    );
  }
}

这是相当多的代码，组件的结构也发生了很大的变化， 我们需要多个小的功能，就需要改写很多。

使用　Hook　轻松添加　State

接下来，使用新的　useState　hook向普通函数组件添加状态：

import React, { useState } from 'react'

function OneTimeButton(props) {
  const [clicked, setClicked] = useState(false)
  
  function doClick() {
    props.onClick();
    setClicked(true)
  }

  return (
    <button
      onClick={clicked ? undefined : doClick}
      disabled={clicked}
    >
      点我点我
    </button>
  )
}

这段代码是如何工作的

这段代码的大部分看起来像我们一分钟前写的普通函数组件，除了useState。

useState是一个hook。 它的名字以“use”开头（这是Hooks的规则之一 - 它们的名字必须以“use”开头）。

useState hook 的参数是 state 的初始值，返回一个包含两个元素的数组:当前state和一个用于更改state 的函数。

类组件有一个大的state对象，一个函数this.setState一次改变整个state对象。

函数组件根本没有状态，但useState hook允许我们在需要时添加很小的状态块。 因此，如果只需要一个布尔值，我们就可以创建一些状态来保存它。

由于Hook以某种特殊方式创建这些状态，并且在函数组件内也没有像setState函数来更改状态，因此 Hook 需要一个函数来更新每个状态。 所以 useState 返回是一对对应关系：一个值，一个更新该值函数。 当然，值可以是任何东西 - 任何JS类型 - 数字，布尔值，对象，数组等。

现在，你应该有很多疑问，如：

• 当组件重新渲染时，每次都不会重新创建新的状态吗？ React如何知道旧状态是什么？

• 为什么hook 名称必须以“use”开头？ 这看起来很可疑。

• 如果这是一个命名规则，那是否意味着我可以自定义 Hook。

• 如何存储更复杂的状态，很多场景不单单只有一个状态值这么简单。

Hooks 的魔力

将有状态信息存储在看似无状态的函数组件中，这是一个奇怪的悖论。这是第一个关于钩子的问题，咱们必须弄清楚它们是如何工作的。

原作者得的第一个猜测是某种编译器的在背后操众。搜索代码useWhatever并以某种方式用有状态逻辑替换它。

然后再听说了调用顺序规则(它们每次必须以相同的顺序调用)，这让我更加困惑。这就是它的工作原理。

React第一次渲染函数组件时，它同时会创建一个对象与之共存，该对象是该组件实例的定制对象，而不是全局对象。只要组件存在于DOM中，这个组件的对象就会一直存在。

使用该对象，React可以跟踪属于组件的各种元数据位。

请记住，React组件甚至函数组件都从未进行过自渲染。它们不直接返回HTML。组件依赖于React在适当的时候调用它们，它们返回的对象结构React可以转换为DOM节点。

React有能力在调用每个组件之前做一些设置，这就是它设置这个状态的时候。

其中做的一件事设置 Hooks 数组。 它开始是空的, 每次调用一个hook时，React 都会向该数组添加该 hook。

为什么顺序很重要

假设咱们有以下这个组件：

function AudioPlayer() {
  const [volume, setVolume] = useState(80);
  const [position, setPosition] = useState(0);
  const [isPlaying, setPlaying] = useState(false);

  .....
}

因为它调用useState 3次，React 会在第一次渲染时将这三个 hook 放入 Hooks 数组中。

下次渲染时，同样的3个hooks以相同的顺序被调用，所以React可以查看它的数组，并发现已经在位置0有一个useState hook ，所以React不会创建一个新状态，而是返回现有状态。

这就是React能够在多个函数调用中创建和维护状态的方式，即使变量本身每次都超出作用域。

多个useState 调用示例

让咱们更详细地看看这是如何实现的，第一次渲染：

1. React 创建组件时，它还没有调用函数。React 创建元数据对象和Hooks的空数组。假设这个对象有一个名为nextHook的属性，它被放到索引为0的位置上，运行的第一个hook将占用位置0。

2. React 调用你的组件（这意味着它知道存储hooks的元数据对象）。

3. 调用useState，React创建一个新的状态，将它放在hooks数组的第0位，并返回[volume，setVolume]对，并将volume 设置为其初始值80，它还将nextHook索引递增1。

4. 再次调用useState，React查看数组的第1位，看到它是空的，并创建一个新的状态。 然后它将nextHook索引递增为2，并返回[position，setPosition]。

5. 第三次调用useState。 React看到位置2为空，同样创建新状态，将nextHook递增到3，并返回[isPlaying，setPlaying]。

现在，hooks 数组中有3个hook，渲染完成。 下一次渲染会发生什么？

1. React需要重新渲染组件, 由于 React 之前已经看过这个组件，它已经有了元数据关联。

2. React将nextHook索引重置为0，并调用组件。

3. 调用useState，React查看索引0处的hooks数组，并发现它已经在该槽中有一个hook。，所以无需重新创建一个，它将nextHook推进到索引1并返回[volume，setVolume]，其中volume仍设置为80。

4. 再次调用useState。 这次，nextHook为1，所以React检查数组的索引1。同样，hook 已经存在，所以它递增nextHook并返回[position，setPosition]。

5. 第三次调用useState，我想你知道现在发生了什么。

就是这样了，知道了原理，看起来也就不那么神奇了， 但它确实依赖于一些规则，所以才有使用 Hooks 规则。

Hooks 的规则

自定义 hooks 函数只需要遵守规则 3 ：它们的名称必须以“use”为前缀。

例如，我们可以从AudioPlayer组件中将3个状态提取到自己的自定义钩子中：

function AudioPlayer() {
  // Extract these 3 pieces of state:
  const [volume, setVolume] = useState(80);
  const [position, setPosition] = useState(0);
  const [isPlaying, setPlaying] = useState(false);

  // < beautiful audio player goes here >
}

因此，咱们可以创建一个专门处理这些状态的新函数，并使用一些额外的方法返回一个对象，以便更容易启动和停止播放，例如：

function usePlayerState(lengthOfClip) {
  const [volume, setVolume] = useState(80);
  const [position, setPosition] = useState(0);
  const [isPlaying, setPlaying] = useState(false);

  const stop = () => {
    setPlaying(false);
    setPosition(0);
  }

  const start = () => {
    setPlaying(true);
  }

  return {
    volume,
    position,
    isPlaying,
    setVolume,
    setPosition,
    start,
    stop
  };
}

像这样提取状态的一个好处是可以将相关的逻辑和行为组合在一起。可以提取一组状态和相关事件处理程序以及其他更新逻辑，这不仅可以清理组件代码，还可以使这些逻辑和行为可重用。

另外，通过在自定义hooks中调用自定义hooks，可以将hooks组合在一起。hooks只是函数，当然，函数可以调用其他函数。

总结

Hooks 提供了一种新的方式来处理React中的问题，其中的思想是很有意思且新奇的。

React团队整合了一组很棒的文档和一个常见问题解答，从是否需要重写所有的类组件到钩Hooks是否因为在渲染中创建函数而变慢? 以及两者之间的所有东西，所以一定要看看。

原文：https://daveceddia.com/intro-to-hooks/

前言

在前端工程化日趋复杂的今天，模块打包工具在我们的开发中起到了越来越重要的作用，其中webpack就是最热门的打包工具之一。

说到webpack，可能很多小伙伴会觉得既熟悉又陌生，熟悉是因为几乎在每一个项目中我们都会用上它，又因为webpack复杂的配置和五花八门的功能感到陌生。尤其当我们使用诸如umi.js之类的应用框架还帮我们把webpack配置再封装一层的时候，webpack的本质似乎离我们更加遥远和深不可测了。

当面试官问你是否了解webpack的时候，或许你可以说出一串耳熟能详的webpack loader和plugin的名字，甚至还能说出插件和一系列配置做按需加载和打包优化，那你是否了解他的运行机制以及实现原理呢，那我们今天就一起探索webpack的能力边界，尝试了解webpack的一些实现流程和原理，拒做API工程师。

你知道webpack的作用是什么吗？

从官网上的描述我们其实不难理解，webpack的作用其实有以下几点：

• 模块打包。可以将不同模块的文件打包整合在一起，并且保证它们之间的引用正确，执行有序。利用打包我们就可以在开发的时候根据我们自己的业务自由划分文件模块，保证项目结构的清晰和可读性。
• 编译兼容。在前端的“上古时期”，手写一堆浏览器兼容代码一直是令前端工程师头皮发麻的事情，而在今天这个问题被大大的弱化了，通过webpack的Loader机制，不仅仅可以帮助我们对代码做polyfill，还可以编译转换诸如.less, .vue, .jsx这类在浏览器无法识别的格式文件，让我们在开发的时候可以使用新特性和新语法做开发，提高开发效率。
• 能力扩展。通过webpack的Plugin机制，我们在实现模块化打包和编译兼容的基础上，可以进一步实现诸如按需加载，代码压缩等一系列功能，帮助我们进一步提高自动化程度，工程效率以及打包输出的质量。

说一下模块打包运行原理？

如果面试官问你Webpack是如何把这些模块合并到一起，并且保证其正常工作的，你是否了解呢？

首先我们应该简单了解一下webpack的整个打包流程：

• 1、读取webpack的配置参数；
• 2、启动webpack，创建Compiler对象并开始解析项目；
• 3、从入口文件（entry）开始解析，并且找到其导入的依赖模块，递归遍历分析，形成依赖关系树；
• 4、对不同文件类型的依赖模块文件使用对应的Loader进行编译，最终转为Javascript文件；
• 5、整个过程中webpack会通过发布订阅模式，向外抛出一些hooks，而webpack的插件即可通过监听这些关键的事件节点，执行插件任务进而达到干预输出结果的目的。

其中文件的解析与构建是一个比较复杂的过程，在webpack源码中主要依赖于compiler和compilation两个核心对象实现。

compiler对象是一个全局单例，他负责把控整个webpack打包的构建流程。compilation对象是每一次构建的上下文对象，它包含了当次构建所需要的所有信息，每次热更新和重新构建，compiler都会重新生成一个新的compilation对象，负责此次更新的构建过程。

而每个模块间的依赖关系，则依赖于AST语法树。每个模块文件在通过Loader解析完成之后，会通过acorn库生成模块代码的AST语法树，通过语法树就可以分析这个模块是否还有依赖的模块，进而继续循环执行下一个模块的编译解析。

最终Webpack打包出来的bundle文件是一个IIFE的执行函数。

// webpack 5 打包的bundle文件内容

(() => { // webpackBootstrap
    var __webpack_modules__ = ({
        'file-A-path': ((modules) => { // ... })
        'index-file-path': ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => { // ... })
    })
    
    // The module cache
    var __webpack_module_cache__ = {};
    
    // The require function
    function __webpack_require__(moduleId) {
        // Check if module is in cache
        var cachedModule = __webpack_module_cache__[moduleId];
        if (cachedModule !== undefined) {
                return cachedModule.exports;
        }
        // Create a new module (and put it into the cache)
        var module = __webpack_module_cache__[moduleId] = {
                // no module.id needed
                // no module.loaded needed
                exports: {}
        };

        // Execute the module function
        __webpack_modules__[moduleId](module, module.exports, __webpack_require__ "moduleId");

        // Return the exports of the module
        return module.exports;
    }
    
    // startup
    // Load entry module and return exports
    // This entry module can't be inlined because the eval devtool is used.
    var __webpack_exports__ = __webpack_require__("./src/index.js");
})

和webpack4相比，webpack5打包出来的bundle做了相当的精简。在上面的打包demo中，整个立即执行函数里边只有三个变量和一个函数方法，__webpack_modules__存放了编译后的各个文件模块的JS内容，__webpack_module_cache__ 用来做模块缓存，__webpack_require__是Webpack内部实现的一套依赖引入函数。最后一句则是代码运行的起点，从入口文件开始，启动整个项目。

其中值得一提的是__webpack_require__模块引入函数，我们在模块化开发的时候，通常会使用ES Module或者CommonJS规范导出/引入依赖模块，webpack打包编译的时候，会统一替换成自己的__webpack_require__来实现模块的引入和导出，从而实现模块缓存机制，以及抹平不同模块规范之间的一些差异性。

你知道sourceMap是什么吗？

提到sourceMap，很多小伙伴可能会立刻想到Webpack配置里边的devtool参数，以及对应的eval，eval-cheap-source-map等等可选值以及它们的含义。除了知道不同参数之间的区别以及性能上的差异外，我们也可以一起了解一下sourceMap的实现方式。

sourceMap是一项将编译、打包、压缩后的代码映射回源代码的技术，由于打包压缩后的代码并没有阅读性可言，一旦在开发中报错或者遇到问题，直接在混淆代码中debug问题会带来非常糟糕的体验，sourceMap可以帮助我们快速定位到源代码的位置，提高我们的开发效率。sourceMap其实并不是Webpack特有的功能，而是Webpack支持sourceMap，像JQuery也支持souceMap。

既然是一种源码的映射，那必然就需要有一份映射的文件，来标记混淆代码里对应的源码的位置，通常这份映射文件以.map结尾，里边的数据结构大概长这样：

{
  "version" : 3,                          // Source Map版本
  "file": "out.js",                       // 输出文件（可选）
  "sourceRoot": "",                       // 源文件根目录（可选）
  "sources": ["foo.js", "bar.js"],        // 源文件列表
  "sourcesContent": [null, null],         // 源内容列表（可选，和源文件列表顺序一致）
  "names": ["src", "maps", "are", "fun"], // mappings使用的符号名称列表
  "mappings": "A,AAAB;;ABCDE;"            // 带有编码映射数据的字符串
}

其中mappings数据有如下规则：

• 生成文件中的一行的每个组用“;”分隔；
• 每一段用“,”分隔；
• 每个段由1、4或5个可变长度字段组成；

有了这份映射文件，我们只需要在我们的压缩代码的最末端加上这句注释，即可让sourceMap生效：

//# sourceURL=/path/to/file.js.map

有了这段注释后，浏览器就会通过sourceURL去获取这份映射文件，通过解释器解析后，实现源码和混淆代码之间的映射。因此sourceMap其实也是一项需要浏览器支持的技术。

如果我们仔细查看webpack打包出来的bundle文件，就可以发现在默认的development开发模式下，每个_webpack_modules__文件模块的代码最末端，都会加上//# sourceURL=webpack://file-path?，从而实现对sourceMap的支持。

sourceMap映射表的生成有一套较为复杂的规则，有兴趣的小伙伴可以看看以下文章，帮助理解soucrMap的原理实现：

Source Map的原理探究[1]

Source Maps under the hood – VLQ, Base64 and Yoda[2]

是否写过Loader？简单描述一下编写loader的思路？

从上面的打包代码我们其实可以知道，Webpack最后打包出来的成果是一份Javascript代码，实际上在Webpack内部默认也只能够处理JS模块代码，在打包过程中，会默认把所有遇到的文件都当作 JavaScript代码进行解析，因此当项目存在非JS类型文件时，我们需要先对其进行必要的转换，才能继续执行打包任务，这也是Loader机制存在的意义。

Loader的配置使用我们应该已经非常的熟悉：

// webpack.config.js
module.exports = {
  // ...other config
  module: {
    rules: [
      {
        test: /^your-regExp$/,
        use: [
          {
             loader: 'loader-name-A',
          }, 
          {
             loader: 'loader-name-B',
          }
        ]
      },
    ]
  }
}

通过配置可以看出，针对每个文件类型，loader是支持以数组的形式配置多个的，因此当Webpack在转换该文件类型的时候，会按顺序链式调用每一个loader，前一个loader返回的内容会作为下一个loader的入参。因此loader的开发需要遵循一些规范，比如返回值必须是标准的JS代码字符串，以保证下一个loader能够正常工作，同时在开发上需要严格遵循“单一职责”，只关心loader的输出以及对应的输出。

loader函数中的this上下文由webpack提供，可以通过this对象提供的相关属性，获取当前loader需要的各种信息数据，事实上，这个this指向了一个叫loaderContext的loader-runner特有对象。有兴趣的小伙伴可以自行阅读源码。

module.exports = function(source) {
    const content = doSomeThing2JsString(source);
    
    // 如果 loader 配置了 options 对象，那么this.query将指向 options
    const options = this.query;
    
    // 可以用作解析其他模块路径的上下文
    console.log('this.context');
    
    /*
     * this.callback 参数：
     * error：Error | null，当 loader 出错时向外抛出一个 error
     * content：String | Buffer，经过 loader 编译后需要导出的内容
     * sourceMap：为方便调试生成的编译后内容的 source map
     * ast：本次编译生成的 AST 静态语法树，之后执行的 loader 可以直接使用这个 AST，进而省去重复生成 AST 的过程
     */
    this.callback(null, content);
    // or return content;
}

更详细的开发文档可以直接查看官网的 Loader API[3]。

是否写过Plugin？简单描述一下编写plugin的思路？

如果说Loader负责文件转换，那么Plugin便是负责功能扩展。Loader和Plugin作为Webpack的两个重要组成部分，承担着两部分不同的职责。

上文已经说过，webpack基于发布订阅模式，在运行的生命周期中会广播出许多事件，插件通过监听这些事件，就可以在特定的阶段执行自己的插件任务，从而实现自己想要的功能。

既然基于发布订阅模式，那么知道Webpack到底提供了哪些事件钩子供插件开发者使用是非常重要的，上文提到过compiler和compilation是Webpack两个非常核心的对象，其中compiler暴露了和 Webpack整个生命周期相关的钩子（compiler-hooks[4]），而compilation则暴露了与模块和依赖有关的粒度更小的事件钩子（Compilation Hooks[5]）。

Webpack的事件机制基于webpack自己实现的一套Tapable事件流方案（github[6]）

// Tapable的简单使用
const { SyncHook } = require("tapable");

class Car {
    constructor() {
        // 在this.hooks中定义所有的钩子事件
        this.hooks = {
            accelerate: new SyncHook(["newSpeed"]),
            brake: new SyncHook(),
            calculateRoutes: new AsyncParallelHook(["source", "target", "routesList"])
        };
    }

    /* ... */
}


const myCar = new Car();
// 通过调用tap方法即可增加一个消费者，订阅对应的钩子事件了
myCar.hooks.brake.tap("WarningLampPlugin", () => warningLamp.on());

Plugin的开发和开发Loader一样，需要遵循一些开发上的规范和原则：

• 插件必须是一个函数或者是一个包含 apply 方法的对象，这样才能访问compiler实例；
• 传给每个插件的 compiler 和 compilation 对象都是同一个引用，若在一个插件中修改了它们身上的属性，会影响后面的插件;
• 异步的事件需要在插件处理完任务时调用回调函数通知 Webpack 进入下一个流程，不然会卡住;

了解了以上这些内容，想要开发一个 Webpack Plugin，其实也并不困难。

class MyPlugin {
  apply (compiler) {
    // 找到合适的事件钩子，实现自己的插件功能
    compiler.hooks.emit.tap('MyPlugin', compilation => {
        // compilation: 当前打包构建流程的上下文
        console.log(compilation);
        
        // do something...
    })
  }
}

最后

本文也是结合一些优秀的文章和webpack本身的源码，大概地说了几个相对重要的概念和流程，其中的实现细节和设计思路还需要结合源码去阅读和慢慢理解。

Webpack作为一款优秀的打包工具，它改变了传统前端的开发模式，是现代化前端开发的基石。这样一个优秀的开源项目有许多优秀的设计思想和理念可以借鉴，我们自然也不应该仅仅停留在API的使用层面，尝试带着问题阅读源码，理解实现的流程和原理，也能让我们学到更多知识，理解得更加深刻，在项目中才能游刃有余的应用。

参考资料

[1]Source Map的原理探究: https://blog.fundebug.com/201...

[2]Source Maps under the hood – VLQ, Base64 and Yoda: *https://docs.microsoft.com/zh...

[3]Loader API: *https://www.webpackjs.com/api...

[4]compiler-hooks: https://webpack.js.org/api/co...

[5]Compilation Hooks: https://webpack.js.org/api/co...

[6]github: https://github.com/webpack/ta...

[7]Plugin API: https://www.webpackjs.com/api...

原文地址(前端大全)

ECMAScript发展进程中，会有很多功能的更新，比如销毁，箭头功能，模块，它们极大的改变JavaScript编写方式，可能有些人喜欢，有些人不喜欢，但像每个新功能一样，我们最终会习惯它们。新版本的ECMAScript引入了三个新的逻辑赋值运算符：空运算符，AND和OR运算符，这些运算符的出现，也是希望让我们的代码更干净简洁，下面分享几个优雅的JavaScript运算符使用技巧

一、可选链接运算符【？.】

可选链接运算符（Optional Chaining Operator） 处于ES2020提案的第4阶段，因此应将其添加到规范中。它改变了访问对象内部属性的方式，尤其是深层嵌套的属性。它也可以作为TypeScript 3.7+中的功能使用。

相信大部分开发前端的的小伙伴们都会遇到null和未定义的属性。JS语言的动态特性使其无法不碰到它们。特别是在处理嵌套对象时，以下代码很常见：

if (data && data.children && data.children[0] && data.children[0].title) {

    // I have a title!

}

上面的代码用于API响应，我必须解析JSON以确保名称存在。但是，当对象具有可选属性或某些配置对象具有某些值的动态映射时，可能会遇到类似情况，需要检查很多边界条件。

这时候，如果我们使用可选链接运算符，一切就变得更加轻松了。它为我们检查嵌套属性，而不必显式搜索梯形图。我们所要做的就是使用“？” 要检查空值的属性之后的运算符。我们可以随意在表达式中多次使用该运算符，并且如果未定义任何项，它将尽早返回。

对于静态属性用法是：

object?.property

对于动态属性将其更改为：

object?.[expression]

上面的代码可以简化为：

let title = data?.children?.[0]?.title;

然后，如果我们有:

let data;

console.log(data?.children?.[0]?.title) // undefined



data  = {children: [{title:'codercao'}]}

console.log(data?.children?.[0]?.title) // codercao

这样写是不是更加简单了呢？ 由于操作符一旦为空值就会终止，因此也可以使用它来有条件地调用方法或应用条件逻辑

const conditionalProperty = null;

let index = 0;



console.log(conditionalProperty?.[index++]); // undefined

console.log(index);  // 0

对于方法的调用你可以这样写

object.runsOnlyIfMethodExists?.()

例如下面的parent对象，如果我们直接调用parent.getTitle(),则会报Uncaught TypeError: parent.getTitle is not a function错误，parent.getTitle?.()则会终止不会执行

let parent = {

    name: "parent",

    friends: ["p1", "p2", "p3"],

    getName: function() {

      console.log(this.name)

    }

  };

  

  parent.getName?.()   // parent

  parent.getTitle?.()  //不会执行

  

与无效合并一起使用

提供了一种方法来处理未定义或为空值和表达提供默认值。我们可以使用??运算符，为表达式提供默认值

console.log(undefined ?? 'codercao'); // codercao

因此，如果属性不存在，则可以将无效的合并运算符与可选链接运算符结合使用以提供默认值。

let title = data?.children?.[0]?.title ?? 'codercao';

console.log(title); // codercao

二、逻辑空分配（?? =）

expr1 ??= expr2

逻辑空值运算符仅在空值（空值或未定义undefined）时才将值分配给expr1，表达方式：

x ??= y

可能看起来等效于：

x = x ?? y;

但事实并非如此！有细微的差别。

空的合并运算符（??）从左到右操作，如果x不为空，则短路。因此，如果x不为null或未定义，则永远不会对表达式y进行求值。因此，如果y是一个函数，它将根本不会被调用。因此，此逻辑赋值运算符等效于

x ?? (x = y);

三、逻辑或分配（|| =）

此逻辑赋值运算符仅在左侧表达式为 falsy值时才赋值。Falsy值与null有所不同，因为falsy值可以是任何一种值：undefined，null，空字符串(双引号""、单引号’’、反引号``)，NaN，0。IE浏览器中的 document.all，也算是一个。

语法

x ||= y

等同于

x || (x = y)

在我们想要保留现有值（如果不存在）的情况下，这很有用，否则我们想为其分配默认值。例如，如果搜索请求中没有数据，我们希望将元素的内部HTML设置为默认值。否则，我们要显示现有列表。这样，我们避免了不必要的更新和任何副作用，例如解析，重新渲染，失去焦点等。我们可以简单地使用此运算符来使用JavaScript更新HTML：

document.getElementById('search').innerHTML ||= '<i>No posts found matching this search.</i>'

四、逻辑与分配（&& =）

可能你已经猜到了，此逻辑赋值运算符仅在左侧为真时才赋值。因此：

x &&= y

等同于

x && (x = y)

最后

本次分享几个优雅的JavaScript运算符使用技巧，重点分享了可选链接运算符的使用，这样可以让我们不需要再编写大量我们例子中代码即可轻松访问嵌套属性。但是IE不支持它，因此，如果需要支持该版本或更旧版本的浏览器，则可能需要添加Babel插件。对于Node.js，需要为此升级到Node 14 LTS版本，因为12.x不支持该版本。

如果你也有优雅的优雅的JavaScript运算符使用技巧，请不要吝惜，在评论区一起交流~

原文链接：https://segmentfault.com/a/1190000039885243

一、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