Javascript rekursive Funktion gibt keinen Wert zurück?

Question

Im ein codewars Problem zu lösen und im ziemlich sicher, ich habe es funktioniert:

function digital_root(n) { 
    // ... 
    n = n.toString(); 
    if (n.length === 1) { 
     return parseInt(n); 
    } else { 
     let count = 0; 
     for (let i = 0; i < n.length; i++) { 
      //console.log(parseInt(n[i])) 
      count += parseInt(n[i]); 
     } 
     //console.log(count); 
     digital_root(count); 
    } 
} 

console.log(digital_root(942)); 

Im Wesentlichen ist es angeblich eine „digitale Wurzel“ zu finden:

Eine digitale Wurzel ist die rekursive Summe aus alle Ziffern in einer Nummer. Gegeben n, nimm die Summe der Ziffern von n. Wenn dieser Wert zwei Ziffern hat, wird die Reduzierung auf diese Weise fortgesetzt, bis eine einstellige Zahl produziert wird. Dies gilt nur für die natürlichen Zahlen.

Also im Moment die richtige Antwort am Ende bekommen, aber aus irgendeinem Grunde auf der if Anweisung (die die Debugger laufen aufpassender und es macht diese Aussage geben Sie ihm den Rückgabewert sagen wird der korrekte Wert ist.

Aber dann springt er aus der if Aussage und versucht, von der Haupt digital_root Funktion zurückzukehren?

Warum ist das? sollte es nicht aus diesem brechen, wenn es die if Aussage trifft? im verwirrt, warum versuchen, es zu springen aus dem if Stateme nt und dann versuchen, nichts von digital_root zurückgeben, so dass der Rückgabewert endet undefiniert ist?

Answer 1

Sie geben nichts zurück else. Es sollte sein:

return digital_root(count); 
^^^^^^^ 

Warum?

digital_root soll etwas zurückgeben. Wenn wir es mit einer einstelligen Zahl aufrufen, dann wird der if Abschnitt ausgeführt, und da wir von diesem if zurückkommen, funktioniert alles gut. Wenn wir jedoch eine Zahl bereitstellen, die aus mehr als einer Ziffer besteht, wird der else-Abschnitt ausgeführt. Nun, im Abschnitt else berechnen wir die digital_root der count, aber wir verwenden diesen Wert (der Wert, der zurückgegeben werden soll) nicht. Die Linie oben könnte in zwei Zeilen Code geteilt werden, die es leicht zu verstehen macht:

var result = digital_root(count); // get the digital root of count (may or may not call digital_root while calculating it, it's not owr concern) 
return result;     // return the result of that so it can be used from the caller of digital_root 

Answer 2

seine eine rekursive Funktion sollte der Code etwas sein wie dieses

function digital_root(n) { 
    // ... 
    n=n.toString(); 
    if(n.length === 1){ 
     return parseInt(n); 
    } 
    else 
    { 
    let count = 0; 
    for(let i = 0; i<n.length;i++) 
    { 
    //console.log(parseInt(n[i])) 
    count+=parseInt(n[i]); 
    } 
    //console.log(count); 
    return digital_root(count); 
    } 
} 

Sie die gleiche Funktion zurückkehren sollte stattdessen der Aufruf es nur den richtigen Call-Stack

Answer 3

Code-Überprüfung

Meine Ausführungen zu erhalten ist, Code Kommentare unten

// javascript generally uses camelCase for function names 
// so this should be digitalRoot, not digital_root 
function digital_root(n) { 
    // variable reassignment is generally frowned upon 
    // it's somewhat silly to convert a number to a string if you're just going to parse it again 
    n = n.toString(); 
    if (n.length === 1) { 
     // you should always specify a radix when using parseInt 
     return parseInt(n); 
    } else { 
     let count = 0; 
     for (let i = 0; i < n.length; i++) { 
      //console.log(parseInt(n[i])) 
      count += parseInt(n[i]); 
     } 
     // why are you looping above but then using recursion here? 
     // missing return keyword below 
     digital_root(count); 
    } 
} 

console.log(digital_root(942)); 

einfache rekursive Lösung

Mit einigen dieser Dinge im Kopf, lassen Sie uns zu digitalRoot unser Ansatz vereinfachen ...

const digitalRoot = n => 
 
    n < 10 ? n : digitalRoot(n % 10 + digitalRoot((n - n % 10)/10)) 
 
    
 
console.log(digitalRoot(123))   //   => 6 
 
console.log(digitalRoot(1234))  //  10 => 1 
 
console.log(digitalRoot(12345))  //  15 => 6 
 
console.log(digitalRoot(123456))  //  21 => 3 
 
console.log(digitalRoot(99999999999)) // 99 => 18 => 9

---

reduzieren Mit

Eine digitale Wurzel ist die rekursive Summe aller Ziffern einer Zahl. Gegeben n, nehmen Sie die Summe der Ziffern von n. Wenn dieser Wert zweistellig ist, wird die Reduzierung auf diese Weise fortgesetzt, bis eine einstellige Zahl erzeugt wird. Dies gilt nur für die natürlichen Zahlen.

Wenn Sie eine tatsächliche reduzierende Funktion verwenden sollen, zeige ich Ihnen hier, wie Sie das tun. Zuerst machen wir eine toDigits Funktion, die eine ganze Zahl nimmt und ein Array ihrer Ziffern zurückgibt. Dann werden wir digitalRoot implementieren, indem diese die entsprechenden Ziffern Reduktion eines add Minderer mit dem leeren Summe initialisiert unter Verwendung 0

// toDigits :: Int -> [Int] 
 
const toDigits = n => 
 
    n === 0 ? [] : [...toDigits((n - n % 10)/10), n % 10] 
 

 
// add :: (Number, Number) -> Number 
 
const add = (x,y) => x + y 
 

 
// digitalRoot :: Int -> Int 
 
const digitalRoot = n => 
 
    n < 10 ? n : digitalRoot(toDigits(n).reduce(add, 0)) 
 
     
 
console.log(digitalRoot(123))   //   => 6 
 
console.log(digitalRoot(1234))  //  10 => 1 
 
console.log(digitalRoot(12345))  //  15 => 6 
 
console.log(digitalRoot(123456))  //  21 => 3 
 
console.log(digitalRoot(99999999999)) // 99 => 18 => 9