摘要：然后將構(gòu)造函數(shù)的原型設為，便實現(xiàn)了對象繼承。首先，我們定義一個構(gòu)造函數(shù)，并在其中定義一個局部變量。這里的是局部變量，其作用域仍然存在是閉包現(xiàn)象，而非對象屬性。

Javascript是動態(tài)的，弱類型的，解釋執(zhí)行的程序設計語言。

Javascript極其靈活，支持多種程序設計范式：面向?qū)ο?、指令式、函?shù)式。JavaSCript最初被用于瀏覽器腳本，現(xiàn)在已經(jīng)是所有主流瀏覽器的默認腳本語言。瀏覽器腳本的作用包括用戶交互、DOM操作、以及與服務器通信。Node.js的流行已經(jīng)將JavaScript從瀏覽器端引入到服務器端，并顯示出卓越的并發(fā)性能。

Javascript 由 Netscape 瀏覽器首次引入到Web文檔中。Javascript的出現(xiàn)使web文檔變得更像動態(tài)的App，而不是靜態(tài)的文檔?，F(xiàn)在主流的瀏覽器都有javascript支持。Javascript核心被標準化為ECMAScript。

JavaScript作為一門通用編程語言（general purpose），其語法、內(nèi)置對象、以及工具庫需要大量的精力才能掌握，但JavaScript有著直觀的語法，是一門非常容易上手的編程語言。本章中介紹JavaScript最基本的語法，然后編寫一個簡單的Javascript程序。

使用你喜歡的文本編輯器，建立一個javascript文件（后綴命名為.js即可），輸入以下的內(nèi)容：

console.log("Hello, world!")

console為多數(shù)JavaScript的宿主環(huán)境都會提供的全局對象，它的log方法用來輸出（到標準輸出）一個字符串。為了運行這段程序，可以打開Chrome瀏覽器的開發(fā)者工具（右上角的設置按鈕->更多工具->開發(fā)者工具），進入Console頁面。

拷貝這段代碼進去，按下回車，你會看到在控制臺的輸出：Hello, world!。

Javascript 是一門弱類型和動態(tài)類型的語言。弱類型意味著允許隱式類型轉(zhuǎn)換，不同類型的變量間可以直接賦值和運算；動態(tài)類型則意味著只在運行時才會進行類型檢查，于是包含錯誤的文件仍然能夠得到執(zhí)行，直到運行至包含類型錯誤的語句，JavaScript程序才異常退出。

Javascript中包含5種基本類型（primitive types）：

字符串（String）：其取值為字符序列。字符串可以用單引號或雙引號分隔，二者完全等價。

var str1 = "str1",
str2 = ""str1" is a string";

數(shù)字（Number）：它是實數(shù)？整數(shù)？無符號數(shù)？這些都不需要考慮！Javascript中，數(shù)字就是數(shù)字！

var n = 1;
n = n/3;    // 0.33333...

布爾類型（Boolean）：只有兩種取值：true, false。

空（Null）：該類型只有一個值可取，它就是null。在多數(shù)Javascript運行時中，null是一種特殊的object。

未定義（Undefined）：該類型也只有一個值可取，它就是undefined。有趣的是，你可以把一個變量聲明為未定義：

var foo = undefined;

除了基本數(shù)據(jù)類型，還有一種對象（object）類型，Object是JavaScript中所有其他對象的原型（如果你熟知Java等基于類繼承的語言，可以理解為Object是其他所有對象的公共父類）。日期、數(shù)組、函數(shù)都是JavaScript內(nèi)置的特殊對象。ECMAScript將對象定義為屬性的集合（Collection），創(chuàng)建一個對象的語法就像創(chuàng)建一個集合：

var student = {name: "小明", age: 23};

我們看到：

所有的變量都是以var聲明的，如果你忘記了寫var，那么這個變量將成為整個運行時的全局變量。

另外，Javascript與C++使用同樣的注釋風格，即/**/用于多行注釋，//用于單行注釋。

Javascript是面向?qū)ο蟮木幊陶Z言，對象是javascript中最重要的概念。上一節(jié)我們通過一對大括號創(chuàng)建了一個對象：

var student = {name: "小明", age: 23};

如果你熟悉構(gòu)造函數(shù)，JavaScript也支持這種方式：

function Student(name){
   this.name = name;
   this.age = 23;
}
var student = new Student("小明");
student.school = "PKU";

