JavaScript 構造函數使用 JavaScript object 文字表示法

Question

使用 object 文字符號在 JavaScript 中構建構造函數的最佳方法是什么？

var myObject = {
 funca : function() {
  //...
 },

 funcb : function() {
  //...
 }
};

我希望能夠打電話

var myVar = new myObject(...);

並將 arguments 傳遞給 myObject 內部的構造函數 function。

Answer 1

這不是 “JSON表示法”，這是JavaScript 對象字面表示法 。 JSON只是JS對象文字表示法的一個子集，但除了看起來相似之外，它們沒有任何共同之處。 JSON用作數據交換格式，如XML。

你不想做什么。

var myObject = {};

創建一個對象。 沒有什么可以實例化的。

但是，您可以創建構造函數並將方法添加到其原型中：

function MyObject(arg1, arg2) {
    // this refers to the new instance
    this.arg1 = arg1;
    this.arg2 = arg2;

    // you can also call methods
    this.funca(arg1);
}

MyObject.prototype = {
 funca : function() {
  // can access `this.arg1`, `this.arg2`
 },

 funcb : function() {
  // can access `this.arg1`, `this.arg2`
 }
};

使用new MyObject()實例化的每個對象都將繼承原型的屬性（實際上，實例只獲得對原型對象的引用）。

有關JavaScript對象和繼承的更多信息：

• 使用對象
• 對象模型的詳細信息
• 重新繼承了遺產

---

UPDATE2：

如果必須實例化許多相同類型的對象，則使用構造函數+ prototype。 如果您只需要一個對象（如單例），則無需使用構造函數（大多數情況下）。 您可以直接使用對象文字表示法來創建該對象。

Answer 2

使對象成為一個函數，如下所示：

var myObject = function(arg1){
  this.funca = function(){
    //...
  };
  this.funcb = function(){
    //...
  };
  this.constructor = function(obj){
    alert('constructor! I can now use the arg: ' + obj.name);
  };
  this.constructor(arg1);
};

// Use the object, passing in an initializer:
var myVar = new myObject({ name: 'Doug'});

Answer 3

很抱歉遲到了派對，但是......我認為這是不可能的 ，這取決於你如何解釋OP的問題以及隨后的評論。

假設OP需要命名空間的好處，對象文字符號可以帶給庫，但也希望在該結構中使用一些“類”。 你能否使用這種形式的東西將構造函數模式組合成對象文字符號命名空間的庫結構？

var myNamespace = {
    aProperty: "A value",

    aMethod: function () { return "A method result"; },

    onePlusOneEquals: function () {
        return new myNamespace.classes.NumberStuff(1, 1).added;
    },

    classes: {
        ClassA: function () {
            this.propertyOne = null;
            this.methodOne = function (param) {
                return "The method was passed " + param;
            }
        },

        NumberStuff: function (argOne, argTwo) {
            this.added      = argOne + argTwo;
            this.subtracted = argOne - argTwo;
        }
    }
};

myNamespace.classes.ClassA.prototype.methodTwo = function () { return "At least this one's not bloating our memory footprint with every ClassA created..."; };

...

var anObj = new myNamespace.classes.ClassA();
alert(anObj.methodOne("the parcel")); // "The method was passed the parcel"
alert(myNamespace.onePlusOneEquals()); //2

他們是愚蠢的例子，但有沒有理由不這樣做，或者為什么這是無效的？ 它消除了人們通常希望對庫使用對象文字符號的全局擁擠問題。

Answer 4

var myObject = function(arg){
    return{
        constructor: function(arg){
            //...
            return this;
        },

        funca: function(){
            //...
        },

        funcb: function(){
            //...
        }
    }.constructor(arg);
};

//...

var myVar = new myObject("...");

Answer 5

var myObject = {
 funca : function() {
  //...
 },

 funcb : function() {
  //...
 }
};

你無法以這種方式創建一個新的對象

var myVar = new myObject(...);

但你可以用下面的構造實現相同的，

var myVar = Object.create(myObject );

Answer 6

我知道的最簡單的方法是：

function test(arg1, arg2) {
  var1 = arg1;
  var2 = arg2;
  return {
    var3 : var1, // json can access var1
    var4 : var2 // json can access var2
  };
}

arg1 = 'test';
arg2 = function() {
  window.alert('test')
};
var5 = new test(arg1, arg2);
var5.var4();

Answer 7

好吧，正如其他人已經回答的那樣，不可能在 object 文字上調用new 。

但是在 object 文字constructor上調用new是可能的。

 var obj = { arg1: null, arg2: null }; var obj1 = new obj.constructor(); var obj2 = new obj.constructor(); obj1.arg1 = 1; obj2.arg1 = 2; console.log("obj2.arg1:", obj2.arg1); console.log("obj1.arg1:", obj1.arg1);