第2章     JavaScript的數(shù)據(jù)類型和運算符
　　
　　
　　學習目標：
　　JavaScript腳本語言同其他程序設計語言一樣，有其自身的基本數(shù)據(jù)類型、表達式和算術(shù)運算符。JavaScript有一套其自身的語法規(guī)則和基本框架結(jié)構(gòu)，這是掌握JavaScript語言和開發(fā)JavaScript程序的基礎。
　　內(nèi)容摘要：
* 熟悉JavaScript的語法規(guī)則
* 掌握JavaScript的數(shù)據(jù)類型
* 熟練掌握JavaScript的運算符

2.1  JavaScript的語法規(guī)則
　　所有的編程語言都有自己的一套語法規(guī)則，用來詳細說明如何使用該語言來編寫程序。JavaScript語言也不例外，為了確保JavaScript代碼正確運行，必須遵守其語法規(guī)則。
　　
 說明：在編寫JavaScript代碼時，由于JavaScript不是一種可獨立運行的語言，所以必須既關(guān)注JavaScript的語法規(guī)則，又要熟悉HTML的語法規(guī)則。
2.1.1  區(qū)分大小寫
　　JavaScript是嚴格區(qū)分大小寫的。例如，在程序代碼中定義一個標識符computer(首字母小寫)的同時還可以定義一個標識符Computer(首字母大寫)，二者是完全不同的兩個符號。一般來說，在JavaScript中使用的大多數(shù)標識符都采用小寫形式。如保留字全部都為小寫，但也有一些名稱采用大小寫組合方式，如onClick、onLoad、Date.getFullYear等。
2.1.2  代碼的格式
　　JavaScript中的代碼有其固定的格式。在JavaScript程序中，每條功能執(zhí)行語句的最后必須以分號結(jié)束。一個單獨的分號也可以表示一條語句，這種語句叫作空語句。為了使程序代碼整齊美觀，而采取的對齊或者縮進文本的格式不是必需的。代碼可以按編寫者的意愿任意編排，只要每個詞之間用空格、制表符、換行符或者大括號、小括號等分隔符隔開就可以了。
　　在JavaScript程序中，一行可以寫一條語句，也可以寫多條語句。一行中寫多條語句時，語句之間使用分號分隔。當在一行中只寫一條語句時，可以省略語句結(jié)尾的分號，此時以回車換行符作為語句的結(jié)束。例如，以下寫法都是正確的。
　　
int  c=10;     //此行結(jié)尾的分號可以省略
int  x=5; 
　　
或
　　
c=10;  x=5;     //此行C=10;之后的分號不能省略
　　
或
　　
c=10      //語句結(jié)尾省略了分號
x=5; 
　　
 說明：為了便于閱讀，即使一行只有一條語句，最好也在語句末尾加上一個分號。
　　如果一條語句被分成了一行以上，JavaScript會自動在該行結(jié)尾插入分號，使換行符之前的一行形成一條語句。例如，如果按以下格式輸入以下語句。
　　
return
false; 
　　
　　本來想表達的意圖是以下語句：
　　
return false; 
　　
　　但JavaScript在解釋時會在return之后自動插入一個分號，而形成以下的兩條語句： 
　　
return; 
false; 
　　
　　從而產(chǎn)生代碼錯誤。因此，要注意同一條語句要寫在一行中，其間不要插入換行符。
　　但作為HTML標簽屬性值的JavaScript腳本程序代碼的最后一條語句結(jié)尾處的分號可以省略，例如：
　　
<input  type=button  value=text  onclick=”alert (new  Date())”>
　　
　　其中alert(new Date())后面就省略了分號。
2.1.3  代碼的注釋
　　為程序添加注釋可以起到解釋程序的作用，提高程序的可讀性。此外，還可以使用注釋來暫時屏蔽某些程序語句，讓瀏覽器暫時不要理會這些語句。等到需要的時候，只要取消注釋標記，這些程序語句就又可以發(fā)揮作用了。
　　實際上，注釋是腳本的重要組成部分，注釋有利于提高腳本的可讀性。為程序加入適當?shù)淖⑨�，其他人就可以借助注釋來理解和維護腳本，從而有利于團隊合作開發(fā)，提高開發(fā)效率。
　　JavaScript可以使用兩種方式書寫注釋：單行注釋和多行注釋。
　　(1) 單行注釋。
　　單行注釋以兩個斜杠開頭，然后在該行中書寫注釋文字，注釋內(nèi)容不超過一行。例如：
　　
//這是對一個函數(shù)的定義
　　
　　(2) 多行注釋。
　　多行注釋又叫注釋塊，它表示一段文字都是注釋的內(nèi)容。多行注釋以符號“/*”開頭，并以“*/”結(jié)尾，中間部分為注釋的內(nèi)容，注釋內(nèi)容可以跨越多行，但其中不能有嵌套的注釋。例如：
　　
/* 這是一個多行注釋，這一行是注釋的開始
函數(shù)定義的開始
……
函數(shù)定義的結(jié)束*/
2.1.4  常量
　　JavaScript的常量又稱為字面常量，是程序中不能改變的數(shù)據(jù)，與數(shù)據(jù)類型相對應，有以下幾種常量。

