prototype允许你创建类。如果你不使用prototype，那么它就变成了静态的。

这里有一个简短的例子。

var obj = new Object();obj.test = function() { alert('Hello?'); };

在上面的例子中，你有静态函数调用测试。这个函数只能被obj.test访问，你可以想象obj是一个类。

在下面的代码中

function obj(){}
obj.prototype.test = function() { alert('Hello?'); };var obj2 = new obj();obj2.test();

obj已经成为一个可以实例化的类。obj的多个实例可以存在，它们都具有test函数。

以上是我的理解。我把它做成一个社区wiki，所以如果我错了，人们可以纠正我。

这个“原型”属性的确切目的是什么？

标准类的接口变得可扩展。例如，你正在使用Array类，你还需要为所有的数组对象添加一个自定义序列化器。你会花时间编写子类，还是使用组合或…原型属性通过让用户控制类可用的确切成员/方法集来解决这个问题。

将原型视为额外的vtable指针。当原始类中缺少一些成员时，会在运行时查找原型。

Javascript没有通常意义上的继承，但它有原型链。

原型链

如果在对象中找不到对象的成员，它会在原型链中查找它。该链由其他对象组成。给定实例的原型可以使用__proto__变量访问。每个对象都有一个，因为javascript中的类和实例之间没有区别。

将函数/变量添加到原型的优点是它必须只在内存中出现一次，而不是每个实例。

它对继承也很有用，因为原型链可以由许多其他对象组成。

每个JavaScript对象有一个内部“插槽”称为[[Prototype]]，其值为null或object。您可以将插槽视为对象上的属性，它是JavaScript引擎内部的，隐藏在您编写的代码中。[[Prototype]]周围的方括号是故意的，是表示内部插槽的ECMAScript规范约定。

对象的[[Prototype]]指向的值，通俗地称为“该对象的原型”。

如果你通过点（obj.propName）或括号（obj['propName']）符号访问一个属性，并且该对象不直接具有这样的属性（即自己的财产，可通过obj.hasOwnProperty('propName')检查），运行时将在[[Prototype]]引用的对象上查找具有该名称的属性。如果[[Prototype]]还没有这样的属性，则依次检查它的[[Prototype]]，依此类推。通过这种方式，原始对象的原型链被遍历，直到找到匹配项，或者到达其末端。原型链的顶部是null值。

现代JavaScript实现允许通过以下方式对[[Prototype]]进行读和/或写访问：

1. new运算符（在构造函数返回的默认对象上配置原型链），
2. extends关键字（使用类语法时配置原型链），
3. Object.create将提供的参数设置为结果对象的[[Prototype]]，
4. Object.getPrototypeOf和Object.setPrototypeOf（获取/设置[[Prototype]]之后对象创建），以及
5. 名为__proto__（类似于4）的标准化访问器（即getter/setter）属性。

Object.getPrototypeOf和Object.setPrototypeOf优于__proto__，部分原因是当对象具有null的原型时o.__proto__是不寻常的行为。

对象的[[Prototype]]最初是在对象创建期间设置的。

如果您通过new Func()创建一个新对象，则默认情况下，对象的[[Prototype]]将设置为Func.prototype引用的对象。

请注意，因此，所有类以及所有可以与#0运算符一起使用的函数，除了它们自己的#2内部插槽外，还有一个名为#1的属性。“原型”这个词的双重使用是该语言新手无休止混淆的根源。

将new与构造函数一起使用允许我们模拟JavaScript中的经典继承；尽管JavaScript的继承系统是原型的，而不是基于类的。

在JavaScript引入类语法之前，构造函数是模拟类的唯一方法。我们可以将构造函数.prototype属性引用的对象的属性视为共享成员；即每个实例都相同的成员。在基于类的系统中，方法对每个实例的实现方式相同，因此方法在概念上被添加到.prototype属性中；然而，对象的字段是特定于实例的，因此在构造过程中被添加到对象本身中。

如果没有类语法，开发人员必须手动配置原型链以实现与经典继承类似的功能。这导致了实现这一目标的不同方法的优势。

这里有一个方法：

function Child() {}function Parent() {}Parent.prototype.inheritedMethod = function () { return 'this is inherited' }
function inherit(child, parent) {child.prototype = Object.create(parent.prototype)child.prototype.constructor = childreturn child;}
Child = inherit(Child, Parent)const o = new Childconsole.log(o.inheritedMethod()) // 'this is inherited'

…还有另一种方法：

function Child() {}function Parent() {}Parent.prototype.inheritedMethod = function () { return 'this is inherited' }
function inherit(child, parent) {function tmp() {}tmp.prototype = parent.prototypeconst proto = new tmp()proto.constructor = childchild.prototype = protoreturn child}
Child = inherit(Child, Parent)const o = new Childconsole.log(o.inheritedMethod()) // 'this is inherited'

ES2015中引入的类语法通过提供extends作为配置原型链的“一种真正的方式”来简化事情，以便模拟JavaScript中的经典继承。

因此，与上面的代码类似，如果您使用类语法创建一个新对象，如下所示：

class Parent { inheritedMethod() { return 'this is inherited' } }class Child extends Parent {}
const o = new Childconsole.log(o.inheritedMethod()) // 'this is inherited'

…结果对象的[[Prototype]]将被设置为Parent的实例，其[[Prototype]]反过来是Parent.prototype。

最后，如果您通过Object.create(foo)创建一个新对象，则结果对象的[[Prototype]]将设置为foo。

当构造函数创建一个对象时，该对象隐式引用构造函数的“原型”属性以解析属性引用。构造函数的“原型”属性可以被程序表达式constructor.prototype引用，并且添加到对象原型的属性通过继承由共享原型的所有对象共享。

在实现经典继承的语言中，如Java，C#或C++，您首先创建一个类-对象的蓝图-然后您可以从该类创建新对象，或者您可以扩展该类，定义一个增强原始类的新类。

在JavaScript中，你首先创建一个对象（没有类的概念），然后你可以增强你自己的对象或从中创建新对象。这并不难，但对于习惯经典方式的人来说有点陌生和难以新陈代谢。

示例：

//Define a functional object to hold persons in JavaScriptvar Person = function(name) {this.name = name;};
//Add dynamically to the already defined object a new getterPerson.prototype.getName = function() {return this.name;};
//Create a new object of type Personvar john = new Person("John");
//Try the getteralert(john.getName());
//If now I modify person, also John gets the updatesPerson.prototype.sayMyName = function() {alert('Hello, my name is ' + this.getName());};
//Call the new method on johnjohn.sayMyName();

到目前为止，我一直在扩展基本对象，现在我创建了另一个对象，然后从Person继承。

//Create a new object of type Customer by defining its constructor. It's not//related to Person for now.var Customer = function(name) {this.name = name;};
//Now I link the objects and to do so, we link the prototype of Customer to//a new instance of Person. The prototype is the base that will be used to//construct all new instances and also, will modify dynamically all already//constructed objects because in JavaScript objects retain a pointer to the//prototypeCustomer.prototype = new Person();
//Now I can call the methods of Person on the Customer, let's try, first//I need to create a Customer.var myCustomer = new Customer('Dream Inc.');myCustomer.sayMyName();
//If I add new methods to Person, they will be added to Customer, but if I//add new methods to Customer they won't be added to Person. Example:Customer.prototype.setAmountDue = function(amountDue) {this.amountDue = amountDue;};Customer.prototype.getAmountDue = function() {return this.amountDue;};
//Let's try:myCustomer.setAmountDue(2000);alert(myCustomer.getAmountDue());

var Person = function (name) {this.name = name;};Person.prototype.getName = function () {return this.name;};var john = new Person("John");alert(john.getName());Person.prototype.sayMyName = function () {alert('Hello, my name is ' + this.getName());};john.sayMyName();var Customer = function (name) {this.name = name;};Customer.prototype = new Person();
var myCustomer = new Customer('Dream Inc.');myCustomer.sayMyName();Customer.prototype.setAmountDue = function (amountDue) {this.amountDue = amountDue;};Customer.prototype.getAmountDue = function () {return this.amountDue;};myCustomer.setAmountDue(2000);alert(myCustomer.getAmountDue());

