Javascript 为什么S函数中的第一个for循环在下面的node js程序中无限运行？

请检查以下代码，并解释当我在输入中多次提供相同的9位电话号码时，为什么for循环无限运行。 我正在更改嵌套for循环中的numberData的内容，但这不应该是一个问题，并且在numberData中嵌套for循环之后会推送元素，因此我很困惑为什么会发生这种情况，有人能解释一下：

    var str = "00:01:07,400-234-090\n00:05:01,701-080-080\n00:05:00,400-234-090\n00:01:06,701-080-080\n00:01:06,701-080-000"

    console.log(solution(str))

    function solution(S) {

        var totalCost = 0
        var lineArray = S.split('\n')

        var numberData = []
        /*{
            number = 0,
            duration = 0,
            cost = 0
        }*/


        console.log(lineArray)
        for (var i = 0; i < lineArray.length; i++) {

            console.log(lineArray.length, i);
            var dataArray = lineArray[i].split(',')
            var number = dataArray[1]
            var duration = dataArray[0]

            var timeArray = duration.split(':')

            var hours = +(timeArray[0])
            var min = +(timeArray[1])
            var sec = +(timeArray[2])

            var numberPresent = false
            var totalDuration = hours * 60 * 60 + min * 60 + sec //in Seconds
            var cost = 0;

            if (min < 5) {
                cost = min * 60 + sec
            } else {
                if (sec == 0)
                    cost = min * 150
                else
                    cost = (min + 1) * 150
            }

            for (var i = 0; i < numberData.length; i++) {
                if (numberData[i].number == number) {
                    numberData[i].duration += totalDuration
                    numberData[i].cost += cost
                    numberPresent = true
                }
            }
            if (!numberPresent)
                numberData.push({
                    number: number,
                    duration: totalDuration,
                    cost: cost
                })

        }

        var maxDurationIndex = 0
        totalCost += numberData[0].cost

        for (var i = 1; i < numberData.length; i++) {
            if (numberData[i].duration > numberData[maxDurationIndex])
                maxDurationIndex = i;

            if (numberData[i].duration == numberData[maxDurationIndex]) {
                var currentNumericNumber = getNumericNumber(numberData[i])
                var maxIndexNumber = getNumericNumber(numberData[maxDurationIndex])

                if (currentNumericNumber > maxIndexNumber)
                    maxDurationIndex = i;

            }
            totalCost += numberData[i].cost
        }

        totalCost = totalCost - (+numberData[maxDurationIndex].cost)

        return totalCost

        function getNumericNumber(numberString) {
            var numberArray = numberString.split('-')
            var string = '';

            for (var i = 0; i < numberArray.length; i++) {
                string += numberArray[i];
            }

            return +string;

        }


    }

var str=“00:01:07400-234-090\n00:05:01701-080-080\n00:05:00400-234-090\n00:01:06701-080-080\n00:01:06701-080-000”
console.log（解决方案（str））
功能解决方案{
var totalCost=0
var lineArray=S.split（'\n'）
变量numberData=[]
/*{
数字=0，
持续时间=0，
成本=0
}*/
console.log（线性阵列）
对于（变量i=0；inumberData[maxDurationIndex]）
maxDurationIndex=i；
if（numberData[i].duration==numberData[maxDurationIndex]）{
var currentNumericNumber=getNumericNumber（numberData[i]）
var maxIndexNumber=getNumericNumber（numberData[maxDurationIndex]）
如果（currentNumericNumber>maxIndexNumber）
maxDurationIndex=i；
}
总成本+=numberData[i]。成本
}
totalCost=totalCost-（+numberData[maxDurationIndex].cost）
返回总成本
函数getNumericNumber（numberString）{
var numberraray=numberString.split（“-”）
var字符串=“”；
对于（变量i=0；i

---

您可以通过在输入中提供不同的电话号码来测试它，然后它就可以正常工作。

您的内循环在外循环的每次迭代中将

i

的值重置为

numberData.length

。对

numberData

上的内环使用不同的变量，如

j

 for(var j=0; j<numberData.length; j++)
 {
     if(numberData[j].number == number)
     {
        numberData[j].duration+= totalDuration
        numberData[j].cost +=cost
        numberPresent = true
     }
 }

---

没有过滤和映射的意义，而仅仅是标记长度。否则，您将如何增加那些数字与number属性中的值相同的值的持续时间和成本？您能否解释为什么自“i”之后，内部循环将i的值重置为numberData.length内循环的作用域位于该循环本身的内部，而外循环“i”对于内循环来说是全局的，因此它改变了外循环的“i”值，var的作用域是封闭函数，而不是块。

numberPresent = numberData.filter( s => s.number == number ).map( s => {
   s.duration += totalDuration;
   s.cost += cost;
   return s;
}).length > 0