Dasar-Dasar Fungsi dan Metode di Scala

Tertarik mempelajari Scala lebih lanjut? Ikuti kursus Introduction to Scala dari DataCamp.

Scala adalah bahasa pemrograman fungsional yang memiliki fungsi sebagai nilai kelas satu sekaligus metode, dengan sejumlah kesamaan dan perbedaan. Baik fungsi maupun metode adalah blok kode yang dapat digunakan ulang untuk menyimpan kode berulang di satu tempat, sehingga cukup melakukan pemanggilan fungsi untuk menjalankan tugas tertentu. Keduanya juga memudahkan proses debug dan modifikasi kode.

Namun, fungsi adalah objek yang diinisialisasi dalam sebuah variabel, sedangkan metode diawali dengan kata kunci 'def' diikuti nama metode, daftar parameter, tubuh metode, beserta nilai kembalian.

Deklarasi dan Definisi Metode

Berikut adalah sintaks deklarasi dan definisi metode dalam Scala:

def 'method_name' ('parameters':'return_type_parameters') : ('return_type_of_method') = {
    'method_body'
     return 'value'
}

Metode dalam Scala dimulai dengan bagian-bagian berikut:

1. 'def': kata kunci yang digunakan untuk mendeklarasikan metode.
2. 'method_name': nama metode Anda, menggunakan lower camel case.
3. 'parameters': parameter metode, dapat tanpa parameter atau satu parameter saja, dan dipisahkan koma jika lebih dari satu parameter.
4. 'return_type_of_parameters': harus sesuai dengan tipe data 'parameters_list' dan bersifat wajib.
5. 'return_type_of_method': opsional; secara default akan mengembalikan 'Unit', tetapi nilai dapat dikembalikan dengan kata kunci 'return'.
6. Simbol Penugasan ('='): opsional; jika digunakan akan menetapkan nilai kembalian, jika tidak digunakan maka metode tidak mengembalikan apa pun.
7. 'method_body': blok kode di dalam kurung kurawal '{}' yang berisi logika, tugas, atau operasi yang diperlukan.
8. return: kata kunci untuk mengembalikan nilai yang diperlukan sekaligus menghentikan eksekusi, namun jarang digunakan di Scala.

Pemanggilan Metode

Sintaks pemanggilan Metode dalam Scala adalah sebagai berikut:

    method_name(arguments)

Pemanggilan Metode dapat dilakukan langsung dengan 'method_name', yaitu nama metode yang ingin Anda panggil, disertai argumen yang diberikan.

Metode dengan Argumen Bernama

Metode dengan argumen bernama memungkinkan Anda meneruskan argumen ke parameter metode saat pemanggilan, di mana setiap argumen dicocokkan satu per satu dengan parameter metode. Lihat contoh di bawah tentang penerusan argumen beserta deklarasi dan definisi Fungsi, serta pemanggilan metodenya:

object calculateResult {
      def funSub(x:Int, y:Int) : Int =
   {

       var diff:Int = 0
       diff = x - y

       // return value
       return diff
   }
   def main(args: Array[String]) {

      // Function call
      println("Difference of the value is: " + funSub(8,6));
      println("Difference of the value is " + funSub(y=6,x=8));
   }
}

Program di atas menghasilkan keluaran:
Difference of the value is: 2
Difference of the value is: 2

Program di atas memiliki objek 'calculateResult', dan di dalamnya terdapat metode bernama 'funSub' dengan parameter x dan y yang keduanya bertipe 'Int', dan tipe kembalian keseluruhan metode adalah 'Int'. Setelah itu terdapat pernyataan penugasan untuk menetapkan nilai kembalian. Kurung kurawal menandai awal tubuh metode, di mana variabel 'diff' diinisialisasi dengan nilai awal 0. Pemanggilan Metode 'funSub(8,6)' di dalam metode main mencocokkan 8 ke 'x' dan 6 ke 'y', lalu operasi pengurangan dijalankan, nilai 'diff' dikembalikan dan akhirnya dicetak. Demikian pula, 'funSub(x=8,y=6)' mencocokkan 6 ke 'y' dan 8 ke 'x' saat pemanggilan metode—urutan tidak menjadi masalah—operasi serupa dilakukan, nilainya dikembalikan, dan hasilnya dicetak.

Nilai Parameter Bawaan

Anda dapat menentukan nilai bawaan untuk parameter metode dengan menginisialisasi nilai yang sesuai, dan Anda dapat membiarkan pemanggilan metode kosong tanpa meneruskan argumen.

object calculateResult {
      def funSub(x:Int=9, y:Int=6) : Int =
   {

       var diff:Int = 0
       diff = x - y

       // return value
       return diff
   }
   def main(args: Array[String]) {

      // Function call
    print( "The final value is: " + funSub() );

   }
}

Program di atas menghasilkan keluaran:
The final value is: 3

Terlihat bahwa program di atas berisi objek bernama 'calculateResult' dan di dalamnya ada metode bernama 'funSub' dengan parameter x dan y yang keduanya bertipe 'Int', dan tipe kembalian keseluruhan metode adalah 'Int', diikuti pernyataan penugasan untuk menetapkan nilai kembalian. Kurung kurawal menandai awal tubuh metode, di mana variabel 'diff' diinisialisasi dengan nilai awal 0. Pemanggilan Metode dilakukan dari dalam metode main, yaitu 'funSub()' yang menginisialisasi x ke 9 dan y ke 6, lalu operasi dijalankan sehingga nilai 'diff' dikembalikan dan dicetak.

Argumen dengan Panjang Variabel

Argumen dengan panjang variabel adalah argumen yang dapat menerima sejumlah argumen yang bervariasi dan dapat diteruskan oleh pengguna atau klien. Parameter terakhir dalam metode dideklarasikan menggunakan '*' yang perlu dapat diulang.

object variableArgument {
    def main(args: Array[String]) {
       printAll("Scala", "is", "great")
    }

    def printAll(strings: String*) {
        var i : Int = 0;

      for( value <- strings ){
         println(value);
         i = i + 1;
      }
    }
}

Program di atas menghasilkan keluaran:
Scala
is
great

Terlihat program di atas memiliki objek 'variableArgument' dengan metode 'printAll' di mana argumen panjang variabel 'String*' didefinisikan di bagian akhir, dan saat pemanggilan metode, daftar string dapat diteruskan. Daftar string yang diteruskan diiterasi dan ditampilkan sebagai keluaran di dalam fungsi utama.

Fungsi Rekursi

Rekursi adalah teknik dalam pemrograman fungsional di mana masalah diselesaikan dengan berulang kali memecahnya menjadi submasalah yang lebih kecil, yang serupa dengan masalah asal. Submasalah yang lebih kecil diselesaikan, lalu solusinya digabungkan untuk memperoleh solusi bagi masalah awal. Karena itu disebut pendekatan divide-and-conquer atau decrease-and-conquer, yang membuat kode menjadi bersih dan elegan. Saat menulis fungsi rekursif, dua poin berikut perlu diperhatikan dengan ketat:

• Kasus dasar (base case): Mungkin ada lebih dari satu kasus dasar dalam sebuah fungsi yang perlu diidentifikasi; jika tidak, dapat menyebabkan rekursi tak berujung. Harus ada solusi, yakni bentuk keluaran sederhana yang dapat dicapai tanpa rekursi.
• Kasus rekursif: Kasus ketika fungsi rekursif diterapkan, yaitu saat pemanggilan rekursif dilakukan. Inti masalahnya adalah pada setiap pemanggilan rekursif, ukurannya harus berkurang, yaitu masalah dipecah menjadi submasalah yang lebih kecil hingga mencapai kasus dasar. Terakhir, Anda menggabungkan solusinya untuk mendapatkan solusi utama, disebut pendekatan divide-conquer.

Faktorial dari suatu bilangan n adalah n! Dapat diekspresikan secara matematis sebagai berikut:

Anda juga dapat menuliskan (n-1).(n-2)...3.2.1 sebagai (n-1)! Jadi, faktorial suatu bilangan selalu n.(n-1)!

