JavaScript简介及JavaScript中的关键保留字、变量和数据类型

青旅半醒 2022-11-29 11:29 170阅读 0赞

##### 1. JavaScript简介 #####

JavaScript 诞生于 1995 年。它当时的目的是为了进行表单输入的验证。因为在 JavaScript 问世之前，表单的验证都是通过服务器端验证的。而当时都是电话拨号上网的年代，服务器验证数据是一件非常痛苦的事情。  
经过许多年的发展，JavaScript 从一个简单的输入验证成为一门强大的编程语言。所以 ，学会使用它是非常简单的，而真正掌握它则需要很漫长的时间。

###### 什么是 JavaScript ######

JavaScript 是一种具有面向对象能力的、解释型的程序设计语言。更具体一点，它是基于对象和事件驱动并具有相对安全性的客户端脚本语言。因为他不需要在一个语言环境下运行，而只需要支持它的浏览器即可。它的主要目的是，验证发往服务器端的数据、增加 Web互动、加强用户体验度等。

###### JavaScript 特点 ######

**松散性**  
JavaScript 语言核心与 C、C++、Java 相似，比如条件判断、循环、运算符等。但是它却是一种松散类型的语言，也就是说，它的变量不必具有一个明确的类型。  
**对象属性**  
JavaScript 中的对象把属性名映射为任意的属性值。它的这种方式很像哈希表或关联数组，而不像 C 中的结构体或者 C++、Java 中的对象。  
**继承机制**  
JavaScript 中的面向对象继承机制是基于原型的，这和另外一种不太为人所知的 Self 语言很像，而和 C++以及 Java 中的继承大不相同。

###### JavaScript 历史 ######

**引子**  
大概在 1992 年，有一家公司 Nombas 开发一种叫做 C–(C-minus-minus,简称 Cmm)的嵌入式脚本语言。后来觉得名字比较晦气，最终改名为 ScriptEase。而这种可以嵌入网页中的脚本的理念将成为因特网的一块重要基石。  
**诞生**  
1995 年，当时工作在 Netscape（网景)公司的布兰登（Brendan Eich）为解决类似于“向服务器提交数据之前验证”的问题。在 Netscape Navigator 2.0 与 Sun 公司联手开发一个称之为 LiveScript 的脚本语言。为了营销便利，之后更名为 JavaScript（目的是在 Java 这课大树下好乘凉）。  
**邪恶的后来者**  
因为 JavaScript 1.0 如此成功，所以微软也决定进军浏览器，发布了 IE 3.0 并搭载了一个 JavaScript 的克隆版，叫做 JScript（这样命名是为了避免与 Netscape 潜在的许可纠纷），并且也提供了自己的 VBScript。  
**标准的重要**  
在微软进入后，有 3 种不同的 JavaScript 版本同时存在：Netscape Navigator 3.0 中的 JavaScript、IE 中的 JScript 以及 CEnvi 中的 ScriptEase。与 C 和其他编程语言不同的是，JavaScript 并没有一个标准来统一其语法或特性，而这 3 种不同的版本恰恰突出了这个问题 。随着业界担心的增加，这个语言标准化显然已经势在必行。

###### ECMA ######

1997 年，JavaScript 1.1 作为一个草案提交给欧洲计算机制造商协会（ECMA）。第 39 技术委员会（TC39）被委派来“标准化一个通用、跨平台、中立于厂商的脚本语言的语法和语义”（http://www.ecma-international.org/memento/TC39.htm）。由来自 Netscape、Sun、微  
软、Borland 和其他一些对脚本编程感兴趣的公司的程序员组成的 TC39 锤炼出了 ECMA-262，该标准定义了叫做 ECMAScript 的全新脚本语言。  
**灵敏的微软、迟钝的网景**  
虽然网景开发了 JavaScript 并首先提交给 ECMA 标准化，但因计划改写整个浏览器引擎的缘故，网景晚了整整一年才推出“完全遵循 ECMA 规范”的 JavaScript1.3。而微软早在一年前就推出了“完全遵循 ECMA 规范”的 IE4.0。这导致一个直接恶果：JScript 成为 JavaScript 语言的事实标准。  
**标准的发展**  
在接下来的几年里，国际标准化组织及国际电工委员会（ISO/IEC）也采纳 ECMAScript 作为标准（ISO/IEC-16262）。从此，Web 浏览器就开始努力（虽然有着不同程度的成功和失败）将 ECMAScript 作为 JavaScript 实现的基础。  
**山寨打败原创**  
JScript 成为 JavaScript 语言的事实标准，加上 Windows 绑定着 IE 浏览器，几乎占据全部市场份额，因此，1999 年之后，所有的网页都是基于 JScript 来开发的。而 JavaScript1.x变成可怜的兼容者。  
**网景的没落与火狐的崛起**  
网景在微软强大的攻势下，1998 年全面溃败。但，星星之火可以燎原。同年成立 Mozilla 项目中 Firefox（火狐浏览器）在支持 JavaScript 方面无可比拟，在后来的时间里一步步蚕食 IE 的市场，成为全球第二大浏览器。  
**谷歌的野心**  
Google Chrome，又称 Google 浏览器，是一个由 Google（谷歌）公司开发的开放源代码的网页浏览器。他以简洁的页面，极速的浏览，一举成为全球第三大浏览器。随着移动互联网的普及，嵌有 Android 系统的平板电脑和智能手机，在浏览器这块将大有作为。  
**苹果的战略**  
Safari 浏览器是苹果公司各种产品的默认浏览器，在苹果的一体机（iMac）、笔记本（Mac）、MP4（ipod）、iphone（智能手机）、ipad（平板电脑），并且在 windows 和 Linux 平台都有相应版本。目前市场份额全球第四，但随着苹果的产品不断的深入人心，具有称霸之势。  
**幸存者**  
Opera 的全球市场份额第五，2%左右。它的背后没有财力雄厚的大公司，但它从“浏览器大战”存活下来的，有着非常大的潜力。

