javascript知识点小结

一、定义正则表达式的两种方法

1.法1，格式: re = /pattern/[flags]

  法2，格式: re = new RegExp("pattern",["flags"]);

 2.用正则表达式来检验，主要是用正则表达式对象中的test(str)方法: 返回一个 Boolean 值，它指出在被检验的字符串中是否匹配

 3. 两种正则表达式定义方法的细节区别

 例：写一个检验只包含6位数字的正则表达式

        法1：var reg = /^\d{6}$/; //不存在转义

        法2：var reg = new RegExp("^\\d{6}$");

       法二和法1相比，，要注意转义字符，即这里有"\"

二、控制提交表单的两种方法

  法一

<form id="userinfo">
		姓名：<input type="text" id="Username" >
		密码：<input type="password" id="pwd" >
        <input type="button" value="提交" onclick="onSubmit();">
</form>

  自己写一个提交的函数，利用userinfo.submit()函数提交,这种方法无需经过表单的onsubmit事件的响应方法返回true，才可提交

法二

写一个checkForm（）函数，如果onsubmit事件的响应方法返回true则表单能够提交，否则被阻止提交-->

<form action="29dhtml-form.html"  onsubmit="return checkForm();">

     姓名：<input type="text" id="Username" >

     密码：<input type="password" id="pwd" >

     <input type="submit" value="注册">

 </form>

三、直接在html的body下添加节点 

document.body.appendChild(oTableNode);

四、<fieldset>标签

<form>
  <fieldset>
    <legend>health information</legend>
    height: <input type="text" />
    weight: <input type="text" />
  </fieldset>
</form>

    当一组表单元素放到 <fieldset> 标签内时，浏览器会以特殊方式来显示它们，它们可能有特殊的边界、3D 效果，或者甚至可创建一个子表单来处理这些元素。

 <legend> 标签为 fieldset 元素定义标题。

五、onchange和onclick的区别

onchange事件只有在选项值有变化时才会触发，而onclick事件在每次点击时都会触发。

<select name="selectName" οnchange="changeColor2(this)">

This代表着select这个元素，然后将其传到changeColor这个函数中

六、slect元素

   

 <select id = "provinces" onchange="GetProvince(this)">
		<option>请选择省/市</option>
		<option>北京</option>
		<option>湖南</option>
		<option>浙江</option>
</select>

1.删除select中的元素

    法1: 该方式要注意,集合中的数据是动态变化的,因此序号i不要++,,永远删第1行，因为删除之后后续的行会依次往上上来

for(var i=1; i<oSubSelNode.options.length;  ){ //此处不能i++ 
	oSubSelNode.removeChild(oSubSelNode.options[i]);
}

oSubSelNode 是通过getElementById（provinces）得到的

法2: <select>中有年属性叫length,通过它可以:设置或获取集合中对象的数目。

oSubSelNode.length=1; //保留第0项

自己添加select中的元素

for(var x=0; x<arrCities.length;x++){
	var oOptionNode = document.createElement("option");
	oOptionNode.innerHTML=arrCities[x];
	//oSubSelNode.add(oOptionNode); //用<select>自己特有的方法
	oSubSelNode.appendChild(oOptionNode);//用底层的方法
}

七、span元素

密码：<input type="password" id="pwd" onmousemove="PwdInfo();"  ><span id="pwdspan"></span><br>
 function PwdInfo(){
	var oSpanPwdNod = document.getElementById("pwdspan");
	oSpanPwdNod.innerHTML="密码长度需为8-16位".fontcolor("red").bold();
}

这段代码可以在鼠标经过密码这个input组件时，向span标签内写 "密码长度需为8-16位"的内容   

八、<a>标签

用a标签包东西，可以实现类似按钮功能的两种方法：

1.<a href="javascript:void(0);>文字按钮1</a>

2.<a href=“#”>文字按钮2</a>  

九、用javascript创建表格，删除表格

1.把表格当作普通的HTML元素来操作 ----没有使用表格相关的专用方法来实现

           function createTable(){
				//1创建<table>
				var oTableNode = document.createElement("table");
				//2创建<tbody>
				var oTbody = document.createElement("tbody");
				//3创建<tr>
				var oTr = document.createElement("tr");
				//4创建<td>
				var oTd = document.createElement("td");
				//5创建文本内容
				oTd.innerHTML="单元格文本内容";
				//6 把1-4组装成一棵子树
				oTr.appendChild(oTd);//可以加多个<td>
				oTbody.appendChild(oTr);//可以加多个<tr>
				oTableNode.appendChild(oTbody);
				//把上面组装的子树添加到div中
				document.getElementById("div1").appendChild(oTableNode);
			}

 2.使用表格相关的专用方法来实现，调table的insertRow()和insertCell()方法

function createTable(){

    var oTableNode = document.createElement("table");

    var oTrNode = oTableNode.insertRow();

    var oTdNode = oTrNode.insertCell();

    document.getElementById("div1").appendChild(oTableNode);

}

3.删除行：直接调用table里的deleteRow（）方法     

 if(rowNum2>=1 && rowNum2<= oTableNode.rows.length){

   oTableNode.deleteRow(rowNum2-1);
 }

   4.删除列：调用tr里面的deleteCell方法

              if(colNum2>=1 && colNum2<= oTableNode.rows[0].cells.length){
				  for(var i=0;i<oTableNode.rows.length;i++){
					  oTableNode.rows[i].deleteCell(colNum2-1);
				  }
			   }	 

十、页面加载完就执行某一函数

      function trColor(){}     

      οnlοad=trColor;

十一、在网页页面上对表格里一个数组进行排序

在内存中排序比较合适，因此方案：把行集合trRows备份到一个数组，对数组进行排序，最后再把排序后的数组添加到表格

十二、删除一个复选款集合里选项

  1. //法1：从前往后删，需要把序号回退一下

             for(var i=0;i<collMailChkNodes.length;i++){
				   if(collMailChkNodes[i].checked){
					   //获取当前复选框所在的<tr>行对象
					   var oTrNode = collMailChkNodes[i].parentNode.parentNode;
					   //删除当前行
					   oTrNode.parentNode.removeChild(oTrNode);
					  i--;//因为行集合是动态变化的，删除第i行之后，原来的第i+1自动更新为第i行。因此这里要回退一下，如若不回退，则再删除2.3.4项的时候会留下第三项，因为再删除第二项的时候，第三项自动变为第二项
				   }
			   }

 2. //法2: 从后往前删，更简单

             for(var i=collMailChkNodes.length-1;i>=0;i--){
				   if(collMailChkNodes[i].checked){
					   var oTrNode = collMailChkNodes[i].parentNode.parentNode;
					   oTrNode.parentNode.removeChild(oTrNode);
				   }
             }
			   

十三、dom中的增删改查

 A、查询节点类别1：（leve10）//level0表示没有层次关系，及直接通过调用相关函数去找某个节点，而没有去找他的兄弟或者父亲，孩子节点

1.getElementById()---通过标签的id属性，返回唯一的元素节点

2.getElementByName()---通过标签的name属性，返回一个数组

3.getElementByTagName()--通过标签名称，返回一个数组

4.getElementByClassName()---通过标签的class属性，返回一个数组

B、通过普通元素(标签节点)，在它的子孙节点中进行level0查询即用    如：

<div id="goods">

  <a href="goods/1.html">商品1</a>     

  <a href="goods/2.html">商品2</a>     

  <a href="goods/3.html">商品3</a>
</div>

var oDivGoods = document.getElementById("goods");

//在oDivGoods节点的子孙节点中进行level0的查询
var oAs = oDivGoods.getElementsByTagName("a");

C、查询节点类别2(level1):

  通过节点在dom中的相互之间的辈份关系(父子、兄弟)进行查询。

 属性: firstChild、lastChild、nextSibling(下一个兄弟节点)、parentNode、previousSibling(上一个兄弟节点) <br/>

 集合: childNodes(儿子们,包括元素和文本内容)、children(儿子们，仅包括元素,没有文本)  ---属性是不在儿子们当中的  

如：//获取表格中第一个td的文本内容

        function demo2(){
			var oTable = document.getElementById("tabl");
			var oTdNode = oTable;
			alert(oTdNode.nodeType + "," + oTdNode.nodeName);//1,TABLE
			while (oTdNode.nodeName != "TD") {
				oTdNode = oTdNode.childNodes[0];
				oTdNode = nextNode(oTdNode);
			}
			alert(oTdNode.innerText);	
			//跳过空白符,无论是上一个标签离下一个标签空了多少行，都只看成一个空白符
			function nextNode(oNode){
				while(oNode.nodeName=="#text"){
					oNode= oNode.nextSibling;
				}
				return oNode;
			}
        }

D、增加一个节点：

 例：添加一个按钮节点

           function add2(){
				//1创建一个文件节点
				var oInputNode = document.createElement("input");
				oInputNode.type="button";
				oInputNode.value="一个新按钮";
				
				//2获取div节点
				var oDiv = document.getElementById("div1");
				//3把文本节点加成div节点的孩子
				oDiv.appendChild(oInputNode);
			}

E、删除一个节点：    

          function delNode(){
				var oDivNode = document.getElementById("div2");
				/*
				var boo = oDivNode.removeNode(false); //删除后，所有子节点上升一层
				//var boo = oDivNode.removeNode(true); //连子节点一起删除
				*/
				
				//建议比较干净删除方式,让父节点删除子节点
                //removeChild()会整个子树一起删除
				oDivNode.parentNode.removeChild(oDivNode); 		
			}

F、将一个节点与另一个节点交换：

 例：用div3 替换 div1

            //1移动替换
			function updateNode(){
				var oDivNode1 = document.getElementById("div1");
				var oDivNode3 = document.getElementById("div3");
				//oDivNode1.replaceNode(oDivNode3);
				oDivNode1.parentNode.replaceChild(oDivNode3,oDivNode1);
			}
		
		    //2克隆替换
			function updateNode2(){
				var oDivNode1 = document.getElementById("div1");
				var oDivNode3 = document.getElementById("div3");
        //空参默认为cloneNode(false),代表子树不克隆。相反，cloneNode(true)会连子树一起克隆
				var oCopyDiv3 = oDivNode3.cloneNode(true);
				oDivNode1.parentNode.replaceChild(oCopyDiv3,oDivNode1);
			}

十四、window对象中的相关常用方法

  1.confirm()

          function demo1(){
			   //close();//关闭窗口   window.close(); 
			   var boo = window.confirm("你真的想关闭窗口??");
			   if(boo){
			   	  window.close();
			   }
		   }//再点击关闭窗口时，弹出一个选择框，让你确定是否关闭

  2.moveBy（），moveTo（） 移动窗口         

           function demo2(){
			   moveBy(10,10);//把当前窗口的位置相对移动(10,10)
			   moveTo(120,210);//把当前窗口的位置移至位置:(120,210)
		   }

3. setTimeout（）， setInterval（）创建定时器

//3秒之后会执行第一个参数中的代码即alert(),,,只执行一次  
setTimeout("alert('时间到!');",3000);

//每隔50毫秒,会执行第一个参数中给定的函数,,,执行多次
setInterval(aa,50);

 4. clearInterval（），clearTimeout（）清除定时器

//3秒之后会执行第一个参数中的代码即alert(),只执行一次 
//idTimer = setTimeout("alert('时间到!');",3000);
idTimer = setInterval(aa,50);//每隔50毫秒,会执行第一个参数中给定的函数,执行多次
//clearTimeout(idTimer);
clearInterval(idTimer);

十五、innerText与innerHtml的区别

oDivElement.innerText="<font size=18>Hello马上下课....</font>";//只是原样(纯文本)输出，不会解析

oDivElement.innerHTML="<font size=18>Hello马上下课....</font>"; //会当作HTML解析显示

十六、DOM，BOM

DOM---Document Object Model  文档对象模型，

bom模型: browse object model 浏览器对象模型

dom技术: 把标记文档变成对象树，通过对这棵树中的对象进行操作(增删改查)，实现对文档内容的操作。

对dom对象树进行增删改查，产生的效果就是对页面内容进行增删改查!

文档:html页面，xml文档(文件)   

dom模型针对的是页面内容，bom模型针对的是浏览器

dom: document对象代表的是整个文档页面

bom:  window对象就是代表整个浏览器本身

十七、DHTM

DHTML:动态html技术，它不是一门语言，而是一项综合技术: html+css+js+dom

技术边界:

        html: 提供标签，对数据进行封装。----目的是便于对该标签中的数据进行操作

        css: 提供样式属性，对标签中的数据进行样式定义

        dom: 把标记文档解析成对象树，并且提供一些对树中对象进行操作的   变量和函数

        js:  提供程序设计语言，对页面中的对象进行逻辑操作 (if,for,...)

十八、自定义对象

1.封装性比较差,比较底层  ---用一个空函数或Object当前对象的原型，然后给该原型手动一步步添加成员变量和方法

例：     var p = new Person(); //相当于调用构造方法，创建一个新对象
	     //☆给已经创建的对象添加成员变量或成员方法: 对象名.成员名=...
	     p.name="Alice"; //添加成员变量
	     p.age=22;
	     p.show=function(){//添加成员变量
	    	 alert("name="+p.name+",age="+p.age);
	     };

         //也可以直接用Object对象来创建
	     var p2 = new Object();
	     p2.name="Bob";
	     p2.sex="male";
	     p2.age=24;
	     p2.sayHello=function(){
	    	 alert("name="+p2.name+",age="+p2.age+",sex="+p2.sex);
	     };

2.方式2: 封装性比较好,更接近于Java中的面向对象建模    

           function Person(name,age){
	        	this.name=name;
	        	this.age=age;
	        	this.setName=function(name){
	        		this.name=name;
	        	};
	        	this.getName=function(){
	        		return this.name;
	        	};
	        	this.setAge=function(age){
	        		this.age=age;
	        	};
	        	this.getAge=function(){
	        		return this.age;
	        	};
	        	this.toString=function(){
	        		return this.name+","+this.age;
	        	};
	        }

3.方式3: 用于封装数据----Json技术 , 是一种轻量级的数据交换格式

      json的基本格式有两种: map(用大括号封装),list(用中括号封装)

3.1 map      

        var p3 = {
	    		  "name":"Bob",
	    		  "age":22,
	    		  3:"小李",
	    		  "getName":function(){ return this.name; }
	      };

	      //访问map中的数据,方式1：对象名["属性名"] -----能通吃所有,但不要忘掉引号
	      println( p3["name"] ); //AC
	      println( p3["3"] ); //AC
	      println( p3["age"]);//AC
	      //println( p3[age]);//WA , 原因:忘掉引号
	      
	    
	      //访问map中的数据,方式2：对象名.属性名 ---如果属性名不符合变量名的命名规则，不行!
	      println( p3.name );
	      println( p3.age );
	      //println( p3.3 ); //WA: 因为这里的属性名是“3”，不符合变量名的命名规则
命名规则：必须以字母或下划线开头，其他的可以用字母，下划线或数字，变量名中不能有空格，+，-等其他符号

3.2 list--array

      var strs=["aa","bb","cc"];

      println( strs[0] ); //访问方式: 对象名[元素序号] ---参见数组元素的访问方式

一般封装数据采用map和list的混合应用：

    如：

         var datas={
             "stus":[
						{"id":"A001", "name":"Jack", "address":"湖南长沙", "age":25},
						{"id":"A002", "name":"张三", "address":"湖南益阳", "age":24},
						{"id":"A003", "name":"孙权", "address":"湖北武汉", "age":20}
  					],
  			"curentpase":15,
  			"cont":100,
  			"depts":{"name":"信电院","address":"信息楼","num":2000}
           };
          println(datas["stus"][1]["address"]);
          println(datas.stus[1].address);
          println(datas.depts.address);

十九、for...in----

    相当于把java中的普通for循环和增强for循环合并成一个,  

    格式：        for(变量 in 对象){

                       ....//对对象中的每个元素分别进行操作

                        }

1.for  in访问数组

var ar=[1,4,6,8];

for(x in ar){

    println(ar[x]);

}

2.for in访问普通对象

for(i in p){

    println(p[i]);

}//会将p对象的所有成员变量输出来

3.for in访问json对象

for(i in datas){
    for(key in datas[i]){
       for(key2 in datas[i][key]){
       print(datas[i][key][key2]+" ");
       }
    }
    println("");
}

二十、Global对象

Global 对象从不直接使用，并且不能用 new 运算符创建。它在 Scripting 引擎被初始化时创建，并立即使其方法和属性可用

方法：例：

 println(parseInt("12abc"));   // 返回 12。

 println(parseInt("110",2));

/*1.parseInt 方法

返回由字符串转换得到的整数。

parseInt(numString, [radix])

*/

二十一、math对象

    Math 对象不能用 new 运算符创建，如果试图这样做则给出错误。该对象在装载脚本引擎时由该引擎创建。其所有方法和属性在脚本中总是可用。

      方法： 例  

      println(Math.round(3.68));
      println(Math.round(3.24));
      /**.round 方法
     返回与给出的数值表达式最接近的整数。
     Math.round(number) 
     必选项 number 参数是要舍入到最接近整数的值。
     */

二十二、date对象

         var d = new Date();
         println(d.getDate());//2,一个月中的第几天
         println(d.getDay());//2，一个星期中的第几天

      /*☆一个小语法:
	    	with(对象){
	    	   ....//对该对象进行一系列操作,可以省略"对象."
	        } 
	    */
	    
	    //获取d4对象中的年、月、日
	    /*
	      var y = d4.getFullYear();
		  var m = d4.getMonth()+1;
		  var dd = d4.getDate();
	    */
	    //上面一段用with(){}语法可以写成如下:
	    var d4=new Date();
	    with(d4){ 
		    var y = getFullYear();
		    var m = getMonth()+1;
		    var dd = getDate();
	    }

二十三、String对象

     //创建String对象的两种方式

     var str1="abc";

     var str2=new String("abc");

二十四、变量的作用域

    1:在js中，一个变量定义之后，它的作用域不是以大括号来区分的，不但在本段脚本有效，而且在整个页面的所有脚本段中都是有效的

      ---这个概念就是全局变量

如：

<script type="text/javascript">
    for(var i=0; i<10; i++){
        document.write("i=" +i+ "&nbsp;");
    }
    document.write("<br>i="+i+"<br>");   //10
</script>
<script type="text/javascript">
    document.write("<br>i="+i+"<br>"); //10
</script>

  2:在函数中定义的变量是局部变量，在函数外面是不能访问的。

一个细节:一个变量若声明但没赋值，它的值是undefined(由js默认帮我们初始化的值)。

如果一个变量没有声明就使用，在语法是挂的---语法错误!

如：

<script type="text/javascript">
    function show(){
        var x=6;
        x++;
    }
    document.write("<br>x="+x+"<br>");
    //WA:因为变量x没有定义，，函数中定义的是局部变量，在这里访问不到。
var y=2;//全局变量
	  function change(y){//形参y是局部变量，更改之后，不影响外面的实参
		  y++; 
		  //alert("yyyyy:"+y); //3
	  }
	  change(y);//实参
	  document.write("y="+y+"<br/>");//2
</script>	 

二十五、js语法

1.、s中关键字，与Java中差不多，多了一个var，分隔符标识符与java中一样。

2、Js中的数据类型有：number,string,boolean,引用数据类型object

 A。js中没有char型，说，单引号和双引号都是字符串的分界符

 B.js中没有整型和浮点型只有number型

 C。和Java一样，true和false都是小写，但有一点区别:js中的布尔型值有0 和 非0 的概念， 且在计算时true的值为1，false的值为0

3、变量，js中变量全部用var声明，

  A。  Var x=1;

       Var x=abc;

        x原来是number类型，现在重新赋另一种数据类型如string型数据，可以的，而且这就是弱类型语言的一个经典体现!

  B.     var x = 45;

         alert("x5="+x);    

          var x;

          alert("x6="+x);  

    x6=45;如果该变量前面已声明，这里并未赋值，那么他得值和前面是共享空间的

    C.    var xx;

          alert("xx="+xx);   

xx=undefined,一个第一声明的变量，若没有赋初值，js默认赋值：undefined

4.运算符和表达式

    4.1:算术运算符： +（正）、-（负）、+（加）、-（减）、*、/（除）、%（取余） 、++、--

    4.2:赋值运算符：= 、+= -=  *= /=  和Java用法一样

   4.3:关系运算符：==  ！=  >    <   >=   <=

  4.4： 逻辑运算符： &&（条件与）、||（条件或）、!（非）  ----JS中只有这三个逻辑运算符，而Java还有：&（与）、|（或）、∧（异或）

  4.5：位运算符：~（非）、&（与）、|（或）、^（异或）、<<（左移位）、>>（右移位）、>>>（无符号右移位）

    4.6:条件运算符（问号表达式，3元运算符）：表达式1 ？ 表达式2 ： 表达式3

    Var c=6;

    alert(c>30 ? 1: 2.5);   //2.5,表达式1为假，执行表达式2

5.循环控制：

    If， if else ， if else if else  ，while ，do while,  for的用法跟Java一样

switch-case:case: 用法和Java类似。只是：Java只能用于 byte、int等整数类型，char和jdk1.7新增的String类型。

//而js支持所有数据类型，即所有类型的数据都能用于选择  

Var x="bb";

  switch(x){

    case "aa":

      alert("aa");

    break;

    case "bb":

      alert("bb");

    break;

    case "cc":

      alert("cc");

    break;

}

二十六、Html与javascript结合的方式

    方式一：直接在scipt标签写js代码   

 <script type="text/javascript">

        var a = 10;

        alert(a);

    </script>

    方式二：导入外部文件--在script标签中利用src属性指定外部js文件的位置及文件名

<script type="text/javascript" src="js/1.js"></script>

二十七、js中的数组

1.数组定义1       

         var arr=[1,3,4,6];

         arr[5]=8;

         for(var i=0; i<arr.length;i++){

             document.write("arr["+i+"]="+arr[i]+" ");

          }

      //js中数组长度可变，若没有赋值，则为undefined

2.数组定义2

        var arr2=[];
         arr2[0]=10;
         arr2[1]=2.65;
         arr2[2]="abc";
         arr2[3]=true;
         for(var i=0; i<arr2.length;i++){
               document.write("arr2["+i+"]="+arr2[i]+"&nbsp;");
         }
    //js中数组的元素类型可任意
   //综合定义法1,2所得， 总之，js语言中只有唯一的一个容器"数组"，它把java中的数组和集合的功能集于一身

    3.数组定义3（基于对象的用法）

     3.1:无参          

            var a=new Array();

            a[0]=1;

            a[1]=2;

            for(var i=0;i<a.length;i++){

                document.write("a["+i+"]="+a[i]+" ");

            }

   3.2带一个参数，即数组长度

           var b=new Array(3);

           b[0]=11;

           b[1]=5;

           for(var i=0;i<b.length;i++){

               document.write("b["+i+"]="+b[i]+" ");

           }

      3.3带有几个参数，参数值即为数组里的值          

          var c = new Array(3,"abc",true,7);

          for(var i=0;i<c.length;i++){

          document.write("c["+i+"]="+c[i]+" ");

二十八、js函数

A、 js函数的定义格式

function  函数名(形参列表){

    执行语句；

    [return 返回值；]

}

1.无参

function hello(){

   alert("hello function");

}

2.有参

function sum(a,b){

    return a+b;

}

function getsum(){

    var x =sum(3,5);

    alert(x);

}

 函数细节：

    1有关函数名及内存模型的细节

     var y=hello;

     alert(y);  //会将函数直接打印出来，因为函数就是一个Function对象，函数名即对象名，这时相当于将hello引用赋值给y，y与hello指向同一个Function对象

alert(y());   //会打印:hello function

    

    2有关函数书写位置的细节

      function demo2(){

         show(1,2);   //在demo2所在函数的script标签内及其以上的script标签都没写show函数

      }

   //demo2();//☆WA:不能执行，因为浏览器在解析当前<script>标记时，还没有加载下一个<script>标记，因此不认识show(a,b)这个函数

 //解决办法：写一个按钮，单击事件中调用demo2()，则可以，因为事件发生时，浏览器已经把整个页面都解析完(显示完成)。//☆综上，为了我们以为写的所有js函数在页面都能被认识，通常把这些js代码写在<head>中，然后在页面元素事件中调用，此时<head>部分早就解析完了。

3.js中的函数不存在重载，参数根据调用时的实参进行自动装配---给了就赋值，没给就是undefined,多给了没接住，js中参数跟函数的识别没有关系，只以函数名识别，而且函数名实际上是引用变量，和函数名捆绑的引用变量指的是同一个函数，js在内部是用一个名为arguments的数

function show(a,b){ //这里的a,b不是用来识别函数用的，而且让js帮忙把前两个实参装配到这个两个变量，以便于使用
     alert(a+","+b);
   }
  function demo3(){
    //show(1,2);   //1,2
    //show(1,2,4);  //1,2
    //show(1);     //1,undefined
show();     //undefined

多个同名的函数，一个调用参数的时候
function add(number) {
    alert(number + 20);   
}
function add(number, number1) {
     alert(number + 30);   
}           
 add(10);  
 结果为40，虽然第二个方法是两个参数，但是仍然调用了它。
//交换两个方法的顺序之后，弹框显示30，可以看出不管参数个数如何，是调用同名的后面的方法。

B、js动态函数的定义格式

//形参列表和函数体描述必须都以字符串的形式给出

var 函数名 = new Function(形参列表,函数体描述);

var add= new Function("a","b","var s=0; s=a+b; return s;");//参数列表分开写
var add=new Function("a,b","var s=0; s=a+b; return s;");//参数列表合用一个字符串参
alert(add(3,5));

C、匿名函数

   var add=function(a,b){

      return a+b;

   };