2

与如何使用调用或应用调用 javascript 构造函数有关？

但不一样，我正在尝试将 SO 答案应用于John Resig在未正确调用时强制构造函数。

function User(first, last){ 
  if ( !(this instanceof User) )
    // the line I want to replace, or remove the redundancy from:
    return new User(first, last);

  this.name = first + " " + last; 
} 

var name = "Resig"; 
var user = User("John", name); 

assert( user, "This was defined correctly, even if it was by mistake." ); 
assert( name == "Resig", "The right name was maintained." );

目标代码行意味着每次构造函数更改时，都必须记住更改内部自调用参数。在过去的 3 天里，我已经对这个问题进行了 3 次项目旅行。

链接问题中的所有示例都在谈论传递constructor，但constructor在这种情况下是什么？它甚至还没有完成定义。

但到目前为止，所有尝试都没有通过测试，或者抛出 stackoverflow。

如何确保调用构造函数的结果instanceof User即使在没有new关键字的情况下也能正确响应，同时消除参数参数的重复？

4

2 回答 2

3

您的一些选项，全部使用Object.create：

选项1：

function User(first, last){ 
  var rv;

  if ( !(this instanceof User) ) {
    // They called us without `new`: Create an object backed by `User.prototype`:
    rv = Object.create(User.prototype);

    // Now, call this function applying the arguments
    User.apply(rv, arguments);

    // Return the object
    return rv;
  }

  // Normal constructor stuff    
  this.name = first + " " + last; 
}

当然，不必为您创建的每个构造函数重复所有这些逻辑，您可以使用辅助函数：

function constructWith(obj, ctor, args) {
    if (obj instanceof ctor) {
        return null;
    }
    obj = Object.create(ctor.prototype);
    ctor.apply(obj, args);
    return obj;
}

然后

function User(first, last){ 
  var rv;

  if ((rv = constructWith(this, User, arguments)) != null) {
      return rv;
  }

  // Normal constructor stuff    
  this.name = first + " " + last; 
}

选项2：不要使用this太多：

function User(first, last){ 
  var rv;

  if (this instanceof User) {
    // They (probably) used `new`, all is good, use `this`
    rv = this;
  } else {
    // They didn't use `new`, create an object backed by `User.prototype`
    rv = Object.create(User.prototype);
  }

  // ...use `rv`, not `this`, from here on

  rv.name = first + " " + last; 

  // This is important for the case where they didn't use `new`, and harmless
  // in the case where they did.
  return rv;
}

正如你所看到的，这要简单得多，但是如果你真的喜欢你的语法高亮（说真的，我有一个客户，它对他来说真的很重要this），等等......

当然，您可以将其包装在一个助手中：

function useOrConstruct(obj, ctor) {
    return obj instanceof ctor ? obj : Object.create(ctor.prototype);
}

然后

function User(first, last){ 
  var rv = useOrConstruct(this, User);

  // ...use `rv`, not `this`, from here on

  rv.name = first + " " + last; 

  // This is important for the case where they didn't use `new`, and harmless
  // in the case where they did.
  return rv;
}

选项 3：constructOMatic

当然，如果我们要定义助手，也许我们应该全力以赴：

function User() {
    return constructOMatic(this, User, arguments, function(first, last) {
        this.name = first + " " + last;
    });
}

...在哪里constructOMatic：

function constructOMatic(obj, ctor, args, callback) {
    var rv;
    if (!(obj instanceof ctor)) {
        obj = Object.create(ctor.prototype);
    }
    rv = callback.apply(obj, args);
    return rv !== null && typeof rv === "object" ? rv : obj;
}

现在，您可以this在回调中尽情享受。最后摆弄rvvs.obj是return为了模拟（表达式new的结果是运算符创建的对象，除非构造函数返回非对象引用，在这种情况下优先）。newnewnull

Object.create是在所有现代浏览器上都可以找到的 ES5 功能，但上面使用的单参数版本可以针对过时的浏览器进行填充：

if (!Object.create) {
    Object.create = function(proto, props) {
        if (typeof props !== "undefined") {
            throw "The two-argument version of Object.create cannot be shimmed.";
        }
        function ctor() { }
        ctor.prototype = proto;
        return new ctor; // Yes, you really don't need () (but put them on if you prefer)
    };
}
于 2015-01-06T14:58:44.627 回答
0

复制和粘贴非常简单，代码很干净。你不需要改变它。

如果你接受eval，你可以这样做：

function User(first, last){ 
  if ( !(this instanceof arguments.callee) ) {
    var name = arguments.callee.name;
    var param = [].map.call(arguments,function(e,i){return 'arguments['+i+']';});
    return eval('new '+name+'('+ param +')');
  }

  this.name = first + " " + last;
}

//test
var user1 = User("John", "Resig");
var user2 = new User("John", "Resig");

没有eval，你可以这样做：

function instantiate(C,a){
    switch(a.length){
        case 0: return new C();
        case 1: return new C(a[0]);
        case 2: return new C(a[0],a[1]);
        case 3: return new C(a[0],a[1],a[2]);
        case 4: return new C(a[0],a[1],a[2],a[3]);
        default : throw("too many arguments");
    }
}

function User(first, last){ 
  if ( !(this instanceof arguments.callee) ) {
    return instantiate(arguments.callee, arguments);
  }

  this.name = first + " " + last;
}


//test
var user1 = User("John", "Resig");
var user2 = new User("John", "Resig");

在 ECMAScript 6 中，您可以使用扩展运算符将带有 new 关键字的构造函数应用于参数数组：

"use strict";
function User(first, last){ 
  if ( !(this instanceof User) ) {
    return new User(...arguments);
  }

  this.name = first + " " + last;
}
于 2015-12-11T11:15:44.370 回答