blocks|key|1016565|text|当您收到此错误时，它基本上意味着它已经在更新视图的过程中。您真的不需要在控制器中调用$apply()。如果您的视图没有像您预期的那样更新，然后在调用$apply()之后得到这个错误，这很可能意味着您没有正确地更新模型。如果你张贴一些细节，我们可以找出核心问题。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1016566|entityMap^0|16|8|22|8|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|M|8|@]|D|@]|E|$]]]|G|$]]

When you get this error, it basically means that it's already in the process of updating your view. You really shouldn't need to call <code>$apply()</code> within your controller. If your view isn't updating as you would expect, and then you get this error after calling <code>$apply()</code>, it most likely means you're not updating the the model correctly. If you post some specifics, we could figure out the core problem.

blocks|key|2044670|text|有时，如果使用这种方式(https://stackoverflow.com/a/12859093/801426)，仍然会出现错误。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2044671|试试这个：|2044672|if(!+$rootScope.$root.$$phase)+{
...|code-block|syntax|javascript|2044673|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/12859093/801426^0|C|17|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]]|C|$]]|$1|D|3|E|5|6|7|W|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|X|8|@]|9|@]|C|$I|J]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]]]

Sometimes you will still get errors if you use this way (<a href="https://stackoverflow.com/a/12859093/801426">https://stackoverflow.com/a/12859093/801426</a>).

Try this:

<pre><code>if(! $rootScope.$root.$$phase) {
...
</code></pre>

blocks|key|1568129|text|让这个过程保持干燥的方便的小助手方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1568130|function+safeApply(scope,+fn)+{
++++(scope.$$phase+%7C%7C+scope.$root.$$phase)+?+fn()+:+scope.$apply(fn);
}|code-block|syntax|javascript|1568131|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Handy little helper method to keep this process DRY: 

<pre><code>function safeApply(scope, fn) {
 (scope.$$phase || scope.$root.$$phase) ? fn() : scope.$apply(fn);
}
</code></pre>

blocks|key|2044711|text|摘要周期是一个同步调用。在完成之前，它不会将控制权让给浏览器的事件循环。有几种方法可以解决这个问题。处理这一问题的最简单方法是使用内置的$timeout，第二种方法是如果使用下划线或存档(应该是)，调用以下命令：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2044712|$timeout(function(){
++++//any+code+in+here+will+automatically+have+an+apply+run+afterwards
});|code-block|syntax|javascript|2044713|或者如果你有房客：|2044714|_.defer(function(){$scope.$apply();});|2044715|我们尝试了几种解决方案，我们讨厌将$rootScope注入到所有控制器、指令甚至一些工厂中。因此，到目前为止，$timeout和_.defer一直是我们的最爱。这些方法成功地告诉角直到下一个动画循环，这将保证当前范围。$apply已经结束。|2044716|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

The digest cycle is a synchronous call. It won't yield control to the browser's event loop until it is done. There are a few ways to deal with this. The easiest way to deal with this is to use the built in $timeout, and a second way is if you are using underscore or lodash (and you should be), call the following:

<pre><code>$timeout(function(){
 //any code in here will automatically have an apply run afterwards
});
</code></pre>

or if you have lodash:

<pre><code>_.defer(function(){$scope.$apply();});
</code></pre>

We tried several workarounds, and we hated injecting $rootScope into all of our controllers, directives, and even some factories. So, the $timeout and _.defer have been our favorite so far. These methods successfully tell angular to wait until the next animation loop, which will guarantee that the current scope.$apply is over.

blocks|key|1016629|text|我已经能够通过调用$eval而不是$apply来解决这个问题，在我知道$digest函数将运行的地方。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1016630|根据文档，$apply基本上是这样做的：|1016631|function+$apply(expr)+{
++try+{
++++return+$eval(expr);
++}+catch+(e)+{
++++$exceptionHandler(e);
++}+finally+{
++++$root.$digest();
++}
}|code-block|syntax|javascript|1016632|在我的例子中，ng-click改变了作用域中的变量，而该变量上的$watch改变了必须是$applied的其他变量。最后一步将导致错误“摘要已经在进行”。|1016633|通过在$apply表达式中用$eval替换$eval，作用域变量将按预期进行更新。|1016634|因此，如果由于角度上的其他变化，文摘无论如何都会运行，那么您只需要做$eval'ing。|1016635|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.angularjs.org/guide/scope^0|9|5|H|6|Z|7|0|5|6|2|2|0|0|0|7|8|18|8|0|3|6|E|5|L|5|0|Y|5|0^^$0|@$1|2|3|4|5|6|7|10|8|@$9|11|A|12|B|C]|$9|13|A|14|B|C]|$9|15|A|16|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|17|8|@$9|18|A|19|B|C]]|D|@$9|1A|A|1B|1|1C]]|E|$]]|$1|H|3|I|5|J|7|1D|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1E|8|@$9|1F|A|1G|B|C]|$9|1H|A|1I|B|C]]|D|@]|E|$]]|$1|O|3|P|5|6|7|1J|8|@$9|1K|A|1L|B|C]|$9|1M|A|1N|B|C]|$9|1O|A|1P|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|6|7|1Q|8|@$9|1R|A|1S|B|C]]|D|@]|E|$]]|$1|S|3|-4|5|6|7|1T|8|@]|D|@]|E|$]]]|T|$U|$5|V|W|X|E|$Y|Z]]]]

I have been able to solve this problem by calling <code>$eval</code> instead of <code>$apply</code> in places where I know that the <code>$digest</code> function will be running.

According to the <a href="http://docs.angularjs.org/guide/scope" rel="nofollow">docs</a>, <code>$apply</code> basically does this:

<pre><code>function $apply(expr) {
 try {
 return $eval(expr);
 } catch (e) {
 $exceptionHandler(e);
 } finally {
 $root.$digest();
 }
}
</code></pre>

In my case, an <code>ng-click</code> changes a variable within a scope, and a $watch on that variable changes other variables which have to be <code>$applied</code>. This last step causes the error "digest already in progress".

By replacing <code>$apply</code> with <code>$eval</code> inside the watch expression the scope variables get updated as expected.

Therefore, it appears that if digest is going to be running anyways because of some other change within Angular, <code>$eval</code>'ing is all you need to do.

blocks|key|2044788|text|例如，对于第三方脚本，比如CodeMirror和Krpano，我也遇到了同样的问题，即使使用这里提到的safeApply方法也没有解决这个错误。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2044789|但是解决问题的方法是使用$timeout服务(别忘了先注入它)。|2044790|因此，类似于：|2044791|$timeout(function()+{
++//+run+my+code+safely+here
})|code-block|syntax|javascript|2044792|如果在您的代码中使用|2044793|这|blockquote|2044794|可能是因为它位于工厂指令的控制器内，或者只是需要某种绑定，所以您可以执行如下操作：|2044795|.factory('myClass',+[
++'$timeout',
++function($timeout)+{

++++var+myClass+=+function()+{};

++++myClass.prototype.surprise+=+function()+{
++++++//+Do+something+suprising!+:D
++++};

++++myClass.prototype.beAmazing+=+function()+{
++++++//+Here+'this'+referes+to+the+current+instance+of+myClass

++++++$timeout(angular.bind(this,+function()+{
++++++++++//+Run+my+code+safely+here+and+this+is+not+undefined+but
++++++++++//+the+same+as+outside+of+this+anonymous+function
++++++++++this.surprise();
+++++++}));
++++}

++++return+new+myClass();

++}]
)|2044796|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|W|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|X|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|Y|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|Z|8|@]|9|@]|A|$]]|$1|M|3|N|5|O|7|10|8|@]|9|@]|A|$]]|$1|P|3|Q|5|6|7|11|8|@]|9|@]|A|$]]|$1|R|3|S|5|H|7|12|8|@]|9|@]|A|$I|J]]|$1|T|3|-4|5|6|7|13|8|@]|9|@]|A|$]]]|U|$]]