1. 整型常量
　　整型常量可以使用十六進制、八進制和十進制表示。十六進制以0x或者0X開頭。如0x8a。八進制必須以0開頭，如0167。十進制的第一位不能是0(數(shù)字0除外)，如235。
2. 實型常量
　　實型常量是由整數(shù)部分加小數(shù)部分表示，如11.376和689.78，實型常量也可以使用科學記數(shù)法來表示，如8E7、7e6。
3. 布爾常量
　　布爾常量不是真就是假。其值只有兩種：true和false。
4. 字符串常量
　　JavaScript中沒有單獨的字符常量，而只有表示由若干字符所組成的字符串常量。字符串常量使用單引號(')或雙引號(" ")引起來的若干字符，如"abc"，"a book"等。一個字符串中不包含任何字符也是可以的，其形式為" "，表示一個空字符串。
5.??null常量
　　JavaScript中的null常量表示一個變量所指向的對象為空值。
6.??undefined常量
　　undefined常量用于表示變量還沒有被賦值的狀態(tài)。null表示賦給變量的值為“空”，“空”是一個有特殊意義的值。而undefined則是表示還沒有對變量賦值，變量的值還處于未知狀態(tài)。
2.1.5  空白符和換行符
　　JavaScript會忽略程序中記號之間的空格、制表符和換行符，除非它們是字符串常量的組成部分。這里的記號就是指一個關(guān)鍵字、變量名、數(shù)字、函數(shù)名或者其他各種實體。具體來說，可以分為以下3種情況。
　　(1) 如果標識符、運算符之間有多于一個的空白字符，對于解釋器來講，多個空白字符相當于一個空白字符的分隔作用。例如，下面的兩行代碼是等價的：
　　
var name="王五";
var name =   "王五";
　　
　　(2) 如果在一個記號中插入了空格或制表符，JavaScript就會將它分成兩個記號。例如，area是一個變量名，而ar ea則是兩個獨立的變量ar和ea。
　　(3) 如果字符串常量本身包含空格，如“cell phone”，JavaScript解釋器在解釋代碼的過程中會保留這些空格。
　　
 說明：由于JavaScript忽略出現(xiàn)在其他地方的空白，因此，可以自由地縮進代碼行，可以采用整齊、一致的方式自由安排程序的格式，以便于閱讀和理解程序。
　　

2.1.6  標識符
　　標識符是指JavaScript中定義的符號，如變量名、函數(shù)名、數(shù)組名等。在JavaScript中，合法的標識符的命名規(guī)則和Java語言以及其他許多編程語言的命名規(guī)則相同，即標識符可以由大小字母、數(shù)字、下劃線(_)和美元符號($)組成，但標識符不能以數(shù)字開頭，不能是JavaScript中的保留字。
　　例如，下面的幾個標識符是合法的：
　　
username
user_name
_userName
$username
　　
　　下面的幾個標識符是非法的：
　　
int //int是JavaScript中的保留字
78.2//78.2是由數(shù)字開頭，并且標識符中不能含有點號(.)
Hello world//標識符中不能含有空格
　　
2.1.7  保留字
　　每種程序語言都有自己的保留字，不能將它們用作程序中的標識符。JavaScript同其他程序語言一樣，也擁有自己的保留字。JavaScript保留字是指在JavaScript語言中有特定含義，成為JavaScript語法的一部分的那些字符。它們只能在JavaScript語言規(guī)定的場合中使用，而不能用作變量名、函數(shù)名等標識符。表2-1列出了JavaScript的保留字。
表2-1  保留的JavaScript的關(guān)鍵字
abstract
do
if
package
throws
boolean
double
implements
protected
transient
break
else
import
public
true
byte
extends
in
return
try
case
false
instanceof
short
var
catch
final
int
static
void
char
finally
interface
super
while
class
float
long
switch
with
const
for
native  
synchronized

continue
function
new
this

default
goto
null  
throw

　　
 說明：在最新的ECMAScript V4標準(草稿)中還將is、namespace和use作為了保留字。使用時應該也避免使用這幾個保留字。
　　除了不能將保留字用作標識符外，還有很多其他的詞也不能被用作標識符。它們是被JavaScript用作屬性名、方法名和構(gòu)造函數(shù)名的詞。如果用這些名字創(chuàng)建了一個變量或函數(shù)，就會重定義已經(jīng)存在的屬性或函數(shù)。編寫程序時，在給變量或函數(shù)命名時不應該和這些全局變量或函數(shù)的名字相同。另外，還要避免定義以兩個下劃線開頭的標識符，因為JavaScript常常將這種形式的標識符用于內(nèi)部。
2.2  數(shù) 據(jù) 類 型
　　JavaScript中的數(shù)據(jù)類型可以分為兩類：基本數(shù)據(jù)類型和引用數(shù)據(jù)類型。JavaScript的基本數(shù)據(jù)類型包括數(shù)值型、字符串型和布爾型以及兩個特殊的數(shù)據(jù)類型(空值和未定義)。另外，還支持數(shù)組、函數(shù)、對象等引用數(shù)據(jù)類型。由于JavaScript采用弱類型的變量聲明形式，因而變量在使用前可以先不作聲明，而是在使用或賦值時再確定其數(shù)據(jù)類型。
2.2.1  數(shù)值型
　　數(shù)值型(number)是最基本的數(shù)據(jù)類型，可以用于完成數(shù)學運算。JavaScript與其他程序設計語言的不同之處在于，它并不區(qū)分整型數(shù)值和浮點型數(shù)值。在JavaScript中，所有數(shù)字都是由浮點型表示的。
　　如果一個數(shù)值直接出現(xiàn)在JavaScript程序中時，稱為數(shù)值直接量。JavaScript支持的數(shù)值直接量的形式有以下幾種。
1. 整型直接量
　　一個整型直接量可以是十進制、十六進制和八進制數(shù)。例如，下面列出了幾個整型直接量：
　　
25 //整數(shù)25的十進制表示
037//整數(shù)31的八進制表示
0x1A//整數(shù)26的十六進制表示
　　
2. 浮點型直接量
　　浮點型直接量即帶小數(shù)點的數(shù)。它既可以使用常規(guī)表示法，也可以使用科學記數(shù)法來表示。使用科學記數(shù)法表示時，指數(shù)部分是在一個整數(shù)后跟一個“e”或“E”，它可以是一個有符號的數(shù)。下面是一些浮點型直接量：
　　
3.1415//常規(guī)表示法
-3.1E12//常規(guī)表示法
.1e12 //科學記數(shù)法，該數(shù)等于0.1×1012
52E-12//科學記數(shù)法，該數(shù)等于52×10-12
　　
 說明：一個浮點數(shù)組必須包含一個數(shù)字、一個小數(shù)點或“e”(或“E”)。
* 特殊數(shù)值
　　JavaScript中還定義了一些表示特殊數(shù)值的常量，如表2-2所示。

表2-2  JavaScript中特殊的數(shù)值常量
常  量
含  義
Infinity
表示正無窮大的特殊值
NaN
特殊的非數(shù)字值
Number.MAX_VALUE
可表示的最大值

Number.MIN_VALUE
可表示的最小負數(shù)(與零最接近的值)
Number.NaN
特殊的非數(shù)字值
Number.POSITIVE_INFINITY
表示正無窮大的特殊值
Number.NEGATIVE_INFINITY
表示負無窮大的特殊值
　　
2.2.2  字符串類型
　　字符串是由字符、數(shù)字、標點符號等組成的序列，是JavaScript中用來表示文本的數(shù)據(jù)類型。
　　
 說明：JavaScript和C以及C++、Java不同的是，它沒有char這樣的字符數(shù)據(jù)類型，要表示單個字符，必須使用長度為1的字符串。
1. 字符串直接量
　　字符串直接量是由單引號或雙引號括起來的一串字符，其中可以包含0個或多個字符。下面為一些字符串直接量：
　　
"fish" 
'李白' 
"5467" 
"a line" 
"That’s very good. "
'"What are you doing?", he asked.'
　　
　　字符串直接量兩邊的引號必須相同，即對一個字符串來說，要么兩邊都是雙引號，要么兩邊都是單引號；否則一邊加單引號，一邊加雙引號會產(chǎn)生錯誤。此外，由單引號定界的字符串中可以含有雙引號，由雙引號定界的字符串中也可以含有單引號，如上面的最后一行即是單引號中包含了雙引號來定界字符串。
　　
 說明：HTML使用雙引號來定界字符串，由于要在HTML文檔中使用JavaScript，所以最好養(yǎng)成在JavaScript語句內(nèi)使用單引號的習慣，這可以避免與HTML代碼沖突。
2. 轉(zhuǎn)義字符
　　有些包含在字符串中的字符，由于在JavaScript 語法上已經(jīng)有了特殊用途，而不能以常規(guī)的形式直接加入這些符號。為了解決這個問題，JavaScript專門為這類字符提供了一種特殊的表達方式，稱為轉(zhuǎn)義字符。
　　轉(zhuǎn)義字符以反斜杠(\)開始，后面跟一些符號。這些由反斜杠開頭的字符表示的是控制字符而不是字符原來的含義。表2-3列出了JavaScript支持的轉(zhuǎn)義字符及其代表的實際意義。
表2-3  JavaScript中的轉(zhuǎn)義字符
字  符
含  義
\0
NULL字符(\u0000)
\b
退格符(\u0008)
\t
水平制表符(\u0009)
\n
換行符(\u000A)
\v
垂直制表符(\u000B)
\f
換頁符(\uDDCC)
\r
回車符(\uDDCD)
\"
雙引號(\u0022)
\'
撇號或單引號(\u0027)
\\
反斜杠符\ (\u005C)
\xXX
由兩個十六進制數(shù)值XX指定的 Latin-1 編碼字符，如 \xA9 即是版權(quán)符號的十六進制碼
\uXXXX
由4位十六進制數(shù)的?XXXX指定的Unicode 字符，如 \u00A9 即是版權(quán)符號的 Unicode 編碼
\XXX
由1～3位八進制數(shù)(從1～377)指定的 Latin-1 編碼字符，如 \251 即是版權(quán)符號的八進制碼(ECMAScript V3不支持，不要使用這種轉(zhuǎn)義序列) 
　　
2.2.3  布爾型
　　布爾型主要用來代表一種狀態(tài)，其數(shù)據(jù)的值只有兩個，由布爾型直接量true和false來表示，分別代表真和假。
　　例如，
　　
a = =1
　　
這行代碼測試了變量a的值是否和數(shù)值1相等，如果相等，結(jié)果就是布爾值true；否則結(jié)果就是false。
2.2.4  空值型
　　JavaScript中還有一個特殊的空值型數(shù)據(jù)，用關(guān)鍵字null來表示。它是JavaScript中的一種對象類型，常常被看作對象類型的一個特殊值，即代表“無對象”的值。如果一個變量的值為null，那么就表示它的值不是有效的對象、數(shù)字、字符串和布爾值。
　　null可用于初始化變量，以避免產(chǎn)生錯誤，也可用于清除變量的內(nèi)容，從而釋放與變量相關(guān)聯(lián)的內(nèi)存空間。當把null賦值給某個變量后，這個變量中就不再保存任何有效的數(shù)據(jù)了。

2.2.5  未定義值
　　JavaScript中還有一個特殊的未定義值，用全局變量undefined來表示。當使用了一個并未聲明的變量或聲明了變量但還沒有為變量賦值時，將返回 undefined 值。
　　null和undefined既有區(qū)別又有聯(lián)系。null是JavaScript中的保留字，而undefined卻不是JavaScript中的保留字，而是在ECMAScript V3標準中系統(tǒng)預定義的一個全局變量。
　　雖然undefined和null值不同，但是= =運算符卻將二者看作相等。如果想?yún)^(qū)分判斷null和undefined，那么應該使用測試一致性的運算符= = =或typeof運算符。
2.2.6  類型轉(zhuǎn)換
　　JavaScript是一種松散類型的程序設計語言，并沒有嚴格的規(guī)定變量的數(shù)據(jù)類型，也就是說，已經(jīng)定義數(shù)據(jù)類型的變量，可以通過相應的方法進行數(shù)據(jù)類型的轉(zhuǎn)換。
　　例如，如果字符串“5”和數(shù)字10進行算術(shù)加法運算，就需要首先將字符串“5”轉(zhuǎn)換為數(shù)值型。
　　為了適應不同的情況，JavaScript提供了兩種數(shù)據(jù)類型轉(zhuǎn)換的方法：一種方法是將整個值從一種類型轉(zhuǎn)換為另一種數(shù)據(jù)類型(稱為基本數(shù)據(jù)類型轉(zhuǎn)換)；另一種方法是從一個值中提取另一種類型的值，并完成類型轉(zhuǎn)換。
　　JavaScript提供了3個方法實現(xiàn)基本數(shù)據(jù)類型之間的轉(zhuǎn)換。
* String()：將其他類型的值轉(zhuǎn)換為字符串，如String(123)將數(shù)值123轉(zhuǎn)換為字符串"123"。
* Number()：將其他類型的值轉(zhuǎn)換為數(shù)值型數(shù)據(jù)。例如，Number(false)可以將布爾型直接量false轉(zhuǎn)換為數(shù)值0。
* Boolean()：將其他類型的值轉(zhuǎn)換為布爾型值。除0、NaN、null、undefined、" " (空字符串)被轉(zhuǎn)換為false外，所有其他值都被轉(zhuǎn)換為true。
　　實例2.1  JavaScript基本數(shù)據(jù)類型轉(zhuǎn)換。其代碼如下：
　　
<HTML>
 <HEAD>
   <TITLE>基本數(shù)據(jù)類型轉(zhuǎn)換</TITLE>
   <SCRIPT Language="JavaScript">
     var num1 ="100";
     var num2="200";
