摘要：原文鏈接猛戳這里構(gòu)造函數(shù)下面生成實(shí)例這時和會自動含有一個屬性，指向它們的構(gòu)造函數(shù)。這個對象的所有屬性和方法，都會被構(gòu)造函數(shù)的實(shí)例繼承。

"use strict";
顧名思義也就是 JavaScript 會在所謂嚴(yán)格模式下執(zhí)行，其一個主要的優(yōu)勢在于能夠強(qiáng)制開發(fā)者避免使用未聲明的變量。對于老版本的瀏覽器或者執(zhí)行引擎則會自動忽略該指令。

在正常模式中，如果一個變量沒有聲明就賦值，默認(rèn)是全局變量。嚴(yán)格模式禁止這種用法，全局變量必須顯式聲明。

"use strict";
　　v = 1; // 報(bào)錯，v未聲明
　　for(i = 0; i < 2; i++) { // 報(bào)錯，i未聲明
　　}

因此，嚴(yán)格模式下，變量都必須先用var命令聲明，然后再使用。

Javascript語言的一個特點(diǎn)，就是允許"動態(tài)綁定"，即某些屬性和方法到底屬于哪一個對象，不是在編譯時確定的，而是在運(yùn)行時（runtime）確定的。
嚴(yán)格模式對動態(tài)綁定做了一些限制。某些情況下，只允許靜態(tài)綁定。也就是說，屬性和方法到底歸屬哪個對象，在編譯階段就確定。這樣做有利于編譯效率的提高，也使得代碼更容易閱讀，更少出現(xiàn)意外。

因?yàn)橄旅娴拇a不是在嚴(yán)格模式下執(zhí)行，并且this的值不會在函數(shù)執(zhí)行時被設(shè)置，此時的this的值會默認(rèn)設(shè)置為全局對象。

function f2(){
  "use strict"; // 這里是嚴(yán)格模式
  return this;
}

f2() === undefined; // true

更全面的信息參考這個鏈接

考慮下面程序的運(yùn)行結(jié)果

var foo = 1;  
function bar() {  
    if (!foo) {  
        var foo = 10;  
    }  
    alert(foo);  
}  
bar();  

結(jié)果是10；
再看下面這個

var a = 1;  
function b() {  
    a = 10;  
    return;  
    function a() {}  
}  
b();  
alert(a); 

結(jié)果是1

出乎意料的結(jié)果是由于“Hoisting (變量提升)”的原因，要理解其中的原理需要先了解下JavaScript的作用域scope。

javascript作用域（函數(shù)作用域）與C語言作用域（塊級作用域）不同

int main() {  
    int x = 1;  
    printf("%d, ", x); // 1  
    if (1) {  
        int x = 2;  
        printf("%d, ", x); // 2  
    }  
    printf("%d
", x); // 1  
}  

這是因?yàn)镃家族的語言有塊作用域，當(dāng)程序控制走進(jìn)一個塊，比如if塊，只作用于該塊的變量可以被聲明，而不會影響塊外面的作用域。但是在Javascript里面，這樣不行

var x = 1;  
console.log(x); // 1  
if (true) {  
    var x = 2;  
    console.log(x); // 2  
}  
console.log(x); // 2  

函數(shù)聲明和變量聲明總是會被解釋器悄悄地被“提升”到方法體的最頂部。這個意思是，像下面的代碼：

function foo() {  
    bar();  
    var x = 1;  
} 

實(shí)際上會被解釋成：

function foo() {  
    var x;  
    bar();  
    x = 1;  
}  

無論定義該變量的塊是否能被執(zhí)行。下面的兩個函數(shù)實(shí)際上是一回事：

function foo() {  
    if (false) {  
        var x = 1;  
    }  
    return;  
    var y = 1;  
}  
function foo() {  
    var x, y;  
    if (false) {  
        x = 1;  
    }  
    return;  
    y = 1;  
}  

只有函數(shù)式的聲明才會連同函數(shù)體一起被提升。foo的聲明會被提升，但是它指向的函數(shù)體只會在執(zhí)行的時候才被賦值

