hope is coming

//返回interpolationFn方法
        return extend(function interpolationFn(context) {
            var i = 0;
            var ii = expressions.length;
            var values = new Array(ii);

            try {
              //根据表达式来解析
              for (; i < ii; i++) {
                //调用parseFns得到value
                values[i] = parseFns[i](context);
              }

              return compute(values);
            } catch (err) {
              $exceptionHandler($interpolateMinErr.interr(text, err));
            }

          }, {
          // all of these properties are undocumented for now
          exp: text, //just for compatibility with regular watchers created via $watch
          expressions: expressions,
          $$watchDelegate: function(scope, listener) {
            var lastValue;
            return scope.$watchGroup(parseFns, function interpolateFnWatcher(values, oldValues) {
              var currValue = compute(values);
              if (isFunction(listener)) {
                listener.call(this, currValue, values !== oldValues ? lastValue : currValue, scope);
              }
              lastValue = currValue;
            });
          }
        });

scope.$watch(interpolateFn, function interpolateFnWatchAction(value) {
             node[0].nodeValue = value;
           });

//如果被解析过后的watch函数有watch的代理那就返回这个代理watch函数
//
//会创建一个watcher
//watcher里放入listener(类似spring里的监听器)
//数据变化时会触发listener
$watch: function(watchExp, listener, objectEquality, prettyPrintExpression) {
        var get = $parse(watchExp);//watchExp为函数时直接返回watchExp

        if (get.$$watchDelegate) {
          return get.$$watchDelegate(this, listener, objectEquality, get, watchExp);
        }
      }

function $watchGroup: function(watchExpressions, listener) {

  if (watchExpressions.length === 1) {
          // Special case size of one
          return this.$watch(watchExpressions[0], function watchGroupAction(value, oldValue, scope) {
            newValues[0] = value;
            oldValues[0] = oldValue;
            listener(newValues, (value === oldValue) ? newValues : oldValues, scope);
          });
        }
}

function inputsWatchDelegate(scope, listener, objectEquality, parsedExpression, prettyPrintExpression) {
   var inputExpressions = parsedExpression.inputs;
   var lastResult;

   if (inputExpressions.length === 1) {
     var oldInputValueOf = expressionInputDirtyCheck; // init to something unique so that equals check fails
     inputExpressions = inputExpressions[0];
     return scope.$watch(function expressionInputWatch(scope) {
       var newInputValue = inputExpressions(scope);
       if (!expressionInputDirtyCheck(newInputValue, oldInputValueOf)) {
         lastResult = parsedExpression(scope, undefined, undefined, [newInputValue]);
         oldInputValueOf = newInputValue && getValueOf(newInputValue);
       }
       return lastResult;
     }, listener, objectEquality, prettyPrintExpression);
   }
 }

