為什么我的JS遞回函式回傳一個填充了相同條目的串列？

我一直在學校學習 Python，我正在利用自己的時間學習 Javascript 并處理一些 JS 專案。我不明白為什么我的遞回函式只是一個具有相同條目的串列。我已經黔驢技窮了。任何見解將不勝感激！

函式描述：該函式接受一個課程物件串列，帶有鍵值對"courseCode": string和"possibleCombos": list[number]. 我希望我的遞回函式輸出另一個物件串列，其中課程物件的“courseCode”值作為其鍵，“possibleCombos”的一個元素作為其值。回傳的串列將包含具有課程組合對的物件的所有可能排列。該函式還接受一個 Object 引數，用于遞回目的。

示例資料：

const dummyObject1 = {
    'courseCode': 'BLUE',
    'possibleCombos': [1, 2, 3, 4, 5]
}

const dummyObject2 = {
    'courseCode': 'RED',
    'possibleCombos': [11, 22, 33, 44]
}

const dummyObject3 = {
    'courseCode': 'PURPLE',
    'possibleCombos': [111, 222, 333, 444, 555, 666]
}

const dummyList = [dummyObject1, dummyObject2, dummyObject3]``` 

我理想地想要：

let dummySchedules = recursionFunction(dummyList, {})
console.log(dummySchedules)

//ideal console output
[
{'BLUE': 1, 'RED': 11, 'PURPLE': 111},
{'BLUE': 1, 'RED': 11, 'PURPLE': 222},
{'BLUE': 1, 'RED': 11, 'PURPLE': 333},
... //and so on.
]

但是，我得到的串列輸出只是同一個物件的 120 個條目。

這是我的代碼：

function recursiveFunction(listOfCourses, dictSoFar) {
    //base case, checks if listOfCourses is empty
    if (!listOfCourses.length) {
        return [dictSoFar]
    } else {
        //recursive step

        var arraySoFar = [] //accumulator

        //iterate through each element of listOfCourses[0]['possibleCombos']
        for (let combo of listOfCourses[0]['possibleCombos']) {
            //update dictSoFar entry.
            dictSoFar[listOfCourses[0]['courseCode']] = combo
            
            //filter out the course we just entered into dictSoFar.
            let course = listOfCourses[0]
            var cloneListOfCourses = listOfCourses.filter(item => item !== course)
            
            //recursive call, this time with the filtered out list. If we keep following the
            //the recursive call down, it should reach the point where listOfCourses is empty,
            //triggering the base case. At that point, dictSoFar already has all course: combo 
            //pairs. This should traverse through all possible course: combo pairs.
            var result = recursiveFunction(cloneListOfCourses, dictSoFar)
            
            //update the accumulator
            arraySoFar.push(...result)
        }
        return arraySoFar;
    }
}

怎么了？從理論上講，我認為邏輯是有道理的，我不知道哪里出了問題。

uj5u.com熱心網友回復：

你可以做這樣的事情

如果您需要一些解釋，請隨時詢問

const dummyObject1 = {
  'courseCode': 'BLUE',
  'possibleCombos': [1, 2, 3, 4, 5]
}

const dummyObject2 = {
  'courseCode': 'RED',
  'possibleCombos': [11, 22, 33, 44]
}

const dummyObject3 = {
  'courseCode': 'PURPLE',
  'possibleCombos': [111, 222, 333, 444, 555, 666]
}

const dummyList = [dummyObject1, dummyObject2, dummyObject3]

function recursiveFunction(listOfCourses) {

  const loop = (data, acc) => {
    
    if (!data.length) { // if listOfCourses is falsy
      return acc
    }
    const [next, ...rest] = data
    
    if(acc.length === 0){
      return loop(rest, next)
    }
    
    return loop(rest, next.flatMap(n => acc.flatMap(a => Object.assign({}, a, n))))
  }
  const courseCombo = listOfCourses.map(({
    courseCode,
    possibleCombos
  }) => possibleCombos.map(c => ({
    [courseCode]: c
  })))
  return loop(courseCombo, [])

}

console.log(recursiveFunction(dummyList))

我提出了一個更簡單的解決方案，根本不涉及遞回

它分為兩個步驟：

第一個轉換映射你用這種形式在一個元素陣列中的虛擬物件

[{ BLUE : 1}, { BLUE : 2},{ BLUE : 3}, { BLUE : 4}, { BLUE : 5}]

然后使用reduce它將三個陣列的所有組合合并在一起

const dummyObject1 = {
  'courseCode': 'BLUE',
  'possibleCombos': [1, 2, 3, 4, 5]
}

const dummyObject2 = {
  'courseCode': 'RED',
  'possibleCombos': [11, 22, 33, 44]
}

const dummyObject3 = {
  'courseCode': 'PURPLE',
  'possibleCombos': [111, 222, 333, 444, 555, 666]
}

const dummyList = [dummyObject1, dummyObject2, dummyObject3]

const result = dummyList
.map(({courseCode, possibleCombos}) => possibleCombos.map(c => ({[courseCode]: c})))
.reduce((res, item) => res.flatMap(r => item.flatMap(i => Object.assign({}, r, i)))) 



console.log(result)

標籤：javascript 递归

上一篇：如何使方法從頭開始運行而不使用回圈

下一篇：MainActivity作為控制器