02. Prosedur dan Fungsi

MODUL MATA KULIAH
LOGIKA DAN ALGORITMA
STIMIK EL RAHMA
JOGJAKARTA 2015
JURUSAN : SISTEM INFORMASI
SEMESTER GENAP 2015
Materi :
PROCEDURE DAN FUNCTION
Program yang besar lebih sulit dimengerti dan lebih sulit lagi dalam melakukan
pelacakan kesalahan (Jika ada). Oleh karena itu, program sebaiknya dipecah menjadi
beberapa sub program yang lebih kecil.
Setiap sub program melakukan komputasi yang spesifik. Sub program yang baik
adalah sub program yang independent dari program utama, sehingga programnya dapat
dirancang tanpa mempermasalahkan bagaimana sub program tersebut dilakukan, tetapi
cukup memikirkan apa yang ia lakukan.
Sub program yang bagus menyembunyikan detil operasi dari bagian program
yang tidak perlu tahu tentang sub-program tersebut. Teknik pemecahan program menjadi
sejumlah sub program dinamakan teknik pemrograman modular.
Modular artinya penyelesaian seluruh masalah dapat dipecah-pecahkan dengan
unsur-unsur langkah penyelesaian spesifik berbentuk modul yang berwujud prosedur
(procedure) dan fungsi (function).

Keuntungan Pemrograman Modular
 Untuk aktivitas yang harus dilakukan lebih dari satu kali, modularisasi
menghindari penulisan teks program yang sama secara berulangkali.
Disini sub-program cukup ditulis sekali saja, lalu sub-program dapat
dipanggil dari bagian lain di dalam program. Disini, penggunaan subprogram dapat mengurangi panjang program.
 Kemudahan menulis dan menemukan kesalahan ( debug) program.
Kemudahan menulis akan sangat berguna pada masalah besar yang
dikerjakan oleh satu tim pemrogram yang beranggotakan beberapa
orang.
 Masalah yang akan diprogram dipecah menjadi

beberapa masalah

yang lebih kecil. Setiap masalah yang lebih kecil tesebut ditulis
kedalam modul yang spesifik dan dikerjakan oleh orang yang
berbeda.

 Satu modul bisa berisi dari satu atau lebih sub-program. Seluruh
modul

diintegrasikan

menjadi

satu

buah

program

yang

lengkap.Program yang modular menjadi lebih mudah untuk dibaca
dan

dimengerti.

Program

yang

tidak

modular

sulit

dipahami,

khususnya kalau program tersebut panjang atau terdiri dari puluhan,
ratusan, atau ribuan baris instruksi.
Karena setiap sub-program melakukan aktivitas spesifik, maka apabila
terdapat kesalahan di dalam program, kesalahan tersebut cukup
dilokalisir di dalam sub-program yang bersangkutan. Kebanyakan
program komputer ditulis modular, meskipun program tersebut tidak
melibatkan ekseskusi yang berulang dari aktivitas yang sama.
Pemecahan program menjadi modul-modul yang lebih kecil umumnya
dianggap sebagai praktik pemrograman yang baik dan terstruktur.
Terdapat 2 bentuk sub-program, yaitu prosedur (procedure) dan
fungsi (function). Dimana struktur setiap sub-program tersebut pada

hakikatnya sama dengan struktur program biasa, yaitu ada bagian
judul (header) yang berisi nama modul, bagian deklarasi, dan badan
(body) program yang berisi instruksi yang akan dilaksanakan.
Variabel Global dan Variabel Lokal
Variabel global adalah variabel yang dapat dipakai diseluruh program,
di program utama atau di dalam procedure atau function.
Variabel lokal hanya dapat dipakai di tempat pendefinisiannya. Jika
variabel lokal didefinisikan didalam procedure, maka hanya procedure
tersebut yang mengenalnya.
Suatu variabel atau peubah akan dideklarasikan global atau local
tergantung kepada penggunaan nama tersebut.
Jika suatu variabel digunakan di seluruh bagian program (termasuk di
dalam prosedur), maka variabel tersebut harus dideklarasikan global.
Sebaliknya, jika variabel tersebut hanya digunakan di dalam
prosedur/function
saja,
maka
nama
variabel
“sebaiknya”

