Vue 2.0 源码分析(八) 基础篇依赖注入 provide/inject组合详解

时间 2019-12-09

标签 vue 2.0 源码分析基础依赖注入 provide inject 组合详解栏目设计模式繁體版

原文原文链接

用法html

先来看看官网的介绍:vue

简单的说，当组件的引入层次过多，咱们的子孙组件想要获取祖先组件的资源，那么怎么办呢，总不能一直取父级往上吧，并且这样代码结构容易混乱。这个就是这对选项要干的事情npm

provide和inject须要配合使用，它们的含义以下:编程

provide       ;一个对象或返回一个对象的函数，该对象包含可注入起子孙的属性，可使用ES6的Symbols做为key(只有原生支持Symbol才能够)
inject       　;一个字符串数组或一个对象
           　　　　;字符串数组   ;provide对象里哪些属性可用
　　　　           ;一个对象 ;key是本地的绑定名，value是provide里对应的对象名，也能够是一个对象，此时from属性是provide里对应的对象名，default属性是不存在时的默认值数组

来个例子理解一下app

<!DOCTYPE html>   　　<!--例1-->　　　　
<html lang="en"> 
<head>
    <meta charset="UTF-8">
    <script src="https://cdn.jsdelivr.net/npm/vue@2.6.10/dist/vue.js"></script>
    <title>Document</title>    
</head>
<body>
    <div id="app"><child></child></div>
    <script>
        Vue.component('child',{
            inject:['message'],
            template:'<p>{{message}}</p>'
        })
        new Vue({
            el:'#app',provide:{message:'Hello Vue!'}
        })
    </script>
</body>
</html>

输出:Hello Vue!,对应的DOM节点渲染为:ide

是否是感受和props的传值差很少，固然这不是 provide/inject该干的事情，咱们在中间再嵌套一层组件就知道他的用处了，例如:函数

<!DOCTYPE html> 　　<!--例2-->　　　　
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Document</title>
    <script src="https://cdn.jsdelivr.net/npm/vue@2.6.10/dist/vue.js"></script>
</head>
<body>
    <div id="app"><test></test></div>
    <script>
        Vue.component('child',{
            inject:['message'],
            template:'<p>{{message}}</p>'
        })
        Vue.component('test',{
            template:`<div><child></child></div>`
        })
        new Vue({
            el:'#app',provide:{message:'Hello Vue!'}
        })
    </script>
</body>
</html>

输出:Hello Vue!,对应的DOM节点渲染为:源码分析

provide/injec就是作这个用的，多层嵌套时用起来不要太爽噢this

源码分析

provide/inject组合的源码分为三个部分，分别是组件注册、Vue实例化和组件实例化的过程，以下:

组件注册时

注册时会执行Vue.extend()(第4770行)，内部会执行mergeOptions()合并一些属性,mergeOptions以下:

function mergeOptions (   //第1451行
  parent,
  child,
  vm
) {
  {
    checkComponents(child);
  }

  if (typeof child === 'function') {
    child = child.options;
  }

  normalizeProps(child, vm);
  normalizeInject(child, vm);         //对inject进行一次规范化
  normalizeDirectives(child);
  var extendsFrom = child.extends;
  if (extendsFrom) {
    parent = mergeOptions(parent, extendsFrom, vm);
  }
  if (child.mixins) {
    for (var i = 0, l = child.mixins.length; i < l; i++) {
      parent = mergeOptions(parent, child.mixins[i], vm);
    }
  }
  var options = {};
  var key;
  for (key in parent) {
    mergeField(key);
  }
  for (key in child) {
    if (!hasOwn(parent, key)) {
      mergeField(key);
    }
  }
  function mergeField (key) {
    var strat = strats[key] || defaultStrat;
    options[key] = strat(parent[key], child[key], vm, key);
  }
  return options
}

normalizeInject定义以下:

function normalizeInject (options, vm) {  //第1398行
  var inject = options.inject;
  if (!inject) { return }
  var normalized = options.inject = {};
  if (Array.isArray(inject)) {                      //若是inject是一个数组
    for (var i = 0; i < inject.length; i++) {           //遍历inject
      normalized[inject[i]] = { from: inject[i] };        //保存到normalized里面，例如:{foo: {from: "foo"}}
    }
  } else if (isPlainObject(inject)) {               //若是inject是一个对象
    for (var key in inject) {
      var val = inject[key];
      normalized[key] = isPlainObject(val)
        ? extend({ from: key }, val)
        : { from: val };
    }
  } else {
    warn(
      "Invalid value for option \"inject\": expected an Array or an Object, " +
      "but got " + (toRawType(inject)) + ".",
      vm
    );
  }
}

对于例1来讲，mergeOptions()以后inject等于:{message: {from: "message"}},以下:

Vue实例化时

