JavaScript基础知识点

本书目录

第一章：  JavaScript语言基础

第二章：  JavaScript内置对象
第三章：  窗口window对象
第四章：  文档document对象
第五章：  表单form对象
第六章：  History与Navigator对象
第七章：  JavaScript框架编程
第八章：  JavaScript异常处理

第九章：  自定义JavaScript对象

 

 

第一章 JavaScript语言基础

 
  1. 什么是JavaScript  
  2. JavaScript是一种基于对象(Object)和事件驱动(Event Driven)并具有安全性能的脚本语  
  3. 言。  
  4. JavaScript的出现弥补了HTML语言的不足，它是Java与HTML折中的选择，具有以下几个基  
  5. 本特点。  
  6. 1、脚本编写  
  7. JavaScript是一种脚本语言，它采用小程序段的方式实现编程。它作为一种解释性语言，不需要  
  8. 进行编译，而是在程序运行过程中逐行地被解释。  
  9. 2、基于对象  
  10. JavaScript是一种基于对象的语言，这意味着它能运用自己已经创建的对象。因此，许多功能可  
  11. 能来自于JavaScript运行环境（即浏览器本身）中对象的方法与JavaScript的对象相互作用。  
  12. 3、简单性  
  13. JavaScript的简单性首先主要体现在它基于Java的基本语句和控制流，是一种简单而紧凑的  
  14. 语言，对于学习Java是一种非常好的过度；其次，它的变量类型是采用“弱类型”，并未使用严格  
  15. 的数据类型。  
  16. 4、安全性  
  17. JavaScript是一种安全性语言，它不允许访问本地的硬盘，而且不能将数据存入到服务器上；  
  18. 不允许对网络文档进行修改和删除，只能通过浏览器实现信息浏览或动态交互，从而有效地防止数据  
  19. 的丢失。  
  20. 5、动态性  
  21. JavaScript是动态的，它可以直接对用户或客户输入做出响应而无需经过Web服务程序。它对  
  22. 用户的响应是采用以事件驱动的方式进行的。所谓事件驱动，就是指在页面中执行某种操作所产生的动  
  23. 作，比如按下鼠标、移动窗口或选择菜单等都可以视为事件，当事件发生后就会引起相应的事件响应。  
  24. 6、跨平台性  
  25. JavaScript仅依赖于浏览器本身，与操作系统无关，只要是能运行浏览器的计算机，并支持  
  26. JavaScript的浏览器就可以正确执行。从而实现“编写一下，走遍天下” 的梦想。  
  27.   
  28. Java和Javascript的区别  
  29. 1、基于对象和面向对象  
  30. Java是一种真正的面向对象的语言，即使是开发简单的程序，必须设计对象。  
  31. JavaScript是种脚本语言，它可以用来制作与网络无关的，与用户交互作用的复杂软件。它是  
  32. 一种基于对象（Object Based）和事件驱动（Event Driver）的编程语言。因而它本身提供了非  
  33. 常丰富的内部对象供设计人员使用。  
  34. 2、解释和编译  
  35. 两种语言在其浏览器中所执行的方式不一样。Java的源代码在传递到客户端执行之前，必须经过  
  36. 编译，因而客户端上必须具有相应平台上的仿真器或解释器，它可以通过编译器或解释器实现独立  
  37. 于某个特定的平台编译代码的束缚。  
  38. JavaScript是一种解释性编程语言，其源代码在发往客户端执行之前不需经过编译，而是将文  
  39. 本格式的字符代码发送给客户编由浏览器解释执行。  
  40. 3、强变量和弱变量  
  41. 两种语言所采取的变量是不一样的。  
  42. Java采用强类型变量检查，即所有变量在编译之前必须作声明。  
  43. JavaScript中变量声明，采用其弱类型。即变量在使用前不需作声明，而是解释器在运行时检  
  44. 查其数据类型，  
  45. 4、代码格式不一样  
  46. Java是一种与HTML无关的格式，必须通过像HTML中引用外媒体那么进行装载，其代码以字节  
  47. 代码的形式保存在独立的文档中。  
  48. JavaScript的代码是一种文本字符格式，可以直接嵌入HTML文档中，并且可动态装载。编写  
  49. HTML文档就像编辑文本文件一样方便。  
  50. 5、嵌入方式不一样  
  51. 在HTML文档中，两种编程语言的标识不同，JavaScript使用<Script>...</Script>来标  
  52. 识，而Java使用<applet>...</applet>来标识，或采用java脚本语言。  
  53. 6、静态联编和动态联编  
  54. Java采用静态联编，即Java的对象引用必须在编译时的进行，以使编译器能够实现强类型检查。  
  55. JavaScript采用动态联编，即JavaScript的对象引用在运行时进行检查，如不经编译则就  
  56. 无法实现对象引用的检查。  
  57.   
  58. 第一节 语言基础  
  59. 编写JavaScript程序  
  60. 1、JavaScript直接嵌入HTML文件中  
  61. 写在head或body标记对之间，要加标记如下：  
  62. <script language="javascript">  
  63. document.write("<font color=blue>Hello World!</font>");  
  64. </script>  
  65. 2、JavaScript程序存放在单独的.js文件中，再在HTML文件中链接  
  66. <head>  
  67. <script language="javascript" SRC="xxx.js"></script>  
  68. </head>  
  69. <body>  
  70. <form>  
  71. <input type=button onclick=show()>  
  72. </form>  
  73. </body>  
  74. 在.js文件中直接书写javascript代码即可。  
  75. function show(){  
  76. document.write("hello world!");  
  77. }  
  78. 基本数据类型  
  79. 在JavaScript中有四种基本的数据类型：  
  80. 数值型（整数和实数）  
  81. 字符串型（用""号或''号括起来的字符或数值）  
  82. 布尔型（使用true或false表示）  
  83. 空值（null）  
  84. 变量  
  85. 在程序执行过程中值可变的量，是系统内存中的一个命名的存储单元。  
  86. 变量的命名：  
  87.   
  88. 变量名以字母开头，中间可以出现数字，下划线。变量名不能有空格、+或其他符号  
  89. 不能使用JavaScript的关键字作为变量。如：var、int、double、delete  
  90. 变量名第一个单词全部小写，第二个单词开始每个单词的首字母大写，其余字母小写。  
  91. 声明（定义）变量：  
  92. var x, myString;  
  93. var y=100, st="hello";  
  94. cost=23.6;  
  95. JavaScript中的保留字（关键字）：  
  96. abstract boolean break byte case catch  
  97. char class const continue default do  
  98. double else extends false final finally  
  99. float for function goto if implements  
  100. import in instanceof int interface long  
  101. native new null package private protected  
  102. public return short static super switch  
  103. synchronized this throw throws transient true  
  104. try var void while with  
  105. 变量的作用域  
  106. 在JavaScript中有全局变量和局部变量之分。全局变量时定义在所有函数体之外，其作用范围  
  107. 是所有函数；而局部变量时定义在函数体之内，只对该函数是可见的。  
  108. <script language="javascript">  
  109. var quanju=100;  
  110. function get(){  
  111. var i=10;  
  112. if(true){  
  113. var j=1;  
  114. }  
  115. }  
  116. </script>  
  117. 常量  
  118. 在程序执行过程中其值不可改变的量。  
  119. 1、整型常量  
  120. 如：123 ，512  
  121. 2、实型常量  
  122.   
  123. 实型常量是由整数部分加小数部分表示，如3.14，12.43等，也可以使用科学或标准方法表示，  
  124. 如5E7，4e5等。  
  125. 3、布尔值  
  126. 布尔常量只有两种取值true 或false。主要用来说明或代表一种状态或标志，用以控制操作流  
  127. 程  
  128. 4、字符型常量  
  129. 字符型常量是指使用单引号（'）括起来的字符或双引号（"）括起来的字符串。例如，字符'a'，  
  130. 字符串 "hello"。  
  131. JavaScript也支持以反斜杠（\）开头的不可显示的特殊字符，通常称为控制字符。例如换行符  
  132. （'\r'）、制表符（'\t'）等  
  133. 5、空值  
  134. JavaScript中有一个空值null，表示什么也没有。如试图引用没有定义的变量，就会返回一个  
  135. null值。  
  136. 运算符  
  137. 运算符是完成某种操作的符号。  
  138. 算术运算符：+, -, *, /, %, ++, --  
  139. 比较运算符：= =, >, >=, <, <=, !=  
  140. 逻辑运算符：&&, ||, !  
  141. 赋值运算符：=, +=, -=, *=, /=,  
  142. 表达式  
  143. x=100;  
  144. str="你好";  
  145. t=null;  
  146. 表达式通常是由变量、常量和函数通过运算符构成的有意义的算式。  
  147. 如：a, a*2/3, (x+y)*10+(z-3)*20, x==y  
  148. 第二节 控制结构  
  149. 1、if 语句  
  150. if (表达式){  
  151. 语句块;  
  152. }  
  153. x=80;  
  154. if (x>=60){  
  155. document.write( "恭喜你，及格了！");  
  156. }  
  157. if (表达式){  
  158. 语句块1 ;  
  159. }else{  
  160. 语句块2 ;  
  161. }  
  162. if (x>=0){  
  163. y=x;  
  164. }else{  
  165. y=-x;  
  166. }  
  167. 2、switch语句  
  168. switch(表达式) {  
  169. case 值1：语句1; break;  
  170. case 值2：语句2; break;  
  171. case 值3：语句3; break;  
  172. default: 语句4;  
  173. }  
  174. <script language="javascript">  
  175. function getWeek(week){  
  176. switch(week){  
  177. case 0:  
  178. st="星期日";  
  179. break;  
  180. case 1:  
  181. st="星期一";  
  182. break;  
  183. case 2:  
  184. st="星期二";  
  185. break;  
  186. case 3:  
  187. st="星期三";  
  188. break;  
  189. case 4:  
  190. st="星期四";  
  191. break;  
  192. case 5:  
  193. st="星期五";  
  194. break;  
  195. case 6:  
  196. st="星期六";  
  197. break;  
  198. default:  
  199. st="错误";  
  200. }  
  201. return st;  
  202. }  
  203. </script>  
  204. 3、for 语句  
  205. for (初值表达式; 条件表达式; 更新语句) {  
  206. //循环体语句  
  207. }  
  208. 4、While语句  
  209. while(条件表达式) {  
  210. //循环体语句  
  211. }  
  212. break语句：结束当前的循环或switch语句。  
  213. continue语句：用于for或while语句中，结束本次循环，继续下一次循环。  
  214.   
  215. 第三节 函数  
  216. 函数是一个设定名字的一系列JavaScript语句的有效组合。  
  217. 函数可以带参数，也可以不带，可以有返回值，也可以没有  
  218. 1、函数的定义  
  219. function 函数名([参数列表]) {  
  220. 语句块;  
  221. [return 表达式;]  
  222. }  
  223. <script language="javascript">  
  224. //例：返回两个参数中较大的。  
  225. function max(a,b){  
  226. var x;  
  227. if (a>b)  
  228. x=a;  
  229. else  
  230. x=b;  
  231. return x;  
  232. }  
  233. </script>  
  234. 2、调用函数  
  235. 函数被调用时函数内的代码才真正被执行。  
  236. 调用函数的方法就是使用函数的名称并赋给全部参数相应的值。  
  237. <script language="javascript">  
  238. max(20,30);  
  239. </script>  
  240. 或  
  241. <input type="button" onClick="max(23,45);">  
  242.   
  243. 在JavaScript中调用函数时，可以向函数传递比在函数定义时参数数目要少的参数。在这种情  
  244. 况下，只要不是试图去读那些没有传递过来的参数就行。  
  245. 用typeof运算符可以得到参数的类型。对于未传递的参数，用typeof运算符得到的结果是  
  246. “undefined”。示例如下：  
  247. <script language="javascript">  
  248. function get(a,b){  
  249. document.write("参数a的数据类型是："+typeof(a)+"<br>");  
  250. document.write("参数b的数据类型是："+typeof(b));  
  251. }  
  252. get(32.4);  
  253. </script>  
  254.   
  255. 另外，JavaScript也可以向函数传递比在函数定义时参数数目要多的参数，为了读取这样的参  
  256. 数，可以使用arguments数组。传递给函数的第一个参数是arguments数组的第一个元素，我们可  
  257. 以用“函数名称.arguments[0]”来进行引用。示例如下：  
  258. <script language="javascript">  
  259. function getSum(){  
  260. var sum=0;  
  261. var number=getSum.arguments.length;//使用函数的参数数组  
  262. for(var i=0;i<number;i++){  
  263. sum+=getSum.arguments[i];  
  264. }  
  265. return sum;  
  266. }  
  267. document.write("23+54+65="+getSum(23,54,65));  
  268. </script>  
  269.   
  270. 第四节 JavaScript系统函数  
  271. JavaScript中的系统函数又称为内部方法，它们不属于任何对象，可以直接使用。它们可以完成许  
  272. 多很常用的功能。  
  273. 1、 eval( 字符串表达式)  
  274. 返回字符串表达式中的运算结果值。  
  275. 例：test=eval("x=8+9+5/2");  
  276. document.write(test); //输出显示19.5  
  277. 2、 escape(字符串)  
  278. 返回字符串的一种简单编码，将非字母数字的符号转换为%加其unicode码的十六进制表示。  
  279. 例如: escape("Hello there") 返回 "Hello%20there"  
  280. 3、unescape(字符串)  
  281. 将已编码的字符串还原为纯字符串。  
  282. 4、parseFloat(字符串)  
  283. 返回浮点数  
  284. 5、parseInt(字符串,radix)  
  285. 其中radix是数的进制，默认是十进制数 parseInt(字符串)  
  286. 第五节 事件驱动及事件处理  
  287. 在JavaScript中编写的函数，通常是在其他代码进行调用时才会执行。不过我们也可以将某个  
  288. 函数与某个事件（Event，通常是鼠标或热键的动作）联系起来，使得当事件发生时执行该函数。这个  
  289. 方法称之为事件驱动（Event Driver）。而对事件进行处理的函数，称之为事件处理程序（Event  
  290. Handler事件句柄）。  
  291. 1、事件  
  292. JavaScript事件驱动中的事件是通过鼠标或热键的动作（点击或按下）引发的。下表中列出了  
  293. 常见的事件及其说明。  
  294. FF: Firefox, N: Netscape, IE: Internet Explorer  
  295. 属性说明FF N IE  
  296. onabort 图像加载被中断1 3 4  
  297. onblur 元素失去焦点1 2 3  
  298. onchange 用户改变域的内容1 2 3  
  299. onclick 鼠标点击某个对象1 2 3  
  300. ondblclick 鼠标双击某个对象1 4 4  
  301. onerror 当加载文档或图像时发生某个错误1 3 4  
  302. onfocus 元素获得焦点1 2 3  
  303. onkeydown 某个键盘的键被按下1 4 3  
  304. onkeypress 某个键盘的键被按下或按住1 4 3  
  305. onkeyup 某个键盘的键被松开1 4 3  
  306. onload 某个页面或图像被完成加载1 2 3  
  307. onmousedown 某个鼠标按键被按下1 4 4  
  308. onmousemove 鼠标被移动1 6 3  
  309. onmouseout 鼠标从某元素移开1 4 4  
  310. onmouseover 鼠标被移到某元素之上1 2 3  
  311. onmouseup 某个鼠标按键被松开1 4 4  
  312. onreset 重置按钮被点击1 3 4  
  313. onresize 窗口或框架被调整尺寸1 4 4  
  314. onselect 文本被选定1 2 3  
  315. onsubmit 提交按钮被点击1 2 3  
  316. onunload 用户退出页面1 2 3  
  317. 2、事件与函数的关联  
  318. 要将一个函数与某个HTML元素的事件关联起来，需要设置相应的HTML标记中的属性值。例如，  
  319. 对于一个button元素的click事件的处理函数为MyProc()，则可以用如下的形式将事件与函数关  
  320. 联起来：  
  321. <script language="javascript">  
  322. function myPorc(){  
  323. alert(document.all("txt").value);  
  324. }  
  325. </script>  
  326. <input type="text" name="txt" />  
  327. <input type="button" value="Try" onClick="myPorc( );"/>  
  328. 另一个示例,实现翻转图的效果，原来在网页上显示一幅图片，当用户把鼠标移到该图像上时，自  
  329. 动将图像切换成新的一幅图片；当用户把鼠标移开时，最初的图像又被恢复回来。  
  330. <script language="javascript">  
  331. //处理mouseover事件  
  332. function imgover(){  
  333. document.myForm.img1.src="color.jpg";  
  334. }  
  335. //处理mouseout事件  
  336. function imgout(){  
  337. document.myForm.img1.src="gray.jpg";  
  338. }  
  339. </script>  
  340. <form name="myForm">  
  341. <img border=0 name="img1" src="gray.jpg"  
  342. onmouseover="imgover();"  
  343. onmouseout="imgout()">  
  344. </form>  
  345.   
  346. 课后练习题：  
  347. 1、计算1加到100的和  
  348. 2、使用while语句计算1加到100的和  
  349. 3、打印100以内的偶数序列 ：02468。。。  
  350. 4、循环1-100，单数次输出“好好学习！”，偶数次输出“天天向上！”  
  351. 5、在死循环中用if和break实现连续打印20个*就结束循环。  
  352. 6、编程查找满足下列条件的三个正整数：x+y+z=50并且x+2*y+5*z=100  
  353. 7、编写函数输出下面的图案  
  354. *  
  355. **  
  356. ***  
  357. ****  
  358. 最多的星数目为函数参数n所决定。  
  359. 8、将a,b,c三个整数按它们数值的大小，从小到大的顺序打印显示。  
  360. （练习if else语句）  
  361. 9、编写函数输出下面的图案  
  362. *  
  363. **  
  364. ***  
  365. ****  
  366. ***  
  367. **  
  368. *  
  369. 行数为函数的参数n决定。  
  370. 10、编写函数寻找水仙花数。  
  371. （三位数各位数字的立方和恰巧是该数本身，100到999之间有四个这样的数）。<strong><span style="font-size:32px;color:#ff0000;">  
  372. </span></strong>  

第二章 JavaScript内置对象

 
  1. 对象概述  
  2. JavaScript是一种基于对象的脚本语句，而不是面向对象的编程语言。  
  3. 对象就是客观世界存在的实体，具有属性和方法两方面特性。  
  4. 访问对象的属性和方法的方式如下：  
  5. 对象名.属性  
  6. 对象名.方法名()  
  7. 第一节 数组对象类型 Array  
  8. 数组可以存放很多相同类型的数据。有数组名代表所有这些数据，而用  
  9. 数组名[下标]表示其中某个元素（下标从0开始）。  
  10. 如：var myA=["张三","李四","王五"];  
  11. document.write(myA); //看到所有三个字符串  
  12. myA[0]指向第一个元素  
  13. myA[2]指向第三个元素  
  14. １、建立数组的三种方法：  
  15. (1) 使用方括号，创建数组的同时赋初值  
  16. var myA=["张三", "李四","王五"];  
  17. var b=[10,20,30,40];  
  18. (2) 使用new 操作符，创建数组的同时赋初值  
  19. var myA=new Array("张三", "李四","王五");  
  20. 注意圆括号和方括号的区别，不能任意使用。  
  21. (3) 先创建长度为10的数组，内容后面再赋值  
  22. var anArray = new Array(9);  
  23. anArray[0]= "张三";  
  24. anArray[1]= "李四";  
  25. anArray[2]= "王五";  
  26.   
  27. ２、数组的属性  
  28. length  
  29. 数组名.length 返回数组中元素的个数  
  30. 如：myA.length 为 3  
  31. 例：使用for语句输出myA数组的各个元素。  
  32. for(i=0;i<myA.length;i++){  
  33. alert(myA[i]);  
  34. }  
  35. ３、数组的方法  
  36. join(分割符)  
  37. 该方法的功能是把数组中所有数据用指定的分割符连接起来，以一个字符串的形式表达出来。  
  38. 例如：  
  39. myA.join("/") 返回一个字符串 "张三/李四/王五"  
  40. reverse()  
  41. 该方法的功能是将数组中的元素整个反转顺序。  
  42. 例如：  
  43. myA.reverse( ) 数组变为 ["王五","李四","张三"]  
  44. sort()  
  45. 该方法的功能是将数组元素排序（汉字按拼音的字母顺序）。  
  46. 例如：  
  47. myA.sort () 数组变为 ["李四","王五","张三"]  
  48. concat()  
  49. 方法用于连接两个或多个数组。  
  50. 下面的例子将把 concat() 中的参数连接到数组 a 中  
  51. <script type="text/javascript">  
  52. var a = [1,2,3];  
  53. document.write(a.concat(4,5));  
  54. //输出结果是：  
  55. //1,2,3,4,5  
  56. </script>  
  57. 下面的例子创建了两个数组，然后使用 concat() 把它们连接起来  
  58. <script type="text/javascript">  
  59. var arr = ["George","John","Thomas"];  
  60. var arr2 = ["James","Adrew","Martin"];  
  61. document.write(arr.concat(arr2));  
  62. //输出结果是：  
  63. //George,John,Thomas,James,Adrew,Martin  
  64. </script>  
  65. 下面的例子创建了三个数组，然后使用 concat() 把它们连接起来  
  66. <script type="text/javascript">  
  67. var arr = ["George","John","Thomas"];  
  68. var arr2 = ["James","Adrew","Martin"];  
  69. var arr3 = ["William","Franklin"];  
  70. document.write(arr.concat(arr2,arr3));  
  71. //输出结果是：  
  72. //George,John,Thomas,James,Adrew,Martin,William,Franklin  
  73. </script>  
  74. pop()  
  75. 方法用于删除并返回数组的最后一个元素。  
  76. 删除数组的最后一个元素，把数组长度减 1，并且返回它删除的元素的值。如果数组已经为空，  
  77. 则 pop() 不改变数组，并返回 undefined 值。  
  78. <script type="text/javascript">  
  79. var arr = ["George","John","Thomas"];  
  80. document.write(arr);  
  81. document.write("<br />");  
  82. document.write(arr.pop());  
  83. document.write("<br />");  
  84. document.write(arr);  
  85. //输出结果是：  
  86. //George,John,Thomas  
  87. //Thomas  
  88. //George,John  
  89. </script>  
  90. push()  
  91. 方法可向数组的末尾添加一个或多个元素，并返回新的长度。  
  92. 语法：arrayObject.push(newelement1,newelement2,....,newelementX)  
  93. push() 方法可把它的参数顺序添加到 arrayObject 的尾部。它直接修改 arrayObject，而  
  94. 不是创建一个新的数组。push() 方法和 pop() 方法使用数组提供的先进后出栈的功能。  
  95. <script type="text/javascript">  
  96. var arr = ["George","John","Thomas"];  
  97. document.write(arr + "<br />");  
  98. document.write(arr.push("James") + "<br />");  
  99. document.write(arr);  
  100. //输出结果是：  
  101. //George,John,Thomas  
  102. //4  
  103. //George,John,Thomas,James  
  104. </script>  
  105. shift()  
  106. 方法用于把数组的第一个元素从其中删除，并返回第一个元素的值。  
  107. 如果数组是空的，那么 shift() 方法将不进行任何操作，返回 undefined 值。请注意，该方  
  108. 法不创建新数组，而是直接修改原有的 arrayObject。  
  109. <script type="text/javascript">  
  110. var arr = ["George","John","Thomas"];  
  111. document.write(arr + "<br />");  
  112. document.write(arr.shift() + "<br />");  
  113. document.write(arr);  
  114. //输出结果是：  
  115. //George,John,Thomas  
  116. //George  
  117. //John,Thomas  
  118. </script>  
  119. unshift()  
  120. 方法可向数组的开头添加一个或更多元素，并返回新的长度。  
  121. unshift() 方法将把它的参数插入 arrayObject 的头部，并将已经存在的元素顺次地移到  
  122. 较高的下标处，以便留出空间。该方法的第一个参数将成为数组的新元素 0，如果还有第二个参数，  
  123. 它将成为新的元素 1，以此类推。  
  124. 请注意，unshift() 方法不创建新的创建，而是直接修改原有的数组。  
  125. <script type="text/javascript">  
  126. var arr = ["George","John","Thomas"];  
  127. document.write(arr + "<br />");  
  128. document.write(arr.unshift("William") + "<br />");  
  129. document.write(arr);  
  130. //输出结果是：  
  131. //George,John,Thomas  
  132. //4  
  133. //William,George,John,Thomas  
  134. </script>  
  135. slice(start,end)  
  136. 从已有的数组中返回选定的元素。  
  137. <script type="text/javascript">  
  138. var arr = ["George","John","Thomas"];  
  139. document.write(arr + "<br />");  
  140. document.write(arr.slice(1) + "<br />");  
  141. document.write(arr);  
  142. //输出结果是：  
  143. //George,John,Thomas  
  144. //John,Thomas  
  145. //George,John,Thomas  
  146. </script>  
  147. <script type="text/javascript">  
  148. var arr =["George","John","Thomas","James","Adrew","Martin"];  
  149. document.write(arr + "<br />");  
  150. document.write(arr.slice(2,4) + "<br />");  
  151. document.write(arr);  
  152. //输出结果是：  
  153. //George,John,Thomas,James,Adrew,Martin  
  154. //Thomas,James  
  155. //George,John,Thomas,James,Adrew,Martin  
  156. </script>  
  157. splice()  
  158. 方法用于插入、删除或替换数组的元素。  
  159. 语法：arrayObject.splice(index,howmany,element1,.....,elementX)  
  160. splice() 方法可删除从 index 处开始的零个或多个元素，并且用参数列表中声明的一个或多  
  161. 个值来替换那些被删除的元素。  
  162. 参数描述  
  163. index  
  164. 必需。规定从何处添加/删除元素。  
  165. 该参数是开始插入和（或）删除的数组元素的下标，必须是数字。  
  166. howmany 必需。规定应该删除多少元素。必须是数字，但可以是 "0"。  
  167. 如果未规定此参数，则删除从 index 开始到原数组结尾的所有元素。  
  168. element1 可选。规定要添加到数组的新元素。从 index 所指的下标处开始插入。  
  169. elementX 可选。可向数组添加若干元素。  
  170. 下面的实例中，创建一个新数组，并向其添加一个元素：  
  171. <script type="text/javascript">  
  172. var arr =["George","John","Thomas","James","Adrew","Martin"];  
  173. document.write(arr + "<br />");  
  174. arr.splice(2,0,"William");  
  175. document.write(arr + "<br />");  
  176. //输出结果是：  
  177. //George,John,Thomas,James,Adrew,Martin  
  178. //George,John,William,Thomas,James,Adrew,Martin  
  179. </script>  
  180. 下面的实例中，将删除位于 index 2 的元素，并添加一个新元素来替代被删除的元素：  
  181. <script type="text/javascript">  
  182. var arr =["George","John","Thomas","James","Adrew","Martin"];  
  183. document.write(arr + "<br />");  
  184. arr.splice(2,1,"William");  
  185. document.write(arr);  
  186. //输出结果是：  
  187. //George,John,Thomas,James,Adrew,Martin  
  188. //George,John,William,James,Adrew,Martin  
  189. </script>  
  190. 下面的实例中，将删除从 index 2 ("Thomas") 开始的三个元素，并添加一个新元素  
  191. ("William") 来替代被删除的元素：  
  192. <script type="text/javascript">  
  193. var arr =["George","John","Thomas","James","Adrew","Martin"];  
  194. document.write(arr + "<br />");  
  195. arr.splice(2,3,"William");  
  196. document.write(arr);  
  197. //输出结果是：  
  198. //George,John,Thomas,James,Adrew,Martin  
  199. //George,John,William,Martin  
  200. </script>  
  201. 4、内部数组  
  202. 在网页对象中，有很多本身就是数组对象。例如：document对象的forms属性就是一个数组对  
  203. 象，其中每个元素对应网页中的一个表单，示例如下：  
  204. <form name="firstForm"></form>  
  205. <form name="secondForm"></form>  
  206. <form name="thirdForm"></form>  
  207. <script language="javascript">  
  208. var fs=document.forms;  
  209. for(i=0;i<fs.length;i++){  
  210. alert(fs[i].name);  
  211. }  
  212. </script>  
  213. 表单中的一个选择列表的options属性也是一个数组对象，其中每个元素对应于列表中的一个  
  214. 选择项目  
  215. <form name="myForm">  
  216. <select multiple size="5" name="box" style="width:150" onClick="f(this);">  
  217. <option value="apple">苹果</option>  
  218. <option value="orange">橘子</option>  
  219. <option value="banana">香蕉</option>  
  220. </select>  
  221. </form>  
  222. <script language="javascript">  
  223. function f(o){  
  224. for(i=0;i<o.options.length;i++){  
  225. alert(o.options[i].value+","+o.options[i].text);  
  226. }  
  227. }  
  228. </script>  
  229.   
  230. 第二节 字符串对象类型 String  
  231. myStr="我们来自五湖四海！";  
  232. 或  
  233. myStr= new String("我们来自五湖四海！");  
  234. １、字符串的长度属性  
  235. myStr.length 返回字符串中字符的个数9，一个汉字算一个字符。  
  236. ２、字符串的方法  
  237. 分为两大类，如下：  
  238. (1) 格式设置方法：  
  239. big(), bold(), fontcolor(颜色字符串), fontsize(字体号), sub(), sup()  
  240. (2) 通用字符串操作。  
  241. str="Hello";  
  242. 方法描述示例及结果  
  243. anchor() 创建 HTML 锚。str.anchor("b"):<A NAME=”b”>Hello</A>  
  244. big() 用大号字体显示字符串。str.big() : <BIG>Hello</BIG>  
  245. blink() 显示闪动字符串。str.blink() : <BLINK>Hello</BLINK>  
  246. bold() 使用粗体显示字符串。str.bold() : <B>Hello</B>  
  247. charAt() 返回在指定位置的字符。"北京欢迎你".charAt(2)结果是"欢"  
  248. "北京欢迎你".charAt(0)结果是"北"  
  249. charCodeAt() 返回在指定的位置的字符的  
  250. Unicode 编码。  
  251. "北京欢迎你".charCodeAt(2)结果是27426  
  252. concat() 连接字符串。"北京".concat("欢迎你")结果是"北京欢迎你"  
  253. fixed() 以打字机文本显示字符串。str.fixed() : <FIXED>Hello</FIXED>  
  254. fontcolor() 使用指定的颜色来显示字符串。str. Fontcolor ("Red") :  
  255. <FONT color="red">Hello</FONT>  
  256. fontsize() 使用指定的尺寸来显示字符串。str. fontsize () : <FONT  
  257. size="3">Hello</FONT>  
  258. indexOf() 检索字符串。"北京欢迎你".indexOf("欢迎")结果是2  
  259. "北京欢迎你".indexOf("上海")结果是-1  
  260. "北京欢迎你，欢迎".indexOf("欢迎")结果是2  
  261. italics() 使用斜体显示字符串。str. italics () : <I>Hello</I>  
  262. lastIndexOf() 从后向前搜索字符串。"北京欢迎你，欢迎".lastIndexOf("欢迎")结果是6  
  263. link() 将字符串显示为链接。str.link("http://www.javakc.com") :  
  264. <a href="http://www.javakc.com"> Hello  
  265. </a>  
  266. match() 找到一个或多个正则表达式的匹配。  
  267. replace() 替换与正则表达式匹配的子串。  
  268. search() 检索与正则表达式相匹配的值。  
  269. slice() 提取字符串的片断，并在新的字符  
  270. 串中返回被提取的部分。  
  271. "北京欢迎你".slice(2,4) 结果是"欢迎"  
  272. small() 使用小字号来显示字符串。str.small():<SMALL>Hello</SMALL>  
  273. split() 把字符串分割为字符串数组。"北京|欢迎你|欢迎".split("|")结果是  
  274. 数组{"北京","欢迎你","欢迎"}  
  275. strike() 使用删除线来显示字符串。str.strike():<strike>Hello </strike>  
  276. sub() 把字符串显示为下标。  
  277. str.sub( ) : <sub> Hello </sub>  
  278. substr() 从起始索引号提取字符串中指定数  
  279. 目的字符。  
  280. "北京欢迎你".substr(1,2) 结果是"京欢"  
  281. substring() 提取字符串中两个指定的索引号之  
  282. 间的字符。  
  283. "北京欢迎你".substring(2,4)结果是"欢迎"  
  284. sup() 把字符串显示为上标。str.sup():<sub> Hello </sub>1  
  285. toLowerCase() 把字符串转换为小写。  
  286. （不改变旧的字符串）  
  287. "Welcome to BeiJing".toLowerCase()结果  
  288. 是  
  289. welcome to beijing  
  290. toUpperCase() 把字符串转换为大写。  
  291. （不改变旧的字符串）  
  292. "Welcome to BeiJing".toUpperCase()结果  
  293. 是WELCOME TO BEIJING  
  294.   
  295. 第三节 数学类 Math  
  296. 包含了常用的数学常量和函数。不需要创建该类型的对象，而可以直接使用Math.属性名或  
  297. Math.方法名来使用这些常量和方法。  
  298. Math.E 返回2.718  
  299. Math.PI 返回3.14159  
  300. Math 对象方法  
  301. 方法描述  
  302. abs(x) 返回数的绝对值。  
  303. acos(x) 返回数的反余弦值。  
  304. asin(x) 返回数的反正弦值。  
  305. atan(x) 以介于 -PI/2 与 PI/2 弧度之间的数值来返回 x 的反正切值。  
  306. atan2(y,x) 返回从 x 轴到点 (x,y) 的角度（介于 -PI/2 与 PI/2 弧度之间）。  
  307. ceil(x) 对数进行上舍入。  
  308. cos(x) 返回数的余弦。  
  309. exp(x) 返回 e 的指数。  
  310. floor(x) 对数进行下舍入。  
  311. log(x) 返回数的自然对数（底为e）。  
  312. max(x,y) 返回 x 和 y 中的最高值。  
  313. min(x,y) 返回 x 和 y 中的最低值。  
  314. pow(x,y) 返回 x 的 y 次幂。  
  315. random() 返回 0 ~ 1 之间的随机数。  
  316. round(x) 把数四舍五入为最接近的整数。  
  317. sin(x) 返回数的正弦。  
  318. sqrt(x) 返回数的平方根。  
  319. tan(x) 返回角的正切。  
  320. toSource() 返回该对象的源代码。  
  321. valueOf() 返回 Math 对象的原始值。  
  322. 第四节 日期时间类 Date  
  323. 该类型对象中存放年月日时分秒等信息。  
  324. １、创建日期对象的几种办法：  
  325. new Date() 不带参数，则以系统时间为新创建日期对象的内容。  
  326. new Date(毫秒数) 以距1970年1月1日零时到期望时间的毫秒数为参数，创建日期对象  
  327. new Date(2005,6,3,21,0,22) 设定2005年7月3日，注意月从0开始的  
  328. new Date("July 3, 2005 21:00:22") 以指定的时间为新创建日期对象的内容  
  329. ２、日期对象的方法：  
  330. getDate() 返回几号  
  331. getDay() 返回星期几 （0代表星期日，1到6代表星期一到星期六）  
  332. getHours() 返回几点  
  333. getMinutes() 返回分钟数  
  334. getSeconds() 返回秒数  
  335. getTime() 返回距1970年1月1日零时到期望时间的毫秒数  
  336. getYear() 返回年份  
  337. setDate() 设置几号  
  338. setDay() 设置星期几 （0代表星期日，1到6代表星期一到星期六）  
  339. setHours() 设置几点  
  340. setMinutes() 设置分钟数  
  341. setSeconds() 设置秒数  
  342. setTime() 以距1970年1月1日零时到期望时间的毫秒数为参数，设置时间  
  343. setYear() 设置年份  
  344.   
  345. 课后练习题：  
  346. 1、倒序输出一个字符串的每个字符。  
  347. 2、显示姓“李”和姓“王”的同学名单。  
  348. 3、显示姓名中含“宁”的名单。  
  349. 4、编写随机点名程序。  
  350. 5、产生50个100以内的随机数，找出其中最大值和最小值，并统计大于等于60的有多少个。  
  351. 6、编写倒计时程序（距明年春节的天数）。  

第三章 窗口window对象

 
  1. 在JavaScript中可以使用window和self标志符来引用当前的浏览器窗口。  
  2. 每个打开的窗口定义一个window对象，如果文档包含框架（frame 或 iframe 标签），浏览  
  3. 器会为 HTML 文档创建一个 window 对象，并为每个框架创建一个额外的 window 对象。  
  4. 可以使用top标识符引用最上层的窗口，或使用parent标志符引用当前窗口的父窗口。  
  5. 第一节 Window 对象属性  
  6. 属性描述  
  7. closed 返回窗口是否已被关闭。  
  8. defaultStatus 设置或返回窗口状态栏中的默认文本。  
  9. document 对 Document 对象的只读引用。请参阅 Document 对象。  
  10. history 对 History 对象的只读引用。请参数 History 对象。  
  11. innerheight 返回窗口的文档显示区的高度。  
  12. innerwidth 返回窗口的文档显示区的宽度。  
  13. length 设置或返回窗口中的框架数量。  
  14. location 用于窗口或框架的 Location 对象。请参阅 Location 对象。  
  15. name 设置或返回窗口的名称。  
  16. Navigator 对 Navigator 对象的只读引用。请参数 Navigator 对象。  
  17. opener 返回对创建此窗口的窗口的引用。  
  18. outerheight 返回窗口的外部高度。  
  19. outerwidth 返回窗口的外部宽度。  
  20. pageXOffset 设置或返回当前页面相对于窗口显示区左上角的 X 位置。  
  21. pageYOffset 设置或返回当前页面相对于窗口显示区左上角的 Y 位置。  
  22. parent 返回父窗口。  
  23. Screen 对 Screen 对象的只读引用。请参数 Screen 对象。  
  24. self 返回对当前窗口的引用。等价于 Window 属性。  
  25. status 设置窗口状态栏的文本。  
  26. top 返回最顶层的先辈窗口。  
  27. window window 属性等价于 self 属性，它包含了对窗口自身的引用。  
  28. · screenLeft  
  29. · screenTop  
  30. · screenX  
  31. · screenY  
  32. 只读整数。声明了窗口的左上角在屏幕上的的 x 坐标和 y 坐标。IE、Safari 和  
  33. Opera 支持 screenLeft 和 screenTop，而 Firefox 和 Safari 支持  
  34. screenX 和 screenY。  
  35. 第二节 Window 对象方法  
  36. 方法描述  
  37. alert() 显示带有一段消息和一个确认按钮的警告框。  
  38. blur() 把键盘焦点从顶层窗口移开。  
  39. clearInterval() 取消由 setInterval() 设置的 timeout。  
  40. clearTimeout() 取消由 setTimeout() 方法设置的 timeout。  
  41. close() 关闭浏览器窗口。  
  42. confirm() 显示带有一段消息以及确认按钮和取消按钮的对话框。  
  43. createPopup() 创建一个 pop-up 窗口。  
  44. focus() 把键盘焦点给予一个窗口。  
  45. moveBy() 可相对窗口的当前坐标把它移动指定的像素。  
  46. moveTo() 把窗口的左上角移动到一个指定的坐标。  
  47. open() 打开一个新的浏览器窗口或查找一个已命名的窗口。  
  48. print() 打印当前窗口的内容。  
  49. prompt() 显示可提示用户输入的对话框。  
  50. resizeBy() 按照指定的像素调整窗口的大小。  
  51. resizeTo() 把窗口的大小调整到指定的宽度和高度。  
  52. scrollBy() 按照指定的像素值来滚动内容。  
  53. scrollTo() 把内容滚动到指定的坐标。  
  54. setInterval() 按照指定的周期（以毫秒计）来调用函数或计算表达式。  
  55. setTimeout() 在指定的毫秒数后调用函数或计算表达式。  
  56. 第三节 常用方法示例  
  57. （1）打开和关闭窗口：  
  58. open 打开另外一个窗口来显示新的页面。  
  59. window.open(URL,窗口名称,可选参数)  
  60. close() 关闭用Open方法打开的窗口  
  61. 可选参数：“toolbar=yes, width=500,height=200”  
  62. （2）对话框方法  
  63. alert (提示字符串) 提示信息，只有一个“确定”按钮  
  64. confirm (提示字符串) 　选择确定或取消，返回值：true, false  
  65. <html>  
  66. <head>  
  67. <script type="text/javascript">  
  68. function disp_confirm(){  
  69. var r=confirm("请点击一个按钮");  
  70. if (r==true){  
  71. document.write("您点击了确认！");  
  72. }else{  
  73. document.write("您点击了取消！");  
  74. }  
  75. }  
  76. </script>  
  77. </head>  
  78. <body>  
  79. <input type="button" onclick="disp_confirm()" value="显示一个确认框" />  
  80. </body>  
  81. </html>  
  82. prompt(提示字符串，初始值) 让用户在对话框中输入  
  83. <html>  
  84. <head>  
  85. <script type="text/javascript">  
  86. function disp_prompt(){  
  87. var name=prompt("请输入您的名字","Bill Gates");  
  88. if (name!=null && name!=""){  
  89. document.write("你好，" + name + "！今天过得好吗？");  
  90. }  
  91. }  
  92. </script>  
  93. </head>  
  94. <body>  
  95. <input type="button" onclick="disp_prompt()" value="显示一个提示框" />  
  96. </body>  
  97. </html>  
  98. （3）移动窗口方法：  
  99. （窗口左上角为坐标0，0点）  
  100. moveBy 窗口横向纵向移动多少象素 moveBy(10,10)  
  101. <html>  
  102. <head>  
  103. <script type="text/javascript">  
  104. function moveWin(){  
  105. myWindow.moveBy(50,50);  
  106. myWindow.focus();  
  107. }  
  108. </script>  
  109. </head>  
  110. <body>  
  111. <script type="text/javascript">  
  112. myWindow=window.open('','','width=200,height=100');  
  113. myWindow.document.write("This is 'myWindow'");  
  114. </script>  
  115. <input type="button" value="Move 'myWindow'" onclick="moveWin()" />  
  116. </body>  
  117. </html>  
  118. moveTo 窗口移动到参数指定的位置 moveTo(100,100)  
  119. <html>  
  120. <head>  
  121. <script type="text/javascript">  
  122. function moveWin(){  
  123. myWindow.moveTo(0,0);  
  124. myWindow.focus();  
  125. }  
  126. </script>  
  127. </head>  
  128. <body>  
  129. <script type="text/javascript">  
  130. myWindow=window.open('','','width=200,height=100');  
  131. myWindow.document.write("This is 'myWindow'");  
  132. </script>  
  133. <input type="button" value="Move 'myWindow'" onclick="moveWin()" />  
  134. </body>  
  135. </html>  
  136. （4）定时方法：  
  137. 设置定时器，按指定时间间隔，反复执行某函数：  
  138. setInterval 和 clearInterval (见跑马灯程序)  
  139. <html>  
  140. <body>  
  141. <input type="text" id="clock" size="35" />  
  142. <script language=javascript>  
  143. var int=self.setInterval("clock()",50);  
  144. function clock(){  
  145. var t=new Date();  
  146. document.getElementById("clock").value=t;  
  147. }  
  148. </script>  
  149. <button onclick="int=window.clearInterval(int)">  
  150. Stop interval  
  151. </button>  
  152. </body>  
  153. </html>  
  154. 设置定时器，按指定时间间隔，执行一遍某函数：  
  155. setTimeout 和 clearTimeout  
  156. <html>  
  157. <head>  
  158. <script type="text/javascript">  
  159. function timedMsg(){  
  160. var t=setTimeout("alert('5 seconds!')",5000);  
  161. }  
  162. </script>  
  163. </head>  
  164. <body>  
  165. <form>  
  166. <input type="button" value="显示计时的消息框！"  
  167. onClick = "timedMsg()">  
  168. </form>  
  169. <p>点击上面的按钮。5 秒后会显示一个消息框。</p>  
  170. </body>  
  171. </html>  
  172. （5）聚焦方法 ：  
  173. 让窗口处于激活状态。  
  174. window.focus()  
  175. <html>  
  176. <body>  
  177. <script type="text/javascript">  
  178. myWindow=window.open('','','width=200,height=100');  
  179. myWindow.document.write("This is 'myWindow'");  
  180. myWindow.focus();  
  181. </script>  
  182. </body>  
  183. </html>  

第四章 文档document对象

 
  1. DOM (文档对象模型)  
  2.  window 整个浏览器窗口的统称，是最上层的唯一对象。这一级可以省略，是系统默认值。  
  3.  document 是Window的一个子对象，包含当前文档(HTML文件)中所有的对象。  
  4.  form 即表单，包含许多子对象。  
  5.  window、document和history对象是系统定义好的，其它对象是由我们程序员自己定义的。  
  6. 我们要为每个对象起一个名称。  
  7. 第一节 document对象概述  
  8. document对象最强大的一个特性在于它的组织性。如果给页面中的元素起个名字，则可以把该元  
  9. 素当成document 对象的一个属性来处理。例如，如果在form 元素“form1”中有一个名叫  
  10. “ txtbox” 的文本框， 则可以像下面这样去引用该文本框中的文本：  
  11. document.form1.txtbox.value。  
  12. 除了将HTML元素按名字组织起来外，document对象还有许多属性、方法、事件，这些特点可以  
  13. 帮助我们扩展程序的功能。  
  14. Document 对象集合  
  15. 集合描述  
  16. all[] 提供对文档中所有 HTML 元素的访问。  
  17. anchors[] 返回对文档中所有 Anchor 对象的引用。  
  18. applets 返回对文档中所有 Applet 对象的引用。  
  19. forms[] 返回对文档中所有 Form 对象引用。  
  20. images[] 返回对文档中所有 Image 对象引用。  
  21. links[] 返回对文档中所有 Area 和 Link 对象引用。  
  22. Document 对象属性  
  23. 属性描述  
  24. body  
  25. 提供对 <body> 元素的直接访问。  
  26. 对于定义了框架集的文档，该属性引用最外层的 <frameset>。  
  27. cookie 设置或返回与当前文档有关的所有 cookie。  
  28. domain 返回当前文档的域名。  
  29. lastModified 返回文档被最后修改的日期和时间。  
  30. referrer 返回载入当前文档的文档的 URL。  
  31. title 返回当前文档的标题。  
  32. URL 返回当前文档的 URL。  
  33. Document 对象方法  
  34. 方法描述  
  35. close() 关闭用 document.open() 方法打开的输出流，并显示选定的数据。  
  36. getElementById() 返回对拥有指定 id 的第一个对象的引用。  
  37. getElementsByName() 返回带有指定名称的对象集合。  
  38. getElementsByTagName() 返回带有指定标签名的对象集合。  
  39. open() 打开一个流，以收集来自任何 document.write() 或  
  40. document.writeln() 方法的输出。  
  41. write() 向文档写 HTML 表达式 或 JavaScript 代码。  
  42. writeln() 等同于 write() 方法，不同的是在每个表达式之后写一个换行符。  
  43. 第二节 document对象的事件（body标记中）  
  44. onkeydown 按下任意键  
  45. onkeypress 将按下任意键  
  46. onkeyup 释放键  
  47. onclick 单击鼠标  
  48. ondblclick 双击鼠标  
  49. onmousedown 按下鼠标  
  50. onmouseup 释放鼠标  
  51. load 文档装载完毕  
  52. unload 文档卸载完毕  
  53. 可以使用attachEvent方法，为body添加事件。  
  54. document.attachEvent ('onclick',getA);  

第五章 表单form对象

 
  1. 第一节 表单对象的使用  
  2. 1、什么是表单对象  
  3. 表单（<form>）是Web页面中的基本元素。表单对象最主要的功能就是能够直接访问页面中的表  
  4. 单。利用表单对象，可以实现与用户的交互；不需要服务器的介入，就可以实现动态改变Web页面的  
  5. 行为。  
  6. 对于Web页面表单，通常使用document对象的forms数组可以很方便地访问不同的表单。例如，  
  7. 某HTML文件片段如下：  
  8. <form name="form1">  
  9. <input type="text">  
  10. <input type="text">  
  11. <input type="text">  
  12. </form>  
  13. <form name="form2">  
  14. <input type="text">  
  15. <input type="text">  
  16. </form>  
  17. document对象的forms数组有两个元素：forms[0]可以访问第一个表单，其中共有三个基本  
  18. 元素：而forms[1]对应表单form2，其中只有两个元素。  
  19. 除了用forms数组方式访问表单对象外，也可以直接用表单的名字进行访问。例如，对于上例，  
  20. 也可以用document.form1和document.form2分别访问两个表单。  
  21. 2、表单对象的方法  
  22. 表单对象的submit（）方法用于实现表单信息的提交。例如，要提交页面中的一个名为form1  
  23. 的表单，可以使用下列语句：  
  24. document.form1.submit();  
  25. 3、表单对象的属性  
  26. 属性描述  
  27. Name 表单的名称  
  28. action 提交表单后执行的程序  
  29. target  
  30. 指定数据显示在哪个窗口(_blank,_parent,_self,_top)  
  31. 或哪个框架(框架名称)中  
  32. encoding 默认为text/html  
  33. method “Get”或“Post”  
  34. elements  
  35. 数组  
  36. 只读，表单中所有对象的索引,0,1,…  
  37. 由document.表单名.elements.length可知该表单共有多少个对象  
  38. 这里elements属性是一个数组，其中的元素对应于页面上表单内的各个控件。除了elements  
  39. 外，表单的其他几个属性均对应于HTML语法中<form>标记的属性。  
  40. 4、表单对象使用示例  
  41. 下面示例如果使用表单对象，效果及代码如下：  
  42. <script type="text/javascript">  
  43. function display(){  
  44. var str;  
  45. // 使用表单名称访问表单对象的属性  
  46. str="name="+document.form1.name+"\r";  
  47. str=str+"action="+document.form1.action+"\r";  
  48. str=str+"method="+document.form1.method+"\r";  
  49. //访问表单对象的elements数组  
  50. str=str+"elements:"+"\r";  
  51. for(var i=0;i<document.form1.elements.length;i++){  
  52. str=str+ " "+document.form1.elements[i].type  
  53. +"\t"+document.form1.elements[i].name  
  54. +"\t"+document.form1.elements[i].value+"\r";  
  55. }  
  56. window.alert(str);  
  57. return false;  
  58. }  
  59. function submitform(){  
  60. //使用表单数组+下标访问表单对象  
  61. document.forms[0].submit();  
  62. }  
  63. </script>  
  64. <form name="form1" action="/web/user" method="post" onsubmit="return  
  65. display()">  
  66. <input type="text" name="text1" value="AAA"/>  
  67. <input type="text" name="text2" value="BBB"/>  
  68. <input type="checkbox" name="check1" value="aaa"/>  
  69. <input type="submit" name="submit" value="提交"/>  
  70. <input type="button" name="button" onclick="submitform();" value="js提交"/>  
  71. </form>  
  72. 注意：单击“提交”按钮会触发表单的onsubmit事件。如果onsubmit的事件处理过程返回  
  73. false，则不进行表单数据的提交。但如果直接使用表单对象的submit（）方法，则直接将数据提交  
  74. 出去。  
  75. 第二节 表单中的基本元素  
  76. 表单中的基本控件由按钮、单选按钮、复选按钮、提交按钮、重置按钮和文本框等组成。在  
  77. JavaScript中要访问这些控件，可以使用以下两种方法实现：  
  78.  表单.元素名称 例如：document.form1.check  
  79.  表单.elements[下标] 例如：document.form1.elements[2]  
  80. 下面分别介绍表单中的各个基本控件。  
  81. 1、text对象  
  82. text对象对应于页面中的text输入框控件。  
  83. <input type="text" name="控件名称" value="默认文本" />  
  84. 属性accessKey 设置或返回访问文本域的快捷键。  
  85. 使用 Alt + accessKey 为拥有指定快捷键的元素赋予焦点  
  86. alt 设置或返回当浏览器不支持文本域时供显示的替代文本。  
  87. defaultValue 设置或返回文本域的默认值。  
  88. disabled 设置或返回文本域是否应被禁用。  
  89. id 设置或返回文本域的 id。  
  90. maxLength 设置或返回文本域中的最大字符数。  
  91. name 设置或返回文本域的名称。  
  92. readOnly 设置或返回文本域是否应是只读的。  
  93. size 设置或返回文本域的尺寸。  
  94. tabIndex 设置或返回文本域的 tab 键控制次序。  
  95. type 返回文本域的表单元素类型。  
  96. value 设置或返回文本域的 value 属性的值。  
  97. 方法blur( ) 将当前焦点移到后台  
  98. select( ) 加亮文字，选取文本域中的内容。  
  99. focus() 在文本域上设置焦点。  
  100. 主要事件onfocus，onblur，onselect，onchange  
  101. text对象使用示例如下：  
  102. <form name="form1">  
  103. <input type="text" name="text1" value="Welcome"/>  
  104. </form>  
  105. <script type="text/javascript">  
  106. document.form1.text1.value="this is a javascirpt";  
  107. document.form1.text1.select();  
  108. alert(document.form1.text1.value);  
  109. document.text1.blur();  
  110. </script>  
  111. 2、textarea对象  
  112. textarea对象对应于页面中的textarea输入控件。  
  113. <textarea name="控件名称">默认文本</textarea>  
  114. 属性name textarea输入框控件名称  
  115. value textarea输入框控件中当前的文本  
  116. defaultvalue textarea输入框控件的默认文本  
  117. 方法blur( ) 将当前焦点移到后台  
  118. select( ) 加亮文字  
  119. 主要事件onfocus，onblur，onselect，onchange  
  120. 3、select对象  
  121. select对象对应于网页中的下拉列表框。  
  122. <select name="下拉列表框的名称" size="下拉列表框显示的条数">  
  123. <option value="选择值">选项描述</option>  
  124. <option value="选择值" selected>选项描述</option>  
  125. …………  
  126. </select>  
  127. 属性disabled 设置或返回是否应禁用下拉列表  
  128. id 设置或返回下拉列表的 id。  
  129. length 返回下拉列表中的选项数目。  
  130. multiple 设置或返回是否选择多个项目。  
  131. name 设置或返回下拉列表的名称。  
  132. options  
  133. 数组  
  134. 返回包含下拉列表中的所有选项(option对象)的一个数组。  
  135. 其中option对象包括如下属性：  
  136. text 该选项显示的文字  
  137. value 该选项的value值  
  138. selected 指明该选项是否别选中  
  139. selectedIndex 当前选中项的下标  
  140. size 设置或返回下拉列表中的可见行数。  
  141. 方法options.add() 向下拉列表添加一个选项。  
  142. blur() 从下拉列表移开焦点。  
  143. focus() 在下拉列表上设置焦点。  
  144. remove() 从下拉列表中删除一个选项。  
  145. 主要事件onfocus，onblur，onchange  
  146. 4、button对象  
  147. button对象对应于网页中的按钮控件。  
  148. <input type="button" value="按钮上显示的值" name="控件名称">  
  149. 属性accessKey 设置或返回访问按钮的快捷键。  
  150. alt 设置或返回当浏览器无法显示按钮时供显示的替代文本。  
  151. disabled 设置或返回是否禁用按钮。  
  152. id 设置或返回按钮的 id。  
  153. name 设置或返回按钮的名称。  
  154. tabIndex 设置或返回按钮的 tab 键控制次序。  
  155. value 设置或返回在按钮上显示的文本。  
  156. 方法blur() 把焦点从元素上移开。  
  157. click() 在该按钮上模拟一次鼠标单击。  
  158. focus() 为该按钮赋予焦点。  
  159. 主要事件onclick  
  160. 5、checkbox对象  
  161. checkbox对象对应于网页中的复选框。  
  162. <input type="checkbox" value="值" name="控件名称" checked>选项说明  
  163. 属性accessKey 设置或返回访问 checkbox 的快捷键。  
  164. alt 设置或返回不支持 checkbox 时显示的替代文本。  
  165. checked 设置或返回 checkbox 是否应被选中。  
  166. defaultChecked 返回 checked 属性的默认值。  
  167. disabled 设置或返回 checkbox 是否应被禁用。  
  168. id 设置或返回 checkbox 的 id。  
  169. name 设置或返回 checkbox 的名称。  
  170. tabIndex 设置或返回 checkbox 的 tab 键控制次序。  
  171. value 设置或返回 checkbox 的 value 属性的值  
  172. 方法blur() 从 checkbox 上移开焦点  
  173. click() 模拟在 checkbox 中的一次鼠标点击。  
  174. focus() 为 checkbox 赋予焦点。  
  175. 主要事件onclick  
  176. 6、radio对象  
  177. radio对象对应于网页中的单选控件。当网页中具有多个相同名称的单选控件后，就形成了一个  
  178. radio对象数组，其中每个单选控件即为一个radio对象。  
  179. <input type="radio" value="选项值" name="单选项名称" checked>选项说明  
  180. <input type="radio" value="选项值" name="单选项名称" >选项说明  
  181. …………  
  182. 属性accessKey 设置或返回访问单选按钮的快捷键。  
  183. alt 设置或返回在不支持单选按钮时显示的替代文本。  
  184. checked 设置或返回单选按钮的状态。  
  185. defaultChecked 返回单选按钮的默认状态。  
  186. disabled 设置或返回是否禁用单选按钮。  
  187. id 设置或返回单选按钮的 id。  
  188. name 设置或返回单选按钮的名称。  
  189. tabIndex 设置或返回单选按钮的 tab 键控制次序。  
  190. value 设置或返回单选按钮的 value 属性的值。  
  191. 方法blur() 从单选按钮移开焦点。  
  192. click() 在单选按钮上模拟一次鼠标点击。  
  193. focus() 为单选按钮赋予焦点。  
  194. 主要事件onclick  
  195. 7、hidden对象  
  196. hidden对象对应于网页中的隐藏域。  
  197. <input type="hidden" value="值" name="名称" >  
  198. 属性alt 设置或返回当不支持隐藏输入域时显示的替代文本。  
  199. id 设置或返回隐藏域的 id。  
  200. name 设置或返回隐藏域的名称。  
  201. value 设置或返回隐藏域的 value 属性的值。  
  202. 8、submit对象  
  203. submit对象对应于网页中的submit按钮。  
  204. <input type="submit" value="显示文本" name="名称" >  
  205. 属性accessKey 设置或返回访问提交按钮的快捷键。  
  206. alt 设置或返回当浏览器不支持提交按钮时供显示的替代文本。  
  207. disabled 设置或返回提交按钮是否应被禁用。  
  208. id 设置或返回提交按钮的 id。  
  209. name 设置或返回提交按钮的名称。  
  210. tabIndex 设置或返回提交按钮的 tab 键控制次序。  
  211. value 设置或返回在提交按钮上显示的文本。  
  212. 方法blur() 从提交按钮上移开焦点。  
  213. click() 在提交按钮上模拟一次鼠标点击。  
  214. focus() 为提交按钮赋予焦点。  
  215. 主要事件onclick  
  216. 9、password对象  
  217. password对象对应于网页中的密码输入框。  
  218. <input type="password" value="值" name="名称" >  
  219. 属性accessKey 设置或返回访问密码字段的快捷键。  
  220. alt 设置或返回当不支持密码字段时显示的替代文字。  
  221. defaultValue 设置或返回密码字段的默认值。  
  222. disabled 设置或返回是否应被禁用密码字段。  
  223. id 设置或返回密码字段的 id。  
  224. maxLength 设置或返回密码字段中字符的最大数目。  
  225. name 设置或返回密码字段的名称。  
  226. readOnly 设置或返回密码字段是否应当是只读的。  
  227. size 设置或返回密码字段的长度。  
  228. tabIndex 设置或返回密码字段的 tab 键控制次序。  
  229. value 设置或返回密码字段的 value 属性的值。  
  230. 方法blur() 从密码字段移开焦点。  
  231. click() 为密码字段赋予焦点。  
  232. focus() 选取密码字段中的文本。  
  233. 主要事件onfocus，onblur，onselect，onchange  

第六章 History与Navigator对象

 
  1. History对象  
  2. History 对象包含用户（在浏览器窗口中）访问过的 URL。  
  3. History 对象是 window 对象的一部分，可通过 window.history 属性对其进行访问。  
  4. History 对象属性  
  5. 属性描述  
  6. length 返回浏览器历史列表中的 URL 数量。  
  7. History 对象方法  
  8. 方法描述  
  9. back() 加载 history 列表中的前一个 URL。  
  10. forward() 加载 history 列表中的下一个 URL。  
  11. go(number|URL) 加载 history 列表中的某个具体页面。  
  12. -1表示前一个页面  
  13. Navigator 对象  
  14. Navigator 对象包含有关浏览器的信息。可以使用这些属性进行平台专用的配置。  
  15. Navigator 对象的实例是唯一的，可以用 Window 对象的 navigator 属性来引用它。  
  16. Navigator 对象集合  
  17. 集合描述  
  18. plugins[]  
  19. 返回对文档中所有嵌入式对象的引用。  
  20. 该集合是一个 Plugin 对象的数组，其中的元素代表浏览器已经安装的插件。Plug-in  
  21. 对象提供的是有关插件的信息，其中包括它所支持的 MIME 类型的列表。  
  22. 虽然 plugins[] 数组是由 IE 4 定义的，但是在 IE 4 中它却总是空的，因为 IE  
  23. 4 不支持插件和 Plugin 对象。  
  24. Navigator 对象属性  
  25. 属性描述  
  26. appCodeName 返回浏览器的代码名。  
  27. appMinorVersion 返回浏览器的次级版本。  
  28. appName 返回浏览器的名称。  
  29. appVersion 返回浏览器的平台和版本信息。  
  30. browserLanguage 返回当前浏览器的语言。  
  31. cookieEnabled 返回指明浏览器中是否启用 cookie 的布尔值。  
  32. cpuClass 返回浏览器系统的 CPU 等级。  
  33. onLine 返回指明系统是否处于脱机模式的布尔值。  
  34. platform 返回运行浏览器的操作系统平台。  
  35. systemLanguage 返回 OS 使用的默认语言。  
  36. userAgent 返回由客户机发送服务器的 user-agent 头部的值。  
  37. userLanguage 返回 OS 的自然语言设置。  
  38. Navigator 对象方法  
  39. 方法描述IE F O  
  40. javaEnabled() 规定浏览器是否启用 Java。4 1 9  
  41. taintEnabled() 规定浏览器是否启用数据污点 (data tainting)。4 1 9  

第七章 JavaScript框架编程

 
  1. 一个HTML页面可以有一个或多个子框架，这些子框架以<iframe>或<frame>来标记，用来显  
  2. 示一个独立的HTML页面。本节介绍框架的自我控制及框架之间的相互访问，例如从一个框架中引用另  
  3. 一个框架中的JavaScript变量，调用其他框架内的函数，控制另一个框架中表单的行为等。  
  4. 第一节 框架的引用  
  5. 在一个HTML 页面中，所有的框架以集合的形式作为window 对象的属性提供，例如  
  6. window.frames表示该页面内所有框架的集合，这和表单对象、链接对象等类似。不同的是，这些集  
  7. 合是document的属性，因此，要引用一个子框架，可以使用如下语法：  
  8. window.frames["frameName"]  
  9. window.frames.frameName  
  10. window.frames[index]  
  11. 其中，window字样也可以用self代替或省略，假设frameName为页面中第一个框架，则以下写法  
  12. 是等价的：  
  13. window.frames["frameName"]  
  14. self.frames["frameName"]  
  15. self.frames[0]  
  16. frames[0]  
  17. frameName  
  18. 每个框架都对应一个HTML页面，所以这个框架也是一个独立的浏览器窗口，它具有窗口的所有  
  19. 性质，对框架的引用也就是对window对象的引用。有了这个window对象，就可以很方便地对其中的  
  20. 页面进行操作，例如使用window.document对象向页面写入数据、使用window.location属性来  
  21. 改变框架内的页面等。下面分别介绍不同层次框架间的相互引用。  
  22. 1、父框架到子框架的引用  
  23. 从父框架引用子框架的方法为：  
  24. window.frames["frameName"]  
  25. 这样就引用了页面内名为frameName的子框架，如果要引用子框架内的子框架，事实上，引用  
  26. 的框架就是window对象，实现方法如下：  
  27. window.frames["frameName"].frames["frameName2"]  
  28. 这样就很容易引用到了二级子框架，依次类推，可以实现多层框架的引用。  
  29. 2、子框架到父框架的引用  
  30. 每个window对象都有一个parent属性，表示它的父框架。如果该框架已经是顶层框架，则  
  31. window.parent还表示该框架本身，例如，先创建一个TestA.html文件，其代码如下：  
  32. <html>  
  33. <head><title>父页面</title></head>  
  34. <body>  
  35. <form name="formA" id="formA">  
  36. <input type="text" name="username" id="username"/>  
  37. </form>  
  38. <iframe src="TestB.html" width="100%"></iframe>  
  39. </body>  
  40. </html>  
  41. 在上面代码中，定义了一个iframe 框架并把TestB.html 文件放在其中，如果需要在  
  42. TestB.html中对TestA.html中的username文本框赋值，就应该在TestB.html中实现如下代码：  
  43. <script type="text/javascript">  
  44. var parentWin=window.parent;  
  45. parentWin.formA.username.value="javakc";  
  46. </script>  
  47. 3、兄弟框架间的引用  
  48. 如果两个框架为同一个框架的子框架，它们称为兄弟框架，可以通过父框架来实现互相引用，例  
  49. 如一个页面包括2个子框架  
  50. <frameset rows="30%,70%">  
  51. <frame src="left.html" name="frame1"/>  
  52. <frame src="main.html" name="frame2"/>  
  53. </frameset>  
  54. 在frame1中可以使用如下语句来引用frame2。  
  55. self.parent.frames["frame2"]  
  56. 4、不同层次框架间的相互引用  
  57. 框架的层次是针对顶层框架而言的。当层次不同时，只要知道自己所在的层次以及另一个框架所在  
  58. 的层次和名字，利用框架引用的window对象性质，就可以很容易地实现互相访问，例如：  
  59. self.parent.frames["childName"].frames["targetFrameName"]  
  60. 5、对顶层框架的引用  
  61. 和parent属性类似，window对象还有一个top属性，它表示对顶层框架的引用，可以用来一  
  62. 个框架自身是否为顶层框架，例如：  
  63. top.window.formA.username.value="javakc";  
  64. 也可以采用下面代码验证本框架是否为顶层框架  
  65. if(self==top){  
  66. //too do  
  67. }  
  68. 对于框架的引用就是对“window”对象的引用，利用window对象的location属性，可以改变  
  69. 框架的导航，例如  
  70. window.frames[0].location="index.html";  
  71. 这就是将页面中的第一个框架的页面重定向到index.html，利用这个性质，甚至可以使用一条  
  72. 链接来更多的框架，例如：  
  73. <frameset rows="30%,70%">  
  74. <frame src="left.html" name="frame1"/>  
  75. <frame src="main.html" name="frame2"/>  
  76. </frameset>  
  77. <a href="frame1.location='index.html';frame2.loaction='top.html'">link</a>  
  78. 第二节 引用其他框架内的变量和函数  
  79. 在一个框架中可以引用其他框架内的JavaScript变量和函数，例如：  
  80. <script type="text/javascript">  
  81. function hello (){  
  82. alert("hello javakc");  
  83. }  
  84. window.hello();  
  85. </script>  
  86. 如果运行这段代码，将会弹出hello javakc的显示对话框，这正是执行hello（）函数的结  
  87. 果。事实上，一个页面内定义的所有全局变量和全局函数都是作为window对象的成员。例如：  
  88. var a="javakc";  
  89. alert(window.a);  
  90. 执行代码后就会弹出对话框显示为javakc。同样，在不同框架之间共享变量和函数，就是通过  
  91. window对象来调用的。  
  92. 页面结构如下：  
  93. <frameset rows="30%,70%">  
  94. <frame src="left.html" name="link"/>  
  95. <frame src="main.html" name="show"/>  
  96. </frameset>  
  97. 在left.htm页面中有如下JavaScript代码片段：  
  98. <script type="text/javascript">  
  99. var arrCars=new Array();  
  100. function addToCars(id){  
  101. arrCars.push(id);  
  102. }  
  103. </script>  
  104. 在main.html页面中有如下代码：  
  105. <a href="void(0)" onclick="self.parent.link.addToCars('id')">加入购物车</a>  

第八章 JavaScript异常处理

 
  1. 在代码的运行过程中一般会发生两种错误：一是程序内部的逻辑或者语法错误；二是运行环境或  
  2. 者用户输入中不可预知的数据造成的错误。JavaScript可以捕获异常并进行相应的处理，从而避免  
  3. 了浏览器向用户报错。  
  4. 1、利用try-catch-finally处理异常  
  5. 用户可以使用该结构处理可能发生异常的代码，如果发生异常，则由catch捕获异常并进行相应  
  6. 的处理，其语法如下：  
  7. try{  
  8. //要执行的代码  
  9. }catch(e){  
  10. //处理异常的代码  
  11. }finally{  
  12. //无论异常发生与否，都会执行的代码  
  13. }  
  14. 这与java或者C#异常处理的语言室一致的。通过异常处理，可以避免程序停止运行，从而具有  
  15. 了一定的自我修复能力。在Ajax开发中，利用异常处理的一个典型应用就是创建XMLHttpRequest  
  16. 对象，不同浏览器创建它的方式也是不一样的，为了使代码能够跨浏览器运行，就可以利用异常。一种  
  17. 方法不行，再可以用另一种方法，知道不发生异常为止，例如：  
  18. <script type="text/javascript">  
  19. var xmlhttp;  
  20. try{  
  21. //尝试用IE的方式创建XMLHttpRequest对象  
  22. xmlhttp=new ActionXObject("Microsoft.XMLHTTP");  
  23. }catch(e){  
  24. try{  
  25. //尝试用非IE的方式创建XMLHttpRequest对象  
  26. xmlhttp=new XMLHttpRequest();  
  27. }catch(e){  
  28. }  
  29. }  
  30. </script>  
  31. 利用这种方式，就可以跨浏览器创建XMLHttpRequest对象。  
  32.   
  33. 2、利用throw处理异常  
  34. 在JavaScript中有其内部的异常机制，在遇到非法操作的时候能自动抛出异常，但在实际的开  
  35. 发中，随着程序的复杂，需要自己实现异常，可以通过throw语句来实现：“throw value”；  
  36. 其中vlaue 就是要抛出的异常变量，它可以是JavaScript 中的任何一种类型，但在  
  37. JavaScript 内部的异常中， 异常参数e 是一个名为error 的对象， 可以通过new  
  38. Error（message）来创建这个对象，异常的描述被作为error对象的一个属性message，可以由  
  39. 构造函数传入，也可以之后赋值。通过这个异常描述，可以让程序获取异常的详细信息，从而自动处理，  
  40. 例如，下面的程序用于计算两个数据的积，如果参数不是数字，则抛出异常：  
  41. <script type="text/javascript">  
  42. //函数默认要求参数是数字  
  43. function sum(a,b){  
  44. a=parseInt(a);  
  45. b=parseInt(b);  
  46. //如果a或b不能转换为数字则抛出一个异常对象  
  47. if(isNaN(a) || isNaN(b)){  
  48. throw new Error("参数不是数字");  
  49. }  
  50. return a*b;  
  51. }  
  52. try{  
  53. //错误的调用  
  54. var s=sum(1,"a");  
  55. }catch(e){  
  56. //显示异常的详细信息  
  57. alert(e.message);  
  58. }  
  59. </script>  
  60. 程序中使用字母作为参数传递给sum函数是错误的，所以函数内跑粗了一个异常对象，这个对象  
  61. 被catch语句获取，并使用alert语句显示了其详细信息，  

第九章 自定义JavaScript对象

    1. 第一节 JavaScript类的定义  
    2. 一个类是对具有相似性质的一类事物的抽象，通过实例化一个类，可以获得属于该类的一个实例  
    3. （即对象）。  
    4. JavaScript中定义一个类的方法如下：  
    5. <script language="javascript">  
    6. function HelloClass{  
    7. alert("类的定义");  
    8. //在这里可定义类成员的定义及构造函数  
    9. HelloClass(v){  
    10. alert("构造");  
    11. }  
    12. }  
    13. new HelloClass();  
    14. </script>  
    15. 上面定义的HelloClass既是一个类成员的定义也是一个类。如果看作是函数，可以把它理解为  
    16. 类的构造方法，负责初始化的工作。可以应用new操作符来创建一个对象，例如：  
    17. new Date();  
    18. var obj=new HelloClass();  
    19. 上面第一句代码表示创建一个日期对象，而Date 就是表示日期的类，但是这个类是由  
    20. JavaScript内部提供的，而不是用户定义的。第二句是用new操作符创建用户定义的对象。  
    21. 在javaScript中，每个对象都可以看作是多个属性（方法）的集合，引用一个属性（方法）的  
    22. 格式如下：  
    23. 对象名.属性（方法）名  
    24. 除此之外，还可以用方括号的形式来引用(注意方括号中的双引号，不可省略):  
    25. 对象名["属性（方法）名"]  
    26. 这里所指的方法名和属性名是一个字符串，例如：  
    27. var arrs=new Array();  
    28. arrs["push"]("javakc"); //添加一个元素(调用对象的方法)  
    29. var len=arrs["length"]; //获得数组的长度(调用对象的属性)  
    30. alert(len);  
    31. 上面编写的代码等价于如下代码：  
    32. var arrs=new Array();  
    33. arrs.push("javakc"); //添加一个元素(调用对象的方法)  
    34. var len=arrs.length; //获得数组的长度(调用对象的属性)  
    35. alert(len);  
    36. 上面这种引用属性（方法）的方式，反应出一个JavaScript对象就是一组属性（方法）的集合  
    37. 这个性质。  
    38. 利用方括号的形式来引用，这种用法适用于不确定具体要调用哪一个属性（方法）的应用，例如  
    39. 有一个用户资料的对象，通过一个字符串来表示要使用的属性，就可以用这种方式来引用，其代码如  
    40. 下：  
    41. <script language="javascript">  
    42. //定义一个User类,包括三个属性name,age和sex,并指定了初始值。  
    43. function User(){  
    44. this.name="Tom";  
    45. this.age=18;  
    46. this.sex="男";  
    47. }  
    48. //创建User对象  
    49. var user=new User();  
    50. //根据下拉列表框显示用户的信息  
    51. function show(slt){  
    52. if(slt.selectedIndex!=0){  
    53. alert(user[slt.value]);  
    54. }  
    55. }  
    56. </script>  
    57. <!--选择用户信息 -->  
    58. <select onchange="show(this)">  
    59. <option value="name">姓名</option>  
    60. <option value="age">年龄</option>  
    61. <option value="sex">性别</option>  
    62. </select>  
    63. 在上面的代码中，使用一个下拉列表框让用户选择User类的属性，每个选项的value就表示用  
    64. 户对象的属性名称。  
    65. 第二节 prototype对象  
    66. prototype对象是实现面向对象的一个重要机制。每个函数也是一个对象，它们对应的类就是  
    67. function，每个函数对象都具有一个子对象prototype。Prototype 表示了该函数的原型，  
    68. prototype表示了一个类的属性的集合。当通过new来生成一个类的对象时，prototype对象的属  
    69. 性就会成为实例化对象的属性。  
    70. 下面以一个例子来介绍prototype的应用，代码如下：  
    71. <script language="javascript">  
    72. //定义一个空类  
    73. function HelloClass(){  
    74. }  
    75. //对类的prototype对象进行修改，增加方法method  
    76. HelloClass.prototype.method=function(){  
    77. alert("prototype测试");  
    78. }  
    79. var obj=new HelloClass(); //创建类HelloClass的实例  
    80. obj.method(); //调用obj的method方法  
    81. </script>  
    82. 当用new创建一个对象时，prototype对象的属性将自动赋给所创建的对象，例如：  
    83. <script language="javascript">  
    84. //定义一个只有一个属性的类  
    85. function HelloClass(){  
    86. this.name="javakc";  
    87. }  
    88. //使用函数的prototype属性给类定义新属性  
    89. HelloClass.prototype.showName=function(){  
    90. alert(this.name);  
    91. }  
    92. var obj=new HelloClass(); //创建类HelloClass的一个实例  
    93. //调用通过prototype原型对象定义的showName方法  
    94. obj.showName();  
    95. </script>  
    96. 因为prototype是一个JavaScript对象，所以可以为prototype对象添加、修改方法和属性。  
    97. 第三节 JavaScript反射机制  
    98. 反射机制是指程序在运行期间能够获取自身的信息，例如一个对象能够在运行时知道自己拥有哪  
    99. 些方法和属性，并且可以调用这些方法和属性。在C#和Java中都提供了反射机制，能够在运行时动  
    100. 态判断和调用自己的属性或方法。在JavaScript中可用for(…in…)语句来实现反射，其语法如下：  
    101. <script language="javascript">  
    102. for(var vs in obj){  
    103. //如果是方法就调用执行  
    104. if(typeof(obj[vs])=="function"){  
    105. obj[vs]();  
    106. //如果是属性，则输出它的值  
    107. }else{  
    108. alert(obj[vs]);  
    109. }  
    110. }  
    111. </script>  
    112. 在以上代码中利用var vs声明的一个变量用来存储对象obj的属性（方法）名称，有了对象名  
    113. 和属性（方法）名，就可以使用方括号语法来调用一个对象的属性（方法）了。  
    114. 上面的程序语句用语遍历obj对象的所有属性和方法，遇到属性则显示它的值，遇到方法，就调  
    115. 用执行。该语句就是遍历一个集合内的所有成员。在基于对象的JavaScript程序设计中，反射机制是  
    116. 很重要的一种技术，它在实现类的继承中发挥了很大的作用。  
    117. 第四节 JavaScript类继承  
    118. 利用共享prototype实现继承  
    119. 类之间的继承关系是现实世界中遗传关系的直接模拟，它表示类之间的内在联系以及对属性和操  
    120. 作的共享，即子类可以沿用父类（被继承的类）的某些特征。当然子类也可以具有自己独立的属性和操  
    121. 作。  
    122. 继承也是软件复用的一种形式，新类由已存在的类生成，通过保留它们的属性和行为并且根据新  
    123. 类的要求对性能加以修改，添加新的属性和行为。虽然在JavaScript中没有专门的机制来实现类的  
    124. 继承，但可以通过复制一个类的prototype到另外一个类来实现继承。下面是一种简单的继承实现，  
    125. 代码如下：  
    126. <script language="javascript">  
    127. function HelloClass(){  
    128. //构造方法  
    129. }  
    130. function HelloSubClass(){  
    131. //构造方法  
    132. }  
    133. HelloSubClass.prototype=HelloClass.prototype;  
    134. HelloSubClass.prototype.Propertys="name";  
    135. HelloSubClass.prototype.subMethods=function(){  
    136. //方法实现代码  
    137. alert("in Methods");  
    138. }  
    139. var obj=new HelloSubClass();  
    140. obj.subMethods();  
    141. </script>  
    142. 在以上的代码中，首先是HelloSubClass具有了和HelloClass一样的prototype，如果不考  
    143. 虑构造方法，则两个类是等价的。随后，又通过prototype给HelloSubClass赋予了额外的属性和方法  
    144. 所以HelloSubClass是在HelloClass的基础上增加了新的属性和方法，从而实现了类的继承。  
    145. JavaScript提供了instanceof操作符来判断一个对象是否是某个类的实例，对于上面创建的obj  
    146. 对象，下面两条语句都是成立的：  
    147. obj instanceof HelloSubClass //true  
    148. obj instanceof HelloClass //true  
    149. JavaScript 能够正确地理解这种继承关系，在下面的代码中，先使用property 让  
    150. HelloSubClass继承HelloClass，然后再HelloSubClass中重复定义method方法，例如：  
    151. <script language="javascript">  
    152. //定义HelloClass  
    153. function HelloClass(){  
    154. //构造方法  
    155. }  
    156. //定义HelloClass的成员  
    157. HelloClass.prototype={  
    158. f1:function(){  
    159. alert("in HelloClass");  
    160. }  
    161. }  
    162. //定义HelloSubClass  
    163. function HelloSubClass(){  
    164. //构造方法  
    165. }  
    166. //让HelloSubClass继承HelloClass  
    167. HelloSubClass.prototype=HelloClass.prototype;  
    168. //给HelloSubClass重新定义方法method  
    169. HelloSubClass.prototype.Propertys="name";  
    170. HelloSubClass.prototype.method=function(){  
    171. //方法实现代码  
    172. alert("in HelloSubClass");  
    173. }  
    174. //创建两个类的实例  
    175. var obj1=new HelloClass();  
    176. var obj2=new HelloSubClass();  
    177. //分别调用两个对象的method方法  
    178. obj1.method();  
    179. obj2.method();  
    180. </script>  
    181. 执行上述代码后，弹出两个对话框都显示HelloSubClass 字样。由此可见，当对  
    182. HelloSubClass 进行prototype 的改变时，HelloClass 的prototype 也随之改变，即使对  
    183. HelloSubClass 对prototype 增减一些成员， HelloClass 的成员也随之改变， 所以  
    184. HelloClass和HelloSubClass仅仅是构造方法不同的两个类，它们保持着相同的成员定义，也就  
    185. 是说HelloClass和HelloSubClass的prototype是完全相同的，是对同一个对象的引用。  
    186. 在JavaScript中，除了基本的数据类型外（数字、字符串、布尔），所有的赋值以及函数参数都  
    187. 是引用传递，而不是值传递，所以上面的语句仅仅是让HelloSubClass 的prototype 对象引用  
    188. HelloClass 的prototype，造成了类成员定义始终保持一致的效果。从这里也可以看到  
    189. instanceof操作符的执行机制，它用于判断一个对象是否是一个prototype的实例，因为这里的  
    190. obj1和obj2是对应同一个prototype，所有它们的instanceof的结果是相同的。  
    191. 利用反射机制和prototype实现继承  
    192. 前面介绍的通过共享prototype来实现类的继承，并不是一种很好的方法，由于两个类共享同  
    193. 一个prototype，任何对成员的重定义都会相互影响，不是严格意义上的继承。可以利用反射机制来  
    194. 实现类的继承，利用for(…in…) 语句枚举所有基类prototype 的成员，并将其赋值给子类的  
    195. prototype对象，实现方法如下：  
    196. <script language="javascript">  
    197. //定义HelloClass  
    198. function HelloClass(){  
    199. //构造方法  
    200. }  
    201. //定义HelloClass的成员  
    202. HelloClass.prototype={  
    203. method:function(){  
    204. alert("in HelloClass method");  
    205. },  
    206. method2:function(){  
    207. alert("in HelloClass method2");  
    208. }  
    209. }  
    210. //定义HelloSubClass  
    211. function HelloSubClass(){  
    212. //构造方法  
    213. }  
    214. //让HelloSubClass继承HelloClass  
    215. for(var p in HelloClass.prototype){  
    216. HelloSubClass.prototype[p]=HelloClass.prototype[p];  
    217. }  
    218. //覆盖HelloClass中的method方法  
    219. HelloSubClass.prototype.method=function(){  
    220. //方法实现代码  
    221. alert("in HelloSubClass method");  
    222. }  
    223. //创建两个类的实例  
    224. var obj1=new HelloClass();  
    225. var obj2=new HelloSubClass();  
    226. //分别调用两个对象的method方法  
    227. obj1.method();  
    228. obj2.method();  
    229. //分别调用两个对象的method2方法  
    230. obj1.method2();  
    231. obj2.method2();  
    232. </script>  
    233. 在以上的代码中，obj2 中重复定义的method 方法已经覆盖了继承的method 方法，同时  
    234. method2方法未受影响，而且obj1中的method方法仍然保持了原有的定义。这样就实现了正确意  
    235. 义上的类的继承，也可以为每个类添加一个公共的方法，用以实现类的继承，例如：  
    236. //为类添加静态方法inherit表示继承于某类  
    237. Function.prototype.inherit=function(baseClass){  
    238. for(var p in baseClass.prototype){  
    239. this.prototype[p]=baseClass.prototype[p];  
    240. }  
    241. }  
    242. 上面用所有函数对象（类）的共同类Function 来添加继承方法，这样所有的类都会有一个  
    243. inherit方法，用以实现继承。于是，上面代码中的类的继承可以写为：  
    244. //让HelloSubClass继承于HelloClass  
    245. HelloSubClass.inherit(HelloClass);  
    246. 这样，代码逻辑变的更加清楚，也更容易理解。  
    247.   
    248. 练习题  
    249. 单选题  
    250. 1. 以下哪条语句会产生运行错误：（A）  
    251. A. var obj = ( );  
    252. B. var obj = [ ];  
    253. C. var obj = { };  
    254. D. var obj = //;  
    255. 2. 以下哪个单词不属于javascript保留字：（B）  
    256. A. with  
    257. B. parent  
    258. C. class  
    259. D. void  
    260. 3. 请选择结果为真的表达式：（C）  
    261. A. null instanceof Object  
    262. B. null === undefined  
    263. C. null == undefined  
    264. D. NaN == NaN  
    265. 不定项选择题  
    266. 4. 请选择对javascript理解有误的：(ABCD)  
    267. A.JScript是javascript的简称  
    268. B.javascript是网景公司开发的一种Java脚本语言，其目的是为了简化Java的开发难度  
    269. C.FireFox和IE存在大量兼容性问题的主要原因在于他们对javascript的支持不同  
    270. D.AJAX技术一定要使用javascript技术  
    271. 5. foo对象有att属性，那么获取att属性的值，以下哪些做法是可以的：（ACE）  
    272. A. foo.att  
    273. B. foo("att")  
    274. C. foo["att"]  
    275. D. foo{"att"}  
    276. E. foo["a"+"t"+"t"]  
    277. 6. 在不指定特殊属性的情况下，哪几种HTML标签可以手动输入文本：（AB）  
    278. A.<TEXTAREA></TEXTAREA>  
    279. B.<INPUT type="text"/>  
    280. C.<INPUT type="hidden"/>  
    281. D.<DIV></DIV>  
    282. 7. 以下哪些是javascript的全局函数：（ABC）  
    283. A.escape  
    284. B.parseFloat  
    285. C.eval  
    286. D.setTimeout  
    287. E.alert  
    288. 8. 关于IFrame表述正确的有：(ABCD)  
    289. A.通过IFrame，网页可以嵌入其他网页内容，并可以动态更改  
    290. B.在相同域名下，内嵌的IFrame可以获取外层网页的对象  
    291. C.在相同域名下，外层网页脚本可以获取IFrame网页内的对象  
    292. D.可以通过脚本调整IFrame的大小  
    293. 9. 关于表格表述正确的有：（ABCDE）  
    294. A.表格中可以包含TBODY元素  
    295. B.表格中可以包含CAPTION元素  
    296. C.表格中可以包含多个TBODY元素  
    297. D.表格中可以包含COLGROUP元素  
    298. E.表格中可以包含COL元素  
    299. 10. 关于IE的window对象表述正确的有：（ACD）  
    300. A.window.opener属性本身就是指向window对象  
    301. B.window.reload()方法可以用来刷新当前页面  
    302. C.window.location="a.html"和window.location.href="a.html"的作用都是把当  
    303. 前页面替换成a.html页面  
    304. D.定义了全局变量g；可以用window.g的方式来存取该变量  
    305. 11. 如何获取表单select域的选择部分的文本？  
    306. 12. 在JavaScript中定时调用函数 foo() 如何写？  
    307. 13. form中的input可以设置readonly和disable，请问这两项属性有什么区别？ 
posted @ 2016-11-25 10:21  starskyhu  阅读(718)  评论(0)  编辑  收藏  举报