Як у Javascript можна прив’язати аргументи до функції без прив'язки thisпараметра?

Наприклад:

//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?

Як я можу уникнути побічного ефекту від необхідності також прив’язувати область функції (наприклад, встановлення this= null)?

Редагувати:

Вибачте за непорозуміння. Я хочу прив’язати аргументи, а потім зможу викликати зв'язану функцію пізніше і змусити її поводитись так, як ніби я викликав початкову функцію і передав їй зв'язані аргументи:

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?

Я все ще нова в цьому, вибачте за плутанину.

Дякую!

Ви можете це зробити, але найкраще уникати думки про це як "обов'язкове", оскільки це термін, який використовується для встановлення значення "це". Можливо, ви думаєте про це як "вкручування" аргументів у функцію?

Що ви робите, це створити функцію, в яку вбудовані потрібні аргументи через закриття:

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

Сподіваюся, що я отримав синтаксис саме там. Для цього потрібно створити функцію, яку називають withWrappedArguments () (щоб бути педантичною, це анонімна функція, присвоєна змінній), яку ви можете викликати будь-коли в будь-якому місці і завжди буде діяти з фактичнимArg1Value та фактичнимArg2Value, і будь-чим іншим, що ви хочете ввести в там. Ви також можете прийняти додаткові аргументи під час дзвінка, якщо хочете. Секрет - це круглі дужки після фінальної дужки закриття. Вони спричиняють негайне виконання зовнішньої функції із переданими значеннями та генерування внутрішньої функції, яку можна викликати пізніше. Потім передані значення заморожуються в момент створення функції.

Це ефективно те, що пов'язує, але таким чином явно, що обкладені аргументи - це просто закриття локальних змінних, і не потрібно змінювати поведінку цього.

У ES6 це легко зробити за допомогою параметрів спокою спільно з оператором спред .

Таким чином, ми можемо визначити функцію, bindArgsяка працює як bind, за винятком того, що пов'язані лише аргументи, але не контекст ( this).

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

Потім для визначеної функції fooта об'єкта objвисловлювання

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

еквівалентно

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

де пов'язані лише перший та другий аргументи bar, тоді як використовується контекст, objзазначений у виклику, та додаткові аргументи додаються після пов'язаних аргументів. Повернене значення просто пересилається.

У рідному bindметодіthis значення у функції результату втрачається. Однак ви можете легко перекодувати загальну шим, щоб не використовувати аргумент для контексту:

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;
};

Ще одна крихітна реалізація просто для розваги:

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);
    };
}

Як використовувати:

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

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

Трохи важко точно сказати, що ви в кінцевому підсумку хочете зробити, тому що приклад є довільним, але ви, можливо, захочете розібратися у сторонах (або домовитись): 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(){})

Посилання на статтю Джона Ресіга: http://ejohn.org/blog/partial-functions-in-javascript/

Можливо, ви хочете зв'язати посилання на це в останньому, але ваш код: -

var c = function(a, b, c, callback) {};
var b = c.bind(null, 1, 2, 3); 

Наприклад, уже застосовано прив'язку, наприклад, це та пізніше ви не можете змінити. Що я запропонував би використовувати посилання також як параметр на зразок цього: -

var c = function(a, b, c, callback, ref) {  
    var self = this ? this : ref; 
    // Now you can use self just like this in your code 
};
var b = c.bind(null, 1, 2, 3),
    newRef = this, // or ref whatever you want to apply inside function c()
    d = c.bind(callback, newRef);

Використовуйте protagonist!

var geoOpts = {...};

function geoSuccess(user){  // protagonizes for 'user'
  return function Success(pos){
    if(!pos || !pos.coords || !pos.coords.latitude || !pos.coords.longitude){ throw new Error('Geolocation Error: insufficient data.'); }

    var data = {pos.coords: pos.coords, ...};

    // now we have a callback we can turn into an object. implementation can use 'this' inside callback
    if(user){
      user.prototype = data;
      user.prototype.watch = watchUser;
      thus.User = (new user(data));
      console.log('thus.User', thus, thus.User);
    }
  }
}

function geoError(errorCallback){  // protagonizes for 'errorCallback'
  return function(err){
    console.log('@DECLINED', err);
    errorCallback && errorCallback(err);
  }
}

function getUserPos(user, error, opts){
  nav.geo.getPos(geoSuccess(user), geoError(error), opts || geoOpts);
}

В основному, функція, якій ви хочете передати парами, стає проксі-сервером, який ви можете викликати для передачі змінної, і вона повертає функцію, якою ви хочете виконати завдання.

Сподіваюся, це допомагає!

Анонімний користувач опублікував цю додаткову інформацію:

Спираючись на те, що вже було запропоновано в цій публікації - найелегантніше рішення, яке я бачив, - це перекрити свої аргументи та контекст:

function Class(a, b, c, d){
    console.log('@Class #this', this, a, b, c, d);
}

function Context(name){
    console.log('@Context', this, name);
    this.name = name;
}

var context1 = new Context('One');
var context2 = new Context('Two');

function curryArguments(fn) {
    var args = Array.prototype.slice.call(arguments, 1);
    return function bindContext() {
      var additional = Array.prototype.slice.call(arguments, 0);
      return fn.apply(this, args.concat(additional));
    };
}

var bindContext = curryArguments(Class, 'A', 'B');

bindContext.apply(context1, ['C', 'D']);
bindContext.apply(context2, ['Y', 'Z']);

Ну для прикладу, який ви дали, це зробить

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

Якщо ви хочете гарантувати охоплення параметрів:

var b= (function(p1,p2,p3, obj){
        var c=obj.c;
        return function(callback){
                return c.call(obj,p1,p2,p3, callback);
        }
})(1,2,3,obj)

Але якщо так, то просто слід дотримуватися свого рішення:

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

Це кращий спосіб.

Простий такий?

var b = (cb) => obj.c(1,2,3, cb)
b(function(){}) // insidde object

Більш загальне рішення:

function original(a, b, c) { console.log(a, b, c) }
let tied = (...args) => original(1, 2, ...args)

original(1,2,3) // 1 2 3
tied(5,6,7) // 1 2 5

За допомогою LoDash ви можете використовувати _.partialфункцію.

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

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

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

Чому б не використовувати обгортку навколо функції, щоб зберегти це як міф?

function mythis() {
  this.name = "mythis";
  mythis = this;
  function c(a, b) {
    this.name = "original";
    alert('a=' + a + ' b =' + b + 'this = ' + this.name + ' mythis = ' + mythis.name);
    return "ok";
  }    
  return {
    c: c
  }
};

var retval = mythis().c(0, 1);

jQuery 1.9 приніс саме цю функцію з функцією проксі.

Як і в jQuery 1.9, коли контекст є нульовим або невизначеним, функція proxied буде викликана тим самим об'єктом, з яким був викликаний проксі. Це дозволяє використовувати $ .proxy () для часткового застосування аргументів функції без зміни контексту.

Приклад:

$.proxy(this.myFunction, 
        undefined /* leaving the context empty */, 
        [precededArg1, precededArg2]);

Випадок використання Jquery:

натомість:

for(var i = 0;i<3;i++){
    $('<input>').appendTo('body').click(function(i){
        $(this).val(i); // wont work, because 'this' becomes 'i'
    }.bind(i));
}

використовуй це:

for(var i = 0;i<3;i++){
    $('<input>').appendTo('body').click(function(e){
        var i = this;
        $(e.originalEvent.target).val(i);
    }.bind(i));
}