如何在循环中保存对象的“上一个”和“下一个”迭代？

Question

我正在开发一个程序，该程序在字符串出现之前和之后获取一个数字，然后比较这些数字 - 但只有当该字符串出现时才会发生。

我尝试过遍历 object.keys（也许我不明白如何正确）

我尝试过嵌套循环（在字符串“restart”中记录单个字母）

let formattedTemps = [ 10,'restart',68,80,'restart',70.1,'restart',
  72,80,'restart',69,'restart',78,'restart',84,100,300,50,'restart',70,
'restart',90,'restart',50,'restart',100 ]

const switch = (Array) => {
  console.log(formattedTemps)
  let previousValue = 0
  let nextValue = 0
  for (let elements of array) {
    console.log(previousValue)
    console.log(nextValue)
    // let previousValue = elements[-1]
    // let nextValue = elements[1]
    //console.log(previousValue , element, nextValue
        // save the iterables beside 'restart' on both sides here
      }
    }

我的预期结果是我在记录字符串“restart”之前和之后都得到了值（因为我会比较它们）。

发生的是一大堆未定义的值，即：多行未定义、“重新启动”、未定义（带有注释掉的代码）和多个 0，就像现在一样。

Answer 1

我们可以使用Array.reduce捕获累加器中迭代的最后一个索引（累加器或acc在我的代码中是Array.reduce回调的第一个参数）并且只打印previous和@987654326 @当当前元素为restart或任意string时

这是我试图解释这背后的逻辑：

• 在第一次迭代中，没有打印任何内容，因为元素是 number。我们只是将当前索引作为累加器的值返回。
• 在第二次迭代中，条件typeof ele === "string" 得到满足，所以现在acc 的值是0（因为它保存了最后一次访问的索引），即previous，下一个比当前索引。
• 每次数组迭代的最后一次访问索引都作为累加器的值 (acc) 返回，我们可以在当前迭代中使用它来查找前一个元素的值。然后我们打印当前元素是否为字符串。下一个元素的值将比数组的当前索引idx 多一个。

let formattedTemps = [ 10,'restart',68,80,'restart',70.1,'restart',
  72,80,'restart',69,'restart',78,'restart',84,100,300,50,'restart',70,
'restart',90,'restart',50,'restart',100 ]

const highLimitSwitch = (formattedTemps) => {
  formattedTemps.reduce((acc, ele, idx, arr) => {
   if(typeof arr[acc] === "number" && typeof ele === "string" && typeof arr[idx + 1] === "number"){
     console.log(`${arr[acc]} ${ele} ${arr[idx + 1]}`)
   }
   return idx;
  }, 0)
}
highLimitSwitch(formattedTemps);

Answer 2

使用索引而不是for of 循环。然后，如果该索引处的元素是'restart'，则可以返回一个索引并转发一个索引来获取值。

let formattedTemps = [ 10,'restart',68,80,'restart',70.1,'restart',
  72,80,'restart',69,'restart',78,'restart',84,100,300,50,'restart',70,
'restart',90,'restart',50,'restart',100 ]

for (let i = 0; i < formattedTemps.length; i++) {
  let temp = formattedTemps[i]
  if (typeof temp === 'string') {
    beforeTemp = formattedTemps[i-1];
    afterTemp = formattedTemps[i+1];
    console.log(beforeTemp, temp, afterTemp);
  }
}

Answer 3

如果实际值是字符串，您可以映射新数组。然后过滤并保留数组。

var array = [10, 'restart', 68, 80, 'restart', 70.1, 'restart', 72, 80, 'restart', 69, 'restart', 78, 'restart', 84, 100, 300, 50, 'restart', 70, 'restart', 90, 'restart', 50, 'restart', 100],
    result = array
        .map((v, i, a) => typeof v === 'string' && [a[i - 1], v, a[i + 1]])
        .filter(Boolean);

console.log(result.map(a => a.join(' ')));

.as-console-wrapper { max-height: 100% !important; top: 0; }

Answer 4

您可以访问数组的任意一侧，这将为您提供值undefined。因此，您可以检查字符串的任一侧是否有数字：

const highLimitSwitch = (formattedTemps) => {
  for (const [index, operation] of formattedTemps.entries()) {
      const num1 = formattedTemps[index - 1];
      const num2 = formattedTemps[index + 1];
      if (typeof num1 === "number" && typeof operation === "string" && typeof num2 === "number") {
          console.log(num1, operation, num2);
      }
  }
};

实时示例：

let formattedTemps = [10,'restart',68,80,'restart',70.1,'restart',
  72,80,'restart',69,'restart',78,'restart',84,100,300,50,'restart',70,
'restart',90,'restart',50,'restart',100 ];

const highLimitSwitch = (formattedTemps) => {
  for (const [index, operation] of formattedTemps.entries()) {
      const num1 = formattedTemps[index - 1];
      const num2 = formattedTemps[index + 1];
      if (typeof num1 === "number" && typeof operation === "string" && typeof num2 === "number") {
          console.log(num1, operation, num2);
      }
  }
};

highLimitSwitch(formattedTemps);

.as-console-wrapper {
  max-height: 100% !important;
}

（注意70.1 被使用了两次，分别作为num2 和下一次操作的num1，因为样本数据中两个'restart's 之间只有一个数字。）

---

或者如果你可以假设当你看到一个字符串时它的两边都有数字（就像你的currently-accepted answer一样），那么它就更简单了：

const highLimitSwitch = (formattedTemps) => {
  for (const [index, operation] of formattedTemps.entries()) {
      if (typeof operation === "string") {
          const num1 = formattedTemps[index - 1];
          const num2 = formattedTemps[index + 1];
          console.log(num1, operation, num2);
      }
  }
};

实时示例：

let formattedTemps = [10,'restart',68,80,'restart',70.1,'restart',
  72,80,'restart',69,'restart',78,'restart',84,100,300,50,'restart',70,
'restart',90,'restart',50,'restart',100 ];

const highLimitSwitch = (formattedTemps) => {
  for (const [index, operation] of formattedTemps.entries()) {
      if (typeof operation === "string") {
          const num1 = formattedTemps[index - 1];
          const num2 = formattedTemps[index + 1];
          console.log(num1, operation, num2);
      }
  }
};

highLimitSwitch(formattedTemps);

.as-console-wrapper {
  max-height: 100% !important;
}