Scala教程(十)函式與閉包詳解

1 函式

1.1 本地函式

函數語言程式設計風格的一個重要設計原則：程式應該被解構成若干小的函式，每個完成一個定義良好的任務。單個函式經常很小。這種風格的好處是它給了程式設計師許多可以靈活組裝成更復雜事物的建造模組。每個小塊應該充分簡化到足以單獨理解。

   Scala中提供了可以把函式定義在另一個函式中。就好象本地變數那樣，這種本地函式僅在包含它的程式碼塊中可見。

  def processData(fileName:String,width:Int){
      // 本地函式
      def processLine(line:String){
          // 長度大數指定的長度，進行列印
          if(line.length() > width){
              println(fileName+":"+line)
          }
      }
      
      // 讀取檔案
      val source = Source.fromFile("E:\\input.txt");
      for(line <- source.getLines()){
          processLine(line);
      }
  }
 

processLine的定義放在processFile的定義裡。作為本地函式，processLine的範圍侷限於processFile之內，外部無法訪問。

1.2 函式值

函式文字被編譯進一個類，類在執行期例項化的時候是一個函式值：function value。因此函式文字和值的區別在於函式文字存在於原始碼，而函式值存在於執行期物件。

    // =>指明這個函式把左邊的東西（任何整數x）轉變成右邊的東西（x + 1）。所以，這是一個把任何整數x對映為x + 1的函式。
    var increase = (x:Int) => x+1;

    // 執行結果：11
    println(increase(10))
    
    // 因為increase是var，你可以在之後重新賦給它不同的函式值。
    increase = (x: Int) => x + 9999
    
    // 執行結果：10009
    println(increase(10));    
    
    // 所有的集合類都能用到foreach方法。
    val someNumbers = List(-11, -10, -5, 0, 5, 10)
    someNumbers.foreach((x: Int) => println(x))
 

    輸出結果：

         -11

         -10

         -5

         0

         5

         10

    // filter 方法選擇集合型別裡可以通過使用者提供的測試的元素。測試是通過函式的使用來提供的。例如，函式(x: Int) => x > 0可以被用作過濾。
    someNumbers.filter((x: Int) => x > 0).foreach { (x:Int) => println(x) }

    輸出結果：

        5

        10

    // 下劃線當做一個或更多引數的佔位符，只要每個引數在函式文字內僅出現一次
    someNumbers.filter(_ > 0).foreach { (x:Int) => println(x) }
 

    輸出結果：

        5

        10

    /*
     * _ + _將擴充套件成帶兩個引數的函式文字。
     * 這也是僅當每個引數在函式文字中最多出現一次的情況下你才能使用這種短格式的原因。
     * 多個下劃線指代多個引數，而不是單個引數的重複使用。
     * 第一個下劃線代表第一個引數，第二個下劃線代表第二個，第三個……，如此類推。
     */
    val f = (_: Int) + (_: Int)
    println(f(5, 10))

    輸出結果：15

1.3 偏應用函式

以這種方式使用下劃線時，你就正在寫一個偏應用函式：partially appliedfunction。

        val data = List(1,2,3,4,5,6);
        // for簡寫遍歷List
        data.foreach(println)
        data.foreach(println _)
        data.foreach(x=>println(x))

1.4 部分應用函式

比如定義了一個函式： def sum(a:Int,b:Int,c:Int) = a + b +c,當呼叫sum的時候，如果不提供所有的引數或某些引數還未知時，比如sum _ ,sum(1,_:Int,3), 這樣就生成了所謂的部分應用函式。

部分應用函式只是邏輯上的一個表達，scala編譯器會用Function1， Function2這些類來表示它。   

        // 定義了一個函式： 
        def sum(a:Int,b:Int,c:Int) = a + b +c
        println(sum(1,2,3));
        
        /*
         *  部分應用函式（Partial Applied Function)是缺少部分引數的函式，是一個邏輯上概念偏函式是隻對函式定義域的一個子集進行定義的函式。
         * 呼叫sum的時候，如果不提供所有的引數或某些引數還未知時，比如sum _ , sum(1,_:Int,3), 這樣就生成了所謂的部分應用函式。
         * 部分應用函式只是邏輯上的一個表達，scala編譯器會用Function1， Function2這些類來表示它.
         */
        val fp_a = sum _;
        println(( sum _).apply(1,2,3));
        val fp_b = sum(1,_:Int,3)
        println(fp_b(2))
        println(fp_b(10))

