这里的许多答案都包含很好的建议，但也可能导致混淆。简单地使用$timeout既不是最好的解决方案，也不是正确的解决方案。此外，如果您关注性能或可伸缩性，请务必阅读。

你应该知道的事情

$$阶段对框架是私有的，这有充分的理由。$timeout（回调）将等待当前摘要周期（如果有）完成，然后执行回调，然后在结束时运行完整的$apply。$timeout（callback，delay，false）将执行相同的操作（在执行回调之前有一个可选的延迟），但不会触发$apply（第三个参数），如果您没有修改Angular模型（$scope），则会节省性能。$范围$apply（callback）调用$rootScope等$digest，这意味着它将重新划分应用程序的根范围及其所有子范围，即使您在一个独立的范围内。$范围$digest（）将简单地将其模型同步到视图，但不会消化其父范围，这可以在使用隔离范围（主要来自指令）处理HTML的隔离部分时节省大量性能$摘要不接受回调：执行代码，然后进行摘要。$范围$angularjs 1.2引入了evalAsync（回调），它可能会解决大部分问题。请参考最后一段了解更多信息。如果你得到了$digest已经在进行中的错误，那么你的架构是错误的：要么你不需要重新定义你的范围，要么你不应该负责这个（见下文）。

如何构造代码

当你遇到这个错误时，你正在试图消化你的范围，而它已经在进行中：因为你不知道你的范围在那一点上的状态，你不负责处理它的消化。

function editModel() {
  $scope.someVar = someVal;
  /* Do not apply your scope here since we don't know if that
     function is called synchronously from Angular or from an
     asynchronous code */
}

// Processed by Angular, for instance called by a ng-click directive
$scope.applyModelSynchronously = function() {
  // No need to digest
  editModel();
}

// Any kind of asynchronous code, for instance a server request
callServer(function() {
  /* That code is not watched nor digested by Angular, thus we
     can safely $apply it */
  $scope.$apply(editModel);
});

如果您知道在大型Angular应用程序的一部分时正在执行和处理一个孤立的小指令，那么您可以选择$digest而不是$apply来节省性能。

从Angularjs 1.2开始更新

任何$scope:$evalAsync中都添加了一个新的强大方法。基本上，如果发生回调，它将在当前摘要周期内执行回调，否则新的摘要周期将开始执行回调。

这仍然不如$scope$如果你真的知道你只需要同步HTML的一个孤立部分（因为如果没有正在进行的话，会触发一个新的$apply），那么这是最好的解决方案，但是当你执行一个你不知道是否会同步执行的函数时，例如在获取一个可能缓存的资源之后，否则将同步本地获取资源。

在这些情况下，以及所有其他情况下$范围$$阶段，请确保使用$scope$evalAsync（回调）

在为我们创建一个可重用的$safeApply函数方面，yearmomo做得很好：

https://github.com/yearofmoo/AngularJS-Scope.SafeApply

用法：

//use by itself
$scope.$safeApply();

//tell it which scope to update
$scope.$safeApply($scope);
$scope.$safeApply($anotherScope);

//pass in an update function that gets called when the digest is going on...
$scope.$safeApply(function() {

});

//pass in both a scope and a function
$scope.$safeApply($anotherScope,function() {

});

//call it on the rootScope
$rootScope.$safeApply();
$rootScope.$safeApply($rootScope);
$rootScope.$safeApply($scope);
$rootScope.$safeApply($scope, fn);
$rootScope.$safeApply(fn);

        let $timeoutPromise = null;
        $timeout.cancel($timeoutPromise);
        $timeoutPromise = $timeout(() => {
            $scope.$digest();
        }, 0, false);

以下是避免此错误和避免$apply的好解决方案

如果基于外部事件调用，则可以将其与反跳（0）结合使用。以上是我们正在使用的“反跳”，以及完整的代码示例

.factory('debounce', [
    '$timeout',
    function ($timeout) {

        return function (func, wait, apply) {
            // apply default is true for $timeout
            if (apply !== false) {
                apply = true;
            }

            var promise;
            return function () {
                var cntx = this,
                    args = arguments;
                $timeout.cancel(promise);
                promise = $timeout(function () {
                    return func.apply(cntx, args);
                }, wait, apply);
                return promise;
            };
        };
    }
])

以及代码本身，以侦听某些事件并仅在需要的$scope上调用$digest

        let $timeoutPromise = null;
        let $update = debounce(function () {
            $timeout.cancel($timeoutPromise);
            $timeoutPromise = $timeout(() => {
                $scope.$digest();
            }, 0, false);
        }, 0, false);

        let $unwatchModelChanges = $scope.$root.$on('updatePropertiesInspector', function () {
            $update();
        });


        $scope.$on('$destroy', () => {
            $timeout.cancel($update);
            $timeout.cancel($timeoutPromise);
            $unwatchModelChanges();
        });

看见http://docs.angularjs.org/error/$rootScope:inprog

当对$apply的调用有时在Angular代码外部异步运行（当应使用$apply时），有时在Angle代码内部同步运行（这导致$digest已经在进行中）时，就会出现问题。

例如，当您拥有一个从服务器异步获取项目并缓存它们的库时，可能会发生这种情况。第一次请求项时，将异步检索该项，以免阻止代码执行。然而，第二次，该项已在缓存中，因此可以同步检索。

防止此错误的方法是确保调用$apply的代码异步运行。这可以通过在调用$timeout时运行代码来完成，延迟设置为0（这是默认值）。然而，在$timeout内调用代码就不需要调用$apply，因为$timeout将自行触发另一个$digest循环，从而执行所有必要的更新等。

解决方案

简而言之，不要这样做：

... your controller code...

$http.get('some/url', function(data){
    $scope.$apply(function(){
        $scope.mydate = data.mydata;
    });
});

... more of your controller code...

执行以下操作：

... your controller code...

$http.get('some/url', function(data){
    $timeout(function(){
        $scope.mydate = data.mydata;
    });
});

... more of your controller code...

只有当您知道运行$apply的代码将始终在Angular代码之外运行时，才调用$apply（例如，您对$apply进行的调用将发生在由Angular代码以外的代码调用的回调内）。

除非有人意识到使用$timeout而不是$apply的一些不利影响，否则我不明白为什么不能总是使用$timeout（零延迟）而不是$app，因为它会做大致相同的事情。

当您收到此错误时，基本上意味着它已经在更新视图的过程中。您真的不需要在控制器中调用$apply（）。如果您的视图没有按预期进行更新，并且在调用$apply（）后出现此错误，那么很可能意味着您没有正确更新模型。如果你发布一些细节，我们可以找出核心问题。

这是我的utils服务：

angular.module('myApp', []).service('Utils', function Utils($timeout) {
    var Super = this;

    this.doWhenReady = function(scope, callback, args) {
        if(!scope.$$phase) {
            if (args instanceof Array)
                callback.apply(scope, Array.prototype.slice.call(args))
            else
                callback();
        }
        else {
            $timeout(function() {
                Super.doWhenReady(scope, callback, args);
            }, 250);
        }
    };
});

这是它的用法示例：

angular.module('myApp').controller('MyCtrl', function ($scope, Utils) {
    $scope.foo = function() {
        // some code here . . .
    };

    Utils.doWhenReady($scope, $scope.foo);

    $scope.fooWithParams = function(p1, p2) {
        // some code here . . .
    };

    Utils.doWhenReady($scope, $scope.fooWithParams, ['value1', 'value2']);
};