Добавить функцию в область действия другой функции JavaScript

Question

Я пытаюсь получить приведенный ниже пример кода.
Edit (Стараясь быть более ясно, что цель состоит в том):

Я wan't, чтобы все функции и переменные obj доступных в функциях setup и draw, как они где глобалам. Это не для браузера. Это для Adobe ExtendScript, поэтому я могу использовать только EcmaScript 3 и некоторые полисы. lib.js файл предоставлен мной и включая до файл user-script.js. У пользователя есть ссылка, какие функции доступны и могут использовать их в пределах setup и draw. Это на самом деле очень похоже на то, что делает P5.js, но я пытаюсь добиться этого для InDesign. Конечно, мы можем назвать obj.foo(). Цель состоит в том, чтобы избавиться от obj., чтобы дать пользователю возможность просто позвонить foo и получить результат obj.foo.

Это lib.js. Это небольшая часть библиотеки, чтобы проиллюстрировать то, что у меня есть.

var obj = { 
    foo: function() { 
    console.log('foo'); 
    }, 
    bah: function() { 
    console.log('bah'); 
    }, 
    foobah:function(arg){ 
    return arg*2; 
    }, 
    CONST:"Hello World", 
    go:function(){ 
    // looks in the global scope if there is 
    // a setup and draw function and should patch them. 
    if(typeof glob.setup === 'function'){ 
     glob.setup(); 
    }, 
    if(typeof glob.draw === 'function'){ 
     glob.draw(); 
    } 
    } 
}; 

Это может быть пользователь-script.js. Структура мы обеспечиваем:

• #include для Lib
• настройки функции() {}
• функция Draw() {}
• obj.go() в качестве исполнения всего (может быть удалены позже)

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

#include lib.js 

function setup() { 
    foo(); // might be called or not 
    console.log('in setup'); 
} 

function draw() { 
    bah();// might be called or not 
    console.log('in draw'); 
} 
obj.go() 

---

Благодаря все ваши ответы. Я рассмотрю их и вернусь, чтобы сообщить, что было окончательным решением. Кажется, что все они решают проблему по-разному. В настоящее время я не могу сказать, какой из них «правильный». Те, кого мы, кажется, были ближе всего к моему вопросу, получили от меня повышенную защиту.

Answer 1

Я вижу проблему добавления в глобальном масштабе, вот новый способ использования eval

var obj = { 
    foo: function() { 
    console.log('foo'); 
    }, 
    bah: function() { 
    console.log('bah'); 
    } 
}; 

function fn1() { 
    foo(); 
    console.log('fn1'); 
} 

function fn2() { 
    bah(); 
    console.log('fn2'); 
} 

function main() { 
    function myFunc(fn) { 
    function foo() { 
     obj.foo(); 
    } 
    function bah() { 
     obj.bah(); 
    } 
    eval("this.exec = " + fn.toString()); 
    } 

    var myNewFunc1 = new myFunc(fn1); 
    myNewFunc1.exec(); //foo, fn1 
    var myNewFunc2 = new myFunc(fn2); 
    myNewFunc2.exec(); //bah, fn2 
} 

main(); 

Работа fiddle

Answer 2

Вы можете передать функцию в функцию.

var obj = { 
    foo: function() { 
    console.log('foo'); 
    }, 
    bah: function() { 
    console.log('bah'); 
    } 
}; 

function fn1(passedFoo) { 
    passedFoo(); 
    console.log('fn1'); 
} 

function fn2(passedBah) { 
    passedBah(); 
    console.log('fn2'); 
} 

function main() { 
    fn1(obj.foo); // Should output: foo and then fn1 
    fn2(obj.bah); // should output: bah and hen fn2 
} 

Answer 3

Это делает так, как вы просите с помощью затворов и функцию высшего порядка, но OBJ в рамках fn1 и Fn2 поэтому фактическая функция не нужно вводить можно просто позвонить obj.foo внутри каждого функция.

var obj = { 
 
    foo: function() { 
 
    console.log('foo'); 
 
    }, 
 
    bah: function() { 
 
    console.log('bah'); 
 
    } 
 
}; 
 

 
function higherOrderF(f,name){ 
 
    return function(){ 
 
    name && console.log(name) 
 
    return f.apply(null,arguments) 
 
    } 
 
} 
 

 
var fn1 = higherOrderF(obj.foo, 'fn1') 
 