正如我所说，我不能调用setAmount（），而在Person上调用getAmount（）。

//The following statement generates an error.john.setAmountDue(1000);

看完这篇文章后，我对JavaScript原型链感到困惑，然后我发现了这些图表

http://iwiki.readthedocs.org/en/latest/javascript/js_core.html#inheritance

这是一个清晰的图表，通过原型链显示JavaScript继承

和

http://www.javascriptbank.com/javascript/article/JavaScript_Classical_Inheritance/

这个包含一个带有代码的示例和几个漂亮的图表。

原型链最终会回到Object.prototype.

原型链可以在技术上扩展，只要你愿意，每次都通过将子类的原型设置为等于父类的对象。

希望它对你理解JavaScript原型链也有帮助。

每个对象都有一个内部属性原型，将其链接到另一个对象：

object [[Prototype]] → anotherObject

在传统的javascript中，链接对象是函数的prototype属性：

object [[Prototype]] → aFunction.prototype

一些环境将原型暴露为__proto__：

anObject.__proto__ === anotherObject

您在创建对象时创建原型链接。

// (1) Object.create:var object = Object.create(anotherObject)// object.__proto__ = anotherObject
// (2) ES6 object initializer:var object = { __proto__: anotherObject };// object.__proto__ = anotherObject
// (3) Traditional JavaScript:var object = new aFunction;// object.__proto__ = aFunction.prototype

所以这些陈述是等价的：

var object = Object.create(Object.prototype);var object = { __proto__: Object.prototype }; // ES6 onlyvar object = new Object;

您实际上无法在新的语句中看到链接目标（Object.prototype）；相反，目标是由构造函数（Object）隐含的。

记住：

• 每个对象都有一个链接原型，有时显示为__proto__。
• 每个函数都有一个prototype属性，最初持有一个空对象。
• 使用新的创建的对象链接到其构造函数的prototype属性。
• 如果一个函数从未被用作构造函数，它的prototype属性将被闲置。
• 如果您不需要构造函数，请使用Object.create而不是new。

当引用obj_n.prop_X时，我发现将“原型链”解释为递归约定很有帮助：

如果obj_n.prop_X不存在，请选中obj_n+1.prop_Xobj_n+1 = obj_n.[[prototype]]

如果最终在第k个原型对象中找到了prop_X，那么

obj_1.prop_X = obj_1.[[prototype]].[[prototype]]..(k-times)..[[prototype]].prop_X

您可以在此处找到Javascript对象按其属性排列的关系图：

http://jsobjects.org

这是一个非常简单的基于原型的对象模型，在解释期间将被视为示例，尚未发表评论：

function Person(name){this.name = name;}Person.prototype.getName = function(){console.log(this.name);}var person = new Person("George");

在完成原型概念之前，我们必须考虑一些关键点。

1. JavaScript函数实际上是如何工作的：

为了迈出第一步，我们必须弄清楚JavaScript函数实际上是如何工作的，作为一个使用#0关键字的类函数，或者只是作为一个带有参数的常规函数，它做什么和它返回什么。

假设我们想要创建一个Person对象模型。但在这一步中，我将尝试在不使用#1和#2关键字的情况下做同样的事情。

所以在这一步#0，#1和#2关键字，是我们所拥有的一切。

第一个问题是#0关键字如何在不使用#1关键字的情况下有用。

因此，为了回答这个问题，假设我们有一个空对象和两个函数，例如：

var person = {};function Person(name){  this.name = name;  }
function getName(){console.log(this.name);}

现在不使用#0关键字我们如何使用这些函数。所以JavaScript有3种不同的方法来做到这一点：

一种。第一种方法是将函数作为常规函数调用：

Person("George");getName();//would print the "George" in the console

在这种情况下，这将是当前上下文对象，它通常是浏览器中的全局window对象或Node.js中的GLOBAL对象。这意味着我们将在浏览器中window.name或在Node.js中GLOBAL.name，其值为“George”。

我们可以附上它们到一个对象，作为它的属性

-最简单的方法这样做是修改空的person对象，如：

person.Person = Person;person.getName = getName;

我们可以这样称呼它们：

person.Person("George");person.getName();// -->"George"

现在person对象就像：

Object {Person: function, getName: function, name: "George"}

-附加财产的另一种方式到一个对象使用了该对象的prototype，该对象可以在任何名称为__proto__的JavaScript对象中找到，我试图在摘要部分解释它。所以我们可以通过这样做得到类似的结果：

person.__proto__.Person = Person;person.__proto__.getName = getName;

但是这样我们实际上正在做的是修改Object.prototype，因为每当我们使用文字（{ ... }）创建JavaScript对象时，它都是基于Object.prototype创建的，这意味着它会作为一个名为#3的属性附加到新创建的对象上，所以如果我们改变它，就像我们在之前的代码片段上所做的那样，所有的JavaScript对象都会改变，这不是一个好的做法。那么现在更好的做法是什么：

person.__proto__ = {Person: Person,getName: getName};

现在其他对象处于和平状态，但这似乎仍然不是一个好的做法。所以我们还有一个解决方案，但要使用这个解决方案，我们应该回到创建person对象的那行代码（var person = {};）然后像这样更改它：

var propertiesObject = {Person: Person,getName: getName};var person = Object.create(propertiesObject);

它所做的是创建一个新的JavaScriptObject并将propertiesObject附加到__proto__属性。所以为了确保你可以这样做：

console.log(person.__proto__===propertiesObject); //true

但是这里棘手的一点是，您可以访问person对象第一层上__proto__中定义的所有属性（有关更多详细信息，请阅读摘要部分）。

正如您所看到的，使用这两种方式中的任何一种，this都将准确地指向person对象。

c。JavaScript还有另一种方式为函数提供this，即使用打电话或适用来调用函数。

应用（）方法调用一个给定this值的函数作为数组（或类似数组的对象）提供的参数。

和

call（）方法调用具有给定this值的函数，并且单独提供的参数。

这是我最喜欢的方式，我们可以轻松地调用我们的函数，例如：

Person.call(person, "George");

或

//apply is more useful when params count is not fixedPerson.apply(person, ["George"]);
getName.call(person);getName.apply(person);

这3个方法是找出.原型功能的重要初始步骤。

new关键字是如何工作的？

这是理解.prototype的第二步functionality.this是我用来模拟过程的：

function Person(name){  this.name = name;  }my_person_prototype = { getName: function(){ console.log(this.name); } };

在这一部分中，我将尝试采取JavaScript所采取的所有步骤，而不使用new关键字和prototype，当你使用new关键字时。所以当我们做new Person("George")时，Person函数充当构造函数，这些是JavaScript所做的，一个接一个：

首先，它创建了一个空对象，基本上是一个空哈希，比如：

var newObject = {};

b. JavaScript的下一步是将所有原型对象附上到新创建的对象

我们这里有my_person_prototype类似于原型对象。

for(var key in my_person_prototype){newObject[key] = my_person_prototype[key];}

这不是JavaScript实际附加原型中定义的属性的方式。实际的方式与原型链概念有关。

a.&b.而不是这两个步骤，您可以通过执行以下操作获得完全相同的结果：

var newObject = Object.create(my_person_prototype);//here you can check out the __proto__ attributeconsole.log(newObject.__proto__ === my_person_prototype); //true//and also check if you have access to your desired propertiesconsole.log(typeof newObject.getName);//"function"

现在我们可以调用my_person_prototype中的getName函数：

newObject.getName();

c.然后它将该对象提供给构造函数，

我们可以使用我们的示例来做到这一点，例如：

Person.call(newObject, "George");

或

Person.apply(newObject, ["George"]);

