Pemrograman Modular

Secara Imperatif Prosedural

dengan Bahasa Pascal
Versi 0.3 alpha

Oleh : Mario Ray M.

Kata Pengantar
Buku ini (diharapkan) dapat digunakan sebagai panduan dalam pengajaran
pemrograman dasar yang bersifat prosedural. Di sisi lain, karena ditulis dengan
posisi penulis sebagai pengajar, buku ini dapat juga digunakan sebagai tutorial
untuk para self-learner.
Buku ini mencoba berbeda dari buku lain yang sejenis, yaitu dengan
menggunakan pendekatan pengajaran learning by analyzing. Saat buku lain
memulai secara teoritis, baru kemudian dilanjutkan dengan kode, buku ini justru
menggunakan kode sebagai basis pengajaran. Kode tersebut yang kemudian akan
ditelaah dan dipelajari untuk menggali konsep-konsep yang ada dalam
pemrograman prosedural.
Bahasa pemrograman yang digunakan adalah bahasa Pascal. Karena selain
ketenarannya dalam dunia pendidikan, juga karena sifatnya yang struktural
memaksa programmer untuk menulis kode yang tersusun rapi, type-safety yang
menjamin keamanan kode saat kompilasi, dan runtime-checking yang sangat
membantu proses pemeriksaan saat menjalankan program. Didukung dengan
pesan error yang cukup jelas, mempermudah pencarian kesalahan dalam kode
yang sering dialami programmer-programmer pemula.

Daftar Isi

Daftar Isi ............................................................................................................ 2

Sejarah Singkat Bahasa Pascal ......................................................................... 4
Prasyarat & Perlengkapan yang Diperlukan ................................................... 6
Struktur Program Pascal................................................................................... 7
Halo, Dunia! ..................................................................................................... 10
Perhitungan Matematika................................................................................. 15
Masukan dan Keluaran ................................................................................... 19
Masukan sederhana (tanpa kemungkinan error)....................................... 19
Masukan dengan kemungkinan error......................................................... 21
Pemberian Nilai ............................................................................................... 23
Pemberian nilai pada saat eksekusi............................................................. 23
Pemberian nilai pada saat deklarasi (inisialisasi) ....................................... 24
Perintah Bercabang ......................................................................................... 26
if ... then ... else ............................................................................................. 26
case ... of........................................................................................................ 30
Bilangan Acak .................................................................................................. 33
Pengulangan 1: Iterasi ..................................................................................... 35
for .. to / downto .. do ................................................................................... 36
while .. do...................................................................................................... 37
repeat .. until ................................................................................................ 38
Ujian 1 .............................................................................................................. 41
Subprogram ..................................................................................................... 42
Prosedur ....................................................................................................... 42
Argumen / Parameter .................................................................................. 43
Prosedur di Dalam Prosedur ....................................................................... 44
Aturan Ruang Lingkup ............................................................................... 45
Penyampaian Parameter ............................................................................. 47
Fungsi ........................................................................................................... 49
Referensi Maju............................................................................................. 50
Pengulangan 2 : Rekursi.................................................................................. 53
Tipe Data Lanjutan.......................................................................................... 55
Larik / Array ................................................................................................ 55
Enumeration / Pencacahan.......................................................................... 59

Himpunan / Set............................................................................................. 59
Rekaman / Record........................................................................................ 59
Penunjuk / Pointer ....................................................................................... 59
Berkas / File.................................................................................................. 59
Tipe Data Prosedural................................................................................... 59

Sejarah Singkat Bahasa Pascal

Pascal dirancang oleh seorang Professor di Polytechnic of Zurich, Swiss
bernama Niklaus Wirth. Beliau merupakan salah seorang anggota komite yang
yang pada tahun 1960-an mengembangkan bahasa Algol, yang merupakan akar
bahasa Pascal. Beliau membuat bahasa Pascal karena ketidakpuasannya dengan
bahasa-bahasa yang ada waktu itu, di mana kode-kode program tidak tersusun
dengan baik dan sulit dipertahankan1. Beliau ingin membuat sebuah bahasa
pemrograman yang terstruktur namun tetap sederhana dan mudah dipelajari. Dari
keinginannya tersebut, lahirlah bahasa Pascal. Pascal diumumkan ke publik pada
tahun 1969, dengan implementasi compiler2 pertama setahun sesudahnya.
Dalam perjalanannya, Pascal terpecah menjadi dua kelompok dialek.
Tepatnya sekitar tahun 80an saat sebuah operating system dan compiler UCSD
Pascal dirilis. UCSD Pascal memperkenalkan sistem unit untuk modularisasi dan
tipe string. Selain itu, ia juga memperkenalkan p-code yang merupakan cikal
bakal dari bytecode Java.
Kelompok pertama adalah Pascal orisinil dan pada tahun 1990 dibuat ISOnya (7185), diikuti dengan Extended Pascal (10206) pada tahun yang sama.
Sayangnya, pengguna kelompok ini tidak terlalu banyak sehingga compiler yang
mengimplementasikan dialek ini pun hanya sedikit. Saat ini, hanya terdapat
sekitar 5 kompilator yang masih bertahan, yaitu Prospero Extended Pascal, IP
Pascal, Dr. Pascal, dan GNU Pascal (GPC). Semuanya ditulis dalam bahasa
Pascal, kecuali GPC yang ditargetkan sebagai front-end dari GCC sehingga ditulis
dalam bahasa C.
Kelompok kedua merupakan Pascal yang banyak digunakan saat ini, yaitu
turunan dari UCSD Pascal. Turbo Pascal adalah salah satu compiler keluaran
Borland tersukses yang termasuk turunan UCSD Pascal. Ia meng-extend UCSD
Pascal dengan object, memungkinkan permrograman berorientasi objek (PBO /
OOP) dengan Pascal, menambah beberapa tipe data seperti PChar, dan
1
2

sering juga disebut spaghetty code

program yang mengubah kode sumber menjadi program yang bisa dieksekusi

melonggarkan beberapa aturan Pascal orisinil sehingga membuat Pascal cocok

untuk pemrograman sistem. Turbo Pascal ditulis dalam bahasa assembler,
sehingga tidak mengherankan jika kecepatannya luar biasa. Setelah masa
keemasan Turbo Pascal berakhir, dirilis Delphi yang kemudian menjadi standar
Object Pascal / Modern Pascal. Delphi mengubah konsep OOP Turbo Pascal
sehingga menjadi lebih natural dengan mengubah object menjadi class, tentunya
dengan ekstensi lain yang membuat bahasa ini semakin kuat. Di saat yang sama,
Free Pascal (FPC) juga mulai dikembangkan dan menargetkan kompatibilitas
dengan Turbo Pascal maupun Delphi. Perbedaannya, Delphi dibuat khusus untuk
Windows, sementara FPC dibuat cross-platform. Selain itu, compiler Delphi
ditulis dalam bahasa C++ sementara FPC ditulis dalam bahasa Pascal.
Pascal banyak digunakan dalam dunia pendidikan, terutama untuk
mengajarkan pemrograman. Namun, sekarang ini mulai banyak digunakan dalam
dunia industri karena kompilatornya sekarang sudah ada yang 32-bit atau bahkan
64-bit dan multiplatform, menggantikan C/C++ karena kemudahan membuat
program yang maintainable dan mengurangi proses debugging3 namun dengan
kecepatan yang relatif sama bahkan dengan penggunaan memori yang lebih
efisien.

pemeriksaan akan adanya kesalahan pada program

Prasyarat & Perlengkapan yang Diperlukan

Diperlukan kemampuan bahasa Inggris yang cukup karena banyak istilah
bahasa Inggris yang akan digunakan. Selain itu, diperlukan kemampuan dasar
mengenai console / command prompt4 (Misalnya, berpindah directory).

1.

Compiler
Sebagian besar kompilator Pascal modern (misal: Free Pascal) bisa
digunakan. Harap baca dokumentasi kompilator yang Anda gunakan. Paling
tidak, carilah informasi bagaimana cara mengompilasi sebuah program.

2.

Editor / IDE
Editor apapun mulai dari yang paling sederhana (misal: Notepad) sampai
yang berbentuk RAD (misal: Lazarus) bisa digunakan. Jangan gunakan word
processor5 (misal: Microsoft Word) karena biasanya word processor
memiliki

kemampuan

untuk

memperbaiki

tulisan

yang

seringkali

mempersulit pengetikan kode, selain itu word processor juga memiliki format
khusus, walaupun sebagian besar bisa juga menyimpan dengan format teks
biasa. Disarankan untuk menggunakan editor yang memiliki nomor baris,
dengan kemampuan syntax highlighting6, code completion7, dan code
templates8 (misal: SciTE) karena itu akan sangat mengurangi beban
pengetikan.

Command prompt (Windows), Console, dan Terminal (Linux & MacOS) merujuk pada aplikasi
yang sama, yaitu program di mana perintah diberikan dengan mengetik tulisan dengan keyboard
ketimbang meng-klik icon dengan mouse
5
Word processor dibuat untuk membantu proses pembuatan dokumen sehingga diperlukan fiturfitur yang bisa mempermudah proses tersebut, seperti memperbaiki tulisan yang salah ketik. Hal
ini menyulitkan dalam penulisan kode program, misalnya untuk kata teh. Sebagian besar word
processor mengenalinya sebagai ketikan yang salah dari kata the dan otomatis setiap kali kita
mengetik teh akan langsung diganti dengan the
6
Pemberian corak khusus pada elemen tertentu dari suatu bahasa pemrograman
7
Penulisan kode secara otomatis untuk melengkapi suatu struktur
8
Penggunaan singkatan untuk menghasilkan suatu struktur

Struktur Program Pascal

Pascal merupakan bahasa imperative9 dan procedural10, artinya program
dalam bahasa Pascal terdiri atas kumpulan instruksi yang dieksekusi secara
berurutan. Bahasa lain yang termasuk dalam kelompok ini misalnya C & Fortran.
Secara umum, struktur program Pascal dapat dilihat pada bagan 1.1. Bagianbagian program tersebut (beserta struktur-struktur lain yang tidak tercakup) akan
kita pelajari pada bab-bab berikutnya.
Pascal adalah bahasa yang bersifat case-insensitive, artinya Pascal TIDAK
membedakan penulisan huruf besar maupun kecil. Begin, begin, BEGIN, bEgIn,
maupun BeGiN memiliki arti yang sama. Namun, demi kemudahan membaca,
disarankan untuk menggunakan 3 cara pertama dan sebaiknya konsisten sepanjang
program. Menurut panduan penulisan kode yang dikeluarkan Borland (produsen
Turbo Pascal dan Delphi), gunakan huruf kecil untuk kata kunci. Untuk nama
fungsi, tipe data, variabel, konstanta, dan elemen lainnya gunakan huruf kapital
(huruf pertama besar) untuk setiap kata. Contoh:
Kata kunci

: program, begin, end, procedure, function, var, const, dst.

Lainnya

: ProgramKu, FungsiXXX, Nama, Alamat, MintaInput, dst.

Bahasa pemrograman yang alur programnya berupa rangkaian instruksi

Bahasa pemrograman yang alur programnya berupa pemanggilan prosedur

10

{ Nama program, secara teknis tidak dibutuhkan }

program judul_program;
(* Penggunaan unit (pustaka) *)
uses
unit1,unit2,...,unitN;
type //
tipe1
tipe2
...
tipeN

Definisi tipe global

= definisi_type1;
= definisi_type2;
= definisi_typeN;

const // Definisi konstanta global

konstanta1 [: tipe_konstanta1] = nilai_konstanta1;
konstanta2 [: tipe_konstanta2] = nilai_konstanta2;
...
konstantaN [: tipe_konstantaN] = nilai_konstantaN;
var // Deklarasi variabel
var1: tipe_variabel1 [=
var2: tipe_variabel2 [=
...
varN: tipe_variabelN [=

global
nilai_awal];
nilai_awal];
nilai_awal];

procedure nama_prosedur[(arg1: tipe_argumen1; arg2: tipe_argumen2;

...; argN: tipe_argumenN)];
{ Deklarasi variabel lokal (bisa juga tipe atau konstanta) }
var
var1: tipe_variabel1 [= nilai_awal];
var2: tipe_variabel2 [= nilai_awal];
...
varN: tipe_variabelN [= nilai_awal];
begin
// Isi prosedur
end;
function nama_fungsi[(arg1: tipe_argumen1; arg2: tipe_argumen2;
...; argN: tipe_argumenN)]: tipe_nilai_balikan;
{ Deklarasi variabel lokal (bisa juga tipe atau konstanta) }
var
var1: tipe_variabel1 [= nilai_awal];
var2: tipe_variabel2 [= nilai_awal];
...
varN: tipe_variabelN [= nilai_awal];
begin
// Isi fungsi
end;
begin
// Isi program utama
end.

Bagan 1.1 Struktur Program Pascal

Keterangan:
Cetak tebal

Kata kunci

Warna biru

Komentar

Warna merah Simbol

Kurung siku

Pilihan (tidak wajib)

Halo, Dunia!
Program paling dasar dalam hampir semua pelajaran bahasa pemrograman
adalah Hello, World11. Program ini bekerja dengan sangat sederhana, hanya
mencetak sebuah kalimat ke dalam console / command prompt. Buka editor yang
Anda miliki, lalu ketikkan program berikut.

1
2
3
4
5
6

program Halo;
begin
WriteLn('Halo, Dunia!');
end.

Program 1.1 Halo, Dunia!

Catatan
Kolom sebelah kiri adalah nomor baris, yang akan sangat berguna ketika kita akan
memusatkan kode pada bagian tertentu.
Simpan program tersebut dengan nama Halo.pas12, kemudian buka
command prompt dan ketikkan perintah untuk mengompilasi program tersebut.
Misalnya, untuk Free Pascal ketikkan (> adalah tanda prompt):
> fpc Halo.pas

Kemudian, jalankan program yang telah dikompilasi dengan mengetik:

> Halo.exe

untuk Windows, dan

> ./Halo

11

Bentuk suatu bahasa biasanya bisa dilihat dari program paling sederhana yang bisa dibuatnya, di
mana Hello, World! adalah yang paling umum digunakan
12
Ekstensi .pas hanyalah konvensi, namun demikian sangat disarankan untuk menggunakannya
untuk membedakan dengan file-file lain. .pas hanya salah satu ekstensi program Pascal, contoh
yang lain adalah .p. Beberapa kompilator juga menambahkan ekstensi sendiri untuk keperluan
masing-masing

10

untuk Linux / MacOS. Jika program berhasil dikompilasi, maka akan muncul
tulisan:
> Halo, Dunia!

Sebaliknya, bila tidak, berarti Anda mendapat compile error13. Periksa kembali
program Anda, apakah mungkin ada titik koma yang terlewatkan, penulisan kata
kunci yang bersentuhan (tidak ada spasi yang memisahkan) dengan pengenal, dsb.

Catatan
Titik koma pada kalimat terakhir sebelum end TIDAK wajib, namun bila ada pun
tidak apa-apa. Disarankan untuk tetap menulisnya karena jika seandainya program
dimodifikasi dan ada kalimat baru yang dimasukkan setelahnya (artinya, kalimat
tersebut tidak lagi menjadi kalimat terakhir), Anda tidak akan mendapat error
karena lupa memberi titik koma.

Sekarang, kita pelajari program tersebut secara lebih mendalam. Pada baris
pertama, terdapat kata kunci program dan pengenal Halo, diakhiri dengan ;
(titik koma). Titik koma bagi Pascal merupakan pemisah antar kalimat dalam
program. Bagi beberapa kompilator (misal Free Pascal, Turbo Pascal, Delphi),
bagian ini TIDAK harus ada. Namun, demi mempertahankan kecocokan dengan
kompilator lain dan kejelasan program, disarankan agar tetap ditulis. Pada
dasarnya, bagian ini hanya memberikan nama dan tidak mempengaruhi jalannya
program.
Kata kunci (keywords / reserved words) merupakan bagian dari bahasa
Pascal dan tidak boleh digunakan sebagai pengenal (identifier). Tabel 1.1
menunjukkan kata kunci yang tersedia dalam bahasa Pascal (termasuk Object
Pascal). Pengenal adalah nama yang kita berikan pada bagian program tertentu
agar bisa dirujuk kemudian. Pengenal dalam Pascal dapat terdiri dari huruf, angka,
dan garis bawah dan HARUS diawali dengan huruf atau garis bawah. Panjang
13

Error yang terjadi saat proses kompilasi. Biasanya karena kesalahan syntax, tipe data yang tidak
cocok, dsb. Error ini sangat berguna untuk mencegah program memberikan hasil yang tidak
diinginkan, meskipun seringkali kesalahan terjadi karena kita tidak dapat merepresentasikan apa
yang kita inginkan dalam bahasa yang dimengerti kompilator.

11

pengenal bisa berapapun, namun sebagian besar kompilator Pascal hanya akan
melihat 32 karakter pertama. Karena itu, gunakan nama dengan panjang yang
masuk akal (tidak lebih dari 15 karakter). Dengan begini, Anda juga mengurangi
waktu pengetikan.
Bagian program berikutnya, yaitu baris kedua dikosongkan. Tentu hal ini
tidak wajib, hanya saja ketika nanti program yang kita buat sudah mulai
kompleks, adanya baris kosong akan mempermudah kita memilah-milah bagian
absolute
and
array
asm
begin
break
case
const
constructor
continue
destructor
div
do
downto
else
end
file
for
function
goto

if
implementation
in
inherited
inline
interface
label
mod
nil
not
object
of
on
operator
or
otherwise
packed
procedure
program
record

reintroduce
repeat
self
set
shl
shr
string
then
to
type
unit
until
uses
var
while
with
xor
as
class
except

exports
finalization
finally
initialization
is
library
on
out
property
raise
threadvar
try
dispose
exit
false
new
true
generic
specialization

Tabel 1.1 Kata kunci dalam bahasa Pascal

Catatan
Beberapa kata kunci hanya ada pada kompilator tertentu, misalnya generic dan
specialization hanya ada pada Free Pascal pada mode ObjFPC atau Delphi.

Namun, demi menjaga kecocokan antar kompilator, akan lebih baik jika Anda
menghindari semua kata-kata di atas.

program.

12

Pada baris ketiga terdapat kata kunci begin, yang diikuti dengan
pemanggilan prosedur14 WriteLn dengan argumen15 bertipe string berisi kalimat
Halo, Dunia!.
String merupakan tipe data berupa untaian karakter yang diawali dan

diakhiri dengan (tanda kutip). Untuk mencetak tanda kutip, tulis dua tanda kutip
secara berurutan. Semua karakter dalam string akan memiliki makna normalnya
(tidak terkecuali kata kunci, operator, dan simbol-simbol lainnya).
WriteLn adalah prosedur internal yang dapat menerima argumen dalam
jumlah dan tipe yang bervariasi. Prosedur ini akan mencetak argumenargumennya dan diakhiri dengan baris baru (dalam keyboard, sama dengan Enter).
Sebelum mencetak, jika argumennya berupa ekspresi16, maka akan dievaluasi
terlebih dahulu, kemudian hasilnya diubah ke string. Karena itu, jika
argumennya tidak dapat diubah ke string, kompilator akan memberikan compile
error.
Sedangkan pada baris kelima terdapat kata kunci end yang diakhiri dengan
. (titik). Dalam suatu program, kumpulan instruksi yang berada dalam satu
kelompok disebut blok, yang dalam bahasa Pascal diawali dengan begin dan
diakhiri dengan end. Terdapat perbedaan antara end yang diakhiri dengan ; (titik
koma) dan . (titik). Untuk program, end harus diakhiri dengan titik. Sementara
elemen program yang lain menggunakan ;. Hal inilah yang mendasari beberapa
kompilator untuk mengabaikan bagian program seperti yang telah dijelaskan di
atas.
Baris terakhir yang dikosongkan diperlukan bagi beberapa kompilator
(misal GNU Pascal) sebagai penanda akhir file.

14

Seringkali (pastinya) dalam sebuah program, kita perlu melakukan rangkaian langkah yang sama
namun hanya berbeda di beberapa tempat. Untuk itulah diciptakan prosedur (dan fungsi), sehingga
hanya bagian yang berbeda itu yang perlu kita tulis
15
Seperti dalam matematika, fungsi dapat menerima argumen. Misalnya f(x) adalah fungsi
bernama f dengan argumen x, g(a,b) adalah fungsi bernama g dengan argumen pertama a dan
argumen kedua b, dst.
16
Operasi yang memberikan nilai

13

Kuis:
1.

Apa perbedaan keywords dengan identifier?

2.

Apa saja (minimal 3) penyebab terjadinya compile error?

14

Perhitungan Matematika
Pada dasarnya, semua program komputer adalah kalkulator, tinggal
bagaimana kita merepresentasikan perhitungan yang kita inginkan dalam bahasa
yang bisa dimengerti komputer. Hal ini sangat sulit dilakukan secara langsung,
karena meskipun terlihat sangat pintar, komputer sebenarnya hanya mengerti
penjumlahan dan perkalian, dan beberapa operasi lain yang tidak berhubungan
secara langsung dengan perhitungan matematis. Dengan bahasa pemrograman dan
bantuan kompilatornya, kita dapat melakukannya semudah menuliskannya pada
kertas. Program 2.1 menunjukkan contoh program yang melakukan perhitungan
1+2*3-4.

1
2
3
4
5
6

program Hitung;
begin
WriteLn('1+2*3-4 = ',1+2*3-4);
end.

Program 2.1 Perhitungan matematika

Kompilasi program tersebut dan jalankan, Anda akan mendapatkan:

> 3

Mengapa 3? Bukankah 1 + 2 = 3 > 3 * 3 = 9 > 9 - 4 = 5? Jawabannya, Pascal