document.write("num1='100'  num2='200'");
var result=Number(num1)+Number(num2);
document.write("<br>數(shù)值的運算結(jié)果為：",result);
var st=String(num1);
result=st+200;
document.write("<br>字符串與數(shù)字的運算結(jié)果為：",result);
var bo=Boolean(num1);
result=bo+num2;
document.write("<br>字符串與布爾值的運算結(jié)果為：",result);
result=bo+200;
document.write("<br>數(shù)值與布爾值的運算結(jié)果為：",result);
document
</SCRIPT>
  </HEAD>
 <BODY>
 </BODY>
</HTML>
　　
　　將頁面保存為shuju.htm文件，在瀏覽器中執(zhí)行，結(jié)果如圖2-1所示。

圖2-1  基本數(shù)據(jù)類型程序運行結(jié)果
　　JavaScript中還提供了3種通過提取數(shù)據(jù)進行數(shù)據(jù)類型轉(zhuǎn)換的方法，即parseInt()、parseFloat()和eval()。
　　(1) 提取整數(shù)的parseInt()方法。
　　parseInt()方法用于將字符串轉(zhuǎn)換為整數(shù)，其語法格式如下：
　　
parseInt(numString,[radix])
　　
　　其中，第一個參數(shù)為必選項，指定要轉(zhuǎn)化為整數(shù)的字符串。當僅包括這個參數(shù)時，表示將字符串轉(zhuǎn)換為十進制整數(shù)。第二個參數(shù)是可選的，使用該參數(shù)能夠完成八進制、十六進制等數(shù)據(jù)的轉(zhuǎn)換。但不管指定按哪一種進制轉(zhuǎn)換，parseInt()方法總是以十進制值返回結(jié)果。
　　例如，parseInt("123abc45")的返回值是123。而parseInt("100abc",8)表示將"100abc"按八進制數(shù)進行轉(zhuǎn)化，由于“abc”不是數(shù)字，所以實際是將八進制數(shù)100轉(zhuǎn)換為十進制，轉(zhuǎn)換的結(jié)果為十進制數(shù)64。
　　(2) 提取浮點數(shù)的parseFloat()方法。
　　parseFloat()方法用于將字符串轉(zhuǎn)換為浮點數(shù)，其語法格式如下：
　　
parseFloat(numString)
　　
　　該方法與parseInt()方法相似，不同之處在于parseFloat()方法能夠轉(zhuǎn)換浮點數(shù)。其參數(shù)即為要轉(zhuǎn)換的字符串，如果字符串不以數(shù)字開始，則parseFloat()方法將返回NaN，表示所傳遞的參數(shù)不能轉(zhuǎn)換為一個浮點數(shù)。
　　例如，parseFloat("12.3abc")轉(zhuǎn)化的結(jié)果為12.3。
　　(3) 計算表達式值的eval()方法。
　　eval()方法用于計算字符串表達式或語句的值，其語法格式如下：
　　

