Angularjs 使用ng repeat按多列筛选

我想知道在Angular中是否有一种简单的方法，可以使用

或
逻辑，而不是
和
对特定列使用
ng repeat
来过滤表。现在，我的过滤器正在搜索表中的所有内容（10+列数据），而实际上它只需要过滤2列数据（ID和名称）

我设法让它在过滤时只查看这两列（并查看），但它使用了
和
逻辑，这太具体了。我想让它使用
或
逻辑，但我遇到了麻烦

我的HTML

<input type="text" ng-model="filterText" />
<table>
      <tr ng-repeat="item in data"><td>{{ item.id }}</td><td>{{ item.name }}</td>...</tr>
</table>


{{item.id}{{item.name}}。。。

我的过滤器逻辑：

$filter（'filter'）（数据，{id:$scope.filterText，name:$scope.filterText}）

过滤是有效的，但同样地，它采用的是匹配列的交集，而不是并集。谢谢
 创建一个自定义过滤器并不难，它允许您拥有任意多的参数。下面是一个带有一个和两个参数的过滤器示例，但您可以根据需要添加任意数量的参数

示例JS：

var app = angular.module('myApp',[]);
app.filter('myTableFilter', function(){
  // Just add arguments to your HTML separated by :
  // And add them as parameters here, for example:
  // return function(dataArray, searchTerm, argumentTwo, argumentThree) {
  return function(dataArray, searchTerm) {
      // If no array is given, exit.
      if (!dataArray) {
          return;
      }
      // If no search term exists, return the array unfiltered.
      else if (!searchTerm) {
          return dataArray;
      }
      // Otherwise, continue.
      else {
           // Convert filter text to lower case.
           var term = searchTerm.toLowerCase();
           // Return the array and filter it by looking for any occurrences of the search term in each items id or name. 
           return dataArray.filter(function(item){
              var termInId = item.id.toLowerCase().indexOf(term) > -1;
              var termInName = item.name.toLowerCase().indexOf(term) > -1;
              return termInId || termInName;
           });
      } 
  }    
});

然后在HTML中：

<tr ng-repeat="item in data | myTableFilter:filterText">



或者，如果要使用多个参数：

<tr ng-repeat="item in data | myTableFilter:filterText:argumentTwo:argumentThree">

我找到了答案——我必须编写自己的自定义过滤器。以下是我的解决方案：

var filteredData;

filteredData = $filter('filter')(data, function(data) {
  if ($scope.filter) {
    return data.id.toString().indexOf($scope.filter) > -1 || data.name.toString().indexOf($scope.filter) > -1;
  } else {
    return true;
  }
});

使用此选项搜索所有列（速度可能较慢）：搜索。$

任意列搜索：
...
要扩展@charlietfl的优秀答案，这里有一个自定义筛选器，它按一列（属性）进行筛选，该列将动态传递给函数，而不是硬编码。这将允许您在不同的表中使用筛选器

var app=angular.module('myApp',[]);        
app.filter('filterByProperty', function () {
        /* array is first argument, each addiitonal argument is prefixed by a ":" in filter markup*/
        return function (dataArray, searchTerm, propertyName) {
            if (!dataArray) return;
            /* when term is cleared, return full array*/
            if (!searchTerm) {
                return dataArray
            } else {
                /* otherwise filter the array */
                var term = searchTerm.toLowerCase();
                return dataArray.filter(function (item) {
                    return item[propertyName].toLowerCase().indexOf(term) > -1;
                });
            }
        }
    });

现在在加价方面

<input type="text" ng-model="filterText" />

<table>
  <tr ng-repeat="item in data |filterByProperty:filterText:'name'"><td>{{ item.id }}</td><td>{{ item.name }}</td>...</tr>
</table>


{{item.id}{{item.name}}。。。
很容易我们可以按照以下编写的代码执行此类型，您将很容易创建另一个字段筛选器


var myApp=angular.module（'myApp'，[]）；
myApp.filter（'myfilter'，myfilter）；
函数myfilter（）{
返回函数（项目、过滤器）{
if（过滤器==null）{
退货项目；
}
var筛选=[]；
//应用过滤器
forEach（项，函数（项）{
如果（（filters.Name=''|| angular.lowercase（item.Name）.indexOf（angular.lowercase（filters.Name））>=0）
)
{
过滤、推送（项目）；
}
});
返回过滤；
};
}
myApp.controller（'mycontroller'，['$scope'，函数（$scope）{
$scope.filters={Name:''，MathsMarks:''}；
$scope.students=[]；
var i=0；
对于（i=0；i
数学：{{m.Math}科学：{{m.Science}
这是我的解决方案，它非常懒惰，它将在第一级上搜索数组中的所有字符串，您可以更新它以循环地向下搜索树，但这应该足够好了

app.filter('filterAll', function () {

    return function (dataArray, searchTerm, propertyNames) {
        if (!dataArray) return;    

        if (!searchTerm) {
            return dataArray;
        } else {



            if (propertyNames == undefined) {
                propertyNames = [];

                for (var property in dataArray[0]) {
                    if(typeof dataArray[0][property] == "string" && 
                        property != "$$hashKey" && 
                        property != "UnitName" )
                        propertyNames.push(property);
                }
            }

            console.log("propertyNames", propertyNames);

            var term = searchTerm.toLowerCase();
            return dataArray.filter(function (item) {
                var found = false;
                propertyNames.forEach(function(val) {
                    if (!found) {
                        if (item[val] != null && item[val].toLowerCase().indexOf(term) > -1)
                            found = true;
                    } 
                });
                return found;
            });
        }
    }
});

我创建此筛选器是为了在多个字段中执行搜索：

var find = function () {
    return function (items,array) {
        var model  = array.model;
        var fields = array.fields;
        var clearOnEmpty = array.clearOnEmpty || false;
        var filtered = [];

        var inFields = function(row,query) {
            var finded = false;
            for ( var i in fields ) {
                var field = row[fields[i]];
                if ( field != undefined ) {
                    finded = angular.lowercase(row[fields[i]]).indexOf(query || '') !== -1;
                }
                if ( finded ) break;
            }
            return finded;
        };

        if ( clearOnEmpty && model == "" ) return filtered;

        for (var i in items) {
            var row = items[i];                
            var query = angular.lowercase(model);

            if (query.indexOf(" ") > 0) {
                var query_array = query.split(" ");
                var x;
                for (x in query_array) {
                    query = query_array[x];
                    var search_result = true;
                    if ( !inFields(row,query) ) {
                        search_result = false;
                        break;
                    }
                }
            } else {
                search_result = inFields(row,query);
            }                
            if ( search_result ) {
                filtered.push(row);
            }
        }
        return filtered;
    };
};   

如何使用：

<tr repeat="item in colletion
                    | find: {
                        model : model, // Input model
                        fields : [     // Array of fields to filter
                            'FIELD1',
                            'FIELD2',
                            'FIELD3'
                        ],
                        clearOnEmpty: true // Clear rows on empty model (not obligatory)
                    } "></tr>


请参见
啊-感谢您的回复！我刚刚发布了我自己的回复-看起来我们是同时发布的！回答很好，我添加了一个答案，该答案在您的答案的基础上扩展为以变量形式传递的一列进行过滤。非常好而且简单。我还没有注意到500多个可过滤数据条目的任何性能问题。它工作正常，但是o您知道是否可以只选择2或3个字段？
<tr repeat="item in colletion
                    | find: {
                        model : model, // Input model
                        fields : [     // Array of fields to filter
                            'FIELD1',
                            'FIELD2',
                            'FIELD3'
                        ],
                        clearOnEmpty: true // Clear rows on empty model (not obligatory)
                    } "></tr>