I had the same problem with third parties scripts like CodeMirror for example and Krpano,
and even using safeApply methods mentioned here haven't solved the error for me.

But what do has solved it is using $timeout service (don't forget to inject it first).

Thus, something like:

<pre><code>$timeout(function() {
 // run my code safely here
})
</code></pre>

and if inside your code you are using 

<blockquote>
 this
</blockquote>

perhaps because it's inside a factory directive's controller or just need some kind of binding, then you would do something like:

<pre><code>.factory('myClass', [
 '$timeout',
 function($timeout) {

 var myClass = function() {};

 myClass.prototype.surprise = function() {
 // Do something suprising! :D
 };

 myClass.prototype.beAmazing = function() {
 // Here 'this' referes to the current instance of myClass

 $timeout(angular.bind(this, function() {
 // Run my code safely here and this is not undefined but
 // the same as outside of this anonymous function
 this.surprise();
 }));
 }

 return new myClass();

 }]
)
</code></pre>

blocks|key|2044823|text|您也可以使用evalAsync。它将在消化完成后的某个时候运行！|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2044824|scope.evalAsync(function(scope){
++++//use+the+scope...
});|code-block|syntax|javascript|2044825|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You can also use evalAsync. It will run sometime after digest has finished!

<pre><code>scope.evalAsync(function(scope){
 //use the scope...
});
</code></pre>

blocks|key|1014597|text|根据最近与角质人就这个主题进行的讨论:出于未来的考虑，您不应该使用$$phase+。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|CODE|entityRanges|data|1014598|当按下“正确”的方法做这件事时，答案是|1014599|$timeout(function()+{
++//+anything+you+want+can+go+here+and+will+safely+be+run+on+the+next+digest.
})|code-block|syntax|javascript|1014600|最近，我在编写棱角服务来包装facebook、google和twitter时遇到了这种情况，这些API在不同程度上都有回调。|1014601|下面是服务内部的一个示例。(为了简洁起见，服务的其余部分--设置变量、注入$timeout等等--已经停止。)|1014602|window.gapi.client.load('oauth2',+'v2',+function()+{
++++var+request+=+window.gapi.client.oauth2.userinfo.get();
++++request.execute(function(response)+{
++++++++//+This+happens+outside+of+angular+land,+so+wrap+it+in+a+timeout+
++++++++//+with+an+implied+apply+and+blammo,+we're+in+action.
++++++++$timeout(function()+{
++++++++++++if(typeof(response['error'])+!==+'undefined'){
++++++++++++++++//+If+the+google+api+sent+us+an+error,+reject+the+promise.
++++++++++++++++deferred.reject(response);
++++++++++++}else{
++++++++++++++++//+Resolve+the+promise+with+the+whole+response+if+ok.
++++++++++++++++deferred.resolve(response);
++++++++++++}
++++++++});
++++});
});|1014603|请注意，$timeout的延迟参数是可选的，如果未设置，默认为0+($timeout调用$browser.defer哪个如果没有设置延迟，默认为0)|1014604|有点不直观，但这是男人写角度的答案，所以对我来说已经足够好了！|1014605|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/angular/angular.js/blob/v1.2.0-rc.2/src/ng/timeout.js#L41|1|https://github.com/angular/angular.js/blob/v1.2.0-rc.2/src/ng/browser.js|2|https://github.com/angular/angular.js/blob/v1.2.0-rc.2/src/ng/browser.js#L344^0|X|7|15|1|X|7|0|0|J|0|0|0|1Q|0|0|1J|0|0|0|22|Y|8|0|18|E|1|1O|D|2|0|0|V|0^^$0|@$1|2|3|4|5|6|7|19|8|@$9|1A|A|1B|B|C]|$9|1C|A|1D|B|C]|$9|1E|A|1F|B|D]]|E|@]|F|$]]|$1|G|3|H|5|6|7|1G|8|@$9|1H|A|1I|B|C]]|E|@]|F|$]]|$1|I|3|J|5|K|7|1J|8|@]|E|@]|F|$L|M]]|$1|N|3|O|5|6|7|1K|8|@$9|1L|A|1M|B|C]]|E|@]|F|$]]|$1|P|3|Q|5|6|7|1N|8|@$9|1O|A|1P|B|C]]|E|@]|F|$]]|$1|R|3|S|5|K|7|1Q|8|@]|E|@]|F|$L|M]]|$1|T|3|U|5|6|7|1R|8|@$9|1S|A|1T|B|C]]|E|@$9|1U|A|1V|1|1W]|$9|1X|A|1Y|1|1Z]|$9|20|A|21|1|22]]|F|$]]|$1|V|3|W|5|6|7|23|8|@$9|24|A|25|B|C]]|E|@]|F|$]]|$1|X|3|-4|5|6|7|26|8|@]|E|@]|F|$]]]|Y|$Z|$5|10|11|12|F|$13|14]]|15|$5|10|11|12|F|$13|16]]|17|$5|10|11|12|F|$13|18]]]]

From a recent discussion with the Angular guys on this very topic: For future-proofing reasons, you should not use <code>$$phase</code>

When pressed for the "right" way to do it, the answer is currently

<pre><code>$timeout(function() {
 // anything you want can go here and will safely be run on the next digest.
})
</code></pre>

I recently ran into this when writing angular services to wrap the facebook, google, and twitter APIs which, to varying degrees, have callbacks handed in.

Here's an example from within a service. (For the sake of brevity, the rest of the service -- that set up variables, injected $timeout etc. -- has been left off.)

<pre><code>window.gapi.client.load('oauth2', 'v2', function() {
 var request = window.gapi.client.oauth2.userinfo.get();
 request.execute(function(response) {
 // This happens outside of angular land, so wrap it in a timeout 
 // with an implied apply and blammo, we're in action.
 $timeout(function() {
 if(typeof(response['error']) !== 'undefined'){
 // If the google api sent us an error, reject the promise.
 deferred.reject(response);
 }else{
 // Resolve the promise with the whole response if ok.
 deferred.resolve(response);
 }
 });
 });
});
</code></pre>

Note that the delay argument for $timeout is optional and will default to 0 if left unset (<a href="https://github.com/angular/angular.js/blob/v1.2.0-rc.2/src/ng/timeout.js#L41">$timeout</a> calls <a href="https://github.com/angular/angular.js/blob/v1.2.0-rc.2/src/ng/browser.js">$browser.defer</a> which <a href="https://github.com/angular/angular.js/blob/v1.2.0-rc.2/src/ng/browser.js#L344">defaults to 0 if delay isn't set</a>)

A little non-intuitive, but that's the answer from the guys writing Angular, so it's good enough for me!

blocks|key|2044889|text|多年来，for为我们创建了一个可重用的$safeApply函数，做得很好：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2044890|https://github.com/yearofmoo/AngularJS-Scope.SafeApply|blockquote|offset|length|2044891|用法：|2044892|//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);|code-block|syntax|javascript|2044893|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|1I|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@$E|W|F|X|1|Y]]|A|$]]|$1|G|3|H|5|6|7|Z|8|@]|9|@]|A|$]]|$1|I|3|J|5|K|7|10|8|@]|9|@]|A|$L|M]]|$1|N|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|O|$P|$5|Q|R|S|A|$T|C]]]]

yearofmoo did a great job at creating a reusable $safeApply function for us : 

<blockquote>
 <a href="https://github.com/yearofmoo/AngularJS-Scope.SafeApply" rel="nofollow">https://github.com/yearofmoo/AngularJS-Scope.SafeApply</a>
</blockquote>

Usage :

<pre><code>//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);
</code></pre>

blocks|key|1016708|text|了解到角文档调用检查$$phase+an+反模式，我试着让$timeout和_.defer工作。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1016709|超时和延迟方法会像失足一样在dom中创建一个未解析的失足内容的闪存。对我来说，这是不可接受的。它使我没有太多的教条告诉我，有些东西是一个黑客，没有一个合适的选择。|1016710|唯一有效的方法是：|1016711|if(scope.$$phase+!==+'$digest'){+scope.$digest()+}。|1016712|我不明白这种方法的危险，也不明白为什么评论和团队中的人会把它描述为黑客。这条命令似乎精确易懂：|1016713|“做好文摘，除非已经发生了”|blockquote|1016714|在CoffeeScript中，它甚至更漂亮：|1016715|scope.$digest()+unless+scope.$$phase+is+'$digest'|1016716|这有什么问题吗？有其他的方法不会造成失败吗？$safeApply看起来很好，但也使用了$$phase检查方法。|1016717|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/angular/angular.js/wiki/Anti-Patterns|1|http://www.paulirish.com/2009/fighting-the-font-face-fout/|2|3|https://github.com/yearofmoo/AngularJS-Scope.SafeApply^0|A|7|T|8|12|7|L|3|0|0|9|2|1|Q|2|2|0|0|0|1E|0|0|0|0|0|1D|0|17|7|M|A|3|0^^$0|@$1|2|3|4|5|6|7|19|8|@$9|1A|A|1B|B|C]|$9|1C|A|1D|B|C]|$9|1E|A|1F|B|C]]|D|@$9|1G|A|1H|1|1I]]|E|$]]|$1|F|3|G|5|6|7|1J|8|@]|D|@$9|1K|A|1L|1|1M]|$9|1N|A|1O|1|1P]]|E|$]]|$1|H|3|I|5|6|7|1Q|8|@]|D|@]|E|$]]|$1|J|3|K|5|6|7|1R|8|@$9|1S|A|1T|B|C]]|D|@]|E|$]]|$1|L|3|M|5|6|7|1U|8|@]|D|@]|E|$]]|$1|N|3|O|5|P|7|1V|8|@]|D|@]|E|$]]|$1|Q|3|R|5|6|7|1W|8|@]|D|@]|E|$]]|$1|S|3|T|5|6|7|1X|8|@$9|1Y|A|1Z|B|C]]|D|@]|E|$]]|$1|U|3|V|5|6|7|20|8|@$9|21|A|22|B|C]]|D|@$9|23|A|24|1|25]]|E|$]]|$1|W|3|-4|5|6|7|26|8|@]|D|@]|E|$]]]|X|$Y|$5|Z|10|11|E|$12|13]]|14|$5|Z|10|11|E|$12|15]]|16|$5|Z|10|11|E|$12|15]]|17|$5|Z|10|11|E|$12|18]]]]

Understanding that the Angular documents call checking the <code>$$phase</code> an <a href="https://github.com/angular/angular.js/wiki/Anti-Patterns" rel="nofollow">anti-pattern</a>, I tried to get <code>$timeout</code> and <code>_.defer</code> to work.

The timeout and deferred methods create a flash of unparsed <code>{{myVar}}</code> content in the dom like a <a href="http://www.paulirish.com/2009/fighting-the-font-face-fout/" rel="nofollow">FOUT</a>. For me this was not acceptable. It leaves me without much to be told dogmatically that something is a hack, and not have a suitable alternative.

The only thing that works every time is:

<code>if(scope.$$phase !== '$digest'){ scope.$digest() }</code>.

I don't understand the danger of this method, or why it's described as a hack by people in the comments and the angular team. The command seems precise and easy to read:

<blockquote>
 "Do the digest unless one is already happening"
</blockquote>

In CoffeeScript it's even prettier:

<code>scope.$digest() unless scope.$$phase is '$digest'</code>

What's the issue with this? Is there an alternative that won't create a FOUT? <a href="https://github.com/yearofmoo/AngularJS-Scope.SafeApply" rel="nofollow">$safeApply</a> looks fine but uses the <code>$$phase</code> inspection method, too.

blocks|key|2044941|text|我建议您使用自定义事件，而不是触发摘要周期。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2044942|我发现，广播自定义事件并为该事件注册侦听器是一个很好的解决方案，可以触发您希望发生的操作，无论您是否处于摘要周期中。|2044943|通过创建自定义事件，您还可以提高代码的效率，因为您只会触发订阅了该事件的侦听器，而不会像调用范围.$apply那样触发绑定到该范围的所有监视。|2044944|$scope.$on('customEventName',+function+(optionalCustomEventArguments)+{
+++//TODO:+Respond+to+event
});


$scope.$broadcast('customEventName',+optionalCustomEventArguments);|code-block|syntax|javascript|2044945|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|O|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|P|8|@]|9|@]|A|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