eval(codeString)
　　
　　其參數(shù)是由JavaScript語句或表達式組成的一個字符串，eval()方法能夠計算出該字符串表達式的值。
　　例如，eval("2+3*5-8")可以計算表達式2+3*5-8的值，并返回計算結(jié)果9。
　　實例2.2  JavaScript數(shù)據(jù)類型轉(zhuǎn)換方法的使用。其代碼如下：
　　
<HTML>
 <HEAD>
   <TITLE>數(shù)據(jù)類型轉(zhuǎn)換方法的使用</TITLE>
   <SCRIPT Language="JavaScript">
      var s1 ="100abc";
      var s2="20.5";
document.write("s1=\"100abc\"  s2=\"20.05\"");
num1=parseInt(s1);
num2=parseInt(s2);
document.write("<br>將s1轉(zhuǎn)換為整型后的結(jié)果為:",num1);
document.write("<br>將s2轉(zhuǎn)換為整型后的結(jié)果為:",num2);
num1=parseInt(s1,8);
num2=parseInt(s1,2);
document.write("<br>將s1作為八進制數(shù)轉(zhuǎn)換的結(jié)果為:",num1);
document.write("<br>將s1作為二進制數(shù)轉(zhuǎn)換的結(jié)果為:",num2);
num2=parseFloat(s2);
document.write("<br>將s2轉(zhuǎn)換為浮點型的結(jié)果為:",num2);
result=eval("100"+s2);
document.write("<br>eval(\"100\"+s2)的返回值為:",result);
</SCRIPT>
  </HEAD>
 <BODY>
 </BODY>
</HTML>
　　
　　將頁面保存為tranferfun.htm文件，在瀏覽器中執(zhí)行，結(jié)果如圖2-2所示。

圖2-2  數(shù)據(jù)類型轉(zhuǎn)換方法的使用實例的運行效果
　　
程序中eval("100"+s2)在執(zhí)行時，是先進行字符串“100”和字符串s2的連接運算，然后再計算整個字符串的值，而不是分別將“100”和s2轉(zhuǎn)化為數(shù)值再進行算術(shù)加法運算，所以最后的結(jié)果為10020.5，而不是120.5。
2.3  變    量
　　與其他編程語言一樣，JavaScript也是采用變量存儲數(shù)據(jù)的。變量就是程序中一個已命名的存儲單元。變量的主要作用是存取數(shù)據(jù)和提供存放信息的容器。對于變量必須明確變量的名稱、類型和變量的值這3方面的特性。
2.3.1  變量的命名
　　JavaScript中的變量命名要遵守以下幾點規(guī)則。
　　(1) 變量名必須以大寫字母、小寫字母或下劃線(_)開頭，其他的字符可以是字母、下劃線或數(shù)字。變量名中不允許出現(xiàn)空格、“+”號、“-”號等其他符號。
　　(2) 不能使用JavaScript中的保留字作為變量名，如var、int、double、true等都不能作為變量的名稱。
　　(3)??JavaScript變量名是區(qū)分大小寫的，因此在使用時必須確保大小寫相同。變量名大小寫不同的變量，如name、Name、NAME，將被視為不同的變量。
　　(4)??JavaScript變量命名規(guī)范與Java類似，對于變量名為一個單詞的，則建議其為小寫字母，如area；對于變量名由兩個或兩個以上的單詞組成的，則建議第二個和第二個以后的單詞的首字母為大寫，如userName。
　　(5) 在對變量命名時，最好把變量名與其代表的內(nèi)容含義對應起來，以便能方便地區(qū)分變量的含義，如name變量就很容易讓人明白其代表的內(nèi)容。
　　例如，下面的變量名是合法的：
　　
user_name
$user_name
_user_name
my_variable_example
myVariableExample
　　
　　而下面的變量名是不合法的：
　　
%user_name
1user_name
$user_name
~user_name
+user_name
　　
2.3.2  變量的聲明
　　JavaScript是弱類型語言，因此它不像大多數(shù)編程語言那樣強制限定每種變量的類型，即在創(chuàng)建一個變量時可以不指定該變量將要存放何種類型的信息。
　　JavaScript中聲明變量的方式有兩種：一種是使用關(guān)鍵字var顯式聲明變量；另一種是使用賦值語句隱式聲明變量。
　　
 說明：為了提高程序的可讀性和正確性，建議對所有變量都使用顯式聲明。
1. 顯式聲明變量
　　格式1：
　　
var 變量名1[,變量名2,變量名3,…]
　　
　　下面是使用格式1聲明變量的示例代碼：
　　
var  i;
var  a,b,c;
var  name,password;
　　
　　在聲明變量的同時，可以為變量指定一個值，這個過程稱為變量的初始化。但該過程不是強制性的，可以聲明一個變量，但不初始化這個變量，此時，該變量的數(shù)據(jù)類型為undefined。
　　格式2：
　　
var 變量名1=值1[,變量名2=值2 變量名3=值3,…]
　　
　　下面是使用格式2聲明變量的示例代碼：
　　
var  name='張三';
var  i=0,j=1;
var  flag=true;
　　
　　在為變量賦初值后，JavaScript會自動根據(jù)所賦的值而確定變量的類型。例如，上面的變量name會自動定義為字符串型，變量i和j為數(shù)值型，變量flag為布爾型。
2. 隱式聲明變量
　　在JavaScript中聲明變量時，還可以在使用格式2聲明變量時省略關(guān)鍵字var，即直接在賦值語句中隱式地聲明變量。使用賦值語句隱式聲明變量的格式為：
　　格式3：
　　
變量名=值; 
　　
　　例如，之前的變量聲明語句，也可以寫成以下格式：
　　
name='張三';
i=0;j=1;
flag=true;
　　
 說明：在一行中有多個賦值語句時，之間要用分號分隔。
　　
　　實例2.3  JavaScript中變量的聲明。其代碼如下：
　　
<HTML>
 <HEAD>
   <TITLE>變量聲明</TITLE>
   <SCRIPT Language="JavaScript">
     var name;//顯式聲明變量但未初始化變量