mengerti apa yang disebut dengan operator precedence (tingkatan operator) yang
biasa digunakan pada kalkulator ilmiah, di mana operator yang memiliki tingkatan
lebih tinggi akan didahulukan operasinya. Tabel 2.1 menunjukkan operator dan
tingkatannya di mana angka yang lebih rendah menunjukkan tingkatan yang lebih
tinggi. Maka dari itu, Pascal memahami perhitungan matematika di atas sebagai
1+(2*3)-4. Jika yang diinginkan adalah (1+2)*3-4, gunakan tanda kurung yang
sesuai. Sebaiknya, demi menghindari hasil yang tidak diinginkan, selalu gunakan
tanda kurung dalam setiap perhitungan yang harus didahulukan.

15

Tingkatan
1
2
3
4

Operator

Kategori
not @
Operator Tunggal
* / div mod and shl shr as Operator Perkalian
+ - or xor
Operator Penjumlahan
= <> < > <= >= in is
Operator Relasi
Tabel 2.1 Operator dan tingkatannya

Selanjutnya, kita akan mempelajari program tersebut. Bagian yang berubah

dari program sebelumnya hanyalah pada argumen prosedur WriteLn. Seperti yang
telah dijelaskan, WriteLn dapat menerima argumen dalam jumlah dan tipe yang
bervariasi. Dalam hal ini argumen yang diberikan ada 2, dipisahkan dengan ,
(tanda koma). Argumen yang pertama sama seperti sebelumnya, berupa string.
Sedangkan argumen kedua berupa ekspresi aritmatika yang memberikan nilai
berupa angka.
Angka dalam komputer tidaklah seabstrak angka dalam matematika. Ada
batasan-batasan yang harus dipenuhi agar kita mendapatkan hasil perhitungan
yang sesuai secara efisien. Pertama, angka dalam komputer bersifat TERBATAS.
Walaupun ada beberapa pustaka yang memungkinkan kita menulis angka
berapapun besarnya namun biasanya perhitungannya lebih lambat dan
menggunakan memori lebih besar. Karenanya, pustaka semacam itu biasanya
hanya digunakan di lingkungan yang membutuhkan ketelitian tinggi.
Pascal mendefinisikan dua tipe angka, yaitu Integer dan Real. Integer
adalah tipe data yang memuat bilangan bulat, sementara Real dapat juga memuat
pecahan. Tabel 2.2 menunjukkan tipe Integer yang tersedia, luas jangkauan, dan
ukurannya dalam memori, sementara tabel 2.3 menunjukkan hal yang sama untuk
Real. Untuk ekspesi aritmatika langsung (tanpa variabel), kompilator akan secara
otomatis menggunakan tipe data yang sesuai. Cobalah bereksperimen dengan

16

perhitungan-perhitungan lainnya! Jika ada perhitungan yang tidak sesuai, lihatlah

tabel tingkatan operator.
Jika Anda mencoba perhitungan yang melibatkan Real (baik operand
maupun hasilnya) dan menuliskannya dengan prosedur Write(Ln), maka Anda
akan mendapatkan hasil yang kelihatannya tidak lazim. Misalnya, jika Anda
menulis WriteLn(1/4)
maka yang tampil di layar adalah
> 2.5000000000000000E-0001

Ini adalah notasi ilmiah yang merupakan default keluaran untuk Real. Jika Anda
ingin hasil yang lebih mudah dibaca, maka Anda harus mem-format-nya dengan
cara memberikan : (titik dua) diikuti dengan lebar minimum keluaran (rata
kanan) dan titik dua diikuti dengan jumlah desimal yang Anda butuhkan (otomatis
dibulatkan). Misalnya
WriteLn(3/8:5:2)

akan memberikan hasil

<spasi>0.38 (pembulatan dari 0.375)
Perhatikan adanya spasi di depan! Karena kita meminta lebar minimum 5,
sedangkan keluarannya hanya 4 karakter (0.38) maka akan ditambahkan spasi
sampai panjang keluaran sama dengan lebar minimum. Karena rata kanan, maka
spasi akan ditambahkan di depan. Hal ini juga berlaku untuk tipe data lain yang
bisa diterima Write(Ln), namun hanya titik dua pertama yang diperlukan (jika
Anda memaksa, akan terjadi compile error) karena tipe data lain tidak memiliki
bagian desimal. Untuk hal ini, Anda dipersilakan mencoba sendiri.

Kuis:
1.

Mengapa pada kalimat WriteLn('1+2*3-4 = ',1+2*3-4);, argumen kedua

dicetak sebagai 3, bukan 1+2*3-4 seperti argumen pertama?

2.

Berapa

jumlah

spasi

yang

akan

WriteLn(2/7:7:3)?

17

ditambahkan

untuk

perintah

Ukuran
(dalam Bytes)
Byte
0 .. 255
1
ShortInt
-128 .. 127
1
SmallInt
-32768 .. 32767
2
Word
0 .. 65535
2
Integer
SmallInt, LongInt, atau Int64
2, 4, atau 8
Cardinal
Word, LongWord, atau QWord
2, 4, atau 8
LongInt
-2147483648 .. 2147483647
4
LongWord
0 .. 4294967295
4
Int64
-9223372036854775808 .. 9223372036854775807
8
QWord
0 .. 18446744073709551615
8
Tipe

Jangkauan

Tabel 2.2 Tipe Integer, luas jangkauan, dan ukurannya dalam memori

Tipe

Jangkauan

Real
Single
Double
Extended
Comp
Currency

tergantung platform
1.5E-45 .. 3.4E38
5.0E-324 .. 1.7E308
1.9E-4932 .. 1.1E4932
-2E64+1 .. 2E63-1
-922337203685477.5808 ..
922337203685477.5807

Digit
Penting
???
7-8
15-16
19-20
19-20
19

Ukuran
(dalam Bytes)
4 atau 8
4
8
10
8
8

Tabel 2.3 Tipe Real, luas jangkauan, dan ukurannya dalam memori

18

Masukan dan Keluaran

Masukan sederhana (tanpa kemungkinan error)
Sejauh ini, program yang kita buat selalu menghasilkan keluaran yang
sama. Jika ingin hasil yang berbeda, maka program harus diubah dan dikompilasi
ulang. Hal ini tentu sangat tidak efisien, sebab tidak mungkin kita selalu menulis
ulang program hanya karena masukannya berubah. Untuk itu, komputer
menyediakan fasilitas masukan dan keluaran untuk program. Sebagai contoh, lihat
program 3.1.

1
2
3
4
5
6
7
8
9
10

program Halo2;
var
Nama: String;
begin
Write('Siapa nama Anda? ');
ReadLn(Nama);
WriteLn('Halo, ',Nama,'!');
end.

Program 3.1 Halo dengan masukan

Keterangan:
String dalam Pascal adalah tipe data sekaligus kata kunci, karena itu selain

dicetak tebal, penulisannya juga menggunakan huruf kapital.

Program ini adalah modifikasi dari program 1.1, di mana ada penambahan 1
struktur dan 2 pemanggilan prosedur baru. Struktur baru yang ditambahkan adalah
blok var pada baris ke-3, yang menandakan deklarasi variabel.
Variabel adalah tempat dalam memori yang bisa kita baca atau tulis.
Sebelum bisa digunakan, variabel HARUS dideklarasikan17 terlebih dahulu (Lihat
kembali bagan 1.1 sebagai referensi bagaimana variabel dideklarasikan). Variabel
17

Beberapa bahasa pemrograman memperbolehkan penggunaan variabel tanpa deklarasi, misalnya

Ruby & Lua

19

dalam program ini berjumlah 1, bernama Nama dan bertipe string. Tipe string
dapat memiliki batas maksimum, yang jika tidak ditulis dianggap 255. Cara
membatasi panjang string adalah dengan menuliskan sebuah Integer non-negatif
dalam kurung siku setelah kata string (Misalnya var s: String[10]).
Kemudian, pada baris ke-6 terdapat pemanggilan prosedur Write ketimbang
WriteLn. Hal ini dimaksudkan agar tidak terjadi penambahan baris setelah
pencetakan.
Baris berikutnya, terdapat pemanggilan prosedur ReadLn. Ini adalah
prosedur internal lain yang melakukan hal yang berkebalikan dari WriteLn, yaitu
membaca masukan dari pengguna. Masukan dapat berupa apa saja, dan diakhiri
dengan Enter. Masukan yang diterima ReadLn selalu bertipe string. Argumen
yang dapat kita berikan harus bertipe Char18, Integer, Real, String atau PChar
(tipe data PChar akan dibahas kemudian). Jika variabel yang kita berikan sebagai
argumen untuk ReadLn bukan string, maka akan diubah ke tipe yang sesuai.
Setelah prosedur selesai, variabel Nama akan berisi masukan dari pengguna (tidak
termasuk Enter). Baris berikutnya mencetak Halo, diikuti dengan ISI dari
variabel Nama (plus ! untuk menandakan kalimat sapaan). Contoh jalannya
program:
> Halo2.exe
> Siapa nama Anda? Mario
> Halo, Mario!

> Halo2.exe
> Siapa nama Anda? 255
> Halo, 255!

Variabel bertipe string bisa memuat apa saja, bahkan ekspresi matematika.
Karena itu, tidak akan terjadi error apa-apa. Namun, ekspresi tersebut akan ditulis
persis seperti kita menulisnya ketimbang hasil perhitungannya.

Kuis:

18

Char adalah tipe data dasar yang membentuk String. Faktanya, String adalah untaian Char.

20

Mengapa ekspresi matematika yang kita tulis tersebut tidak dievaluasi terlebih
dahulu sebelum dicetak?

Masukan dengan kemungkinan error

Modifikasi program 3.1 hingga menjadi program 3.2. Lalu seperti biasa,
kompilasi dan jalankan. Ikuti dan isilah dengan logis. Misalnya:
> Halo3.exe
> Siapa nama Anda? Mario

1
2
3
4
5
6
7
8
9
10
11
12
13

program Halo3;
var
Nama: String;
Umur: Byte;
begin
Write('Siapa nama Anda? ');
ReadLn(Nama);
WriteLn('Halo, ',Nama,'!');
Write('Berapa umur Anda? ');
ReadLn(Umur);
WriteLn('Tidak disangka umur Anda ',Umur,' tahun!');
end.

Program 3.2 Masukan dengan kemungkinan error

> Halo, Mario!
> Berapa umur Anda? 20
> Tidak disangka umur Anda 20 tahun!

Sekarang, jalankan lagi dan ketika program bertanya tentang umur, coba jawab
dengan karakter alfabet atau suatu kalimat. Misalnya:
> Berapa umur Anda? Nggak tahu

Anda mungkin akan mendapatkan:

Runtime error 106 at $00401424
$00401424
$004069F0

atau sejenisnya. Menurut dokumentasi Free Pascal, Runtime error19 106 berarti
Invalid numeric format. Yaitu error yang terjadi ketika program meminta angka
19

Error yang terjadi ketika program sedang berjalan. Error semacam ini lebih sulit ditangani
ketimbang compile error, karena kemunculannya bisa tidak terduga

21

