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
      }
    }

我的预期结果是我在记录字符串“重新启动”之前和之后都得到了该值（因为然后我将对其进行比较）。

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

Answer 1

使用索引而不是使用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 2

您可以访问数组的任意一边，这将为您提供值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'之间只有一个数字样本数据。）

或者，如果您可以假设，当您看到一个字符串时，字符串的两边都有数字（就像您的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;
}

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

我们可以使用Array.reduce来捕获累加器中迭代的最后一个索引（我代码中的累加器或acc是Array.reduce回调的第一个参数），并且仅打印当前元素为previous或任何next

时的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);

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

4 个答案: