Vanilla Javascript Algorithmus, wie er und Erklärung

Question

Für meine Schulaufgabe zu tun haben, rief ich eine reine Javascript-Funktion kodieren:

foo(c) 

das sollte die folgenden Werte zurück:

foo('a') // return 'fa' 
foo()('b') // return 'fob' 
foo()()("t")) // return 'foot' 

Also im Grunde Wenn die Funktion mit einem Zeichen 'c' als Parameter aufgerufen wird, werden die ganzen Werte zurückgegeben (beachten Sie, dass das Aufrufen von foo() ein 'o' Zeichen im gesamten Rückgabewert hinzufügt und das erste zurückgegebene Zeichen der letzten Zeichenfolge immer ' f '.

Kann jemand eine mögliche Implementierung bereitstellen? Idealerweise würde ich es gerne selbst ausprobieren, daher sind auch Hinweise und Tipps sowie Kommentare im Code sehr willkommen.

NB: Mein größter Kampf im Moment ist es, einen Weg zu finden, die aufrufende Funktion zu verketten.

Vielen Dank.

Answer 1

function foo (c) { 

    // Initialize the result 
    var result = 'f'; 

    // Call the internal foo and return the result 
    // Which will either be the function itself, or a string, depnding on 
    // whether or not a truthy argument was passed in 
    return foo(c); 

    function foo (c) { 

     // If an argument was passed in, return the result 
     if (c) 
      return result + c; 

     // Otherwise append an 'o' to the result 
     result += 'o'; 

     // and return the function so it can be called again 
     return foo; 
    } 

} 

Answer 2

Hier ist eine rekursive Ansatz mit Pfeil Funktionen:

const foo = c => { 
    let rec = acc => x => x === undefined ? rec(acc + "o") : foo(acc + x); 
    return c === undefined ? rec("o") : "f" + c; 
}; 

foo('t'); // "ft" 
foo()('t'); // "fot" 
foo()()('t'); // "foot" 

foo ist eine einstellige Funktion, kann aber den Fall behandeln, wenn es ohne Argument aufgerufen wird. Die innere Funktion rec ist in Curry-Form definiert und akzeptiert einen Akkumulator als erste und eine Zeichenfolge als zweiten Parameter. Wenn das zweite Argument weggelassen wird, ruft rec rekursiv sich selbst auf.

Answer 3

Iven's answer mich inspiriert zu diesem Spaß Herausforderung

// ES6 
const foo = (x,y='f') => x && (y + x) || (x => foo(x, y + 'o')); 
foo('a'); // "fa" 
foo()('b'); // "fb" 
foo()()('t'); // "foot" 

---

Für Menschen mit ES5 noch zu nehmen ...

// ES5 
var foo = function foo(x) { 
    var y = arguments.length <= 1 || arguments[1] === undefined ? 'f' : arguments[1]; 
    return x && y + x || function (x) { 
    return foo(x, y + 'o'); 
    }; 
}; 
foo('a'); // "fa" 
foo()('b'); // "fb" 
foo()()('t'); // "foot" 

Answer 4

Wenn Sie nicht mit brillanten Ideen wie @Iven kommen können Marquardt, eine Schließung würde den Job perfekt machen.

function Foo(){ 
    var count = 0, 
     str = ""; 
    function f(a){ 
    if (!!a){ 
    str = "f"+"o".repeat(count)+a; 
    count = 0; 
    return str; 
    } 
    count++; 
    return foo; 
    } 
    return f; 
} 
var foo = Foo(); 
foo('a')  // <- 'fa' 
foo()('b')  // <- 'fob' 
foo()()("t")) // <- 'foot' 

Answer 5

Neben meiner previous answer, die zur Lösung dieses Problems eine naive und herkömmliche Art und Weise zeigt, wollte ich ganz von selbst eine separate Antwort hinzuzufügen, da ich das nicht nett unbemerkt gehen wollte. Die wahrscheinlich beste Lösung für dieses Problem liegt in einer meist übersehenen Spezialität der ES6-Standardwerte.

Wenn eine Funktion aufgerufen wird, wenn ein Argument mit Standardwert nicht angegeben wird, gilt der Standardwert. (es wird nicht "undefined")

Sobald Sie diese Funktionalität kennen, ist die Antwort auf diese Frage sehr einfach und nichts anderes als ein einzelner Liner.

var foo = (c, o = "") => !!c ? "f"+o+c : c => foo(c, o+= "o") 
foo("a"); //fa 
foo()("b"); //fob 
foo()()("t") //foot