Cara paling mudah untuk belajar pemrograman adalah dengan menulis kode. Tulisan ini akan mengenalkan dasar-dasar Scala, dengan tujuan membantu pembaca untuk dapat menuliskan kode Scala sederhana pada akhir tulisan. Jika belum memiliki lingkungan pengembangan Scala, baca dahulu post sebelumnya untuk pengenalan dan instalasi lingkungan pengembangannya.

Sangat disarankan untuk mencoba menulis dan menjalankan kode-kode yang dijelaskan pada tulisan ini, untuk mendapatkan pengertian penuh. Jika anda adalah programmer berpengalaman, beberapa bagian akan terasa terlalu mendasar (karena konsep yang sama dengan bahasa pemrograman pada umumnya), dan akan ada catatan untuk melewatkan bagian tersebut.

Terakhir, jika tertarik untuk melihat keseluruhan kode terlebih dahulu, kode-kode yang ada pada tulisan ini dapat diakses pada repository Github blog ini.

Interpreter Scala

Cara paling mudah untuk segera menuliskan scala ialah dengan memanggil interpreter Scala melalui terminal atau command-prompt dari sistem operasi anda. Interpreter Scala adalah sebuah program untuk menulis dan menjalankan program Scala secara interaktif (istilah kerennya, REPL). Melalui interpreter, anda dapat memasukkan kode dan langsung melihat hasil eksekusi kode tersebut. Untuk menjalankan interpreter, aktifkan terminal (atau command-prompt) anda dan masukkan perintah scala. Isi dari command-prompt akan terlihat seperti berikut (jika anda menggunakan sistem operasi Windows):

Microsoft Windows [Version 6.1.7601]
Copyright (c) 2009 Microsoft Corporation.  All rights reserved.

C:\Users\bert>scala
Welcome to Scala version 2.9.2 (Java HotSpot(TM) Client VM, Java 1.7.0_06).
Type in expressions to have them evaluated.
Type :help for more information.

scala>

Setelah masuk ke prompt Scala, anda dapat langsung memasukkan kode Scala, dan interpreter akan langsung memberikan hasil eksekusi kode tersebut. Ketikkan kode berikut dan tekan enter:

scala> 1 + 1

dan interpreter akan mengeluarkan:

res0: Int = 2

Hasil keluaran interpreter tersebut kelihatan aneh. Apa maksudnya?

  1. res0 merupakan nama variabel tempat interpreter menyimpan hasil eksekusi perintah yang kita masukkan. Karena kita tidak memberikan nama variabel, maka interpreter secara otomatis memberikan nama: res0, yang berarti result 0. Penjelasan detil mengenai variabel akan ada pada bagian berikutnya.
  2. Titik dua (:) diikuti dengan Int. Kedua simbol ini merupakan sintaks definisi variabel dari Scala, yang mendeskripsikan tipe data dari variabel. res0: Int berarti variabel res0 memiliki tipe data Integer.
  3. Tanda sama dengan (=). Tidak perlu dijelaskan lagi bukan? (Kerennya: memasukkan nilai di sebelah kanan simbol ke variabel yang ada di sebelah kiri).
  4. Angka 2, hasil evaluasi dari kode 1 + 1 yang kita masukkan.

Seperti yang telah disebutkan, hasil evaluasi dari kode secara otomatis disimpan oleh interpreter ke dalam sebuah variabel, yang diberi nama resX, di mana X merupakan nilai yang akan terus bertambah. Variabel ini bersifat seperti variabel lainnya, sehingga dapat diproses lebih lanjut. Misalnya, kita dapat menggunakan res0 kembali seperti berikut:

scala> res0 * 4
res1: Int = 8

Lalu bagaimana jika kita tidak ingin memasukkan hasil evaluasi kode ke dalam variabel? Perintah println dapat digunakan untuk mencetak hasil ke dalam interpreter, tanpa menyimannya ke dalam variabel.

scala> println("Hello, world!")
Hello, world!

Oke, saya merasa tidak lengkap kalau tutorial awal bahasa pemorgraman tidak dimulai dengan “Hello World” makanya menulis contoh di atas. Perintah println dapat mengevaluasi tipe data standar juga kok:

scala> println(1 + 1)
2

Oh ya, jika ingin memasukkan kode yang lebih dari satu baris, langsung saja tekan enter dan sambung menulis setelah baris pertama. Interpreter akan memberikan tanda dengan garis vertikal (|) pada baris berikutnya, seperti berikut:

scala> println(
     |  "HALO"
     | )
HALO

Jika terjadi kesalahan pengetikan enter, tekan enter dua kali untuk membatalkan masukan.

scala> println("Kepencet"
     |
     |
You typed two blank lines.  Starting a new command.

Pada tulisan-tulisan berikutnya yang menggunakan interpreter, garis vertikal tidak akan dimasukkan dalam kode untuk memudahkan percobaan (copy-paste) dan pembacaan.

Variabel

Catatan: Awal dari bagian ini merupakan penjelasan dasar mengenai variabel. Jika anda telah fasih pemrograman, anda dapat melewatkan paragraf-paragraf awal, sampai ke kotak catatan berikutnya.

Dalam pemrograman, variabel merupakan tempat penyimpanan bagi sebuah nilai. Variabel umumnya dapat diberi nama (sebuah identifier), agar mudah dipanggil kembali jika ingin digunakan kembali oleh program. Variabel, meskipun terlihat sederhana, merupakan sebuah konsep yang cukup mendalam dan terikat dengan bahasa pemrograman. Pembahasan mengenai variabel akan memerlukan artikelnya sendiri. Dalam artikel ini, konsep mengenai variabel yang harus dimengerti adalah:

  1. Variabel merupakan tempat penyimpanan sebuah nilai atau informasi.
  2. Informasi yang ada dalam variabel dapat diambil kembali jika dibutuhkan.
  3. Nilai yang disimpan oleh variabel dapat diubah jika diperlukan.
  4. Variabel memiliki tipe data tertentu. Pada beberapa bahasa pemrograman (misal: PHP, BASIC) tipe data variabel dapat berubah ketika program dijalankan. Pada bahasa lainnya tidak. Tipe data variabel pada Scala tidak dapat berubah setelah variabel dideklarasikan.

Terdapat banyak tipe data dari sebuah variabel. Tetapi berikut adalah tipe data yang umumnya dimiliki oleh bahasa pemrograman:

  1. Integer: menyimpan nilai bilangan bulat (1, 2, 3, 4, ..),
  2. Double dan Float: menyimpan bilangan pecahan dengan presisi rendah (3.149265, 0.2135837, 0.0002341, …),
  3. Decimal: menyimpan bilangan pecahan dengan presisi tinggi, tetapi tidak dapat merepresentasikan pecahan yang berulang. (Bisa: 2.9180317, 0.00001213; tidak bisa: 0.232323232…),
  4. Character: menyimpan sebuah karakter (‘a’, ‘b’, ‘c’, …),
  5. String: menyimpan rangkaian karakter (“Halo?”, “Pemrograman Scala!”, …),
  6. Boolean: menyimpan nilai untuk logika boolean (true dan false),

dan masih banyak tipe data lainnya. Perlu diperhatikan bahwa tipe data dasar dari tiap bahasa pemrograman berbeda-beda, dan umumnya bahasa pemrograman memungkinkan pengguna untuk menspesifikasikan tipe datanya sendiri. Karena tulisan ini bersifat pengenalan, maka pembahasan lebih lanjut tidak akan dilakukan.

Catatan: Akhir dari pengenalan tentang variabel. Awal dari pembahasan variabel pada Scala.

Scala memiliki dua jenis variabel, val dan var. Val merupakan variabel yang nilainya tidak dapat berubah, dan var adalah variabel yang nilainya dapat berubah. Kode berikut akan mendeklarasikan variabel:

scala> val pesan = "WOOOOO~"
pesan: java.lang.String = WOOOOO~

Perintah di atas membuat sebuah variabel baru bernama pesan dan memberikan nilai "WOOOOO~" terhadap pesan. Tipe data dari pesan secara otomatis ditentukan oleh interpreter, yaitu java.lang.String. Karena terkadang interpreter (atau compiler) mungkin saja salah mendeteksi, maka juga dimungkinkan memberikan tipe data secara langsung pada saat deklarasi:

scala> val pesanLangsung: java.lang.String = "Variabel dengan deklarasi tipe data"
pesanLangsung: java.lang.String = Variabel dengan deklarasi tipe data

Karena String merupakan salah satu tipe data yang didukung secara langsung oleh Scala, maka kode di atas dapat disingkat menjadi:

scala> val pesanLangsungSingkat: String = "Singkat"
pesanLangsungSingkat: String = Singkat

Dan seperti yang telah dijelaskan, semua variabel yang telah ditulis sebelumnya dapat digunakan kembali sekarang. Misalnya:

scala> println(pesan)
WOOOOO~

scala> println(pesanLangsung)
Variabel dengan deklarasi tipe data

scala> println(pesan + pesanLangsung)
WOOOOO~Variabel dengan deklarasi tipe data

Tetapi seluruh variabel yang telah kita deklarasaikan sampai sekarang (pesan, pesanLangsung, pesanLangsungSingkat) tidak dapat diubah nilainya. Hal ini karena kita mendeklarasikan variabel dengan kata kunci val.

scala> pesan = "Saya tidak mau WOOOOO~ lagi"
<console>:8: error: reassignment to val
       pesan = "Saya tidak mau WOOOOO~ lagi"
             ^

Jika ingin mengubah nilai variabel, maka deklarasi harus dilakukan dengan var, seperti berikut:

scala> var pesanYangTertukar: String  = "WOOOOO~"
pesanYangTertukar: String = WOOOOO~

scala> pesanYangTertukar = "WOOOOO HOOOOO~"
pesanYangTertukar: String = WOOOOO HOOOOO~

dan tentunya var dapat digunakan sama dengan val:

scala> println(pesanYangTertukar + pesanLangsungSingkat)
WOOOO HOOOOO~Singkat

Menulis Script dengan Scala

Script merupakan program sederhana yang dijalankan baris demi baris, sampai akhir dari program. Umumnya Script disimpan dalam sebuah file, untuk kemudian dieksekusi melalui pemanggilan file tersebut. Meskipun dirancang untuk digunakan pada aplikasi besar, Scala juga mendukung scripting dengan memanggil file melalui interpreter Scala.

Langsung saja, masukkan kode berikut ke dalam aplikasi editor teks, dan simpan dengan nama “ScalaScript.scala”.

println("Halo, scripting dengan Scala")

kemudian navigasi ke tempat penyimpanan file tersebut, dan jalankan perintah:

scala ScalaScript.scala

yang akan memberikan hasil sebagai berikut:

C:\Users\bert\Desktop\scala\blog>scala ScalaScript.scala
Halo, scripting dengan Scala

Scala juga menyediakan fasilitas untuk mengakses argumen yang diberikan oleh pengguna kepada program dengan mudah, melalui variabel args yang selalu dapat diakses pada script Scala. Kode berikut:

println("Argumen dari pengguna adalah " + args(0) + "!")

jika disimpan ke dalam file dengan nama ScalaArgs.scala dan kemudian dijalankan dengan argumen -v akan memberikan hasil berikut:

C:\Users\bert\Desktop\scala\blog>scala ScalaArgs.scala -v
Argumen dari pengguna adalah -v!

Perhatikan juga bahwa variabel args diakses dengan cara yang berbeda: args(0). Hal ini karena args adalah sebuah Array, yang menyimpan banyak nilai String. Dengan mengetahui hal ini, kita dapat membuat script yang dapat menerima banyak argumen dari pengguna seperti berikut:

println("Argumen pertamanya: " + args(0) + ", argumen kedua: " + args(1) + ", dan argumen ketiga: " + args(2))

yang jika disimpan dengan nama ScalaBanyakArgs.scala akan dapat dipanggil seperti berikut:

C:\Users\bert\Desktop\scala\blog>scala ScalaBanyakArgs.scala -v -r -f
Argumen pertamanya: -v, argumen kedua: -r, dan argumen ketiga: -f

Catatan: Penjelasan mengenai apa itu Array, dan kenapa diakses mulai dari angka 0 tidak diberikan untuk menjaga fokus artikel. Artikel-artikel berikutnya akan menjelaskan Array secara lengkap.

Perulangan dan Percabangan

Keunggulan utama dari pengunaan komputer adalah otomasi. Komputer dapat melakukan hal yang sama berulang kali, tanpa melakukan kesalahan. Hal ini berbeda dengan manusia yang memiliki kemungkinan untuk melakukan kesalahan karena faktor luar (kelelahan, bosan, dll). Karena inilah hampir semua bahasa pemrograman (yang digunakan untuk memberikan perintah kepada komputer) umumnya memiliki perulangan dan percabangan.

Catatan: Perintah while dan if yang dimiliki Scala tidak memiliki perbedaan signifikan dengan perintah yang sama pada bahasa pemrograman lain pada umumnya. Jika telah mempelajari kedua perintah ini pada bahasa lain, anda dapat melanjutkan ke bagian selanjutnya untuk melihat sekilas perintah for Scala, yang berbeda dengan bahasa pemrograman lain pada umumnya.

Perulangan While dan Percabangan If

Perulangan digunakan untuk memberikan perintah yang harus dilakukan berulangkali, sementara percabangan digunakan sebagai sarana pengambilan keputusan. Misalkan kode berikut:

var i = 1
while(i <= 10) {
  println("Cetakan ke " + i)
  i = i + 1
}

Kode dimulai dengan inisialisasi variabel i yang diberi nilai awal 1. Selesai membuat dan mengisikan variabel, kita lalu memerintahkan Scala untuk menjalankan kode tertentu selama i lebih kecil atau sama dengan 10. while(i <= 10) merupakan perintah perulangan yang digunakan, sementara kode yang berada di dalam kurung kurawal (while(i <= 10){ ... }) setelah while adalah kode yang harus diulang oleh program. Terdapat dua baris kode program yang harus diulang selama i bernilai kurang atau sama dengan 10, yaitu:

println("Cetakan ke " + i)
i = i + 1

Baris println(...) jelas kegunaannya, yaitu mencetak tulisan "Cetakan ke i", di mana i adalah nilai Integer dari i. Selesai dicetak, nilai i ditambahkan satu dengan dirinya sendiri (i = i + 1). Baris ini memiliki kegunaan ganda: untuk memastikan nilai i yang dicetak selalu berbeda-beda, dan memastikan nilai i terus bertambah hingga akhirnya menjadi lebih dari 10 dan perulangan dapat berhenti.

Simpan kode di atas ke dalam file dengan nama ScalaLoop.scala dan jalankan untuk melihat hasil eksekusi sebagai berikut:

C:\Users\bert\Desktop\scala\blog>scala ScalaLoop.scala
Cetakan ke 1
Cetakan ke 2
Cetakan ke 3
Cetakan ke 4
Cetakan ke 5
Cetakan ke 6
Cetakan ke 7
Cetakan ke 8
Cetakan ke 9
Cetakan ke 10

Bagaimana jika kita ingin mengubah hanya beberapa keluaran dari hasil di atas? Misalnya, jika kita ingin mencetak "Cetakan Ketujuh" pada saat i bernilai tujuh? (Jangan tanya kenapa, tapi mungkin saja tujuh adalah bilangan mistis yang harus dieja dengan baik dan benar).

Ketika bertemu dengan situasi seperti itu, kita dapat menggunakan perintah if untuk membantu dalam membuat keputusan. Kode berikut:

var i = 1
while(i <= 10) {
  if(i == 7) {
    println("Cetakan ketujuh")
  } else {
    println("Cetakan ke " + i)
  }
  i = i + 1
}

merupakan kode yang akan mencetak "Cetakan Ketujuh" pada saat i bernilai 7. Perbedaan utama antara kode ini dengan kode sebelumnya ialah pada tambahan perintah if yang menggantikan perintah println secara langsung. Perintah if dapat dimengerti dengan membaca secara langsung kode yang tertulis seperti berikut:

if(i == 7) {   // 1. Jika i sama dengan tujuh
  ...          // 2. jalankan semua kode yang ada di sini
} else {       // 3. Jika tidak (i tidak sama dengan tujuh)
  ...          // 4. jalankan semua kdoe yang ada di sini
}

Perhatikan bahwa langkah 2 tidak akan dijalankan jika i tidak sama dengan tujuh, dan sebaliknya langkah 4 tidak akan dijalankan jika i sama dengan tujuh. Ketika kode disimpan ke dalam file bernama ScalaLoopIf.scala dan dieksekusi maka kita akan mendapatkan hasil sebagai berikut:

C:\Users\bert\Desktop\scala\blog>scala ScalaLoopIf.scala
Cetakan ke 1
Cetakan ke 2
Cetakan ke 3
Cetakan ke 4
Cetakan ke 5
Cetakan ke 6
Cetakan ketujuh
Cetakan ke 8
Cetakan ke 9
Cetakan ke 10

Simpel, eh?

Catatan: Perulangan for milik Scala berbeda dengan for pada bahasa pemrograman pada umumnya. Jika melewatkan bagian sebelumnya, anda dapat melanjutkan membaca pada bagian ini.

Perulangan for

Metode perulangan while yang telah dijelaskan pada bagian sebelumnya merupakan metode perulangan yang digunakan pada pemrograman imparatif. Meskipun Scala mendukung baik pemrograman imparatif maupun pemrograman fungsional, paradigma yang lebih didukung (dan disarankan untuk digunakan) oleh Scala adalah paradigma fungsional.

Metode perulangan yang didukung oleh pemrograman fungsional pada Scala adalah pengulangan menggunakan for. Jalankan kode berikut pada intepreter Scala:

1 to 10 foreach(println)

untuk melakukan percetakan angka 1 sampai 10. Berikut adalah hasil eksekusi kode di atas:

scala> 1 to 10 foreach(println)
1
2
3
4
5
6
7
8
9
10

Sebentar, sebentar. APA YANG BARUSAN TERJADI?

Tenang, kawan. Kode di atas adalah perulangan yang dilakukan dengan metode fungsional. Belum benar-benar menampakkan for, karena kita terlebih dahulu akan melihat apa yang terjadi di balik layar ketika menjalankan for pada Scala. Sekarang, penjelasan kode di atas:

  1. 1 to 10 adalah cara penulisan alternatif dari 1.to(10). Kita memanggil fungsi to dari Integer bernilai 1, dan memberikan parameter 10 kepada fungsi to tersebut. Fungsi to akan menghasilkan sekumpulan bilangan dari 1 sampai 10 kepada kita (1, 2, 3, 4, 5, 6, 7, 8, 9, 10). > Catatan: Konsep yang barusan dijelaskan (pemanggilan fungsi terhadap nilai) adalah konsep pemrograman berorientasi objek (PBO). Jika belum mengerti PBO, tenang saja, yang cukup dimengerti hanyalah perintah 1 to 10 akan menghasilkan kumpulan bilangan 1 sampai 10. Konsep PBO akan dibahas lain waktu.

  2. Setelah mendapatkan kumpulan bilangan dari 1 sampai 10, maka kita kembali memanggil fungsi dari kumpulan bilangan tersebut, foreach. Setiap kumpulan dalam Scala memiliki fungsi ini, yang akan menerima argumen berupa fungsi lainnya, yang akan diaplikasikan ke setiap elemen dalam kumpulan. Singkatnya, fungsi foreach menerima satu argumen yang betipe fungsi. Secara matematis fungsi ini dituliskan seperti berikut:

    foreach(f(x))
    
  3. Dan fungsi f(x) yang kita kirimkan kepada foreach adalah println. Karena println menerima satu argumen saja, maka Scala secara otomatis memberikan nilai dari setiap elemen pada koleksi kepada println.

Jika dituliskan dengan lengkap, maka kode 1 to 10 foreach(println) akan menjadi kode berikut:

1.to(10).foreach((x: Int) => println(x))

Fungsi yang dikirimkan ke foreach adlaah (x: Int) => println(x). Fungsi ini tidak memiliki nama dan hanya memiliki satu argumen bernama x. Fungsi jenis ini dikenal dengan nama fungsi literal (function literal). Penjelasan mengenai fungsi literal dapat dibaca di sini (yang akan saya bahas pada tulisan berikutnya - tulisan ini sudah terlampau panjang).

Bentuk perulangan for di atas tentunya sangat tidak familiar bagi yang mengenal for pada bahasa pemrograman lainnya (yang tidak fungsional). Untungnya, model perulangan memiliki cara penulisan alternatif yang lebih dekat dengan bahasa lainnya. Kode berikut juga mencetak angka 1 sampai 10:

scala> for(x <- 1 to 10) {
     println(x)
   }
1
2
3
4
5
6
7
8
9
10

Tetapi perintah for seperti yang dituliskan pada kode di atas tidak terbatas kemampuannya hanya untuk iterasi sederhana saja. Perintah for memiliki banyak fitur dan kegunaan yang akan membutuhkan pembahasan tersendiri untuk melihat seluruh kemampuannya. Contoh pengunaan for di atas sudah sangat cukup untuk mulai menulis program yang berguna menggunakan Scala. Berbagai kekuatan for akan kita jelajahi pada tulisan-tulisan berikutnya. Untuk sekarang, happy coding!

comments powered by Disqus

Daftar Isi