Implementieren einer Join-Funktion, die 3 Argumente übergeben wird

Question

Ich bin auf der Suche nach dieser Übung fLet schreiben Sie eine Funktion namens Join, die funktioniert genau wie die integrierte Join, aber mit reduzieren!

Let's write a function called join that works just like the built-in join, but using reduce! If you're unfamiliar with the built-in version of join, this is how it works: 
 

 
["the", "quick", "brown", "fox"].join(" "); // => "the quick brown fox" 
 
["one", "two", "three"].join(":"); // => "one:two:three" 
 
Part One: First, write a function called joinWith that takes three arguments: the string to join onto, the string that will be joined, and a separator. That is, it should work like this: 
 

 
function joinWith(onto, next, separator) { 
 
    // YOUR CODE HERE 
 
} 
 
joinWith("the quick", "brown", " "); // => "the quick brown" 
 
joinWith("one:two", "three", ":"); // => "one:two:three" 
 
Part Two: Now, using joinWith and reduce, write join: 
 

 
function join(array, separator) { 
 
    // YOUR CODE HERE 
 
} 
 
join(["the", "quick", "brown", "fox"], " "); // => "the quick brown fox" 
 
join(["one", "two", "three"], ":"); // => "one:two:three"

und ich habe den folgenden Code geschrieben:

var joinWith = function(start, toAdd, separt){ 
 

 
\t return reduce(arguments, function(start, toAdd){ 
 
\t \t return start + separt + toAdd; 
 
\t \t 
 
\t }, " "); 
 
}

Allerdings bin ich mir nicht sicher, warum ich folgend als Ergebnis bin immer.

joinWith("one: two", "three", ":"); 
 
" :one: two:three::"

Kann mir jemand sagen, was hier geschieht und wie ich den Separator von der Vorderseite des Strings entfernen und den Bereichen, in denen der Separator nach oben nicht zeigen soll.

Ich schätze Ihre Hilfe sehr.

Answer 1

Was derzeit passiert:

Sie zeigen nicht Ihre reduce() Funktion der Implementierung, aber vorausgesetzt, es ist in der gleichen Weise wie die Standard-Array.prototype.reduce() arbeitet dann kann die Ausgabe wie folgt erklärt werden:

arguments Objekt ist ein Array-wie mit diesen Werten:

["one: two", "three", ":"] 

Wenn Sie anrufen reduce() auf arguments, besucht er jedes Element wiederum wie folgt:

1. Iteration: start ist " ", aus dem letzten Argument reduce() und toAdd ist "one: two". Von dieser Iteration geben Sie die Zeichenfolge " :one: two" zurück.

zweite Iteration: start ist " :one: two" (der Rückgabewert aus der vorherigen Iteration) und toAdd ist "three", und Sie kehren " :one: two:three".

3. Iteration: start ist " :one: two:three" (der Rückgabewert aus der vorherigen Iteration) und toAdd ist ":" und Sie kehren " :one: two:three::"

Was sollten Sie tun:

Sie kennen die Funktion hat drei Argumente , so benutzen Sie einfach:

function joinWith(start, toAdd, separt) { 
    return start + separt + toAdd; 
} 

Aber Sie wirklich verwenden möchten reduce():

Nun, es ist wirklich das falsche Werkzeug für den Job, wenn Ihre Spezifikation nur zwei Strings zu verbinden ist, aber wenn es sein muss, wollen Sie es auf alle, aber das letzte Argument zu joinWith() verwenden - unter Hinweis darauf, dass wie folgt, in dem Sie eine beliebige Anzahl von Zeichenfolge übergeben, so lange zu verbinden, wie der Separator das letzte Argument ist:

var joinWith = function(){ 
 
    if (arguments.length < 3) return arguments[0]; 
 
    var separt = arguments[arguments.length-1]; 
 
    return reduce(Array.prototype.slice.call(arguments,0,-1), function(start, toAdd){ 
 
    return start + separt + toAdd; 
 
    }); // note: do not pass an initial value 
 
} 
 
    
 
console.log(joinWith("one: two", "three", ":")); 
 
console.log(joinWith("one","two","three","four","five",":")); 
 
console.log(joinWith("a","b","c","d","e",", ")); 
 
console.log(joinWith("x","y")); 
 
    
 
// Dodgy simulation of your reduce() function for demo purposes only: 
 
function reduce(arr, cb) { 
 
    return Array.prototype.reduce.call(arr, cb); 
 
}