Javascript Array.sort角度过滤器和"；错误：[$rootScope:infdig]已达到10$digest（）次迭代。流产&引用；

我正在尝试对ng repeat指令中的某些元素进行排序

我已经创建了一个自定义过滤器，尽管出现以下错误，但该过滤器仍能正常工作：

“错误：[$rootScope:infdig]已达到10$digest（）次迭代。正在中止！”

从我在其他答案上看到的情况来看，这通常是因为每个过滤器返回的值不同。我已经检查并返回了相同的数组对象…所以我不确定是什么导致了它

.filter('sortOffers', function() {
        return function(vals, predicate, reverse) {
            var vals_old = vals;

            vals.sort(function(a, b) {
                var sorter = reverse ? 1 : -1;

                if(predicate === 'seeking') {
                    if(a.data.valueSought > b.data.valueSought) {
                        return sorter;
                    } else if(a.data.valueSought < b.data.valueSought) {
                        return -sorter;
                    } else {
                        return 0;
                    }
                }

                if(predicate === 'offering') {
                    if(a.data.valueOffered > b.data.valueOffered) {
                        return sorter;
                    } else if(a.data.valueOffered < b.data.valueOffered) {
                        return -sorter;
                    } else {
                        return 0;
                    }
                }
            });

            return vals;
        }
    });

.filter（'sortOffers'，function（）{
返回函数（VAL、谓词、反向）{
var VAL_old=VAL；
VAL.sort（函数（a，b）{
var分拣机=反向？1:-1；
if（谓词=='seeking'）{
如果（a.data.valueseek>b.data.valueseek）{
返回分拣机；
}否则，如果（a.data.valueseekb.data.valueOffered）{
返回分拣机；
}否则如果（a.data.valueOffered

html:

{{offer.data.valueOffered | |'0'}{{{offer.offeringString}}
{{offer.data.valueseekend | |'0'}{{{offer.seekingString}}
接受要约
取消你的报价

在排序之前复制数组。在适当位置修改阵列是触发$watch的原因：

        return vals.slice().sort(function(a, b) {
            var sorter = reverse ? 1 : -1;

            if(predicate === 'seeking') {
                if(a.data.valueSought > b.data.valueSought) {
                    return sorter;
                } else if(a.data.valueSought < b.data.valueSought) {
                    return -sorter;
                } else {
                    return 0;
                }
            }

            if(predicate === 'offering') {
                if(a.data.valueOffered > b.data.valueOffered) {
                    return sorter;
                } else if(a.data.valueOffered < b.data.valueOffered) {
                    return -sorter;
                } else {
                    return 0;
                }
            }
        });

返回vals.slice（）.sort（函数（a，b）{
var分拣机=反向？1:-1；
if（谓词=='seeking'）{
如果（a.data.valueseek>b.data.valueseek）{
返回分拣机；
}否则，如果（a.data.valueseekb.data.valueOffered）{
返回分拣机；
}否则如果（a.data.valueOffered

---

我相信ng repeat$使用$watchCollection监视右侧（rhs）表达式的更改$watchCollection不按引用比较数组，而是查找长度差异，并将逐项比较数组。

在排序之前复制数组。在适当位置修改阵列是触发$watch的原因：

        return vals.slice().sort(function(a, b) {
            var sorter = reverse ? 1 : -1;

            if(predicate === 'seeking') {
                if(a.data.valueSought > b.data.valueSought) {
                    return sorter;
                } else if(a.data.valueSought < b.data.valueSought) {
                    return -sorter;
                } else {
                    return 0;
                }
            }

            if(predicate === 'offering') {
                if(a.data.valueOffered > b.data.valueOffered) {
                    return sorter;
                } else if(a.data.valueOffered < b.data.valueOffered) {
                    return -sorter;
                } else {
                    return 0;
                }
            }
        });

返回vals.slice（）.sort（函数（a，b）{
var分拣机=反向？1:-1；
if（谓词=='seeking'）{
如果（a.data.valueseek>b.data.valueseek）{
返回分拣机；
}否则，如果（a.data.valueseekb.data.valueOffered）{
返回分拣机；
}否则如果（a.data.valueOffered

---

我相信ng repeat$使用$watchCollection监视右侧（rhs）表达式的更改$watchCollection不按引用比较数组，而是查找长度差异，还将逐项比较数组。

因此这里的问题是基于在筛选器中修改数组这一事实。但是，有一种方法可以解决这个问题，如本机过滤器的原始源代码所示

数组本身正在被

.sort（）

函数修改，从而触发

$digest

循环。使用将创建一个可以排序的新数组，并且可以在不触发

$digest

的情况下返回新数组

return vals.slice().sort(function(a, b) {

这里有更多的上下文

返回与原始数组具有相同数据结构的不同数组没有什么错。事实上，如果要删除项，则必须返回与原始数组不同的数组。令人困惑的是，您无法返回

值发生更改的数组（原始数组或副本）。通过使用
.slice（）

但是，接收数组并使用它计算数据并返回具有完全不同结构的不同数组的筛选器将不起作用。
因此，这里的问题是基于在筛选器中修改数组这一事实。但是，有一种方法可以解决这个问题，如本机过滤器的原始源代码所示

数组本身正在被
.sort（）
函数修改，从而触发
$digest
循环。使用将创建一个可以排序的新数组，并且可以在不触发
$digest
的情况下返回新数组

return vals.slice().sort(function(a, b) {

这里有更多的上下文

返回与原始数组具有相同数据结构的不同数组没有什么错。事实上，如果要删除项，则必须返回与原始数组不同的数组。令人困惑的是，您无法返回数组（