var age=20;//顯式聲明變量并初始化變量
sex='男';//使用賦值語句隱式聲明變量
document.writeln("變量name的初始值：",name);
     document.writeln("<br>變量name的類型是：",typeof(name));
document.writeln("<br>變量age的初始值：",age);
     document.writeln("<br>變量age的類型是：",typeof(age));
document.writeln("<br>變量sex的初始值：",sex);
     document.writeln("<br>變量sex的類型是：",typeof(sex));
</SCRIPT>
  </HEAD>
 <BODY>
 </BODY>
</HTML>
　　
　　將頁面保存為tranferfun.htm文件，在瀏覽器中執(zhí)行，結(jié)果如圖2-3所示。

圖2-3  實例2.3的運行結(jié)果(顯式聲明的變量的值)
 說明：為了提高程序的可讀性和正確性，建議對所有的變量都使用關(guān)鍵字var顯式聲明變量，這樣可以區(qū)分變量和直接量。此外，全局變量必須使用var關(guān)鍵字。
　　
2.3.3  變量的賦值
　　在程序中任何位置需要改變變量的值時，都可以使用賦值語句來為變量賦值。賦值語句由變量名、等號以及確定的值組成。賦值語句的格式與格式3相同，即：
　　格式4：
　　
變量名=值; 
　　
　　格式4與格式3的不同之處是，格式3中的變量名一般是在程序中第一次出現(xiàn)，表示在聲明變量的同時給變量賦值，而格式4中的變量名可以是在程序中已經(jīng)出現(xiàn)過的變量，經(jīng)常是改變變量的值，甚至還能改變變量的類型。
　　實例2.4  JavaScript中變量的賦值。其代碼如下：
　　
<HTML>
 <HEAD>
   <TITLE>變量賦值</TITLE>
   <SCRIPT Language="JavaScript">
     salary=1000;      //在聲明變量salary的同時給變量賦值
     document.writeln("變量salary的初始值：",salary);
     document.writeln("<br>變量salary的類型是：",typeof(salary));
     salary=1500;      //使用賦值語句改變變量salary的值
     document.writeln("<br>變量salary改變后的值：",salary);
     document.writeln("<br>變量salary的類型是：",typeof(salary));
     salary='我的工資'   //使用賦值語句將變量salary的類型由數(shù)值型變?yōu)榱俗址��?br />     document.writeln("<br>變量salary改變類型后的值：",salary);
     document.writeln("<br>變量salary改變類型后的類型是：",typeof(salary));
</SCRIPT>
 </HEAD>
 <BODY>
 </BODY>
</HTML>
　　
　　將頁面保存為var2.htm文件，在瀏覽器中執(zhí)行，結(jié)果如圖2-4所示。

圖2-4  實例2.4的運行結(jié)果(顯示每次賦值的變量的值)
2.4  運  算  符
　　運算符是完成操作的一系列符號，運算符用于將一個或幾個數(shù)據(jù)按照某種規(guī)則進行運算，并產(chǎn)生一個操作結(jié)果，它必須作用在數(shù)據(jù)上才有效，使用運算符的數(shù)據(jù)被稱為操作數(shù)。
　　根據(jù)運算類別，可以將JavaScript中的運算符分為以下6類。
* 算術(shù)運算符。
* 賦值運算符。
* 關(guān)系運算符。
* 邏輯運算符。
* 字符串運算符。
* 其他運算符。
　　根據(jù)操作數(shù)的個數(shù)，可以將JavaScript中的運算符分為3類。
* 單目運算符：只作用于一個數(shù)據(jù)的運算符。
* 雙目運算符：作用于兩個數(shù)據(jù)上的運算符。
* 三目運算符：作用于3個數(shù)據(jù)上的運算符。
　　
 說明：除了條件運算符是三目運算符外，JavaScript中其他的運算符都是雙目或者單目運算。
　　
　　雙目運算符基本語法格式如下：
　　
操作數(shù)1   運算符   操作數(shù)2
　　
　　例如，100+200、“This is”+“a book.”等。
　　雙目運算符包括+(加)、-(減)、*(乘)、/(除)、%(取模)、|(按位或)、&(按位與)、<<(左移)、>>(右移)、>>>(右移，零填充)等。
　　單目運算符是只需要一個操作數(shù)的運算符，此時運算符可能在運算符前或運算符后�；�本語法格式如下：
　　
操作數(shù)1   運算符
　　
或
　　
運算符    操作數(shù)1   
　　
　　單目運算符包括-(單目減)、！(邏輯非)、~(取補)、++(遞加1)、--(遞減1)等。
2.4.1  算術(shù)運算符
　　JavaScript中的算術(shù)運算符如表2-4所示。
表2-4  JavaScript中的算術(shù)運算符
運算符
說  明
+
加法運算符
-
減法運算符
*
乘法運算符
/
除法運算符
%
取模運算符，即計算兩個數(shù)相除的余數(shù)
-
取反運算符，即將運算數(shù)的符號變成相反的

續(xù)表
運算符
說  明
++
增量運算符，遞加1并返回數(shù)值或返回數(shù)值后遞加1，取決于運算符的位置在操作數(shù)之前還是之后
--
減量運算符，遞減1并返回數(shù)值或返回數(shù)值后遞減1，取決于運算符的位置在操作數(shù)之前還是之后
　　
1. 加(+)、減(-)、乘(*)、除(/)運算符
　　加(+)、減(-)、乘(*)、除(/)運算符符合日常的數(shù)學運算規(guī)則，兩邊的運算數(shù)的類型要求是數(shù)值型的(+也可用于字符串連接操作)，如果不是數(shù)值型的，JavaScript會將它們自動轉(zhuǎn)換為數(shù)值型。
2. 取模運算符(%)
　　取模運算符也稱為取余運算符，其兩邊的運算數(shù)的類型也必須是數(shù)值型的。A%B的結(jié)果是數(shù)A除以數(shù)B后得到的余數(shù)，如11%2=1。
　　以上的運算符都是雙目運算符，使用這些運算符時一定要特別小心，有可能會出現(xiàn)NaN或其他錯誤的結(jié)果，如果除數(shù)為0就會出現(xiàn)問題。
3. 取反運算(-)
　　取反運算的作用就是將值的符號變成相反的，即把一個正值轉(zhuǎn)換成相應的負值；反之亦然。例如，x=5，則-x=-5。該運算符是單目運算符，同樣也要求操作都是數(shù)值型的，如果不是數(shù)值型的，會被自動轉(zhuǎn)換成數(shù)值型。
4. 增量運算符(++)和減量運算符(--)
　　這兩種運算符實際上是代替變量x進行x=x+1和x=x-1兩種操作的簡單而有效的方法，但是該運算符是置于變量之前和置于變量之后所得到的結(jié)果是不同的。
　　將運算符置于變量之前，表示先對變量進行加1或減1操作，然后再在表達式中進行計算。
　　例如，如果x=5，則++x+4=10，這是因為x先加1得到6，然后再進行加法運算，所以得到結(jié)果10，這相當于先執(zhí)行了x=x+1，然后執(zhí)行x+4。
　　同理，如果x=5，則--x+4=8，這是因為x先減1得到4，然后再進行加法運算，所以得到結(jié)果8，這相當于先執(zhí)行了x=x-1，然后執(zhí)行x+4。
　　如果將運算符置于變量之后，表示先將變量的值在表達式中參加運算后，再進行加1或減1。
　　例如，如果x=5，則x+++4=9，這是因為x的值先與4相加得到9，然后x才加1得到6，這相當于先執(zhí)行了x+4，然后再執(zhí)行x=x+1。
　　同理，如果x=5，則x--+4=9，這是因為x的值也是先與4相加得到9，然后x才減1得到4，這相當于先執(zhí)行了x+4，然后再執(zhí)行x=x-1。
　　這兩個運算符都是單目運算符，同樣也要求操作數(shù)都是數(shù)值型的，如果不是數(shù)值型的，會被自動轉(zhuǎn)換成數(shù)值型。
　　實例2.5  JavaScript中增量和減量運算符的使用。其代碼如下：
　　
<HTML>
 <HEAD>
   <TITLE>增量運算符和減量運算符的使用</TITLE>
   <SCRIPT Language="JavaScript">
     var a=5;  
