Question

我正在Angular 6中做一个应用程序，我想过滤一个对象数组以查找其中一个对象的X属性是否等于X值。

我的对象数组：

   keyword_2 ="destination
   j = 
   if re.match(keyword_1, line):
                lineafter = lines[i + j]
                lineafter_split= lineafter.split(' ')

            if value2 and cell_value in line:
                if 'access-list' not in line:
                    if 'nat' not in line:
                        lineafter_2 = lines[i + 1]
                        if 'description' not in lineafter_2:
                            print(lineafter_2)




Second attempt ...
```keyword_1 ="source"
   keyword_2 ="destination
   j=1
   for i, line in enumerate(lines):
       if keyword_1 in line:
          prev_line=lines[i - j]
           for i in range(1,15):
               if w in prev_line:
                   print(prev_line)
               else:j= j+1

我想查找users = [ { "id": "3myuB3YYlHNK5m4WZC7CxrX3MvA3", "identificationMethod": "cedula", "identificationNumber": "23447847457", }, { "id": "7ruDZvmsvTVZfA59nfB7SU65gwi1", "identificationMethod": "cedula", "identificationNumber": "23232323232", }, { "id": "8IpMYYfy5dhBaR7QoQz4mXXLE1T2", "identificationMethod": "passport", "identificationNumber": "src34323", } ]等于护照的所有用户，然后我想知道其中identificationMethod等于23232323232的用户中是否有一个。

现在，我正在运行以下代码段：

identificationNumber

我想实现相同的目的，但是将const equalUsers: UserId[] = this.users.filter(user => user.identificationMethod === identificationMethod); const isUnique: boolean = equalUsers.map(user => user.identificationNumber).some(value => value === identificationNumber); (isUnique) ? console.log('Is unique') : console.log('Is not unique');，.map()和.filter()（或任何其他可用的方法）组合成一行。

我尝试过：

.some()

我需要在这里使用const isUnique = this.users.filter(user => user.identificationMethod === identificationMethod) .some(user => user.identificationNumber === identificationNumber);吗？
有更好的方法吗？

我的目标是实现与第一个代码段相同的功能，但更短，更快，更易于理解。我很困惑，我不确定是否需要先使用.map()还是不必要。

Answer 1

您可以在Array方法中扩展条件。

const users = [{
    "id": "3myuB3YYlHNK5m4WZC7CxrX3MvA3",
    "identificationMethod": "passport",
    "identificationNumber": "23447847457",
  },
  {
    "id": "3myuB3YYlHNK5m4WZC7CxrX3MvA3",
    "identificationMethod": "passport",
    "identificationNumber": "23447847457",
  },
  {
    "id": "8IpMYYfy5dhBaR7QoQz4mXXLE1T2",
    "identificationMethod": "passport",
    "identificationNumber": "src34323",
  }
];

const identificationMethod = "passport";
const identificationNumberDuplicate = "23447847457";
const identificationNumberUnique = "src34323";
const identificationNumberDoesNotExist = "xxx";

const test = (identificationMethod, identificationNumber) => {
  const found = users.filter(user => user.identificationMethod === identificationMethod &&
    user.identificationNumber === identificationNumber);
  const exists = found.length > 0;
  const isUnique = found.length === 1;

  console.log("Exists: " + exists, "Unique: " + isUnique);
};

test(identificationMethod, identificationNumberUnique);
test(identificationMethod, identificationNumberDuplicate);
test(identificationMethod, identificationNumberDoesNotExist);

Answer 2

我不确定是否需要将其充实以得到完整的答案，但是我建议这样做：

this.users.some(user => 
  user.identificationMethod === identificationMethod && 
  user.identificationNumber === identificationNumber
);

假设您有一个有限长度的数组array，在读取时不会引发错误，一个参数的函数f和一个参数的predicate p（谓词是返回true或false的函数），以下表达式应始终为您提供相同的结果：

array.map(f).some(p); // turn all x into f(x), then check that at least one p(f(x)) is true
array.some(x => p(f(x))); // check that at least one p(f(x)) is true

也就是说，您可以compose p和f到一个新的谓词q中，而只需对其进行array.some()。您已经弄清楚了，因为您的情况

f是user => user.identificationNumber，
p是id => id === identificationNumber，
所以q是user => user.identificationNumber === identificationNumber

此外，以下内容应始终为您提供相同的结果：

array.filter(p).some(q); // of the x where p(x) is true, is there an x where q(x) is true?
array.some(x => p(x) && q(x)); // is there an x where both p(x) and q(x) are true?

也就是说，您正在通过conjunction将两个谓词p和q组合成一个新的谓词r。在上面的回调中执行该转换：

p是user => user.identificationMethod === identificationMethod，
q是user => user.identificationNumber === identificationNumber，
所以r是u => user.identificationMethod === identificationMethod && user.identificationNumber === identificationNumber

请注意，尽管它们给出相同的结果，但是它们执行的步骤不同。您拥有的原始版本array.filter(p).map(f).some(q)将最终对数组的每个元素p执行x，然后对所有通过测试的元素执行f，并且最后对所有q执行f(x)，直到找到通过测试的。但是新版本array.some(r)将仅对元素执行p和f，直到一个通过q测试为止。如果数组的第一个元素通过测试，则后一种方法将只查看该第一个元素，而前一种方法将遍历所有元素。

就性能而言，除非您的数组绝对很大，否则这可能不是什么大问题；就行为而言，除非您从数组中读取时数组有side effects，否则就行为而言也没有太大关系。，也许您使用的是Proxy，当您从中读取内容时会进行更改）。

无论如何，希望能有所帮助；祝你好运！

结合使用Map，Filter和TypeScript中的一些

2 个答案: