在一系列数字中，如何计算一个数字出现的次数，该数字的值恰好比前一个数字的值小 1？

Question

代码：

function OneDecremented(num) { 
  num = num.toString()
  var count = 0

  for(i = 1; i < num.length; i++) {
    if(num[i - 1] - num[i] === 1){
      count++
    }
  }
  return count

}
console.log(OneDecremented(9876541110))

所以我很难理解两件事：

1. i 和 num[i] 有什么区别
2. 我不明白if语句中的计算是如何发生的，有人可以分解它吗？

抱歉，如果这些问题听起来太傻了，我是 JS 新手，无法真正理解算术计算。谢谢您的宝贵时间。

Answer 1

该代码写得不好，原因有几个，但最重要的是，它在全局范围内泄漏了

i

引用，所以，让我们从一个更好的版本开始：

function OneDecremented(num) {
  var str = num.toString();
  var count = 0;
  for(var i = 1; i < str.length; i++) {
    if(str[i - 1] - str[i] === 1)
      count++;
  }
  return count;
}

字符串，在现代JS中，可以像数组一样访问，索引返回

index

位置的char：

if(str[i - 1] - str[i] === 1)
// is the same as
if ((str.charAt(i - 1) - str.charAt(i)) === 1)

一旦检索到每个字符，代码就会执行隐式的“char to number”转换，这要归功于

-

运算符，但如果它是

+

，它会将两个字符连接为字符串（所以，要小心）。

明确说明总是更好，但如果您知道

-

的工作原理，它就可以完成此任务。

循环从

1

开始，它检查

i - 1

处的字符（第一次迭代中索引

0

处的字符减去当前字符）是否为

1

，这意味着当前字符为比上一个少一个.

在这种情况下，计数器就会累加。

Answer 2

Andrea 和 Mitya 已经搞定了。

下一步可能会切换到基于第一类的方法，例如使用特定的

Array

方法，例如

reduce

。

如果正确实施，这种方法通常会提高代码的可读性/可维护性，并实现更好的代码重用。

对于OP提供的示例，可以编写两个函数，即获取计数的实际方法和上述第一类减速器功能。由于

reduce

是处理数组的标准方法，因此减速器/回调的参数优先级也得到了很好的指定...

[/* ... */].reduce(function(accumulator, currentValue, currentIndex, currentlyProcessedArray) {

  // implement reducer/aggregation/accumulator logic here.

  // the return value serves as the
  // new `accumulator` value within
  // the next iteration step.

  // thus, always return something! ... e.g ...

  return (accumulator + currentValue); 
});

function aggregatePrecursorAndDecrementedSuccessorCount(count, char, idx, arr) {

  const precursorValue = Number(arr[idx - 1]);
  const incrementedCurrentValue = (Number(char) + 1);
  const isValidCount = (precursorValue === incrementedCurrentValue);

  return (count + (isValidCount ? 1 : 0));
//return (count + Number(isValidCount)); // cast boolean value to either 1 or 0.
}

function getPrecursorAndDecrementedSuccessorCount(int) {
  return String(int) // - assure/typecast always a/into string value.
    .split('')       // - split string value into an array of single characters.
    .reduce(aggregatePrecursorAndDecrementedSuccessorCount, 0);
}

console.log(getPrecursorAndDecrementedSuccessorCount(9876541110));

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

Answer 3

i 和 num[i] 有什么区别

i

是迭代键，即 0、1、2 等，表示字符串化数字中有多少个字符。

num[i]

是字符串中索引

i

处的字符，即

num[i]

，其中

i

是 0 ==

9

（字符串中索引 0 处的字符）。

我不明白if语句中的计算是如何发生的，有人可以分解它吗？

也就是说：如果计算字符串索引

i-1

处的数字，减去当前正在考虑的数字（字符串中索引

i

处）减值为 1，则递增

count

。

按照实际使用的数量一步步进行：

• 9 - 没有先前的字符；计算（未定义 - 9）不等于 1
• 8 - 前一个字符是 9； (9 - 8) == 1;增量

  count

• 7 - 同上
• 6 - 同上
• 5 - 同上
• 4 - 同上
• 1 - 前一个字符是 4；计算 (4 - 1) 不等于 1
• 1 - 前一个字符为 1；计算 (1 - 1) 不等于 1
• 1 - 同上
• 0 - 前一个字符为 1； (1 - 0) == 1;增量

  count

Answer 4

function OneDecremented(num) { 
  num = num.toString()
  var count = 0

  for(i = 1; i < num.length; i++) {
    if(num[i - 1] - num[i] === 1){
      count++
    }
  }
  return count

}
console.log(OneDecremented(5915582))