Kode Bersih: Fungsi (dalam Javascript)
Apakah Anda lelah berjuang dengan fungsi yang rumit dan sulit dipahami di basis kode Anda? Apakah Anda ingin menulis fungsi yang lebih dapat dipelihara, digunakan kembali, dan tidak rentan terhadap kesalahan? Jika ya, maka Anda perlu mempelajari tentang “Kode Bersih: Fungsi”. Dengan mengikuti praktik terbaik yang diuraikan dalam buku “Clean Code” oleh Robert C. Martin, Anda dapat mempelajari cara menulis fungsi yang lebih mudah dibaca, diuji, dan dipelihara. Dalam posting blog ini, kami akan mengeksplorasi konsep utama fungsi kode bersih dan memberi Anda tip dan contoh praktis untuk membantu Anda menerapkan konsep ini dalam kode Anda sendiri. Dengan bantuan kami, Anda dapat meningkatkan keterampilan coding Anda ke level selanjutnya dan menulis fungsi yang menyenangkan untuk dikerjakan. Jadi, apakah Anda siap untuk belajar tentang fungsi kode bersih? Ayo selami!
Daftar Isi
· Fungsi Kecil Lebih Baik daripada Yang Besar
· Fungsi Harus Melakukan Satu Hal
· Fungsi Harus Memiliki Nama Deskriptif
· Fungsi Harus Memiliki Jumlah Argumen Yang Terbatas
· Fungsi Seharusnya Tidak Memiliki Efek Samping
· Fungsi Tidak Harus Bergantung pada Variabel Global
· Fungsi Tidak Harus Terlalu Sangat Bersarang
· Gunakan Pengecualian, Bukan Kode Kesalahan
· Kesimpulan
Fungsi Kecil Lebih Baik daripada Fungsi Besar
Fungsi kecil lebih mudah dibaca dan dipahami karena biasanya melakukan satu hal dan memiliki tujuan yang jelas. Ini juga membuatnya lebih mudah untuk diuji dan dipelihara karena ada lebih sedikit kode untuk ditinjau atau dimodifikasi. Fungsi besar, di sisi lain, bisa jadi lebih kompleks dan sulit dipahami, yang bisa menyebabkan bug atau kesalahan.
// Large function
function processOrders(orders) {
const total = orders.reduce((acc, order) => acc + order.price, 0);
const orderIds = orders.map(order => order.id);
const orderCount = orders.length;
const orderSummary = `You have ${orderCount} orders with IDs ${orderIds.join(', ')} for a total of $${total}.`;
console.log(orderSummary);
return orderSummary;
}
// --------------------------------------------------------------
// Refactored into smaller functions
function getTotalPrice(orders) {
return orders.reduce((acc, order) => acc + order.price, 0);
}
function getOrderIds(orders) {
return orders.map(order => order.id);
}
function getOrderCount(orders) {
return orders.length;
}
function generateOrderSummary(orders) {
const total = getTotalPrice(orders);
const orderIds = getOrderIds(orders);
const orderCount = getOrderCount(orders);
return `You have ${orderCount} orders with IDs ${orderIds.join(', ')} for a total of $${total}.`;
}
function logOrderSummary(orders) {
const orderSummary = generateOrderSummary(orders);
console.log(orderSummary);
return orderSummary;
}
Fungsi getTotalPrice()mengambil array pesanan dan mengembalikan harga totalnya dengan menggunakan reduce()fungsi untuk menjumlahkan harga setiap pesanan. Fungsi getOrderIds()mengambil larik pesanan dan mengembalikan larik id mereka dengan menggunakan map()fungsi. Fungsi getOrderCount()mengambil larik pesanan dan mengembalikan hitungannya dengan menggunakan lengthproperti. Terakhir, generateOrderSummary()fungsi mengambil larik pesanan dan menggunakan tiga fungsi yang lebih kecil untuk menghasilkan string ringkasan. Fungsi logOrderSummary()mengambil larik pesanan dan mencatat string ringkasan ke konsol.
Fungsi Harus Melakukan Satu Hal
Setiap fungsi harus memiliki tujuan yang jelas dan berbeda. Ketika suatu fungsi melakukan banyak hal, akan menjadi lebih sulit untuk dipahami, diuji, dan dipelihara. Dengan memecah tugas yang lebih besar menjadi fungsi yang lebih kecil, kita dapat membuat kode yang lebih mudah dibaca dan dipelihara.
// Function that performs multiple tasks
function processUserInput(input) {
const inputLines = input.split('\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\n');
const trimmedLines = inputLines.map(line => line.trim());
const nonEmptyLines = trimmedLines.filter(line => line !== '');
const formattedLines = nonEmptyLines.map(line => `> ${line}`);
return formattedLines.join('\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\n');
}
// --------------------------------------------------------------
// Refactored into smaller functions
function splitInput(input) {
return input.split('\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\n');
}
function trimLines(lines) {
return lines.map(line => line.trim());
}
function removeEmptyLines(lines) {
return lines.filter(line => line !== '');
}
function formatLines(lines) {
return lines.map(line => `> ${line}`);
}
function joinLines(lines) {
return lines.join('\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\n');
}
function processUserInput(input) {
const lines = splitInput(input);
const trimmedLines = trimLines(lines);
const nonEmptyLines = removeEmptyLines(trimmedLines);
const formattedLines = formatLines(nonEmptyLines);
return joinLines(formattedLines);
}
Fungsi splitInput()mengambil string dan menggunakan split()metode untuk membaginya menjadi array baris. Fungsi trimLines()mengambil larik baris dan menggunakan map()metode untuk menghapus spasi kosong dari awal dan akhir setiap baris. Fungsi removeEmptyLines()mengambil larik garis dan menggunakan filter()metode untuk menghapus baris kosong. Fungsi formatLines()mengambil larik baris dan menggunakan map()metode untuk menambahkan >karakter ke awal setiap baris. Fungsi joinLines()mengambil larik garis dan menggunakan join()metode untuk menggabungkannya menjadi satu string, dipisahkan oleh baris baru. Terakhir, processUserInput()fungsi menggunakan fungsi yang lebih kecil untuk memproses string masukan.
Fungsi Harus Memiliki Nama Deskriptif
Nama fungsi harus menjelaskan secara akurat apa yang dilakukan fungsi dan harus mudah dipahami tanpa harus membaca implementasi fungsi. Nama fungsi deskriptif dapat membantu membuat kode lebih jelas dan mengurangi kebutuhan akan komentar.
// Function with a vague name
function processData(data) {
// ...
}
// --------------------------------------------------------------
// Refactored with a descriptive name
function processUserData(userData) {
// ...
}
Fungsi Harus Memiliki Jumlah Argumen yang Terbatas
Fungsi yang membutuhkan banyak argumen bisa lebih sulit untuk digunakan, dipahami, dan diuji. Bertujuan untuk menjaga jumlah argumen di bawah tiga atau empat, jika memungkinkan. Salah satu cara untuk mengurangi jumlah argumen adalah dengan meneruskannya sebagai satu objek atau struktur data.
// Function with too many arguments
function createPerson(name, age, address, phone, email) {
// ...
}
// --------------------------------------------------------------
// Refactored to use an object instead
function createPerson(personData) {
// ...
}
// Now, we can pass an object with properties for name, age, address, phone, and email:
const personData = {
name: 'John Doe',
age: 30,
address: '123 Main St',
phone: '555-555-1234',
email: '[email protected]'
};
const person = createPerson(personData);
Fungsi Seharusnya Tidak Memiliki Efek Samping
Efek samping terjadi ketika suatu fungsi mengubah status apa pun di luar cakupannya sendiri. Efek samping dapat mempersulit pengujian dan penalaran tentang perilaku fungsi dan juga dapat menyebabkan perilaku yang tidak diharapkan. Fungsi harus beroperasi hanya pada parameter dan variabel lokalnya sendiri dan tidak boleh mengubah status apa pun di luar cakupannya.
// Example with side effects
let arr = [1, 2, 3];
function popLastElement() {
arr.pop(); // modifies the external state of `arr`
}
popLastElement();
console.log(arr); // Output: [1, 2]
// --------------------------------------------------------------
// Example without side effects
function getLastElement(arr) {
return arr[arr.length - 1]; // returns a new value without modifying the input
}
let arr = [1, 2, 3];
let lastElement = getLastElement(arr);
console.log(lastElement); // Output: 3
Fungsi Tidak Harus Bergantung pada Variabel Global
Variabel global membuat lebih sulit untuk memahami dan menguji fungsi dan dapat menyebabkan perilaku yang tidak terduga. Fungsi harus beroperasi hanya pada parameter dan variabel lokalnya sendiri dan tidak boleh bergantung pada status global. Ini juga memudahkan untuk menggunakan kembali fungsi dalam konteks yang berbeda.
// Example relying on global state
let x = 0;
function increment() {
x++;
}
increment();
console.log(x); // Output: 1
// --------------------------------------------------------------
// Example without relying on global state
function increment(x) {
return x + 1;
}
let y = 0;
y = increment(y);
console.log(y); // Output: 1
Fungsi Tidak Harus Bersarang Terlalu Dalam
Fungsi yang disarangkan secara mendalam bisa lebih sulit untuk dibaca dan dipahami, serta mengarah pada struktur kontrol yang rumit. Fungsi harus disusun dengan cara yang memudahkan untuk memahami aliran kontrol, tanpa harus secara mental melacak beberapa tingkat fungsi bersarang.
// Example with deeply nested functions
function add(a, b) {
function increment(x) {
return x + 1;
}
let c = increment(a);
let d = increment(b);
return c + d;
}
console.log(add(1, 2)); // Output: 5
// --------------------------------------------------------------
// Example with flatter function structure
function increment(x) {
return x + 1;
}
function add(a, b) {
let c = increment(a);
let d = increment(b);
return c + d;
}
console.log(add(1, 2)); // Output: 5
Gunakan Pengecualian, Bukan Kode Kesalahan
Kode kesalahan dapat mempersulit penalaran tentang kode dan dapat menyebabkan struktur kontrol yang rumit. Pengecualian memungkinkan aliran kontrol yang lebih alami dan penanganan kesalahan yang lebih mudah. Fungsi harus melontarkan pengecualian untuk menunjukkan kesalahan atau perilaku yang tidak diharapkan, daripada mengembalikan kode atau nilai kesalahan.
// Example with error code
function divide(a, b) {
if (b === 0) {
return -1; // error code for divide by zero
}
return a / b;
}
let result = divide(4, 0);
if (result === -1) {
console.log("Error: Divide by zero"); // error handling with error code
}
// --------------------------------------------------------------
// Example with exception
function divide(a, b) {
if (b === 0) {
throw new Error("Divide by zero"); // throws an exception
}
return a / b;
}
try {
let result = divide(4, 0);
} catch (e) {
console.log("Error: " + e.message); // error handling with exception
}
Kesimpulan
Kesimpulannya, penting untuk mengikuti praktik terbaik saat menulis fungsi untuk meningkatkan kualitas keseluruhan basis kode kita. Dengan melakukannya, kami dapat memastikan bahwa fungsi kami tidak hanya dapat dibaca dan digunakan kembali, tetapi juga dapat dipertahankan dalam jangka panjang. Ini dapat membantu mengurangi jumlah bug dan kesalahan yang mungkin timbul dari kode yang ditulis dengan buruk, yang dapat menghemat waktu dan sumber daya dalam jangka panjang.
Perlu dicatat bahwa kode bersih bukan hanya tentang menulis kode yang berfungsi; ini juga tentang menulis kode yang dapat dengan mudah dipahami, diuji, dan dimodifikasi dari waktu ke waktu. Oleh karena itu, sebaiknya luangkan waktu untuk mempertimbangkan dengan cermat praktik terbaik yang diuraikan di atas saat menulis fungsi, untuk mengoptimalkan kualitas dan pemeliharaan kode Anda.
![Apa itu Linked List? [Bagian 1]](https://post.nghiatu.com/assets/images/m/max/724/1*Xokk6XOjWyIGCBujkJsCzQ.jpeg)