var b;
document.write("a=",a);
b=a++;
document.write("<br>執(zhí)行b=a++后，a=",a);
document.write("  b=",b);
a=5;
document.write("<br>a=",a);
b=++a;
document.write("<br>執(zhí)行b=++a后，a=",a);
document.write("  b=",b);
a=5;
document.write("<br>a=",a);
b=a--;
document.write("<br>執(zhí)行b=a--后，a=",a);
document.write("  b=",b);
a=5;
document.write("<br>a=",a);
b=--a;
document.write("<br>執(zhí)行b=--a后，a=",a);
document.write("  b=",b);
a=5;
document.write("<br>a=",a);
b=a+++5;
document.write("<br>執(zhí)行b=a+++5后，a=",a);
document.write("  b=",b);
a=5;
document.write("<br>a=",a);
b=++a+5;
document.write("<br>執(zhí)行b=++a+5后，a=",a);
document.write("  b=",b);
a=5;
document.write("<br>a=",a);
b=a--+5;
document.write("<br>執(zhí)行b=a--+5后，a=",a);
document.write("  b=",b);
a=5;
document.write("<br>a=",a);
b=--a+5;
document.write("<br>執(zhí)行b=--a+5后，a=",a);
document.write("  b=",b);
</SCRIPT>
  </HEAD>
 <BODY>
 </BODY>
</HTML>
　　
　　
將頁面保存為var3.htm文件，在瀏覽器中執(zhí)行，結(jié)果如圖2-5所示。

圖2-5  增量和減量運算符實例的運行結(jié)果
2.4.2  賦值運算符
　　在之前創(chuàng)建變量時，實際上已經(jīng)使用了賦值運算符(=)給變量賦初值。賦值運算符(=)的作用是將其右邊的表達式的值給左邊的變量。
　　例如，a=5+1就表示把賦值號右邊的表達式5+1計算出來的結(jié)果值6給左邊的變量a，這樣變量a的值就是6。
　　賦值運算符(=)還可以用來給多個變量指定同一個值，如a=b=c=1，執(zhí)行該語句后，變量a、b、c的值都為1。
　　除了直接賦值外，還可以在賦值運算符(=)之前加上其他的運算符，構(gòu)成復合賦值運算符。表2-5列出了常用的復合賦值運算符。
表2-5  JavaScript中的復合賦值運算符
運算符
說  明
=
賦值運算符，將運算符左邊的變量設置為右邊表達式的值
+=
加法賦值運算符，將運算符左邊的變量加上右邊表達式的值，即a+=b，等同于a=a+b
-=
減法賦值運算符，將運算符左邊的變量減去右邊表達式的值，即a-=b，等同于a=a-b
*=
乘法賦值運算符，將運算符左邊的變量乘以右邊表達式的值，即a*=b，等同于a=a*b
/=
除法賦值運算符，將運算符左邊的變量除以右邊表達式的值，即a/=b，等同于a=a/b
%=
取模賦值運算符，將運算符左邊的變量用右邊表達式的值求模，即a%=b，等同于a=a%b
　　
　　實例2.6  JavaScript中賦值運算符的使用。其代碼如下：
　　
<HTML>
 <HEAD>
   <TITLE>賦值運算符的使用</TITLE>
   <SCRIPT Language="JavaScript">
     var a=10;  
document.write("a=",a);
a+=3;
document.write("  執(zhí)行a+=3后,a=",a);
a=10;
document.write("<br>a=",a);
a-=3;
     document.write("  執(zhí)行a-=3后,a=",a);
a=10;
document.write("<br>a=",a);
a*=3;
     document.write("  執(zhí)行a*=3后,a=",a);
a=10;
document.write("<br>a=",a);
a/=3;
     document.write("  執(zhí)行a/=3后,a=",a);
a=10;
document.write("<br>a=",a);
a%=3;
     document.write("  執(zhí)行a%=3后,a=",a);
</SCRIPT>
  </HEAD>
 <BODY>
 </BODY>
</HTML>
　　
　　將頁面保存為var4.htm文件，在瀏覽器中執(zhí)行，結(jié)果如圖2-6所示。

圖2-6  賦值運算符實例的運行結(jié)果
2.4.3  關(guān)系運算符
　　關(guān)系運算符又稱為比較運算符，是一個雙目運算符，用于比較操作數(shù)之間的大小等關(guān)系，關(guān)系運算符的操作數(shù)可以是數(shù)值、字符串，也可以是布爾值，其運算結(jié)果是true或false。JavaScript中的關(guān)系運算符如表2-6所示。

表2-6  JavaScript中的關(guān)系運算符
運算符
說  明
<
小于
<=
小于等于
>
大于
>=
大于等于
==
等于
===
嚴格等于
!=
不等于
!==
嚴格不等于
　　
 說明：嚴格等于(===)和嚴格不等于(!==)運算符是ECMAScript標準中的運算符，因此只在Navigator 4.06以上和IE4以上的瀏覽器中支持。
　　如果比較的兩個操作數(shù)為數(shù)值型，則按數(shù)學上的比較原則來比較。如果比較的兩個操作數(shù)為布爾值，JavaScript認為true大于false。如果比較的兩個操作數(shù)為字符串型時，要按字符編碼依次自左到右進行比較。
　　實例2.7  JavaScript中關(guān)系運算符的使用。其代碼如下：
　　
<HTML>
 <HEAD>
   <TITLE>比較運算符</TITLE>
   <SCRIPT Language="JavaScript">
     var i=5,j=8;
var b1=true,b2=false;
     var s1="Shanghai";
