Возможна ли передача контекста (Scope) между замыканиями (Closure)?

Question

[Victor]

// рабочий результат
var invoke = function(fn){
  var str = 'var test = \'sss\';';
  alert(fn)
  var fnxt = new Function(str+fn);
  fnxt();
}
var tester = 'alert(test);'

invoke(tester);

// желательный результат
var invoke_real = function(fn){
  var test = 'sss';
  alert(fn)
  // дальше, само собой -- не работает, т.к. test отсутствует для scope tester_real'a
  fn();
}
var tester_real = function(){ alert(test); }

invoke_real(tester_real);

* This source code was highlighted with Source Code Highlighter.

Comments

[mark_ablov]

что хотите получить в итоге?
в invoke_real у вас scope == window.

[Victor]

хочу, чтобы в tester_real «материализовалась» переменная test из Scope invoke_real'a

Answer 1

[mark_ablov]

Не знаю насколько вам подойдет, но только через работу с объектом пришло в голову:

    var invoke_real = 
    {
        real: function(fn)
        {
           this.test = 'sss';
           fn(this);
           this.f();
        }
    };
    var tester_real = function(ctx){ctx.f = function() {alert(this.test);};};

    invoke_real.real(tester_real);

scope наследуется только если функция определена внутри другой функции, так что сомневаюсь что можно сделать значительно проще.

Comments

[mark_ablov]

в принципе можно упростить, использовав arguments.callee/arguments.caller

[Victor]

Решение понятное. Оно хорошее.
Думаю, что не менее успешно можно просто воспользоваться промежуточным объектом.

К сожалению, это не совсем то, что нужно.

1. Есть необходимость проинициализировать внутри функции кучу переменных.
2. Таких функций — десяток (пока).
3. Можно просто написать функцию, возвращающую объект с проинициализированными переменными, собственно, так и сделано.

Хотелось сделать «заморочено и страшно», так, чтобы внутри функции «всплывали» эти самые переменные. Например:

1. Объявляем одну из «наших» функций: var test_n_n = function(){
2. На второй строчке пишем вызов к функции-инициализаторше: define_our_vars();
3. После исполнения этого вызова, начиная с третьей строчки функции test_n_n, будут доступны переменные, которые были объявлены внутри Scope define_our_vars(), при этом все они «существуют» только в рамках Scope для " define_our_vars" и «test_n_n».

Сейчас на месте второй строчки конструкция:
var Object_For_Variables = define_our_vars();

Соответственно «define_our_vars» просто возвращает объект, конечно, при этом он виден только внутри «test_n_n», так что глобальный Scope девственно чист…

Да, это просто, понятно, и вполне юзабельно, и «хороший тон».

Но, хотелось как нибудь красиво «поиграться», чтобы, например, алгоритмически написать следующую логическую конструкцию:
А начиная с этого места у нас будет присутствовать пачка переменных, которые мы дальше можем использовать, несмотря на то, что для них раньше не было даже объявления.

Примерно так: define new variables for this local scope ().

Возможно, можно «поиграться», и передать текущий «this», т.е. функцию «test_n_n» в «define_our_vars», например так:

define_our_vars.call(test_n_n);

а уже потом вызвать test_n_n внутри define_our_vars.

При этом, конечно, внутри test_n_n должна быть «обертка», обрабатывающая логику так:
1. Если test_n_n вызвана напрямую, то «пере_вызвать» её через define_our_vars.call(test_n_n)
2. Иначе — просто исполнить её код, т.к. все нужные переменные есть.

Получается, что нужно уже как бы три функции. Инициализационная, Обёрточная, и, непосредственно та, которую вызывают. Может быть здесь, как раз, помог бы «decorator pattern». Но, что-то пока у меня мозгов не хватило как это можно сделать.

Вот, собственно, и спросил.
Но, что-то

[Константин Китманов]

Подавите это желание, пожалуйста.

Явно лучше неявного. Куча переменных, которые магически появляются неизвестно откуда, плохо повлияют на читабельность кода. Даже если вы пишете для себя.

Answer 2

[Victor]

То есть, пока, «отсутствие мыслей» завело сюда:

var invoker = {
   init  : function(fn){
    invoker.arr[fn] = window[fn];
    window[fn] = function(){
      var test = 'sss';
      alert('+1 '+test)
      invoker.arr[fn]();
    };
  }
  , del  : function(fn){
    window[fn] = invoker.arr[fn];
    delete invoker.arr[fn];
  }
  , arr  : []
}

var tester = function(){ alert(222); try{ alert(test); }catch(e){ alert(e); /* ref err */ } }

invoker.init('tester');
alert(111);
tester();
alert(333);
invoker.del('tester');
tester();

* This source code was highlighted with Source Code Highlighter.

Comments

[mark_ablov]

мне всё же непонятны ваши стремления, хотя и прочитал тот длинный коммент :)
что вас напрягает в использовании объекта, который вы инициализируете своей функцией?
необходимость каждый раз писать имя объекта перед переменными? ну так используйте with(obj) :)

[Victor]

Марк, меня ничего не напрягает. Это уже так и работает, почти так как написали Вы, код немножко другой но смысл тот же.

Меня просто привлекла «странность» идеи. Желание понять возможно ли?
Это всё.

Answer 3

[Александр Кит]

Может такой вариант подойдет?

function test(args) {
  console.log(this.title1, test.title1, args.title2); // -> Hello! Hello! Hello World
}
(function(){
  test.__proto__.title1 = 'Hello!';
  test = test.bind(test, {title2: 'Hello World'});
    
})();

test();