內置類型

JavaScript 有七種內置類型：
? 空值（null） ? 未定義（undefined） ? 布爾值（ boolean） ? 數字（number） ? 字符串（string） ? 對象（object） ? 符號（symbol，ES6 中新增）

• 除對象之外，其他統稱為“基本類型”。
• 我們可以用typeof 運算符來查看值的類型，它返回的是類型的字符串值。
• 有意思的是，這七種類型和它們的字符串值并不一一對應：

typeof undefined === "undefined"; // true
typeof true === "boolean"; // true
typeof 42 === "number"; // true
typeof "42" === "string"; // true
typeof { life: 42 } === "object"; // true
typeof Symbol() === "symbol"; // true  ES6中新加入的類型

而在對變量執行typeof 操作時，得到的結果并不是該變量的類型，而是該變量持有的值的類型，因為JavaScript 中的變量沒有類型。
你可能注意到null 類型不在此列。它比較特殊，typeof 對它的處理有問題：
typeof null === "object"; // true
正確的返回結果應該是"null"，但這個bug 由來已久，在JavaScript 中已經存在了將近二十年，也許永遠也不會修復，因為這牽涉到太多的Web 系統，“修復”它會產生更多的bug，令許多系統無法正常工作。
我們需要使用復合條件來檢測null 值的類型：

var a = null;
(!a && typeof a === "object"); // true

null 是基本類型中唯一的一個 “假值”（falsy 或者false-like）類型，typeof 對它的返回值為"object"。實際上，null 本身是基本類型。

• 數組也是對象。確切地說，它也是object 的一個“子類型”
• 除了undefined和null其他三個都有相應的構造器函數，分別是Number()、String()、Boolean()。通過這些可以創建出相應的對象，通過將這些基本類型封裝成對象，就可以在其中繼承一些有用的工作方法。
  其調用分為兩種形式：
  1）使用new操作符調用--用于新建對象。
  2）不使用new操作符調用，用于將任意符轉換為基本數據類型。

操作符

• 操作符優先級：！> && > || (最佳操作是使用括號)
• == 相等運算符，在該比較操作之前，兩邊的操作數會會被自動轉換為相同的類型如：1==“1”;將返回true
  而===等價運算符其幕后不存在任何形式的類型轉換。此外!=存在類型轉換，!==不允許類型轉換
• 如果在同一個值上執行兩次邏輯非運輸，其結果就等于原值；var b=!!true; b; 將返回true
• 如果在一個非布爾值上執行邏輯運算，該值會在運算期間轉換為布爾值：var b="one"; !b; 將返回false;!!b;將會返回true;
• 檢驗一個字符串中是否包含另一個字符串，可以用-1來做indexOf()結果比照（是區分大小寫的）
  if (s.indexOf('Couch') !== -1){.....}
  注意 if (s.indexOf('Couch')){.....}是不對的，因為索引值可能是0，會被轉換為falsh

變量

• 變量沒有類型，但它們持有的值有類型。類型定義了值的行為特征，通過typeof 的安全防范機制（阻止報錯）來檢查undeclared 變量，有時是個不錯的辦法。
• 注意當第二次設置變量時，就不需要再使用var語句了。
  var n=1; n=1234;
• 檢查變量是否存在：
  if(typeof somevar !==‘undefined’){result=‘yes’;}

變量的作用域
這是一個至關重要的問題，js語言不能為變量定義特定的塊作用域，但可以定義其所屬的函數域，函數外不可見。而如果該變量定義在if或for代碼塊中，它在代碼塊以外是可見的。

• 還有一點很重要，聲明一個變量時沒有用var語句，該變量會被默認為全局變量，在函數中的這種變量也一樣，不過要訪問到需要函數首先被調用過，也可以說在該函數被調用之前，這個沒有var的變量是不存在的

function f(){local=2;}  //local為全局變量
local；    //ReferenceError: local is not defined
f();      //注意這里函數執行后，函數內的全局變量才能訪問到
local；   //2

注意：函數域始終優先于全局域

var a=123;
function f(){
  alert(a); //undefined; a的聲明會提升到函數體頂端，而賦值留在書寫的位置
   var a=1; //1
  alert (a);
}
f()  //1

函數

• function（函數）也是JavaScript 的一個內置類型，然而查閱規范就會知道，它實際上是object 的一個“子類型”。具體來說，函數是“可調用對象”，它有一個內部屬性[[Call]]，該屬性使其可以被調用。

函數對象中最重要的還是prototype屬性；每個函數的prototype屬性中都包含了一個對象（內建對象）；它只有在該函數是構造器時才會發揮作用；
每次某個函數被調用，就會有個新的執行上下文為其創建，即使是調用的自身函數，也是如此

var some_obj={
    name:'Ninjia',
    say: function(){
         return 'I am a ' + this.name;
    }
}
function F(){}
typeof F.prototype; //"object"

F.prototype = some_obj;
var obj=new F();  //----------------------------- 作為構造器
obj.say()  //"I am a Ninjia"

Function 對象的方法：
函數對象中有兩個非常有用的方法：call() 和 applay()，通過這兩個方法我們就能讓對象去借用其他對象中的方法，為己所用。這也是一種重用代碼的方式，非常簡單實用

call()方法：

