高级Javascript：检测当前函数是否被构造函数调用

Question

在 Javascript 函数中，它是一个相当简单的检测函数是简单地执行还是作为对象实例构造函数执行（使用 new 关键字）。

// constructor
function SomeType() {
    if (this instanceof SomeType)
        // called as an object instance constructor
    else
        // the usual function call
}

没关系，这个问题已经在这里回答过至少几次了。

现在假设我们的构造函数调用了我直接在 Function 原型上定义的另一个函数，因此所有函数都可以访问 - 我这样做的主要目的。

Function.prototype.doSomething = function doSomething() {
    // what code here?
};

// constructor
function SomeType() {
    SomeType.doSomething();
}

主要问题

我们现在如何在doSomething 中检测到与SomeType 函数相同的情况？

我想检测它的原因是我正在编写一个函数，该函数采用/注入构造函数参数作为具有相同名称的构造对象实例成员。当然，这个函数应该只在被构造函数调用而不是被定期调用的函数调用时执行。

This is my answer 到另一个问题，您可以在其中看到我的adoptArguments 函数，该函数将对象构造函数参数作为成员放入构造的对象实例中。

强制执行特定用法的解决方法 = 不好

我有一个我不想使用的可能解决方法，因为它强制正确使用 - 执行上下文注入。这是可以检测对象实例构造函数执行的代码：

Function.prototype.doSomething = function doSomething() {
    if (this instanceof doSomething.caller)
    {
        // object instance construction
    }
    else return; // nope, just normal function call
};

// constructor
function SomeType() {
    // required use of ".call" or ".apply"
    SomeType.doSomething.call(this);
}

这个想法可能会激发你自己的一些想法来解决最初的问题

Answer 1

在 Javascript 函数中，它是一个相当简单的检测函数是简单地执行还是作为对象实例构造函数执行（使用 new 关键字）。

其实那是不可能的，JS中的cannot know是否调用了用户函数作为构造函数。 this instanceof 测试对于通常情况来说已经足够了，但只检查上下文是否确实继承自类的原型。

我们现在如何在doSomething 中检测到与SomeType 函数相同的情况？

出于同样的原因，您不能进行 instanceof 测试，除非将 this 作为参数传递给您的 doSomething。

主要问题：我正在编写一个函数，它采用/注入构造函数参数作为具有相同名称的构造对象实例成员。

我建议不要通过构造函数中的函数调用来这样做。相反，请尝试装饰构造函数，以便您可以立即访问所需的所有值：

Function.prototype.adoptArguments = function() {
    var init = this;
    var args = arguments.length ? arguments : init.toString().replace(comments, "").match(argumentsparser);

    if (!args || !args.length) return init;

    var constructor = function() {
        if (this instanceof constructor) {
            for (var i=0; i<args.length; i++)
                this[args[i]] = arguments[i];
            init.apply(this, arguments);
        } else {
            // throw new Error("must be invoked with new");
        }
    };
    return constructor;
};

然后代替

function SomeType() {
    SomeType.adoptArguments();
}

做

var SomeType = function() {

}.adoptArguments();

Answer 2

一种可能的解决方案是将构造函数上下文作为参数传递。无需传入参数对象，因为它可以通过this.arguments 访问，就像您在链接答案中的adoptArguments 中所做的那样。

这个解决方案对我来说很有意义，因为我希望 Function.prototype.someMethod 是 在 Function 实例的上下文而不是其他上下文中调用 （即新创建的实例）。

Function.prototype.doSomethingWith = function doSomethingWith(instance) {
    if( instance instanceof this ) // proceed
};

// constructor
function SomeType() {
    SomeType.doSomethingWith(this);
}

警告：您的 adoptArguments 函数存在严重错误，见下文

var comments = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/mg;
var parser = /^function[^\(]*\(([^)]*)\)/mi;
var splitter = /\s*,\s*/mi;

Function.prototype.adoptArguments = function() {
    var args;
    // remove code comments
    args = this.toString().replace(comments, "");
    // parse function string for arguments
    args = parser.exec(args)[1];

    if (!args) return; // empty => no arguments

    // get individual argument names
    args = args.split(splitter);

    // adopt all as own prototype members
    for(var i = 0, len = args.length; i < len; ++i)
    {
        this.prototype[args[i]] = this.arguments[i];
    }
};

console.log('the problem with your implementation:');
console.log('> adopting arguments as prototype members');
console.log('> implies you override values for every instance of YourType');

function YourType(a, b, c) {
  YourType.adoptArguments();
}

var foo = new YourType( 1, 2, 3 );
console.log( 'foo', foo.a, foo.b, foo.c ); // foo 1 2 3

var bar = new YourType( 4, 5, 6 );
console.log( 'foo', foo.a, foo.b, foo.c ); // foo 4 5 6
console.log( 'bar', bar.a, bar.b, bar.c ); // bar 4 5 6

console.log();
console.log('also, a trim is need because:');

function OtherType( a, b, c ) { // see where whitespaces are
  OtherType.adoptArguments();
}

var baz = new OtherType( 1, 2, 3 );
console.log( 'baz', baz.a, baz.b, baz.c );
// baz undefined 2 undefined

//
// My solution
//

console.log();
console.log('results');

// slighly modified from your adoptArguments function
Function.prototype.injectParamsOn = function injectParamsOn( instance ) {
  // you may check `instance` to be instanceof this
  if( ! (instance instanceof this) ) return;

  // proceed with injection
  var args;
  // remove code comments
  args = this.toString().replace(comments, "");
  // parse function string for arguments
  args = parser.exec(args)[1];

  if (!args) return; // empty => no arguments

  // get individual argument names (note the trim)
  args = args.trim().split(splitter);

  // adopt all as instance members
  var n = 0;
  while( args.length ) instance[ args.shift() ] = this.arguments[ n++ ];
};

function MyType( a, b, c ){
  MyType.injectParamsOn( this );
}

var one = new MyType( 1, 2, 3 );
console.log( 'one', one.a, one.b, one.c ); // one 1 2 3

var two = new MyType( 4, 5, 6 );
console.log( 'one', one.a, one.b, one.c ); // one 1 2 3
console.log( 'two', two.a, two.b, two.c ); // two 4 5 6

var bad = MyType( 7, 8, 8 );
// this will throw as `bad` is undefined
// console.log( 'bad', bad.a, bad.b, bad.c );
console.log( global.a, global.b, global.c );
// all undefined, as expected (the reason for instanceof check)