dideklarasikan
sebagai
variabel
lokal
saja,
meskipun
bila
dideklarasikan global pun masih tetap benar.
Usahakanlah menggunakan variabel global sesedikit mungkin.
Penggunaan variabel lokal akan memberikan keuntungan, sebab
variabel lokal membuat program lebih elegan, dan dapat
meminimumkan usaha pencarian kesalahan yang disebabkan oleh

nama tersebut, karena variabel lokal hanya dipakai di dalam lingkup
procedure atau function saja.
Procedure/function yang baik adalah yang independen dari program
pemanggilnya. Pernyataan ini menyiratkan bahwa procedure/function
yang baik tidak menggunakan variabel-varibel global di dalam badan
procedur / function-nya. Jika program utama perlu mengkomunikasikan
nilai variabel global ke dalam procedure/fucntion, maka ada satu cara

untuk melakukannya yaitu dengan menggunakan parameter. Karena
parameter dapat mengurangi kebutuhan penggunaan variabel global.
Parameter
Kebanyakan program memerlukan informasi antara procedure ( atau
fungsi) dimana ia dipanggil. Penggunaan parameter menawarkan
mekanisme pertukaran informasi tersebut. Tiap item data ditransfer
antara parameter actual dan parameter formal yang bersesuaian.
Parameter actual adalah parameter yang disertakan pada waktu
pemanggilan, sedangkan parameter formal adalah parameter yang
dideklarasikan didalam bagian header procedure/function itu sendiri.
Ketika procedure/function dipanggil, parameter actual menggantikan
parameter formal. Tiap-tiap parameter actual berpasangan dengan
parameter formal yang bersesuaian.
Berdasarkan maksud penggunaannya, terdapat tiga jenis parameter
formal yang disertakan didalam procedure/function, yaitu :
a.

Parameter masukan (input) → parameter yang nilainya berlaku
sebagai masukan untuk procedure/function.

b. Parameter keluaran (output)→parameter yang menampung
keluaran yang dihasilkan oleh procedure.
c. Parameter

masukan/keluaran

(input/output

parameter)→

parameter yang berfungsi sebagai masukan sekaligus keluaran
bagi procedure tersebut.
Parameter Masukan

Jika program utama ingin meng-komunikasikan panjang alas dan tinggi
segitiga ke prosedur Luas_Segitiga, maka peubah alas dan tinggi harus
dideklarasikan sebagai parameter formal dibagian header prosedur :
Procedure Luas_Segitiga( input alas, tinggi :
real )
Deklarasi :

luas: integer
Algoritma :
write('Masukan alas segitiga: ')
read(alas)
write('Masukan tinggi segitiga: ')
read(tinggi)
luas (alas*tinggi)/2
write('luas segitiga: ',luas)
Parameter Keluaran
Parameter keluaran dideklarasikan didalam header prosedur, sebagaimana
parameter masukan. Parameter keluaran harus dideklarasikan dengan kata kunci
input :
Procedure Luas_Segitiga( input alas, tinggi : real, output luas :
real )
Deklarasi :
{ tidak ada}
Algoritma :
luas (alas*tinggi)/2

Dalam function hanya ada parameter masukan saja.

Bila procedure menghasilkan keluaran yang digunakan oleh program
pemanggil, gunakan parameter keluaran untuk menampung keluaran
tersebut.
Sebaliknya, bila procedure tidak menghasilkan keluaran, atau kalaupun
menghasilkan keluaran dan ternyata keluaran tersebut hanya
digunakan di dalam procedure itu saja, gunakan parameter masukan.
Bila procedure menerima masukan sekaligus keluaran pada parameter
yang sama, gunakan parameter masukan/keluaran.
Aturan penting yang harus diamati dalam korespondensi satu-satu
antara parameter actual dan parameter formal adalah :