var fn2 = higherOrderF(obj.bah, 'fn2') 
 

 
fn1(); 
 
fn2();

Answer 4

Это обезьяна заплата решение это действительно замена оригинальных функций с новыми, еще называют первоначальную функцию ... так он работает, как если бы вы вводили код в них. Вы могли бы использовать функцию более высокого порядка, чтобы помочь составить эти патчи для обезьян.

var obj = { 
 
    foo: function() { 
 
    console.log('foo'); 
 
    }, 
 
    bah: function() { 
 
    console.log('bah'); 
 
    } 
 
}; 
 

 
function fn1() { 
 
    //foo(); 
 
    console.log('fn1'); 
 
} 
 

 
function fn2() { 
 
    //bah(); 
 
    console.log('fn2'); 
 
} 
 

 
main() 
 
function main() { 
 
    //monkey patched functions 
 
    var originalFn1=fn1 
 
    fn1 = function(){ 
 
    obj.foo() 
 
    return originalFn1.apply(this,arguments) 
 
    } 
 
    
 
    var originalFn2=fn2 
 
    fn2 = function(){ 
 
    obj.bah() 
 
    return originalFn2.apply(this,arguments) 
 
    } 
 
    
 
    fn1(); // Should output: foo and then fn1 
 
    fn2(); // should output: bah and hen fn2 
 
}

Answer 5

Я думаю, что для функции добавления, нужно этот глобальных переменный .so здесь я проверяю для неопределенного состояния для функции вызова второго раза без параметра!

function fn1(f) { 
    if(typeof f != "undefined") this.fn1.add = f; 
    this.fn1.add(); 
    console.log('fn1'); 
} 

function fn2(f) { 
    if(typeof f != "undefined") this.fn2.add = f; 
    this.fn2.add(); 
    console.log('fn2'); 
} 
function main() { 
    fn1(obj.foo); // <= Should add function foo to fn1 
    fn2(obj.bah); // <= Should add function bah to fn2 
    fn1(); // Should output: foo and then fn1 
    fn2(); // should output: bah and hen fn2 
} 

main(); 

Answer 6

Я думаю, что прототипы - это путь. Итак, я использую Function.prototype в своем решении. Пожалуйста, проверьте, работает ли это для вас:

var obj = { 
    foo: function() { 
     console.log('food'); 
    }, 
    goo: function() { 
     console.log('good'); 
    } 
} 

Function.prototype.add = function(fun) { 
    if (!this.list) { 
     this.list = []; 
    } 
    this.list.push(fun); 
} 

function a() { 
    if (a.list) { 
     a.list.forEach(function(f) { 
      f(); 
     }) 
    } 
    console.log('done at a'); 
} 

function b() { 
    if (b.list) { 
     b.list.forEach(function(f) { 
      f(); 
     }) 
    } 
    console.log('done at b'); 
} 

function main() { 
    a.add(obj.foo); 
    b.add(obj.goo); 
    a(); 
    b(); 
    console.log('done at main'); 
} 

main(); 

Я пытался использовать столько, как вы могли бы назвать (с точки зрения структуры).

У вас проблема?

Answer 7

Как уже упоминалось, это единственный шаблон, который помогает достичь цели изменения/изменения управляющего потока закрытых функций/методов (таким образом, у них нет собственных кодовых оснований.) Является функциональным составом.

Он также указал на то, что к нему по-разному применяются апробации.

В измененном примере OP будет использована прототипная реализация Function.before. Поскольку JavaScript уже имеет стандартизированную bind, я твердо убежден в том, что Function.prototype это правильное место, а также для некоторых других метод модификаторов как before, after, around, afterThrowing и afterFinally.

... наклеивания как можно ближе к примеру Ор как можно:

var 
    obj = { 
     foo: function() { 
      console.log('foo'); 
     }, 
     bah: function() { 
      console.log('bah'); 
     } 
    }; 

function fn1() { 
    //foo(); 
    console.log('fn1'); 
} 

function fn2() { 
    //bah(); 
    console.log('fn2'); 
} 

