Wie kann man Funktionsargumente binden, ohne dies zu binden?

Wie kann ich in Javascript Argumente an eine Funktion binden, ohne die this Parameter?

Zum Beispiel:

//Example function.
var c = function(a, b, c, callback) {};

//Bind values 1, 2, and 3 to a, b, and c, leave callback unbound.
var b = c.bind(null, 1, 2, 3); //How can I do this without binding scope?

Wie kann ich den Nebeneffekt vermeiden, den Bereich der Funktion binden zu müssen (z. B. setting this = null) auch?

Bearbeiten:

Sorry für die Verwirrung. Ich möchte Argumente binden, dann in der Lage sein, die gebundene Funktion später aufzurufen und sie sich genau so verhalten zu lassen, als hätte ich die ursprüngliche Funktion aufgerufen und ihr die gebundenen Argumente übergeben:

var x = 'outside object';

var obj = {
  x: 'inside object',
  c: function(a, b, c, callback) {
    console.log(this.x);
  }
};

var b = obj.c.bind(null, 1, 2, 3);

//These should both have exact same output.
obj.c(1, 2, 3, function(){});
b(function(){});

//The following works, but I was hoping there was a better way:
var b = obj.c.bind(obj, 1, 2, 3); //Anyway to make it work without typing obj twice?

Ich bin noch neu dabei, sorry für die Verwirrung.

Vielen Dank!

Sie können dies tun, aber am besten vermeiden Sie es, es als “verbindlich” zu betrachten, da dies der Begriff ist, der zum Festlegen des “this” -Werts verwendet wird. Stellen Sie sich das vielleicht so vor, als würden Sie die Argumente in eine Funktion “verpacken”?

Was Sie tun, ist eine Funktion zu erstellen, in die die gewünschten Argumente über Closures eingebaut sind:

var withWrappedArguments = function(arg1, arg2)
    {
        return function() { ... do your stuff with arg1 and arg2 ... };
    }(actualArg1Value, actualArg2Value);

Ich hoffe, ich habe die Syntax richtig verstanden. Was es tut, ist eine Funktion namens withWrappedArguments() zu erstellen (um pedantisch zu sein, es ist eine anonyme Funktion, die der Variablen zugewiesen ist), die Sie jederzeit und überall aufrufen können und immer mit dem aktuellenArg1Value und dem aktuellenArg2Value und allem anderen, was Sie einfügen möchten, agieren dort. Wenn Sie möchten, können Sie auch weitere Argumente zum Zeitpunkt des Anrufs akzeptieren lassen. Das Geheimnis sind die runden Klammern nach der abschließenden schließenden geschweiften Klammer. Diese bewirken, dass die äußere Funktion mit den übergebenen Werten sofort ausgeführt wird und die später aufrufbare innere Funktion generiert. Die übergebenen Werte werden dann zum Zeitpunkt der Generierung der Funktion eingefroren.

Dies ist effektiv das, was bind tut, aber auf diese Weise ist es explizit, dass die umschlossenen Argumente einfach Closures für lokale Variablen sind, und es besteht keine Notwendigkeit, das Verhalten davon zu ändern.

In ES6 geht das ganz einfach mit Ruhe Parameter In Verbindung mit Spread-Operator.

Wir können also eine Funktion definieren bindArgs das funktioniert wie bindaußer dass nur Argumente gebunden sind, aber nicht der Kontext (this).

Function.prototype.bindArgs =
    function (...boundArgs)
    {
        const targetFunction = this;
        return function (...args) { return targetFunction.call(this, ...boundArgs, ...args); };
    };

Dann für eine bestimmte Funktion foo und ein Objekt objdie Aussage

return foo.call(obj, 1, 2, 3, 4);

ist äquivalent zu

let bar = foo.bindArgs(1, 2);
return bar.call(obj, 3, 4);

wo nur das erste und zweite Argument gebunden sind barwährend der Kontext obj der im Aufruf angegebene Wert verwendet wird und zusätzliche Argumente nach den gebundenen Argumenten angehängt werden. Der Rückgabewert wird einfach weitergeleitet.

Im Eingeborenen bind Methode das this Wert in der Ergebnisfunktion geht verloren. Sie können das gemeinsame Shim jedoch leicht umcodieren, um kein Argument für den Kontext zu verwenden:

Function.prototype.arg = function() {
    if (typeof this !== "function")
        throw new TypeError("Function.prototype.arg needs to be called on a function");
    var slice = Array.prototype.slice,
        args = slice.call(arguments), 
        fn = this, 
        partial = function() {
            return fn.apply(this, args.concat(slice.call(arguments)));
//                          ^^^^
        };
    partial.prototype = Object.create(this.prototype);
    return partial;
};

var b = function() {
    return c(1,2,3);
};

Eine weitere winzige Implementierung nur zum Spaß:

function bindWithoutThis(cb) {
    var bindArgs = Array.prototype.slice.call(arguments, 1);

    return function () {
        var internalArgs = Array.prototype.slice.call(arguments, 0);
        var args = Array.prototype.concat(bindArgs, internalArgs);
        return cb.apply(this, args);
    };
}

Wie benutzt man:

function onWriteEnd(evt) {}
var myPersonalWriteEnd = bindWithoutThis(onWriteEnd, "some", "data");

Es ist ein bisschen schwierig, genau zu sagen, was Sie letztendlich tun möchten, da das Beispiel irgendwie willkürlich ist, aber Sie möchten sich vielleicht mit Partials (oder Currying) befassen: http://jsbin.com/ifoqoj/1/edit

Function.prototype.partial = function(){
  var fn = this, args = Array.prototype.slice.call(arguments);
  return function(){
    var arg = 0;
    for ( var i = 0; i < args.length && arg < arguments.length; i++ )
      if ( args[i] === undefined )
        args[i] = arguments[arg++];
    return fn.apply(this, args);
  };
};

var c = function(a, b, c, callback) {
  console.log( a, b, c, callback )
};

var b = c.partial(1, 2, 3, undefined);

b(function(){})

Link zum Artikel von John Resig: http://ejohn.org/blog/partial-functions-in-javascript/

Verwenden LoDash du kannst den … benutzen _.partial Funktion.

const f  = function (a, b, c, callback) {}

const pf = _.partial(f, 1, 2, 3)  // f has first 3 arguments bound.

pf(function () {})                // callback.