Object.create（null）在Javascript中&；创建新的顶级对象

如果这个问题太模糊，让我知道，我会把它记下来或尝试添加更多的代码示例，谢谢

这篇文章的灵感来自

在Javascript中，您可以通过使用

Object.create（）

来利用原型，这将产生一种类似于许多OOP语言的依赖/继承。如果将

null

参数传递给

create（）

方法，则此新对象将是顶级对象，与

object.prototype

的级别相同

现在，也许这只是我多年的Java和C经验，但是什么时候才能创建顶级对象呢？如果您对

Object.prototype

中的字段/方法不满意，为什么不扩展它并创建自己的伪顶级对象呢

示例： 在本例中，person是顶级对象。因此，它没有继承

Object.prototype

中包含的标准方法，例如

toString（）

，

hasOwnProperty（）

，

valueOf（）

，等等

var person = Object.create(null);

// instead of using defineProperty and specifying writable,
// configurable, and enumerable, we can just assign the
// value directly and JavaScript will take care of the rest
person['fullName'] = function() {
  return this.firstName + ' ' + this.lastName;
};

// this time, let's make man's prototype person, so all
// men share the fullName function
var man = Object.create(person);
man['sex'] = "male";

var yehuda = Object.create(man);
yehuda['firstName'] = "Yehuda";
yehuda['lastName'] = "Katz";

yehuda.sex        // "male"
yehuda.fullName() // "Yehuda Katz"

---

正如您所说，构造

{}

或

新对象

会生成一个具有原型的对象。使用

Object.create（null）

构建一个原型为空的对象，因此没有继承的成员

我可以考虑的一个好的用例是，当您实际需要一个绝对无成员的对象时，例如，执行一个安全的迭代：

for(var key in obj) {
    /*
      in normal conditions, you must ensure that object hasOwnProperty(key)
      so you know you're iterating on actual members.
     */
     if (obj.hasOwnProperty(key)) {
         console.log("key: " + key + "; value: " + obj[key]);
     }
}

但是通过这种方法，您可以确保没有任何原型，因此默认情况下每个属性都是自己的

obj = Object.create(null);
//to-do populate your object keys here, treating it like a hash instead of an object.
for(var key in obj) {
     /*
       this operation is safe and also this object is safe to be populated
       in server-side javascript (e.g. nodejs) via a POST request.
       a common use case is to SERIALIZE this object quickly, while the
       previous IF could provide some overhead.
     */
     console.log("key: " + key + "; value: " + obj[key]);
}

因此，您可以安全地将对象视为散列，并按照我所说的进行迭代，只保存真实数据

---

另一个可能的用例是，当您想要从头构建自己的原型（甚至是一个toString函数或不在对象原型中定义某些函数）并创建一个全新的层次结构时。这可能只对框架有用。这有点麻烦，但在OOP方法中可能很有用。

构造

{}

或

新对象

会生成一个具有原型的对象，正如您所说的。使用

Object.create（null）

构建一个原型为空的对象，因此没有继承的成员

我可以考虑的一个好的用例是，当您实际需要一个绝对无成员的对象时，例如，执行一个安全的迭代：

for(var key in obj) {
    /*
      in normal conditions, you must ensure that object hasOwnProperty(key)
      so you know you're iterating on actual members.
     */
     if (obj.hasOwnProperty(key)) {
         console.log("key: " + key + "; value: " + obj[key]);
     }
}

但是通过这种方法，您可以确保没有任何原型，因此默认情况下每个属性都是自己的

obj = Object.create(null);
//to-do populate your object keys here, treating it like a hash instead of an object.
for(var key in obj) {
     /*
       this operation is safe and also this object is safe to be populated
       in server-side javascript (e.g. nodejs) via a POST request.
       a common use case is to SERIALIZE this object quickly, while the
       previous IF could provide some overhead.
     */
     console.log("key: " + key + "; value: " + obj[key]);
}

因此，您可以安全地将对象视为散列，并按照我所说的进行迭代，只保存真实数据

---

另一个可能的用例是，当您想要从头构建自己的原型（甚至是一个toString函数或不在对象原型中定义某些函数）并创建一个全新的层次结构时。这可能只对框架有用。这有点麻烦，但在OOP方法中可能很有用。

构造

{}

或

新对象

会生成一个具有原型的对象，正如您所说的。使用

Object.create（null）

构建一个原型为空的对象，因此没有继承的成员

我可以考虑的一个好的用例是，当您实际需要一个绝对无成员的对象时，例如，执行一个安全的迭代：

for(var key in obj) {
    /*
      in normal conditions, you must ensure that object hasOwnProperty(key)
      so you know you're iterating on actual members.
     */
     if (obj.hasOwnProperty(key)) {
         console.log("key: " + key + "; value: " + obj[key]);
     }
}

但是通过这种方法，您可以确保没有任何原型，因此默认情况下每个属性都是自己的

obj = Object.create(null);
//to-do populate your object keys here, treating it like a hash instead of an object.
for(var key in obj) {
     /*
       this operation is safe and also this object is safe to be populated
       in server-side javascript (e.g. nodejs) via a POST request.
       a common use case is to SERIALIZE this object quickly, while the
       previous IF could provide some overhead.
     */
     console.log("key: " + key + "; value: " + obj[key]);
}

因此，您可以安全地将对象视为散列，并按照我所说的进行迭代，只保存真实数据

---

另一个可能的用例是，当您想要从头构建自己的原型（甚至是一个toString函数或不在对象原型中定义某些函数）并创建一个全新的层次结构时。这可能只对框架有用。这有点麻烦，但在OOP方法中可能很有用。

构造

{}

或

新对象

会生成一个具有原型的对象，正如您所说的。使用

Object.create（null）

构建一个原型为空的对象，因此没有继承的成员

我可以考虑的一个好的用例是，当您实际需要一个绝对无成员的对象时，例如，执行一个安全的迭代：

for(var key in obj) {
    /*
      in normal conditions, you must ensure that object hasOwnProperty(key)
      so you know you're iterating on actual members.
     */
     if (obj.hasOwnProperty(key)) {
         console.log("key: " + key + "; value: " + obj[key]);
     }
}

但是通过这种方法，您可以确保没有任何原型，因此默认情况下每个属性都是自己的

obj = Object.create(null);
//to-do populate your object keys here, treating it like a hash instead of an object.
for(var key in obj) {
     /*
       this operation is safe and also this object is safe to be populated
       in server-side javascript (e.g. nodejs) via a POST request.
       a common use case is to SERIALIZE this object quickly, while the
       previous IF could provide some overhead.
     */
     console.log("key: " + key + "; value: " + obj[key]);
}

因此，您可以安全地将对象视为散列，并按照我所说的进行迭代，只保存真实数据

---

另一个可能的用例是，当您想要从头构建自己的原型（甚至是一个toString函数或不在对象原型中定义某些函数）并创建一个全新的层次结构时。这可能只对框架有用。这有点麻烦，但在OOP方法中可能很有用。

一般来说？当你想避免灾难时（例如使用对象来绘制地图），你想在真实对象中避免灾难的实际情况非常少。一般来说？当你想避免灾难时（例如使用对象来绘制地图），你想在真实对象中避免灾难的实际情况非常少。一般来说？当你想避免灾难时（例如使用对象来绘制地图），你想在真实对象中避免灾难的实际情况非常少。一般来说？当你想要避免灾难时（例如使用对象来绘制地图），你想要在真实对象中避免灾难的实际情况是非常少的。