function main() { 
    //fn1.add(obj.foo); // <= Should add function foo to fn1 
    //fn2.add(obj.bah); // <= Should add function bah to fn2 

    window.fn1 = window.fn1.before(obj.foo); 
    window.fn2 = window.fn2.before(obj.bah); 

    fn1(); // Should output: foo and then fn1 
    fn2(); // should output: bah and then fn2 

    //obj.foo = obj.foo.after(f1); 
    //obj.bah = obj.bah.after(f2); 
} 

main(); 

... реализация Function.prototype.before:

(function (Function) { 
    var 
     isFunction = function (type) { 
      return (
       (typeof type == "function") 
       && (typeof type.call == "function") 
       && (typeof type.apply == "function") 
      ); 
     }, 
     getSanitizedTarget = function (target) { 
      //return (target == null) ? null : target; 
      return ((target != null) && target) || null; 
     }; 

    Function.prototype.before = function (handler, target) { // before 
     target = getSanitizedTarget(target); 
     var proceed = this ; 

     return (isFunction(handler) && isFunction(proceed) && function() { 
      var args = arguments; 

      //handler.apply(target, args); 
      handler.call(target, args); 
      return proceed.apply(target, args); 

     }) || proceed; 
    }; 
}(Function)); 

Принимая во внимание ответ на OP еще ...

A: Да Это верно ...

... на этот вопрос ...

Q: ...Правильно ли вы понимаете, что вы собираетесь оставить решение о том, следует ли позвонить foo, полученному от obj.foo или bah/obj.bah, до логики, реализованной в пределах fn1, соответственно fn2?

... прежний подход шахты изменяется от Function.before до Function.around.

Однако, лично я не доволен этим решением, так как для методов, предоставляемых во всем мире fn1 и fn2 теперь необходимо заранее предвидеть модификацию, что в моих глазах не является чистым подходом.

Тем не менее, следующий пример приближается к тому, что OP ищет:

var 
    obj = { 
     foo: function() { 
      console.log('foo'); 
     }, 
     bah: function() { 
      console.log('bah'); 
     } 
    }; 

// - both next function's arguments-signatures 
// do already anticipate the modification. 
// - this is considered to be a dirty approach, 
// please check your architecture or your 
// concept of control flow. 

function fn1(foo, fn1, args) { 

    foo(); // does not necessarily need to be called. 

    console.log('fn1'); 
} 
function fn2(bah, fn2, args) { 

    bah(); // does not necessarily need to be called. 

    console.log('fn2'); 
} 

function main() { 
    //fn1.add(obj.foo); // <= Should add function foo to fn1 
    //fn2.add(obj.bah); // <= Should add function bah to fn2 

    window.fn1 = obj.foo.around(window.fn1); 
    window.fn2 = obj.bah.around(window.fn2); 

    fn1(); // Should output: foo and then fn1 
    fn2(); // should output: bah and then fn2 
} 

main(); 

... реализация Function.prototype.around:

(function (Function) { 
    var 
     isFunction = function (type) { 
      return (
       (typeof type == "function") 
       && (typeof type.call == "function") 
       && (typeof type.apply == "function") 
      ); 
     }, 
     getSanitizedTarget = function (target) { 
      //return (target == null) ? null : target; 
      return ((target != null) && target) || null; 
     }; 

    Function.prototype.around = function (handler, target) { // around 
     target = getSanitizedTarget(target); 

     var proceed = this ; 
     return (isFunction(handler) && isFunction(proceed) && function() { 

      return handler.call(target, proceed, handler, arguments); 

     }) || proceed; 
    }; 
}(Function)); 

Answer 8

with простое решение

var obj = { 
 
    foo: function() { 
 
    console.log('foo'); 
 
    }, 
 
    bah: function() { 
 
    console.log('bah'); 
 
    }, 
 
    proto: null 
 
} 
 

 
//the frowned upon with statement use with caution!!! 
 
with(obj){ 
 
function fn1() { 
 
    foo(); 
 
    console.log('fn1'); 
 
} 
 

 
function fn2() { 
 
    bah(); 
 
    console.log('fn2'); 
 
} 
 

 
function main() { 
 
    fn1(); // Should output: foo and then fn1 
 
    fn2(); // should output: bah and hen fn2 
 
} 
 
} 
 
