Memahami Kod Bersih: Sistem ⚡️

Apabila membina sistem perisian, adalah penting untuk mengurus kerumitan asas kod.

Clean Code's Bab 11 membincangkan mereka bentuk sistem modular yang lebih mudah diselenggara dan disesuaikan dari semasa ke semasa.

Kami boleh menggunakan contoh JavaScript untuk menggambarkan konsep ini.

? Masalah dengan Sistem Besar

Apabila sistem berkembang, ia secara semula jadi menjadi lebih kompleks. Kerumitan ini boleh menyukarkan untuk:

• Fahami sistem secara keseluruhan.
• Buat perubahan tanpa menyebabkan kesan sampingan yang tidak diingini.
• Skalakan sistem dengan ciri atau keperluan baharu.

Sistem yang direka bentuk dengan baik hendaklah mudah diubah suai, boleh diuji dan berskala. Rahsia untuk mencapai ini terletak pada modulariti dan pengasingan kebimbangan yang teliti.

? Modulariti: Bahagi dan Takluk

Di tengah-tengah reka bentuk sistem yang bersih ialah prinsip modulariti. Anda menjadikan sistem lebih mudah diurus dengan memecahkan sistem yang besar kepada modul yang lebih kecil dan bebas, masing-masing mempunyai tanggungjawab yang jelas.

Setiap modul harus merangkumi fungsi tertentu, menjadikan keseluruhan sistem lebih mudah difahami dan diubah.

Contoh: Mengadakan Sistem Troli Beli-belah

Mari bayangkan sistem troli beli-belah dalam JavaScript. Daripada menggabungkan semua logik ke dalam satu fail, anda boleh memecahkan sistem kepada beberapa modul:

// cart.js
export class Cart {
    constructor() {
        this.items = [];
    }

    addItem(item) {
        this.items.push(item);
    }

    getTotal() {
        return this.items.reduce((total, item) => total + item.price, 0);
    }
}

// item.js
export class Item {
    constructor(name, price) {
        this.name = name;
        this.price = price;
    }
}

// order.js
import { Cart } from './cart.js';
import { Item } from './item.js';

const cart = new Cart();
cart.addItem(new Item('Laptop', 1000));
cart.addItem(new Item('Mouse', 25));

console.log(`Total: $${cart.getTotal()}`);

Tanggungjawab dibahagikan di sini: Troli menguruskan item, Item mewakili produk dan order.js mengatur interaksi.

Pengasingan ini memastikan setiap modul adalah serba lengkap dan lebih mudah untuk diuji dan diubah secara bebas.

? Enkapsulasi: Sembunyikan Butiran Pelaksanaan

Salah satu matlamat modulariti ialah enkapsulasi—menyembunyikan kerja dalaman modul daripada seluruh sistem.

Kod luaran hanya boleh berinteraksi dengan modul melalui antara muka yang jelas.

Ini menjadikan penukaran pelaksanaan dalaman modul lebih mudah tanpa menjejaskan bahagian lain sistem.

Contoh: Logik Troli Merangkum

Katakan kita mahu menukar cara kita mengira jumlah dalam Troli. Mungkin sekarang kita perlu mengakaunkan cukai jualan. Kita boleh merangkum logik ini di dalam kelas Cart:

// cart.js
export class Cart {
    constructor(taxRate) {
        this.items = [];
        this.taxRate = taxRate;
    }

    addItem(item) {
        this.items.push(item);
    }

    getTotal() {
        const total = this.items.reduce((sum, item) => sum + item.price, 0);
        return total + total * this.taxRate;
    }
}

// Now, the rest of the system does not need to know about tax calculations.

Bahagian lain sistem (seperti order.js) tidak terjejas oleh perubahan dalam cara jumlah dikira. Ini menjadikan sistem anda lebih fleksibel dan lebih mudah diselenggara.

? Pemisahan Kebimbangan: Pastikan Tanggungjawab Jelas

Masalah biasa dalam sistem besar ialah bahagian sistem yang berlainan terjerat.

Apabila modul mula memikul terlalu banyak tanggungjawab, ia menjadi lebih sukar untuk diubah atau digunakan semula dalam konteks yang berbeza.

Prinsip pemisahan kebimbangan memastikan setiap modul mempunyai satu tanggungjawab khusus.

Contoh: Mengendalikan Pembayaran Secara Berasingan

Dalam contoh troli beli-belah, pemprosesan pembayaran hendaklah dikendalikan dalam modul yang berasingan:

// payment.js
export class Payment {
    static process(cart) {
        const total = cart.getTotal();
        console.log(`Processing payment of $${total}`);
        // Payment logic goes here
    }
}

// order.js
import { Cart } from './cart.js';
import { Payment } from './payment.js';

const cart = new Cart(0.07); // 7% tax rate
cart.addItem(new Item('Laptop', 1000));
cart.addItem(new Item('Mouse', 25));

Payment.process(cart);

Kini, logik pembayaran diasingkan daripada pengurusan troli. Ini memudahkan untuk mengubah suai proses pembayaran kemudian (mis., menyepadukan dengan penyedia pembayaran lain) tanpa menjejaskan seluruh sistem.

? Modul Pengujian Secara Bebas

Salah satu faedah terbesar modulariti ialah anda boleh menguji setiap modul secara bebas.

Dalam contoh di atas, anda boleh menulis ujian unit untuk kelas Cart tanpa perlu risau tentang cara pembayaran diproses.

Contoh: Unit Menguji Troli

// cart.test.js
import { Cart } from './cart.js';
import { Item } from './item.js';

test('calculates total with tax', () => {
    const cart = new Cart(0.05); // 5% tax
    cart.addItem(new Item('Book', 20));

    expect(cart.getTotal()).toBe(21);
});

Dengan pemisahan kebimbangan yang jelas, setiap modul boleh diuji secara berasingan, menjadikan penyahpepijatan lebih mudah dan pembangunan lebih pantas.

? Mengendalikan Kebergantungan: Elakkan Gandingan Ketat

Apabila modul bergantung terlalu banyak antara satu sama lain, perubahan dalam satu bahagian sistem boleh menyebabkan akibat yang tidak dijangka di tempat lain.

Untuk meminimumkan ini, bertujuan untuk gandingan longgar antara modul.

Ini membolehkan setiap modul berkembang secara bebas.

Contoh: Menyuntik Kebergantungan

Daripada kebergantungan pengekodan keras di dalam modul, masukkannya sebagai argumen:

// cart.js
export class Cart {
    constructor(taxRateCalculator) {
        this.items = [];
        this.taxRateCalculator = taxRateCalculator;
    }

    addItem(item) {
        this.items.push(item);
    }

    getTotal() {
        const total = this.items.reduce((sum, item) => sum + item.price, 0);
        return total + this.taxRateCalculator(total);
    }
}

Pendekatan ini menjadikan kelas Cart lebih fleksibel dan lebih mudah untuk diuji dengan pengiraan cukai yang berbeza.

Kesimpulan: Pastikan Sistem Bermodul, Fleksibel dan Mudah Diubah

Selamat Pengekodan! ?

Atas ialah kandungan terperinci Memahami Kod Bersih: Sistem ⚡️. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!