sebagai masukan, namun yang terbaca adalah karakter non-angka. Error ini dipicu
oleh kesalahan pada ReadLn(Umur) di mana Umur didefinisikan sebagai variabel
bertipe Byte, namun masukan yang kita berikan adalah Nggak tahu (atau
masukan non-angka lainnya) yang tidak dapat direpresentasikan nilainya dalam
Byte.

Lalu, bagaimana kita mengatasi error di atas? Tidak mungkin kita bisa
memastikan bahwa masukan yang diberikan pengguna selalu benar. Setelah
mempelajari loop (dan fungsi), cobalah untuk mengatasinya. Sampai saat itu,
pastikan saja bahwa masukan yang diberikan selalu benar.

22

Pemberian Nilai
Pemberian nilai pada saat eksekusi
Selain melalui masukan, variabel dengan tipe data tertentu dapat kita beri
nilai secara eksplisit. Yang termasuk kategori ini adalah seluruh tipe data dasar
(Integer, Real, Char, dan Boolean20) dan beberapa tipe terstruktur (String, PChar,
Set21). Operator pemberian nilai dalam bahasa Pascal adalah := (tanpa kutip),
jangan tertukar dengan = yang merupakan operator relasi). Program 4.1 berikut
menunjukkan pemberian nilai yang valid dalam Pascal.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

program BeriNilai;
var
i: Integer;
r: Real;
c: Char;
b: Boolean;
s: String;
p: PChar;
sb: set of Byte;
begin
i:=10;
r:=3.14;
c:='a';
b:=false;
s:='aku';
p:='aku';
sb:=[1,2,5];
end.

Program 4.1 Pemberian nilai pada variabel

Cobalah mengubah-ubah nilai di atas, bila Anda mendapat compile error, periksa
apakah nilai yang Anda berikan memiliki tipe data yang sesuai dengan
variabelnya. Untuk sementara, abaikan dahulu Boolean, PChar, dan Set.

20

Tipe data yang hanya memiliki dua nilai, yaitu benar (true) atau salah (false).
Tipe data ini sangat berguna dalam menyelesaikan masalah yang berkaitan dengan himpunan,
baik dalam matematika maupun masalah umum.
21

23

Pemberian nilai tidak harus berupa nilai mutlak, namun dapat juga berupa
ekspresi. Sebagai contoh, lihat program 4.2.

1
2
3
4
5
6
7
8
9
10
11
12
13
14

program BeriNilai2;
var
i: Integer;
r: Real;
c: Char;
s: String;
begin
i:=1+2*3-4;
r:=(5+6)/7;
c:=Chr(65);
s:='Nama'+' saya '+'Joko';
end.

Program 4.2 Pemberian nilai dengan ekspresi

Pemberian nilai pada saat deklarasi (inisialisasi)

Selain saat eksekusi, kita juga dapat memberikan nilai pada saat deklarasi
variabel (atau disebut juga inisialisasi). Kebalikan dari sebelumnya, tipe data
Array (larik) dan Record (rekaman) dapat diinisialisasi. Berikut contoh program
yang melakukan inisialisasi variabel.

1
2
3
4
5
6
7
8
9
10
11
12
13
14

program BeriNilai2;
var
i: Integer = 1;
r: Real = 2.5;
c: Char = 'c';
s: String = 'Nama saya Joko';
a: array [1..3] of Byte = (1,3,6);
r: record
x,y: Byte;
end = (x:1;y:2);
begin
end.

Program 4.3 Pemberian nilai melalui inisialisasi

24

Sekali lagi, untuk sementara abaikan dahulu tipe data Array dan Record. Program
di atas hanya untuk menunjukkan bahwa tipe data terstruktur dapat juga
diinisialisasi.
Tugas 1
Buatlah sebuah program yang meminta masukan 5 buah variabel bertipe
ShortInt, kemudian tuliskan nilai masing-masing, jumlah, dan rata-ratanya!

Tuliskan dengan rapi (rata kiri-kanan dan = yang berada pada satu kolom) di
mana untuk rata-rata, tuliskan 3 angka desimalnya! Contoh keluaran:
> Angka 1

10

> Angka 2

-15

> Angka 3

-7

> Angka 4

22

> Angka 5

> Jumlah

13

> Rata-rata =

2.600

Asumsikan masukan memiliki jangkauan -100 sampai 100.

25

Perintah Bercabang
Dalam program komputer, tidak seluruh perintah yang kita tulis harus
dijalankan. Ada kalanya, kita perlu mengeksekusi perintah hanya apabila suatu
kondisi dipenuhi. Hal ini dapat dilakukan dengan perintah bercabang (branching).
Dalam bahasa Pascal, terdapat dua perintah bercabang, yaitu if dan case.

if ... then ... else

Perhatikan program 5.1 berikut.

1
2
3
4
5
6
7
8
9
10
11
12
13

program IfThenElse;
var
b: Byte;
begin
Write('Berapa 1+1? ');
ReadLn(b);
if b=2 then
WriteLn('Benar!')
else
WriteLn('Salah!');
end.

Program 5.1 Perintah bercabang ifthenelse

Fokuskan perhatian Anda pada baris ke-8 sampai 11. Alur program pada bagian
tersebut dapat dijelaskan sebagai berikut:
1.

Periksa ekspresi boolean pada bagian if (dalam hal ini, b=2)

2.

Jika bernilai true, lakukan perintah pada bagian then (dalam hal ini,
WriteLn('Benar!'))

3.

Jika bernilai false, lakukan perintah pada bagian else (dalam hal ini
WriteLn('Salah!'))

Ekspresi boolean merupakan ekspresi yang hanya mengembalikan nilai

true

(benar) atau false (salah). Ekspresi ini dapat diperoleh dengan

menggunakan operator relasi (lihat tabel 2.1) dan operator logika. Yang termasuk

26

operator logika pada Pascal adalah and, or, not, dan xor. Pascal menggunakan
ke-4 operator (sekaligus kata kunci) tersebut dalam dua konteks yang berbeda,
yaitu sebagai operator logika dan operator bitwise (dipelajari kemudian), namun
dengan tingkatan yang sama. Jadi, tingkatan operator pada tabel 2.1 berlaku juga
di sini. Operasi logika dalam pemrograman sama dengan operasi logika pada
matematika. Tabel 3.1 menunjukkan tabel kebenaran dalam operasi logika.

AND benar salah

OR

benar

salah

XOR benar

benar benar salah

benar benar benar

benar

salah

salah benar

salah benar

salah salah

salah

salah

salah benar
salah

Tabel 3.1 Tabel kebenaran operasi logika

Untuk operasi not, tinggal balikkan saja nilainya (benar > salah, salah > benar).
Kembali ke ekspresi boolean, ekspresi ini bisa diberikan sebagai nilai untuk
variabel bertipe boolean.

Catatan
Hati-hati saat melakukan operasi boolean yang rumit! Perhatikan bahwa tanda
kurung ( ) memiliki tingkatan tertinggi dari semua operator, diikuti operator
logika, dan yang terrendah operator relasi. Maka, terjemahan yang benar dari a
kurang dari 5 atau a lebih dari 10 adalah (a<5) or (a>10). Jika Anda hanya
menulis a<5 or a>10, kompilator akan melihatnya sebagai a<(5 or a)>10 yang
akan mengakibatkan compile error.

Setelah mempelajari ekspresi boolean, bentuk perintah bercabang if dapat

dengan mudah dipahami. Kembali ke program, bagian else tidak harus ada.
Bagian tersebut diperlukan jika percabangan memiliki perintah alternatif. Sebagai
contoh, misalkan jika pengguna memberi masukan yang salah, maka program

27

akan memberi nilai yang telah ditentukan (default). Contohnya dapat dilihat pada
program 5.2.

program IfTanpaElse;

1
2
3
4
5
6
7
8
9
10
11

var
b: Byte;
begin
Write('Masukkan satu angka antara 1 s/d 5 (default: 1): ');
ReadLn(b);
if (b<1) or (b>5) then b:=1;
WriteLn('Angka yang Anda masukkan adalah ',b);
end.

Program 5.2 If tanpa else

Gunakan ekspresi boolean yang telah Anda pelajari untuk memahami program ini.
Kembali ke program 5.1, perhatikan pada baris ke-9 bahwa tidak ada titik koma
pada akhir baris. Hal ini dikarenakan konstruksi if then else merupakan
satu kesatuan.
Perintah yang terdapat pada bagian then dan else pada dasarnya tidak
dapat berjumlah lebih dari satu. Namun, kita dapat memberikan lebih dari satu
perintah dengan menggunakan kalimat gabungan (compound statement) atau yang
sebelumnya kita sebut blok, yaitu berupa kumpulan kalimat yang dilingkupi oleh
begin dan end. Sebagai contoh, lihat program 5.3.
Konstruksi ini dapat pula dikumpulkan (nested), artinya pada bagian then
maupun else, perintah yang diberikan dapat berupa if then else lagi.
Anda diberikan kebebasan untuk membuat contoh programnya.

Kuis:
1.

Apa hasil dari true and not false or true xor false?

2.

Bagaimana kompilator melihat ekspresi tersebut?

28

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

program IfThenElse2;
var
b: Byte;
begin
Write('Berapa 1+1? ');
ReadLn(b);
if b=2 then begin
WriteLn('Benar!');
WriteLn('Jawabannya ',b);
end else begin
WriteLn('Salah!');
WriteLn('Jawaban yang benar ',b);
end;
end.

Program 5.3 If dengan compound statement

Catatan
Hati-hati pada penggunaan nested if then else! Perhatikan potongan
program berikut:
if a then
if b then
LakukanSesuatu
else
LakukanYangLain;

Meskipun kelihatannya else merupakan alternatrif dari if a then, namun

sebenarnya kompilator melihatnya sebagai:
if a then
if b then
LakukanSesuatu
else
LakukanYangLain;

Aturan sebenarnya dalam hal ini adalah else dipasangkan pada if pertama yang
belum dipasangkan. Jika Anda ingin kode berjalan seperti pada bentuk yang
pertama, maka pemberian begin end pada bagian then dari if yang pertama
wajib dilakukan. Saat Anda ragu, sebaiknya tuliskan saja. Dengan aturan tersebut,
maka potongan program yang benar adalah:

29

if a then begin
if b then
LakukanSesuatu;
end else
LakukanYangLain;

case ... of
Perintah bercabang kedua adalah case of. Perhatikan contoh program
berikut.

1
2
3
4
5
6
7
8
9
10
11
12
13
14

program CaseOf;
var
Sudut: Word;
begin
Write('Berapa besar sudut pada segitiga sama sisi? ');
ReadLn(Sudut);
case Sudut of
0..59: WriteLn('Terlalu kecil!');
60
: WriteLn('Benar!');
else
WriteLn('Terlalu besar!');
end;
end.

Program 5.4 Perintah bercabang caseof

Perhatikan baris 8 12! Cara kerja case of pada program tersebut kurang
lebih sebagai berikut:
1. Periksa nilai ekspresi di antara kata kunci case dan of (dalam program: nilai
variabel Sudut)
2. Periksa nilai di antara kata kunci of dan simbol titik dua (disebut kasus, dalam
program: 0..59). Jika tipenya berupa:
-

Nilai ordinal22, bandingkan nilai pada bagian 1 dengan nilai tersebut

(menggunakan operator =)

22

Tipe data yang banyaknya bisa dihitung dan nilai-nilainya bisa diurutkan, memiliki nilai terkecil
dan juga nilai terbesar

30

Subjangkauan23 (subrange), tentukan apakah nilai pada bagian 1

termasuk di dalamnya (menggunakan operator in)

3. Jika hasil perbandingan bernilai true, lakukan perintah setelah titik dua di
belakang nilai yang tersebut. Jika false, ulangi langkah 2 untuk nilai-nilai
berikutnya (dalam program: 60)
4. Jika hasil perbandingan selalu false dan pada bagian terakhir ada kata kunci
24

else (atau otherwise ) pada bagian terakhir, langsung lakukan perintah

yang ada setelahnya

if then else dan case of sebenarnya mirip, berikut adalah

kesamaan-kesamaan di antara keduanya.

1. Perintah untuk setiap kasus pada dasarnya hanya dapat menampung satu
kalimat. Namun sama seperti pada if, Anda dapat menggunakan kalimat
gabungan untuk memberikan perintah yang memiliki lebih dari satu kalimat.
2. Sama seperti if, konstruksi case dapat dikumpulkan. Artinya dalam salah satu
atau beberapa (atau bahkan semua) kasusnya, perintah yang diberikan berupa
case juga.

Selain kesamaan, tentu ada perbedaan (kekurangan/kelebihan) di antara

keduanya. Kekurangan case of adalah ekspresi yang dapat digunakan terbatas
pada tipe ordinal (dan subjangkauan pada setiap kasusnya), karena pembandingan
hanya dilakukan dengan menggunakan operator = (dan in untuk subjangkauan).
Pada if, seluruh operator relasi dapat digunakan. Sedangkan kelebihan case
of dibandingkan if then else secara umum ada 2, yang pertama adalah

penulisan kode yang lebih pendek. Hal ini dikarenakan ekspresi yang akan
dibandingkan (yang terletak diantara case dan of) hanya perlu ditulis 1 kali.
Kelebihan yang kedua dan lebih mencolok adalah ketika ekspresi yang akan
dibandingkan bukan ekspresi sederhana. Perhatikan kedua potongan program
berikut.

23

Sub-tipe dari suatu tipe ordinal. Didefinisikan sebagai batas bawah dan batas atas dari suatu
jangkauan nilai
24
Kata kunci ini didefinisikan dalam Extended Pascal, namun sebagian besar kompilator lebih
memilih menggunakan else walaupun otherwise tetap diterima

31

if i*(5+4) div 3=1 then

LakukanA
else if i*(5+4) div 3=2 then
LakukanB
else if i*(5+4) div 3 in [3..5] then
LakukanC
else

case i*(5+4) div 3 of

1

: LakukanA;

: LakukanB;

3..5: LakukanC;
else

LakukanD;

end;

LakukanD;

Kedua potongan program tersebut ekivalen, namun ada yang sedikit berbeda
dalam kerjanya. Pada potongan program yang pertama, ekspresi i*(5+4) div 3
harus dihitung 3 kali, sementara pada potongan program yang kedua, hanya 1 kali.
Hal ini akan mempengaruhi waktu eksekusi program. Program yang lebih cepat
tentu lebih baik (asalkan hasilnya tetap benar).

Bilangan Acak
Pernahkah Anda bermain game kartu? Apakah setiap kali bermain, Anda
selalu mendapatkan susunan kartu yang sama? Tentu tidak, bukan? Bagaimana
cara komputer melakukannya?
Kompilasi dan jalankan program berikut, Anda akan mendapat hasil yang
berbeda tiap kali menjalankannya!

1
2
3
4
5
6
7
8
9
10
11
12
13

program Acak;
var
b: Byte;
begin
Randomize;
WriteLn(
Random,' ',
// 0.0 .. 0.999...9
Random(100)+1,' ', // 1 .. 100
Random(256)
// 0 .. 255
);
end.

Program 6.1 Bilangan acak

Komputer sebenarnya tidak memiliki kemampuan untuk menghasilkan bilangan

acak. Setiap bahasa pemrograman memiliki cara masing-masing untuk
melakukannya. Dari sekian banyak algoritma, yang paling sering digunakan
adalah dengan melakukan lompatan dari satu lokasi memori ke lokasi yang lain
dan mengambil nilai yang terdapat di sana. Jarak lompatan ditentukan oleh seed
yang kita tentukan sendiri. Namun, program akan menghasilkan keluaran yang
sama jika seed-nya sama. Masalah ini diatasi dengan menggunakan timer
(biasanya bagian detik saja) sebagai seed sebelum melakukan lompatan. Dalam
Pascal, hal ini dapat dilakukan oleh prosedur Randomize. Sedangkan lompatan
dilakukan oleh fungsi Random yang meminta 1 argumen bertipe Integer, dan
menghasilkan nilai antara 0 dan argumen tersebut (termasuk 0, tidak termasuk
argumen). Atau fungsi alternatif yang memiliki nama yang sama namun tidak

33

meminta argumen, menghasilkan nilai Real antara 0 dan 1 (termasuk 0, tidak

termasuk 1).

Tugas 2
1. Buatlah sebuah program yang menanyakan perhitungan matematika sederhana
(penjumlahan, pengurangan, perkalian, pembagian) dengan dua operand (batas
nilai operand 1 100). Kemudian, berikan tanggapan atas jawaban pengguna
(respon benar jika jawabannya benar dan juga sebaliknya) beserta jawaban
yang benar. Soal yang diberikan tidak boleh sama setiap kali program
dijalankan!
Keterangan: Untuk pembagian, ambil nilai bulatnya saja. Misal: 7 / 3 = 2
2. Jika Anda menggunakan konstruksi if, buatlah versi case-nya! Sebaliknya
jika Anda menggunakan case, buatlah versi if-nya!

34

Pengulangan 1: Iterasi
Apakah Anda pernah merasa bahwa program yang Anda buat sebenarnya
memiliki langkah-langkah yang berulang? Misalnya, bagaimana Anda mencetak
daftar 2n untuk 1 < n < 5? Asumsikan Anda menggunakan fungsi Power dari unit
Math, mungkin Anda akan menuliskan:

1
2
3
4
5
6
7
8
9
10
11
12
13

program DuaPangkatN;
uses
Math;
begin
WriteLn(Power(2,1));
WriteLn(Power(2,2));
WriteLn(Power(2,3));
WriteLn(Power(2,4));
WriteLn(Power(2,5));
end.

Program 7.1 Dua pangkat n tanpa pengulangan

Bagaimana jika kebutuhan Anda meningkat? Misalkan sekarang 0 < n < 99. Jika
Anda melakukan hal yang sama seperti di atas, berarti Anda harus menambahkan
95 baris lagi! Program Anda akan menjadi panjang dan sulit dibaca. Belum lagi
kemungkinan salah ketik yang sangat besar. Bagaimana caranya supaya
perubahan yang Anda lakukan seminimal mungkin? Dengan pengulangan
(looping), hal ini dapat dengan mudah dilakukan. Pengulangan dibagi menjadi
dua, yaitu iterasi dan rekursi. Dalam bab ini, kita akan mempelajari iterasi atau
pengulangan iteratif. Rekursi akan kita pelajari dalam prosedur dan fungsi.
Dalam pemrograman, dikenal tiga jenis pengulangan iteratif, yaitu:
1. Pengulangan tetap (jumlah pengulangan dapat dihitung dahulu)
2. Pre-test (pemeriksaan dilakukan sebelum pengulangan)
3. Post-test (pemeriksaan dilakukan setelah pengulangan)

35

Pascal mengimplementasikan ketiga jenis pengulangan tersebut dengan tiga

konstruksi berbeda. Kita akan mempelajarinya satu per satu.

for .. to / downto .. do
Pengulangan tetap dalam Pascal diwakili oleh konstruksi for, di mana
pengulangan dikendalikan oleh sebuah variabel (disebut loop variable atau
index25) mulai dari suatu nilai awal hingga nilai akhirnya. Kita akan menggunakan
permasalahan sebelumnya sebagai contoh.

1
2
3
4
5
6
7
8
9
10
11
12

program DuaPangkatNFor;
uses
Math;
var
n: Byte;
begin
for n:=1 to 5 do
WriteLn(Power(2,n));
end.

Program 7.2 Dua pangkat n dengan pengulangan tetap

Sekarang, Anda hanya perlu mengganti nilai n pada bagian for untuk
memperoleh hasil yang berbeda. Pada permasalahan di atas, ketika n berubah dari
1 < n < 5 ke 0 < n < 99, yang perlu Anda lakukan hanya mengganti
for n:=1 to 5 do

dengan
for n:=0 to 99 do

Cara kerja for kurang lebih sebagai berikut:

1. Inisialisasi index dengan nilai awalnya
2. Periksa apakah nilai index sekarang lebih besar dari nilai akhirnya, jika:
a.

Ya, hentikan iterasi

25

Hal ini dikarenakan for sering digunakan untuk menginisialisasi array yang sulit jika
diinisialisasi secara manual. Misalnya, untuk membuat tabel trigonometri.

36

b.

Tidak, jalankan perintah setelah kata kunci do lalu tambahkan nilai index
sebanyak 1

3. Ulangi langkah ke-2 dan 3 hingga iterasi selesai (kasus 2a)

Catatan
Free Pascal tidak mengizinkan adanya kalimat yang mengubah nilai index dalam
perintah setelah do. Hal ini akan menjadikan pengulangan menjadi tidak tetap
sehingga tidak jelas kapan iterasi akan selesai.
Turbo Pascal dan beberapa kompilator Mac Pascal membolehkan hal ini,
walaupun dianggap merusak struktur for.

Bagaimana jika hasil yang ingin diperoleh disusun terbalik? Untuk tujuan
ini, Pascal memiliki tipe for yang nilai index-nya berkurang dari satu iterasi ke
iterasi berikutnya.
Sama seperti konstruksi Pascal yang lain, for dapat dikumpulkan dan
perintah setelah do dapat berupa kalimat gabungan.

while .. do
Pre-test dalam Pascal diwakili oleh konstruksi while. Konstruksi ini hanya
dikendalikan oleh kondisi yang diberikan, tanpa variabel tambahan. Program
sebelumnya dapat pula dibuat versi while-nya seperti pada program 7.3 berikut.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

program DuaPangkatNWhile;
uses
Math;
var
n: Byte;
begin
n:=1;
while n<>5 do begin
WriteLn(Power(2,n));
Inc(n); // Tambahkan nilai n sebanyak 1
end;
end.

37

Program 7.3 - Dua pangkat n dengan pre-test

Cara kerjanya sangat sederhana:

Periksa kondisi di antara kata kunci while dan do, jika hasilnya:
a.

False, hentikan iterasi

b.

True, lakukan perintah setelah kata kunci do kemudian lakukan lagi langkah
di atas

