$watch: function(watchExp, listener, objectEquality){
  var scope = this,
      get = compileToFn(watchExp, 'watch'),
      array = scope.$$watchers,
      watcher = {
        fn: listener, // 监听函数
        last: initWatchVal, // 上次的值
        get: get, // 获取监听表达式的值
        exp: watchExp, // 监听表达式
        eq: !!objectEquality //是否需要深度对比
      };

    lastDirtyWatch = null;
    ...
    if(!array){
      array = scope.$$watchers = [];
    }

    array.unshift(watcher);

    return function deregisterWatch(){
      arrayRemove(array, watcher);
      lastDirtyWatch = null;
    };
}

$digest: function(){
  var watch, value, last,
      watchers,
      asyncQueue = this.$$asyncQueue,
      postDigestQueue = this.$$postDigestQueue,
      length,
      dirty, ttl = TTL, // TTL默认为10，循环最大轮数
      next, current, target = this,
      watchLog = [],
      logIdx, logMsg, asyncTask;

  beginPhase('$digest'); // 设置$$phase状态为$digest中
  $browser.$$checkUrlChange();

  lastDirtyWatch = null;

  do{ // "脏检查"循环开始
    dirty = false;
    current = target;

    // 先执行由$scope.$evalAsync注册的异步对象
    while(asyncQueue.length){
      try{
        asyncTask = asyncQueue.shift();
        asyncTask.scope.$eval(asyncTask.expression);
      }catch(e){
        clearPhase();
        $excpetionHandler(e);
      }
      lastDirtyWatch = null;
    }

    traverseScopeLoop:
      do{ // 对当前$scope及其子$scope循环
        if((watchers = current.$$watchers)){
          // 对当前$scope的watcher函数询问
          length = watchers.length;

          while(length--){
            try{
              watch = watchers[length];
              // 首先会使用js的 === 比较，因为比较快，再视情况使用angular.equals比较
              // 对number类型比较应排除NaN
              if(watch){
                if(
                  (value = watch.get(current)) !== (last = watch.last) &&
                  !(watch.eq?equals(value, last):(typeof value === 'number' && typeof last === 'number' && isNaN(value) && isNaN(last)))
                ){
                  dirty = true;
                  lastDirtyWatch = watch;
                  watch.last = watch.eq?copy(value, null):value;
                  // 执行watcher的监听函数，参数为：新值、旧值、当前$scope
                  watch.fn(value, ((last === initWatchVal)?value:last), current);
                  if(ttl < 5){
                    // ... log message
                  }
                }else if(watch === lastDirtyWatch){
                  dirty = false;
                  break traverseScopeLoop;
                }
              }
            }catch(e){
              clearPahse(); // 去除$$phase的$digest状态
              $exceptionHandler(e);
            }
          }
        }

        // 对后代$scope循环，所有的watcher函数都会检查
        if(
          !(next = (current.$$childHead || (current !== target && current.$$nextSibling)))
          ){
            while(current !== target && !(next = current.$$nextSibling)){
              current = current.$parent;
            }
        }
      }while((current = next)); // 进入下一个子$scope $digest

    if((dirty || asyncQueue.length) && !(ttl--)){
      // 若超过默认10次digest循环，抛出异常，终止循环、
      clearPhase();
      throw $rootScopeMinErr('infdig', '{0} $digest() iterations reached. Aborting!\n' + 'Watchers fired in the last 5 iterations: {1}', TTL, toJson(watchLog));
    }
  }while(dirty || asyncQueue.length);

  clearPhase(); // 去除$$phase的$digest状态

  while(postDigestQueue.length){
    try{
      postDigestQueue.shift()();
    }catch(e){
      $exceptionHandler(e);
    }
  }
}

$apply: function(expr){
  try{
    beginPhase('$apply');
    return this.$eval(expr);
  }catch(e){
    $exceptionHandler(e);
  }finally{
    clearPhase();
    try{
      $rootScope.$digest();
    }catch(e){
      $exceptionHandler(e);
      throw e;
    }
  }
}