Javascript过滤具有另一个数组的关联数组

如何用另一个关联数组过滤关联数组

function filter (a,f) {
    console.log (a) ;
    console.log (f) ;  

    //Using f as filter, How to get only these rows fom a ?
    //{"XD_A":"XDR","XD_B_1":"38","XD_B_2":"PB"},
    //{"XD_A":"XDR","XD_B_1":"38","XD_B_2":"PB"},                
}

function test() {
    var data = [{"XD_A":"XDL","XD_B_1":"38","XD_B_2":"PB"},
    {"XD_A":"XDR","XD_B_1":"51","XD_B_2":"PB"},
    {"XD_A":"XDL","XD_B_1":"58","XD_B_2":"PB"},
    {"XD_A":"XDR","XD_B_1":"38","XD_B_2":"PB"},
    {"XD_A":"XDL","XD_B_1":"76","XD_B_2":"PB"},
    {"XD_A":"XDR","XD_B_1":"38","XD_B_2":"PB"}] ;
    var filters =[{"XD_A":"XDR"},{"XD_B_1":"38"}] ;
    filter (data,filters) ;
}

提前感谢,

致意

马西莫

let data=[{“XD_A”：“XDL”，“XD_B_1”：“38”，“XD_B_2”：“PB”}，
{“XD_A”：“XDR”，“XD_B_1”：“51”，“XD_B_2”：“PB”}，
{“XD_A”：“XDL”，“XD_B_1”：“58”，“XD_B_2”：“PB”}，
{“XD_A”：“XDR”，“XD_B_1”：“38”，“XD_B_2”：“一”}，
{“XD_A”：“XDL”，“XD_B_1”：“76”，“XD_B_2”：“PB”}，
{“XD_A”：“XDR”，“XD_B_1”：“38”，“XD_B_2”：“两”}]，
过滤器=[{“XD_A”：“XDR”}，{“XD_B_1”：“38”}]；
控制台信息（过滤器（数据，过滤器））；
函数过滤器（d，f）{
返回数据。过滤器（e=>{
试一试{
f、 forEach（o=>{
Object.keys（o）.forEach（key=>{
如果（e[键]！==o[键]）抛出新的1；
});
});
返回true；
}捕获（e）{
返回false；
}
});
}

您可以在不使用

try catch

块的情况下调整阵列

函数过滤器（数据，过滤器）{
返回数据。过滤器（函数（d）{
返回过滤器。每个（函数（f）{
var k=Object.keys（f）[0]；
返回d[k]==f[k]；
});
});
}
“38”、“XD\U B\U 2”：“38”、“XDU B\U 2”：“PB”}，，{“XDU A A”：“XDR”、“XDR”、“XDU U A A”：“XDR”、“XDR”、“XDU U B\U A A”：“51”、“51”、“51”、“XDU U A A A A A A”：“51”、“51”、“XDU U A A A A A A”：“XDL”、“XDU U U 1 1 1 1”：“38”、“38”、“XDL”、“XDL”、“XDU B\U 1周一周一周一周一”、“1”1”1”1除了除了除了除了除了除了除了除了除了除了除了除了除了除了除了除了除了1以外，1以外，1个除了除了除了除了除了除了1以外，1以外，1““““““““”、“1”1”、“8”、“8”、“8”、“8”、“8”、“8”、“8”、“8”、“8”、“8”、“8”、“8”、“8”、“8”、“8”、“8”、“8”、“8”、“8”以及以及从从从从从从从从从从从从PB}，{“XD_A”：“XDR”，“XD_B_1”：“38”，“XD_B_2”：“PB}]，
过滤器=[{“XD_A”：“XDR”}，{“XD_B_1”：“38”}]；
日志（过滤器（数据，过滤器））
.as控制台包装{最大高度：100%！重要；顶部：0；}
关联数组排序，hmmm？我想用一种非ES6的方式来做这件事（因为我在几分钟内就找到了它的解决方案；borrrrrring.JK我爱你ES6！）。我使用了你自己例子中的确切标准

这是一种非库、非ES6方式（以防万一，只是为了好玩），其中包括一些使用args的额外输出结果：
包含
，
结果
，
严格

