Javascript 我的嵌套for循环正在输出重复项

此函数的目的是传入：

[{lang:'英语'，熟练程度：'初级熟练'}，{lang:'西班牙语'，熟练程度：'完全专业熟练'}]

并具有打印功能：

[{level:1，lang:'English'，proficiency:'primary proficiency'}，{level:3，lang:'西班牙语'，proficiency:'Full Professional proficiency'}]

然而，我得到了：

[{level:3，lang:'西班牙语'，熟练程度：'完全专业熟练程度}，{level:3，lang:'西班牙语'，熟练程度：'完全专业熟练程度}]

。有什么想法吗？多谢各位

lngSort(exObj) {
      let userprof = []
      let lng = []

      const proficiencies = [
        { level: 1, name: 'Elementary Proficiency' },
        { level: 2, name: 'Limited Working Proficiency' },
        { level: 3, name: 'Full Professional Proficiency' },
        { level: 4, name: 'Native Bilingual Proficiency' }
      ]

      for(let v in exObj) {
        userprof.push(exObj[v].proficiency);
        lng.push(exObj[v].lang);
      }

      let findmax = (proficiencies, userprof) => {
          const arr = [];
          const ob = {};

          let found = false;
          for (const prof of proficiencies) {
            for (const user of userprof) {
              if (found) found = false
              for (const l of lng) {
                if (prof.name === user) {
                  ob.level = qual.level
                  ob.proficiency = qual.name
                  ob.lang = l
                  arr.push(ob);
                  found = true
                  break
                }
              }
            }
          }
          console.log("QUAL: " + JSON.stringify(arr))
      }
      findmax(proficiencies, userqual);
    }

---

看起来使用

map

是解决这个问题的更简单的方法

const熟练度=[
{级别：1，名称：'初级熟练程度'}，
{级别：2，名称：'有限的工作熟练程度'}，
{级别：3，名称：'完全专业熟练'}，
{级别：4，名称：“母语双语熟练程度”}
];
常数项=[
{lang:'英语'，熟练程度：'初级熟练'}，
{lang:'西班牙语'，熟练程度：'完全专业熟练'}
];
const res=items.map（（item）=>{
常量熟练程度=熟练程度.find（i=>i.name==item.熟练程度）；
if（熟练程度）{
item.level=熟练程度.level；
}
退货项目；
});
控制台日志（res）看起来使用
map
是解决这个问题的更简单的方法


const熟练度=[
{级别：1，名称：'初级熟练程度'}，
{级别：2，名称：'有限的工作熟练程度'}，
{级别：3，名称：'完全专业熟练'}，
{级别：4，名称：“母语双语熟练程度”}
];
常数项=[
{lang:'英语'，熟练程度：'初级熟练'}，
{lang:'西班牙语'，熟练程度：'完全专业熟练'}
];
const res=items.map（（item）=>{
常量熟练程度=熟练程度.find（i=>i.name==item.熟练程度）；
if（熟练程度）{
item.level=熟练程度.level；
}
退货项目；
});
控制台日志（res）您只不过是打破了
的
最深层次。你也需要打破其他的。当前，下一个循环不会中断，而是重新开始，并且此循环中的第一条指令是
if（found）found=false
，这将重置布尔值，因此再次执行此任务

for (const prof of proficiencies) {
    for (const user of userprof) {
        if (found) found = false
        for (const l of lng) {
            if (prof.name === user) {
                ob.level = qual.level
                ob.proficiency = qual.name
                ob.lang = l
                arr.push(ob);
                found = true
                break
            }
        }
        if (found) break;
    }
    if (found) break;
}

你只是打破了
的最深层次的
。你也需要打破其他的。当前，下一个循环不会中断，而是重新开始，并且此循环中的第一条指令是
if（found）found=false
，这将重置布尔值，因此再次执行此任务

for (const prof of proficiencies) {
    for (const user of userprof) {
        if (found) found = false
        for (const l of lng) {
            if (prof.name === user) {
                ob.level = qual.level
                ob.proficiency = qual.name
                ob.lang = l
                arr.push(ob);
                found = true
                break
            }
        }
        if (found) break;
    }
    if (found) break;
}

如果您将
熟练程度
数组重新构造为一个对象，则只需使用一个
映射（）
，这将变得非常简单


const input=[{lang:'英语'，熟练程度：'初级熟练'}，{lang:'西班牙语'，熟练程度：'完全专业熟练'}]；
常数熟练度={
"基本熟练程度":1,，
“有限的工作熟练程度”：2，
“完全专业能力”：3，
‘母语双语能力’：4
}
const out=input.map（o=>（{level:proficiencies[o.proficiency]，…o}））；
控制台。注销
如果您将
熟练度
数组重新构造为一个对象，则只需一个
映射（）
，这将变得非常简单


const input=[{lang:'英语'，熟练程度：'初级熟练'}，{lang:'西班牙语'，熟练程度：'完全专业熟练'}]；
常数熟练度={
"基本熟练程度":1,，
“有限的工作熟练程度”：2，
“完全专业能力”：3，
‘母语双语能力’：4
}
const out=input.map（o=>（{level:proficiencies[o.proficiency]，…o}））；
控制台。注销对于您的问题，您可以采取稍微不同的方法，这可能会更容易实现。与使用多个循环不同，您可以创建一个循环（其行为与对象非常相似，它保留键值对，以后可以使用
.get（key）
访问这些键值对）。可以使用
map
构造函数从
熟练程度
数组构建地图。映射构造函数获取一个数组，该数组包含
[[key1，value1]，[key2，value2]，…]
对，您可以使用数组上的方法构建这些对。构建地图后，它将具有以下结构：

"Elementary Proficiency" => 1
"Limited Working Proficiency" => 2
"Full Professional Proficiency" => 3
"Native Bilingual Proficiency" => 4

其中，数字是可以使用
.get（proficiencyName）
从地图中获得的值。拥有此结构后，只需将原始数组中的所有对象变换为
级别
属性。为此，我再次使用了
.map（）
，它将使用数组中当前存在的每个对象的属性构建一个新对象（这是使用
..
完成的），并将添加一个额外的
level
属性，该属性表示通过在上面制作的地图中查找对象的熟练程度而获得的级别：


const arr=[{lang:'英语'，熟练程度：'初级熟练'}，{lang:'西班牙语'，熟练程度：'完全专业熟练'}]；
const proficiencies=[{level:1，name:'初级熟练'}，{level:2，name:'有限工作熟练'}，{level:3，name:'完全专业熟练'}，{level:4，name:'母语双语熟练'}]；
const-levelLookUp=newmap（proficiencies.Map（o=>[o.name，o.level]）；
const result=arr.map（obj=>（{level:levelLookUp.get（obj.proficiency），…obj}））；
控制台日志（结果）对于您的问题，您可以采取稍微不同的方法，这可能会更容易实现。与使用多个循环不同，您可以创建一个循环（其行为与对象非常相似，它保留键值对，以后可以使用
.get（key）
访问这些键值对）。可以使用
map
构造函数从
熟练程度
数组构建地图。map构造函数接受一个
[