a. Jumlah parameter actual pada pemanggilan procedure/function
harus sama dengan jumlah parameter formal pada deklarasi
procedure/function-nya.
b. Tiap parameter actual harus bertipe sama dengan tipe parameter
formal yang bersesuaian.

PROCEDURE (PROSEDUR)
Procedure adalah modul program yang mengerjakan tugas/aktivitas
yang spesifik dan menghasilkan suatu efek netto. Pada beberapa

bahasa pemrograman, procedure dikenal dengan nama subroutine.
Atau lebih jelasnya, procedure merupakan sekumpulan instruksi yang
dibungkus yang akan dipakai / dipanggil dalam program utama. Ini
berarti, instruksi-instruksi didalam procedure baru dapat dilaksanakan
hanya bila procedure tersebut diakses.
Struktur Procedure :
Notasi Algoritmik :

Procedure NamaProcedure(deklarasi parameter,jika ada)
{Spesifikasi procedure, berisi penjelasan tentang apa yang
dilakukan oleh prosedur ini,
keadaan sebelum prosedur dijalankan dan setelah prosedur
dijalankan}
Deklarasi :
{Semua nama yang dipakai dalam prosedur didefinisikan disini
dan hanya
berlaku lokal di dalam prosedur}
Algoritma :
{Badan prosedur, berisi kumpulan instruksi}
Notasi Pascal :

Procedure NamaProcedure(deklarasi parameter,jika ada);
{Spesifikasi procedure, berisi penjelasan tentang apa yang
dilakukan oleh prosedur ini,
keadaan sebelum prosedur dijalankan dan setelah prosedur
dijalankan}
(* Deklarasi *)
var
{Semua nama yang dipakai dalam prosedur didefinisikan disini
dan hanya
berlaku lokal di dalam prosedur}

(*Algoritma*)
begin
{Badan prosedur, berisi kumpulan instruksi}
end;
Keterangan :
 Dalam bahasa Pascal, pendefinisian prosedur ditulis bersatu di
dalam program utama, kecuali jika direalisasikan sebagai unit.
Prosedur diletakkan dibawah kata var.
 Bahasa Pascal memungkinkan prosedur mempunyai parameter
masukan, parameter keluaran, dan parameter masukan/keluaran.
Parameter formal yang bertipe keluaran atau masukan/keluaran
harus diawali dengan kata kunci var, sedangkan untuk parameter
formal yang bertipe masukan tidak diawali dengan kata kunci var.
 Argumen parameter aktual dilewatkan ke parameter formal
bertipe masukan sebagai “by value”, sedangkan bila parameter
formalnya bertipe
keluaran atau masukan/keluaran, maka
argumen parameter aktual dilewatkan sebagai “By reference”
Contoh procedure :
Algoritmik:

Procedure Luas_Segitiga
{Procedure tanpa parameter)
Deklarasi :
{Variabel Lokal}
alas,tinggi,luas: real
Algoritma :
write('Masukan alas segitiga: ')
read(alas)
write('Masukan tinggi segitiga: ')
read(tinggi)
luas (alas*tinggi)/2
write('luas segitiga: ',luas)
Procedure Tukar1 ( input A,B :integer)
{Procedure dengan 2 parameter input)
Deklarasi :
Temp:integer
Algoritma :
Temp  A
AB
B  Temp

Procedure Maksimum ( input A,B:integer; output
Maks:integer)
{Procedure dengan 2 parameter input dan 1
parameter output)
Algoritma :
if A>B then
maks  A
else
maks  B
endif

Procedure Tukar2 ( input /output A,B :integer)
{Procedure dengan 2 parameter input/output)
Deklarasi :

Temp:integer

Algoritma :
Temp  A
AB
B  Temp

