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添加到最前面。
       

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