05.JS函數

前言：
學習一門編程語言的基本步驟
（01）瞭解背景知識
（02）搭建開發環境
（03）語法規範
（04）常量和變量
（05）數據類型
（06）數據類型轉換
（07）運算符
（08）邏輯結構
（09）函數
9.函數——function
   1.函數
     函數分爲系統函數和自定義函數
     JS提供的函數—isNaN/parseInt/parseFloat/Number/prompt...
     function：功能體，函數（方法），能夠接收若干個數據，返回處理結果。用於封裝反覆執行的代碼。
     1）建立一個普通函數
         function 函數名稱（）{  //名字能夠自定義
         函數體  //要封裝的代碼
         }
         //調用
         函數名稱();

    //function普通函數
    function say(){
      console.log("hello");
      console.log("javaScript");
      console.log("hello is me");
    }
    say ();//調用函數打印上述文字

    //練習：封裝計算1-100之間1-100的和
    function R(){
      for (var i=1,sum=0;i<=100 ;i++ ){
        sum+=i;//for循環運算
      }    
      console.log(sum);//最後是打印sum
    }
    R();//因此調用r以後打印sum，結果爲5050

     2）建立帶有參數的函數 ——function-param
         function 函數名稱（參數列表）{ //參數列表用於接受傳遞的數據
         函數體；
         }
         //調用
         函數名稱（參數列表）//實際傳遞的數據
         參數：建立函數時的參數成爲形參，調用時參數成爲實參，實參會賦值給形參，多個參數之間用逗號隔開。參數能夠有0個或者多個，若是參數未被賦值，值爲undefined。

    //function有參數函數
    //計算任意兩個數字相加的和
    function add(var1,var2){//參數：形參——參數形式
      console.log(var1+var2);
    }
    //調用
    add(2,3);//參數：實參——實際接收的參數

    //練習：建立函數，封裝計算1-任意數字之間全部整數的和，調用屢次
    function getsum(b){
      for (i=1,sum=0; i<=b;i++ ){
        sum+=i;
      }
      console.log(sum);
    }
    getsum(100);
    getsum(1004);
    getsum(10042);

    //練習：建立函數，封裝計算任意兩個年份之間閏年的個數，調用屢次
    function runnian(year,year2){
      for (i=year,count=0;i<=year2 ;i++ ){
        if (i%4===0 && i%100!==0 || i%400===0 ){
        count++;
        console.log(i,count);
        }
      }
    }
    runnian(1980,2000);
    runnian(1880,2100);

     3）建立帶有 返回值得函數——function-return
         function 函數名稱（參數列表）{
         函數體；
         return 值；//返回值，函數執行完返回的結果
         }
         //調用
         函數名稱（參數列表）
         注意事項： 若是函數中沒有return，或是return 中沒有加任何值，返回undefined；執行完return後的代碼不會再執行。
                         return 函數：供外部使用的數據，return後面的數據不會被執行。 

    //function帶有返回值的函數
    function add(n1,n2){
      //返回n1+n2的結果，用於後期保存，能夠理解爲若是n1,n2若是有參數傳進來以後就執行n1+n2，而後保存結果，以便於後續使用
      return n1+n2;
    }
    //把函數的結果保存下來
    var a=add(100,140);
    console.log("總成績爲："+a);

    //練習：建立函數，傳遞任意年份，返回是否爲閏年，若是是返回true，不是返回false；打印該年天數
    function year(a){
      if (a%4===0  && a%100!==0 || a%400===0){
        return true;
    }//else {   能夠省略
      return false;
    }
    function getdays(a){
      if(year(a)){//此處解釋爲若是year(a)爲真就執行如下
        return a+"閏年，366天";
      }//此處省略else  不然
    return a+"不是閏年，365天";
    }
    console.log(getdays(2019));//2019不是閏年，365天

    //練習：計算1-任何數字之間全部整數階乘的和
    //1!+2!+3!+4!+5!
    //步驟一：計算任意數字的階乘n-1之間全部整數的乘積
    function R(a){
      for (var b=1,num=1;b<=a ; b++){
      num*=b;
      }
      return num;  
    }
    //R(4);
    //步驟2：計算1-n之間全部整數的和
    function getSum(a){
      for(var i=1,sum=0;i<=a;i++){
        sum+=R(i);
      }
      return sum;
    }
    console.log(getSum(5));//153

         總結：對比break和return的用法
                  break用於結束switch語句，還能夠用於提早結束循環。
                  return用於在函數中的返回值，也能夠結束函數後續代碼執行。

   2.做用域——scope
      變量或者函數的可訪問範圍，分兩種
      全局做用域：在全局使用var聲明的變量，能夠在任意範圍訪問到，
      函數做用域：在函數中使用var聲明的變量，只能在函數內部訪問到。

    //做用域——scope
    //全局做用域下的變量
    var a=1;//全局變量，在此處除function fn(){}函數之外就是全局。
    //函數做用域下使用var聲明的變量
    function fn(){
      var b=2;//局部變量
      console.log(a);//全局函數a能夠在任意範圍訪問
      console.log(b);//2,局部變量能夠在函數做用域內訪問
    }
    console.log(a);//1
    fn();//1 調用函數，執行函數體代碼。
    console.log(b);//報錯，b is not defined

       注意事項：函數中不使用var聲明的變量，默認是全局變量，能夠在函數的外部訪問，不推薦這樣寫。

    //注意事項
    function fn2(){
      c=3;//函數中不使用var聲明的變量默認是全局變量，不建議這麼寫，形成全局污染
    }
    console.log(c);//即便c是包裹在函數內部，可是沒有聲明的變量默認是全局變量，因此在函數外部是能夠訪問的
    fn2();//而調用fn2()的時候內部是什麼都沒有寫的，至關於沒有任何函數體代碼

      1）變量提高
          JS程序執行前，會將使用var關鍵字聲明的變量提高到所在做用域的最前邊，可是賦值仍是在原來的位置。

    //變量提高——全局做用域
    var a=1;//聲明變量並賦值
    console.log(a);
    /***************** 實際在程序中應爲 ****************/
    //變量提高——全局做用域
    var a;//聲明提早
    a=1;//var a=1中，聲明提早，可是賦值留在原地
    console.log(a);

    //變量提高——函數做用域
    function fn(){
      console.log(b);
      var b=2;
    }
    fn();
    /***************** 實際在程序中應爲 ****************/
    //變量提高——函數做用域
    function fn(){
      var b;//變量提高到所在函數做用域前面
      console.log(b);//此時只聲明，沒有賦值，因此打印結果是undefined
      b=2;//賦值留在原地，
    }
    fn();//因此調用後結果是undefined

       2）函數的做用域
          函數的可訪問範圍，在全局做用域下建立的函數能夠在任意位置訪問；在函數做用域下建立的函數只能在函數內部訪問。

    //函數做用域
    var n=5,m=7;
    function fn2(){
    //var n;提高到所在做用域最前面，至關於此處有一個聲明變量，可是未賦值，只能在內部訪問這個n
    console.log(n);//此時打印的n值爲undefined，由於在函數做用域中var聲明提早到做用域最前面，
    var n=8;//此處的至關於正常爲 n=8 給前面聲明的變量賦值，
    console.log(n);//此時打印的n值爲8
    console.log(m);//函數做用域內沒有m，調用全局的m
    }
    console.log(n);//此處打印的n值是全局做用域下的n，值爲5
    fn2();//此處調用fn2

      3）函數提高
          和變量提高同樣，JS程序執行前，會把function關鍵字建立的函數提高到坐在做用域的最前邊，在調用的時候纔會執行函數提高的代碼。

    //函數提高
    fn();//先調用，
    function fn(){
      console.log(1);    
    }
    /***************** 實際在程序中應爲 ****************/
    function fn(){//提高到當前做用域最前端，先建立
      console.log(1);    
    }
    fn();//調用

  3.匿名函數

     沒有名稱的函數 function(){ }

      1）建立函數

          function fn1(){ }——函數聲明

    //建立函數——函數聲明
    function fn1(){  }
    var a;

          var fn2=function(參數){ 函數體 }——函數表達式，變量名就是函數名稱

    //建立函數——函數表達式
    //變量名稱就是函數名稱
    var fn2=function(a,b){
      console.log(a+b);
    }
    fn2(1,3);

    //練習：使用函數表達式建立函數，計算任意兩個數字之間全部整數的和
    //只能先建立在調用，由於不存在提高，
    var add=function(a,b){
      for (i=1,sum=0;i<=b ;i++ ){
      sum+=i;
      }
      return sum;
    }
    console.log(add(3,10));

          總結：對比函數聲明與函數表達式的區別

                   函數聲明，建立函數存在提高，能夠在任意位置建立，後調用。

                   函數表達式，使用變量建立，只存在變量的提高，不存在函數提高，只能先建立，再調用。

      2）匿名函數的自調用
          目的：建立函數做用域包裹起來，防止污染全局。
          (function（形參列表）{
          //函數體中的變量不能被外部訪問
          }）（實參列表）；

    //匿名函數
    //避免全局污染，把變量放到函數做用域下
    (function(){//匿名函數能夠本身調用本身函數內的數據,匿名函數須要用（）（）
      var num=2;
      console.log(num);
    })();

    (function(a,b){//匿名函數能夠本身調用本身函數內的數據,匿名函數須要用（）（）
      var num=4;
      console.log(a+b);
    })(3,5);

      3）回調函數——callback
           把匿名函數以實參的形式傳遞，意味着形參就是傳遞的匿名函數的名稱
           function fn（a）{
           //調用fn的時候，匿名函數賦值給參數a，a就是函數名稱
           a() //執行傳遞的匿名函數體中的代碼。
           }

    //回調函數
    function fn(a){
    //實參賦值給形參
    //把匿名函數賦值給a，a就是函數名稱
    //a=function(){  }
    a();
    } 
    fn(function(){
      console.log(1);
      console.log(2);
    }); //調用函數a，執行傳遞的函數體中的代碼

    //練習：建立函數，傳遞兩個參數，實參使用匿名函數的形式傳遞，在匿名函數的函數體中添加若干行代碼；在函數中執行匿名函數中的代碼。
    function fun(a,b){
    a();
    b();
    };
    fun(function(){
      console.log(3);
    },function(){
        console.log(4);
    });

   4.全局函數——global
      parseInt()/parseFloat()/isNaN()/
      encodeURI() 對網址中的漢字進行編碼
      decodeURI() 對已經編碼網址進行解碼
      isFinite()      判斷一個值是否爲有限值，是—>true 不是-false
      eval()          能夠執行字符串中的表達式

    //全局函數
    //對一個網址中的中文編碼
    var str='http://www.jd.com/search?kw=電腦';
    var str2=encodeURI(str);
    console.log(str2);//http://www.jd.com/search?kw=%E7%94%B5%E8%84%91
    //對已經編碼的網址進行解碼
    var str3=decodeURI(str2);
    console.log(str3);//http://www.jd.com/search?kw=電腦

    //isFinite判斷一個值是否爲有限值。是—>true 不是-false
    //2/0-> Infinity(無窮) 0/2->0
    console.log(0/2,2/0);//0 Infinity
    console.log(isFinite(1/3));//true

    //eval能夠執行字符串中的表達式
    console.log("1+2");//1+2
    console.log(eval("1+2"));//3