Factory that builds functions whose contents are different?

Question

I'm curious if this is possible in JavaScript.

I want a factory function that can return functions whose actual contents are different. Say this is our factory:

function makeFunction(a, b, c) {
  // Implement me
  return f;
}

I want it to work like this:

> makeFunction(true, true, false);
=> function() { do_a(); do_b(); }
> makeFunction(false, true, false);
=> function() { do_b(); }
> makeFunction(true, false, true);
=> function() { do_a(); do_c(); }

Setting aside whether or not this is a good idea ... Can I do this? If so, what needs to happen inside makeFunction?

Bonus: Generally, what is this pattern called?

---

Edit: I should clarify something I'm not looking for: the sane approach that uses closures. E.g. the following has the correct effect, but doesn't change the function contents/body:

function makeFunction(a, b, c) {
  return function() {
    if (a) { do_a(); }
    if (b) { do_b(); }
    if (c) { do_c(); }
  }
}

Answer 1

This solution takes care of it all for you, define the functions you want in the func array using their names and then use it to create.

function a (){
    console.log("a");
};
function b() {
    console.log("b");
};
function c() {
    console.log("c");
};
function makeFunction() {
    var funcs = [a, b, c];
    var finalfunc = [];
    for (var i = 0; i < arguments.length && i < funcs.length; i++) {
        if (arguments[i]) {
            finalfunc.push(funcs[i]);
        }
    }
    return function () {
        var f = finalfunc;
        for (var a = 0; a < f.length; a++) {
            f[a]();
        }
    };
};

Examples:

var z = makeFunction(true);
z();//outputs a

var z = makeFunction(true, false, true);
z();//outputs a c

var z = makeFunction(true, true, false);
z();//outputs a b

var z = makeFunction(true, true, true);
z();//outputs a b c

var z = makeFunction(true, true, true, true);
z();//outputs a b c

EDIT

I didn't see until I had wrote it that you didn't want closures, but I will keep this here anyway

Although you have said this, this is probably a safer way. It also directly answers the question excluding that fact, I have created a function with only the functions in it that you want to be run inside of it. There is no if statement for every function, it simply depends on the functions you have provided and the arguments :)

It is also completely dynamic and doesn't rely on defining conditions for each function.

Answer 2

Yes, this is possible. No, I'm not going to comment on the (perceived) value of such an approach.

Here's a quick sample:

window.addEventListener('load', mInit, false);

function createFunction(funcName, message)
{
    var script = document.createElement('script');
    var scriptContents = 'function ' + funcName + '()\n';
    scriptContents += '{\n\talert("' + message + '");\n}\n';
    script.appendChild( newTxt(scriptContents) );
    document.head.appendChild(script);
}

function mInit()
{
    createFunction('myFunc', 'hello world');
    myFunc();
}

Output:

<script>function myFunc()
{
    alert("hello world");
}
</script>

I wasn't sure the function would work immediately, hence the test as shown above. (it does, btw)

I had an idea in the past that involved hiding a script in the alpha channel of images...

Answer 3

You can use the Function constructor to accomplish this. For example:

// Globals can be seen by the function we're going to create.
function do_a() { /* stuff */ }
function do_b() { /* stuff */ }
function do_c() { /* stuff */ }

function makeFunction(a, b, c) {
  var contents = [];
  if (a) { contents.push("do_a();"); }
  if (b) { contents.push("do_b();"); }
  if (c) { contents.push("do_c();"); }
  return new Function(contents.join(''));
}

console.log(makeFunction(true, true));
console.log(makeFunction(true, false, false));
console.log(makeFunction(false, true, true));

The above code will print the following to the console:

function anonymous() {
  do_a();do_b();
}
function anonymous() {
  do_a();
}
function anonymous() {
  do_b();do_c();
}

I believe this satisfies the requirements of the question. Some JavaScript libraries actually do use this technique to compile extremely efficient functions based on the needs of the program at runtime. However, there are a few notable downsides to this approach:

• Functions created with the Function constructor only inherit the global scope. Depending on what your code needs to do, this could be a deal-breaker.
• Function construction in this way is slow, because the engine must convert the function source to executable code. (Note: This doesn't mean the created functions themselves will be slow. In fact, they will run normally.)
• It's hard to write functions like this. (Quoting/unquoting.)
• The function contents wouldn't be lint-able.

Answer 4

The following "manual" approach that would get the job done, but is only recommended if you only need to handle a few conditions and/or if you like typing.

function makeFunction(a, b, c) {
   if (a && b && c) {
      return function() { do_a(); do_b(); do_c(); }
   }

   if (a && b && !c) {
      return function() { do_a(); do_b(); }
   }

   // You get the idea...
}

Pros: It works? Cons: If you need to provide for a lot of permutations... good luck :)

Answer 5

You can use an object and return it's methods.

I really don't see any point to this though.

function makeFunction(a, b) {
 var f = {
    a:function(){console.log("IcanBeANythign")},
    b:function(a,b){return a+b}
  };
  if(a){
  return f.a;
  }
  if(b){
  return f.b;
  }
}
var f = makeFunction(false,true)(3,4) // 7

Something similar is currying or more accurately partial application . It has been answered here quite thoroughly

You can do something like this:

function curryPlus(a){
          return function(b){
          return a+b;
          }
    }

var add1 = curryPlus(1);
add1(2) // Outputs: 3