Berikut cara rekursif untuk menyelesaikan masalah tersebut.

object factorialDemo {
   def main(args: Array[String]) {
      for (i <- 1 to 5)
         println( "Factorial of " + i + ": = " + factorial(i) )
   }

   def factorial(n: Int): Int = {  
      if (n <= 1)
         return 1  
      else    
      return n * factorial(n - 1)
   }
}

Program di atas menghasilkan keluaran:
Factorial of 1: = 1
Factorial of 2: = 2
Factorial of 3: = 6
Factorial of 4: = 24
Factorial of 5: = 120

Terlihat di atas terdapat objek bernama 'factorialDemo' dan di dalamnya ada fungsi 'main' yang berisi sebuah loop yang berulang lima kali dan juga memanggil fungsi 'factorial' di mana fungsi rekursif melakukan pemanggilan rekursif, yakni n hingga lima kali. Proses berhenti pada kasus dasar saat n menjadi kurang dari atau sama dengan 1, lalu hasilnya dikembalikan dan dicetak.

Fungsi Anonim

Fungsi Anonim adalah definisi fungsi ringan yang tidak memiliki nama dan dikenal sebagai function literal dalam Scala.

Sintaks beserta contoh untuk Fungsi Anonim adalah sebagai berikut:

• Sintaks pertama dan contohnya untuk fungsi Anonim adalah:

Sintaks:

('first_variable':'data_type', 'second_variable':'data_type') => "certain_expression"

Contoh:

(var1:String:var2:String) => var1 + var2

ATAU

• Sintaks kedua dan contohnya untuk fungsi Anonim adalah:

Sintaks:

 (_:'data_type')operator(_'data_type')

Contoh:

 (_:String)+(_:String)

Sintaks pertama menunjukkan bahwa ekspresi setelah "=>" dievaluasi menjadi suatu nilai tertentu, sedangkan daftar variabel sebelum "=>" digunakan untuk mengevaluasi ekspresi tersebut.

Sintaks kedua di atas bekerja seperti placeholder yang menerima nilai sebagai karakter 'wild card' satu kali, lalu operator dijalankan di antara keduanya.

Berikut contoh fungsi anonim:

 object anonymousDemo  
{
    def main(args: Array[String])  
    {


        var function1 = (var1:Int, var2:Int) => var1 + var2
        var function2 = (_:Int) + (_:Int)

        // function call
        println(function1(5, 5))
        println(function2(7, 3))
    }
}

Initializing Scala interpreter ...



Spark Web UI available at http://DESKTOP-03TH7J0:4040
SparkContext available as 'sc' (version = 2.4.3, master = local[*], app id = local-1566986265958)
SparkSession available as 'spark'




<console>:10: error: unbound placeholder parameter

        var function2 = {_:Int} + {_:Int}

                         ^

<console>:10: error: unbound placeholder parameter

        var function2 = {_:Int} + {_:Int}

                                   ^

Program di atas menghasilkan keluaran:
10
10

Terlihat di atas objek bernama 'anonymousDemo' dengan fungsi 'main' yang berisi dua fungsi anonim. Keduanya berbeda secara sintaks, tetapi menghasilkan hasil yang sama, di mana 'function1' dievaluasi dengan mengambil parameter dari pemanggilan fungsi saat dipanggil—meneruskan nilai 5 dan 5 sehingga hasil yang dicetak adalah 10, sedangkan 'function2' juga dipanggil dengan meneruskan 7 dan 3, di mana ia menerima nilai sekali yang menerima 'Integer' apa pun yang valid. Dalam kasus Anda, lakukan operasi penjumlahan dan cetak hasilnya.

Kesimpulan

Selamat, Anda telah menyelesaikan tutorial ini.

Ada banyak topik lanjutan di Scala seperti higher-order functions, nested function, currying function, dan lainnya.

Referensi:
TOUR OF SCALA BASICS
Scala | Functions – Basics
Scala - Functions
Anonymous Functions in Scala

Lihat kursus Introduction to Scala dari DataCamp.