然后构造函数可以做任何它想做的事情，因为该构造函数内部的这个是刚刚创建的对象。

现在是模拟其他步骤之前的最终结果：对象{name："George"}

总结：

基本上，当您在函数上使用新的关键字时，您正在调用该函数，该函数用作构造函数，因此当您说：

new FunctionName()

JavaScript在内部创建一个对象，一个空哈希，然后它将该对象提供给构造函数，然后构造函数可以做任何它想做的事情，因为该构造函数内部的这个是刚刚创建的对象，然后它会给你那个对象，当然，如果你没有在函数中使用返回语句，或者如果你在函数体的末尾放了一个return undefined;。

所以当JavaScript去查找一个对象的属性时，它做的第一件事，就是在那个对象上查找它。然后有一个秘密属性#0，我们通常把它像#1一样，这个属性就是JavaScript接下来要查看的。当它查看#1时，只要它是另一个JavaScript对象，它有自己的#1属性，它就会不断上升，直到它到达下一个#1为空的点。这一点是JavaScript中唯一一个#1属性为空的对象是Object.prototype对象：

console.log(Object.prototype.__proto__===null);//true

这就是继承在JavaScript中的工作原理。

换句话说，当你在一个函数上有一个原型属性并且你调用了一个new，在JavaScript完成查看新创建的对象的属性后，它会查看函数的.prototype，并且这个对象可能有自己的内部原型。

原型的七个Koans

当西罗圣经过深思后下火狐山时，他的头脑清晰而平静。

然而，他的手不安分，自己抓起画笔，记下下面的笔记。

0）两种不同的东西可以称为“原型”：

• 原型属性，如obj.prototype

• 原型内部属性，表示为[[Prototype]]在es5。

  它可以通过ES5Object.getPrototypeOf()检索。

  Firefox使它可以通过__proto__属性作为扩展访问。ES6现在提到__proto__的一些可选要求。

1）这些概念的存在是为了回答这个问题：

当我做obj.property时，JS在哪里寻找.property？

直观地说，经典继承应该会影响属性查找。

2）

• __proto__用于点.属性查找，如obj.property所示。
• .prototype是没有直接用于查找，只是间接地，因为它在使用new创建对象时确定__proto__。

查找顺序是：

• obj添加了obj.p = ...或Object.defineProperty(obj, ...)的属性
• 属性obj.__proto__
• obj.__proto__.__proto__的属性，等等
• 如果某个__proto__是null，则返回undefined。

这就是所谓的原型链。

您可以使用obj.hasOwnProperty('key')和Object.getOwnPropertyNames(f)避免.查找

3）设置obj.__proto__有两种主要方法：

• new：

  var F = function() {}var f = new F()

  然后new设置：

  f.__proto__ === F.prototype

  这个是使用.prototype的地方。

• Object.create：

   f = Object.create(proto)

  套：

  f.__proto__ === proto

4) The code:

var F = function(i) { this.i = i }var f = new F(1)

对应于下图（省略了一些Number的东西）：

(Function)       (  F  )                                      (f)----->(1)|  ^             | | ^                                        |   i    ||  |             | | |                                        |        ||  |             | | +-------------------------+              |        ||  |constructor  | |                           |              |        ||  |             | +--------------+            |              |        ||  |             |                |            |              |        ||  |             |                |            |              |        ||[[Prototype]]   |[[Prototype]]   |prototype   |constructor   |[[Prototype]]|  |             |                |            |              |        ||  |             |                |            |              |        ||  |             |                | +----------+              |        ||  |             |                | |                         |        ||  |             |                | | +-----------------------+        ||  |             |                | | |                                |v  |             v                v | v                                |(Function.prototype)              (F.prototype)                         ||                                 |                                    ||                                 |                                    ||[[Prototype]]                    |[[Prototype]]          [[Prototype]]||                                 |                                    ||                                 |                                    || +-------------------------------+                                    || |                                                                    |v v                                                                    v(Object.prototype)                                       (Number.prototype)| | ^| | || | +---------------------------+| |                             || +--------------+              ||                |              ||                |              ||[[Prototype]]   |constructor   |prototype|                |              ||                |              ||                | -------------+|                | |v                v |(null)           (Object)

