Nel mio primo lavoro come ingegnere del software, pensavo di avere una buona conoscenza di come sviluppare buone applicazioni o sistemi da quando ho imparato a programmare al liceo. Quindi sono piuttosto ottimista allora. In effetti, non ho davvero prestato attenzione alla qualità del mio codice. E per questo motivo, nello sviluppo successivo, mi sono trovato davvero frustrato a causa del mio stesso codice. Non è leggibile e non è facile da mantenere.

Poi ho iniziato a rendermi conto che un buon sistema non inizia con una buona interfaccia, grandi funzionalità e cose complicate. I buoni sistemi iniziano con la loro buona qualità del codice.

Dopo un po', ho chiesto agli ingegneri senior di darmi suggerimenti su come migliorare la qualità del mio codice. E alla fine, mi hanno dato uno dei buoni approcci più conosciuti nella programmazione, si chiama Clean Code .

Si scopre che migliorare la qualità del nostro codice non è poi così difficile. Dobbiamo solo rendere il codice pulito. Pulire significa rimuovere tutte le cose complicate e renderle semplici e leggibili.

Quindi, in questo post, vorrei condividere ciò che faccio personalmente per mantenere la qualità del mio codice e ti darò alcuni esempi che ho preso da Clean Code di Robert J. Martin . È un libro di programmazione. Ti suggerisco di esplorare di più sul codice pulito in quel libro per ottenere maggiori dettagli.

Usa nomi descrittivi

Possiamo cominciare dai nomi. I nomi delle variabili e delle funzioni devono essere quanto più descrittivi possibile. Non utilizzare abbreviazioni o nomi privi di significato. Ecco un esempio di nomi cattivi e buoni.

Brutti nomi ❌

const fn = 'Farizal';
const ln = 'Hamami';

function full() {
    return fn + ln;
}

const firstName = 'Farizal';
const lastName = 'Hamami';

function getFullName() {
    return firstName + lastName;
}

— Robert C. Martin

Cerca di evitare di usare i commenti

Immagina se dovessimo mantenere i commenti mantenendo anche il codice. Ci farà perdere tempo. Invece, il codice stesso dovrebbe essere informativo.

Codice sbagliato ❌

// Check to see if the employee
// is eligible for full benefits
if ((employee.flags & HOURLY_FLAG) && (employee.age > 65))

if (employee.isEligibleForFullBenefits())

Commento ridondante ❌

// Declare first name
const firstName = 'Farizal';

// Declare last name
const lastName = 'Hamami';

/**
  Get full name by combining
  first name and last name
*/
function getFullName() {
    return firstName + lastName;
}

Commento informativo ✅

// SimpleDateFormat is not thread-safe,
// so we need to create each instance independently.
const dateFormat = new SimpleDateFormat(
  ”EEE, dd MMM yyyy HH:mm:ss z”);
df.setTimeZone(TimeZone.getTimeZone(”GMT”));

Tuttavia, non richiediamo un commento se il nostro codice è comprensibile. Se creiamo un commento e qualcuno deve modificare il codice, non possiamo confermare che anche questa persona abbia aggiornato il commento. Ecco perché dobbiamo evitare di utilizzare i commenti quando possibile.

Assegna un nome di funzione coerente

Nonostante siano descrittivi, anche i nomi delle funzioni dovrebbero essere coerenti. Renderà il codice più ordinato e ci aiuterà a trovare le funzioni più facilmente, poiché possiamo scansionare rapidamente la base di codice alla ricerca di un nome specifico.

Nomi incoerenti ❌

class Circle {
    public function getRadius() {...}
    public function fetch_color() {...}
    public function retrieveArea() {...}
}

class Circle {
    public function getRadius() {...}
    public function getColor() {...}
    public function getArea() {...}
}

Ridurre i caratteri in una riga

Tieni presente che vogliamo creare un codice facile da leggere e dovremmo evitare di avere lunghe righe di codice suddividendo i caratteri in nuove righe.

Troppo lungo ❌

throw ValidationException::withMessages(['email' => trans('auth.failed'), 'error' => 'Your password is incorrect', 'redirect' => true]);

