Javascript 在对象中迭代数组后，为键创建具有单行的数组

如果columns数组中的给定元素针对fieldValues对象中的每个键的数组存在，我当前正在尝试创建一个新数组

寻找从给定结构中获得预期输出的想法。谢谢

const columns = ['growth item', 'savings item', 'sustainability']

const fieldValues = {
  'additional revenue': [ 'growth item', 'sustainability' ],
  'energy costs': [ 'savings item' ],
  'managing energy': [ 'savings item' ]
}

const categories = [];

const newArray = columns.forEach((element) => {
            Object.values(fieldValues).forEach((value) => {
              let res = value.some(val => val === element);
              
              switch(element){
                case "growth item":
                  categories.push({
                    growth:res
                  })
                  break;
                case "savings item":
                  categories.push({
                    save:res
                  })
                  break;
                case "sustainability":
                  categories.push({
                    sustain:res
                  })
                  break;
              }

        })
      })

console.log(categories);

我想得到这样的输出

预期产出：

[
  { growth: true, save: false, sustain: true },
  { growth: false, save: false, sustain: false },
  { growth: false, save: undefined, sustain: false },
]

实际产出

[
  { growth: true },
  { growth: false },
  { growth: false },
  { save: false },
  { save: true },
  { save: true },
  { sustain: true },
  { sustain: false },
  { sustain: false }
]

---

您可以按如下方式设置格式，如果该列不存在，则在这种情况下，值将为false：

let columns = ['growth item', 'savings item', 'sustainability']

let fieldValues = {
  'additional revenue': [ 'growth item', 'sustainability' ],
  'energy costs': [ 'savings item' ],
  'managing energy': [ 'savings item' ]
  }
  
let result = Object.values(fieldValues).map((values) => {
   return { 
        growth: values.includes('growth item'),
        save: values.includes('savings item'),
        sustain: values.includes('sustainability')
   }; 
});

console.log(result)

let columns=[“增长项目”、“节约项目”、“可持续性”] 设字段值={ “额外收入”：[“增长项目”、“可持续性”]， “能源成本”：[“节约项目”]， “管理能源”：[“节约项目”] } 让结果=Object.valuesfieldValues.mapvalues=>{ 返回{ 增长：价值。包括“增长项目”， 保存：值。包括“保存项”， 维持：价值观。包括“可持续性” }; };

---

console.logresult您可以将其格式化如下，如果该列不存在，则在这种情况下，值将为false：

let columns = ['growth item', 'savings item', 'sustainability']

let fieldValues = {
  'additional revenue': [ 'growth item', 'sustainability' ],
  'energy costs': [ 'savings item' ],
  'managing energy': [ 'savings item' ]
  }
  
let result = Object.values(fieldValues).map((values) => {
   return { 
        growth: values.includes('growth item'),
        save: values.includes('savings item'),
        sustain: values.includes('sustainability')
   }; 
});

console.log(result)

let columns=[“增长项目”、“节约项目”、“可持续性”] 设字段值={ “额外收入”：[“增长项目”、“可持续性”]， “能源成本”：[“节约项目”]， “管理能源”：[“节约项目”] } 让结果=Object.valuesfieldValues.mapvalues=>{ 返回{ 增长：价值。包括“增长项目”， 保存：值。包括“保存项”， 维持：价值观。包括“可持续性” }; };

---

console.logresult代码中的循环顺序错误，并且fiedlValues声明中缺少}。此外，我们需要为字段值中的每个项创建一个对象，然后将该对象推送到categories数组中。每次运行嵌套循环时，都会将项目推入类别

const columns = ['growth item', 'savings item', 'sustainability']

const fieldValues = {
  'additional revenue': [ 'growth item', 'sustainability' ],
  'energy costs': [ 'savings item' ],
  'managing energy': [ 'savings item' ]
}
const categories = [];

const newArray = Object.values(fieldValues).forEach((value) => {
             let tempObj = {};
             columns.forEach((element) => {
              
              let res = value.some(val => val === element);
              
              switch(element){
                case "growth item":
                  tempObj = {...tempObj, growth: res};
                  break;
                case "savings item":
                  tempObj = {...tempObj, save: res};
                  break;
                case "sustainability":
                  tempObj = {...tempObj, sustain: res};
                  break;
              }
              

        });
        categories.push(tempObj);
      })

console.log(categories);

---

代码中的循环顺序错误，并且fiedlValues声明中缺少}。此外，我们需要为字段值中的每个项创建一个对象，然后将该对象推送到categories数组中。每次运行嵌套循环时，都会将项目推入类别

const columns = ['growth item', 'savings item', 'sustainability']

const fieldValues = {
  'additional revenue': [ 'growth item', 'sustainability' ],
  'energy costs': [ 'savings item' ],
  'managing energy': [ 'savings item' ]
}
const categories = [];