var s2="ShangHai";
var s3="I am a boy."
var s4="I am a girl."
var s5="北京";
var s6="天津";
document.write("數(shù)值型比較：5>8=",i>j);
document.write("<br>布爾值比較：true>false=",b1>b2);
document.write("<br>字符串比較：");
document.write("<br>'Shanghai'>'ShangHai'=",s1>s2);
document.write("<br>'Shanghai'=='ShangHai'=",s1==s2);
document.write("<br>'I am a boy.'>'I am a girl.'=",s3>s4);
document.write("<br>'北京'>'天津'=",s5>s6);
document.write("<br>忽略大小寫比較
'Shanghai'=='ShangHai'=",s1.toUpperCase()==s2.toUpperCase());
</SCRIPT>
  </HEAD>
 <BODY>
 </BODY>
</HTML>
　　
　　
程序中使用s1.toUpperCase()和s2.toUpperCase()方法將字符串s1和s2全部轉(zhuǎn)換為大寫字母。將頁面保存為var5.htm文件，在瀏覽器中執(zhí)行，結(jié)果如圖2-7所示。

圖2-7  關(guān)系運算符實例的運行結(jié)果
　　JavaScript提供的運算符==和!=分別用于完成判斷兩個操作數(shù)是否相等，其中操作數(shù)可以是各種類型。除了相等和不相等運算符之外，JavaScript還提供了嚴格等于(===)和嚴格不等于(!==)運算符，用于測試兩個操作數(shù)是否完全一樣，包括值是否相等以及類型是否相同。這兩個運算符在比較之前不進行類型轉(zhuǎn)換直接測試是否相等。只有兩個操作數(shù)的值相等并且類型也相同時，一致性測試運算===的計算結(jié)果才為true；否則其值為false。例如，表達式“58”==58的結(jié)果為true，而表達式“58”===58的結(jié)果為false，原因在于它們的數(shù)據(jù)類型不一致(一個操作數(shù)為字符串型，另一個為數(shù)值類型)。
2.4.4  邏輯運算符
　　邏輯運算符通常在條件語句中使用，它們與關(guān)系運算符一起構(gòu)成復雜的判斷條件。JavaScript中提供了3種邏輯運算符：邏輯與(&&)、邏輯或(||)、邏輯非(!)，如表2-7所示。
表2-7  JavaScript中的邏輯運算符
運算符
說  明
&&
邏輯與，當兩個操作數(shù)的值都為true時，運算結(jié)果為true
||
邏輯或，只要兩個操作數(shù)中有一個值為true時，運算結(jié)果就為true
!
邏輯非，對操作數(shù)取反，即true值非運算的結(jié)果為false，false值非運算的結(jié)果為true
　　
　　其中邏輯與和邏輯或運算符是雙目運算符，而邏輯非運算符是單目運算符。它們所連接的操作數(shù)都是邏輯型變量或表達式。對于連接的非邏輯型變量或表達式，在JavaScript中將非0的數(shù)值看作是true，而將0看作是false。
　　(1) 邏輯與(&&)。只有當兩個操作數(shù)的值都為true時，運算結(jié)果才為true；否則為false。因此，如果邏輯與運算符左邊的表達式的計算結(jié)果為零、null或空字符串，那么整個表達式的結(jié)果就肯定是false；如果邏輯與運算符左邊的表達式的計算結(jié)果為true，此時計算邏輯與運算符右側(cè)的表達式，如果這個表達式的值也是true，那么整個表達式的結(jié)果為true；否則，如果左邊值為true，右邊值為false，整個表達式的值將為false。
　　(2) 邏輯或(||)。只要兩個操作數(shù)中有一個值為true時，運算結(jié)果就為true，如果兩個操作數(shù)的值都為假，則運算結(jié)果為假。如果邏輯或運算符左邊的表達式計算結(jié)果為true，那么就不再計算或運算符右邊的表達式的值，并且整個表達式的值為true；如果邏輯或運算符左邊的表達式計算結(jié)果為false，那么計算或運算符右側(cè)的表達式的值，如果這個值為true，那么整個表達式的值為true；如果右側(cè)表達式計算的結(jié)果也為false，那么整個表達式的值為false。
　　(3) 邏輯非(!)。用于否定一個運算的結(jié)果。“真”的邏輯非值為“假”，“假”的邏輯非值為“真”。邏輯非是一個單目運算符，它只有一個操作數(shù)，如!true或!(5>8) 。
　　實例2.8  JavaScript中邏輯運算符的使用。其代碼如下：
　　
<HTML>
 <HEAD>
   <TITLE>邏輯運算符</TITLE>
   <SCRIPT Language="JavaScript">
     var a=10,b=20,c=30,d=40;
document.write("a=",a," b=",b," c=",c," d=",d);
document.write("<br>true&&false=",true&&false);
document.write("<br>true||false=",true||false);
document.write("<br>!true=",!true);
document.write("<br>!false=",!false);
document.write("<br>(a>b)&&(d>c)=",(a>b)&&(d>c));
document.write("<br>(a>b)||(d>c)=",(a>b)||(d>c));
document.write("<br>!(a>b)=",!(a>b))
</SCRIPT>
  </HEAD>
 <BODY>
 </BODY>
</HTML>
　　
　　將頁面保存為var6.htm文件，在瀏覽器中執(zhí)行，結(jié)果如圖2-8所示。

圖2-8  邏輯運算符實例的運行結(jié)果

2.4.5  字符串運算符
　　在JavaScript中只有一個字符串運算符，即連接運算符(+)，它是一個雙目運算符，可以將兩個字符串連接起來形成一個新的字符串。例如"This"+"is"的運算結(jié)果為"This is"， "中國"+"北京"運算結(jié)果為"中國北京"。
　　當操作數(shù)中至少有一個操作數(shù)是字符串時，JavaScript將自動把另一操作數(shù)轉(zhuǎn)換為字符串。例如，"36"+2的運算結(jié)果為"362"，"It is"+true的運算結(jié)果為"It is true"。
　　另外，字符串連接運算符還可以和前面的賦值運算符聯(lián)合使用，形成"+="運算符，它的作用是，將運算符右側(cè)的字符串拼接到該運算符左側(cè)字符串的后面，并將結(jié)果賦值給運算符左側(cè)的操作數(shù)。
　　實例2.9  JavaScript中字符串運算符的使用。其代碼如下：
　　
<HEAD>
   <TITLE>字符串運算符</TITLE>
   <SCRIPT Language="JavaScript">
     var a="this";
var b=" is ";
var c=10;
var d=true;
var e;
document.write("a=",a," b=",b," c=",c," d=",d);
document.write("<br>a+b=",e=a+b);
document.write("<br>e=",e);
document.write("<br>e+c=",e+c);
document.write("<br>e+d=",e+d);
document.write("<br>c+c=",c+c);
document.write("<br>d+d=",d+d);
document.write("<br>e+e=",e+e);
e+=c;
document.write("<br>執(zhí)行完e+=c后，e=",e);
</SCRIPT>
  </HEAD>
 <BODY>
 </BODY>
</HTML>
　　
　　將頁面保存為var7.htm文件，在瀏覽器中執(zhí)行，結(jié)果如圖2-9所示。

圖2-9  字符串運算符實例的運行結(jié)果
　　

 說明：如果字符串運算符中兩個操作數(shù)都為數(shù)值型或布爾型，則按加法進行運算。布爾型中的true被轉(zhuǎn)換為數(shù)值1，false則轉(zhuǎn)換為數(shù)值0。
2.4.6  其他運算符
　　除了前面介紹的各種運算符以外，JavaScript還提供了位操作運算符、條件運算符等其他的運算符。表2-8 列出的是有關(guān)位操作的運算符。
表2-8  JavaScript中的位運算符
運算符
說  明
~
按位取反運算符
<<
按位左移運算符
>>
按位右移運算符
>>>
無符號右移運算符
&
按位與運算符
^
按位異或運算符
|
按位或運算符
&=
按位與賦值運算符
|=
按位或賦值運算符
^=
按位異或賦值運算符
<<=
按位左移賦值運算符
>>=
按位右移賦值運算符
>>>=
按位無符號右移賦值運算符
　　
　　表2-9列出了JavaScript中其他的一些運算符。
表2-9  JavaScript中的其他運算符
運算符
說  明
? :
三目條件運算符。例如，x?a:b表示如果x為真，則整個表達式的值為a的值；否則為b的值
,
逗號運算符，計算兩個表達式的值，并返回第二個表達式的值
delete
用于刪除對象并釋放該對象所占用的空間
typeof
用于返回操作數(shù)的數(shù)據(jù)類型
void
運算符對表達式求值，并返回 undefined
instanceof
判斷對象是否是指定的對象類型
new
用于創(chuàng)建用戶自定義對象實例
in
判斷指定屬性是否是對象的屬性。當指定屬性是對象的屬性時返回真；否則返回假
　　

2.4.7  運算符的優(yōu)先級
　　運算符優(yōu)先級是指在一個表達式中，運算符的優(yōu)先順序，程序的執(zhí)行順序?qū)⒁罁?jù)運算符的優(yōu)先級順序。例如，在進行四則運算時，規(guī)則是先乘除、后加減，即乘法和除法的運算優(yōu)先級高于加法和減法的優(yōu)先級，同一優(yōu)先級的運算符按從左到右方式進行計算，這就是運算符的結(jié)合方式。所有的算術(shù)運算符都是從左向右執(zhí)行，所以如果有兩個或者更多的算術(shù)運算符有相同的優(yōu)先級，那么左邊的將先執(zhí)行，然后依次執(zhí)行。
　　如下面的表達式：
　　
x = 5 + 9 – 3 * 2 + 30/6
　　
　　該例子中，乘和除將首先被運算，接下來是加和減，運算中還包含了乘和除兩個優(yōu)先級相同的運算符號，所以左邊的乘法將先被執(zhí)行，然后是除；3*2等于6，30/6等于5，則原式變?yōu)椋簒=5+9–6+5，接下來按從左到右的順序進行加減運算，最后的結(jié)果x=13。
　　如果想改變運算的執(zhí)行順序，就需要使用成對的括號，括號內(nèi)的運算將比括號外的運算先執(zhí)行。如果同樣是上面幾個運算數(shù)，寫成下面的表達式：
　　
x = (5 + 9 – 3) * 2 + 30/6
　　
　　括號里的表達式將先被執(zhí)行，結(jié)果是11，原式變?yōu)閤=11*2+30/6，然后進行乘除運算，接下來是加減運算，最后的結(jié)果是27，這個結(jié)果與前一個例子的結(jié)果就完全不相同了。
　　如果兩個或者兩個以上的運算符有相同的優(yōu)先級，JavaScript根據(jù)運算符的執(zhí)行順序進行排序，一般都是從左向右。但是也有一些是從右向左。表2-10中列出了JavaScript中的運算符優(yōu)先級以及運算符的結(jié)合方式，同一優(yōu)先級的運算符放在同一行上，表格自上向下運算符的優(yōu)先級逐漸降低，在“結(jié)合性”一欄中列出的運算符的結(jié)合性是從右向左的，其余運算符的結(jié)合性均為從左向右。
表2-10  JavaScript中運算符優(yōu)先級和結(jié)合性
優(yōu)先級
運算符
結(jié)合性(從右向左)
1
括號運算, 函數(shù)調(diào)用, 數(shù)組游標

