函数Function怎么用

这篇文章主要介绍了函数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

view plaincopy to clipboardprint?
//定义通用排序函数  
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 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 返回我们调用函数时传递的参数列表

view plaincopy to clipboardprint?
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("
出错啦!错误消息: "+ex.description);                    
   }  
   return result;                        
}  
 
document.write("
调用形式为：f(1,2,3)其结果为:
t"+f(1,2,3));  
document.write("
调用形式为：f(1,2)其结果为:
t"+f(1,2));  
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("
出错啦!错误消息: "+ex.description);    
}
return result;        
}

document.write("
调用形式为：f(1,2,3)其结果为:
t"+f(1,2,3));
document.write("
调用形式为：f(1,2)其结果为:
t"+f(1,2));

函数的参数及调用

view plaincopy to clipboardprint?
<!--  
   /*  
       Function:函数在Javascript中的是一个非常重要的概念，  
       一般函数都是有返回值的，如果函数没有返回值则默认情况下  
       返回的是undefined。  
       return 语句返回函数的值，也可以写成"return ;"什么都不返回  
       定义：function 函数名(参数列表){}              
   */  
     
   function fun(a,b){  
       return a+b;  
   }  
     
   document.write("
函数fun(3)的返回值为："+fun(3));  
   document.write("
函数fun(3,null)的返回值为："+fun(3,null));  
   document.write("
函数fun(3,3,4)的返回值为："+fun(3,3,4));  
   document.write("
函数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("
少传参数的情况：fun3(8)"+fun3(8));  
   document.write("
多传参数的情况：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("
参数不匹配，实参个数为："+arguments.length+  
           "，形参的个数为："+fun4.length);  
       }else  
       {  
           alert("传入的参数与实参个数匹配");  
       }  
   }  
     
   try{  
       document.write("
调用函数形式为：fun4(8)"+fun4(8));  
   }catch(ex){  
       document.write("
调用函数时出错了！"+ex.description);  
   }  
     
   fun4(8,8);  
     
   //接收任意参数的函数（通过arguments参数）  
   function fun5(){  
       document.write("
函数调用的参数为：");  
       for(var i=0;i            document.write(" - " + arguments[i] + " - ");  
       }  
       document.write("
");  
   }  
     
   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("
参数类型出错了，" + ex.description);  
   }      
// --&gt
<!--
/*
 Function:函数在Javascript中的是一个非常重要的概念，
 一般函数都是有返回值的，如果函数没有返回值则默认情况下
 返回的是undefined。
 return 语句返回函数的值，也可以写成"return ;"什么都不返回
 定义：function 函数名(参数列表){}    
*/

function fun(a,b){
 return a+b;
}

document.write("
函数fun(3)的返回值为："+fun(3));
document.write("
函数fun(3,null)的返回值为："+fun(3,null));
document.write("
函数fun(3,3,4)的返回值为："+fun(3,3,4));
document.write("
函数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("
少传参数的情况：fun3(8)"+fun3(8));
document.write("
多传参数的情况：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("
参数不匹配，实参个数为："+arguments.length+
  "，形参的个数为："+fun4.length);
 }else
 {
  alert("传入的参数与实参个数匹配");
 }
}

try{
 document.write("
调用函数形式为：fun4(8)"+fun4(8));
}catch(ex){
 document.write("
调用函数时出错了！"+ex.description);
}

fun4(8,8);

//接收任意参数的函数（通过arguments参数）
function fun5(){
 document.write("
函数调用的参数为：");
 for(var i=0;i   document.write(" - " + arguments[i] + " - ");
 }
 document.write("
");
}

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("
参数类型出错了，" + ex.description);
}
// --&gt

函数Call的用法

view plaincopy to clipboardprint?
function fun(){                
   document.write("
调用者为："+ 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("

");  
function fun2(str){  
   document.write("
调用方法有参数时的call调用形式 fun2.call(obj,args)");  
};  
fun2.call(this);  
 
 
//实例  
var fruit = {name:"苹果",act:"吃的"};  
var book = {name:"电脑书",act:"读的",play:function(){  
   document.write("
"+this.name+" 是用来 "+this.act+" !");  
}};  
book.play();  
book.play.call(fruit);  
book.play.call(Math);  
function fun(){    
document.write("
调用者为："+ 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("

");
function fun2(str){
document.write("
调用方法有参数时的call调用形式 fun2.call(obj,args)");
};
fun2.call(this);

//实例
var fruit = {name:"苹果",act:"吃的"};
var book = {name:"电脑书",act:"读的",play:function(){
document.write("
"+this.name+" 是用来 "+this.act+" !");
}};
book.play();
book.play.call(fruit);
book.play.call(Math);

函数的闭包

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

view plaincopy to clipboardprint?
<!--  
             
   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("

");  
     
   //我们说匿名函数调用产生一个"瞬时"的闭包  
   //因此当调用结束后，私有变量无法访问，并且如果没有外部引用存在  
   //内部对象就会被销毁  
   //而如果返回了函数，或者被全局引用，则"闭包"被保留了下来  
   //闭包中的内容被"有选择"地开放出来  
   (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("
"+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，打印出产生的随机数  
// --&gt
<!--
 
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("

");

//我们说匿名函数调用产生一个"瞬时"的闭包
//因此当调用结束后，私有变量无法访问，并且如果没有外部引用存在
//内部对象就会被销毁
//而如果返回了函数，或者被全局引用，则"闭包"被保留了下来
//闭包中的内容被"有选择"地开放出来
(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("
"+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，打印出产生的随机数
// --&gt

全局函数

未与任何函数关联的函数    
    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 源代码的动态执行。

view plaincopy to clipboardprint?
//对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("
"+str);  
}  
//对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("
"+str);
}

感谢你能够认真阅读完这篇文章，希望小编分享的“函数Function怎么用”这篇文章对大家有帮助，同时也希望大家多多支持亿速云，关注亿速云行业资讯频道，更多相关知识等着你来学习!