JS reflection and dependency injection use case analysis

This time I will bring you JS reflection and Dependency injectionUse case analysis, what are the Notes when using JS reflection and dependency injection, the following is a practical case, let’s take a look one time.

The understanding of reflection in javascript has always been that using an array to save the callback function, and then using the call or apply method at the appropriate moment , just call the callback. Generally, the operation is as follows:

First define two methods:

var service = function() {
  return { name: 'Service' };
}
var router = function() {
  return { name: 'Router' };
}

We have another function that needs to use these two modules.

var doSomething = function(other) {
  var s = service();
  var r = router();
};

Of course, we hope to be able to use dependency injection to do it and give the control to the computer instead of manually calling the following:

var doSomething = injector.resolve('router,,service', function(a, b, c) {
  expect(a().name).to.be('Router');
  expect(b).to.be('Other');
  expect(c().name).to.be('Service');
});
doSomething("Other");

Then we can create Create a reflection method as follows:

var injector ={
    dependencies: {},
    register: function(key, value) {
      this.dependencies[key] = value;
    },
    resolve:function(deps, func, scope) {
      var args = [];
      for(var i=0; i<deps.length><p style="text-align: left;">As shown in the above code, dependencies are used to save the callback function collection, and resolve is used to call it. </p>
<p style="text-align: left;">This can be considered a relatively mature and ok idea. </p>
<p style="text-align: left;"><strong>But there are still several problems: </strong></p>
<p style="text-align: left;">1 When calling resolve, the order of the deps parameter list must be consistent. </p>
<p style="text-align: left;">2 This is a bit far-fetched, but it counts. When calling, you need to enter the formal parameters again and cannot call it directly. </p>
<p style="text-align: left;">In order to solve the above problems, the following solutions are given: </p>
<pre class="brush:php;toolbar:false">var injector ={
    dependencies: {},
    register: function(key, value) {
      this.dependencies[key] = value;
    },
    resolve: function() {
      var func, deps, scope, args = [], self = this;
      if(typeof arguments[0] === 'string') {
        func = arguments[1];
        deps = arguments[0].replace(/ /g, '').split(',');
        scope = arguments[2] || {};
      } else {
        func = arguments[0];
        deps = func.toString().match(/^function\s*[^]*\(\s*([^]*\(\s*([^]*)\)/m)[1].replace(/ /g, '').split(',');
        scope = arguments[1] || {};
      }
      return function() {
        var a = Array.prototype.slice.call(arguments, 0);
        for(var i=0; i<deps.length><p style="text-align: left;">Use regular rules to parse the code, parse out the function list parameters, and then automatically match and pass values ​​one by one, then you can To solve the problem, the order must always be maintained. Of course, this is also the approach taken by the hottest mvvm framework <a href="http://www.php.cn/angularjs/angularjs-examples.html" target="_blank">AngularJs</a>. </p>
<p style="text-align: left;">The calling method can be as follows: </p>
<pre class="brush:php;toolbar:false">injector.resolve(['service,,router', function(service, router) {
}]);

You may notice that there are two commas after the first parameter-note that

This is not a typo. The null value actually represents the "Other" parameter (placeholder). This shows how we control the order of arguments.

Finally, there is another way to directly inject the scope, that is, directly inject the scope. Then the scope is injected, and the above-mentioned parameter order problem does not exist

Because there is no need to pass parameters , directly accessible from the scope.

var injector = {
  dependencies: {},
  register: function(key, value) {
    this.dependencies[key] = value;
  },
  resolve: function(deps, func, scope) {
    var args = [];
    scope = scope || {};
    for(var i=0; i<deps.length var dosomething><p> I believe you have mastered the method after reading the case in this article. For more exciting information, please pay attention to other related articles on the php Chinese website! </p>
<p>Recommended reading: </p>
<p><a href="http://www.php.cn/xiaochengxu-399477.html" target="_blank">How to develop the verification code password input box function in the WeChat applet</a><br></p>
<p><a href="http://www.php.cn/xiaochengxu-399476.html" target="_blank">How to use js statistics Number of page tags</a><br></p></deps.length>

The above is the detailed content of JS reflection and dependency injection use case analysis. For more information, please follow other related articles on the PHP Chinese website!