Javascript 使用reduce将数组转换为对象数组

我想将

optimizedLote

转换为结果。我想用ES6

.reduce（）

实现这一点。以下是我尝试过的：

optimizedRoute = ['Bengaluru', 'Salem', 'Erode', 'Tiruppur', 'Coimbatore']

result = [
  {start: bengaluru, end: salem},
  {start: salem, end: erode},
  {start: erode, end: tiruppur},
  {start: tiruppur, end: coimbatore},
]

---

以下代码使用的是

扩展运算符

、

三值运算符

和

数组。reduce

const-optimizedLote=[
“班加鲁”，
“塞勒姆”，
"侵蚀",，
"提鲁珀",，
"哥印拜陀",，
];
//看看我们是否在处理最后一个值
//如果我们只返回构造的数组
//如果没有，则向构造的数组中添加一个新值。
//tmp是我们正在构建的数组
//x实际循环项
//席项目的索引
const lastItemIndex=optimizedLote.length-1；
const Re=优化器DRUTE。（（TMP，X，席）= >席！= = LASTITEMTEXT）
…tmp，
{
起点：x，
//我们使用
//本项目（十一）
结束：杜洛特[xi+1]，
},
]：tmp，[]）；
控制台日志（ret）既然您要求
reduce
，下面是一种方法：


let optimizedLote=['Bengaluru'、'Salem'、'腐蚀'、'Tiruppur'、'Coimbatore']
让res=optimized.reduce（（累计，项目，i）=>{
if（i==optimizedLote.length-1）
返回累计；
累计推送（{start:item，end:optimizedLote[i+1]}）
返回累计；
}, [])
控制台日志（res）另一种方法是将
map
方法与
slice
结合使用。对于
map
函数，必须将
callback
函数作为参数传递，该参数将应用于给定数组中的每个项


OptimizedLote=['Bengaluru'、'Salem'、'腐蚀'、'Tiruppur'、'Coimbatore']
var结果=最优级
.slice（0，-1）
.map（（项，索引）=>（{start:item，end:optimizedLote[index+1]}））；
控制台日志（结果）下面是一个使用
reduce
的示例。但我不确定这是最自然的方式

使用
reduce
感觉太过分了，在这种情况下（但这只是我的观点），我自然会使用索引，我会选择一个简单的
for
循环


const-optimizedLote=['Bengaluru'、'Salem'、'腐蚀'、'Tiruppur'、'Coimbatore']；
让我们开始行动；
const result=optimized.reduce（（acc，城市）=>{
if（起始城市）{
acc.push（{开始：开始城市，结束：城市}）；
}
startCity=城市；
返回acc；
}, []);
控制台日志（结果）您可以使用
reduce
获取路线的起点和终点部分，并返回终点进行下一次起点

const r = optimizedRoute.reduce((places, place, i) => {
  const result: any = [];
  places = []
  places.push({
    startPlace: place,
    endPlace: place
  });
  // result.push ({ startplace, endplace, seats: 4 });
  // console.log(result);
  return places;
}, {});
console.log(r)

getParts = a => (                   // take a as array and return an IIFE
    r => (                          // with an initialized result array
        a.reduce((start, end) => (  // reduce array by taking two values
            r.push({ start, end }), // push short hand properties
            end                     // and take the last value as start value for next loop
        )),
        r                           // finally return result
    )
)([]);                              // call IIFE with empty array


constgetparts=a=>（r=>（a.reduce（（start，end）=>（r.push（{start，end}），end）），r））（[]）；
var-Durote=['Bengaluru'、'Salem'、'侵蚀'、'Tiruppur'、'Coimbatore']
console.log（getParts（optimize））
。作为控制台包装{最大高度：100%！重要；顶部：0；}
我简化了尼娜·斯科尔斯的答案，
按照尼娜的想法，使用reduce获取路线的开始和结束部分，并返回结束部分以进行下一次开始

const r = optimizedRoute.reduce((places, place, i) => {
  const result: any = [];
  places = []
  places.push({
    startPlace: place,
    endPlace: place
  });
  // result.push ({ startplace, endplace, seats: 4 });
  // console.log(result);
  return places;
}, {});
console.log(r)

getParts = a => (                   // take a as array and return an IIFE
    r => (                          // with an initialized result array
        a.reduce((start, end) => (  // reduce array by taking two values
            r.push({ start, end }), // push short hand properties
            end                     // and take the last value as start value for next loop
        )),
        r                           // finally return result
    )
)([]);                              // call IIFE with empty array

我并不真正理解“with reduce”要求，因为使用循环的相应代码可以立即读取，并且不需要解释：


const-optimizedLote=['Bengaluru'、'Salem'、'腐蚀'、'Tiruppur'、'Coimbatore']；
const result=新数组（optimizedLote.length-1）；
for（设i=0；iconsole.log（result）
reduce
在这里并不合适，因为您没有尝试将数组减少到单个值

在一个完美的世界里，我们可以像这样使用它，通常被称为
zip

getParts = a => {
  const result = [];
    a.reduce((start, end) => {
      result.push({ start, end });
      return end;
    });
    return result;
};
var optimizedRoute = ['Bengaluru', 'Salem', 'Erode', 'Tiruppur', 'Coimbatore'];
console.log(this.getParts(optimizedRoute));

但是JavaScript中没有。最好的替代方法是
使用以下方法将一系列索引映射到路线中：

我更喜欢可读性而不是解决它的简短代码

此外，该解决方案缩短了文件的篇幅，但降低了可读性（至少对我而言），可能是：

optimizedRoute.reduce((routes, city, index) => {
  const firstCity = index === 0;
  const lastCity = index === optimizedRoute.length - 1;
  if (!firstCity) {
    routes.last().end = city;
  }
  if (!lastCity) {
    routes.push({ start: city });
  }
  return routes;
}, []);

关于
last（）
，这是一个我通常用于可读性的函数：

optimizedRoute.reduce((routes, city) => {
  routes.last().start = city;
  routes.push({ end: city });
  return routes;
}, [{}]).slice(1, -1);

如果有人需要，请使用ReduceRight解决方案

Array.prototype.last = function() { 
  return this[this.length - 1] 
}

这令人印象深刻，但很难做到！尽管这可能是一个（好的）解决方案，但我认为这对于OP来说太难了，以至于OP无法理解OP的特定技能。尼娜，你能补充一些细节来解释这条令人敬畏的单行线的步骤吗？@Nina Scholz我不明白为什么第一个推送值不是
{start:undefined，end:'Bengaluru'，}
。这是关于reduce在没有初始值时忽略第一个值吗？@GrégoryNEUT，对，如果reduce不是以初始值开始的，那么前两个元素将作为累加器和项。索引以
1
开头。为了便于说明，您可以尝试这样做：
[4,5,6,7].reduce（（a，b，i）=>（console.log（i，a，b），b））这种方法与Mihai Alexandru Ionut和Tom Fenech的做法非常相似，你也应该投票表决他们的答案@赛拉：哎呀，修好了。流程非常简单，
Array.from（{length:…}，…）
是一个基本等同于
range（0，…）.map（…）
@Bergi，根据o表示法，它是最好的。@saila我认为这里给出的所有解决方案都有线性运行时请解释为什么在这里进行向下表决，如果有人正在寻找使用reduceRight（类似于reduce）的解决方案，我会添加这个答案。谢谢
optimizedRoute.reduceRight((acc, d, i, arr) => 
             i == 0 
                ? acc 
                : [{ start: arr[i -1], end: d }, ...acc]  
            , [])