函數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怎么用”這篇文章對大家有幫助，同時也希望大家多多支持億速云，關注億速云行業資訊頻道，更多相關知識等著你來學習!