function test() {  
    foo(); // TypeError "foo is not a function"  
    bar(); // "this will run!"  
    var foo = function () { // 變量指向函數(shù)表達(dá)式  
        alert("this won"t run!");  
    }  
    function bar() { // 函數(shù)聲明 函數(shù)名為bar  
        alert("this will run!");  
    }  
}  
test(); 

如果程序員不能很好的理解變量提升，他們寫的程序就容易出現(xiàn)一些問題。
為了避免這些問題，通常我們在每個作用域開始前聲明這些變量，這也是正常的 JavaScript 解析步驟，易于我們理解。

JavaScript 嚴(yán)格模式(strict mode)不允許使用未聲明的變量。

原文鏈接猛戳這里

function Person (name,age) {
    this.name = name;
    this.age = age;
    this.type = "human";
    this.play = function(){console.log("video game")};
}

//下面生成實(shí)例
var Person1 = new Person("Tom",25);
var Person2 = new Person("Jack",26);
alert(Person1.name);

//這時Person1和Person2會自動含有一個constructor屬性，指向它們的構(gòu)造函數(shù)。
alert(Person1.constructor);
//Javascript還提供了一個instanceof運(yùn)算符，驗(yàn)證原型對象與實(shí)例對象之間的關(guān)系
alert(Person1 instanceof Person); //true

alert(Person1.type == Person2.type);//ture
alert(Person1.play == Person2.play);//false

type屬性和play()方法都是一模一樣的內(nèi)容，每一次生成一個實(shí)例，都必須為重復(fù)的內(nèi)容，多占用一些內(nèi)存.

Javascript規(guī)定，每一個構(gòu)造函數(shù)都有一個prototype屬性，指向另一個對象。這個對象的所有屬性和方法，都會被構(gòu)造函數(shù)的實(shí)例繼承。
這意味著，我們可以把那些不變的屬性和方法，直接定義在prototype對象上.

function Person (name,age) {
    this.name = name;
    this.age = age;
}
Person.prototype.type = "human";
Person.prototype.play = function(){console.log("video game")};

var Person1 = new Person("Tom",25);
var Person2 = new Person("Jack",26);
alert(Person1.type); //human
alert(Person1.play == Person2.play); //true

這時所有實(shí)例的type屬性和play()方法，其實(shí)都是同一個內(nèi)存地址，指向prototype對象，使用原型的好處是可以讓對象實(shí)例共享它所包含的屬性和方法,因此就提高了運(yùn)行效率。

在JavaScript中,一共有兩種類型的值,原始值和對象值。每個對象都有一個內(nèi)部屬性 prototype ,我們通常稱之為原型。原型的值可以是一個對象,也可以是null。如果它的值是一個對象，則這個對象也一定有自己的原型。這樣就形成了一條線性的鏈，我們稱之為原型鏈。
關(guān)于原型、原型鏈-猛戳

ECMAScript 有 5 種原始類型（primitive type），即 Undefined、Null、Boolean、Number 和 String。
原始數(shù)據(jù)類型

引用類型通常叫做類（class），也就是說，遇到引用值，所處理的就是對象。

Object 對象
Object 對象自身用處不大，不過在了解其他類之前，還是應(yīng)該了解它。因?yàn)?ECMAScript 中的 Object 對象與 Java 中的 java.lang.Object 相似，ECMAScript 中的所有對象都由這個對象繼承而來，Object 對象中的所有屬性和方法都會出現(xiàn)在其他對象中，所以理解了 Object 對象，就可以更好地理解其他對象。

Object 對象具有下列屬性
constructor
對創(chuàng)建對象的函數(shù)的引用（指針）。對于 Object 對象，該指針指向原始的 Object() 函數(shù)。
Prototype
對該對象的對象原型的引用。對于所有的對象，它默認(rèn)返回 Object 對象的一個實(shí)例。

所有程序設(shè)計(jì)語言最重要的特征之一是具有進(jìn)行類型轉(zhuǎn)換的能力。
ECMAScript 給開發(fā)者提供了大量簡單的類型轉(zhuǎn)換方法。

toString()

parseInt()

parseFloat()