Javascript 创建对象的正确方法

创建对象的正确方法是什么（使用其“名称空间”等等）

1

//Company object
var Microsoft = {};

//Create an employee
Microsoft.employee = function(name) {
   this.name = name;
}

或

2

//Company object
Apple = {

   employee: function(name) {
      this.name = name;
   }

}

还是另一种方式？开枪

---

阅读一些关于原型之类的东西。正确的方法是什么；利与弊

首先，您忘记了

Apple

的

var

。但除此之外，这些基本上是一样的

其次，在我的示例中，我不打算使用属性

name

，因为在处理函数时，

name

默认为空字符串。至少在Node.js和Chrome中。因此，我将使用

empName

在

Microsoft

示例中，您正在生成一个空对象，然后在事实发生后向其添加一个属性

在

Apple

示例中，您正在使用该属性立即创建一个对象

这对你来说是最有意义的，也是你更喜欢的。因为它们或多或少是等价的

现在，这与原型无关。以下是您所做工作的示例：

var Apple = { 
    employee: function(empName) {
        this.empName = empName;
    }
};

Apple.employee('Hank');
Apple.empName; // 'Hank'

下面是如何使用实例（使用

new

操作符和

prototype

）

因此，

prototype

用于向对象的新实例添加属性（松散地使用“object”）。请注意，在第二个示例中，要访问

Apple

中的

employee

，您必须执行以下操作

Apple.prototype.employee('Hank'); // doesn't really do much
Apple.empName; // undefined

// but you can call the employee prototype with a bound variable
// you'd do this if you don't want to make an instance of Apple
// but still want to use one of it's prototypes
var obj = {};
Apple.prototype.employee.call(obj, 'Hank');
obj.empName; // 'Hank'

// a practical use of accessing a prototype method is
// when wanting to convert a function's arguments
// to an array. function arguments are like an array,
// but until turned into one they are not completely the same
var func = function() {
    var args = Array.prototype.slice.call(arguments);
    var sum = 0;
    for(var i = 0, l = args.length; i < l; i++) {
        sum += args[i];
    }
    return sum;
};

func(1); // 1
func(1, 2, 3, 4, 5); // 15

Apple.prototype.employee（'Hank'）；//真的没什么用
Apple.empName；//未定义
//但是您可以使用绑定变量调用employee原型
//如果你不想以苹果为例，你会这么做的
//但仍然想使用它的一个原型
var obj={}；
Apple.prototype.employee.call（obj'Hank'）；
obj.empName；//'汉克
//访问原型方法的一个实际用途是
//当想要转换函数的参数时
//到一个数组。函数参数就像一个数组，
//但在成为一体之前，它们并不完全相同
var func=函数（）{
var args=Array.prototype.slice.call（参数）；
var总和=0；
对于（变量i=0，l=args.length；i

希望有帮助

---

编辑：另外，不要原型化对象（例如

{}

或

对象

）。这样做不安全。从本质上讲，JavaScript中的每个变量都是一个对象，因此添加到它们中的任何原型都可以在所有变量上使用。因此，如果你做了

Object.prototype.xyz=12

，然后做了

var-obj={a:1，b:2，c:3}

，然后尝试

for（obj中的var-key）{console.log（key）；}

你会得到以下日志：

a

，

b

，

c

和

xyz。。。这是你不想要的。
首先，你忘记了
Apple
的
var
。但除此之外，这些基本上是一样的

其次，在我的示例中，我不打算使用属性
name
，因为在处理函数时，
name
默认为空字符串。至少在Node.js和Chrome中。因此，我将使用
empName

在
Microsoft
示例中，您正在生成一个空对象，然后在事实发生后向其添加一个属性

在
Apple
示例中，您正在使用该属性立即创建一个对象

这对你来说是最有意义的，也是你更喜欢的。因为它们或多或少是等价的

现在，这与原型无关。以下是您所做工作的示例：

var Apple = { 
    employee: function(empName) {
        this.empName = empName;
    }
};

Apple.employee('Hank');
Apple.empName; // 'Hank'

下面是如何使用实例（使用
new
操作符和
prototype
）

因此，
prototype
用于向对象的新实例添加属性（松散地使用“object”）。请注意，在第二个示例中，要访问
Apple
中的
employee
，您必须执行以下操作

Apple.prototype.employee('Hank'); // doesn't really do much
Apple.empName; // undefined

// but you can call the employee prototype with a bound variable
// you'd do this if you don't want to make an instance of Apple
// but still want to use one of it's prototypes
var obj = {};
Apple.prototype.employee.call(obj, 'Hank');
obj.empName; // 'Hank'

// a practical use of accessing a prototype method is
// when wanting to convert a function's arguments
// to an array. function arguments are like an array,
// but until turned into one they are not completely the same
var func = function() {
    var args = Array.prototype.slice.call(arguments);
    var sum = 0;
    for(var i = 0, l = args.length; i < l; i++) {
        sum += args[i];
    }
    return sum;
};

func(1); // 1
func(1, 2, 3, 4, 5); // 15

Apple.prototype.employee（'Hank'）；//真的没什么用
Apple.empName；//未定义
//但是您可以使用绑定变量调用employee原型
//如果你不想以苹果为例，你会这么做的
//但仍然想使用它的一个原型
var obj={}；
Apple.prototype.employee.call（obj'Hank'）；
obj.empName；//'汉克
//访问原型方法的一个实际用途是
//当想要转换函数的参数时
//到一个数组。函数参数就像一个数组，
//但在成为一体之前，它们并不完全相同
var func=函数（）{
var args=Array.prototype.slice.call（参数）；
var总和=0；
对于（变量i=0，l=args.length；i

希望有帮助

编辑：另外，不要原型化对象（例如
{}
或
对象
）。这样做不安全。从本质上讲，JavaScript中的每个变量都是一个对象，因此添加到它们中的任何原型都可以在所有变量上使用。因此，如果你做了
Object.prototype.xyz=12
，然后做了
var-obj={a:1，b:2，c:3}
，然后尝试
for（obj中的var-key）{console.log（key）；}
你会得到以下日志：
a
，
b
，
c
和
xyz。。。你不会想要的。
考虑到这两种可能性，两者都可以。如果你有一个构造函数，并且打算创建一个以上的“同类”对象，你只需要担心原型。@FelixKling编辑了我的问题，如果你知道更好的方法，请分享。@FelixKling一般来说，如果你比较每个优点和缺点，您推荐使用哪一种。您展示的两个版本在实际应用中完全相同。零差异（您缺少一个
var