此图显示了许多语言预定义的对象节点：

• null
• Object
• Object.prototype
• Function
• Function.prototype
• 1
• Number.prototype（可以用(1).__proto__找到，括号必须满足语法）

我们的2行代码只创建了以下新对象：

• f
• F
• F.prototype

i现在是f的属性，因为当你这样做时：

var f = new F(1)

它计算F，this是new将返回的值，然后将其分配给f。

5）.constructor通常来自F.prototype到.查找：

f.constructor === F!f.hasOwnProperty('constructor')Object.getPrototypeOf(f) === F.prototypeF.prototype.hasOwnProperty('constructor')F.prototype.constructor === f.constructor

当我们写f.constructor时，JavaScript执行.查找：

• f没有.constructor
• f.__proto__ === F.prototype有.constructor === F，所以拿去吧

结果f.constructor == F在直觉上是正确的，因为F用于构造f，例如设置字段，就像经典的OOP语言一样。

6）经典的继承语法可以通过操纵原型链来实现。

ES6添加了class和extends关键字，这些关键字主要是以前可能的原型操作疯狂的语法糖。

class C {constructor(i) {this.i = i}inc() {return this.i + 1}}
class D extends C {constructor(i) {super(i)}inc2() {return this.i + 2}}

// Inheritance syntax works as expected.c = new C(1)c.inc() === 2(new D(1)).inc() === 2(new D(1)).inc2() === 3

// "Classes" are just function objects.C.constructor === FunctionC.__proto__ === Function.prototypeD.constructor === Function// D is a function "indirectly" through the chain.D.__proto__ === CD.__proto__.__proto__ === Function.prototype

// "extends" sets up the prototype chain so that base class// lookups will work as expectedvar d = new D(1)d.__proto__ === D.prototypeD.prototype.__proto__ === C.prototype// This is what `d.inc` actually does.d.__proto__.__proto__.inc === C.prototype.inc

// Class variables// No ES6 syntax sugar apparently:// http://stackoverflow.com/questions/22528967/es6-class-variable-alternativesC.c = 1C.c === 1// Because `D.__proto__ === C`.D.c === 1// Nothing makes this work.d.c === undefined

没有所有预定义对象的简化图：

(c)----->(1)|   i|||[[Prototype]]||v    __proto__(C)<--------------(D)         (d)| |                |           || |                |           || |prototype       |prototype  |[[Prototype]]| |                |           || |                |           || |                | +---------+| |                | || |                | || |                v v|[[Prototype]]    (D.prototype)--------> (inc2 function object)| |                |             inc2| |                || |                |[[Prototype]]| |                || |                || | +--------------+| | || | || v v| (C.prototype)------->(inc function object)|                incvFunction.prototype

让我们花一点时间来研究以下内容是如何工作的：

c = new C(1)c.inc() === 2

第一行将c.i设置为1，如“4）”中所述。

在第二行，当我们这样做时：

c.inc()

• .inc是通过[[Prototype]]链找到的：c->C->C.prototype->inc
• 当我们在JavaScript中调用X.Y()函数时，JavaScript会在Y()函数调用中自动将this设置为等于X！

同样的逻辑也解释了d.inc和d.inc2。

本文https://javascript.info/class#not-just-a-syntax-sugar提到了class值得了解的进一步效果。如果没有class关键字，其中一些可能无法实现（待办事项请检查哪个）：

• [[FunctionKind]]:"classConstructor"，强制使用new：ES6类构造函数不能作为普通函数调用的原因是什么？调用构造函数
• 类方法是不可枚举的。可以用Object.defineProperty完成。
• 类总是use strict。可以为每个函数显式地use strict来完成，这确实很乏味。

让我告诉你我对原型的理解。我不打算在这里将继承与其他语言进行比较。我希望人们不要再比较语言，而是理解语言本身。理解原型和原型继承很简单，我将在下面向你展示。

