Dependency injection in JavaScript

bar.js

/* A basic implementation of bar */
define(function () {
  return {
    plop: function () { alert('bar implementation'); }
  }
});

baz.js

/* An alternative implementation of bar */
define(function () {
  return {
    plop: function () { alert('baz implementation'); }
  }
});

foo.js

/*
 * foo is a module that depends on a bar module.
 * Note that the dependency is modeled as a parameter of the function returned by the module definition.
 */
define(function () {
  return function (bar) {
    return bar.plop()
  }
});

usage.js

/* The end-user wires dependencies */
require(['foo', 'baz'], function (fooProvider, bazProvider) {
  var baz = bazProvider();
  var foo = fooProvider(baz);
})

It works because both bar.js and baz.js have the same API. It's like having interfaces and implementations. And in this case, you are right, it works fine.

But in my case, for Prolyfill, the fact is that implementations were created before the interface (aka the spec) and so they all have more or less different APIs. You need a way to normalize that if you want to use any of them.

Also, it's not only about dependency but also about polyfill: if the global context already has the feature, do nothing, otherwise, create an implementation. You can only do that at runtime.

Ok, indeed if several implementations have a different API the problem is not the same :)