1.5 高階函式例項

高階函式：函式當作引數進行傳遞。

        // 生成1到9集合，將其中的每個項都變成*，再次進行列印
        (1.to(9)).map("*" * _).foreach(println);

輸出結果：

      *

      **

      ***

      ****

      *****

      ******

      *******

      ********

      *********

        // 生成1到9集合，對2取產為0，進行列印輸出
        (1.to(9)).filter(_ % 2 == 0).foreach(println);

輸出結果：

      2

      4

      6

      8

        // 從右向左連乘 格式  (…((1 * 2) * 3) * … * 9)
        println((1.to(9)).reduceLeft(_ * _))

輸出結果：362880

     // 將內容進拆分 拆分後的單詞進行拆 
     "Spark is the most exciting thing happening in big data today"
      .split(" ").sortWith(_.length < _.length)
      .foreach(println);<span lang="EN-US" style="font-family:Consolas;color:black;font-size:12.0pt;">   </span>

輸出結果：

            is

            in

            the

            big

            most

            data

            Spark

            thing

            today

            exciting

            happening

        // 呼叫Java的方法：向上取整計算，它返回的是大於或等於函式引數，並且與之最接近的整數。
        def ceil (x:Double) :Double = java.lang.Math.ceil(x);
        val fun = ceil _;
        val num  =3.14;
        println(fun(num))

        // array陣列進行迴圈呼叫函式
        Array(3.14,1.42,2.0).map(fun).foreach(println);

輸出結果：  4.0

             2.0

             2.0   

        // array陣列元素 * 3
        val triple = (x:Double) => 3 * x
        Array(3.14,1.42,2.0).map{ (x : Double) => 3 * x}.foreach(println);
        Array(3.14,1.42,2.0).map(triple).foreach(println);

輸出結果：9.42

            4.26

            6.0

        /*
         *  (引數型別) => 結果型別
         *  由於high_order_functions是一個接受函式引數的函式，因此它被稱做高階函式（higher-order function）。
         */
        def high_order_functions(f:(Double) => Double) =f(0.25);
        println(high_order_functions(ceil _))

輸出結果：1.0

       /*
        *  閉包寫法
        *  mulBy函式有一個型別為Double的引數，返回一個型別為 (Double) => Double 的函式。因此，它的型別為：(Double) => ((Double) => Double)
        *  mulBy的威力在於，它可以產出能夠乘以任何數額的函式：
        */
        def mulBy(factor:Double) = (x:Double) => factor* x
        val quintuple = mulBy(5)
        println(quintuple(20))

        // 引數（型別）推斷
        // Scala會盡可能幫助你推斷出型別資訊。舉例來說，你不需要將程式碼寫成：
        println(high_order_functions((x:Double) => 3 * x))
        
        /*
         * 由於high_order_functions方法知道你會傳入一個型別為 
         * (Double) => Double 的函式，你可以簡單地寫成：
         */
        high_order_functions((x) => 3 * x)
        
        // 作為額外獎勵，對於只有一個引數的函式，你可以略去引數外圍的()：
        high_order_functions(x => 3 * x)
        
        // 如果引數在=>右側只出現一次，你可以用_替換掉它：
        high_order_functions(3 * _)

輸出結果：0.75

        // 引數型別
        val fun2 = 3 * (_:Double)
        val fun3:(Double) => Double = 3 *

2 閉包

2.1 定義閉包

   add函式首次呼叫引數值為：1，該變數在(x:Int) =>  x +more函式的函式體內被引用，該值賦值a。然後引數變數more從執行時的棧上被彈出來。

接下來add函式再次被呼叫，這次引數值設定為了10，該變數在(x:Int) =>  x +more再次被引用，打印出計算結果的資訊。

      def add(more:Int) = (x:Int) =>  x +more       
      val a = add(1);
      println(a(10));
      
      val b = add(1000);
      println(b(10));

                                                                                                                                                                                      ——厚積薄發(yuanxw)