I would advise you to use a custom event rather than triggering a digest cycle.

I've come to find that broadcasting custom events and registering listeners for this events is a good solution for triggering an action you wish to occur whether or not you are in a digest cycle. 

By creating a custom event you are also being more efficient with your code because you are only triggering listeners subscribed to said event and NOT triggering all watches bound to the scope as you would if you invoked scope.$apply.

<pre><code>$scope.$on('customEventName', function (optionalCustomEventArguments) {
 //TODO: Respond to event
});


$scope.$broadcast('customEventName', optionalCustomEventArguments);
</code></pre>

blocks|key|1016731|text|请参阅http://docs.angularjs.org/error/$rootScope:inprog|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1016732|当您调用$apply时，有时在角码之外异步运行(当应该使用$apply时)，有时在角码内同步运行(这会导致$digest+already+in+progress错误)，就会出现问题。|style|CODE|1016733|例如，当您拥有一个从服务器异步获取项目并缓存它们的库时，可能会发生这种情况。第一次请求项时，将异步检索该项，以避免阻止代码执行。但是，第二次，该项已经在缓存中，因此可以同步检索。|1016734|防止此错误的方法是确保异步运行调用$apply的代码。这可以通过在对$timeout的调用中运行代码来完成，延迟设置为0+(这是默认的)。但是，在$timeout中调用代码将消除调用$apply的必要性，因为$timeout将自动触发另一个$digest循环，这反过来将执行所有必要的更新，等等。|1016735|溶液|BOLD|1016736|简而言之，不是这样做的：|1016737|...+your+controller+code...

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