Program Contoh_Prosedur
Deklarasi :
x,y,maksi:integer
Procedure Luas_Segitiga
Procedure Tukar1 ( input A,B :integer)
Procedure Maksimum ( input A,B:integer;
output Maks:integer)
Procedure Tukar2 ( input /output
A,B :integer)
Algoritma :
{Program Utama}
Luas_Segitiga
write('Masukan Angka ke-1: ')
read(X)
write('Masukan Angka ke-2: ')
read(Y)
Maksimum(X,Y,maksi)
write('Angka ke-1: ',x,' ','Angka ke-2: ',Y,' ','Nilai
Maksimum: ',maksi)
Tukar1(X,Y)
Write('Angka ke-1 sekarang nilainya: ',X)
Write('Angka ke-2 sekarang nilainya: ',Y)
Tukar2(X,Y)
Write('Angka ke-1 sekarang nilainya: ',X)
Write('Angka ke-2 sekarang nilainya: ',Y)
Pascal:

Program Contoh_prosedur;
var
X,Y,maksi:integer;
procedure luas_segitiga;
var
alas,tinggi,luas:real;
begin
write('masukan alas segitiga: ');
readln(alas);
write('masukan tinggi segitiga: ');
readln(tinggi);
luas:=(alas*tinggi)/2;
write('Luas segitiga:',luas);
end;
procedure tukar1 (a,b:integer);
var
temp:integer;
begin
temp:=a;
a:=b;
b:=temp;
end;
procedure
maks:integer);
begin
if a>b then
maks:=a
else
maks:=b
end;