main() 
 

 
//Dependency Injection 
 
//es6 can do this a lot cleaner. 
 
;(function(o){ 
 
    var foo = o.foo, 
 
     bah = o.bah; 
 
    
 
    function fn1() { 
 
    foo(); 
 
    console.log('fn1'); 
 
    } 
 
    
 
    function fn2() { 
 
    bah(); 
 
    console.log('fn2'); 
 
    } 
 
    
 
    function main() { 
 
    fn1(); // Should output: foo and then fn1 
 
    fn2(); // should output: bah and hen fn2 
 
    } 
 
    main() 
 
}(obj)) 
 

 

 
//es6 Dependency Injection 0 globals 
 
;(({foo,bah} = obj)=>{ 
 
    function fn1() { 
 
    foo(); 
 
    console.log('fn1'); 
 
    } 
 
    
 
    function fn2() { 
 
    bah(); 
 
    console.log('fn2'); 
 
    } 
 
    
 
    function main() { 
 
    fn1(); // Should output: foo and then fn1 
 
    fn2(); // should output: bah and hen fn2 
 
    } 
 
    
 
    main() 
 
})()

Answer 9

ОП: Я не понимаю идею модульной системы. ...

С (на заказ) модульной системой один собираются обеспечить способ для пользователей те, через которые они смогли зарегистрировать ихние базы коды, инкапсулированными каждый в самой функцию. Так как был контроль над «регистрацией», то само по себе было необходимо ввести дополнительное состояние/поведение в такие модули, основанные на функциях. Нужно просто указать, какие аргументы будут переданы в эти модули одной системой.

OP: ... Я рассмотрю прототип before. Похоже, это может сработать для нас. ...

Это не будет. Но другой более простой подход сделает. Это будет неправильно использовать идею модульной системы и превратить все наизнанку. Пункты OP далеко не идеальны. Но возможное решение, переработаны из условия последнего примера кода ФПА, в том, что - в рамках данного сценария - делает то, что ОП может искать, может выглядеть так, что ...

lib.js

// lib.js 

(function() { 
    // do not unnecessarily pollute the global namespace. 

    function foo() { 
     console.log('foo'); 
    } 
    function bar() { 
     console.log('bar'); 
    } 

    function biz() { 
     console.log('biz'); 
    } 
    function baz() { 
     console.log('baz'); 
    } 

    function foobar(arg){ 
     return (arg * 2); 
    } 

    function executeGlobalCustomCode() { 

     // does look for the existence of both globally 
     // scoped methods `setup` and `draw` and, if so, 
     // calls them with the right arguments. 

     if (typeof global.setup === 'function') { 

      global.setup(foo, bar); 
     } 
     if (typeof global.draw === 'function') { 

      global.draw(biz, baz); 
     } 
    } 

    var 
     global = (function() { 
      return this; 
     }).call(null), 

     CONST = "Hello World"; 

    // do only expose into global namespace what is really needed. 
    global.util = { 
     go: executeGlobalCustomCode 
    }; 

}()); 

Пользовательский код с включенным «lib.js».

// custom code with "lib.js" included. 

function setup(foo, bar) { 

    console.log('within SETUP :: call "foo" and "bar".'); 

    foo(); // might be called or not 
    bar(); // 
} 

function draw(biz, baz) { 

    //console.log('within DRAW :: call "biz" and "baz".'); 
    console.log('within DRAW :: call "baz" only.'); 

    //biz(); // might be called or not 
    baz(); // 
} 

util.go(); // does trigger execution of `setup` and `draw`. 

Answer 10

OP: Проблема здесь состоит в том, что у нас есть много функций, которые должны присутствовать в розыгрыше и настройки. Таким образом, передавая их один за другим, это не решение. Мы могли бы передать их как объект, но затем мы вернемся к квадрату. ... Я переосмыслил идею и, возможно, нам нужно пойти на глобальную сферу.

Просто из любопытства и потому, что я никогда не нуждается в черной магии eval и with, я, наконец, пошел за него, доказывая, что чудовище Франкенштейна действительно могут быть созданы с помощью этих инструментов. Там он, этот бедняга ...