2
!, ~, +, -, ++, --, typeof, new,void, delete
+(一元加), -(一元減), ++, --, !, ~
3
*, /, %

4
+, -

5
<<, >>, >>>

6
<, <=, >, >=

7
= =, != , = = =, != =

8
&

9
^

10
|

11
&&

12
||


續(xù)表
優(yōu)先級
運算符
結(jié)合性(從右向左)
13
?:
?:
14
=, +=, -=, *=, /=, %=, <<=, >>=,>>>=, &=, ^=, !=
=, *=, /=, +=, -=,
%=, <<=, >>=,&=, ^=,!=
15
逗號 (,)操作符

　　
課 后 小 結(jié)
　　本章主要介紹了JavaScript語言的基本語法規(guī)則，以及數(shù)據(jù)類型、變量和運算符的基本使用方法，為后續(xù)JavaScript的流程控制語句的學習打下基礎。
習    題
一、填空題
　　1.??JavaScript里面的標識符不能以__________開頭。
　　2. 根據(jù)變量的作用域，可以把變量分為_____________或者____________。
　　3. 在JavaScript運算符中，______擁有最高的優(yōu)先級。
　　4.??__________運算符可以連接兩個字符串。
二、選擇題
　　1. 下面(    )是聲明變量和賦值的正確語法。
A．var myVariable="Hello";B．var myVariable=Hello;
C．"Hello" =var myVariable;D．var "Hello"= myVariable;
　　2. 下面( )是合法的變量名。
A．%varoable_name B．1varoable_name
C．varoable_nameD．+varoable_name
　　3. 下述(    )不是引用數(shù)據(jù)類型。
A．函數(shù)B．數(shù)組C．布爾類型D．對象
　　4. 下面(    )不是浮點數(shù)。
A．-439.35 B．3.17C．10D．-7e11
　　5. 下面(    )轉(zhuǎn)義字符可以在字符串中加入一個換行操作。
A．\bB．\fC．\nD．\r
　　6. 在語句return Value=count++中，如果count的初始值為10，則Value的值為(    )。
A．10B．11C．12D．20
　　7. 表達式50=="fifty"的值為(    )。
A．trueB．falseC．50D．“fifty”
　　
8. 如果x的值為1，執(zhí)行y=eval(x+"2*2")；語句后，y的值為(    )。
A．“1+2*2”B．“12*2”C．6D．24
三、上機練習題
　　定義3個變量，分別為整型、浮點型和字符串，對它們進行算術(shù)運算(加、減、乘、除等)，將結(jié)果輸出到頁面上。