Pendahuluan

Return Early/Early Exit Pattern merupakan salah satu Best Practice yang perlu diketahui oleh Software Engineer.

Return Early/Early Exit Pattern merupakan salah satu cara agar membuat Method atau Function dari coding kita mudah dibaca dan lebih bersih.

Langsung contoh saja kali ya …


Contoh 1

Misalkan kita punya code seperti ini :


 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

package com.huzefril.refactoring;

import org.springframework.stereotype.Service;

import lombok.extern.slf4j.Slf4j;

@Slf4j
@Service
public class EarlyReturnService {

  /*
	   fungsi untuk validasi argument1 dan argument2 apakah valid, kemudian melakukan
		 sebuah aksi, lalu mengembalikan hasilnya berupa String.
	*/

	public String validate(Object argument1, Object argument2) {
		if (argument1.isValid()) {
			if (argument2.isValid()) {
				String result1 = doSomething(argument1, argument2);

				if (result1 !=null) {
					log.info("Hasilnya : {}", result1);
				} else {
					throw new Exception("Hasilnya null !");
				}
			} else {
				throw new Exception("Argument2 tidak valid !");
			}
		} else {
			throw new Exception("Argument1 tidak valid !");
		}
	}

	private String doSomething(Object argument1, Object argument2) {
		// sebuah logic dijalankan
	}
}

Ada yang salah dengan code diatas ?

Hmmm…sepertinya tidak..

Cobaa..lihat lagi..

Iyaa..sepertinya tidak..tidak ada yang salah..

Logicnya sepertinya benar dan memang begitu seharusnya ..

Iyaa, tapi codenya membuat Brain overloaded dan tidak mudah dibaca.


Hmmm, dibagian mananya ?


Secara sederhana bisa kita lihat :

  • Terlalu banyak If .. else di code nya.
  • Terkait dengan banyak If .. else, maka otak kita secara natural mesti menyimpan kondisi-kondisi positif dan negatif di setiap kondisi If..Else yang ada di code nya tersebut, agar kita bisa paham logicnya. Dan ini membuat otak kita berputar-putar seperti gasing, membuat kasus yang namanya Brain Overload.
  • Membuat Unit test untuk mengetes logic dari codenya, membutuhkan kombinasi kasus yang kita mesti sedikit mengerenyitkan dahi.

Lihat kaan..

Dengan code seperti diatas, maka hidup kita akan cukup tersiksa dengan cara coding seperti diatas.

Oleh karenanya muncul Best Practice, namanya Return Early/Early Exit pattern


Apa itu Return Early/Early Exit Pattern ?


Return Early/Early Exit pattern adalah cara coding untuk sebuah fungsi/method dimana sesegera mungkin melakukan termination dari eksekusi (dengan melakukan return fungsi atau throw exception) ketika ada kondisi yang tidak cocok.

Caranya bagaimana ?

Simple..sesuai namanya :

  • Letakkan kondisi / If .. yang negatif di bagian paling atas code.
  • Lakukan Return .. seketika sudah ketemu kasus yang diinginkan, tanpa menunggu sampai seluruh code sampai akhir fungsi dijalankan.
  • Segera lakukan Throw … ketika terjadi kondisi negatif.
  • Sebisa mungkin hindari menggunakan variable boolean yang selalu diupdate untuk pengecekan kondisi, langsung kembalikan Return atau Throw.

Ok,coba kita langsung ke code nya saja :

Kita ambil contoh code diatas.

Setelah direfactoring, maka akan menjadi sbb :


 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

package com.huzefril.refactoring;

import org.springframework.stereotype.Service;

import lombok.extern.slf4j.Slf4j;

@Slf4j
@Service
public class EarlyReturnService {

	public String validate(Object argument1, Object argument2) {
		if (!argument1.isValid()) {
			throw new Exception("Argument1 tidak valid !");
		}

		if (!argument2.isValid()) {
			throw new Exception("Argument2 tidak valid !");
		}

		String result1 = doSomething(argument1, argument2);

		if (result1 == null) {
			throw new Exception("Hasilnya null !");
		}

		return result1;
	}

	private String doSomething(Object argument1, Object argument2) {
		// sebuah logic dijalankan
	}
}

Code kita diatas sebenarnya sama dengan code di code yang pertama diatas.

Tetapi dengan pendekatan Return Early pattern.

Coba kita lihat, apa yang berbeda, sbb :

  • Analisa kondisi negatif dilakukan di awal-awal line of code, dan langsung Throw Exception
  • Sisa dari code nya hanya merupakan kondisi positif. Dalam hal ini ditaruh di bagian terakhir dari line of code nya method validate.
  • Struktur penulisan code nya juga lebih flat, dan tidak berkalang seperti code yang pertama di atas.
  • Memahami code nya juga lebih mudah, karena pemisahan kasus-kasus yang negatif.
  • Membuat unit test juga lebih mudah, karena tidak ada percabangan if yang membuat banyak kasus.

See.. code kita jadi lebih mudah dibaca, dipahami, dilihat, diraba, diterawang. (udah kayak memeriksa uang saja)