function $CacheFactoryProvider() {
  //定义$get方法供依赖调用
  //controller中获取cacheFactory时会调用此方法
  //这个$get方法也是获取provider的关键方法
   this.$get = function() {
     var caches = {};//闭包的一个运用

     function cacheFactory(cacheId, options) {
       //部分代码省略
       //可以用if来判断
       if (cacheId in caches) {//如果caches中已经存在cacheId
           //实例代码里抛出的错误就在此处、
           //统一调用minErr函数
          throw minErr('$cacheFactory')('iid', "CacheId '{0}' is already taken!"
                                        , cacheId);
        }

         var size = 0,
         //把options 和{id:cacheId} 放入{} 中 不是深拷贝
         stats = extend({}, options, {id: cacheId}),
         data = createMap(),//通过Object.create(null) 创建个空对象
         capacity = (options && options.capacity) || Number.MAX_VALUE,
         lruHash = createMap(),
         freshEnd = null,
         staleEnd = null;
         //返回caches中的一个对象
         return caches[cacheId] = {
              //省略部分代码
              //存储里讲解
              put:function(key,value){
              },
              get: function(key) {
              },
              remove: function(key) {
              },
              removeAll: function() {
              },
              destroy: function() {
              },
              info: function() {
              }
         }
         //刷新节点次序
         function refresh(entry) {
         }
         //
         function link(nextEntry, prevEntry) {

         }
       }

       //所有的缓存
      cacheFactory.info = function() {
        var info = {};
        forEach(caches, function(cache, cacheId) {
          info[cacheId] = cache.info();
        });
        return info;
      };

      cacheFactory.get = function(cacheId) {
          return caches[cacheId];
      };

      return cacheFactory;
   }
}

 put: function(key, value) {
    if (isUndefined(value)) return;
      //如果设定的capcity小于maxvalue
    if (capacity < Number.MAX_VALUE) {
      //lruHash 存了当前的key 还有可能是 p 和n  (previous和next)
      var lruEntry = lruHash[key] || (lruHash[key] = {key: key});
      //刷新各节点的次序
      refresh(lruEntry);//把当前entry放入链表末尾
    }
    //如果key 在data里不存在 那么增加size
    if (!(key in data)) size++;
    data[key] = value;
    //当大于capacity时 会清除最早加入的那个
    if (size > capacity) {
      this.remove(staleEnd.key);//移除淘汰节点stableEnd
    }
    return value;
}

get: function(key) {
  if (capacity < Number.MAX_VALUE) {
    var lruEntry = lruHash[key];
    if (!lruEntry) return;
    // 获取first的时候 因为staleEnd为first 所以会让staleEnd指向 second
    // 内部会执行link 使得 second.p = null
    // first.p =  third  third.n = first
    //stableEnd为 second freshEnd为first
    refresh(lruEntry);
  }
  return data[key];
}

remove: function(key) {
          //如果capacity小于maxvalue
          if (capacity < Number.MAX_VALUE) {
            //先取出当前key的entry
            var lruEntry = lruHash[key];
            if (!lruEntry) return;
            //第一次超过时 freshEnd 为third  lryEntry为first
            if (lruEntry == freshEnd) freshEnd = lruEntry.p;
             //第一次超过时 staleEnd 为first  lryEntry为first
             //所以 会让 stalEnd 指向second 以便于下次移除时
            if (lruEntry == staleEnd) staleEnd = lruEntry.n;
            //把淘汰节点的一个节点选中
            //第一次超过时 lryEntry.n为 second  lryEntry.p 为null
            //执行结果为 second.p = null
            link(lruEntry.n,lruEntry.p);
            //把当前key从lruHash中删除
            delete lruHash[key];
          }
          if (!(key in data)) return;
          delete data[key];
          size--;
        }

function refresh(entry) {
  if (entry != freshEnd) {
    if (!staleEnd) { //staleEnd为空那么就让他指向当前entry
      staleEnd = entry;
    } else if (staleEnd == entry) {
      //如果淘汰节点等于当前节点
      staleEnd = entry.n; //用于把 当前的下一个节点 用作淘汰节点
    }
    //放入第一个元素时 entry.n,entry.p都为undefined
    link(entry.n, entry.p); //当前的上一个节点 和当前的下一个节点
    link(entry, freshEnd); // 当前的节点 和 最新的末尾节点
    freshEnd = entry;  
    freshEnd.n = null;
    //第一次执行完 结果为: freshEnd = first  staleEnd为first  
    //first.p=null first.n=null
    //第二次执行完 结果为：freshEnd = second staleEnd为first
    // first.p=null first.n= second
    // scecond.p = first scecond.n = null
    //第三次执行完 freshEnd = third staleEnd为first first.p=null
    //first.n= second
    // second.p = first second.n = null
    // third.p = second third.n = null
  }
}

function link(nextEntry, prevEntry) {
      //undefined 不等于undefined
      if (nextEntry != prevEntry) {
        //
        if (nextEntry) nextEntry.p = prevEntry;
        //p stands for previous, 'prev' didn't minify
        if (prevEntry) prevEntry.n = nextEntry;
         //n stands for next, 'next' didn't minify
      }
    }