###### JavaScript核心 ######

虽然 JavaScript 和 ECMAScript 通常被人们用来表达相同的含义，但JavaScript 的含义却比ECMA-262中规定的要多得多。一个完整的JavaScript应该由下列三个不同的部分组成：

1.  核心（ECMAScript）
2.  文档对象模型（DOM）
3.  浏览器对象模型（BOM）

**ECMAScript 介绍**  
由 ECMAScript-262 定义的 ECMAScript 与 Web 浏览器没有依赖关系。ECMAScript 定义的只是这门语言的基础，而在此基础之上可以构建更完善的脚本语言。我们常见的 Web 浏览器只是 ECMAScript 实现可能的宿主环境之一。既然他不依赖于 Web 浏览器，那么他还在哪些环境中寄宿呢？比如：ActionScript、ScriptEase 等。而他的组成部分有：语法、类型、语句、关键字、保留字、操作符、对象等。  
**ECMAScript 版本**  
ECMAScript 目前有五个版本，1、2、3、4、5 版本，这里不再进行详细探讨。  
**Web 浏览器对 ECMAScript 的支持**  
到了 2008 年，五大主流浏览器（IE、Firefox、Safari、Chrome、Opera）全部做到了与 ECMA-262 兼容。其中，只有 Firefox 力求做到与该标准的第 4 版兼容。以下是支持表。

<table> 
 <thead> 
  <tr> 
   <th>浏览器</th> 
   <th>ECMAScript 兼容性</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Netscape Navigator 2</td> 
   <td>----</td> 
  </tr> 
  <tr> 
   <td>Netscape Navigator 3</td> 
   <td>----</td> 
  </tr> 
  <tr> 
   <td>Netscape Navigator 4 – 4.05</td> 
   <td>----</td> 
  </tr> 
  <tr> 
   <td>Netscape Navigator 4.06 – 4.79</td> 
   <td>第 1 版</td> 
  </tr> 
  <tr> 
   <td>Netscape 6+（Mozilla 0.6.0+）</td> 
   <td>第 3 版</td> 
  </tr> 
  <tr> 
   <td>Internet Explorer 3</td> 
   <td>----</td> 
  </tr> 
  <tr> 
   <td>Internet Explorer 4</td> 
   <td>----</td> 
  </tr> 
  <tr> 
   <td>Internet Explorer 5</td> 
   <td>第 1 版</td> 
  </tr> 
  <tr> 
   <td>Internet Explorer 5.5 – 7</td> 
   <td>第 3 版</td> 
  </tr> 
  <tr> 
   <td>Internet Explorer 8</td> 
   <td>第 3.1 版（不完全兼容）</td> 
  </tr> 
  <tr> 
   <td>Internet Explorer 9</td> 
   <td>第 5 版</td> 
  </tr> 
  <tr> 
   <td>Opera 6 - 7.1</td> 
   <td>第 2 版</td> 
  </tr> 
  <tr> 
   <td>Opera 7.2+</td> 
   <td>第 3 版</td> 
  </tr> 
  <tr> 
   <td>Opera 11+</td> 
   <td>第 5 版</td> 
  </tr> 
  <tr> 
   <td>Safari 3+</td> 
   <td>第 3 版</td> 
  </tr> 
  <tr> 
   <td>Firefox 1–2</td> 
   <td>第 3 版</td> 
  </tr> 
  <tr> 
   <td>Firefox 3/4/5/6/7/8/9</td> 
   <td>第 3/5 版</td> 
  </tr> 
 </tbody> 