...+more+of+your+controller+code...|code-block|syntax|javascript|1016738|这样做：|1016739|...+your+controller+code...

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

...+more+of+your+controller+code...|1016740|只有当您知道正在运行的代码时才调用$apply，它将始终在角代码之外运行(例如，您对$apply的调用将发生在由角代码之外的代码调用的回调中)。|1016741|除非有人意识到使用$timeout+over+$apply会有一些不利之处，否则我不明白为什么不能总是使用$timeout+(具有零延迟)而不是$apply，因为它将做大致相同的事情。|1016742|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.angularjs.org/error/$rootScope:inprog^0|3|1D|0|0|4|6|1H|R|0|0|H|6|Y|8|1N|1|21|8|2J|6|3C|7|0|0|2|0|0|0|0|0|H|6|0|9|8|N|6|1H|8|20|6|0^^$0|@$1|2|3|4|5|6|7|1B|8|@]|9|@$A|1C|B|1D|1|1E]]|C|$]]|$1|D|3|E|5|6|7|1F|8|@$A|1G|B|1H|F|G]|$A|1I|B|1J|F|G]]|9|@]|C|$]]|$1|H|3|I|5|6|7|1K|8|@]|9|@]|C|$]]|$1|J|3|K|5|6|7|1L|8|@$A|1M|B|1N|F|G]|$A|1O|B|1P|F|G]|$A|1Q|B|1R|F|G]|$A|1S|B|1T|F|G]|$A|1U|B|1V|F|G]|$A|1W|B|1X|F|G]]|9|@]|C|$]]|$1|L|3|M|5|6|7|1Y|8|@$A|1Z|B|20|F|N]]|9|@]|C|$]]|$1|O|3|P|5|6|7|21|8|@]|9|@]|C|$]]|$1|Q|3|R|5|S|7|22|8|@]|9|@]|C|$T|U]]|$1|V|3|W|5|6|7|23|8|@]|9|@]|C|$]]|$1|X|3|Y|5|S|7|24|8|@]|9|@]|C|$T|U]]|$1|Z|3|10|5|6|7|25|8|@$A|26|B|27|F|G]]|9|@]|C|$]]|$1|11|3|12|5|6|7|28|8|@$A|29|B|2A|F|G]|$A|2B|B|2C|F|G]|$A|2D|B|2E|F|G]|$A|2F|B|2G|F|G]]|9|@]|C|$]]|$1|13|3|-4|5|6|7|2H|8|@]|9|@]|C|$]]]|14|$15|$5|16|17|18|C|$19|1A]]]]

See <a href="http://docs.angularjs.org/error/$rootScope:inprog">http://docs.angularjs.org/error/$rootScope:inprog</a>

The problem arises when you have a call to <code>$apply</code> that is sometimes run asynchronously outside of Angular code (when $apply should be used) and sometimes synchronously inside Angular code (which causes the <code>$digest already in progress</code> error).

This may happen, for example, when you have a library that asynchronously fetches items from a server and caches them. The first time an item is requested, it will be retrieved asynchronously so as not to block code execution. The second time, however, the item is already in cache so it can be retrieved synchronously.