在Javascript中，通過this來訪問自己的屬性。有趣的是，訪問屬性前不需聲明：

如果直接讀取未聲明屬性，會得到undefined；

如果直接寫入未聲明屬性，則會聲明并用指定的值初始化該屬性。

如果你熟悉設計模式，你可能會需要這樣的對象創(chuàng)建方式：

function StudentFactory(_school){
    var school = _school;

    this.create = function(name, age){
        return {
            name: name,
            age : age,
            school: school
        }
    }
}
var factory = new StudentFactory("PKU");
var student = factory.create("小明", 23);

上述代碼中，首先聲明了一個工廠對象（function是一種特殊的對象），并用school來配置該工廠。此后用該工廠生產(chǎn)一個學生對象：小明。

現(xiàn)在，你已經(jīng)熟悉了Javascript中對象的創(chuàng)建。如果你曾開發(fā)過C++或者Java，你可能會關心Javascript中如何進行繼承，以及實現(xiàn)多態(tài)。

不錯，Javascript是面向?qū)ο笳Z言。但沒有類的聲明和實例化機制，Javascript使用原型繼承的方式（prototype）?？吹较旅娴睦右苍S就清楚了：

// file: prototype.js

var Person = {
    sayhi : function(){
        console.log("hi! I"m", this.name)
    }
};

function Student(name){
    this.name = name;
    this.school = "pku";
}
Student.prototype = Person;

var student = new Student("alice");

// hi! I"m alice
student.sayhi();

上述代碼中，首先聲明了Person對象，他有一個sayhi屬性，該屬性的值為function類型（還記得嗎？函數(shù)是一種特殊的對象）。然后將構(gòu)造函數(shù)Student的原型設為Person，便實現(xiàn)了對象繼承。

prototype對象是個模板，要實例化的對象都以這個模板為基礎（屬性和方法都被傳遞給那個類的所有實例）。prototype是可以傳遞的，最終形成原型鏈。

JavaScript 最令人感興趣的可能莫過于函數(shù)實際上是功能完整的對象，通過function來聲明函數(shù)。在JavaScript中的函數(shù)是一級公民，這意味著函數(shù)和其他變量一樣，可以被傳參、賦值、以及返回。函數(shù)有如下幾個默認屬性：

1.length：參數(shù)個數(shù)

 function func(arg1, arg2){}

 // 2
 console.log(func.length)

2.toString：這是所有對象共有的方法，將會輸出函數(shù)的源代碼

 // function func(arg1, arg2){}
 console.log(func.toString())

在函數(shù)體中，JavaScript提供了一個特殊對象 arguments，它是當前函數(shù)被調(diào)用時傳入的參數(shù)數(shù)組，通過訪問arguments不僅可以訪問所有實參，還可以獲得實參的數(shù)目，從而實現(xiàn)其他編程語言中可變參數(shù)的機制：

/ file: arguments.js

function sayHi(){
    if(arguments.length == 1)
        console.log("I"m", arguments[0]);
    if(arguments.length == 2)
        console.log("I"m", arguments[0], "aged", arguments[1]);
}
// I"m alice
sayHi("alice");
// I"m alice aged 23
sayHi("alice", 23);

Javascript并未提供函數(shù)重載、默認參數(shù)機制。但我們可以直接訪問arguments參數(shù)列表，sayHi其實模仿了函數(shù)重載。

call和apply是函數(shù)對象的兩個函數(shù)屬性，一般用于對象冒充、包裝或者代理?？赡茉诮虒W中不會用到太多，但在JS庫的開發(fā)中會經(jīng)常用到。這兩個函數(shù)的功能均為用一個對象去調(diào)用一個函數(shù)，而該函數(shù)并非該對象的屬性，例如：

// file: call.js
function sayHi(age){
    console.log("I"m", this.name, "aged", age)
}
var student = {
    name: "alice"
};
// I"m alice aged 23
sayHi.call(student, 23)

call的第一個參數(shù)是用作this的對象。其他參數(shù)都直接傳遞給函數(shù)自身。既然如此，如果我們希望實現(xiàn)一個自己的log函數(shù)，來包裝console.log：

// file: log.js
function log(){
    var str = "";
    for(var i = 0; i < arguments.length; i++){
        str += " " + arguments[i]
    }
    console.log(str);
}
// a b c
log("a", "b", "c");

這里我們不能使用call函數(shù)，因為我們不知道參數(shù)個數(shù)。這便是apply的用武之地：

// file: log.js
function log(){
    console.log.apply(this, arguments)
}
// a b c
log("a", "b", "c");

apply接受的第二個參數(shù)為參數(shù)數(shù)組，而非call的參數(shù)列表。這便為上述的情況提供了便利。

因Javascript最初運行于瀏覽器端，與服務器的通信必然要異步執(zhí)行（否則，將會阻塞主控制流，此時瀏覽器會不響應用戶操作）。于是，Javascript天生就是異步的，Node.js也是采用異步事件而大幅提高I/O密集型任務的效率。

異步是計算機在執(zhí)行任務的過程中，某些任務可以獨立于主控制流執(zhí)行，使得主控制流得以繼續(xù)執(zhí)行，是一種非阻塞的控制方案。

在Javascript中有多種異步的實現(xiàn)方案，它們無一例外地需要回調(diào)函數(shù)。回調(diào)函數(shù)就是將函數(shù)作為參數(shù)傳遞到其他代碼（例如：某一個異步任務），這一設計允許了該異步任務完成時執(zhí)行傳入的函數(shù)。例如：

// file: async.js
function taskFinished(){
    console.log("Task finished!")
}
setTimeout(taskFinished, 3000);

上述代碼中，首先定義了一個任務完成時需要執(zhí)行的函數(shù)taskFinished。setTimeout是Javascript提供的一個全局對象（還記得嗎？函數(shù)是一種特殊的對象），它是一個計時器，在到達指定的時間后調(diào)用某個函數(shù)。上述例子中，在5000毫秒后運行taskFinished函數(shù)。

Javascript的變量作用域不同于其他的主流編程語言。包括變量的定義方式、作用域的劃分、作用持續(xù)時間等。

在javascript中使用賦值語句即可定義一個對象，而不需要對象聲明（也不需要指定變量的類型）。使用var可以定義局部變量，而省略var則可以定義全局變量。例如：

// 定義局部變量 foo
var foo = "bar"

// 定義全局變量 bar
bar = "foo

上述的全局變量作用域不是當前對象，也不是當前文件，而是整個運行時進程！實際項目中，應盡量避免引入全局變量。眾所周知，全局變量會使得代碼高度耦合、難以復用和維護、復雜化團隊協(xié)作。

那么，局部變量的作用域是怎樣的呢？局部作用域即當前函數(shù)，不同于C++或Java的當前代碼塊（以大括號分隔）。正因為javascript的這一點特殊性質(zhì)，引出了javascript中的一個重要概念：閉包（closure）。閉包是指是引用了自由變量的函數(shù)。這個被引用的自由變量將和這個函數(shù)一同存在，即使已經(jīng)離開了它最初被創(chuàng)建的環(huán)境。

閉包之所以如此重要，是因為它完成了javascript的諸多面向?qū)ο筇匦裕?strong>數(shù)據(jù)封裝、運行時多態(tài)。我們看一個閉包：

// file: closure.js
function Count(){
    var num=0;
    this.add = function(){
        console.log(num++);
    }
}
var c = new Count();
c.add();
c.add();

Count是函數(shù)，而函數(shù)是對象，對象可以有屬性和方法。add是方法屬性（類型為方法的屬性），而num則只是函數(shù)的局部變量。

首先，我們定義一個構(gòu)造函數(shù)Count，并在其中定義一個局部變量num。接著，我們調(diào)用該構(gòu)造函數(shù)創(chuàng)建一個對象c，并調(diào)用兩次它的add方法。不出所料，程序的輸出將是：

0
1

你可能已經(jīng)注意到：第二次調(diào)用add方法時，add中引用的num仍然保持著上次調(diào)用后的值。事實上，num是被add方法引用的一個自由變量，其作用域會一直跟隨add而存在。

不要混淆局部變量和對象屬性。這里的num是局部變量，其作用域仍然存在是閉包現(xiàn)象，而非對象屬性。對象屬性需要用this關鍵字來定義。

如果你希望進一步學習Javascript，Mozilla Developer和W3C School: Javascript教程都提供了很好文檔。如果你愿意深究Javascript語法規(guī)則，請參考ECMAScript標準：ECMAScript-262。

本文由Harttle創(chuàng)作，轉(zhuǎn)載需署名作者且注明文章出處