一、AJAX裏面status的值表明什麼 二、get post 的區別 三、怎樣把對象轉化成字符串 四、閉包、繼承、原型、原型鏈 5 、http傳輸協議 六、arguments是什麼
一、AJAX裏面status的值表明什麼 javascript
在JavaScript裏面寫AJax的時，最關鍵的一步是對XMLHttpRequest對象創建監聽，即便用「onreadystatechange」方法。監聽的時候，要對XMLHttpRequest對象的請求狀態進行判斷，一般是判斷readyState的值爲4且status的值爲200或者304時執行咱們須要的操做。如下記錄了一些經常使用readState以及status的值及其含義html
readyState 屬性表示Ajax請求的當前狀態。它的值用數字表明。
0 表明未初始化。 尚未調用 open 方法
1 表明正在加載。 open 方法已被調用，但 send 方法尚未被調用
2 表明已加載完畢。send 已被調用。請求已經開始
3 表明交互中。服務器正在發送響應
4 表明完成。響應發送完畢java
經常使用狀態碼（status）及其含義：數據庫
404 沒找到頁面(not found)
403 禁止訪問(forbidden)
500 內部服務器出錯(internal service error)
200 一切正常(ok)
304 沒有被修改(not modified)(服務器返回304狀態，表示源文件沒有被修改 )瀏覽器
二、get post 的區別 緩存
Http定義了與服務器交互的不一樣方法，最基本的方法有4種，分別是GET，POST，PUT，DELETE。URL全稱是資源描述符，咱們能夠這樣認爲：一個URL地址，它用於描述一個網絡上的資源，而HTTP中的GET，POST，PUT，DELETE就對應着對這個資源的查，改，增，刪4個操做。到這裏，你們應該有個大概的瞭解了，GET通常用於獲取/查詢資源信息，而POST通常用於更新資源信息。安全
1.根據HTTP規範，GET用於信息獲取，並且應該是安全的和冪等的。服務器
(1).所謂安全的意味着該操做用於獲取信息而非修改信息。換句話說，GET 請求通常不該產生反作用。就是說，它僅僅是獲取資源信息，就像數據庫查詢同樣，不會修改，增長數據，不會影響資源的狀態。網絡
* 注意：這裏安全的含義僅僅是指是非修改信息。閉包
(2).冪等的意味着對同一URL的多個請求應該返回一樣的結果。這裏我再解釋一下冪等這個概念：
冪等有一下幾種定義：
對於單目運算，若是一個運算對於在範圍內的全部的一個數屢次進行該運算所得的結果和進行一次該運算所得的結果是同樣的，那麼咱們就稱該運算是冪等的。好比絕對值運算就是一個例子，在實數集中，有abs(a)=abs(abs(a))。
對於雙目運算，則要求當參與運算的兩個值是等值的狀況下，若是知足運算結果與參與運算的兩個值相等，則稱該運算冪等，如求兩個數的最大值的函數，有在在實數集中冪等，即max(x,x) = x。
看完上述解釋後，應該能夠理解GET冪等的含義了。
但在實際應用中，以上2條規定並無這麼嚴格。引用別人文章的例子：好比，新聞站點的頭版不斷更新。雖然第二次請求會返回不一樣的一批新聞，該操做仍然被認爲是安全的和冪等的，由於它老是返回當前的新聞。從根本上說，若是目標是當用戶打開一個連接時，他能夠確信從自身的角度來看沒有改變資源便可。
2.根據HTTP規範，POST表示可能修改變服務器上的資源的請求。繼續引用上面的例子：仍是新聞以網站爲例，讀者對新聞發表本身的評論應該經過POST實現，由於在評論提交後站點的資源已經不一樣了，或者說資源被修改了。
上面大概說了一下HTTP規範中GET和POST的一些原理性的問題。但在實際的作的時候，不少人卻沒有按照HTTP規範去作，致使這個問題的緣由有不少，好比說：
1.不少人貪方便，更新資源時用了GET，由於用POST必需要到FORM（表單），這樣會麻煩一點。
2.對資源的增，刪，改，查操做，其實均可以經過GET/POST完成，不須要用到PUT和DELETE。
3.另一個是，早期的Web MVC框架設計者們並無有意識地將URL看成抽象的資源來看待和設計，因此致使一個比較嚴重的問題是傳統的Web MVC框架基本上都只支持GET和POST兩種HTTP方法，而不支持PUT和DELETE方法。
* 簡單解釋一下MVC：MVC原本是存在於Desktop程序中的，M是指數據模型，V是指用戶界面，C則是控制器。使用MVC的目的是將M和V的實現代碼分離，從而使同一個程序能夠使用不一樣的表現形式。
以上3點典型地描述了老一套的風格（沒有嚴格遵照HTTP規範），隨着架構的發展，如今出現REST(Representational State Transfer)，一套支持HTTP規範的新風格，這裏很少說了，能夠參考《RESTful Web Services》。
說完原理性的問題，咱們再從表面現像上面看看GET和POST的區別：
1.GET請求的數據會附在URL以後（就是把數據放置在HTTP協議頭中），以?分割URL和傳輸數據，參數之間以&相連，如：login.action?name=hyddd&password=idontknow&verify=%E4%BD%A0%E5%A5%BD。若是數據是英文字母/數字，原樣發送，若是是空格，轉換爲+，若是是中文/其餘字符，則直接把字符串用BASE64加密，得出如：%E4%BD%A0%E5%A5%BD，其中％XX中的XX爲該符號以16進製表示的ASCII。
POST把提交的數據則放置在是HTTP包的包體中。
2."GET方式提交的數據最多隻能是1024字節，理論上POST沒有限制，可傳較大量的數據，IIS4中最大爲80KB，IIS5中爲100KB"？？！
以上這句是我從其餘文章轉過來的，其實這樣說是錯誤的，不許確的：
(1).首先是"GET方式提交的數據最多隻能是1024字節"，由於GET是經過URL提交數據，那麼GET可提交的數據量就跟URL的長度有直接關係了。而實際上，URL不存在參數上限的問題，HTTP協議規範沒有對URL長度進行限制。這個限制是特定的瀏覽器及服務器對它的限制。IE對URL長度的限制是2083字節(2K+35)。對於其餘瀏覽器，如Netscape、FireFox等，理論上沒有長度限制，其限制取決於操做系統的支持。
注意這是限制是整個URL長度，而不只僅是你的參數值數據長度。[見參考資料5]
(2).理論上講，POST是沒有大小限制的，HTTP協議規範也沒有進行大小限制，說「POST數據量存在80K/100K的大小限制」是不許確的，POST數據是沒有限制的，起限制做用的是服務器的處理程序的處理能力。
對於ASP程序，Request對象處理每一個表單域時存在100K的數據長度限制。但若是使用Request.BinaryRead則沒有這個限制。
由這個延伸出去，對於IIS 6.0，微軟出於安全考慮，加大了限制。咱們還須要注意：
1).IIS 6.0默認ASP POST數據量最大爲200KB，每一個表單域限制是100KB。
2).IIS 6.0默認上傳文件的最大大小是4MB。
3).IIS 6.0默認最大請求頭是16KB。
IIS 6.0以前沒有這些限制。[見參考資料5]
因此上面的80K，100K可能只是默認值而已(注：關於IIS4和IIS5的參數，我尚未確認)，但確定是能夠本身設置的。因爲每一個版本的IIS對這些參數的默認值都不同，具體請參考相關的IIS配置文檔。
3.在ASP中，服務端獲取GET請求參數用Request.QueryString，獲取POST請求參數用Request.Form。在JSP中，用request.getParameter(\"XXXX\")來獲取，雖然jsp中也有request.getQueryString()方法，但使用起來比較麻煩，好比：傳一個test.jsp?name=hyddd&password=hyddd，用request.getQueryString()獲得的是：name=hyddd&password=hyddd。在PHP中，能夠用$_GET和$_POST分別獲取GET和POST中的數據，而$_REQUEST則能夠獲取GET和POST兩種請求中的數據。值得注意的是，JSP中使用request和PHP中使用$_REQUEST都會有隱患，這個下次再寫個文章總結。
4.POST的安全性要比GET的安全性高。注意：這裏所說的安全性和上面GET提到的「安全」不是同個概念。上面「安全」的含義僅僅是不做數據修改，而這裏安全的含義是真正的Security的含義，好比：經過GET提交數據，用戶名和密碼將明文出如今URL上，由於(1)登陸頁面有可能被瀏覽器緩存，(2)其餘人查看瀏覽器的歷史紀錄，那麼別人就能夠拿到你的帳號和密碼了，除此以外，使用GET提交數據還可能會形成Cross-site request forgery攻擊。
總結一下，Get是向服務器發索取數據的一種請求，而Post是向服務器提交數據的一種請求，在FORM（表單）中，Method默認爲"GET"，實質上，GET和POST只是發送機制不一樣，並非一個取一個發！
三、怎樣把對象轉化成字符串
1、採用Object.toString()
toString方法是java.lang.Object對象的一個public方法。在java中任何對象都會繼承Object對象，因此通常來講任何對象均可以調用toString這個方法。這是採用該種方法時，常派生類會覆蓋Object裏的toString()方法。
可是在使用該方法時要注意，必須保證Object不是null值，不然將拋出NullPointerException異常。
2、採用(String)Object
該方法是一個標準的類型轉換的方法，能夠將Object轉換爲String。可是在使用該方法是要注意的是須要轉換的類型必須是可以轉換爲String的，不然會出現CalssCastException異常錯誤。
String string = (String)o;
這段程序代碼會出現java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String。由於將Integer類型強制轉換爲String類型，沒法經過。
3、String.valueOf(Object)
上面咱們使用Object.toString()方法時須要擔憂null問題。可是使用該方法無需擔憂null值問題。由於在使用String.valueOf(Object)時，它會判斷Object是否爲空值，若是是，則返回null。下面爲String.valueOf(Object)的源碼：
return (obj == null) ? "null" : obj.toString();
}
從上面咱們能夠看出兩點：一是不須要擔憂null問題。二是它是以toString()方法爲基礎的。
可是必定要注意：當object爲null時，String.valueOf（object）的值是字符串對象："null"，而不是null
四、閉包、繼承、原型、原型鏈
1、原型、原型鏈
原型對象
在JavaScript 中，每當定義一個對象（函數）時候，對象中都會包含一些預約義的屬性。其中函數對象的一個屬性就是原型對象 prototype。注：普通對象沒有prototype,但有__proto__屬性。
原型對象其實就是普通對象（Function.prototype除外,它是函數對象，但它很特殊，他沒有prototype屬性（前面說道函數對象都有prototype屬性））。看下面的例子：
function f1(){};
console.log(f1.prototype) //f1{}
console.log(typeof f1. prototype) //Object
console.log(typeof Function.prototype) // Function，這個特殊
console.log(typeof Object.prototype) // Object
console.log(typeof Function.prototype.prototype) //undefined
從這句console.log(f1.prototype) //f1 {} 的輸出就結果能夠看出，f1.prototype就是f1的一個實例對象。就是在f1建立的時候,建立了一個它的實例對象並賦值給它的prototype，基本過程以下：
var temp = new f1();
f1. prototype = temp;
因此，Function.prototype爲何是函數對象就迎刃而解了，上文提到凡是new Function ()產生的對象都是函數對象，因此temp1是函數對象。
var temp1 = new Function ();
Function.prototype = temp1;
那原型對象是用來作什麼的呢？主要做用是用於繼承。舉了例子：
var person = function(name){
this.name = name
};
person.prototype.getName = function(){
return this.name;
}
var zjh = new person(‘zhangjiahao’);
zjh.getName(); //zhangjiahao
從這個例子能夠看出，經過給person.prototype設置了一個函數對象的屬性，那有person實例（例中：zjh）出來的普通對象就繼承了這個屬性。具體是怎麼實現的繼承，就要講到下面的原型鏈了。
三．原型鏈
JS在建立對象（不管是普通對象仍是函數對象）的時候，都有一個叫作__proto__的內置屬性，用於指向建立它的函數對象的原型對象prototype。以上面的例子爲例：
console.log(zjh.__proto__ === person.prototype) //true
一樣，person.prototype對象也有__proto__屬性，它指向建立它的函數對象（Object）的prototype
console.log(person.prototype.__proto__ === Object.prototype) //true
繼續，Object.prototype對象也有__proto__屬性，但它比較特殊，爲null
console.log(Object.prototype.__proto__) //null
咱們把這個有__proto__串起來的直到Object.prototype.__proto__爲null的鏈叫作原型鏈。以下圖：
四．內存結構圖
爲了更加深刻和直觀的進行理解，下面咱們畫一下上面的內存結構圖：
畫圖約定：
疑點解釋：
1.Object.__proto__ === Function.prototype // true
Object是函數對象，是經過new Function()建立，因此Object.__proto__指向Function.prototype。
2.Function.__proto__ === Function.prototype // true
Function 也是對象函數，也是經過new Function()建立，因此Function.__proto__指向Function.prototype。
本身是由本身建立的，好像不符合邏輯，但仔細想一想，現實世界也有些相似，你是怎麼來的，你媽生的，你媽怎麼來的，你姥姥生的，……類人猿進化來的，那類人猿從哪來，一直追溯下去……，就是無，（NULL生萬物）
正如《道德經》裏所說「無，名天地之始」。
3.Function.prototype.__proto__ === Object.prototype //true
其實這一點我也有點困惑，不過也能夠試着解釋一下。
Function.prototype是個函數對象，理論上他的__proto__應該指向 Function.prototype，就是他本身，本身指向本身，沒有意義。
JS一直強調萬物皆對象，函數對象也是對象，給他認個祖宗，指向Object.prototype。Object.prototype.__proto__ === null，保證原型鏈可以正常結束。
五．constructor
原型對象prototype中都有個預約義的constructor屬性，用來引用它的函數對象。這是一種循環引用
person.prototype.constructor === person //true
Function.prototype.constructor === Function //true
Object.prototype.constructor === Object //true
完善下上面的內存結構圖：
有兩點須要注意：
（1）注意Object.constructor===Function；//true 自己Object就是Function函數構造出來的
（2）如何查找一個對象的constructor，就是在該對象的原型鏈上尋找碰到的第一個constructor屬性所指向的對象
六．總結
1.原型和原型鏈是JS實現繼承的一種模型。
2.原型鏈的造成是真正是靠__proto__ 而非prototype
2、閉包
1、什麼是閉包？
官方」的解釋是：閉包是一個擁有許多變量和綁定了這些變量的環境的表達式（一般是一個函數），於是這些變量也是該表達式的一部分。
相信不多有人能直接看懂這句話，由於他描述的太學術。其實這句話通俗的來講就是：JavaScript中全部的function都是一個閉包。不過通常來講，嵌套的function所產生的閉包更爲強大，也是大部分時候咱們所謂的「閉包」。看下面這段代碼：
function a() {
var i = 0;
function b() { alert(++i); }
return b;
}
var c = a();
c();
這段代碼有兩個特色：
一、函數b嵌套在函數a內部；
二、函數a返回函數b。
引用關係如圖：
這樣在執行完var c=a()後，變量c其實是指向了函數b，再執行c()後就會彈出一個窗口顯示i的值(第一次爲1)。這段代碼其實就建立了一個閉包，爲何？由於函數a外的變量c引用了函數a內的函數b，就是說：
當函數a的內部函數b被函數a外的一個變量引用的時候，就建立了一個閉包。
讓咱們說的更透徹一些。所謂「閉包」，就是在構造函數體內定義另外的函數做爲目標對象的方法函數，而這個對象的方法函數反過來引用外層函數體中的臨時變量。這使得只要目標 對象在生存期內始終能保持其方法，就能間接保持原構造函數體當時用到的臨時變量值。儘管最開始的構造函數調用已經結束，臨時變量的名稱也都消失了，但在目 標對象的方法內卻始終能引用到該變量的值，並且該值只能通這種方法來訪問。即便再次調用相同的構造函數，但只會生成新對象和方法，新的臨時變量只是對應新 的值，和上次那次調用的是各自獨立的。
2、閉包有什麼做用？
簡而言之，閉包的做用就是在a執行完並返回後，閉包使得Javascript的垃圾回收機制GC不會收回a所佔用的資源，由於a的內部函數b的執行須要依賴a中的變量。這是對閉包做用的很是直白的描述，不專業也不嚴謹，但大概意思就是這樣，理解閉包須要按部就班的過程。
在上面的例子中，因爲閉包的存在使得函數a返回後，a中的i始終存在，這樣每次執行c()，i都是自加1後alert出i的值。
那 麼咱們來想象另外一種狀況，若是a返回的不是函數b，狀況就徹底不一樣了。由於a執行完後，b沒有被返回給a的外界，只是被a所引用，而此時a也只會被b引 用，所以函數a和b互相引用但又不被外界打擾(被外界引用)，函數a和b就會被GC回收。(關於Javascript的垃圾回收機制將在後面詳細介紹)
3、閉包內的微觀世界
若是要更加深刻的瞭解閉包以及函數a和嵌套函數b的關係，咱們須要引入另外幾個概念：函數的執行環境(excution context)、活動對象(call object)、做用域(scope)、做用域鏈(scope chain)。以函數a從定義到執行的過程爲例闡述這幾個概念。
- 當定義函數a的時候，js解釋器會將函數a的做用域鏈(scope chain)設置爲定義a時a所在的「環境」，若是a是一個全局函數，則scope chain中只有window對象。
- 當執行函數a的時候，a會進入相應的執行環境(excution context)。
- 在建立執行環境的過程當中，首先會爲a添加一個scope屬性，即a的做用域，其值就爲第1步中的scope chain。即a.scope=a的做用域鏈。
- 而後執行環境會建立一個活動對象(call object)。活動對象也是一個擁有屬性的對象，但它不具備原型並且不能經過JavaScript代碼直接訪問。建立完活動對象後，把活動對象添加到a的做用域鏈的最頂端。此時a的做用域鏈包含了兩個對象：a的活動對象和window對象。
- 下一步是在活動對象上添加一個arguments屬性，它保存着調用函數a時所傳遞的參數。
- 最後把全部函數a的形參和內部的函數b的引用也添加到a的活動對象上。在這一步中，完成了函數b的的定義，所以如同第3步，函數b的做用域鏈被設置爲b所被定義的環境，即a的做用域。
到此，整個函數a從定義到執行的步驟就完成了。此時a返回函數b的引用給c，又函數b的做用域鏈包含了對函數a的活動對象的引用，也就是說b能夠訪問到a中定義的全部變量和函數。函數b被c引用，函數b又依賴函數a，所以函數a在返回後不會被GC回收。
當函數b執行的時候亦會像以上步驟同樣。所以，執行時b的做用域鏈包含了3個對象：b的活動對象、a的活動對象和window對象，以下圖所示：
如圖所示，當在函數b中訪問一個變量的時候，搜索順序是：
- 先搜索自身的活動對象，若是存在則返回，若是不存在將繼續搜索函數a的活動對象，依次查找，直到找到爲止。
- 若是函數b存在prototype原型對象，則在查找完自身的活動對象後先查找自身的原型對象，再繼續查找。這就是Javascript中的變量查找機制。
- 若是整個做用域鏈上都沒法找到，則返回undefined。
小結，本段中提到了兩個重要的詞語：函數的定義與執行。文中提到函數的做用域是在定義函數時候就已經肯定，而不是在執行的時候肯定（參看步驟1和3）。用一段代碼來講明這個問題：
function f(x) {
var g = function () { return x; }
return g;
}
var h = f(1);
alert(h());
這段代碼中變量h指向了f中的那個匿名函數(由g返回)。
- 假設函數h的做用域是在執行alert(h())肯定的，那麼此時h的做用域鏈是：h的活動對象->alert的活動對象->window對象。
- 假設函數h的做用域是在定義時肯定的，就是說h指向的那個匿名函數在定義的時候就已經肯定了做用域。那麼在執行的時候，h的做用域鏈爲：h的活動對象->f的活動對象->window對象。
若是第一種假設成立，那輸出值就是undefined；若是第二種假設成立，輸出值則爲1。
運行結果證實了第2個假設是正確的，說明函數的做用域確實是在定義這個函數的時候就已經肯定了。
4、閉包的應用場景
保護函數內的變量安全。以最開始的例子爲例，函數a中i只有函數b才能訪問，而沒法經過其餘途徑訪問到，所以保護了i的安全性。
- 在內存中維持一個變量。依然如前例，因爲閉包，函數a中i的一直存在於內存中，所以每次執行c()，都會給i自加1。
- 經過保護變量的安全實現JS私有屬性和私有方法（不能被外部訪問）
私有屬性和方法在Constructor外是沒法被訪問的function Constructor(...) {
var that = this;
var membername = value;
function membername(...) {...}
}
以上3點是閉包最基本的應用場景，不少經典案例都源於此。
3、繼承
JS繼承的實現方式
既然要實現繼承，那麼首先咱們得有一個父類，代碼以下：
// 定義一個動物類
function Animal (name) {
// 屬性
this.name = name || 'Animal';
// 實例方法
this.sleep = function(){
console.log(this.name + '正在睡覺！');
}
}
// 原型方法
Animal.prototype.eat = function(food) {
console.log(this.name + '正在吃：' + food);
};
一、原型鏈繼承
核心： 將父類的實例做爲子類的原型
function Cat(){
}
Cat.prototype = new Animal();
Cat.prototype.name = 'cat';
// Test Code
var cat = new Cat();
console.log(cat.name);
console.log(cat.eat('fish'));
console.log(cat.sleep());
console.log(cat instanceof Animal); //true
console.log(cat instanceof Cat); //true
特色：
- 很是純粹的繼承關係，實例是子類的實例，也是父類的實例
- 父類新增原型方法/原型屬性，子類都能訪問到
- 簡單，易於實現
缺點：
- 要想爲子類新增屬性和方法，必需要在
new Animal()這樣的語句以後執行，不能放到構造器中 - 沒法實現多繼承
- 來自原型對象的引用屬性是全部實例共享的（詳細請看附錄代碼： 示例1）
- 建立子類實例時，沒法向父類構造函數傳參
二、構造繼承
核心：使用父類的構造函數來加強子類實例，等因而複製父類的實例屬性給子類（沒用到原型）
function Cat(name){
Animal.call(this);
this.name = name || 'Tom';
}
// Test Code
var cat = new Cat();
console.log(cat.name);
console.log(cat.sleep());
console.log(cat instanceof Animal); // false
console.log(cat instanceof Cat); // true
特色：
- 解決了1中，子類實例共享父類引用屬性的問題
- 建立子類實例時，能夠向父類傳遞參數
- 能夠實現多繼承（call多個父類對象）
缺點：
- 實例並非父類的實例，只是子類的實例
- 只能繼承父類的實例屬性和方法，不能繼承原型屬性/方法
- 沒法實現函數複用，每一個子類都有父類實例函數的副本，影響性能
三、實例繼承
核心：爲父類實例添加新特性，做爲子類實例返回
function Cat(name){
var instance = new Animal();
instance.name = name || 'Tom';
return instance;
}
// Test Code
var cat = new Cat();
console.log(cat.name);
console.log(cat.sleep());
console.log(cat instanceof Animal); // true
console.log(cat instanceof Cat); // false
特色：
- 不限制調用方式，無論是
new 子類()仍是子類(),返回的對象具備相同的效果
缺點：
- 實例是父類的實例，不是子類的實例
- 不支持多繼承
四、拷貝繼承
function Cat(name){
var animal = new Animal();
for(var p in animal){
Cat.prototype[p] = animal[p];
}
Cat.prototype.name = name || 'Tom';
}
// Test Code
var cat = new Cat();
console.log(cat.name);
console.log(cat.sleep());
console.log(cat instanceof Animal); // false
console.log(cat instanceof Cat); // true
特色：
- 支持多繼承
缺點：
- 效率較低，內存佔用高（由於要拷貝父類的屬性）
- 沒法獲取父類不可枚舉的方法（不可枚舉方法，不能使用for in 訪問到）
五、組合繼承
核心：經過調用父類構造，繼承父類的屬性並保留傳參的優勢，而後經過將父類實例做爲子類原型，實現函數複用
function Cat(name){
Animal.call(this);
this.name = name || 'Tom';
}
Cat.prototype = new Animal();
// Test Code
var cat = new Cat();
console.log(cat.name);
console.log(cat.sleep());
console.log(cat instanceof Animal); // true
console.log(cat instanceof Cat); // true
特色：
- 彌補了方式2的缺陷，能夠繼承實例屬性/方法，也能夠繼承原型屬性/方法
- 既是子類的實例，也是父類的實例
- 不存在引用屬性共享問題
- 可傳參
- 函數可複用
缺點：
- 調用了兩次父類構造函數，生成了兩份實例（子類實例將子類原型上的那份屏蔽了）
六、寄生組合繼承
核心：經過寄生方式，砍掉父類的實例屬性，這樣，在調用兩次父類的構造的時候，就不會初始化兩次實例方法/屬性，避免的組合繼承的缺點
function Cat(name){
Animal.call(this);
this.name = name || 'Tom';
}
(function(){
// 建立一個沒有實例方法的類
var Super = function(){};
Super.prototype = Animal.prototype;
//將實例做爲子類的原型
Cat.prototype = new Super();
})();
// Test Code
var cat = new Cat();
console.log(cat.name);
console.log(cat.sleep());
console.log(cat instanceof Animal); // true
console.log(cat instanceof Cat); //true
特色：
- 堪稱完美
缺點：
- 實現較爲複雜
5 、http傳輸協議
http
http技術架構
http協議功能
http協議基礎
http通用頭域
http請求消息
http響應消息
http實體信息
http運做方式
http報文格式
http工做原理
http狀態消息
|
消息
|
描述
|
|---|---|
|
100 Continue
|
服務器僅接收到部分請求，可是一旦服務器並無拒絕該請求，客戶端應該繼續發送其他的請求。
|
|
101 Switching Protocols
|
服務器轉換協議：服務器將聽從客戶的請求轉換到另一種協議。
|
|
消息
|
描述
|
|---|---|
|
200 OK
|
請求成功（其後是對GET和POST請求的應答文檔。）
|
|
201 Created
|
請求被建立完成，同時新的資源被建立。
|
|
202 Accepted
|
供處理的請求已被接受，可是處理未完成。
|
|
203 Non-authoritative Information
|
文檔已經正常地返回，但一些應答頭可能不正確，由於使用的是文檔的拷貝。
|
|
204 No Content
|
沒有新文檔。瀏覽器應該繼續顯示原來的文檔。若是用戶按期地刷新頁面，而Servlet能夠肯定用戶文檔足夠新，這個狀態代碼是頗有用的。
|
|
205 Reset Content
|
沒有新文檔。但瀏覽器應該重置它所顯示的內容。用來強制瀏覽器清除表單輸入內容。
|
|
206 Partial Content
|
客戶發送了一個帶有Range頭的GET請求，服務器完成了它。
|
|
消息
|
描述
|
|---|---|
|
300 Multiple Choices
|
多重選擇。連接列表。用戶能夠選擇某連接到達目的地。最多容許五個地址。
|
|
301 Moved Permanently
|
所請求的頁面已經轉移至新的url。
|
|
302 Found
|
所請求的頁面已經臨時轉移至新的url。
|
|
303 See Other
|
所請求的頁面可在別的url下被找到。
|
|
304 Not Modified
|
未按預期修改文檔。客戶端有緩衝的文檔併發出了一個條件性的請求（通常是提供If-Modified-Since頭表示客戶只想比指定日期更新的文檔）。服務器告訴客戶，原來緩衝的文檔還能夠繼續使用。
|
|
305 Use Proxy
|
客戶請求的文檔應該經過Location頭所指明的代理服務器提取。
|
|
306
Unused
|
此代碼被用於前一版本。目前已再也不使用，可是代碼依然被保留。
|
|
307 Temporary Redirect
|
被請求的頁面已經臨時移至新的url。
|
|
消息
|
描述
|
|---|---|
|
400 Bad Request
|
服務器未能理解請求。
|
|
401 Unauthorized
|
被請求的頁面須要用戶名和密碼。
|
|
401.1
|
登陸失敗。
|
|
401.2
|
服務器配置致使登陸失敗。
|
|
401.3
|
因爲 ACL 對資源的限制而未得到受權。
|
|
401.4
|
篩選器受權失敗。
|
|
401.5
|
ISAPI/CGI 應用程序受權失敗。
|
|
401.7
|
訪問被 Web 服務器上的 URL 受權策略拒絕。這個錯誤代碼爲 IIS 6.0 所專用。
|
|
402 Payment Required
|
此代碼尚沒法使用。
|
|
403 Forbidden
|
對被請求頁面的訪問被禁止。
|
|
403.1
|
執行訪問被禁止。
|
|
403.2
|
讀訪問被禁止。
|
|
403.3
|
寫訪問被禁止。
|
|
403.4
|
要求 SSL。
|
|
403.5
|
要求 SSL 128。
|
|
403.6
|
IP 地址被拒絕。
|
|
403.7
|
要求客戶端證書。
|
|
403.8
|
站點訪問被拒絕。
|
|
403.9
|
用戶數過多。
|
|
403.10
|
配置無效。
|
|
403.11
|
密碼更改。
|
|
403.12
|
拒絕訪問映射表。
|
|
403.13
|
客戶端證書被吊銷。
|
|
403.14
|
拒絕目錄列表。
|
|
403.15
|
超出客戶端訪問許可。
|
|
403.16
|
客戶端證書不受信任或無效。
|
|
403.17
|
客戶端證書已過時或還沒有生效。
|
|
403.18
|
在當前的應用程序池中不能執行所請求的 URL。這個錯誤代碼爲 IIS 6.0 所專用。
|
|
403.19
|
不能爲這個應用程序池中的客戶端執行 CGI。這個錯誤代碼爲 IIS 6.0 所專用。
|
|
403.20
|
Passport 登陸失敗。這個錯誤代碼爲 IIS 6.0 所專用。
|
|
404 Not Found
|
服務器沒法找到被請求的頁面。
|
|
404.0
|
（無）–沒有找到文件或目錄。
|
|
404.1
|
沒法在所請求的端口上訪問 Web 站點。
|
|
404.2
|
Web 服務擴展鎖定策略阻止本請求。
|
|
404.3
|
MIME 映射策略阻止本請求。
|
|
405 Method Not Allowed
|
請求中指定的方法不被容許。
|
|
406 Not Acceptable
|
服務器生成的響應沒法被客戶端所接受。
|
|
407 Proxy Authentication Required
|
用戶必須首先使用代理服務器進行驗證，這樣請求才會被處理。
|
|
408 Request Timeout
|
請求超出了服務器的等待時間。
|
|
409 Conflict
|
因爲衝突，請求沒法被完成。
|
|
410 Gone
|
被請求的頁面不可用。
|
|
411 Length Required
|
"Content-Length" 未被定義。若是無此內容，服務器不會接受請求。
|
|
412 Precondition Failed
|
請求中的前提條件被服務器評估爲失敗。
|
|
413 Request Entity Too Large
|
因爲所請求的實體的太大，服務器不會接受請求。
|
|
414 Request-url Too Long
|
因爲url太長，服務器不會接受請求。當post請求被轉換爲帶有很長的查詢信息的get請求時，就會發生這種狀況。
|
|
415 Unsupported Media Type
|
因爲媒介類型不被支持，服務器不會接受請求。
|
|
416 Requested Range Not Satisfiable
|
服務器不能知足客戶在請求中指定的Range頭。
|
|
417 Expectation Failed
|
執行失敗。
|
|
423
|
鎖定的錯誤。
|
|
消息
|
描述
|
|---|---|
|
500 Internal Server Error
|
請求未完成。服務器遇到不可預知的狀況。
|
|
500.12
|
應用程序正忙於在 Web 服務器上從新啓動。
|
|
500.13
|
Web 服務器太忙。
|
|
500.15
|
不容許直接請求 Global.asa。
|
|
500.16
|
UNC 受權憑據不正確。這個錯誤代碼爲 IIS 6.0 所專用。
|
|
500.18
|
URL 受權存儲不能打開。這個錯誤代碼爲 IIS 6.0 所專用。
|
|
500.100
|
內部 ASP 錯誤。
|
|
501 Not Implemented
|
請求未完成。服務器不支持所請求的功能。
|
|
502 Bad Gateway
|
請求未完成。服務器從上游服務器收到一個無效的響應。
|
|
502.1
|
CGI 應用程序超時。 ·
|
|
502.2
|
CGI 應用程序出錯。
|
|
503 Service Unavailable
|
請求未完成。服務器臨時過載或當機。
|
|
504 Gateway Timeout
|
網關超時。
|
|
505 HTTP Version Not Supported
|
服務器不支持請求中指明的HTTP協議版本。
|
http版本歷史
六、arguments是什麼
JavaScript arguments對象
一、在JavaScript中，arguments對象是比較特別的一個對象，其實是當前函數的一個內置屬性。arguments很是相似Array，但實際上又不是一個Array實例。能夠經過以下代碼得以證明（固然，實際上，在函數funcArg中，調用arguments是沒必要要寫成funcArg.arguments，直接寫arguments便可）。
1 Array.prototype.testArg = "test";
2 function funcArg() {
3 alert(funcArg.arguments.testArg);
4 alert(funcArg.arguments[0]);
5 }
6
7 alert(new Array().testArg); // result: "test"
8 funcArg(10); // result: "undefined" "10"
二、arguments對象的長度是由實參個數而不是形參個數決定的。形參是函數內部從新開闢內存空間存儲的變量，可是其與arguments對象內存空間並不重疊。對於arguments和值都存在的狀況下，二者值是同步的，可是針對其中一個無值的狀況下，對於此無值的情形值不會得以同步。以下代碼能夠得以驗證。
1 function f(a, b, c){
2 alert(arguments.length); // result: "2"
3 a = 100;
4 alert(arguments[0]); // result: "100"
5 arguments[0] = "qqyumidi";
6 alert(a); // result: "qqyumidi"
7 alert(c); // result: "undefined"
8 c = 2012;
9 alert(arguments[2]); // result: "undefined"
10 }
11
12 f(1, 2);
三、由JavaScript中函數的聲明和調用特性，能夠看出JavaScript中函數是不能重載的。
根據其餘語言中重載的依據："函數返回值不一樣或形參個數不一樣"，咱們能夠得出上述結論：
第一：Javascript函數的聲明是沒有返回值類型這一說法的；
第二：JavaScript中形參的個數嚴格意義上來說只是爲了方便在函數中的變量操做，實際上實參已經存儲在arguments對象中了。
另外，從JavaScript函數自己深刻理解爲何JavaScript中函數是不能重載的：在JavaScript中，函數其實也是對象，函數名是關於函數的引用，或者說函數名自己就是變量。對於以下所示的函數聲明與函數表達式，其實含以上是同樣的（在不考慮函數聲明與函數表達式區別的前提下），很是有利於咱們理解JavaScript中函數是不能重載的這一特性。
1 function f(a){
2 return a + 10;
3 }
4
5 function f(a){
6 return a - 10;
7 }
8
9 // 在不考慮函數聲明與函數表達式區別的前提下，其等價於以下
10
11 var f = function(a){
12 return a + 10;
13 }
14
15 var f = function(a){
16 return a - 10;
17 }
四、arguments對象中有一個很是有用的屬性：callee。arguments.callee返回此arguments對象所在的當前函數引用。在使用函數遞歸調用時推薦使用arguments.callee代替函數名自己。
以下：
1 function count(a){
2 if(a==1){
3 return 1;
4 }
5 return a + arguments.callee(--a);
6 }
7
8 var mm = count(10);
9 alert(mm);
- 1. AJAX裏面status的值表明什麼
- 2. 原型、原型鏈、閉包、繼承
- 3. 原型 、原型鏈和對象是怎麼實現繼承的
- 4. http協議中，「get」和「post」的區別是什麼？
- 5. 什麼是原型對象？原型鏈？
- 6. 什麼是HTTP協議
- 7. JavaScript原型系列（二）什麼是原型繼承
- 8. 什麼是HTTP協議？
- 9. 閉包、原型鏈和繼承
- 10. 什麼是http協議(一)
- 更多相關文章...
- • ACID原則是什麼？ - NoSQL教程
- • 網絡協議是什麼？ - TCP/IP教程
- • Kotlin學習（二）基本類型
- • Flink 數據傳輸及反壓詳解
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. AJAX裏面status的值表明什麼
- 2. 原型、原型鏈、閉包、繼承
- 3. 原型 、原型鏈和對象是怎麼實現繼承的
- 4. http協議中，「get」和「post」的區別是什麼？
- 5. 什麼是原型對象？原型鏈？
- 6. 什麼是HTTP協議
- 7. JavaScript原型系列（二）什麼是原型繼承
- 8. 什麼是HTTP協議？
- 9. 閉包、原型鏈和繼承
- 10. 什麼是http協議(一)