原型就像一个模型，你可以基于它创建一个产品。要理解的关键点是，当您使用另一个对象作为原型创建一个对象时，原型和产品之间的联系是永恒的。例如：

var model = {x:2};var product = Object.create(model);model.y = 5;product.y=>5

每个对象都包含一个名为[[原型]]的内部属性，可以由Object.getPrototypeOf()函数访问。Object.create(model)创建一个新对象并将其[[原型]]属性设置为对象模型。因此，当您执行Object.getPrototypeOf(product)时，您将获得对象模型。

产品中的属性按以下方式处理：

• 当一个属性被访问只是为了读取它的值时，它会在作用域链中查找。对变量的搜索从产品开始，一直到它的原型。如果在搜索中找到这样的变量，搜索就会停止，并返回值。如果在作用域链中找不到这样的变量，则返回未定义。
• 写入（更改）属性时，该属性始终写入产品对象。如果产品还没有这样的属性，则会隐式创建和写入它。

这种使用原型属性的对象链接称为原型继承。在那里，它很简单，同意吗？

另一个尝试用更好的图片解释基于JavaScript原型的继承

这篇文章很长。但我相信它会清除你的大部分疑问关于JavaScript继承的“原型”性质。甚至更多。请阅读完整的文章。

JavaScript基本上有两种数据类型

• 非对象
• 对象

非对象

以下是非对象数据类型

• 字符串
• 数（包括NaN和Infinity）
• 布尔值（true， false）
• 未定义

当您使用typeof运算符时，这些数据类型返回以下内容

typeof"字符串文字"（或包含字符串文字的变量) === 字符串

typeof5（或任何数字文字或包含数字文字的变量或NaN或Infynity) === 数字

typeof真正（或虚假或包含真正或虚假的变量) === 布尔型

typeof未定义（或未定义的变量或包含未定义的变量) === “不确定”

字符串、数量和布尔数据类型可以表示为对象和非对象。当它们表示为对象时，它们的类型总是==='对象'。一旦我们理解了对象数据类型，我们将回到这个问题。

对象

对象数据类型可以进一步分为两种类型

1. 函数类型对象
2. 非函数类型对象

函数类型对象是使用typeof运算符返回字符串函数的那些。所有用户定义的函数和所有可以使用new运算符创建新对象的JavaScript内置对象都属于这一类。例如。

• 对象
• String
• 数量
• 布尔
• 数组
• 类型化数组
• RegExp
• 函数
• 所有其他可以使用new运算符创建新对象的内置对象
• 函数用户定义参数（）{/*用户自定义代码*/}

所以，typeof（对象） === typeof（字符串）===typeof（数量）===typeof（布尔值）===typeof（数组）===typeof（RegExp）===typeof（函数）===类型（用户定义函数）===函数

var Object= new Function ([native code for object Object])var String= new Function ([native code for object String])var Number= new Function ([native code for object Number])var Boolean= new Function ([native code for object Boolean])var Array= new Function ([native code for object Array])var RegExp= new Function ([native code for object RegExp])var Function= new Function ([native code  for object Function])var UserDefinedFunction= new Function ("user defined code")

var a=new Object() or var a=Object() or var a={} //Create object of type Objectvar a=new String() //Create object of type Stringvar a=new Number() //Create object of type Numbervar a=new Boolean() //Create object of type Booleanvar a=new Array() or var a=Array() or var a=[]  //Create object of type Arrayvar a=new RegExp() or var a=RegExp() //Create object of type RegExpvar a=new UserDefinedFunction()

var b=new a() //error. a is not typeof==='function'

var b=new Math() //error. Math is not typeof==='function'

var a=String() // Create a new Non Object string. returns a typeof==='string'var a=Number() // Create a new Non Object Number. returns a typeof==='number'var a=Boolean() //Create a new Non Object Boolean. returns a typeof==='boolean'

var a=UserDefinedFunction() //may or may not create an object of type UserDefinedFunction() based on how it is defined.

function UserDefinedFunction(){}