const newArray = Object.values(fieldValues).forEach((value) => {
             let tempObj = {};
             columns.forEach((element) => {
              
              let res = value.some(val => val === element);
              
              switch(element){
                case "growth item":
                  tempObj = {...tempObj, growth: res};
                  break;
                case "savings item":
                  tempObj = {...tempObj, save: res};
                  break;
                case "sustainability":
                  tempObj = {...tempObj, sustain: res};
                  break;
              }
              

        });
        categories.push(tempObj);
      })

console.log(categories);

---

下面的解决方案解决了这个问题，请对此进行研究

   var columns = ['growth item', 'savings item', 'sustainability'];

var fieldValues = {
  'additional revenue': [ 'growth item', 'sustainability' ],
  'energy costs': [ 'savings item' ],
  'managing energy': [ 'savings item' ]
};
var ValueConstants = {
"growth item" :"growth",
"savings item" :"save",
"sustainability":"sustain"
}

var categories = [];

for(let key in fieldValues){
    var obj={};
    for(let col of columns){
            obj[ValueConstants[col]]= fieldValues[key].includes(col);
    }    
    categories.push(obj)
} 
console.log(categories);

---

下面的解决方案解决了这个问题，请对此进行研究

   var columns = ['growth item', 'savings item', 'sustainability'];

var fieldValues = {
  'additional revenue': [ 'growth item', 'sustainability' ],
  'energy costs': [ 'savings item' ],
  'managing energy': [ 'savings item' ]
};
var ValueConstants = {
"growth item" :"growth",
"savings item" :"save",
"sustainability":"sustain"
}

var categories = [];

for(let key in fieldValues){
    var obj={};
    for(let col of columns){
            obj[ValueConstants[col]]= fieldValues[key].includes(col);
    }    
    categories.push(obj)
} 
console.log(categories);

---

使用reduce函数可以完成这项工作

const columns=[“增长项目”、“节约项目”、“可持续性”] const colNames=['growth'，'save'，'sustain']； 常量字段值={ “额外收入”：[“增长项目”、“可持续性”]， “能源成本”：[“节约项目”]， “管理能源”：[“节约项目”] }; 常量结果=Object.valuesfieldValues.ReduceAc，curr=>{ 常量项={}； columns.forEachcol，i=>{ 条目[colNames[i]]=curr.indexOfcol！=-1； }; acc.pushentry； 返回acc； }, [];

---

使用reduce函数可以完成这项工作

const columns=[“增长项目”、“节约项目”、“可持续性”] const colNames=['growth'，'save'，'sustain']； 常量字段值={ “额外收入”：[“增长项目”、“可持续性”]， “能源成本”：[“节约项目”]， “管理能源”：[“节约项目”] }; 常量结果=Object.valuesfieldValues.ReduceAc，curr=>{ 常量项={}； columns.forEachcol，i=>{ 条目[colNames[i]]=curr.indexOfcol！=-1； }; acc.pushentry； 返回acc； }, [];

---

看来forEach的命令改变了

const columns=[“增长项目”、“节约项目”、“可持续性”] 常量字段值={ “额外收入”：[“增长项目”、“可持续性”]， “能源成本”：[“节约项目”]， “管理能源”：[“节约项目”] } 常量类别=[]； 让subObj={growth:undefined，save:undefined，sustain:undefined}； 常数newArray= Object.valuesfieldValues.forEachvalue=>{ columns.forEachelement=>{ 让res=value.someval=>val==element； 开关元件{ 案例增长项目： subObj.growth=res； 打破 个案节省项目： subObj.save=res； 打破 案例可持续性： subObj.sustain=res； 打破 } } 类别.pushsubj； subObj={growth:undefined，save:undefined，sustain:undefined}； }

---

console.logcategories 看来forEach的命令改变了

const columns=[“增长项目”、“节约项目”、“可持续性”] 常量字段值={ “额外收入”：[“增长项目”、“可持续性”]， “能源成本”：[“节约项目”]， “管理能源”：[“节约项目”] } 常量类别=[]； 让subObj={growth:undefined，save:undefined，sustain:undefined}； 常数newArray= Object.valuesfieldValues.forEachvalue=>{ columns.forEachelement=>{ 让res=value.someval=>val==element； 转换 元素{ 案例增长项目： subObj.growth=res； 打破 个案节省项目： subObj.save=res； 打破 案例可持续性： subObj.sustain=res； 打破 } } 类别.pushsubj； subObj={growth:undefined，save:undefined，sustain:undefined}； }

---

console.logcategories；Love简明解决方案，比mineLove简明解决方案好得多，比mineLove简明解决方案好得多为FieldValue放置结尾“}”。为FieldValue添加缺少的“}”。为FieldValue添加缺少的“}”结尾。为FieldValue添加缺少的“}”