Prosedur dan fungsi di delphi

Secara umum dengan bahasa lain, Delphi menyediakan 2 jenis subroutine – Prosedur dan Fungsi. Fungsinya adalah sama seperti prosedur kecuali bahwa mereka kembali nilai selain statemen mengeksekusi. Sebuah Fungsi, seperti namanya, adalah seperti sebuah program kecil yang menghitung sesuatu, mengembalikan nilai ke pemanggil. Di sisi lain, suatu prosedur seperti rutin kecil yang melakukan sesuatu, dan kemudian hanya selesai.

Parameter untuk subrutin
Kedua fungsi dan prosedur dapat didefinisikan untuk beroperasi tanpa adanya data yang berlalu. Sebagai contoh, Anda mungkin memiliki fungsi yang hanya mengembalikan nomor acak (seperti fungsi Random Delphi).

Demikian juga, Anda dapat memiliki prosedur yang melakukan beberapa tugas tanpa perlu data untuk mendikte operasinya. Sebagai contoh, Anda mungkin memiliki prosedur yang menarik persegi pada layar dan Setiap waktu tiap persegi itu disebut.

beberapa contoh fungsi dan prosedure

Procedure tanpa parameter

procedure ShowTime; // sebuah prosedur tanpa parameter
begin
// Tampilkan waktu sekarang
ShowMessage('Waktu sekarang adalah : '+DateTimeToStr(Now));
end;

//cara memanggil prosedur
ShowTime;

prosedur dengan parameter


procedure ShowTime(dateTime : TDateTime); // dengan parameter datetime
begin
// menampilkan tanggal kemarin
ShowMessage('Date and time is '+DateTimeToStr(dateTime));
end;

// cara memanggil prosedure , perhatikan Yesterday (Tdatetime)
//, parameter yang di masukan harus sama tipe variable di prosedur yang telah dibuat

ShowTime(Yesterday);

A function without parameters


function RandomChar : char;
var
i : integer;
begin
// Get a random number from 65 to 90
// (These numbers equate to characters 'A' to 'Z'
i := RandomRange(65, 90);
// nilai kembalian (dalam kasus ini char)
// tipe variabel harus sama dengan
// fungsi yang dideklarasikan
Result := Chr(i);
end;
// cara pemanggilan fungsi
ShowMessage('Char chosen is : '+RandomChar);

Penting untuk dicatat bahwa kita mengembalikan nilai dari fungsi dalam sebuah Hasil variabel khusus yang disebut Result bahwa Delphi menentukan bagi kita untuk menjadi tipe yang sama sebagai tipe pengembalian fungsi. Kita dapat menetapkan untuk itu pada setiap titik dalam fungsi. Bila fungsi berakhir, nilai kemudian dilempar ke Hasil dan kemudian dikembalikan ke pemanggil.

fungsi dengan parameter

function Average(a, b, c : Extended) : Extended;
begin
// menghitung mean rata rata
Result := Mean(a, b, c);
end;

// cara memangil fungsi dengan tipe variable harus sama dengan tipe parameter fungsi yang dideklarasikan.
ShowMessageFmt(‘Average of 2, 13 and 56 = %f’,[Average(2,13,56)]);

Interfaces/Antarmuka versus Implementasi
Dalam contoh di atas, kita telah menunjukkan subrutin dan kode panggilan dalam satu urutan. Dalam prakteknya, bahkan kode panggilan akan berada dalam sebuah sub rutin, untuk alasan yang sangat baik. Mari kita menampilkan kode Unit lengkap untuk mengklarifikasi ini:


// Full Unit code.
// ----------------------------------------------
//unit harus disimpan dengan formnya.
//dpanggil Form1 that has an
// OnCreate event called FormCreate

unit Unit1;

interface

uses
Forms, Dialogs;

type
TForm1 = class(TForm)
procedure FormCreate(Sender: TObject);
end;

var
Form1: TForm1;

implementation
{$R *.dfm} // Include form definitions

// A small procedure
procedure InLineProc;
begin
ShowMessage(‘Hello World’);
end;

procedure TForm1.FormCreate(Sender: TObject);
begin
// Call our little in line procedure
InLineProc;
end;

end.

catatan:

setiap method fungsi sebagai contoh OnCreate telah deklarasikan procedure FormCreate(Sender: TObject); yang digenerate oleh delphi sendiri ketika kita mengisi method. berbeda dengan procedure InLineProc;

Setiap subrutin didefinisikan dalam bagian Interface harus didefinisikan pada bagian Implementasi. InLineProc tidak, sehingga perlu ada deklarasi terlebih dahulu sebelum dipanggil.

lokal data untuk subrutin Data

Pada contoh RandomChar di atas, kita mendeklarasikan sebuah variabel integer untuk digunakan dalam perhitungan dengan fungsinya. Subrutin dapat memiliki sendiri jenis, konstanta dan variabel, dan ini tetap lokal untuk rutinitas. Nilai Variabel di-reset setiap kali rutin disebut (menggunakan benda kelas untuk memegang data melalui panggilan rutin). Berikut adalah ilustrasi dari tindakan ini variabel lokal:

procedure DoIt(A : Integer);
begin
A := A * 2;
ShowMessageFmt('A in the procedure = %d',[A]);
end;

procedure TForm1.FormCreate(Sender: TObject);
var
A : Integer;
begin
A := 22;
ShowMessageFmt(‘A in program before call = %d’,[A]);
// Call the procedure
DoIt(A);
ShowMessageFmt(‘A in program now = %d’,[A]);
end;

keluarannya:

A in program before call = 22
A in the procedure = 44
A in program now = 22

Prosedur dilewatkan A, update dan menampilkannya.caller kemudian menampilkan A yang dilewatkan ke prosedur. Itu tidak berubah. Prosedur melihat A ini seolah-olah itu didefinisikan sebagai sebuah variabel lokal. Seperti variabel lokal, ketika prosedur berakhir, nilai nya hilang.

Passing data by reference

procedure DoIt(Var A : Integer);
begin
A := A * 2;
ShowMessageFmt('A in the procedure = %d',[A]);
end;

procedure TForm1.FormCreate(Sender: TObject);
var
A : Integer;
begin
A := 22;
ShowMessageFmt(‘A in program before call = %d’,[A]);
// Call the procedure
DoIt(A);
ShowMessageFmt(‘A in program now = %d’,[A]);
end;

Output only parameters

procedure DoIt(Out A : Integer);
begin
A := 123;
ShowMessageFmt('A in the procedure = %d',[A]);
end;

procedure TForm1.FormCreate(Sender: TObject);
var
A : Integer;
begin
ShowMessage(‘A before the call is unknown’);
// Call the procedure
DoIt(A);
ShowMessageFmt(‘A in program now = %d’,[A]);
end;

Keluaran:

A before the call is unknown
A in the procedure = 123
A in program now = 123


Constant value parameters

Untuk kejelasan kode, dan kinerja, sering bijaksana untuk menyatakan argumen yang hanya pernah dibaca oleh subrutin sebagai konstanta. Hal ini dilakukan dengan awalan const. Hal ini dapat digunakan bahkan ketika suatu parameter non-konstan berlalu. Ini hanya berarti bahwa parameter hanya pernah dibaca oleh subrutin.

procedure DoIt(Const A : Integer; Out B : Integer);
begin
B := A * 2;
end;

procedure TForm1.FormCreate(Sender: TObject);
var
A, B : Integer;
begin
A := 22;
// Call the procedure
DoIt(A, B);
ShowMessageFmt(‘B dikirimkan ke = %d’,[B]);
end;

Keluaran :

B dikirimkan ke 44

Routin sama beda parameter

Salah satu manfaat adalah bahwa kita dapat mendefinisikan dua atau lebih subrutin yang memiliki nama yang sama persis. Delphi mampu membedakan mereka dengan jumlah yang berbeda atau jenis parameter.

contoh :

procedure DoIt; overload;
begin
ShowMessage('DoIt with no parameters called');
end;

procedure DoIt(msg : String); overload;
begin
ShowMessage(‘DoIt called with parameter : ‘+msg);
end;

procedure TForm1.FormCreate(Sender: TObject);
begin
// Call the procedure using no parameters
DoIt;
// Now call the procedure using one parameter
DoIt(‘Hi there’);
end;

Keluaran

DoIt with no parameters called
DoIt called with parameter : Hi There

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s