... Виктор ...

// lib.js 

(function() { 
    // do not unnecessarily pollute the global namespace. 

    var toolkit = { 

     foo : function foo() { 
      console.log('foo'); 
     }, 
     bar : function bar() { 
      console.log('bar'); 
     }, 

     biz : function biz() { 
      console.log('biz'); 
     }, 
     baz : function baz() { 
      console.log('baz'); 
     } 
    }; 

    var globallyExecutablesNameList = [ 
     "setup", 
     "draw" 
    ]; 

    function badlyEvalPatchAndExecuteGlobalCustomCode() { 

     // does look for the existence of listed globally 
     // scoped methods and, if so, patches them with a 
     // bad "eval" approach (using `new Function`) that 
     // within this eval uses an `with (context)` which 
     // is considered to be error prone. 

     var 
      fct, 

      str, 
      args, 
      body, 
      result, 

      regXFctArgsAndBody = (/function[^(]*\(([^)]*)\)\s*\{(.*)\}/); 

     globallyExecutablesNameList.forEach(function (fctName) { 
      fct = global[fctName]; 

      if (typeof fct === "function") { 

       str  = fct.toString().replace((/\n/g), "###__NEW__LINE__###"); 
       result = regXFctArgsAndBody.exec(str); 

       if (result) { 
        body = [ 
         "with (this) {", // within new method's `this` context ... 
              // do stuff, that was derived from ... 

         result[2].split(/###__NEW__LINE__###/).join("\n"), 

              // ... a (global) custom function's body. 
         "}"    // 
        ].join(""); 

        args = result[1] 
         .replace((/###__NEW__LINE__###/g), "") 
         .replace((/\s+/g), "") 
         .split(","); 

        args.push(body); 

        fct = Function.apply(null, args); // frankenstein's monster. 

        //console.log("args : ", args); 
        //console.log("fct.toString() : ", fct.toString()); 
       } 
       fct.call(toolkit); // provide `toolkit` as this function's context. 
      } 
     }); 
    } 

    var 
     global = (function() { 
      return this; 
     }).call(null); 

    // do only expose into global namespace what is really needed. 
    global.lib = { 
     go: badlyEvalPatchAndExecuteGlobalCustomCode 
    }; 

}()); 

... и это жертвы ...

// custom code with "lib.js" included. 

function setup(/*a, b, c*/) { 

    console.log("SETUP"); 

    foo(); 
    bar(); 
} 

function draw(/*x, y*/) { 

    console.log("DRAW"); 

    //biz(); 
    baz(); 
} 

lib.go(); // does look for `setup` + `draw` + processes them by 2 dirty techniques. 

Answer 11

1. Узнайте все имена функций, которые вы хотите преобразовать в глобальные переменные из импортируемой библиотеки.
2. Сделать их глобальными. Если вы хотите сделать какую-то фантастическую вещь для разбора АСТ, которая найдет их все для вас, я полагаю, вы могли бы это сделать. Или вы можете просто использовать консоль и проработать ее. Тем не менее, вы действительно хотите, чтобы это было статичным, поскольку это помогает вам рассуждать о выпуске кода. Если он динамически создается, то будущие обновления библиотеки могут тормозить предыдущий код, если у вас возникли глобальные имена.

Но код нужно только посмотреть, как этот

var foo = obj.foo, 
    bar = obj.bar; 
foo() 
bar() 

В качестве альтернативы, можно признать, что имея все свои функции пространств имён не такая уж плохая идея, и что это не сложно даже для начинающего программиста сделать псевдоним функции, которую они хотят использовать. Это помогает им понять, что может быть хорошей идеей сохранить организованный код и поможет им понять, что функции и объекты не копируются, когда им назначено новое имя переменной, на которое они просто ссылаются.

var map = reallyLongLibraryNameThatNoOneWantsToType.map 
//alternatively 
var lib = reallyLongLibraryNameThatNoOneWantsToType 
lib.reduce([1,2,3],function(a,b){ return a +b }, 0) 

Это лучший ответ, который может быть дан для этого случая. Я знаю, что это раздражает. Все приведенные выше варианты создают больше проблем, чем они решают. На самом деле спросите себя, почему именно я хочу делать то, что я спросил?