var some_obj={
  name:'Ninjia',
  say: function(who){
     return 'Haya ' + who + ', I am a ' + this.name;
   }
}
some_obj.say('qing')  //"Haya qing, I am a Ninjia"

再創建一個無方法的my_obj對象
my_obj = {name: 'zhu'};
some_obj.say.call(my_obj,'niro')   //  "Haya niro, I am a zhu"

實際上就是通過call的首參數修改了對象函數this的值。當say()被調用時，其中的this就被自動設置成了my_obj對象的引用，this.name返回的不再是Ninija了，call方法可以傳遞更多的參數apply()與call()基本相同，不同在于參數的傳遞形式（apply是數組傳遞）some_obj.apple(my_obj,['qing']);

js循環（四種）

js中有四種循環：while循環 、do-while循環、for循環、for-in循環

while循環是最為簡單的一種：分為兩個部分：小括號中的條件和大括號中的的代碼塊，僅當條件為true是代碼塊才會被反復執行。

image

var i=0;
while(i<10){  
   i++;
}

for 循環
打印一個5行5列的星號字符串圖形

var res='\n';    //讓第一個星號回行
for(var i=0; i<5; i++){
    for(var j=0; j<5; j++){
       res +='* '; //這里實際上是重新定義變量res，j 循環是列出一行5個星號。
    }
   res +='\n'; //這里是循環在每行加一個回行符。
}
返回：
* * * * * * * * * * 
* * * * * * * * * * 
* * * * * * * * * * 
* * * * * * * * * * 
* * * * * * * * * * 

加深理解

var res='\n'; //定義變量并讓第一行換行  
for(var i=0; i<10; i++){
    for(var j=0; j<5; j++){
       res +='*';  //這里輸出的是一行5個星
    }
   res +='\n' + i; //這里輸出的是10列，沒有換行符的話就是在每5顆星后一個序列數字
}
"
*****
0*****
1*****
2*****
3*****
4*****
5*****
6*****
7*****
8*****
9"

乘法口訣：

 var res='\n';
for(var i =1 ;i<=9;i++){
     for(var j=1 ;j<=i;j++){  //---------------------重點j<=i
       res +=(i+"*"+j+"="+(i*j)+"   ");  //----------核心是(i*j)
     }
  res +="\n";
}

for-in 循環：
往往用來遍歷一某個數組或對象中的元素，下面打印出數組當前所在的位置鍵值和元素值

var a = ['a','b','c','d'];
var result='\n';
for(var i in a){   //
result += 'index: ' + i + ', value: ' + a[i]+ '\n';
}   // ------------------------------核心只是result += a[i]
打印出：
index: 0, value: a
index: 1, value: b
index: 2, value: c
index: 3, value: d

下面將所有對象屬性復制在一個數組中：

var o={x:1,y:2,z:3};
var a=[],i=0;
for(a[i++] in o); // 這里很簡單，a和i上面已經聲明過了結果就是a[0]、a[1]...
console.log(a)  // 輸出["x", "y", "z"]

location (瀏覽器對象模型BOM的組成部分)：

使用location對象可以通過編程方式來訪問瀏覽器的導航系統，設置相應的屬性、可以逐段或整體地 修改瀏覽器的URL.
如：假設初始URL為http://www.zunyang.com/okzu/

將URL修改為"http://www.zunyang.com/okzu/#sectino1"
location.hash="#sectino1";

將URL修改為"http://www.zunyang.com/okzu/zun/"
location.pathname="zun" ;

將URL修改為"http://www.zunyang.com/okzu/?q=javascript"
location.search="?q=javascript"

等等，此外還有hostname、port

HTML5 classList屬性的方法

toggle、contains、add、remove

toggle 如果列表中已經存在給定的值，刪除她，如果沒有就添加
div.classList.toggle("myClass");

確定元素中是否包含既定的類名
if(div.classList.contains("db) && !div.classList.contains("disable")){}

刪除類名remove，添加add

readyState 屬性

有兩個可能的值

1.loading,正在加載文檔 2.complete,已經加載完文檔

if(documengt.readyState == "complete"）{//執行操作}

內存與性能問題

在使用innerHTML、outerHTML屬性、insertAdjacentHTML()方法時（以上都是HTML5規范），最好先手動刪除要被替換元素的所有事件處理程序和JS對象屬性。假設某個HTML元素有一個事件處理程序或引用了一個JS對象作為屬性，將該元素從文檔樹中刪除后，其綁定關系并沒有一并刪除，這種情況太多頁面占用內存的數量就會明顯上升。

for(i=0;len=values.length;i<len,i++){
     ul.innerHTML += "<li>" + values[i] + "<li/>";
}

要避免以上的操作，因為每次循環要從innerHTML中讀取信息，要像下面這樣把innerHTML放在循環體外面

var itemsHTML ="";
for(i=0;len=values.length;i<len,i++){
     itemsHTML += "<li>" + values[i] + "<li/>";
}
ul.innerHTML =  innerHTML; //只對innerHTML執行了一次賦值操作；

Firefox 控制臺設置

1.地址欄輸入about:config;
2.在過濾器的搜索欄輸入strict按回車；
3.雙擊javascript.options.strict選項所在的行，將其值改為true;
另外控制臺有多行代碼輸入選項，一般情況下是單行，多行注意在行尾端輸入“；”