การหลีกเลี่ยงโอเปอเรเตอร์ใหม่ใน JavaScript - วิธีที่ดีกว่า

คำเตือน: นี่เป็นเรื่องยาว

ขอให้มันง่าย ฉันต้องการหลีกเลี่ยงคำนำหน้าโอเปอเรเตอร์ใหม่ทุกครั้งที่ฉันเรียกนวกรรมิกใน JavaScript นี่เป็นเพราะฉันมักจะลืมมันและรหัสของฉันก็แย่มาก

วิธีง่ายๆในการนี้คือ ...

function Make(x) {
  if ( !(this instanceof arguments.callee) )
  return new arguments.callee(x);

  // do your stuff...
}

แต่ฉันต้องการสิ่งนี้เพื่อยอมรับตัวแปร ของการโต้แย้งเช่นนี้ ...

m1 = Make();
m2 = Make(1,2,3);
m3 = Make('apple', 'banana');

ทางออกแรกทันทีน่าจะเป็นวิธี 'สมัคร' เช่นนี้ ...

function Make() {
  if ( !(this instanceof arguments.callee) )
    return new arguments.callee.apply(null, arguments);

  // do your stuff
}

นี้เป็นธรรม แต่ - วัตถุใหม่จะถูกส่งผ่านไปยังวิธีการและไม่ให้คอนสตรัคของเราapplyarguments.callee

ตอนนี้ฉันได้คำตอบสามข้อ คำถามง่ายๆของฉันคือคำถามข้อใดที่ดูเหมือนดีที่สุด หรือถ้าคุณมีวิธีที่ดีกว่าบอกมัน

ก่อนอื่น - ใช้eval()เพื่อสร้างรหัส JavaScript ที่เรียกใช้นวกรรมิก

function Make(/* ... */) {
  if ( !(this instanceof arguments.callee) ) {
    // collect all the arguments
    var arr = [];
    for ( var i = 0; arguments[i]; i++ )
      arr.push( 'arguments[' + i + ']' );

    // create code
    var code = 'new arguments.callee(' + arr.join(',') + ');';

    // call it
    return eval( code );
  }

  // do your stuff with variable arguments...
}

สอง - วัตถุทุกชิ้นมี__proto__คุณสมบัติซึ่งเป็นลิงค์ 'ความลับ' ไปยังวัตถุต้นแบบ โชคดีที่คุณสมบัตินี้สามารถเขียนได้

function Make(/* ... */) {
  var obj = {};

  // do your stuff on 'obj' just like you'd do on 'this'
  // use the variable arguments here

  // now do the __proto__ magic
  // by 'mutating' obj to make it a different object

  obj.__proto__ = arguments.callee.prototype;

  // must return obj
  return obj;
}

สาม - นี่คือสิ่งที่คล้ายกับโซลูชันที่สอง

function Make(/* ... */) {
  // we'll set '_construct' outside
  var obj = new arguments.callee._construct();

  // now do your stuff on 'obj' just like you'd do on 'this'
  // use the variable arguments here

  // you have to return obj
  return obj;
}

// now first set the _construct property to an empty function
Make._construct = function() {};

// and then mutate the prototype of _construct
Make._construct.prototype = Make.prototype;

• eval การแก้ปัญหาดูเหมือนเงอะงะและมาพร้อมกับปัญหาทั้งหมดของ "ความชั่วร้าย eval"

• __proto__ โซลูชันไม่ได้มาตรฐานและ "Great Browser of mIsERY" ไม่ให้เกียรติ

• วิธีที่สามดูเหมือนซับซ้อนเกินไป

แต่ด้วยวิธีแก้ปัญหาทั้งสามข้อที่กล่าวมาข้างต้นเราสามารถทำสิ่งนี้ได้ซึ่งเราไม่สามารถทำได้ ...

m1 = Make();
m2 = Make(1,2,3);
m3 = Make('apple', 'banana');

m1 instanceof Make; // true
m2 instanceof Make; // true
m3 instanceof Make; // true

Make.prototype.fire = function() {
  // ...
};

m1.fire();
m2.fire();
m3.fire();

วิธีแก้ปัญหาข้างต้นทำให้เรามีประสิทธิภาพ "ของจริง" คอนสตรัคเตอร์ที่รับหมายเลขตัวแปร newของการขัดแย้งและไม่จำเป็นต้อง คุณทำอะไรกับเรื่องนี้

- อัปเดต -

บางคนบอกว่า "เพิ่งโยนข้อผิดพลาด" คำตอบของฉันคือ: เรากำลังทำแอพหนักกับตัวสร้าง 10+ ตัวและฉันคิดว่ามันคงจะเป็นงานที่หนักหนากว่าถ้าตัวสร้างทุกตัวสามารถ "ฉลาด" จัดการกับข้อผิดพลาดนั้นได้โดยไม่ต้องทิ้งข้อความแสดงข้อผิดพลาดบนคอนโซล

ประการแรกarguments.calleeเลิกใช้งานอย่างเข้มงวดใน ES5 ดังนั้นเราจึงไม่ใช้ ทางออกที่แท้จริงนั้นค่อนข้างง่าย

คุณไม่ได้ใช้newเลย

var Make = function () {
  if (Object.getPrototypeOf(this) !== Make.prototype) {
    var o = Object.create(Make.prototype);
    o.constructor.apply(o, arguments);
    return o;
  }
  ...
}

นั่นเป็นความเจ็บปวดที่ถูกต้องในตูดใช่มั้ย

ลอง enhance