Perhatikan bahwa while tidak akan mengubah kondisi yang diberikan secara
otomatis. Kita harus secara eksplisit mengubahnya dalam salah satu kalimat dalam
perintah setelah kata kunci do. Maka pada program di atas, diperlukan
penambahan nilai n (melalui Inc(n)) pada baris ke-12.

Catatan
Ketika melakukan konversi antara for dan while, perhatikan bahwa for
menambah nilai index SETELAH melakukan perintah. Untuk itu, pada while
penambahan index harus selalu dilakukan pada kalimat terakhir.

repeat .. until
Jenis iterasi yang terakhir, yaitu post-test, dalam Pascal diwakili oleh
konstruksi repeat. Konstruksi ini mirip dengan while, hanya saja terdapat dua
perbedaan dari while, yaitu:
1. Tidak diperlukan compound statement untuk perintah yang memiliki lebih dari
satu kalimat. Hal ini dikarenakan repeat until sendiri sudah membentuk
blok (anggap repeat sebagai begin dan until sebagai end)
2. Cara kerjanya terbalik dari while (pemeriksaan dilakukan setelah perintah
dieksekusi)
Untuk lebih memahami, berikut cara kerja repeat.
Lakukan perintah di antara kata kunci repeat dan until, kemudian periksa
kondisi setelah kata kunci until. Jika hasilnya:

38

a. False, ulangi langkah di atas

b. True, hentikan iterasi
Perhatikan bahwa repeat akan melakukan perintah hingga kondisi terpenuhi,
sementara while akan melakukan perintah hingga kondisi TIDAK terpenuhi. Satu
hal lagi yang perlu diperhatikan adalah karena repeat melakukan pemeriksaan
setelah melakukan perintah, maka setidak-tidaknya perintah akan dilakukan satu
kali. Sementara pada while, perintah bisa saja sama sekali tidak dilakukan.
Program yang sama dengan konstruksi repeat dapat dilihat pada program 7.4
berikut.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

program DuaPangkatNRepeat;
uses
Math;
var
n: Byte;
begin
n:=1;
repeat
WriteLn(Power(2,n));
Inc(n); // Tambahkan nilai n sebanyak 1
until n=5;
end.

Program 7.4 Dua pangkat n dengan post-test

Kuis:
1. Jika mengikuti cara kerja masing-masing, manakah yang hubungannya lebih
dekat antara for while dan for repeat? Jelaskan!
2. Dari contoh di atas, for selalu dapat direpresentasikan sebagai while dan/atau
repeat. Apakah hal yang sama berlaku untuk kebalikannya? Mengapa?

39

Tugas 3
Iterasi merupakan elemen penting pemrograman imperative. Kuasailah dengan
baik dan ujilah dengan mengerjakan tugas berikut. Buatlah program yang
meminta input sebuah Byte kemudian buatlah struktur-struktur berikut
berdasarkan input tersebut!
a. Panah
Input 2:

Input 3:

Input 4:

*
**
*

*
**
***
**
*

*
**
***
****
***
**
*

Input 2:

Input 3:

Input 4:

**
**

***
* *
***

****
* *
* *
****

Input 2:

Input 3:

Input 4:

*
**
*

*
**
***
**
*

*
**
***
****
***
**
*

Input 2:

Input 3:

Input 4:

**
**

* *
*
* *

b. Kotak

c. Berlian (wajik)

d. Silang

*
**
**

* *
Jika Anda telah berhasil dengan satu jenis iterasi, coba gunakan yang lain. Untuk
lebih menguji kemampuan Anda, gabungkan antara dua atau lebih jenis iterasi.

40

Ujian 1
Buatlah program tebak angka dengan spesifikasi sebagai berikut:
1. Program meminta nama pemain
2. Program meminta nilai minimum dan maksimum tebakan (antara 1 1000).
Jika nilai yang dimasukkan diluar jangkauan atau nilai minimum lebih besar
dari maksimum, beri pesan kesalahan dan ulangi permintaan
3. Program meminta berapa kali pemain boleh menebak sebelum dinyatakan
gagal (minimum 3 kali, maksimal 15 kali). Jika nilai yang dimasukkan diluar
jangkauan, beri pesan kesalahan dan ulangi permintaan
4. Nilai tebakan harus berbeda setiap kali program dijalankan
5. Untuk setiap tebakan, tuliskan banyaknya kesempatan yang masih tersisa
6. Untuk setiap tebakan, jika nilai yang dimasukkan pemain:
a.

> nilai tebakan, beri pesan bahwa nilai yang dimasukkan terlalu besar
kemudian kurangi kesempatan yang tersisa

b.

< nilai tebakan, beri pesan bahwa nilai yang dimasukkan terlalu kecil
kemudian kurangi kesempatan yang tersisa

c.

= nilai tebakan, akhiri permainan dengan menampilkan pesan yang berisi

nilai tebakan yang benar, berapa kali pemain menebak, nama pemain,
dan grade-nya

d.

Di luar jangkauan, beri pesan kesalahan (JANGAN kurangi kesempatan!)

7. Grade ditentukan dari dari kesempatan yang tersisa, jika

a.

> nilai yang dimasukkan (dibulatkan*) di awal permainan, A

b.

> nilai yang dimasukkan (dibulatkan) di awal permainan, B

c.

> nilai yang dimasukkan (dibulatkan) di awal permainan, C

d.

< nilai yang dimasukkan (dibulatkan) di awal permainan, D

8. Jika kesempatan=0, akhiri permainan dengan menampilkan pesan yang berisi

nilai tebakan yang benar dan nama pemain

*: Gunakan fungsi internal Round untuk membulatkan

41

Subprogram
Setelah mempelajari dasar-dasar pemrograman imperative, sekarang kita
akan menggabungkannya dengan konsep yang menjadi basis pemrograman
prosedural, yaitu subprogram, dalam bentuk prosedur dan fungsi.

Prosedur
Prosedur merupakan langkah pertama dalam modularisasi26. Program dibagi
menjadi bagian-bagian kecil yang saling berhubungan, namun dengan tugas yang
independen, sehingga (program utama) tidak akan menjadi terlalu panjang, karena
sebagian besar hanya merupakan pemanggilan prosedur. Contoh penggunaan
prosedur dapat dilihat pada program berikut.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

program Prosedur;
uses
SysUtils, // DateOf, Now
DateUtils; // EncodeDateTime, YearsBetween
procedure HitungUmur(Tgl,Bln: Byte; Thn: Word);
begin
WriteLn('Umur Anda sekarang ',
YearsBetween(
EncodeDateTime(Thn,Bln,Tgl,0,0,0,0),
DateOf(Now)
),
' tahun.');
end;
var
Tanggal,Bulan: Byte;
Tahun: Word;
begin
Write('Tanggal, bulan, dan tahun berapa '+
'Anda lahir (misal: 25 5 1988)? ');
ReadLn(Tanggal,Bulan,Tahun);
HitungUmur(Tanggal,Bulan,Tahun);
end.

Program 8.1 Prosedur menghitung umur

26

Teknik pembuatan program yang mudah dipertahankan maupun dikembangkan

42

Apa keuntungan penggunaan prosedur dalam program ini? Yang paling

mencolok adalah ketika hasil perhitungan umur salah, Anda tidak perlu
memeriksa seluruh program, namun cukup bagian yang menghitungnya, yaitu
prosedure HitungUmur.
Pembuatan prosedur dimulai dengan header berupa kata kunci procedure,
diikuti nama prosedur, lalu jika memiliki argumen / parameter, tambahkan dengan
daftar parameter dalam tanda kurung, diakhiri dengan titik koma. Nama prosedur
dan argumen harus merupakan pengenal yang valid. Setelah itu, diikuti body dari
prosedur dalam blok begin end;. Body berisi perintah perintah seperti dalam
program. Diantara header dan body, Anda dapat mendeklarasikan variabel,
konstanta, atau apapun yang bisa dideklarasikan dalam program (kecuali klausa
uses27).

Pemanggilan prosedur dilakukan dengan menuliskan nama prosedur, diikuti

parameter parameter yang diminta (Anda sudah mempelajarinya ketika
menelaah WriteLn (Bab Halo, Dunia!), lihat lagi jika lupa).

Argumen / Parameter
Argumen / parameter merupakan perwakilan dari nilai yang diberikan saat
pemanggilan prosedur. Sebagai contoh, kita dapat memanggil prosedur
HitungUmur seperti di bawah ini:
HitungUmur(25,5,1998);
Ketika prosedur dipanggil, nilai 25 akan dikopi ke Tgl, 5 ke Bln, dan 1998 ke
Thn. Bagaimana dengan contoh di atas? Sama saja, nilai yang terdapat pada
variabel Tanggal dikopi ke Tgl, Bulan ke Bln, dan Tahun ke Thn. Parameter dapat
memiliki nama yang sama dengan variabel yang digunakan sebagai parameternya.
Sebagai contoh, penulisan ulang prosedur HitungUmur seperti di bawah ini valid
dan tidak memerlukan penggantian nama variabel pada program utama. Hal ini
yang disebut dengan aturan ruang lingkup atau scope.

27

Hal ini dikarenakan penggunaan pustaka berlaku secara global dalam program

43

procedure HitungUmur(Tanggal,Bulan: Byte; Tahun: Word);

begin
WriteLn('Umur Anda sekarang ',
YearsBetween(
EncodeDateTime(Tahun,Bulan,Tanggal,0,0,0,0),
DateOf(Now)
),
' tahun.');
end;

Parameter terbagi dalam beberapa jenis, namun yang paling umum

digunakan hanya 3, yaitu parameter nilai, parameter variabel, dan parameter
konstan. Ketiganya akan dijelaskan pada subbab Penyampaian Parameter.

Prosedur di Dalam Prosedur

Berbeda dengan beberapa bahasa pemrograman lain, Pascal mendukung
deklarasi prosedur di dalam prosedur (nested procedure). Hal ini dapat membantu
jika body dari prosedur terlalu panjang, sehingga akan lebih baik jika dibagi
dalam subprosedur subprosedur. Contohnya dapat dilihat pada program berikut.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

program Nested;
procedure Outer(s: String);
procedure Inner;
begin
WriteLn(s);
end;
begin
Inner;
end;
begin
Outer('Hello');
end.

Program 8.2 Prosedur di dalam prosedur

Prosedur dalam (disebut child procedure) dapat mengakses parameter

prosedur luar (disebut parent procedure). Sehingga, dalam program ini
pengaksesan s oleh Inner valid walaupun s adalah parameter dari Outer. Selain

44

parameter, seluruh definisi yang ditulis dalam prosedur luar sebelum deklarasi
prosedur dalam dapat diakses oleh prosedur dalam. Misalnya, jika kita membuat

procedure Outer;
var
a: Byte;
procedure Inner;
begin
a:=5;
end;
var
b: Byte;
begin
Inner;
end;

Maka, Inner dapat mengakses a tapi tidak b.

Catatan
Jika Anda perhatikan baik-baik, maka program sebenarnya adalah nested
procedure juga. Perbedaannya hanya pada penggunaan klausa uses, global
directive28, dan deklarasi parameter.

Aturan Ruang Lingkup

Perhatikan program di bawah ini baik-baik. Menurut Anda, bagaimana
keluaran dari program tersebut? Bandingkan dengan hasil sebenarnya. Dalam
program, seringkali kita memerlukan nama variabel yang umum digunakan,
misalnya i, j, atau k untuk variabel index dari loop for. Hal ini mungkin akan
membingungkan jika Anda menggunakannya baik pada program utama maupun
prosedur prosedur yang terdapat di dalamnya. Untuk itulah diberlakukan aturan
ruang lingkup, agar tidak terjadi tumpang tindih antara variabel variabel
tersebut.

28

Direktive yang yang berlaku dari awal hingga akhir program. Directive akan dijelaskan pada
Bab Kompilasi Kondisional / Preprocessing.

45

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

program Scope;
var
a: Byte;
procedure Outer;
var
a: Byte;
procedure Inner;
var
a: Byte;
begin
a:=3;
WriteLn(a);
end;
begin
a:=2;
WriteLn(a);
Inner;
WriteLn(a);
end;
begin
a:=1;
WriteLn(a);
Outer;
WriteLn(a);
end.

Program 8.3 Penerapan aturan ruang lingkup

Perhatikan bahwa baik program utama, prosedur luar, maupun prosedur

dalam memiliki variabel bernama a dengan tipe Byte. Ingat aturan bahwa
prosedur dalam dapat mengakses variabel prosedur luar (prosedur luar pun dapat
mengakses variabel program utama, karena program utama adalah prosedur luar
bagi prosedur tersebut) asal deklarasinya sebelum deklarasi prosedur dalam. Lalu
bagaimana dengan kasus seperti di atas?
Aturan ruang lingkup menyatakan bahwa ruang lingkup suatu pengenal
(karena hal ini tidak hanya berlaku pada variabel) adalah mulai dari blok ia
dideklarasikan hingga akhir blok tersebut dan blok yang lebih dalam memiliki
prioritas lebih tinggi dari blok luar. Maka, dalam kasus di atas masing-masing
prosedur tidak mengakses variabel milik parent-nya, namun hanya variabel

46

masing-masing. Sehingga perubahan nilai yang terjadi melalui pemberian nilai

hanya berlaku secara lokal (dalam prosedur itu saja).
Aturan ruang lingkup sebenarnya sederhana, namun jika tidak teliti dapat
membuat program Anda tidak berjalan seperti yang diharapkan.

Tugas 4.1
Untuk menguji pemahaman Anda, buatlah prosedur-prosedur berikut:
1.

Prosedur untuk mencetak setiap kata dalam suatu kalimat (1 baris 1 kata) (1
argumen bertipe String)

2.

Prosedur untuk mencetak setiap digit dari suatu bilangan desimal (1 baris 1
digit), dimulai dari digit terakhir (1 argumen bertipe ordinal)

3.

Generalisasikan nomor 1 sehingga dapat memisahkan kata berdasarkan suatu

karakter pembatas!

Penyampaian Parameter
Bagaimana parameter diberikan kepada sebuah prosedur dan apa efeknya
terhadap parameter tersebut baik di dalam prosedur maupun pada ruang lingkup ia
dideklarasikan bergantung pada cara penyampaiannya. Tiga yang paling umum
dan sering digunakan adalah parameter nilai, parameter variabel, dan parameter
konstan.
Parameter nilai (pass by value) menyampaikan parameter dengan cara
mengopi nilai yang akan diberikan ke masing-masing parameter. Dalam prosedur,
parameter ini dapat digunakan maupun diganti-ganti nilainya. Namun, hal ini
tidak akan mempengaruhi nilai aslinya karena yang diganti sebenarnya adalah
kopiannya. Parameter ini tidak memerlukan kata kunci apapun. Program 8.1 dan
8.2 merupakan contoh penggunaan parameter nilai dalam prosedur.
Parameter variabel (pass by reference) menggunakan cara yang relatif sama
dengan parameter nilai, hanya saja yang dikopi bukanlah nilainya, tetapi alamat
dari nilai tersebut. Karena itu, untuk parameter ini kita tidak dapat menggunakan
nilai eksplisit, namun harus dengan variabel sebab nilai eksplisit tidak (selalu)
memiliki alamat dalam memori. Dalam prosedur, penggantian nilai pada

47

parameter mengakibatkan nilai aslinya juga berubah. Karenanya, parameter

variabel biasanya digunakan untuk mengembalikan nilai majemuk (lihat subbab
Fungsi). Untuk menggunakan parameter ini tuliskan kata kunci var sebelum nama
parameter pada header prosedur. Contoh penggunaannya dapat dilihat pada
program 8.4.
Parameter konstan mengindikasikan bahwa nilai yang ada pada parameter
tidak boleh diganti-ganti. Biasanya digunakan jika Anda ingin memastikan bahwa
prosedur yang Anda buat tidak mengubah nilai dari parameter. Pada contoh
HitungUmur di atas, nilai parameter Tgl, Bln, atau Thn bisa saja secara tidak
sengaja kita ubah dan mengakibatkan kesalahan dalam perhitungan umur.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

program PassByRef;
procedure TambahDua(var x: Byte);
begin
x:=x+2;
end;
var
a: Byte;
begin
a:=1;
WriteLn(a); // 3
TambahDua(a);
WriteLn(a); // 5
end.

Program 8.4 Penggunaan parameter variabel

Dengan parameter konstan, hal ini dapat diketahui saat kompilasi sehingga hasil
yang tidak diinginkan dapat dihindari. Parameter ini akan di-pass by value atau dipass by reference tergantung ukurannya. Jika < ukuran pointer29 pada arsitektur
bersangkutan, maka pass by value yang digunakan. Jika sebaliknya, pass by
reference. Pada dasarnya, hal ini hanya untuk mempercepat eksekusi karena pass
by reference lebih ringan (hanya sebesar ukuran pointer). Bagaimanapun, nilai

29

Tipe data terstruktur yang sangat powerful namun juga berbahaya jika tidak digunakan dengan
hati-hati.

48

parameter tersebut tetap tidak boleh diganti-ganti (kecuali dengan trik tertentu).
Untuk menggunakan parameter ini tuliskan kata kunci const sebelum nama
parameter pada header prosedur. Untuk contoh, silakan dicoba sendiri.

Catatan
Dalam Modern Pascal, parameter variabel dan parameter konstan dapat tidak
memiliki tipe (untyped). Hal ini tidak akan dibahas karena merupakan topik yang
cukup advanced, dan penggunaannya pun bisa dibilang sangat jarang karena hal
ini mengurangi keamanan program dalam hal pemeriksaan tipe.

Fungsi
Dalam Pascal penggunaan prosedur sebenarnya lebih natural, namun
diperlukannya variabel sebagai parameter variabel terkadang menjengkelkan
(karena kita mungkin membutuhkan nilai aslinya) dan membuat program menjadi
kurang terbaca. Ditambah lagi, pengembalian nilai tunggal (jauh) lebih sering
terjadi dibandingkan nilai majemuk. Untuk memfasilitasi hal tersebut, dibuatlah
fungsi.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

program Fungsi;
function HitungDigit(l: LongWord): Byte;
begin
HitungDigit:=0;
while l>0 do begin
Inc(HitungDigit);
l:=l div 10;
end;
end;
begin
WriteLn(HitungDigit(256));
// 3
WriteLn(HitungDigit(1234567890)); // 10
end.

Program 8.5 Fungsi penghitung banyak digit suatu desimal

49

Perbedaannya dengan prosedur hanya terletak pada penggunaan kata kunci

function dan adanya deklarasi tipe nilai balikan setelah deklarasi parameter (atau

setelah nama fungsi jika tidak memiliki parameter). Untuk mengembalikan nilai,
dalam body-nya nama fungsi digunakan sebagai variabel. Semua hal yang berlaku
pada prosedur juga berlaku pada fungsi.

Tugas 4.2
Buatlah fungsi-fungsi berikut!
1.

Fungsi penghitung nilai KPK (2 argumen bertipe ordinal, balikan bertipe

ordinal)

2.

Fungsi penghitung nilai FPB (2 argumen bertipe ordinal, balikan bertipe

ordinal)

3.

Fungsi penentu apakah suatu bilangan merupakan bilangan prima (1 argumen

bertipe ordinal, balikan bertipe Boolean)

4.

Fungsi untuk menghitung nilai akar-akar persamaan kuadrat. Kembalikan

nilai false jika diskriminan negatif, true jika sebaliknya (2 argumen bertipe
ordinal, balikan bertipe Boolean)

5.

Fungsi untuk mengonversi bilangan desimal ke biner, oktal, dan heksadesimal

(1 argumen bertipe ordinal, balikan bertipe String)

Bonus:
1.

Modifikasi nomor 1 dan 2 sehingga bisa menghitung untuk 3 bilangan

sekaligus!

2.

Generalisasikan nomor 5 sehingga bisa mengembalikan representasi desimal

dalam basis 2 36!

Referensi Maju
Prosedur / fungsi hanya dapat dipanggil setelah dideklarasikan (sama seperti
variabel). Bagaimana jika Anda memiliki prosedur-prosedur yang saling
memanggil satu sama lain? Prosedur yang lebih dahulu dideklarasikan tidak akan
dapat memanggil prosedur lain setelahnya karena belum dideklarasikan. Masalah

50

ayam dan telur30 ini dapat diselesaikan dengan referensi maju (forward
reference). Perhatikan program 8.6 berikut.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

program FwdRef;
procedure Later(const i: Byte); forward;
procedure Sooner(const i: Byte);
Begin
WriteLn(i);
if i>0 then Later(i-2);
end;
procedure Later(const i: Byte);
Begin
WriteLn(i);
if i>0 then Sooner(i+1);
end;
Begin
Sooner(5);
end.

Program 8.6 Referensi maju untuk prosedur-prosedur yang saling rekursif

Cara menggunakan referensi maju adalah dengan mendeklarasikan header

prosedur tersebut diikuti dengan modifier31 forward, seperti program 8.6 di atas.

Catatan
Free Pascal mengharuskan deklarasi header tersebut sama dengan deklarasi
lengkapnya termasuk parameter dan nilai balikan (untuk fungsi). Hal ini
dikarenakan Free Pascal mendukung function overloading32. Beberapa kompilator
lain (misal: Turbo Pascal) mengizinkan penghapusan daftar parameter saat
deklarasi lengkap.

30

Jawab pertanyaan berikut: Mana yang lebih dahulu ada, ayam atau telur? Masalah yang mirip
dengan pertanyaan tersebut sering disebut masalah ayam dan telur
31
Modifier dapat mengubah sifat fungsi / prosedur. Mulai dari perjanjian pemanggilan, membuat
nama alias, dan lain-lain
32
Deklarasi beberapa fungsi / prosedur dengan nama yang sama namun dengan argumen yang
berbeda

51

Ketika Anda mempelajari bab pemrograman modular, maka setiap fungsi /

prosedur yang dideklarasikan pada bagian interface secara implisit akan
memiliki modifier forward.