UserDefinedFunction.prototype={constructor:UserDefinedFunction}

function UserDefinedFunction(){
}
/* creating the above function automatically does the following as mentioned earlier
UserDefinedFunction.prototype={constructor:UserDefinedFunction}
*/

var newObj_1=new UserDefinedFunction()
alert(Object.getPrototypeOf(newObj_1)===UserDefinedFunction.prototype)  //Displays true
alert(newObj_1.constructor) //Displays function UserDefinedFunction
//Create a new property in UserDefinedFunction.prototype object
UserDefinedFunction.prototype.TestProperty="test"
alert(newObj_1.TestProperty) //Displays "test"
alert(Object.getPrototypeOf(newObj_1).TestProperty)// Displays "test"
//Create a new Object
var objA = {property1 : "Property1",constructor:Array
}

//assign a new object to UserDefinedFunction.prototypeUserDefinedFunction.prototype=objA
alert(Object.getPrototypeOf(newObj_1)===UserDefinedFunction.prototype)  //Displays false. The object referenced by UserDefinedFunction.prototype has changed
//The internal reference does not changealert(newObj_1.constructor) // This shall still Display function UserDefinedFunction
alert(newObj_1.TestProperty) //This shall still Display "test"
alert(Object.getPrototypeOf(newObj_1).TestProperty) //This shall still Display "test"

//Create another object of type UserDefinedFunctionvar newObj_2= new UserDefinedFunction();
alert(Object.getPrototypeOf(newObj_2)===objA) //Displays true.
alert(newObj_2.constructor) //Displays function Array()
alert(newObj_2.property1) //Displays "Property1"
alert(Object.getPrototypeOf(newObj_2).property1) //Displays "Property1"
//Create a new property in objAobjA.property2="property2"
alert(objA.property2) //Displays "Property2"
alert(UserDefinedFunction.prototype.property2) //Displays "Property2"
alert(newObj_2.property2) // Displays Property2
alert(Object.getPrototypeOf(newObj_2).property2) //Displays  "Property2"

var o=Starting object;
do {alert(o + "\n" + Object.getOwnPropertyNames(o))
}while(o=Object.getPrototypeOf(o))

var o=Object.create(null)alert(Object.getPrototypeOf(o)) //Displays null

function UserDefinedFunction(){}UserDefinedFunction.prototype=null// Can be set to any non object value (number,string,undefined etc.)
var o=new UserDefinedFunction()alert(Object.getPrototypeOf(o)==Object.prototype)   //Displays truealert(o.constructor)    //Displays Function Object

• 有两种类型的对象函数类型和非函数类型

• 只有函数类型对象可以使用运算符new创建新对象。这样创建的对象是非函数类型对象。非函数类型对象不能使用运算符new进一步创建对象。

• 默认情况下，所有函数类型对象都有一个“原型”属性。这个“原型”属性引用了一个对象，该对象有一个“构造函数”属性，默认情况下引用了函数类型对象本身。

• 所有对象（函数类型和非函数类型）都有一个“构造函数”属性，默认情况下引用创建它的函数类型对象/构造函数。

• 每个在内部创建的对象都引用了创建它的构造函数的“原型”属性。这个对象被称为创建的对象的原型（它不同于它引用的函数类型对象“原型”属性）。这样创建的对象可以直接访问构造函数的“原型”属性引用的对象中定义的方法和属性（在对象创建时）。

• 可以使用Object.get原型（）方法检索对象的原型（以及它的继承属性名称）。事实上，这个方法可以用于导航对象的整个原型链。

• 每个对象的原型链最终都可以追溯到Object.prototype（除非对象是使用Object.create（null）创建的，在这种情况下，对象没有原型）。

• typeof（new Array())==='对象'是语言的设计，而不是Douglas Crockford所指出的错误

• 将构造函数的原型属性设置为空（或未定义、数字、真、假、字符串）不会创建具有空原型的对象。在这种情况下，新创建的对象的原型设置为Object.prototype，其构造函数设置为函数Object。