var Make = enhance(function () {
  ...
});

var enhance = function (constr) {
  return function () {
    if (Object.getPrototypeOf(this) !== constr.prototype) {
      var o = Object.create(constr.prototype);
      constr.apply(o, arguments);
      return o;
    }
    return constr.apply(this, arguments);
  }
}

ตอนนี้แน่นอนต้องใช้ ES5 แต่ทุกคนใช้สิทธิES5ใช่มั้ย

คุณอาจสนใจในรูปแบบของ js OO

นอกเหนือจากนี้คุณสามารถเปลี่ยนตัวเลือกที่สองด้วย

var Make = function () {
  var that = Object.create(Make.prototype);
  // use that 

  return that;
}

ในกรณีที่คุณต้องการ ES5 ของคุณเองObject.createมันเป็นเรื่องง่าย

Object.create = function (proto) {
  var dummy = function () {};
  dummy.prototype = proto;
  return new dummy;
};

ขอให้มันง่าย ฉันต้องการหลีกเลี่ยงคำนำหน้าโอเปอเรเตอร์ใหม่ทุกครั้งที่ฉันเรียกนวกรรมิกใน JavaScript นี่เป็นเพราะฉันมักจะลืมมันและรหัสของฉันก็แย่มาก

คำตอบที่ชัดเจนคืออย่าลืมnewคำหลัก

คุณกำลังเปลี่ยนโครงสร้างและความหมายของภาษา

ซึ่งในความคิดของฉันและเพื่อประโยชน์ของผู้ดูแลรหัสในอนาคตของคุณเป็นความคิดที่น่ากลัว

ทางออกที่ง่ายที่สุดคือการจำnewและโยนข้อผิดพลาดเพื่อทำให้ชัดเจนว่าคุณลืม

if (Object.getPrototypeOf(this) !== Make.prototype) {
    throw new Error('Remember to call "new"!');
}

evalสิ่งที่คุณทำไม่ได้ใช้ ฉันจะอายที่จะไม่ใช้คุณสมบัติที่ไม่ได้มาตรฐานเหมือน__proto__อย่างเฉพาะเจาะจงเพราะมันไม่ได้มาตรฐานและฟังก์ชั่นการทำงานอาจเปลี่ยนแปลง

ฉันเขียนโพสต์เกี่ยวกับสิ่งนี้จริงๆ http://js-bits.blogspot.com/2010/08/constructors-without-using-new.html

function Ctor() {
    if (!(this instanceof Ctor) {
        return new Ctor(); 
    }
    // regular construction code
}

และคุณยังสามารถทำให้เป็นมาตรฐานได้โดยที่คุณไม่ต้องเพิ่มมันเข้าไปที่ด้านบนของคอนสตรัคเตอร์ทุกตัว คุณสามารถดูได้โดยไปที่โพสต์ของฉัน

ข้อจำกัดความรับผิดชอบฉันไม่ได้ใช้สิ่งนี้ในรหัสของฉันฉันโพสต์ไว้เฉพาะค่าสอนเท่านั้น ฉันพบว่าการลืมnewข้อผิดพลาดเป็นเรื่องง่าย เช่นเดียวกับคนอื่น ๆ ฉันไม่คิดว่าเราต้องการรหัสนี้จริง ๆ นอกจากว่าคุณกำลังเขียนไลบรารีเพื่อสร้างการสืบทอด JS ซึ่งในกรณีนี้คุณสามารถใช้จากที่เดียวและคุณจะใช้วิธีการที่แตกต่างจากการสืบทอดต่อไป

แล้วเรื่องนี้ล่ะ?

/* thing maker! it makes things! */
function thing(){
    if (!(this instanceof thing)){
        /* call 'new' for the lazy dev who didn't */
        return new thing(arguments, "lazy");
    };

    /* figure out how to use the arguments object, based on the above 'lazy' flag */
    var args = (arguments.length > 0 && arguments[arguments.length - 1] === "lazy") ? arguments[0] : arguments;

    /* set properties as needed */
    this.prop1 = (args.length > 0) ? args[0] : "nope";
    this.prop2 = (args.length > 1) ? args[1] : "nope";
};

/* create 3 new things (mixed 'new' and 'lazy') */
var myThing1 = thing("woo", "hoo");
var myThing2 = new thing("foo", "bar");
var myThing3 = thing();

/* test your new things */
console.log(myThing1.prop1); /* outputs 'woo' */
console.log(myThing1.prop2); /* outputs 'hoo' */

console.log(myThing2.prop1); /* outputs 'foo' */
console.log(myThing2.prop2); /* outputs 'bar' */

console.log(myThing3.prop1); /* outputs 'nope' */
console.log(myThing3.prop2); /* outputs 'nope' */

แก้ไข: ฉันลืมเพิ่ม:

"หากแอปของคุณ 'หนัก' อย่างแท้จริงสิ่งสุดท้ายที่คุณต้องการคือกลไกการก่อสร้างที่ overwrought เพื่อทำให้ช้าลง"

ฉันเห็นด้วยอย่างยิ่ง - เมื่อสร้าง 'สิ่ง' ด้านบนโดยไม่มีคำหลัก 'ใหม่' จะช้ากว่าหรือหนักกว่า ข้อผิดพลาดคือเพื่อนของคุณเพราะพวกเขาบอกคุณว่ามีอะไรผิดปกติ นอกจากนี้พวกเขายังบอกนักพัฒนาเพื่อนของคุณว่าพวกเขาทำอะไรผิด