52

Pengulangan 2 : Rekursi
Setiap prosedur / fungsi dapat memanggil fungsi lain, maka dapatkah ia
memanggil dirinya sendiri? Hal inilah yang disebut dengan rekursi. Rekursi biasa
dipakai untuk menyelesaikan masalah yang bisa dipecah-pecah menjadi masalah
yang lebih kecil (disebut recursive case) sampai tidak dapat dipecah lagi (disebut
base case). Rekursi merupakan implementasi dari deduksi dalam matematika.
Contoh rekursi yang paling umum adalah fungsi faktorial seperti pada program
9.1 berikut.

1
2
3
4
5
6
7
8
9
10
11
12
13
14

program Rekursi;
function Faktorial(const n: Byte): LongWord;
begin
if n<=1 then
Faktorial:=1
else
Faktorial:=n*Faktorial(n-1);
end;
begin
WriteLn(Faktorial(5)); // 120
end.

Program 9.1 Fungsi rekursif untuk menghitung nilai faktorial

Bagaimana fungsi tersebut bisa dibuat? Definisikan fakta dan aturan tentang
faktorial dari suatu nilai n:
1.

0! = 1! = 1 (dalam program nilai negatif juga dianggap sama)

2.

n! = n*(n-1)!

Dengan adanya fakta (1) dan aturan (2) diatas, kita bisa membuat base case (1)
dan recursive case-nya (2). Bagian if pada program merupakan base case,
sedangkan else merupakan recursive case-nya.
Pada bahasa pemrograman deklaratif, tidak ada loop seperti for, while, dan
repeat. Satu-satunya cara adalah dengan menggunakan rekursi, maka penguasaan

rekursi akan membantu Anda dalam mempelajari bahasa pemrograman tersebut.

53

Pada dasarnya, semua iterasi dapat dibuat versi rekursinya. Perhatikan program
9.2 berikut.

1
2
3
4
5
6
7
8
9

program IterRek1;
var
i: Byte;
begin
for i:=1 to 10 do
WriteLn(i);
end.

Program 9.2a Loop for sederhana

1
2
3
4
5
6
7
8
9
10
11
12
13
14

program IterRek2;
procedure Loop(const Awal,Akhir: Byte);
begin
if Awal<=Akhir then begin
WriteLn(Awal);
Loop(Awal+1,Akhir);
end;
end;
begin
Loop(1,10);
end.

Program 9.2b Versi rekursi dari program 9.2a

Untuk iterasi sederhana seperti ini, rekursi memang terlihat lebih panjang. Namun,
untuk masalah yang lebih rumit rekursi biasanya lebih pendek dari pada iterasi.

Catatan
Hati-hati saat membuat recursive case. Pastikan recursive case tersebut dapat
mencapai base case atau Anda akan mengalami infinite recursion (kemungkinan
ditampilkan sebagai Stack Overflow)! Meskipun secara teori tidak ada batasan,
namun dalam prakteknya nilai suatu variabel selalu memiliki batasan. Pastikan
bahwa nilai yang Anda gunakan tidak overflow (melewati batas jangkauan).

54

Tipe Data Lanjutan

Selain tipe-tipe dasar seperti Integer, Char, dan Boolean, Pascal juga
memiliki tipe data lanjutan, yaitu tipe data yang dapat dibentuk dari satu atau
lebih tipe data dasar atau tipe data lanjutan lainnya. Sebelum mempelajari bab ini,
pastikan Anda sudah cukup menguasai tipe data dasar.

Larik / Array
Larik / Array adalah tipe data yang dapat menampung banyak nilai yang
memiliki tipe dasar yang sama. Larik sering digunakan sebagai tempat
penyimpanan data sementara dalam berbagai proses, misalnya pengurutan dan
pencarian data. Contoh penggunaan larik dapat dilihat pada program 10.1 berikut.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

program TabelKuadrat;
type
TTabelKuadrat = array [1..100] of Word;
var
TK: TTabelKuadrat;
i,n: Byte;
begin
for i:=Low(TK) to High(TK) do
TK[i]:=i*i; // Inisialisasi tabel
ReadLn(n);
WriteLn('Kuadrat dari ',n,' adalah ',TK[n]);
end.

Program 10.1 Larik sebagai tabel kuadrat

Sebelum membahas larik-nya, kita berhadapan dengan elemen baru dari

bahasa Pascal, yaitu definisi tipe. Definisi tipe digunakan untuk membuat tipe
baru, baik sebagai alias untuk tipe yang lama (untuk memperjelas program), atau
untuk penulisan tipe data terstruktur seperti contoh di atas. Definisi tipe ditandai
dengan penggunaan kata kunci type, diikuti oleh nama tipe baru, tanda =,

55

definisinya, dan diakhiri dengan ;. Seperti variabel, lebih dari 1 definisi dapat
ditulis dalam blok type yang sama.
Keuntungan definisi tipe adalah ketika kita akan mengubah elemen tipe
tersebut (misalnya, jangkauan 1..100 diubah menjadi 0..99), kita hanya perlu
mengubah pada bagian definisi tipe saja, tidak perlu untuk setiap deklarasi
variabel. Pada konstruksi program tertentu, definisi tipe merupakan keharusan.
Maka, lebih baik jika Anda selalu menggunakannya untuk mendefinisikan tipe
data terstruktur.
Sebagai perjanjian, setiap definisi tipe sebaiknya diberi prefiks T. Hal ini
untuk menghindari terjadinya name clash33 dengan variabel / konstanta yang
dideklarasikan oleh unit tertentu.

Catatan
Hati-hati, definisi tipe menggunakan =, bukan :! Karena itulah ia disebut
definisi, bukan deklarasi.

Sekarang, kita akan mempelajari penggunaan array. Bayangkan array

sebagai kumpulan variabel yang sejenis (tipe data sama), yang hanya berbeda
namanya. Variabel TK pada program di atas bisa diasumsikan sebagai 100 buah
variabel TK1, TK2, TK3, ..., TK100. Hanya saja, dapat digunakan dengan lebih
efektif dan efisien, yaitu dengan menggunakan index.
Index diletakkan dalam kurung siku setelah nama variabel, dalam contoh di
atas, misalnya TK[n] menunjukkan index ke n pada variabel TK. Dengan
menggunakan index, kita dapat memanipulasi semua nilai yang terdapat di
dalamnya tanpa perlu menulis satu per satu, yaitu dengan menggunakan bantuan
loop. Index tidak harus berupa nilai langsung, namun dapat berupa ekspresi apa
saja yang mengembalikan nilai yang setipe dengan index tersebut. Pengaksesan
larik di luar index-nya akan mengakibatkan error, baik saat kompilasi maupun
dijalankan, tergantung ekspresinya.

33

Konflik karena pengenal yang sama digunakan lebih dari satu kali

56

Index tidak terbatas pada bilangan saja, semua tipe cacahan (beserta
subjangkauannya) bisa menjadi index dari larik. Contoh:
Array ['a'..'z'] of Byte;

Merupakan larik dengan index bertipe Char, yang setiap elemennya bertipe Byte.

Latihan:
1. Buatlah program yang menerima input berupa string sebanyak 5 kali, lalu
tampilkan dalam bentuk tabel string-string tersebut beserta panjang masingmasing! Asumsikan panjang maksimum masing-masing string adalah 10.
Contoh keluaran:
string

| panjang

----------+--------Mario

Ray

Mahardhika|

10

Ganteng

Sekali

2. Buatlah program untuk menyelesaikan suatu sistem persamaan linier dengan 2

unknown (x dan y)! Contoh untuk persamaan 2x + 3y = 6 dan x - 2y = 4:
Input:

Output:

236

x=0

1 -2 4

y = -2

Perhatikan bahwa nilai x / y bisa berupa pecahan. Gunakan tipe data yang
sesuai!

Larik dapat pula dibuat lebih dari 1 dimensi, biasa disebut larik
multidimensi (multidimensional array). Caranya adalah dengan menggunakan
larik lain sebagai tipe elemennya. Larik 2 dimensi umumnya digunakan sebagai
matriks atau tabel koordinat. Dimensi yang lebih tinggi bisa digunakan untuk
perhitungan geometri yang mendalam. Contoh larik multidimensi dapat dilihat
pada program berikut.

57

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

program MatrixTest;
const
n = 3;
NumWidth = n-1;
type
TMatrix = array [1..n] of array [1..n] of ShortInt;
procedure PrintMatrix(const M: TMatrix);
var
i,j: Byte;
begin
{ Cetak pembatas atas }
Write(#218); // Sudut kiri atas
for i:=1 to n*(NumWidth+1)+1 do Write(' ');
WriteLn(#191); // Sudut kanan atas
{ Cetak isi matriks }
for i:=1 to n do begin
Write(#179' '); // Garis tegak lurus
for j:=1 to n do Write(M[i,j]:NumWidth,' ');
WriteLn(#179); // Garis tegak lurus
end;
{ Cetak pembatas bawah }
Write(#192); // Sudut kiri bawah
for i:=1 to n*(NumWidth+1)+1 do Write(' ');
WriteLn(#217); // Sudut kanan bawah
end;
var
M: TMatrix;
i,j: Byte;
begin
for i:=1 to n do
for j:=1 to n do
M[i][j]:=n*(i-1)+j;
PrintMatrix(M);
end.

Program 10.2 Larik 2 dimensi untuk perhitungan matriks

Terdapat 1 elemen baru lagi, yaitu definisi konstanta. Bagian ini cukup
mudah, pahami saja bahwa pengenal yang digunakan adalah alias dari nilai yang
didefinisikan. Nilai tersebut boleh berupa ekspresi, asalkan ekspresi tersebut dapat
dihitung pada saat kompilasi (tidak mengandung variabel). Keuntungannya
adalah, misalnya dalam program ini, untuk mengubah ukuran matriks, cukup ubah
nilai n maka seluruh nilai n pada program juga akan terubah secara otomatis.

58

Untuk mempermudah penulisan dan memperpendek kode, disediakan jalan

pintas dalam membuat larik multidimensi. Pada contoh di atas, penulisan TMatrix
bisa dipersingkat menjadi:
array [1..n,1..n] of ShortInt;

begitu juga untuk pengaksesan elemen, (walaupun tidak terlalu signifikan karena
hanya menghemat 1 karakter). M[i][j] bisa dipersingkat menjadi M[i,j].
Programmer Pascal pada umumnya lebih suka menggunakan versi yang
dipersingkat karena lebih mirip dengan definisi tipenya.

Latihan:
Buatlah program untuk menghitung determinan dari matriks 2 dimensi dan 3
dimensi!

Pengurutan dan pencarian data biasa dilakukan dengan menggunakan larik.

Beberapa algoritma akan dipelajari di sini. Untuk pengurutan, kita akan
membahas bubble sort, selection sort, dan quicksort. Sementara untuk pencarian,
akan dibahas linear search dan binary search.
To be continued ...

Enumeration / Pencacahan

Himpunan / Set

Rekaman / Record

Penunjuk / Pointer

Berkas / File

Tipe Data Prosedural

59