Question

我正在尝试对此信息进行过滤，这是来自 API 的对象数组，其中包含数据库中所有产品的信息，在此示例中我只显示一个产品，但 API 请求所有产品。

[
        {
            "Id": 11,
            "Name": "Papas fritas",
            "Description": "Papas",
            "Availability": 1,
            "Price": 1,
            "Stock": 10,
            "Promotion": 0,
            "Discount": 0,
            "Visible": 1,
            "CreationDate": "2021-04-22T18:51:51.000Z",
            "UpdateAt": null,
            "Photo": [
                {
                    "Id": 21,
                    "Photo": "photo.png"
                }
            ],
            "Rating": 4.5,
            "Category": [
                {
                    "Id": 2,
                    "Category": "Moda",
                    "Icon": "Fashion"
                },
                {
                    "Id": 3,
                    "Category": "Fitness",
                    "Icon": "Fitness"
                }
            ],
            "Subcategory": [],
            "Characteristics": [],
  
}

现在我创建了一个具有 short 和过滤该数组的方法的类，但是我在过滤信息时遇到了问题，我不知道如何使用以下内容按类别过滤信息：

[{Category: 'Art,Fitnness'}]

Promotion 属性也有可能采用以下格式：

[{Promotion: 'true'}]

正如你所看到的，这个带有过滤器的数组可以有多个属性，并且可以是与类别不同的属性，我需要验证这些值，因为数组中的所有值都是字符串，有时 Array.filter 无法进行比较字符串 "true" === 1

我为此实现的是这个函数，query 是产品数组，queryvalues 是过滤器数组

FilterFuntion(Query, QueryValues)
{
    QueryValues = Object.entries(QueryObj).map((e) => ( { [e[0]]: e[1] } ));
    
    let FilteredArray = Query;

    QueryValues.map((Filter) =>
    {
        var key = Object.keys(Filter)[0];

        FilteredArray = ValidateFilter(key, Filter[key], FilteredArray);
    });

    return FilteredArray;
}

ValidateFilter(Key, Value, array)
{
        return array.filter((El) => 
        {
            if (Value === "true" || Value === "false")
            {
                return Boolean(El[Key]) === Boolean(Value);
            }

            if(Array.isArray((El[Key]))
            {
                 (El[Key]).filter((sub) => 
                 {
                     return String(sub[Key]) === String(Value);
                 });           
            }

            return String(El[Key]) === String(Value);
        });
}

所以我首先验证过滤器的值是 bool 字符串还是 int，然后我返回匹配的值，这对所有正常值都正确，但是当嵌套在另一个数组中的值不起作用时，它返回类别的过滤器数组而不是返回整个产品，当存在嵌套数组时，我不知道如何使其工作，并且当我想过滤多个类别时，我该怎么做？。

[{Category: 'Art,Fitnness'}]

另一件事是例如当过滤器具有两个数字之间的值时，例如查看评级属性，我需要过滤并仅返回评级在 5 和 4 之间的产品

[{Promotion: 'true'}, {Category: 'Fitness'}, {Rating: '5,4'}]

Answer 1

使用filter，我们可以从数组中取出每个对象并测试它是否满足条件。

这里是过滤器对象的剖析：

filter = {
      Rating: [3, 5],
      Category: [
        ['Fitness','Moda'],
        ['OtherCategory']
      ],
      Promotion: 'false'
    }

Rating 是一个“介于”的数组 - 如果您正在寻找一个确切的数字，只需将其输入两次 ([4.5,4.5])。 Category 是一个数组数组，并像这样处理 or/and：

  [
    ['Fitness','Moda'], // product has both categories 'Fitenss' and 'Moda'
    ['OtherCategory'] // OR product has 'OtherCategory'
  ]

const data = [{
    "Id": 11,
    "Name": "Papas fritas",
    "Description": "Papas",
    "Availability": 1,
    "Price": 1,
    "Stock": 10,
    "Promotion": 0,
    "Discount": 0,
    "Visible": 1,
    "CreationDate": "2021-04-22T18:51:51.000Z",
    "UpdateAt": null,
    "Photo": [{
      "Id": 21,
      "Photo": "photo.png"
    }],
    "Rating": 4.5,
    "Category": [{
        "Id": 2,
        "Category": "Moda",
        "Icon": "Fashion"
      },
      {
        "Id": 3,
        "Category": "Fitness",
        "Icon": "Fitness"
      }
    ],
    "Subcategory": [],
    "Characteristics": []

  },
  {
    "Id": 13,
    "Name": "Papas fritas2",
    "Description": "Papas2",
    "Availability": 1,
    "Price": 1,
    "Stock": 10,
    "Promotion": 0,
    "Discount": 0,
    "Visible": 1,
    "CreationDate": "2021-04-22T18:51:51.000Z",
    "UpdateAt": null,
    "Photo": [{
      "Id": 21,
      "Photo": "photo.png"
    }],
    "Rating": 3.5,
    "Category": [{
      "Id": 2,
      "Category": "OtherCategory",
      "Icon": "Fashion"
    }],
    "Subcategory": [],
    "Characteristics": []

  }
]

//[{Promotion: 'true'}, {Category: 'Fitness'}, {Rating: '5,4'}]


const filterProductsBy = (criteria, data) => {
  let p = data.filter(obj => {
    let isMatch = true;
    if (criteria.Rating && (obj.Rating < criteria.Rating[0] || obj.Rating > criteria.Rating[1])) isMatch = false;
    if (criteria.Category) {
      let catMatch = false
      // prepare the cat array
      let cats = obj.Category.map(c => c.Category);
      criteria.Category.forEach(set =>
        set.forEach(catAnd => {
          console.log(cats, catAnd, cats.includes(catAnd))
          if (cats.includes(catAnd)) catMatch = true;
        })
      )
      if (!catMatch) isMatch = false;
    }



    if (criteria.Subcategory) {
      let catMatch = false
      // prepare the Subcategory array
      let subcats = obj.Subcategory.map(c => c.Subcategory);
      criteria.Subcategory.forEach(set =>
        set.forEach(catAnd => {
          //console.log(subcats, catAnd, subcats.includes(catAnd))
          if (subcats.includes(catAnd)) catMatch = true;
        })
      )
      if (!catMatch) isMatch = false;
    }



    obj.Promotion = obj.Promotion === 0 ? 'false' : 'true';
    if (criteria.Promotion && obj.Promotion != criteria.Promotion) isMatch = false;


    return isMatch;

  })

  return p

}

let filter = {
  Rating: [3, 5],
  Category: [
    ['Fitness']
  ],
  Promotion: 'false'
}

console.log(filterProductsBy(filter, data))


filter = {
  Rating: [3, 5],
  Category: [
    ['Fitness'],
    ['OtherCategory']
  ],
  Promotion: 'false'
}

console.log(filterProductsBy(filter, data))

使用嵌套数组过滤对象数组

1 个答案: