04 函数Function

 函数Function

 1、概述:函数是完成特定任务的可重复调用的代码段，是JavaScript组织代码的单位 。
 2、功能:将代码组织为可复用的单位，可以完成特定的任务并返回数据
 3、函数定义：
  3.1、JavaScript的函数属于Function对象，因此可以使用Function对象的构造函数来创建一个函数 。
  3.2、可以使用function关键字以普通的形式来定义一个函数
    如：
    var say = Function([参数列表]){语句；[return 表达式]}   //函数变量
    function 函数名([参数列表]){语句；[return 表达式]}    //普通函数
 
 4、函数指针调用方式
  回调 ：其机制是通过指针来调用函数 。
  一般函数的调用方式是常见而且普通的，但JavaScript中函数调用的形式比较多，非常灵活。
  有一种重要的、在其它语言中也经常使用的调用形式叫做回调 。回调函数按调用者的照约定
  实现函数的功能，由调用者调用

 

 函数返回类型
 一般情况下，函数返回的非对象数据都使用值返回方式
 引用类型返回的是数据的地址，而不是数据本身 。
 引用传递的优点是速度快，但系统会为维护数据而付出额外的开销。通常返回复合类型数据时使用引用传递方式
 function getNameList(){
  var list = new Array("张三","李四","王五");
  return list ;  //返回引用
 }
 var nameList = getNameList() ;
 nameList = null ;  //删除引用

 返回函数 :函数可以返回一个函数指针
 外部代码可以通过指针调用其引用的函数对象，调用方式和一般函数完全一样。
 一般情况下私有函数不能被外界直接调用，因此可以将一个私有函数的地址作为结果返回给外界使用

 function getSum(){
  function sum(a,b){
   return a+b ;
  }
  return sum ;
 }
 var sumOfTwo = getSum() ;
 var total = sumOfTwo(1,2) ;

 函数的作用域
 公有函数：是指定义在全局作用域中，每一个代码都可以调用的函数 。
 私有函数 ：是指处于局部作用域中的函数 。当函数嵌套定义时，
 子级函数就是父级函数的私有函数。外界不能调用私有函数，私有函数
 只能被拥有该函数的函数代码调用 。

 function a(){
  alert("a");
  function b(){
   alert("b");
   function c(){
    alert("c");
   }
  }
  b(); //可以
  c(); //不可以
 }
 a();  //调用a

 

//定义通用排序函数 function sortNumber(obj,func){ //参数验证，如果不是指定参数类型则抛出异常 if(!(obj instanceof Array)||!(func instanceof Function)){ var e = new Error(); //生成错误信息 e.number = 100000 ; //定义错误号 e.message = "参数无效" ;//错误描述 throw e ; //抛出异常 }else{ for(n in obj){ //开始据排序 for(m in obj){ if(func(obj[n],obj[m])){ //使用回调函数排序，规则由用户设定 var temp = obj[n] ; //创建临时变量 obj[n] = obj[m] ; //交换数据 obj[m] = temp ; } } } } return obj ; //返回排序后的数组 } //回调函数，用户定义的排序规则 function greatThan(arg1,arg2){ return arg1>arg2 ; //规则：从大到小 } try{ var numAry = new Array(5,8,6,32,1,45,7,25); //生成一数组 pf("排序前："+numAry); sortNumber(numAry,greatThan); //调用排序函数 pf("排序后："+numAry); }catch(e){ //捕捉异常 alert(e.number+" : "+e.message); //异常处理 }

 

函数的长度属性

Function.length : 是一个只读的属性，它返回函数定义的参数个数
    arguments 返回我们调用函数时传递的参数列表

 

function check(args) { var actual = args.length; // 实际参数个数 var expected = args.callee.length; // 期望参数个数 if (actual != expected) { //当实参与形参个数不匹配时抛出异常 throw new Error("错误的参数个数；形参数为: " + expected + "， 实际传参数为： " + actual); } } function f(x, y, z) { var result = 0 ; try{ //检查实参与形参是否匹配 check(arguments); result = x + y + z; }catch(ex){ document.write("<br/>出错啦!错误消息: "+ex.description); } return result; } document.write("<br/>调用形式为：f(1,2,3)其结果为:<br/>/t"+f(1,2,3)); document.write("<br/>调用形式为：f(1,2)其结果为:<br/>/t"+f(1,2));

 

函数的参数及调用

 

<mce:script type="text/javascript"><!-- /* Function:函数在Javascript中的是一个非常重要的概念， 一般函数都是有返回值的，如果函数没有返回值则默认情况下 返回的是undefined。 return 语句返回函数的值，也可以写成"return ;"什么都不返回 定义：function 函数名(参数列表){} */ function fun(a,b){ return a+b; } document.write("<br/>函数fun(3)的返回值为："+fun(3)); document.write("<br/>函数fun(3,null)的返回值为："+fun(3,null)); document.write("<br/>函数fun(3,3,4)的返回值为："+fun(3,3,4)); document.write("<br/>函数fun(3,undefined)的返回值为："+fun(3,undefined)); /* 没显式给出return语句，则函数返回undefined */ function fun2(){} if(!fun2()){ alert("函数返回的是" + fun2()); } /* 函数的缺省参数 */ function fun3(a,b){ //给定参数a的缺省值为10 a = a || 10; //给定参数b的缺省值为20 if(!b){ b = 20 ; } return a + b ; } /* 在Javascript中调用一个带参函数时传入的实参个数与定义的形参个数可以不 如果传少，后面的自动为undefined 如果传多，后面多余的自动截断 */ document.write("<br/>少传参数的情况：fun3(8)"+fun3(8)); document.write("<br/>多传参数的情况：fun3(8,8,8)"+fun3(8,8,8)); /* 检测函数的参数个数 length，arguments 函数length的属性返回的是函数的形参个数 函数arguments.length返回的是函数的实参个数 */ function fun4(a,b){ if(fun4.length!=arguments.length){ throw new Error("<br/>参数不匹配，实参个数为："+arguments.length+ "，形参的个数为："+fun4.length); }else { alert("传入的参数与实参个数匹配"); } } try{ document.write("<br/>调用函数形式为：fun4(8)"+fun4(8)); }catch(ex){ document.write("<br/>调用函数时出错了！"+ex.description); } fun4(8,8); //接收任意参数的函数（通过arguments参数） function fun5(){ document.write("<br/> 函数调用的参数为："); for(var i=0;i<arguments.length;i++){ document.write(" - " + arguments[i] + " - "); } document.write("<br/>"); } fun5(1,2,3); /* 抛参数类型异常 */ function fun6(a,b){ if((typeof a) != "number" || (typeof b) != "number"){ throw new Error("参数的类型必须为数字"); } return a + b ; } try{ fun6("aa"); }catch(ex){ document.write("<br/>参数类型出错了，" + ex.description); } // --></mce:script>

 

函数Call的用法

 

function fun(){ document.write("<br/>调用者为："+ this.toString() +" , 调用函数为fun()" ); } //fun()的调用形式与fun.call(this)的调用形式一样 fun(); fun.call(this); //用JS中的固定对象Math去执行fun()方法 fun.call(Math); //自定义一个对象 var p = { name : "自定义对象p", //重写Object对象的toString()方法 toString : function(){ return this.name; } }; //用自定义的对象去执行fun()方法 fun.call(p); //调用方法有参数时的call调用形式 document.write("<br/><br/>"); function fun2(str){ document.write("<br>调用方法有参数时的call调用形式 fun2.call(obj,args)"); }; fun2.call(this); //实例 var fruit = {name:"苹果",act:"吃的"}; var book = {name:"电脑书",act:"读的",play:function(){ document.write("<br/>"+this.name+" 是用来 "+this.act+" !"); }}; book.play(); book.play.call(fruit); book.play.call(Math);

 

函数的闭包

 

闭包 : closure 微软在设计Ajax时就使用这种技术来模拟类
    很显然，这种模型的类描述特别象C#语言的描述形式，在一个构造函数里依次定义了私有成员、公共属性和可用的方法，显得非常
    优雅嘛。特别是“闭包”机制可以模拟对私有成员的保护机制，做得非常漂亮。
    所谓的“闭包”，就是在构造函数体内定义另外的函数作为目标对象的方法函数，而这个对象的方法函数反过来引用外层外层函数体中
    的临时变量。这使得只要目标对象在生存期内始终能保持其方法，就能间接保持原构造函数体当时用到的临时变量值。尽管最开始的构
    造函数调用已经结束，临时变量的名称也都消失了，但在目标对象的方法内却始终能引用到该变量的值，而且该值只能通这种方法来访
    问。即使再次调用相同的构造函数，但只会生成新对象和方法，新的临时变量只是对应新的值，和上次那次调用的是各自独立的。的确
    很巧妙！但是前面我们说过，给每一个对象设置一份方法是一种很大的浪费。还有，“闭包”这种间接保持变量值的机制，往往会给JavaSript
    的垃圾回收器制造难题。特别是遇到对象间复杂的循环引用时，垃圾回收的判断逻辑非常复杂。无独有偶，IE 浏览器早期版本确实存在
    JavaSript 垃圾回收方面的内存泄漏问题。再加上“闭包”模型在性能测试方面的表现不佳，微软最终放弃了“闭包”模型，而改用“原型”
    模型。正所谓“有得必有失”嘛。
    普通函数在调用完后，如果没有外部的引用就会被销毁
    使用闭包结构的函数，则使闭包中的内容有选择的保留下来了 

 

<mce:script type="text/javascript"><!-- function fun2(){ var x = 5 ; return function(){ return x++ ; } } pf(fun2()()); //这个代码每执行一次输出不同的x的值 //使用闭包计算阶乘 function fun(x){ return x > 1 ? x * arguments.callee(x-1) : 1 ; } pf("fun(1) : " + fun(1)); pf("fun(2) : " + fun(2)); pf("fun(3) : " + fun(3)); pf("<br/><br/>"); //我们说匿名函数调用产生一个"瞬时"的闭包 //因此当调用结束后，私有变量无法访问，并且如果没有外部引用存在 //内部对象就会被销毁 //而如果返回了函数，或者被全局引用，则"闭包"被保留了下来 //闭包中的内容被"有选择"地开放出来 (function(){ //封闭的私有域 var innerX = 10 ; var innerY = 20 ; //开放的公共域 outerObj = {x:innerX,y:innerY}; })(); try{ pf(innerX); //内部数据无法访问 }catch(ex){ pf("内部数据无法访问" + ex.description); } pf(outerObj.x); //通过外部接口访问 function pf(str){ document.write("<br/>"+str); } //闭包改变外部环境 //定义一个计数器生成函数，生成某种类型的计数器 function counter(iden, addi) { //闭包"外部"，函数counter"内部"的参数iden的值在闭包被调用的时候会被改变 return function(){ //改变iden的值 iden = iden+addi; return iden; } } //产程一个从0开始计数，每次计数值加1的计数器 var c1 = counter(0, 1); //产生一个从10开始计数，每次计数值减1的计数器 var c2 = counter(10, -1); for(var i = 0; i < 10; i++){ //循环计数 c1(); } for(var i = 0; i < 10; i++){ //循环计数 c2(); } //闭包和面向对象 //定义一个Foo类型 function Foo(a) { function _pC() //私有的函数 { return a; } //公有的函数，通过它产生的闭包可以访问对象内部的私有方法_pC() this.bar = function(){ dwn("foo" + _pC() + "!"); } } var obj = new Foo("bar"); obj.bar(); //显示Foo bar! //闭包的其它形式 //测试函数，异步计数 function test() { for (var i = 0; i < 5; i++) { //如果没有这个闭包，不能正确得到0,1,2,3,4的结果 //因为setTimeout是在循环结束后才被"异步"调用的 (function(j){ setTimeout(function(){alert(j)}, 100); })(i); } } test(); //私有域 var a,b; (function(){ //(function(){……})();的写法利用闭包构成了一个私有域 //它将私有属性a、b同外界隔离开来 //这种用法在高级的JavaScript程序设计中会经常见到 //查看闭包内的a、b的值 showAB = function() { dwn(a); dwn(b); } var a = 10; var b = 20; })(); a = -10; b = -20; //外部改写的a、b dwn(a); dwn(b); showAB(); //不会破坏showAB()得到的内部的a、b的值 //函数的执行域 //产生随机数的函数 function RandomAlert() { var x = Math.random() return function() { alert(x); } } var a = RandomAlert(); //闭包的执行域随函数调用而创建 var b = RandomAlert(); a(); //调用a，打印出产生的随机数 b(); //调用b，打印出产生的随机数 // --></mce:script>

 

全局函数

 

未与任何函数关联的函数    
     decodeURI(URIstring):返回一个已编码的统一资源标识符 (URI) 的非编码形式。 必要的 URIstring 参数代表一个已编码 URI 的值。    
     encodeURI(URIString):将文本字符串编码为一个有效的统一资源标识符 (URI)。encodeURI 方法不会对下列字符进行编码：":"、"/"、";" 和 "?"。    
     isNaN(numValue):数值判断函数 ,如果值是 NaN， 那么 isNaN 函数返回 true ，否则返回 false 。     *
     parseInt(numString, [radix]):将不同进制的数值转换成十进制，底数radix可选。    
     parseFloat(numString):返回由字符串转换得到的浮点数。    
     eval(codeString):检查 JScript 代码并执行.eval 函数允许 JScript 源代码的动态执行。

 

//对url地址进行编码 var url1 = "http://www.csdn.net/ppjava2009/note.aspx?name='函数原形'"; pf("encodeURI编码前为："+url1+" ， 编码后为："+encodeURI(url1)); pf("decodeURI解码前为："+encodeURI(url1)+" ， 编码后为："+decodeURI(encodeURI(url1))); //判断非数值isNaN，如果值是NaN则返回true，否则返回false var s1 = "123abc"; var s2 = "123"; var s3 = 30; var s4 = new Number("8"); pf(isNaN(s1)); //打印true pf(isNaN(s2)); //打印false pf(isNaN(s3)); //打印false pf(isNaN(s4)); //打印false //数值转化 parseInt(str)和parseFloat(str) var n1 = "123abc5"; var n2 = "abc"; var n3 = "123.5d4"; pf(parseInt(n1)); //打印123，数值转换时遇到字母、小数点以及其它字符就停止 pf(parseInt(n2)); //打印NaN 转换没有报异常 pf(parseInt(n3)); //打印123 var n4 = "123.5d4"; var n5 = "0.884"; pf(parseFloat(n4)); //打印123.5 pf(parseFloat(n5)); //打印0.884 //eval编译器 var str = "alert('hello eval')"; eval(str); //弹出"hello eval" function pf(str){ document.write("<br/>"+str); }