Scala Function (Part 1)

Scala Function được ví như trái tim của ngôn ngữ lập trình Scala, vì thế ngôn ngữ lập trình Scala được biết đến như là một Functional programming language. Việc nắm vững các kiến thức và ứng dụng function một cách linh động trong lập trình Scala sẽ đem đến một vũ khí lợi hại cho bất kì lập trình viên Scala nào. Bài viết này sẽ giới thiệu một vài cách thức ban đầu để xây dựng, chinh phục và dần chiếm hữu loại vũ khí này.

1. Function Declarations

Sử dụng từ khóa "def" để bắt đầu khai báo 1 function, ở đây ta có một funtion tên là max. hàm max chứa 2 tham số x và y, cả 2 đều có kiểu Int, ": Int" là kiểu trả về của hàm max, trong trường hợp không trả về gì cho hàm thì ta có kiểu ": Unit" để sử dụng, thằng này tương tự như kiểu "void" trong Java:

_Ví dụ: _

def huongXinhGai(vong1: Float, vong2: Float, vong3: Float): Unit ={
//do something
}

2. Functions with Named Arguments

Thông thường khi một function được gọi, các arguments trong hàm gọi sẽ matched theo đúng thứ tự với các parameter của hàm được gọi. Tuy nhiên trong Scala với Named Arguments, nó cho phép chúng ta truyền arguments cho một hàm mà không cần theo đúng thứ tự, cách thức khá dễ quẩy đó là: với mỗi argument ta biểu diễn bằng tên của 1 parameter trong function được gọi và kèm theo dầu "=" cùng value cần truyền.

Ví dụ:

object FunctionScala {
    def main(args: Array[String]) {
      testFuntion(b = "đúng", a = "xinh gái");
   }

    def testFuntion( a: String, b: String ) = {
      println("Hương : " + a );
      println("Công nhận : " + b );
   }
}

Trong main hàm tesFuntion được gọi đang truyền vào 2 argument với thứ tự truyền vào khác so với thứ tự các parameter của nó khi khai báo theo cách thức Named Arguments, điều này là được phép trong Scala, khi run chương trình trên nó sẽ biến hình ra kết quả như dưới đây:

Hương : xinh gái
Công nhận : đúng

3. Function with Variable Arguments

Variable Arguments cho phép bạn quyết định số lượng list argument truyền vào, tức là bạn có thể thoải mái thích truyền bao nhiêu argument vào thằng hàm mình gọi cũng được, nó chỉ có nhiệm vụ vâng lời và làm nhiệm vụ, không có giới hạn và không thể tức nước vỡ bờ được trừ khi có bên thứ 3 can thiệp vào (bên thứ 3 mình chưa đề cập đến ở bài viết này).

Ví dụ:

object FunctionScala {
    def main(args: Array[String]) {
      testFunction("Hello", "Framgia", "I", "Love", "You", null, "");
   }

    def testFunction( args:String* ) = {
      var i : Int = 0;

      for( arg <- args ){
         println("Output[" + i + "] = " + arg );
         i = i + 1;
      }
   }
}

Ví dụ trên "args" được khai báo kiểu "String*" thực tế nó có thể hiểu tương đương với kiểu Array[String] hàm testFuntion được gọi trong main truyền vào một list argument kiểu String, ta có thể truyền thêm hoặc bỏ đi các argument tùy ý, nó chấp nhận cả giá trị null được truyền vào.

Output của chương trình trên như sau:

Output[0] = Hello
Output[1] = Framgia
Output[2] = I
Output[3] = Love
Output[4] = You
Output[5] = null
Output[6] =

4. Nested Functions

Scala cho phép khai báo function lồng bên trong một function khác và các function được khai báo bên trong function khác được gọi là local function (hàm địa phương) và chức năng này được gọi là Nested Functions in Scala, để cho nhanh và dễ hiểu chúng ta nhìn luôn vào ví dụ sau:

object FunctionScala {
  def main(args: Array[String]) {
    println(factorial(0))
    println(factorial(1))
    println(factorial(2))
    println(factorial(3))
  }

  def factorial(i: Int): Int = {
    def fact(i: Int, accumulator: Int): Int = {
      if (i <= 1)
        accumulator
      else
        fact(i - 1, i * accumulator)
    }
    fact(i, 1)
  }
}

Output của chương trình trên:

1
1
2
6

Part 1 mang tính chất giới thiệu sơ bộ là chính, ở bài viết tiếp theo mình sẽ lại tiếp tục giới thiệu sơ bộ thêm vài điểm hay ho hơn nữa về function trong scala mà ở part 1 chưa được đề cập và sẽ không còn sơ bộ nữa mà đi sâu hơn về các vấn đề đã được đề cập ở những bài sau nữa.