Wie erstellt man ein Array eines gegebenen Wertes rekursiv?

Question

Ich versuche, Rekursion mit Javascript zu arbeiten, und ich habe Probleme herauszufinden, wie dies rekursiv zu tun. Zum Beispiel würde fillArray(num, len) mit num = 5 und len = 3[5,5,5] zurückgeben. Ich bin ehrlich gesagt festgefahren, und ich war nicht in der Lage, Fortschritte zu machen. Es ist nicht viel, aber das ist was ich habe. Könnte jemand bitte helfen?

var fillArray = function(num, len) { 
    var list = []; 
    if (length === 0) { 
     return []; 
    } 
    return list.concat(function(value, length--)); 
} 

Answer 1

Dies kann leichter iterativ

var fillArray = function(num, len) { 
    var result = []; 

    for (var i = 0; i < len; i++) { 
     result.push(num); 
    } 

    return result; 
} 

Wenn Sie wirklich Rekursion erfolgen sollte

var fillArray = function(num, len) { 
    if (len === 0) { 
     return []; 
    } 

    return [num].concat(fillArray(num, len - 1)); 
} 

Answer 2

arbeiten verwenden, müssen Sie es so tun können, aber es ist nicht sehr effizient zu sein ehrlich.

function arrayFill(num, length){ 
 
    if(length === 0) return []; 
 
    return [].concat(num, arrayFill(num, length - 1)); 
 
} 
 

 
console.log(arrayFill(5, 3));

Answer 3

Etwas wie folgt aus:

var fillArray = function(num, len, list) { 
     list.push(num); 
     if (list.length === len) { 
      return list; 
     } else { 
      return fillArray(num, len, list); 
     } 
    } 

    var num = 3; 
    var len = 3; 
    var list = []; 

    console.log(fillArray(num, len, list)); 

Answer 4

var fillArray = function(num, len) { 
    var result = []; 

    if (len > 1) result.push(fillArray(num, len - 1)); 
    result.push(num); 

    return result; 
} 

x = fillArray(5, 3); 

Answer 5

Ein Beispiel Rekursion:

function fillArray(num, length) { 
    var array; 
    if(length) { 
     array = fillArray(num, length-1); 
     array.push(num); 
     return array; 
    } 
    else { 
     return []; 
    } 
} 

Die rekursive Funktion ruft sich selbst auf, wobei die Länge um 1 dekrementiert wird, bis die Länge Null ist. Dann gibt es ein leeres Array zurück. Im Rückweg wird auf jeder Ebene der abnehmenden Rekursion der Wert der Zahl auf das Array geschoben.

Rekursion erfordert im Allgemeinen eine Bedingung, um weitere Rekursion zu stoppen (hier durch length - 1 erreicht Null), und den Wert des rekursiven Aufrufs (hier der Wert array).