The way to prevent this error is to ensure that the code that calls <code>$apply</code> is run asynchronously. This can be done by running your code inside a call to <code>$timeout</code> with the delay set to <code>0</code> (which is the default). However, calling your code inside <code>$timeout</code> removes the necessity to call <code>$apply</code>, because $timeout will trigger another <code>$digest</code> cycle on its own, which will, in turn, do all the necessary updating, etc.

Solution

In short, instead of doing this:

<pre><code>... your controller code...

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

... more of your controller code...
</code></pre>

do this:

<pre><code>... your controller code...

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

... more of your controller code...
</code></pre>

Only call <code>$apply</code> when you know the code running it will always be run outside of Angular code (e.g. your call to $apply will happen inside a callback that is called by code outside of your Angular code).

Unless someone is aware of some impactful disadvantage to using <code>$timeout</code> over <code>$apply</code>, I don't see why you couldn't always use <code>$timeout</code> (with zero delay) instead of <code>$apply</code>, as it will do approximately the same thing.

blocks|key|2045072|text|在https://coderwall.com/p/ngisma中，Nathan+(页面底部附近)建议在$rootScope中使用一个装饰器来创建func+'safeApply'，代码：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2045073|yourAwesomeModule.config([
++'$provide',+function($provide)+{
++++return+$provide.decorator('$rootScope',+[
++++++'$delegate',+function($delegate)+{
++++++++$delegate.safeApply+=+function(fn)+{
++++++++++var+phase+=+$delegate.$$phase;
++++++++++if+(phase+===+"$apply"+%7C%7C+phase+===+"$digest")+{
++++++++++++if+(fn+&&+typeof+fn+===+'function')+{
++++++++++++++fn();
++++++++++++}
++++++++++}+else+{
++++++++++++$delegate.$apply(fn);
++++++++++}
++++++++};
++++++++return+$delegate;
++++++}
++++]);
++}
]);|code-block|syntax|javascript|2045074|entityMap|0|LINK|mutability|MUTABLE|url|https://coderwall.com/p/ngisma^0|1|U|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

Found this: <a href="https://coderwall.com/p/ngisma" rel="nofollow">https://coderwall.com/p/ngisma</a> where Nathan Walker (near bottom of page) suggests a decorator in $rootScope to create func 'safeApply', code:

<pre><code>yourAwesomeModule.config([
 '$provide', function($provide) {
 return $provide.decorator('$rootScope', [
 '$delegate', function($delegate) {
 $delegate.safeApply = function(fn) {
 var phase = $delegate.$$phase;
 if (phase === "$apply" || phase === "$digest") {
 if (fn &amp;&amp; typeof fn === 'function') {
 fn();
 }
 } else {
 $delegate.$apply(fn);
 }
 };
 return $delegate;
 }
 ]);
 }
]);
</code></pre>

blocks|key|1568585|text|这里的许多答案包含了很好的建议，但也可能导致混淆。简单地使用$timeout不是最好的解决方案，也不是正确的解决方案。此外，如果您关心性能或可伸缩性，请务必阅读。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1568586|你应该知道的事|1568587|$$phase对框架是私有的，这是有充分理由的。|unordered-list-item|1568588|$timeout(callback)将等待当前摘要周期(如果有的话)完成，然后执行回调，然后在结束时运行一个完整的$apply。|1568589|$timeout(callback,+delay,+false)也会这样做(在执行回调之前有一个可选的延迟)，但是不会触发一个$apply+(第三个参数)，如果您不修改角度模型($scope)，这会节省性能。|1568590|$scope.$apply(callback)除其他外调用$rootScope.$digest，这意味着它将重新消化应用程序的根范围及其所有子级，即使您是在一个独立的范围内。|1568591|$scope.$digest()将简单地将其模型同步到视图，但不会消化它的父作用域，这可以在使用隔离作用域(大部分来自指令)处理HTML的孤立部分时节省大量性能。$digest不接受回调:您执行代码，然后消化。|1568592|$scope.$evalAsync(callback)是在angularjs1.2中引入的，可能会解决大部分问题。请参考最后一段来了解更多。|1568593|如果您得到了$digest+already+in+progress+error，那么您的体系结构是错误的:要么您不需要重新消化您的范围，要么您不应该负责这个问题(参见下面)。|1568594|如何构造代码|1568595|当您得到这个错误时，您正在尝试消化您的作用域，而它已经在进行中:由于您不知道您的作用域在那时的状态，所以您不负责处理它的消化。|1568596|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);
});|code-block|syntax|javascript|1568597|如果您知道自己在做什么，并且在大角度应用程序中使用一个孤立的小指令，那么您可以选择$digest而不是$apply来保存性能。|1568598|自Angularjs+1.2以来的更新|1568599|在任何$scope：$evalAsync中都添加了一个新的、强大的方法。基本上，如果出现一个摘要周期，它将在当前摘要周期内执行回调，否则一个新的摘要周期将开始执行回调。|1568600|如果您真的知道您只需要同步HTML中的一个独立部分(因为如果没有正在进行的话，就会触发一个新的$apply+)，那么这仍然不如$apply好，但是当您正在执行一个您不知道是否将同步执行的函数时，这是最好的解决方案，例如在获取可能缓存的资源之后:有时这将需要对服务器进行异步调用，否则资源将在本地同步获取。|1568601|在这些情况下和所有其他有!$scope.$$phase的地方，一定要使用$scope.$evalAsync(+callback+)|1568602|entityMap^0|U|8|0|0|0|7|0|0|I|1L|6|0|0|W|1R|6|0|0|N|T|I|0|0|G|0|0|R|0|6|X|0|0|0|0|0|0|A|A|0|1B|6|1R|6|0|C|F|10|T|0^^$0|@$1|2|3|4|5|6|7|1H|8|@$9|1I|A|1J|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1K|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|1L|8|@$9|1M|A|1N|B|C]]|D|@]|E|$]]|$1|K|3|L|5|J|7|1O|8|@$9|1P|A|1Q|B|C]|$9|1R|A|1S|B|C]]|D|@]|E|$]]|$1|M|3|N|5|J|7|1T|8|@$9|1U|A|1V|B|C]|$9|1W|A|1X|B|C]]|D|@]|E|$]]|$1|O|3|P|5|J|7|1Y|8|@$9|1Z|A|20|B|C]|$9|21|A|22|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|J|7|23|8|@$9|24|A|25|B|C]]|D|@]|E|$]]|$1|S|3|T|5|J|7|26|8|@$9|27|A|28|B|C]]|D|@]|E|$]]|$1|U|3|V|5|J|7|29|8|@$9|2A|A|2B|B|C]]|D|@]|E|$]]|$1|W|3|X|5|6|7|2C|8|@]|D|@]|E|$]]|$1|Y|3|Z|5|6|7|2D|8|@]|D|@]|E|$]]|$1|10|3|11|5|12|7|2E|8|@]|D|@]|E|$13|14]]|$1|15|3|16|5|6|7|2F|8|@]|D|@]|E|$]]|$1|17|3|18|5|6|7|2G|8|@]|D|@]|E|$]]|$1|19|3|1A|5|6|7|2H|8|@$9|2I|A|2J|B|C]]|D|@]|E|$]]|$1|1B|3|1C|5|6|7|2K|8|@$9|2L|A|2M|B|C]|$9|2N|A|2O|B|C]]|D|@]|E|$]]|$1|1D|3|1E|5|6|7|2P|8|@$9|2Q|A|2R|B|C]|$9|2S|A|2T|B|C]]|D|@]|E|$]]|$1|1F|3|-4|5|6|7|2U|8|@]|D|@]|E|$]]]|1G|$]]