</table>

**文档对象模型 （DOM）**  
文档对象模型（DOM，Document Object Model）是针对 XML 但经过扩展用于 HTML 的应用程序编程接口（API，Application Programming Interface）。DOM 有三个级别，每个级别都会新增很多内容模块和标准。以下是主流浏览器对 DOM 支持的情况：

<table> 
 <thead> 
  <tr> 
   <th>浏览器</th> 
   <th>DOM 兼容性</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Netscape Navigator 1 – 4.x</td> 
   <td>----</td> 
  </tr> 
  <tr> 
   <td>Netscape Navigator 6+（Mozilla 0.6.0+）</td> 
   <td>1 级、2 级（几乎全部）、3 级（部分）</td> 
  </tr> 
  <tr> 
   <td>Internet Explorer 2 – 4.x</td> 
   <td>----</td> 
  </tr> 
  <tr> 
   <td>Internet Explorer 5</td> 
   <td>1 级（最小限度）</td> 
  </tr> 
  <tr> 
   <td>Internet Explorer 5.5 – 7</td> 
   <td>1 级（几乎全部）</td> 
  </tr> 
  <tr> 
   <td>Opera 1 – 6</td> 
   <td>----</td> 
  </tr> 
  <tr> 
   <td>Opera 7 – 8.x</td> 
   <td>1 级（几乎全部）、2 级（部分）</td> 
  </tr> 
  <tr> 
   <td>Opera 9+</td> 
   <td>1 级、2 级（几乎全部）、3 级（部分）</td> 
  </tr> 
  <tr> 
   <td>Safari 1.0x</td> 
   <td>1 级</td> 
  </tr> 
  <tr> 
   <td>Safari 2+</td> 
   <td>1 级、2 级（部分）</td> 
  </tr> 
  <tr> 
   <td>Chrome 0.2+</td> 
   <td>1 级、2 级（部分）</td> 
  </tr> 
  <tr> 
   <td>Firefox 1+</td> 
   <td>1 级、2 级（几乎全部）、3 级（部分）</td> 
  </tr> 
 </tbody> 
</table>

**浏览器对象模型（BOM）**  
访问和操作浏览器窗口的浏览器对象模型（BOM，Browser Object Model）。开发人员使用 BOM 可以控制浏览器显示页面以外的部分。而 BOM 真正与众不同的地方（也是经常会导致问题的地方），还是它作为 JavaScript 实现的一部分，至今仍没有相关的标准。  
**JavaScript 版本**  
身为 Netscape“继承人”的 Mozilla 公司，是目前唯一沿用最初的 JavaScript 版本编号的浏览器开发商。在网景把 JavaScript 转手给 Mozilla 项目的时候，JavaScript 在浏览器中最后的版本号是 1.3。后来，随着 Mozilla 继续开发，JavaScript 版本号逐步递增。

<table> 
 <thead> 
  <tr> 
   <th>浏览器</th> 
   <th>JavaScript 版本</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Netscape Navigator 2</td> 
   <td>1.0</td> 
  </tr> 
  <tr> 
   <td>Netscape Navigator 3</td> 
   <td>1.1</td> 
  </tr> 
  <tr> 
   <td>Netscape Navigator 4</td> 
   <td>1.2</td> 
  </tr> 
  <tr> 
   <td>Netscape Navigator 4.06</td> 
   <td>1.3</td> 
  </tr> 
  <tr> 
   <td>Netscape 6+ （Mozilla 0.6.0+）</td> 
   <td>1.5</td> 
  </tr> 
  <tr> 
   <td>Firefox 1</td> 
   <td>1.5</td> 
  </tr> 
  <tr> 
   <td>Firefox 1.5</td> 
   <td>1.6</td> 
  </tr> 
  <tr> 
   <td>Firefox 2</td> 
   <td>1.7</td> 
  </tr> 
  <tr> 
   <td>Firefox 3</td> 
   <td>1.8</td> 
  </tr> 
  <tr> 
   <td>Firefox 3.1+</td> 
   <td>1.9</td> 
  </tr> 
 </tbody> 
</table>

##### 2. 使用JavaScript #####

######  ######

`<script>xxx</script>`这组标签，是用于在 html 页面中插入 js 的主要方法。它主要有以下几个属性：

*  charset：可选。表示通过 src 属性指定的字符集。由于大多数浏览器忽略它，所以很少有人用它。
 *  defer：可选。表示脚本可以延迟到文档完全被解析和显示之后再执行。由于大多数浏览器不支持，故很少用。
 *  language：已废弃。原来用于代码使用的脚本语言。由于大多数浏览器忽略它，所以不要用了。
 *  src：可选。表示包含要执行代码的外部文件。
 *  type：必需。可以看作是 language 的替代品。表示代码使用的脚本语言的内容类型。范例：`type="text/javascript"`。

###### JS代码嵌入的一些问题 ######

如果你想弹出一个`</script>`标签的字符串，那么浏览器会误解成 JS 代码已经结束了。解决的方法，就是把字符串分成两个部分，通过连接符‘+’来连接。

一般来说，JS 代码越来越庞大的时候，我们最好把他另存为一个.js 文件，通过 src 引入即可。它还具有维护性高、可缓存（加载一次，无需加载）、方便未来扩展的特点。

这样标签内就没有任何 JS 代码了。但是要注意的是，虽然没有任何代码，也不能用单标签：

也不能在里面添加任何代码：

按照常规，我们会把`<script>` 标签存放到`<head>...</head>` 之间。但有时也会放在 body 之间。  
不再需要提供注释，以前为了让不支持 JavaScript 浏览器能够屏蔽掉`<script>`内部的代码，我们习惯在代码的前后用 html 注释掉，现在已经不需要了。

平稳退化不支持 JavaScript 处理：`<nosciprt>`

##### 3. JavaScript语法构成 #####

**区分大小写**  
ECMAScript 中的一切，包括变量、函数名和操作符都是区分大小写的。例如：text 和 Text 表示两种不同的变量。  
**标识符**  
所谓标识符，就是指变量、函数、属性的名字，或者函数的参数。标识符可以是下列格式规则组合起来的一或多个字符：

1.  第一字符必须是一个字母、下划线(\_)或一个美元符号($)。
2.  其他字符可以是字母、下划线、美元符号或数字。
3.  不能把关键字、保留字、true、false 和 null 作为标识符。

标识符例子：myName、book123 等。  
**注释**  
ECMAScript 使用 C 风格的注释，包括单行注释和块级注释。

// 单行注释
    
    /*
    * 这是一个多行
    * 注释
    */

**直接量（字面量 literal）**  
所有直接量（字面量），就是程序中直接显示出来的数据值。

100 		// 数字字面量
    '李炎恢' 	// 字符串字面量
    false 		// 布尔字面量
    /js/gi 		// 正则表达式字面量
    null 		// 对象字面量

在 ECMAScript 第 3 版中，像数组字面量和对象字面量的表达式也是支持的，如下：

{x:1, y:2} 		// 对象字面量表达式
    [1,2,3,4,5] 	// 数组字面量表达式

##### 4. JavaScript中的关键字和保留字 #####

ECMAScript-262 描述了一组具有特定用途的关键字，一般用于控制语句的开始或结束，或者用于执行特定的操作等。关键字也是语言保留的，不能用作标识符。  
**ECMAScript 全部关键字**

<table> 
 <tbody> 
  <tr> 
   <td>break</td> 
   <td>else</td> 
   <td>new</td> 
   <td>var</td> 
  </tr> 
  <tr> 
   <td>case</td> 
   <td>finally</td> 
   <td>return</td> 
   <td>void</td> 
  </tr> 
  <tr> 
   <td>catch</td> 
   <td>for</td> 
   <td>switch</td> 
   <td>while</td> 
  </tr> 
  <tr> 
   <td>continue</td> 
   <td>function</td> 
   <td>this</td> 
   <td>with</td> 
  </tr> 
  <tr> 
   <td>default</td> 
   <td>if&gt;</td> 
   <td>throw</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>delete</td> 
   <td>in</td> 
   <td>try</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>do</td> 
   <td>instanceof</td> 
   <td>typeof</td> 
   <td></td> 
  </tr> 
 </tbody> 
</table>

ECMAScript-262 还描述了另一组不能用作标识符的保留字。尽管保留字在 JavaScript 中还没有特定的用途，但它们很有可能在将来被用作关键字。

**ECMAScript-262 第 3 版定义的全部保留字**

<table> 
 <tbody> 
  <tr> 
   <td>abstract</td> 
   <td>enum</td> 
   <td>int</td> 
   <td>short</td> 
  </tr> 
  <tr> 
   <td>boolean</td> 
   <td>export</td> 
   <td>interface</td> 
   <td>static</td> 
  </tr> 
  <tr> 
   <td>byte</td> 
   <td>extends</td> 
   <td>long</td> 
   <td>super</td> 
  </tr> 
  <tr> 
   <td>char</td> 
   <td>final</td> 
   <td>native</td> 
   <td>synchronized</td> 
  </tr> 
  <tr> 
   <td>class</td> 
   <td>float</td> 
   <td>package</td> 
   <td>throws</td> 
  </tr> 
  <tr> 
   <td>const</td> 
   <td>goto</td> 
   <td>private</td> 
   <td>transient</td> 
  </tr> 
  <tr> 
   <td>debugger</td> 
   <td>implements</td> 
   <td>protected</td> 
   <td>volatile</td> 
  </tr> 
  <tr> 
   <td>double</td> 
   <td>import</td> 
   <td>public</td> 
   <td></td> 
  </tr> 
 </tbody> 
</table>

##### 5. JavaScript中的变量 #####

ECMAScript 的变量是松散类型的，所谓松散类型就是用来保存任何类型的数据。定义变量时要使用 var 操作符（var 是关键词），后面跟一个变量名（变量名是标识符）。

var box;
    alert(box);

这句话定义了 box 变量，但没有对它进行初始化（也就是没有给变量赋值）。这时，系统会给它一个特殊的值 undefined（表示未定义）。

var box= '李炎恢';
    alert(box);

所谓变量，就是可以初始化后可以再次改变的量。ECMAScript 属于弱类型（松散类型）的语言，可以同时改变不同类型的量。

var boxString = '李炎恢';
    boxString = 100;
    alert(boxString);

重复的使用 var 声明一个变量，只不过是一个赋值操作，并不会报错。但这样的操作是比较二的，没有任何必要。

var box= '李炎恢';
    var box= 'Lee';

还有一种变量不需要前面 var 关键字即可创建变量。这种变量和 var 的变量有一定的区别和作用范围，我们会在作用域那一节详细探讨。

box= '李炎恢';

当你想声明多个变量的时候，可以在一行或者多行操作。

var box= '李炎恢';var age= 100;

而当你每条语句都在不同行的时候，你可以省略分号。

var box= '李炎恢'
    var age= 100
    alert(box)

可以使用一条语句定义多个变量，只要把每个变量（初始化或者不初始化均可）用逗号分隔开即可，为了可读性，每个变量，最好另起一行，并且第二变量和第一变量对齐。

var box= '李炎恢',
    	age = 28,
    	height;

##### 6. JavaScript中的数据类型 #####

ECMAScript 中有 5 种简单数据类型：Undefined、Null、Boolean、Number 和 String。还有一种复杂数据类型Object。ECMAScript 不支持任何创建自定义类型的机制，所有值都成为以上 6 种数据类型之一。

###### typeof 操作符 ######

typeof 操作符是用来检测变量的数据类型。对于值或变量使用 typeof 操作符会返回如下字符串。

<table> 
 <thead> 
  <tr> 
   <th>字符串</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>undefined</td> 
   <td>未定义</td> 
  </tr> 
  <tr> 
   <td>boolean</td> 
   <td>布尔值</td> 
  </tr> 
  <tr> 
   <td>string</td> 
   <td>字符串</td> 
  </tr> 
  <tr> 
   <td>number</td> 
   <td>数值</td> 
  </tr> 
  <tr> 
   <td>object</td> 
   <td>对象或 null</td> 
  </tr> 
  <tr> 
   <td>function</td> 
   <td>函数</td> 
  </tr> 
 </tbody> 
</table>

var box = '李炎恢';
    alert(typeof box);
    alert(typeof '李炎恢');

typeof 操作符可以操作变量，也可以操作字面量。虽然也可以这样使用：`typeof(box)`，但是typeof 是操作符而非内置函数。函数在 ECMAScript 中是对象，不是一种数据类型 。所以，使用 typeof 来区分 function 和 object 是非常有必要的。

###### Undefined 类型 ######

Undefined 类型只有一个值，即特殊的 undefined。在使用 var 声明变量，但没有对其初始化时，这个变量的值就是 undefined。

var box;
    alert(box);

我们没有必要显式的给一个变量赋值为 undefined，因为没有赋值的变量会隐式的（自动的）赋值为 undefined；而 undefined 主要的目的是为了用于比较，ECMAScript 第 3 版之前并没有引入这个值，引入之后为了正式区分空对象与未经初始化的变量。未初始化的变量与根本不存在的变量（未声明的变量）也是不一样的。

var box;
    alert(age); 		//age is not defined

如果 typeof box，typeof age 都返回的 undefined。从逻辑上思考，他们的值，一个是 undefined，一个报错；他们的类型，却都是 undefined。所以，我们在定义变量的时候，尽可能的不要只声明，不赋值。

###### Null 类型 ######

Null 类型是一个只有一个值的数据类型，即特殊的值 null。它表示一个空对象引用（指针），而 typeof 操作符检测 null 会返回 object。

var box = null;
    alert(typeof box);

如果定义的变量准备在将来用于保存对象，那么最好将该变量初始化为 null。这样，当检查 null 值就知道是否已经变量是否已经分配了对象引用了。

var box = null;
    if (box != null) {
    	alert('box 对象已存在！');
    }

有个要说明的是：undefined 是派生自 null 的，因此 ECMA-262 规定对它们的相等性测试返回 true。

alert(undefined == null);

由于 undefined 和 null 两个值的比较是相等的，所以，未初始化的变量和赋值为 null 的变量会相等。这时，可以采用 typeof 变量的类型进行比较。但是建议还是养成编码的规范 ，不要忘记初始化变量。

var box;
    var car = null;
    alert(typeof box == typeof car)

###### Boolean 类型 ######

Boolean 类型有两个值（字面量）：true 和 false。而 true 不一定等于 1，false 不一定等于 0 。JavaScript 是区分大小写的，True 和 False 或者其他都不是 Boolean 类型的值。

var box = true;
    alert(typeof box);

虽然 Boolean 类型的字面量只有 true 和 false 两种，但 ECMAScript 中所有类型的值都有与这两个 Boolean 值等价的值。要将一个值转换为其对应的 Boolean 值，可以使用转型函数Boolean()。

var hello = 'Hello World!';
    var hello2 = Boolean(hello);
    alert(typeof hello);

上面是一种显示转换，属于强制性转换。而实际应用中，还有一种隐式转换。比如，在 if 条件语句里面的条件判断，就存在隐式转换。

var hello = 'Hello World!';
    if (hello) {
    	alert('如果条件为 true，就执行我这条！');
    } else {
    	alert('如果条件为 false，就执行我这条！');
    }

**以下是其他类型转换成 Boolean 类型规则**

<table> 
 <thead> 
  <tr> 
   <th>数据类型</th> 
   <th>转换为 true 的值</th> 
   <th>转换为 false 的值</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Boolean</td> 
   <td>true</td> 
   <td>false</td> 
  </tr> 
  <tr> 
   <td>String</td> 
   <td>任何非空字符串</td> 
   <td>空字符串</td> 
  </tr> 
  <tr> 
   <td>Number</td> 
   <td>任何非零数字值（包括无穷大）</td> 
   <td>0 和 NaN</td> 
  </tr> 
  <tr> 
   <td>Object</td> 
   <td>任何对象</td> 
   <td>null</td> 
  </tr> 
  <tr> 
   <td>Undefined</td> 
   <td>&nbsp;</td> 
   <td>undefined</td> 
  </tr> 
 </tbody> 
</table>

###### Number 类型 ######

Number 类型包含两种数值：整型和浮点型。为了支持各种数值类型，ECMA-262 定义了不同的数值字面量格式。最基本的数值字面量是十进制整数。

var box = 100; 		// 十进制整数

八进制数值字面量，(以 8 为基数)，前导必须是 0，八进制序列(0~7)。

var box = 070; 		// 八进制，56
    var box = 079; 		// 无效的八进制，自动解析为 79
    var box = 08; 		// 无效的八进制，自动解析为 8

十六进制字面量前面两位必须是 0x，后面是(0~9 及 A~F)。

var box = 0xA; 		// 十六进制，10
    var box = 0x1f; 	// 十六进制，31

浮点类型，就是该数值中必须包含一个小数点，并且小数点后面必须至少有一位数字。

var box = 3.8;
    var box = 0.8;
    var box = .8; 		// 有效，但不推荐此写法

由于保存浮点数值需要的内存空间比整型数值大两倍，因此 ECMAScript 会自动将可以转换为整型的浮点数值转成为整型。

var box = 8.; 		//小数点后面没有值，转换为 8
    var box = 12.0; 	//小数点后面是 0，转成为 12

对于那些过大或过小的数值，可以用科学技术法来表示（e 表示法）。用 e 表示该数值的前面 10 的指数次幂。

var box = 4.12e9; 				// 即 4120000000
    var box = 0.00000000412; 		// 即 4.12e-9

虽然浮点数值的最高精度是 17 位小数，但算术运算中可能会不精确。由于这个因素，做判断的时候一定要考虑到这个问题（比如使用整型判断）。

alert(0.1+0.2); 	// 0.30000000000000004

浮点数值的范围在：Number.MIN\_VALUE ~ Number.MAX\_VALUE 之间。

alert(Number.MIN_VALUE);		// 最小值
    alert(Number.MAX_VALUE); 		// 最大值

如果超过了浮点数值范围的最大值或最小值，那么就先出现 Infinity(正无穷)或者-Infinity(负无穷)。

var box = 100e1000; 		// 超出范围，Infinity
    var box = -100e1000; 		// 超出范围，-Infinity

也可能通过 Number.POSITIVE\_INFINITY 和Number.NEGATIVE\_INFINITY 得到 Infinity（正无穷）及-Infinity（负无穷）的值。

alert(Number.POSITIVE_INFINITY); 	// Infinity（正无穷）
    alert(Number.NEGATIVE_INFINITY);	// -Infinity（负无穷）

要想确定一个数值到底是否超过了规定范围，可以使用 isFinite()函数。如果没有超过 ，返回 true，超过了返回 false。

var box = 100e1000;
    alert(isFinite(box)); 		// 返回 false 或者 true

NaN，即非数值（Not a Number）是一个特殊的值，这个数值用于表示一个本来要返回数值的操作数未返回数值的情况（这样就不会抛出错误了）。比如，在其他语言中，任何数值除以 0 都会导致错误而终止程序执行。但在 ECMAScript 中，会返回出特殊的值，因此不会影响程序执行。

var box = 0 / 0; 		// NaN
    var box = 12 / 0; 		// Infinity
    var box = 12 / 0 * 0; 	// NaN

可以通过 Number.NaN 得到 NaN 值，任何与 NaN 进行运算的结果均为 NaN，NaN 与自身不相等（NaN 不与任何值相等）。

alert(Number.NaN); 		// NaN
    alert(NaN+1); 			// NaN
    alert(NaN == NaN) 		// false

ECMAScript 提供了 isNaN()函数，用来判断这个值到底是不是 NaN。isNaN()函数在接收到一个值之后，会尝试将这个值转换为数值。

alert(isNaN(NaN)); 		// true
    alert(isNaN(25)); 		// false，25 是一个数值
    alert(isNaN('25')); 	// false，'25'是一个字符串数值，可以转成数值
    alert(isNaN('Lee')); 	// true，'Lee'不能转换为数值
    alert(isNaN(true)); 	// false true 可以转成成 1

isNaN()函数也适用于对象。在调用 isNaN()函数过程中，首先会调用 valueOf()方法，然后确定返回值是否能够转换成数值。如果不能，则基于这个返回值再调用 toString()方法，再测试返回值。

var box = {
    	toString : function () {
    		return '123'; 			// 可以改成 return 'Lee'查看效果
    	}
    };
    alert(isNaN(box)); 				// false

有 3 个函数可以把非数值转换为数值：Number()、parseInt()和 parseFloat()。Number()函数是转型函数，可以用于任何数据类型，而另外两个则专门用于把字符串转成数值。

alert(Number(true)); 		// 1，Boolean 类型的 true 和 false 分别转换成 1 和 0
    alert(Number(25)); 			// 25，数值型直接返回
    alert(Number(null)); 		// 0，空对象返回 0
    alert(Number(undefined)); 	// NaN，undefined 返回 NaN

如果是字符串，应该遵循一下规则：

1.  只包含数值的字符串，会直接转成成十进制数值，如果包含前导 0，即自动去掉。

alert(Number('456')); 		// 456
    alert(Number('070')); 		// 70

1.  只包含浮点数值的字符串，会直接转成浮点数值，如果包含前导和后导 0，即自动去掉。

alert(Number('08.90')); 	// 8.9

1.  如果字符串是空，那么直接转成成 0。

alert(Number('')); 			// 0

1.  如果不是以上三种字符串类型，则返回 NaN。

alert('Lee123'); 			// NaN

1.  如果是对象，首先会调用 valueOf()方法，然后确定返回值是否能够转换成数值。如果转换的结果是 NaN，则基于这个返回值再调用 toString()方法，再测试返回值。

var box = {
    	toString : function () {
    		return '123'; 		// 可以改成 return 'Lee'查看效果
    	}
    };
    alert(Number(box)); 		// 123

由于 Number()函数在转换字符串时比较复杂且不够合理，因此在处理整数的时候更常用的是 parseInt()。

alert(parsetInt('456Lee')); 		// 456，会返回整数部分
    alert(parsetInt('Lee456Lee')); 		// NaN，如果第一个不是数值，就返回 NaN
    alert(parseInt('12Lee56Lee')); 		// 12，从第一数值开始取，到最后一个连续数值结束
    alert(parseInt('56.12')); 			// 56，小数点不是数值，会被去掉
    alert(parseInt('')); 				// NaN，空返回 NaN

parseInt()除了能够识别十进制数值，也可以识别八进制和十六进制。

alert(parseInt('0xA')); 			// 10，十六进制
    alert(parseInt('070')); 			// 56，八进制
    alert(parseInt('0xALee')); 			// 100，十六进制，Lee 被自动过滤掉

ECMAScript 为 parseInt()提供了第二个参数，用于解决各种进制的转换。

