Javascript Python和Node.js中的相同函数返回不同的结果

我正在将一个项目从Python过渡到Node.js——到目前为止，一切都进展顺利。我有一个函数，可以将某个人的经验值转换为一个级别。我试图将Python中的工作函数重写为Node.js，但函数返回的结果完全不同，我不知道为什么

Python:

def calculateLevel(exp):
    if exp < 83: return 1
    else:
        calcExp = 0
        for level in range(1, 1000):
            diff = int(level + 300 * math.pow(2, float(level)/7))
            calcExp += diff
            if exp < calcExp//4:
                break
        return level

def calculateLevel（exp）：
如果exp<83：返回1
其他：
calcExp=0
对于范围内的液位（1000）：
差值=整数（电平+300*数学功率（2，浮点（电平）/7））
calcExp+=diff
如果exp

Node.js：

const _ = require("underscore");
// ...
function calculateLevel(exp) {
    return new Promise((resolve, reject) => {
        if (exp < 83) resolve(1);
        else {
            var calcExp = 0;
            for (var i in _.range(1, 1000)) {
                calcExp += parseInt(i + 300 * Math.pow(2, i/7));
                if (exp < Math.floor(calcExp/4)) {
                    resolve(i);
                    break;
                }
            }
        }
    });
}

const=require（“下划线”）；
// ...
函数计算器级别（exp）{
返回新承诺（（解决、拒绝）=>{
如果（exp<83）解决（1）；
否则{
var-calcExp=0；
用于（范围（1，1000）内的var i）{
calcExp+=parseInt（i+300*Math.pow（2，i/7））；
如果（经验<数学下限（calcExp/4））{
决议（i）；
打破
}
}
}
});
}

例如，Python中的

calculateLevel（123456）

返回

51

（正确答案），但

等待calculateLevel（123456）返回
15
（回答不正确）

显然Node.js版本中存在一些错误，但我不知道它是什么

非常感谢您的帮助。提前感谢。
在Python中：

for i in range(1, 10)
   print(i)

将创建序列到
123456789

JavaScript中的将迭代键，而不是值

因此（范围（11000）内的变量i）{

将始终是

0…999

换成

函数计算级别（exp）{
返回新承诺（（解决、拒绝）=>{
如果（exp<83）解决（1）；
否则{
var-calcExp=0；
用于（范围为（1999）的变量i）{
calcExp+=parseInt（i+300*Math.pow（2，i/7））；
如果（经验<数学下限（calcExp/4））{
决议（i）；
打破
}
}
}
});
}

除此之外，还不清楚为什么在这里使用承诺，因为这里没有任何异步代码。因此，您可以完全删除这里的承诺

const _ = require("underscore");
// ...
function calculateLevel(exp) {
  if (exp < 83) return 1;
  else {
      var calcExp = 0;
      for (var i of _.range(1, 1000)) {
          calcExp += parseInt(i + 300 * Math.pow(2, i/7));
          if (exp < Math.floor(calcExp/4)) {
              break;
          }
      }
      return i;
  }
}

console.log(calculateLevel(123456))

const=require（“下划线”）；
// ...
函数计算器级别（exp）{
如果（exp<83）返回1；
否则{
var-calcExp=0；
用于（范围为（11000）的变量i）{
calcExp+=parseInt（i+300*Math.pow（2，i/7））；
如果（经验<数学下限（calcExp/4））{
打破
}
}
返回i；
}
}
控制台日志（calculateLevel（123456））

在Python中：

for i in range(1, 10)
   print(i)

将创建序列到

123456789

JavaScript中的将迭代键，而不是值

因此（范围（11000）内的变量i）{将始终是

0…999

换成

函数计算级别（exp）{
返回新承诺（（解决、拒绝）=>{
如果（exp<83）解决（1）；
否则{
var-calcExp=0；
用于（范围为（1999）的变量i）{
calcExp+=parseInt（i+300*Math.pow（2，i/7））；
如果（经验<数学下限（calcExp/4））{
决议（i）；
打破
}
}
}
});
}

除此之外，还不清楚为什么在这里使用承诺，因为这里没有任何异步代码。因此，您可以完全删除这里的承诺

const _ = require("underscore");
// ...
function calculateLevel(exp) {
  if (exp < 83) return 1;
  else {
      var calcExp = 0;
      for (var i of _.range(1, 1000)) {
          calcExp += parseInt(i + 300 * Math.pow(2, i/7));
          if (exp < Math.floor(calcExp/4)) {
              break;
          }
      }
      return i;
  }
}

console.log(calculateLevel(123456))

const=require（“下划线”）；
// ...
函数计算器级别（exp）{
如果（exp<83）返回1；
否则{
var-calcExp=0；
用于（范围为（11000）的变量i）{
calcExp+=parseInt（i+300*Math.pow（2，i/7））；
如果（经验<数学下限（calcExp/4））{
打破
}
}
返回i；
}
}
控制台日志（calculateLevel（123456））

if（exp

应该是

if (exp < Math.floor(calcExp/4)) {
                        break;
                    }
resolve(i)

if（exp

if（exp

应该是

if (exp < Math.floor(calcExp/4)) {
                        break;
                    }
resolve(i)

if（exp

我运行了以下代码：

function calculateLevel(exp) {
    return new Promise((resolve, reject) => {
        if (exp < 83) resolve(1);
        else {
            var calcExp = 0;
            for (var i=1; i<1000; i++) {
                calcExp += parseInt(i + 300 * Math.pow(2, i/7));
                if (exp < Math.floor(calcExp/4)) {
                    resolve(i);
                    break;
                }
            }
        }
    }); }

console.log(calculateLevel(123456));

函数计算级别（exp）{
返回新承诺（（解决、拒绝）=>{
如果（exp<83）解决（1）；
否则{
var-calcExp=0；
对于（var i=1；i我运行了以下代码：

function calculateLevel(exp) {
    return new Promise((resolve, reject) => {
        if (exp < 83) resolve(1);
        else {
            var calcExp = 0;
            for (var i=1; i<1000; i++) {
                calcExp += parseInt(i + 300 * Math.pow(2, i/7));
                if (exp < Math.floor(calcExp/4)) {
                    resolve(i);
                    break;
                }
            }
        }
    }); }

console.log(calculateLevel(123456));

函数计算级别（exp）{
返回新承诺（（解决、拒绝）=>{
如果（exp<83）解决（1）；
否则{
var-calcExp=0；
对于（var i=1；i，只需添加我的意见，因为您已经有了一个可接受的答案

尽管您将Python代码块转换为Javascript，但我觉得您实际上不必使用相同的语法和方法名

例如，如果我们使用Python和JS中的以下代码块

Python:

def calculateLevel(exp):
    if exp < 83: return 1
    else:
        calcExp = 0
        for level in range(1, 1000):
            diff = int(level + 300 * math.pow(2, float(level)/7))
            calcExp += diff
            if exp < calcExp//4:
                break
        return level

但是，在Python中对
for in range（）
进行循环比使用
while
循环更有效

for in range（）
：在0.000秒内调用55个函数

while
：0.001秒内调用1650个函数

虽然Python就是这种情况，但Javascript（以及您使用下划线的
range（）
函数的方法）与此完全不同。虽然函数名看起来相似，但这并不意味着它们的性能与Python相同

事实上，在
上循环.range（）
要慢得多