Dalam pembangunan perisian, fungsi ialah blok bangunan mana-mana aplikasi. Ia adalah cara utama kita menstruktur logik kita, merangkum tingkah laku dan membahagikan tugas yang kompleks kepada bahagian yang boleh diurus.
Walau bagaimanapun, tidak semua fungsi dicipta sama. Dalam Bab 3 Kod Bersih, tumpuan adalah pada tugas menulis yang kecil, tertumpu dan melakukan satu perkara dengan baik.
Dalam artikel ini, kita akan menyelami prinsip ini dan meneroka cara menggunakannya dalam JavaScript.
Satu prinsip teras Kod Bersih ialah fungsi mestilah kecil.
Tetapi apakah maksud "kecil" dalam konteks ini? Pengarang menyokong fungsi yang biasanya hanya beberapa baris panjang.
Ideanya ialah fungsi kecil lebih mudah difahami, diuji dan diselenggara.
Mari kita lihat contoh dalam JavaScript:
// Bad Example: A large, unfocused function function processOrder(order) { applyDiscount(order); calculateShipping(order); calculateTax(order); generateInvoice(order); sendConfirmationEmail(order); updateInventory(order); }
Fungsi ini, walaupun kelihatan mudah, melakukan terlalu banyak. Setiap tugasan ini boleh dan harus dipecahkan kepada fungsinya sendiri.
// Good Example: Small, focused functions function processOrder(order) { applyDiscount(order); calculateShipping(order); calculateTax(order); generateInvoice(order); sendConfirmationEmail(order); updateInventory(order); } function applyDiscount(order) { // Discount logic } function calculateShipping(order) { // Shipping calculation logic } function calculateTax(order) { // Tax calculation logic } function generateInvoice(order) { // Invoice generation logic } function sendConfirmationEmail(order) { // Email sending logic } function updateInventory(order) { // Inventory update logic }
Dalam contoh yang disemak, setiap fungsi melakukan satu perkara, menjadikan kod lebih mudah dibaca dan diselenggara.
Fungsi processOrder kini berfungsi sebagai orkestra peringkat tinggi, manakala fungsi yang lebih kecil dan lebih fokus mengendalikan butiran.
Sesuatu fungsi harus melakukan satu perkara dan melakukannya dengan baik. Jika anda mendapati diri anda menulis fungsi yang melaksanakan pelbagai tugas, ini adalah tanda bahawa anda harus memfaktorkannya semula kepada fungsi yang lebih kecil.
Ini contohnya:
// Bad Example: A function doing multiple things function formatAndSendEmail(email, subject, message) { const formattedMessage = `<html><body>${message}</body></html>`; sendEmail(email, subject, formattedMessage); }
Walaupun fungsi ini kelihatan ringkas, ia melakukan dua perkara: memformat mesej dan menghantar e-mel. Sebaliknya, pecahkannya:
// Good Example: Functions doing one thing function formatMessage(message) { return `<html><body>${message}</body></html>`; } function sendFormattedEmail(email, subject, message) { const formattedMessage = formatMessage(message); sendEmail(email, subject, formattedMessage); }
Kini, setiap fungsi mempunyai satu tanggungjawab, yang menjadikan kod lebih mudah untuk diuji dan digunakan semula.
Fungsi formatMesej boleh diuji secara bebas daripada logik penghantaran e-mel.
Fungsi harus meminimumkan kesan sampingan, bermakna ia tidak seharusnya mengubah keadaan sistem dengan cara yang tidak dijangka. Fungsi dengan kesan sampingan boleh menjadi lebih sukar untuk nyahpepijat dan membuat alasan.
Ini contohnya:
// Bad Example: A function with a side effect let globalCounter = 0; function incrementCounter() { globalCounter++; }
Fungsi incrementCounter mengubah keadaan global, yang boleh membawa kepada pepijat jika tidak diurus dengan teliti.
Pendekatan yang lebih baik ialah mengembalikan nilai baharu dan biarkan pemanggil memutuskan perkara yang perlu dilakukan dengannya:
// Good Example: Avoiding side effects function incrementCounter(counter) { return counter + 1; } globalCounter = incrementCounter(globalCounter);
Dengan mengelakkan kesan sampingan, anda menjadikan fungsi anda lebih mudah diramal dan lebih mudah untuk digunakan.
Fungsi harus beroperasi pada satu tahap abstraksi. Mencampurkan tahap perincian yang berbeza dalam fungsi yang sama boleh menjadikannya lebih sukar untuk difahami.
Contohnya:
// Bad Example: Mixed levels of abstraction function getUserData(userId) { const user = database.fetchUserById(userId); // Low-level return `${user.firstName} ${user.lastName} (${user.email})`; // High-level }
Di sini, fungsi mencampurkan pengambilan pangkalan data peringkat rendah dengan pemformatan peringkat tinggi data pengguna.
Adalah lebih baik untuk memisahkan kebimbangan ini:
// Good Example: Single level of abstraction function getUser(userId) { return database.fetchUserById(userId); } function formatUserData(user) { return `${user.firstName} ${user.lastName} (${user.email})`; } const user = getUser(userId); const formattedUserData = formatUserData(user);
Kini, setiap fungsi beroperasi pada satu tahap abstraksi, menjadikan kod lebih jelas dan lebih mudah diselenggara.
Menulis fungsi bersih ialah asas menulis kod yang boleh diselenggara.
Dengan mengekalkan fungsi kecil, memastikan ia melakukan satu perkara, mengelakkan kesan sampingan dan mengekalkan satu tahap abstraksi, anda boleh membuat kod yang lebih mudah dibaca, difahami dan diselenggara.
Sambil anda terus mengasah kemahiran anda dalam JavaScript, simpan prinsip ini daripada Kod Bersih untuk menulis fungsi yang benar-benar merangkumi seni kesederhanaan dan kejelasan.
Atas ialah kandungan terperinci Memahami Kod Bersih: Fungsi ⚡. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!