throw ValidationException::withMessages([
    'email' => trans('auth.failed'),
    'error' => 'Your password is incorrect',
    'redirect' => true
]);

So che è allettante risolvere il nostro problema con una singola funzione e creiamo una funzione che fa molte cose. Penso che dovremmo evitare di farlo per minimizzare la complessità della funzione.

Funzione complessa ❌

function createAppointment(appointment) {
    const patientList = this.$api.get('patient');
    const currentPatient = patientList.find((patient) => {
        patient.id = appointment.patient_id
    });
    const selectedDoctor = doctorList.find((doctor) => {
        doctor.id = appointment.doctor_id
    });
    const selectedLocation = locationList.find((location) => {
        location.id = appointment.location_id
    });
    this.sendAppointment(selectedDoctor, selectedDoctor, currentPatient);
}

function createAppointment(appointment) {
    const currentPatient = getCurrentPatient(this.patientId);
    this.sendAppointment(
      appointment,
      currentPatient
    );
}

— Robert C. Martin

A parte questo, mi sembra che usare troppi parametri sia anche una cattiva idea perché ci renderà difficile mantenere quella funzione in molti posti diversi. Quindi sarebbe bene se potessimo ridurre al minimo i parametri della funzione.

function buildCar(float wheelDiameter, float wheelColor, float wheelMaterial, float wheelManufacturer, String engineType, String engineColor, String engineManufacturer);

function buildCar(Wheel wheel, Engine engine);

All'epoca c'erano alcuni problemi di formattazione del codice, ogni sviluppatore ha la propria formattazione del codice. Non so quale formato di scrittura dovrei seguire e come la formattazione più ideale sia scrivere codice.

Fortunatamente, ci sono convenzioni di formattazione nell'approccio Clean Code. Penso che, in questo caso, dobbiamo concludere l'accordo, quindi sarebbe bello se ogni sviluppatore seguisse questo scenario .

Variabili

Le variabili dovrebbero essere dichiarate il più vicino possibile al loro utilizzo.

function paySalary(Employee employee) {
    const bonus = calculateBonus(employee);
    const totalSalary = bonus + employee.getSalary();
    sendMoney(employee, totalSalary);
}

public class Employee {
    private String name;
    private String id;
    private float salary;
    
    public function getName() { ... }
}

Le funzioni dipendenti dovrebbero essere vicine verticalmente.

function paySalary() {
    calculateBonus(salary);
}

function calculateBonus(salary) {
    return (salary / 10);
}

class Employee {
    public function payTax() {}

    public function payOverdueTax(date) {}

    public function increaseSalary() {}

    public function decreaseSalary() {}
}

Molti sviluppatori stanno cercando di rendere l'allineamento orizzontale del loro codice uguale a un'altra riga di codice.

public class WebService {
    private    Request         request;
    private    Response        response;
    private    FitnesseContext context;
    protected. long            requestTimeLimit;
}

public class WebService {
    private Request request;
    private Response response;
    private FitnesseContext context;
    protected long requestTimeLimit;
}

Il modo più semplice per rendere leggibile il nostro codice è prestare attenzione all'indentazione del nostro codice. Ecco un esempio.

public String functionName() {return "";}

public String functionName() {
    return "";
}

Prima di tutto, grazie per aver letto questo articolo. Penso che l'articolo sia piuttosto lungo. Ma spero che sarà utile per gli sviluppatori, specialmente per quelli che sono nuovi a questo mondo tecnico.

Voglio fare un paio di parole per porre fine a questo, e direi che la qualità del codice è una delle cose più importanti di cui dobbiamo prenderci cura come sviluppatore. Altrimenti, il nostro tempo in futuro costerebbe, peggio ancora, costerebbe molto all'organizzazione e ai team. E possiamo iniziare a migliorare la qualità del nostro codice implementando codice pulito .

Il codice pulito non solo ha vantaggi per te, ma migliorerà anche la produttività dei team o di chiunque sia coinvolto nei progetti. Il tuo codice sarà più comprensibile, leggibile e facile da mantenere. E penso che sia un'abilità cruciale che ogni sviluppatore dovrebbe padroneggiare.