IoC контейнер на javascript в 90 строк

var Injector = {
   dependencies: {},
   add : function(qualifier, obj){
      this.dependencies[qualifier] = obj; 
   },
   get : function(func){
      var obj = new func;
      var dependencies = this.resolveDependencies(func);
      func.apply(obj, dependencies);
      return obj;
   },
   resolveDependencies : function(func) {
      var args = this.getArguments(func);
      var dependencies = [];
      for ( var i = 0; i < args.length; i++) {
         dependencies.push(this.dependencies[args[i]]);
      }
      return dependencies;
   },
   getArguments : function(func) {
      //This regex is from require.js
      var FN_ARGS = /^functions*[^(]*(s*([^)]*))/m;
      var args = func.toString().match(FN_ARGS)[1].split(',');
      return args;
   }
};

function userInput(player) {
  let onkeydown = (e) => {
    if (e.keyCode == 38) player().moveUp();
    if (e.keyCode == 40) player().moveDown();
    if (e.keyCode == 37) player().moveLeft();
    if (e.keyCode == 39) player().moveRight();
    e.preventDefault();
  };
  document.addEventListener("keydown", onkeydown, false);
};

Я в конечном итоге в этот же метод добавил поддержку touch устройств, а можно было добавить еще один сервис так, чтобы их обязанности были разделены:

function userInputForTouchDevices(player) {
  let onClick = direction => {
  	if (direction === "top") player().moveUp();  	
    if (direction === "bottom") player().moveDown();
  	if (direction === "left") player().moveLeft();
  	if (direction === "right") player().moveRight();
  };

  document.querySelector(".left .top").onclick = () => onClick("top");
  document.querySelector(".right .top").onclick = () => onClick("top");
  document.querySelector(".left .bottom").onclick = () => onClick("bottom");
  document.querySelector(".right .bottom").onclick = () => onClick("bottom");
  document.querySelector(".left .middle").onclick = () => onClick("left");
  document.querySelector(".right .middle").onclick = () => onClick("right");
};

"use strict";

function IoC() {
  let services = {}; // services registration options
  let self = this;

  this.register = function(service, options) {
    if (typeof(service) !== "function")
      throw new Error("Service is not a function: " + service);

    if (typeof(options) === "undefined") {
      options = {};
    };
    setDefaultOptions(options);

    let name = service.name;
    if (services.hasOwnProperty(name))
      throw new Error("Service already has been registered: " + name);

    options.__service = service;
    services[name] = options;

    return function() {
      return self.resolve(name);
    };
  };

  this.resolve = function(name) {
    if (!services.hasOwnProperty(name))
      throw new Error("Service can not be resolved: " + name);
    let options = services[name];
    let service = options.__service;
    let usedServices = getParamNames(service).map(self.resolve);

    if (options.lifetime == "transient") {
      return function() {
        return new function() {
          return service.apply(this, usedServices);
        };
      };
    };
    if (options.lifetime == "singleton") {
      return function() {
        return options.__instance || (options.__instance = new function() {
          return service.apply(this, usedServices);
        });
      };
    };
    throw new Error("Service can not be resolved: " + name);
  };

  this.check = function() {
    Object.keys(services).forEach(checkUsedServicesExist);
    Object.keys(services).forEach(checkCycle);
  };
  
  function checkUsedServicesExist(name) {
  	getUsedServices(name).map(self.resolve);
  };

  let getUsedServices = name => getParamNames(services[name].__service);

  function checkCycle(name) {
    let chains = [[name]];
    let i = 0;
    while (i < chains.length) {
      let currentChain = chains[i];
      let currentName = currentChain[currentChain.length - 1];
      let currentUsed = getUsedServices(currentName);
      currentChain.forEach(x => {
        if (currentUsed.includes(x))
          throw new Error("Cicle found : " + currentChain + " > " + x);
      });
      let newChains = currentUsed.map(x => currentChain.concat([x]));
      chains = chains.concat(newChains);
      i++;
    }
  };

  function setDefaultOptions(options) {
    options.lifetime = options.lifetime || "singleton";
  };

  // https://stackoverflow.com/questions/1007981/how-to-get-function-parameter-names-values-dynamically
  const STRIP_COMMENTS = /((//.*$)|(/*[sS]*?*/))/mg;
  const ARGUMENT_NAMES = /([^s,]+)/g;

  function getParamNames(func) {
    let functionString = func.toString().replace(STRIP_COMMENTS, '');
    let result = functionString.slice(functionString.indexOf('(') + 1, functionString.indexOf(')')).match(ARGUMENT_NAMES);
    if (result === null)
      result = [];
    return result;
  }
};

///////////////// Services implementation /////////////////////

function multiService(singletonService) {
  let index = 0;
  this.start = function() {
    index++;
    console.log("multiService : " + index);
  };
  singletonService().start();
};

let singletonService = function() {
  let index = 0;
  this.start = function() {
    index++;
    console.log("singletonService : " + index);
  };
};

let mainService = function(multiService, singletonService) {
  multiService().start();
  singletonService().start();
};

///////////////// IoC registration and check (Composition root) /////////////////////

let container = new IoC();

container.register(mainService, {
  lifetime: "transient"
});
container.register(singletonService);
container.register(multiService, {
  lifetime: "transient"
});

container.check();

///////////////// Run App /////////////////////

let main = container.resolve("mainService");

main();