Many of the answers here contain good advices but can also lead to confusion. Simply using <code>$timeout</code> is not the best nor the right solution.
Also, be sure to read that if you are concerned by performances or scalability.

<h2>Things you should know</h2>

<ul>
<li><code>$$phase</code> is private to the framework and there are good reasons for that.</li>
<li><code>$timeout(callback)</code> will wait until the current digest cycle (if any) is done, then execute the callback, then run at the end a full <code>$apply</code>.</li>
<li><code>$timeout(callback, delay, false)</code> will do the same (with an optional delay before executing the callback), but will not fire an <code>$apply</code> (third argument) which saves performances if you didn't modify your Angular model ($scope).</li>
<li><code>$scope.$apply(callback)</code> invokes, among other things, <code>$rootScope.$digest</code>, which means it will redigest the root scope of the application and all of its children, even if you're within an isolated scope.</li>
<li><code>$scope.$digest()</code> will simply sync its model to the view, but will not digest its parents scope, which can save a lot of performances when working on an isolated part of your HTML with an isolated scope (from a directive mostly). $digest does not take a callback: you execute the code, then digest.</li>
<li><code>$scope.$evalAsync(callback)</code> has been introduced with angularjs 1.2, and will probably solve most of your troubles. Please refer to the last paragraph to learn more about it.</li>
<li>if you get the <code>$digest already in progress error</code>, then your architecture is wrong: either you don't need to redigest your scope, or you should not be in charge of that (see below).</li>
</ul>

<h2>How to structure your code</h2>

When you get that error, you're trying to digest your scope while it's already in progress: since you don't know the state of your scope at that point, you're not in charge of dealing with its digestion.

<pre><code>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);
});
</code></pre>

And if you know what you're doing and working on an isolated small directive while part of a big Angular application, you could prefer $digest instead over $apply to save performances.

<h2>Update since Angularjs 1.2</h2>

A new, powerful method has been added to any $scope: <code>$evalAsync</code>. Basically, it will execute its callback within the current digest cycle if one is occurring, otherwise a new digest cycle will start executing the callback.

That is still not as good as a <code>$scope.$digest</code> if you really know that you only need to synchronize an isolated part of your HTML (since a new <code>$apply</code> will be triggered if none is in progress), but this is the best solution when you are executing a function which you cannot know it if will be executed synchronously or not, for instance after fetching a resource potentially cached: sometimes this will require an async call to a server, otherwise the resource will be locally fetched synchronously.

In these cases and all the others where you had a <code>!$scope.$$phase</code>, be sure to use <code>$scope.$evalAsync( callback )</code>

blocks|key|2045229|text|您应该根据上下文使用$evalAsync或$timeout。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2045230|这是一个有很好解释的链接：|2045231|http://www.bennadel.com/blog/2605-scope-evalasync-vs-timeout-in-angularjs.htm|blockquote|offset|length|2045232|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|0|25|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|R|8|@]|9|@$G|S|H|T|1|U]]|A|$]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|J|$K|$5|L|M|N|A|$O|E]]]]

You should use $evalAsync or $timeout according to the context.

This is a link with a good explanation: 

<blockquote>
 <a href="http://www.bennadel.com/blog/2605-scope-evalasync-vs-timeout-in-angularjs.htm" rel="nofollow">http://www.bennadel.com/blog/2605-scope-evalasync-vs-timeout-in-angularjs.htm</a>
</blockquote>

blocks|key|1568748|text|安全$apply的最短形式是：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1568749|$timeout(angular.noop)|code-block|syntax|javascript|1568750|entityMap^0|2|6|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

The shortest form of safe <code>$apply</code> is:

<pre><code>$timeout(angular.noop)
</code></pre>

blocks|key|1568752|text|这将解决你的问题：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1568753|if(!$scope.$$phase)+{
++//TODO
}|code-block|syntax|javascript|1568754|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

This will be solve your problem:

<pre><code>if(!$scope.$$phase) {
 //TODO
}
</code></pre>

blocks|key|2045274|text|使用$scope.$$phase+%7C%7C+$scope.$apply();代替|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2045275|entityMap^0|2|Y|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

use <code>$scope.$$phase || $scope.$apply();</code> instead

blocks|key|1014820|text|这是我的功用服务：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1014821|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);
++++++++}
++++};
});|code-block|syntax|javascript|1014822|这是它的用法的一个例子：|1014823|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']);
};|1014824|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

This is my utils service:

<pre><code>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);
 }
 };
});
</code></pre>

and this is an example for it's usage:

<pre><code>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']);
};
</code></pre>

blocks|key|1014826|text|类似于上面的答案，但这对我很有用.在服务中添加：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1014827|++++//sometimes+you+need+to+refresh+scope,+use+this+to+prevent+conflict
++++this.applyAsNeeded+=+function+(scope)+{
++++++++if+(!scope.$$phase)+{
++++++++++++scope.$apply();
++++++++}
++++};|code-block|syntax|javascript|1014828|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

