變量：
變量的含義：就是用於表示一個數據的代號——我們自己定義的一個名字。
變量的定義：var v1; var v2 = 2; var v3, v4, v5; var v6, v7=7, v8, v9=”abc”;
變量的使用:
賦值：v1 = 1; v1 = 1+2+3; v1 = v2 + “abc”; v1 = v1 + 5; v1 = v1 + v1;
取值：m1 = v1; //將v1的值取到，再賦值給m1
m2 = v1 + 5; //將v1的值取到，再跟5相加，然後賦值給m2
alert( v1 ); //將v1的值取到，並交給alert去“彈出”
document.write( v1 ); //將v1的值取到，並交給document.write去“輸出”
alert( “v1=” + v1); //取到v1的值，並和字符串“v1=”進行連接運算，然後結果被alert。
document.write( “v1=” + v1);
數據類型：
基本類型：
布爾類型： boolean; 這種類型只有兩個值可用： true, false
字符串類型： string; 可以用單引號或雙引號表示，含義相同；
數字類型： number
復合類型：
數組： Array,
對象： Object
特殊類型：
null：空類型——可以給一個變量明確賦值為“null”，這就是空值，也是空類型，只是表示一個“含義”：該變量沒有給有效值。
undefined: 未定義：此類型通常就是對應“根本就還沒有給值”這種狀態。
算術運算符： ＋ － ＊ ／ ％
注意點：
1， 除法（/）就是數學上的自然除，而不是C語言的除法含義。
2， ++ 和 -- 稱為一元運算符，即只針對一個變量進行運算
3， 但 ++ 和 – 可以在表達式（比如賦值語句）中使用，則類似同時進行了2件事：自加（或自減）和表達式本身的計算，此時他們放在變量的前面和後面有不同含義。
a) var i = 1; var s1 = i++; //結果是：s1為1，i為2
b) var i = 1; var s2 = ++i; //結果是：s2為2，i為2
比較運算符：> >= < <= == != === !==
比較運算符用於數據的大小比較，通常是數字。其中值得注意的是：
==被稱為“模糊相等”，即數據的內容或經過轉換後的內容相等，就認為是相等。
===稱為“嚴格相等”，只有數據的類型和數據的內容都相等的時候才算是相等。
——從計算機的角度來說，一個數據具有兩個方面：數據類型和數據值（數據內容）
邏輯運算符：只用於對bool值進行運算。
邏輯與( && )：兩個數據只有都是true的時候，結果才是true
邏輯或( || )：兩個數據只要有一個是true，結果就是true
邏輯非( ! )：獲取一個bool值的“相反值”
字符串運算符：
只有一個連接運算符（ + ）: 含義是“連接兩個字符串”
辨析算術運算符的加法（ + ）:
此加號( + )兩個的數據只要有一個是字符串，則都會按字符串的“連接”含義進行運算，另一如果不是字符串，則會自動轉換為字符串後再進行連接運算。
位運算符只針對數字的二進制形式進行。
var v1 = 5; //這是10進制，二進制其實是：101,在計算機內部其實類似這樣： 00000101
var v2 = 6； //這是10進制，二進制其實是：110,在計算機內部其實類似這樣： 00000110
按位與：
符號： &
含義：將兩個二進制數字的對應位上的數字進行“與運算”，結果還是這些位運算的結果組成的二進制數所代表的值。
解釋：二進制數字進行“與運算”的規則是：
1 & 1 è 1
1 & 0 è 0
0 & 1 è 0
0 & 0 è 0
舉例：
var v1 = 5, v2 = 6，運算圖示為：
v1=5
0
0
0
0
0
1
0
1
v2=6
0
0
0
0
0
1
1
0
v1 & v2
0
0
0
0
0
1
0
0
var v3 = v1 & v2 = 00000100(2) = 4(10)
按位或：
符號： |
含義：將兩個二進制數字的對應位上的數字進行“或運算”，結果是這些位運算的結果組成的二進制數所代表的值。
解釋：二進制數字進行“或運算”的規則是：
1 | 1 è 1
1 | 0 è 1
0 | 1 è 1
0 | 0 è 0
按位非：
符號： ~ //這是一個“單目運算符”
含義：將一個二進制數字的對應位上的數字進行“非運算”，結果是這些二進制數字所代表的值。
解釋：二進制數字進行“非運算”的規則是：
~1 è 0
~0 è 1
按位左移運算：
符號： <<
含義： 將一個二進制數的每一個位上的數字往左邊移動指定的位數，並且左邊“冒”出去的就不管了（不算了），右邊空出來的位上填入“0”，得到的結果就是該二進制數字所代表的值。
舉例：
var v1 = 5；var v2 = 5 << 2; 運算圖示為：
v1=5
0
0
0
0
0
1
0
1
v2= 5 << 2
0
0
0
1
0
1
0
0
var v2 = 5 << 2 = 00010100(2) = 1 * 24 + 1*22 = 16+4 = 20(10)
按位左移運算：
符號： >>
含義： 將一個二進制數的每一個位上的數字往右邊移動指定的位數，並且右邊“冒”出去的就不管了（不算了），左邊空出來的位上填入原來的左邊的數字，得到的結果就是該二進制數字所代表的值。
舉例：
var v1 = 5；var v2 = 5 >> 2; 運算圖示為：
v1=5
0
0
0
0
0
1
0
1
v2= 5 >> 2
0
0
0
0
0
0
0
1
var v2 = 5 >> 2 = 00000001(2) = 1(10)
賦值運算符：其實就一個基本的賦值運算符： = ,其含義是將等號右邊的數據放到等號左邊的變量中去。
錯誤的語法：
var v1 = 1, v2 = 2, v3 = 5, v4 = -2;
v1 + v2 = v3 + v4; //錯，大錯，大錯特錯
復合賦值運算符： += -= *= /= %=
運算符的優先級 —— 太多，較為復雜，記不住，但請記住一下幾條規則：
1， 要心如明鏡：運算符有優先級（先後順序）問題。
2， 括號最優先，等號（賦值）最落後。
3， 先乘除後加減
4， 想不清楚或用不明白的，使用括號來解決
5， 括號只有小括號，可以一層層嵌套。
舉例：
var year = 2013;
//判斷閏年：一個年份能被4整除並且不能被100整除是閏年，或者能被400整除，也是閏年。
if ( ( (year % 4 == 0) && (year % 100 != 0) ) || (year % 400 == 0) )
{ documment.write( year + “是閏年”) ;}
var v1 = 10;
var v2 = v1; //將v1中值拷貝一份，放到v2這個變量中去了——此時也可以說成“將v1的值傳遞給v2”
var v1 = v1 + v1; //v1的值改變了，但並不影響v2——因為v2本身也是一個獨立的變量。
document.write("<br />v1=" + v1); //20
document.write("<br />v2=" + v2); //10, 不會，40，
上述“v2 = v1”就稱為“拷貝傳值”——取得v1的值並拷貝一份，然後賦值給v2
var v3 = {name:"小花", age:18, edu:"大學" }; //這是一個所謂“對象”類型——其中包括了3個數據。
//操作其中的數據類似這樣：
document.write("<br />v3這個對象的年齡為：" + v3.age);
v3.age = 19; //v3這個對象的age這項數據的值重復賦了一個新值，類似前面v1 = 20;
var v4 = v3; //此時，是將v3這個變量的“內存地址”傳遞給v4這個變量，而v3這個對象的數據本身其實只是由該地址來獲取。——這就叫做引用傳值——此時，其實這兩個變量是一樣的數據內容，類似一個人的多個名字：真名，藝名，網名，小名
document.write("<br />v4這個對象的年齡為：" + v4.age);
v3.age = 20; //
document.write("<br />此時，v4這個對象的年齡為：" + v4.age);
總結：
在js中，基本數據類型使用 “拷貝傳值”——傳值的時候直接就出現了一份新的數據（當然同時也是另一個變量所代表）
復合數據類型（數組和對象）使用“引用傳值”——傳值的時候只是做了一個地址指向，數據仍然只有一份，兩個變量就指向這同一份數據。
控制結構：就是使用一定的語法來控制我們程序執行的流程——也可以叫“流程控制結構”
分支就是“多條路徑，走一條”。
最簡形式：
//如果此條件滿足（即條件判斷的結果是true），則會執行其中的語句塊，否則什麼也不做。
if( 條件判斷語句 )
{
//要執行的語句塊——語句塊其實就是一種表示“n條語句”泛泛說法。
}
二選一分支形式：含義是兩條路，必走一條。
if( 條件判斷語句 )
{
//要執行的語句塊1——前面條件成立時執行
}
else
{
//要執行的語句塊2——前面條件不成立時執行
}
多選一分支結構：多條路根據條件的滿足情況走其中一條，但也可能一條都不走：
if( 條件判斷1 ) //如果此條件滿足，則執行語句塊1，然後if就結束了
{
//語句塊1
}
else if ( 條件判斷2 ) //如果條件1不滿足，則判斷條件2：如果滿足，則執行語句塊2，並結束if
{
//語句塊2
}
else if ( 條件判斷3 ) //如果條件2不滿足，則判斷條件3：如果滿足，則執行語句塊3，並結束if
{
//語句塊3
}
…………………… //依此類推。。。。。。如果沒有一個條件滿足，則其實到最後什麼也不會執行，if結束。
綜合型式：
if( 條件判斷1 ) //如果此條件滿足，則執行語句塊1，然後if就結束了
{
//語句塊1
}
else if ( 條件判斷2 ) //如果條件1不滿足，則判斷條件2：如果滿足，則執行語句塊2，並結束if
{
//語句塊2
}
else if ( 條件判斷3 ) //如果條件2不滿足，則判斷條件3：如果滿足，則執行語句塊3，並結束if
{
//語句塊3
}
……………. //依此類推。。。。。。
else
{
//最後的else語句塊。 //此語句塊會在前面條件都不滿足的時候去執行。
}
注意：綜合型式中是必有一條分支（語句塊）會得到執行。
switch的分支結構整體含義跟if類似，也是表示“多條路走一條”，其使用形式：
switch ( 一個變量或表達式 ) //不管是變量還是表達式，最終都代表一個“值”，我們用v1來說話
{
case 固定值1： //如果v1等於本值1，則會執行語句塊1
//語句塊1；
break； //退出此switch結構
case 固定值2： 如果v1不等於前面值1，則繼續判斷是否等於這裡的值2，如果相等，執行語句2
//語句塊2；
break； //退出此switch結構
case ………………………………
。。。。。。。。。。。。。。。。。
default: //如果前面各個判斷都不成立（也就是不相等），則會執行此語句塊。
//注意：switch中此default語句塊可以沒有。
//默認語句塊
}
特別注意：if語句其實是可以使用非常靈活的條件判斷，比如 > >= < <= == != === ，但，switch這裡case的判斷，只能有一種判斷：相等判斷。
循環的基本觀念：
1， 循環就是讓某些程序（語句塊）反復執行
2， 循環必須能夠有辦法停止——計算機沒有自己的判斷能力去決定“累了，不做了”
while循環的基本語法形式：
while ( 條件判斷 ) //如果條件判斷滿足了，則會執行其中的語句塊，否則while結束。
{
//要執行的語句塊
} //如果此語句塊執行完了，會立即回到前面while的位置繼續判斷。
上述形式只是語法上的基本要求，但，在“實用”中，通常會需要遵照如下模式：
【循環變量初始化】
while ( 【循環變量作為條件判斷】 )
{
//循環體，就是要反復執行的語句塊
【循環變量值的改變】
}
do while循環是一種會先執行一次，然後再根據判斷條件來決定是否繼續執行並循環的一種循環結構。
do while的實用形式如下：
【循環變量初始化】
do
{
//循環體，就是要反復執行的語句塊
【循環變量值的改變】
} while ( 【循環變量作為條件判斷】 ) ;
描述： 先執行do後面打括號中的語句塊，然後再進行while語句中的條件判斷，如果判斷成立（true），則繼續回到上面do後面的大括號中執行語句塊，否則就結束。
for循環基本形式：
for( 【循環變量初始化A】； 【循環變量作為條件判斷B】； 【循環變量值的改變C】 )
{
//循環體D，也就是要反復執行的語句塊
}
for循環的執行邏輯（順序）：
A è Bètrue è D è C è Bètrue è D è C è Bè
┗èfalseèfor循環結束 ┗èfalseèfor循環結束
函數不是數。
函數只是一種語法結構。
函數是一種將若干行代碼“包裝”起來作為一個整體而使用的一種語法結構。
函數可以說是一種需要去定義並使用的語法——類似變量：需要定義，並使用之。
函數是為了完成某種特定功能且通常是“需要反復執行的功能”——函數的目的就是執行其中包起來的那些代碼塊（語句塊）
函數是一個獨立的執行空間，即其內容的代碼跟函數外部的代碼可以認為是“分離”的。
函數的定義形式：
function 函數名( 形式參數1， 形式參數2， …… )
{
//其中要執行的語句塊——函數體
}
var s1 = parseInt(3.5); //3
var s2 = parseInt(3.8); //3
var s3 = parseInt(3.1); //3
var s4 = parseInt(3.0); //3
var s5 = parseInt(3); //3
——parseInt其實就是一個函數——系統內部函數。此函數具有一種“神奇的能力”：將給他的一個數字轉變成一個相應的整數，該整數是不大於該給定數字的最大整數。
提出需求：
我想要求3和4兩個直角邊對應的斜邊。
還還想要球5和6對應的斜邊，還有，7和8，還有。。。。。。。。
函數到底是什麼？函數只是模塊化編程思想的語法體現——所謂模塊化編程思想就是將各種“反復要執行的任務”做出一個獨立的“模塊”，用的時候就“直接調用”，這樣就節省了反復要寫的那些代碼。
函數的調用形式：
函數名( 實際參數1， 實際參數2， ….. );
函數調用過程：
1， 首先將調用函數處的實際參數值一一對應傳遞給函數定義處的形式參數。
a) 形式參數一定只能是一個“變量名”，它代表一定的實際含義——根據函數功能而定。
b) 實際參數一定只能是一個“數據”（可能為直接數據或變量數據）
c) 注意：形式參數中的變量名不能使用var，也不能在其他地方定義。
2， 接著程序的執行流程進入到函數內部，按應該的流程執行函數中的“所有語句”
3， 函數內部程序執行完畢，則程序的執行流程會回到函數調用的位置。
a) 如果函數執行的任務需要有返回值，則必須使用return語句將該值返回。此時函數也自然結束了。
b) 如果一個函數不需要返回值，也是可以使用return語句的，則此時只是表明函數立即在此結束（可能並沒有完全執行完所有語句）
函數的返回值2種情況：
有返回值：表示函數經過一定的“計算”（執行），會得出一個數據，並且會將該數據返回到調用位置（調用者）。此時就必須使用“return 某值；”來實現。——比如：老板拿一定的錢吩咐某員工買火車票，則該員工需要將該購得的火車票交回給老板。
特別注意：有返回值的時候，要把函數的調用當作一個值來看待。
一個函數有沒有返回值並不是語法所決定的，而是實際需求所決定——語法只是據實際需求而變。
無返回值：表示一個函數只是單純地去執行裡面的代碼，執行完就算結束，並不需要返回一個數據給“調用者”。
函數的參數：完全沒有語法上的規定，而是要根據應用的需求本身來決定有沒有參數或有幾個參數——即完成該函數的功能，應該提供哪些必要的數據，此數據也就反應為函數的形式參數，每個形式參數各代表一定的含義（數據）。
所謂作用域就是指“有效的可用的范圍”
作用域分兩種：
全局作用域：在所有程序范圍內都可以使用（有效）的范圍。
局部作用域：只在特定范圍內（通常是函數內部）可以使用（有效）的范圍。
變量從作用域角度分兩種：
全局變量：指一個變量可以在全局范圍內使用（有效）。在函數外部定義的變量就是全局變量。全局變量可以在函數外部和函數內部都能使用。
局部變量：指一個變量只能在特定范圍（通常就是函數）內部有效——通常就是定義該變量的函數內部
parseInt(xxx): 將參數xxx轉換為一個整數——取整操作。
parseInt( 3 ); è 3
parseInt( 3.8 ); è 3
parseInt( 3.1 ); è 3
parseInt( “3” ); è 3
parseInt( “3.8” ); è 3
parseInt( “3.1” ); è 3
parseInt( “3abc” ); è 3
parseInt( “3.8abc” );è 3
parseInt( “3.1abc” );è 3
parseInt( “abc3” ); è NaN
parseInt( “abc 3.8” );è NaN
parseInt( “abc3.1” );è NaN
parseInt( “abc” ); è NaN
NaN——它是一個特殊的數字（類型為number），其含義是：Not a Number（即非數字）——此情形其實通常是指需要一個數字但提供的數據不是一個數字或不能轉成一個數字的時候。——NaN這個數字跟任何數都不相等，包括它本身。
parseFloat(xxx): 將參數xxx轉換為一個小數。
parseFloat ( 3 ); è 3
parseFloat ( 3.8 ); è 3.8
parseFloat ( 3.1 ); è 3.1
parseFloat ( “3” ); è 3
parseFloat ( “3.8” ); è 3.8
parseFloat ( “3.1” ); è 3.1
parseFloat ( “3abc” ); è 3
parseFloat ( “3.8abc” ); è 3.8
parseFloat ( “3.1abc” ); è 3.1
parseFloat ( “abc3” ); è NaN
parseFloat ( “abc 3.8” ); è NaN
parseFloat ( “abc3.1” ); è NaN
parseFloat ( “abc” ); è NaN
Number( xxx ): 將參數xxx轉換為一個“數字”——注意跟parseFloat對比。
Number ( 3 ); è 3
Number ( 3.8 ); è 3.8
Number ( 3.1 ); è 3.1
Number ( “3” ); è 3
Number ( “3.8” ); è 3.8
Number ( “3.1” ); è 3.1
Number ( “3abc” ); è NaN
Number ( “3.8abc” ); è NaN
Number ( “3.1abc” ); è NaN
Number ( “abc3” ); è NaN
Number ( “abc 3.8” ); è NaN
Number ( “abc3.1” ); è NaN
Number ( “abc” ); è NaN
isNaN（xxx）： 判斷參數xxx是否是一個“非數字”——如果是一個非數字，結果是true，否則如果是數字，結果是false
isNaN ( 3 ); è false
isNaN ( 3.8 ); è false
isNaN ( 3.1 ); è false
isNaN ( “3” ); è false
isNaN ( “3.8” ); è false
isNaN ( “3.1” ); è false
isNaN ( “3abc” ); è true
isNaN ( “3.8abc” ); è true
isNaN ( “3.1abc” ); è true
isNaN ( “abc3” ); è true
isNaN ( “abc 3.8” ); è true
isNaN ( “abc3.1” ); è true
isNaN ( “abc” ); è true