当过滤器需要增加/减少时，它也会缩放。注意：它不会以多个对象属性作为条件进行过滤，而是完全按照您发布的内容进行过滤：使用多个“关联数组”的数组项（但显然可以更改这一点）

这是我在SO上的第一篇帖子，在使用多年之后（对不起）。无论如何，希望它对你（）和其他人有效，Massimo

PS-如果它是垃圾/马车，我会设法找时间帮你修理

/**
* _filterStrict only gives back data if both filter criteria are satisfied
* @param data {obj}
*        filterList {arr}
* @returns bool
*/
var _filterStrict = function(data, filterList) {
  var filterLength = filterList.length
  // handy little truthy array
  var strictMatchResults = []
    for (var i = 0; i < filterLength; ++i) {
    for (var prop in filterList[i]) {
        // we need to match both the property and value
        if (data.hasOwnProperty(prop) && data[prop] === filterList[i][prop]) {
        strictMatchResults.push(true)
      } else {
        // no truthy for you! YOU CAN'T HANDLE THE TRUTH!
        continue;
      }
    }
  }
  return strictMatchResults.length === filterLength ? true : false
}

/**
* _filterContains loose check; if data is found to be matching, it's a match.
* @param prop {str}
*        val {str} // !could be extended to allow more types!
*        filterList {arr}
* @returns bool
*/
var _filterContains = function(prop, val, filterList) {
  var filterLength = filterList.length
  var found = []
    for (var i = 0; i < filterLength; ++i) {
    // we need to match both the property and value
    if (filterList[i].hasOwnProperty(prop) && filterList[i][prop] === val) {
        return true
    } else {
        // "W-w-what? I have to go back to the expression, again? Ugh."
        continue;
    }
  }
}

/**
* _filterChoose detects which filter to use via filterMode and selects
*   the appropriate internal filter
* @param dataToCheck {obj}
*        filterList {arr}
*        filterMode {str}
* @returns arr
*/
var _filterChoose = function(dataToCheck, filterList, filterMode) {
  var dataMatchesFilter = null
  var initObjFlag = false
  var filterLength = filterList.length

  // run in "strict search" mode
  if (filterMode === 'strict') {        
    return _filterStrict(dataToCheck, filterList) ? dataToCheck : null
  }

  // loop through slice of data
  for (var prop in dataToCheck) {
    var val = dataToCheck[prop]
    // check against filter criteria
    if (_filterContains(prop, val, filterList)) {
        // only create the object literal once
      if (initObjFlag === false) {
          initObjFlag = true
        dataMatchesFilter = {}
      }
      // only return the found results from the array
      if (filterMode === 'results') {
        dataMatchesFilter[prop] = val
      }
      // return the whole value if the data matches anywhere in the array
      if (filterMode === 'contains' || filterMode === '' || filterMode === undefined) {
        dataMatchesFilter = dataToCheck
      }  
    }
  }
  return dataMatchesFilter
}

/**
* Filter "associative array" [{"str":"str"}]
*   - Searches one level deep.
*   - Filter Mode settings:
*        * <contains|''|undefined> - loose search; returns whole object if even one *              match is found. This is the default.
*        * results - returns results only (does not include any other original values)
*        * strict - returns a match only if *all* filter criteria are met
*
* @param data {arr}
*        filterList {arr}
*        filterMode {str} - possible values: '', contains', 'results', 'strict'
*/
var FilterAssoc = function(data, filterList, filterMode) {
  // cache length for being nice to compiler guy/gal
  var dataLength = data.length
  var filteredArray = []
  // loop through array to access the object literals
  for (var i = 0; i < dataLength; ++i) {
    var filterRes = _filterChoose(data[i], filterList, filterMode)
    // if results from our internal filter methods are NOT "null",
    // then we need those results!
    if (filterRes !== null) {
        // build our results
        filteredArray.push(filterRes)
    }
  }
  return filteredArray
}

var filteredData = FilterAssoc(data, filters, 'strict')

console.log(filteredData)

/**
*_filterStrict仅在满足两个筛选条件时返回数据
*@param data{obj}
*过滤器列表{arr}
*@returns bool
*/
var\u filterStrict=函数（数据，过滤器列表）{
var filterLength=filterList.length
//灵巧的小特鲁西阵列
var strictMatchResults=[]
对于（变量i=0；i