similar to answers above but this has worked faithfully for me...
in a service add:

<pre><code> //sometimes you need to refresh scope, use this to prevent conflict
 this.applyAsNeeded = function (scope) {
 if (!scope.$$phase) {
 scope.$apply();
 }
 };
</code></pre>

blocks|key|1568814|text|我一直在使用这种方法，它似乎工作得很好。这只是等待周期结束的时间，然后触发apply()。只需从您想要的任何地方调用函数apply(<your+scope>)即可。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1568815|function+apply(scope)+{
++if+(!scope.$$phase+&&+!scope.$root.$$phase)+{
++++scope.$apply();
++++console.log("Scope+Apply+Done+!!");
++}+
++else+{
++++console.log("Scheduling+Apply+after+200ms+digest+cycle+already+in+progress");
++++setTimeout(function()+{
++++++++apply(scope)
++++},+200);
++}
}|code-block|syntax|javascript|1568816|entityMap^0|11|7|1O|J|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|L|$]]

I have been using this method and it seems to work perfectly fine. This just waits for the time the cycle has finished and then triggers <code>apply()</code>. Simply call the function <code>apply(&lt;your scope&gt;)</code> from anywhere you want.

<pre><code>function apply(scope) {
 if (!scope.$$phase &amp;&amp; !scope.$root.$$phase) {
 scope.$apply();
 console.log("Scope Apply Done !!");
 } 
 else {
 console.log("Scheduling Apply after 200ms digest cycle already in progress");
 setTimeout(function() {
 apply(scope)
 }, 200);
 }
}
</code></pre>

blocks|key|1568818|text|您可以使用$timeout来防止错误。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1568819|$timeout(function+()+{
++++var+scope+=+angular.element($("#myController")).scope();
++++scope.myMethod();+
++++scope.$scope();
},+1);|code-block|syntax|javascript|1568820|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.angularjs.org/api/ng/service/$timeout^0|5|8|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

You can use <a href="https://docs.angularjs.org/api/ng/service/$timeout" rel="nofollow noreferrer"><code>$timeout</code></a> to prevent the error.
<pre><code>$timeout(function () {
 var scope = angular.element($(&quot;#myController&quot;)).scope();
 scope.myMethod(); 
 scope.$scope();
}, 1);
</code></pre>

blocks|key|2045399|text|首先，不要这样修理它|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2045400|if+(+!+$scope.$$phase)+{+
++$scope.$apply();+
}|code-block|syntax|javascript|2045401|这是没有意义的，因为$phase只是$digest循环的一个布尔标志，因此您的$apply()有时不会运行。记住这是个糟糕的练习。|2045402|相反，使用$timeout|offset|length|style|CODE|2045403|++++$timeout(function(){+
++//+Any+code+in+here+will+automatically+have+an+$scope.apply()+run+afterwards+
$scope.myvar+=+newValue;+
++//+And+it+just+works!+
});|2045404|如果您使用的是下划线或存档，则可以使用defer():|BOLD|2045405|_.defer(function(){+
++$scope.$apply();+
});|2045406|entityMap^0|0|0|0|5|8|0|0|0|R|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Y|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Z|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|10|8|@$K|11|L|12|M|N]]|9|@]|A|$]]|$1|O|3|P|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|Q|3|R|5|6|7|14|8|@$K|15|L|16|M|S]]|9|@]|A|$]]|$1|T|3|U|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|V|3|-4|5|6|7|18|8|@]|9|@]|A|$]]]|W|$]]

First of all, don’t fix it this way

<pre><code>if ( ! $scope.$$phase) { 
 $scope.$apply(); 
}
</code></pre>

It does not make sense because $phase is just a boolean flag for the $digest cycle, so your $apply() sometimes won’t run. And remember it’s a bad practice.

Instead, use <code>$timeout</code>

<pre><code> $timeout(function(){ 
 // Any code in here will automatically have an $scope.apply() run afterwards 
$scope.myvar = newValue; 
 // And it just works! 
});
</code></pre>

If you are using underscore or lodash, you can use defer():

<pre><code>_.defer(function(){ 
 $scope.$apply(); 
});
</code></pre>

blocks|key|1016986|text|试着使用|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1016987|$scope.applyAsync(function()+{
++++//+your+code
});|code-block|syntax|javascript|1016988|而不是|1016989|if(!$scope.$$phase)+{
++//$digest+or+$apply
}|1016990|$applyAsync计划在稍后时间调用$apply。这可以用来对需要在同一摘要中计算的多个表达式进行排队。|1016991|注意:在$digest中，只有当当前作用域是$rootScope时，$applyAsync()才会刷新。这意味着，如果在子作用域中调用$digest，它将不会隐式地刷新$applyAsync()队列。|1016992|例外：|1016993|++$scope.$applyAsync(function+()+{
++++++++++++++++if+(!authService.authenticated)+{
++++++++++++++++++++return;
++++++++++++++++}

++++++++++++++++if+(vm.file+!==+null)+{
++++++++++++++++++++loadService.setState(SignWizardStates.SIGN);
++++++++++++++++}+else+{
++++++++++++++++++++loadService.setState(SignWizardStates.UPLOAD_FILE);
++++++++++++++++}
++++++++++++});|1016994|参考文献：|1016995|1.AngularJS+1.3中的范围$applyAsync()与作用域。$evalAsync()|offset|length|1016996|AngularJs+Docs|ordered-list-item|1016997|entityMap|0|LINK|mutability|MUTABLE|url|https://www.bennadel.com/blog/2751-scope-applyasync-vs-scope-evalasync-in-angularjs-1-3.htm|1|https://docs.angularjs.org/api/ng/type/$rootScope.Scope#$applyAsync^0|0|0|0|0|0|0|0|0|0|2|1B|0|0|0|E|1|0^^$0|@$1|2|3|4|5|6|7|1B|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|1C|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|1D|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|1E|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|1F|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|1G|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|1H|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|1I|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|1J|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|1K|8|@]|9|@$W|1L|X|1M|1|1N]]|A|$]]|$1|Y|3|Z|5|10|7|1O|8|@]|9|@$W|1P|X|1Q|1|1R]]|A|$]]|$1|11|3|-4|5|6|7|1S|8|@]|9|@]|A|$]]]|12|$13|$5|14|15|16|A|$17|18]]|19|$5|14|15|16|A|$17|1A]]]]