执行_init()时会执行mergeOptions()进行数据的合并，对于provide的合并策略等于mergeDataOrFn()函数(和data的合并策略是同样的，定义在1321行),返回一个匿名函数(第1154行)，以下:

function mergeDataOrFn (    //第1154行
  parentVal,
  childVal,
  vm
) {
  if (!vm) {                    //这是组件的分支
    // in a Vue.extend merge, both should be functions
    if (!childVal) {
      return parentVal
    }
    if (!parentVal) {
      return childVal
    }
    // when parentVal & childVal are both present,
    // we need to return a function that returns the
    // merged result of both functions... no need to
    // check if parentVal is a function here because
    // it has to be a function to pass previous merges.
    return function mergedDataFn () {
      return mergeData(
        typeof childVal === 'function' ? childVal.call(this, this) : childVal,
        typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal
      )
    }
  } else {                    //这是非组件的实例，返回一个函数
    return function mergedInstanceDataFn () {
      // instance merge
      var instanceData = typeof childVal === 'function'
        ? childVal.call(vm, vm)
        : childVal;
      var defaultData = typeof parentVal === 'function'
        ? parentVal.call(vm, vm)
        : parentVal;
      if (instanceData) {
        return mergeData(instanceData, defaultData)
      } else {
        return defaultData
      }
    }
  }
}

而后返回到_init()以后会调用initProvide()初始化provide:

function initProvide (vm) {     //第3619行
  var provide = vm.$options.provide;                //尝试获取provide
  if (provide) {                                    //若是provide存在,当它是函数时执行该返回，不然直接将provide保存到Vue实例的_provided属性上
    vm._provided = typeof provide === 'function' 
      ? provide.call(vm)
      : provide;
  }
}

返回后_provided等于{message:"Hello Vue!"}，以下

组件实例化时

_init()时会执行initInjections()，通过了前面两步的处理，这里比较简单了，直接从父Vue或父Vue的父Vue获取对应的值便可，以下:

function initInjections (vm) {      //第2681行 初始化inject
  var result = resolveInject(vm.$options.inject, vm);         //遍历祖先节点，获取对应的inject,例如:好比:{foo: "bar"}
  if (result) {                                               //若是获取了对应的值，则将它变成响应式
    toggleObserving(false);
    Object.keys(result).forEach(function (key) {
      /* istanbul ignore else */
      {
        defineReactive(vm, key, result[key], function () { 　　//将key编程响应式，这样就能够访问该元素了
          warn(
            "Avoid mutating an injected value directly since the changes will be " +
            "overwritten whenever the provided component re-renders. " +
            "injection being mutated: \"" + key + "\"",
            vm
          );
        });
      }
    });
    toggleObserving(true);
  }
}

function resolveInject (inject, vm) {           //第3649行 肯定Inject inject:例如:{foo: {from: "foo"}} vm:当前组件的实例
  if (inject) {                                                   //若是inject非空
    // inject is :any because flow is not smart enough to figure out cached
    var result = Object.create(null);                             //存储最后的结果
    var keys = hasSymbol
      ? Reflect.ownKeys(inject).filter(function (key) {                   //若是有符号类型，调用Reflect.ownKeys()返回全部的key，再调用filter
        /* istanbul ignore next */
        return Object.getOwnPropertyDescriptor(inject, key).enumerable
      })
      : Object.keys(inject);                                              //获取全部的key，此时keys就是个字符串数组,好比:["foo"]

    for (var i = 0; i < keys.length; i++) {                               //这里遍历每一个key
      var key = keys[i];
      var provideKey = inject[key].from;
      var source = vm;
      while (source) {
        if (source._provided && hasOwn(source._provided, provideKey)) {   //若是source存在_provided 且 含有provideKey这个属性
          result[key] = source._provided[provideKey];                         //则将值保存到result[key]中
          break                                                               //并跳出while循环
        }
        source = source.$parent;                                          //不然将source赋值给父Vue实例，直到找到对应的providekey为止
      }
      if (!source) {                                                      //若是最后source不存在，即没有从当前实例或祖先实例的_provide找到privideKey这个key
        if ('default' in inject[key]) {
          var provideDefault = inject[key].default;                          //若是有定义defult,则使用默认值
          result[key] = typeof provideDefault === 'function'
            ? provideDefault.call(vm)
            : provideDefault;
        } else {
          warn(("Injection \"" + key + "\" not found"), vm);
        }
      }
    }
    return result                                                       //返回结果，好比:{foo: "bar"}
  }
}

注:provide 和 inject 绑定并非可响应的。这是刻意为之的。然而，若是你传入了一个可监听的对象，那么其对象的属性仍是可响应的。

Vue 2.0 源码分析(八) 基础篇 依赖注入 provide/inject组合详解

Vue 2.0 源码分析(八) 基础篇依赖注入 provide/inject组合详解