maksimum(a,b:integer;var

procedure tukar2 (var a,b:integer);
var
temp:integer;
begin
temp:=a;
a:=b;
b:=temp;
end;

{Program Utama}
begin
luas_segitiga;

write ('Masukan angka ke-1:');
readln(X);
write ('Masukan angka ke-2:');
readln(Y);
maksimum(X,Y,maksi);
writeln('Angka ke-1:',x,' ','Angka ke-2:',Y,'
','Nilai maksimum: ',maksi);
tukar1(x,y);
writeln('Angka ke-1 sekarang nilainya:',X);
writeln('Angka ke-2 sekarang nilainya:',Y);
tukar2(x,y);
writeln('Angka ke-1 sekarang nilainya:',X);
writeln('Angka ke-2 sekarang nilainya:',Y);
end.

Function (Fungsi)
Function adalah modul program yang memberikan/mengembalikan
(return) sebuah nilai dan tipe tertentu. Sebagaimana halnya dengan
procedure, function diakses dengan memanggil namanya. Selain itu,
fungsi juga dapat mengandung daftar parameter formal. Parameter
pada fungsi sama seperti didalam prosedur, tetapi hanya ada
parameter masukan saja jika ada. Function hanya dapat
mengembalikan nilai bertipe sederhana. Karena itu, tipe hasil dari
fungsi haruslah dari tipe sederhana.
Struktur Function :
Notasi Algoritmik :
Function NamaFunction(deklarasi parameter,jika ada):tipe

{Spesifikasi function, berisi penjelasan tentang apa yang
dilakukan dan yang dikembalikan oleh function}
Deklarasi :
{Semua nama yang dipakai dalam function didefinisikan disini
dan hanya
berlaku lokal di dalam function }
Algoritma :
{Badan function, berisi kumpulan instruksi-instruksi untuk
menghasilkan nilai yang
akan dikembalikan oleh function}

Notasi Pascal :
function NamaFunction(deklarasi parameter,jika ada):tipe
{Spesifikasi
function , berisi penjelasan tentang apa yang
dilakukan dan yang dikembalikan oleh function}

(* Deklarasi *)
var
{Semua nama yang dipakai dalam function didefinisikan disini
dan hanya
berlaku lokal di dalam function }
(*Algoritma*)
begin
{Badan function, berisi kumpulan instruksi-instruksi untuk
menghasilkan nilai yang
akan dikembalikan oleh function}
NamaFunction:= ekspresi;
{pengembalian nilai yang
dihasilkan fungsi}
end;
Keterangan :
 Dalam bahasa Pascal, function hanya dapat mengembalikan nilai
bertipe sederhana (integer, real, boolean, char, dan string). Karena
itu, tipe hasil dari fungsi haruslah dari tipe sederhana.
 Apabila function tidak memiliki daftar parameter formal, maka
tanda ‘( )’ tidak ditulis.
 Function dideklarasikan sekaligus didefinisikan di dalam blok
program utama pemanggil (sesudah kata kunci var).

Cara memanggil function:
Function diakses dengan cara memanggil namanya dari program
pemanggil, diikuti dengan daftar parameter actual (bila ada). Karena
fungsi menghasilkan nilai, maka nilai tersebut ditampung dalam
sebuah peubah yang bertipe sama dengan tipe fungsi.
peubah  namafunction(daftar parameter actual)
atau nilai yang dikembalikan oleh function dapat langsung
dimanipulasi seperti contoh-contoh berikut:
 write (Namafunction(daftar parameter actual))
 if (Namafunction(daftar parameter actual)) < 0 then ……..
 z2* (Namafunction(daftar parameter actual))-x+y
Contoh function :
Algoritmik :
Function
NilaiRata(a,b,c:integer):real
Deklarasi :
NR:real
Algoritma :
NR (a+b+c)/3
NilaiRataNR

Program Contoh_fungsi
Deklarasi :
Nilai1,Nilai2,Nilai3:integer
RataRata:real
Function
NilaiRata(a,b,c:integer):real
Algoritma :
write('Nilai 1 : ')
read(Nilai1)
write('Nilai 2 : ')
read(Nilai2)
write('Nilai 3 : ')
read(Nilai3)
RataRataNilaiRata(Nilai1,Nilai
2,Nilai3)
write('Nilai rata-rata adalah ',
RataRata)
Perhatikan bagian deklarasi function:
function NilaiRata(a,b,c:integer):real
Function di atas mempunyai 3 parameter nilai,yaitu a,b,c. Ketiga
parameter tersebut bertipe integer.Hasil dari function NilaiRata bertipe
real. Di dalam function harus ada pernyataan yang memberi nilai pada
function, pada contoh diatas adalah: NilaiRataNR.
Perhatikan cata pemanggilan function didalam program utama:
NilaiAkhirNilaiRata(Nilai1,Nilai2,Nilai3)
Karena hasil dari function NilaiRata bertipe real,maka NilaiAkhir juga
harus bertipe real.
Pascal:
Program Contoh_fungsi;
var
Nilai1,Nilai2,Nilai3:integer;
RataRata : real;
function NilaiRata (a,b,c : integer):real;
var
NR:real;

begin
NR:= (a+b+c)/3;
NilaiRata:=NR;
end;

{Program Utama}
begin
write('Nilai 1 : ');
readln(Nilai1);
write('Nilai 2 : ');
readln(Nilai2);
write('Nilai 3 : ');
readln(Nilai3);
RataRata:=NilaiRata(Nilai1,Nilai2,Nilai3);
write('Nilai rata-rata adalah ',
RataRata);
end.
KESIMPULAN
 Fungsi digunakan apabila modul program mengembalikan sebuah
nilai.
 Prosedur digunakan bila modul menghasilkan effek netto dari (satu
atau) sekumpulan aksi.
 Fungsi dapat dikonversi sebagai prosedur dengan cara menyatakan
nilai yang dikembalikan (return value) oleh fungsi tersebut sebagai
parameter keluaran pada prosedur.
 Prosedur yang mempunyai satu buah parameter keluaran dapat
ditulis sebagai fungsi dengan cara menyatakan parameter keluaran
sebagai nilai yang dikembalikan oleh fungsi.
Latihan
- Buatlah program untuk
menggunakan procedure .

menghitung

berbagai

luas

dengan

- Buat procedure yang menghasilkan nilai rata-rata sekumpulan data
bilangan bulat yang dibaca secara berulang-ulang dari keyboard
(akhir pembacaan adalah 9999). Prosedur ini memiliki parameter
keluaran, yaitu nilai rata-rata yang dihasilkan.
- Buatlah function untuk menentukan bilangan genap dan program
utamanya.

- Buat function untuk menghitung fungsi F(X)= 2x2 + 5x +- 8