alert(parseInt('0xAF')); 			// 175，十六进制
    alert(parseInt('AF',16)); 			// 175，第二参数指定十六进制，可以去掉 0x 前导
    alert(parseInt('AF')); 				// NaN，理所当然
    alert(parseInt('101010101',2)); 	// 314，二进制转换
    alert(parseInt('70',8)) 			// 56，八进制转换

parseFloat()是用于浮点数值转换的，和 parseInt()一样，从第一位解析到非浮点数值位置。

alert(parseFloat('123Lee')); 		// 123，去掉不是别的部分
    alert(parseFloat('0xA')); 			// 0，不认十六进制
    alert(parseFloat('123.4.5')); 		// 123.4，只认一个小数点
    alert(parseFloat('0123.400')); 		// 123.4，去掉前后导
    alert(parseFloat('1.234e7')); 		// 12340000，把科学技术法转成普通数值

###### String 类型 ######

String 类型用于表示由零个或多个 16 位 Unicode 字符组成的字符序列，即字符串。字符串可以由双引号(")或单引号(’)表示。

var box = 'Lee';
    var box = "Lee";

在某些其他语言（PHP）中，单引号和双引号表示的字符串解析方式不同，而ECMAScript 中，这两种表示方法没有任何区别。但要记住的是，必须成对出现，不能穿插使用，否则会出错。

var box = '李炎恢"; 	// 出错

String 类型包含了一些特殊的字符字面量，也叫转义序列。

<table> 
 <thead> 
  <tr> 
   <th>字面量</th> 
   <th>含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>\n</td> 
   <td>换行</td> 
  </tr> 
  <tr> 
   <td>\t</td> 
   <td>制表</td> 
  </tr> 
  <tr> 
   <td>\b</td> 
   <td>空格</td> 
  </tr> 
  <tr> 
   <td>\r</td> 
   <td>回车</td> 
  </tr> 
  <tr> 
   <td>\f</td> 
   <td>进纸</td> 
  </tr> 
  <tr> 
   <td><code>\\</code></td> 
   <td>斜杠</td> 
  </tr> 
  <tr> 
   <td>\’</td> 
   <td>单引号</td> 
  </tr> 
  <tr> 
   <td>\"</td> 
   <td>双引号</td> 
  </tr> 
  <tr> 
   <td>\xnn</td> 
   <td>以十六进制代码 nn 表示的一个字符(0~F)。例：\x41</td> 
  </tr> 
  <tr> 
   <td>\unnn</td> 
   <td>以十六进制代码nnn表示的一个Unicode字符(0~F)。例：\u03a3</td> 
  </tr> 
 </tbody> 
</table>

ECMAScript 中的字符串是不可变的，也就是说，字符串一旦创建，它们的值就不能改变。要改变某个变量保存的字符串，首先要销毁原来的字符串，然后再用另一个包含新值的字符串填充该变量。

var box = 'Mr.';
    box = box + ' Lee';

toString()方法可以把值转换成字符串。

var box = 11;
    var box = true;
    alert(typeof box.toString());

toString()方法一般是不需要传参的，但在数值转成字符串的时候，可以传递进制参数。

var box = 10;
    alert(box.toString()); 		// 10，默认输出
    alert(box.toString(2)); 	// 1010，二进制输出
    alert(box.toString(8)); 	// 12，八进制输出
    alert(box.toString(10)); 	// 10，十进制输出
    alert(box.toString(16)); 	// a，十六进制输出

如果在转型之前不知道变量是否是 null 或者 undefined 的情况下，我们还可以使用转型函数 String()，这个函数能够将任何类型的值转换为字符串。

var box = null;
    alert(String(box));

如果值有 toString()方法，则调用该方法并返回相应的结果；如果是 null 或者undefined，则返回"null"或者"undefined"。

###### Object 类型 ######

ECMAScript 中的对象其实就是一组数据和功能的集合。对象可以通过执行 new 操作符后跟要创建的对象类型的名称来创建。

var box = new Object();

Object()是对象构造，如果对象初始化时不需要传递参数，可以不用写括号，但这种方式我们是不推荐的。

var box = new Object;

Object()里可以任意传参，可以传数值、字符串、布尔值等。而且，还可以进行相应的计算。

var box = new Object(2); 	// Object 类型，值是 2
    var age = box + 2; 			// 可以和普通变量运算
    alert(age); 				// 输出结果，转型成 Number 类型了

既然可以使用 new Object()来表示一个对象，那么我们也可以使用这种 new 操作符来创建其他类型的对象。

var box = new Number(5); 	// new String('Lee')、new Boolean(true)
    alert(typeof box); 			// Object 类型