try using 

<pre><code>$scope.applyAsync(function() {
 // your code
});
</code></pre>

instead of

<pre><code>if(!$scope.$$phase) {
 //$digest or $apply
}
</code></pre>

$applyAsync Schedule the invocation of $apply to occur at a later time. This can be used to queue up multiple expressions which need to be evaluated in the same digest.

NOTE: Within the $digest, $applyAsync() will only flush if the current scope is the $rootScope. This means that if you call $digest on a child scope, it will not implicitly flush the $applyAsync() queue.

Exmaple:

<pre><code> $scope.$applyAsync(function () {
 if (!authService.authenticated) {
 return;
 }

 if (vm.file !== null) {
 loadService.setState(SignWizardStates.SIGN);
 } else {
 loadService.setState(SignWizardStates.UPLOAD_FILE);
 }
 });
</code></pre>

References: 

1.<a href="https://www.bennadel.com/blog/2751-scope-applyasync-vs-scope-evalasync-in-angularjs-1-3.htm" rel="noreferrer">Scope.$applyAsync() vs. Scope.$evalAsync() in AngularJS 1.3</a>

<ol start="2">
<li><a href="https://docs.angularjs.org/api/ng/type/$rootScope.Scope#$applyAsync" rel="noreferrer">AngularJs Docs</a></li>
</ol>

blocks|key|1014936|text|当我禁用调试器时，错误不再发生。--在我的例子中是--是因为调试器停止了代码执行。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|1014937|entityMap^0|G|9|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

When I disabled debugger , the error is not happening anymore. In my case, it was because of debugger stopping the code execution.

blocks|key|2045465|text|这个问题基本上是在我们要求以角度来运行消化周期的时候出现的，即使它是在过程中产生的问题，从角度到理解。控制台中的结果异常。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2045466|在$timeout函数中调用scope.$apply()没有任何意义，因为在内部它也是这样做的。|ordered-list-item|2045467|该代码与香草JavaScript函数一起使用，因为它的本机而非角角定义，即setTimeout。|2045468|要做到这一点，您可以利用|2045469|如果(！范围.$阶段){|2045470|+++++++++scope.$evalAsync(function(){|code-block|syntax|javascript|2045471|)；}|2045472|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|U|8|@]|9|@]|A|$]]|$1|E|3|F|5|D|7|V|8|@]|9|@]|A|$]]|$1|G|3|H|5|D|7|W|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|X|8|@]|9|@]|A|$]]|$1|K|3|L|5|M|7|Y|8|@]|9|@]|A|$N|O]]|$1|P|3|Q|5|6|7|Z|8|@]|9|@]|A|$]]|$1|R|3|-4|5|6|7|10|8|@]|9|@]|A|$]]]|S|$]]

The issue is basically coming when, we are requesting to angular to run the digest cycle even though its in process which is creating issue to angular to understanding. consequence exception in console. 
1. It does not have any sense to call scope.$apply() inside the $timeout function because internally it does the same. 
2. The code goes with vanilla JavaScript function because its native not angular angular defined i.e. setTimeout 
3. To do that you can make use of 
 if(!scope.$$phase){ 
 scope.$evalAsync(function(){ 
 });
 }

blocks|key|2045539|text|++++++++let+$timeoutPromise+=+null;
++++++++$timeout.cancel($timeoutPromise);
++++++++$timeoutPromise+=+$timeout(()+=>+{
++++++++++++$scope.$digest();
++++++++},+0,+false);|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|2045540|下面是避免此错误和避免$apply的好解决方案|unstyled|offset|length|style|BOLD|2045541|如果基于外部事件进行调用，则可以将其与can+(0)结合起来。上面是我们正在使用的“反衰退”，以及代码的完整示例。|2045542|.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;
++++++++++++};
++++++++};
++++}
])|2045543|以及侦听某些事件的代码本身，只在需要的$scope上调用|2045544|++++++++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();
++++++++});|2045545|entityMap^0|0|3|E|0|0|0|E|4|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|V|8|@$G|W|H|X|I|J]]|9|@]|A|$]]|$1|K|3|L|5|F|7|Y|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|Z|8|@]|9|@]|A|$B|C]]|$1|O|3|P|5|F|7|10|8|@$G|11|H|12|I|J]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|13|8|@]|9|@]|A|$B|C]]|$1|S|3|-4|5|F|7|14|8|@]|9|@]|A|$]]]|T|$]]

<pre><code> let $timeoutPromise = null;
 $timeout.cancel($timeoutPromise);
 $timeoutPromise = $timeout(() =&gt; {
 $scope.$digest();
 }, 0, false);
</code></pre>

Here is good solution to avoid this error and avoid $apply

you can combine this with debounce(0) if calling based on external event. Above is the 'debounce' we are using, and full example of code

<pre><code>.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;
 };
 };
 }
])
</code></pre>

and the code itself to listen some event and call $digest only on $scope you need

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

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


 $scope.$on('$destroy', () =&gt; {
 $timeout.cancel($update);
 $timeout.cancel($timeoutPromise);
 $unwatchModelChanges();
 });
</code></pre>

I'm finding that I need to update my page to my scope manually more and more since building an application in angular.

The only way I know of to do this is to call <code>$apply()</code> from the scope of my controllers and directives. The problem with this is that it keeps throwing an error to the console that reads :

<blockquote>
 Error: $digest already in progress
</blockquote>

Does anyone know how to avoid this error or achieve the same thing but in a different way?

AngularJS : Prevent error $digest already in progress when calling $scope.$apply()

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我发现我需要手动更新我的页面到我的范围越来越多，因为构建一个应用程序的角度。我知道的唯一方法就是从控制器和指令的范围调用$apply()。这样做的问题是，它不断向控制台抛出一个错误，该控制台读取：错误：$digest已经在进行中有没有人知道如何避免这一错误，或者以不同的方式实现相同的目标？

问AngularJS :在调用$scope.$apply()时防止已经在进行中的错误$digest
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问AngularJS :在调用$scope.$apply()时防止已经在进行中的错误$digestEN