In meinem ersten Job als Softwareentwickler dachte ich, ich hätte gute Kenntnisse darüber, wie man gute Anwendungen oder Systeme entwickelt, da ich in der High School das Programmieren gelernt habe. Da bin ich also recht optimistisch. Tatsächlich habe ich nicht wirklich auf meine Codequalität geachtet. Und deshalb war ich bei der nächsten Entwicklung wegen meines eigenen Codes wirklich frustriert. Es ist nicht lesbar und nicht einfach zu pflegen.

Dann wurde mir klar, dass ein gutes System nicht mit einer guten Benutzeroberfläche, großartigen Funktionen und komplizierten Dingen beginnt. Gute Systeme beginnen mit ihrer guten Codequalität.

Nach einer Weile bat ich die damaligen leitenden Ingenieure, mir Vorschläge zu machen, wie ich meine Codequalität verbessern könnte. Und schließlich gaben sie mir einen der bekanntesten guten Ansätze in der Programmierung, er heißt Clean Code .

Es stellt sich heraus, dass es nicht so schwierig ist, unsere Codequalität zu verbessern. Wir müssen nur den Code sauber machen. Sauber bedeutet, all die komplizierten Dinge zu entfernen und sie einfach und lesbar zu machen.

Lassen Sie mich also in diesem Beitrag mitteilen, was ich persönlich tue, um meine Codequalität aufrechtzuerhalten, und ich werde Ihnen einige Beispiele geben, die ich aus Robert J. Martins Clean Code entnommen habe . Es ist ein Programmierbuch. Ich schlage vor, dass Sie in diesem Buch mehr über sauberen Code erfahren, um mehr Details zu erfahren.

Verwenden Sie aussagekräftige Namen

Wir können mit den Namen beginnen. Die Namen der Variablen und Funktionen müssen so aussagekräftig wie möglich sein. Verwenden Sie keine Abkürzungen oder Namen, die nicht aussagekräftig sind. Hier ist ein Beispiel für schlechte und gute Namen.

Schlechte Namen ❌

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

Versuchen Sie, Kommentare zu vermeiden

Stellen Sie sich vor, wir müssten Kommentare pflegen und gleichzeitig Code pflegen. Es wird unsere Zeit verschwenden. Stattdessen sollte der Code selbst informativ sein.

Schlechter Code ❌

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

if (employee.isEligibleForFullBenefits())

Redundanter Kommentar ❌

// 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;
}

Informativer Kommentar ✅

// 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”));

Wir benötigen jedoch keinen Kommentar, wenn unser Code verständlich ist. Wenn wir einen Kommentar erstellen und jemand den Code ändern muss, können wir nicht bestätigen, dass diese Person den Kommentar ebenfalls aktualisiert hat. Aus diesem Grund müssen wir die Verwendung von Kommentaren nach Möglichkeit vermeiden.

Geben Sie einen konsistenten Funktionsnamen an

Obwohl sie beschreibend sind, sollten Funktionsnamen auch konsistent sein. Dadurch sieht der Code ordentlich aus und es hilft uns, Funktionen einfacher zu finden, da wir schnell die Codebasis durchsuchen können, um nach einem bestimmten Namen zu suchen.

Inkonsistente Namen ❌

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

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

Zeichen in einer Zeile reduzieren

Denken Sie daran, dass wir Code erstellen möchten, der leicht lesbar ist, und wir sollten vermeiden, lange Codezeilen zu haben, indem wir Zeichen in neue Zeilen umbrechen.

Zu lange ❌

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
]);

Ich weiß, dass es verlockend ist, unser Problem mit einer einzigen Funktion zu lösen, und wir erstellen eine Funktion, die viele Dinge tut. Ich denke, wir sollten das vermeiden, um die Komplexität der Funktion zu minimieren.

Komplexe Funktion ❌

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

Abgesehen davon halte ich es auch für eine schlechte Idee, zu viele Parameter zu verwenden, da es uns erschweren wird, diese Funktion an vielen verschiedenen Stellen aufrechtzuerhalten. Es wäre also gut, wenn wir die Funktionsparameter minimieren könnten.

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

function buildCar(Wheel wheel, Engine engine);

Damals gab es einige Bedenken hinsichtlich der Codeformatierung, jeder Entwickler hat seine eigene Codeformatierung. Ich weiß nicht, wessen Schreibformat ich folgen soll und wie die idealste Formatierung zum Schreiben von Code ist.

Glücklicherweise gibt es im Clean-Code-Ansatz Formatierungskonventionen. Ich denke, in diesem Fall müssen wir den Deal haben, also wäre es gut, wenn jeder Entwickler diesem Szenario folgen würde .

Variablen

Variablen sollten so nah wie möglich an ihrer Verwendung deklariert werden.

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() { ... }
}

Abhängige Funktionen sollten vertikal nah sein.

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() {}
}

Viele Entwickler versuchen, die horizontale Ausrichtung ihres Codes der einer anderen Codezeile anzupassen.

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;
}

Der einfachste Weg, unseren Code lesbar zu machen, besteht darin, auf die Einrückung unseres Codes zu achten. Hier ist ein Beispiel.

public String functionName() {return "";}

public String functionName() {
    return "";
}

Zunächst einmal vielen Dank, dass Sie diesen Artikel gelesen haben. Ich finde den Artikel ziemlich lang. Aber ich hoffe, es wird für Entwickler nützlich sein, besonders für diejenigen, die neu in dieser technischen Welt sind.

Ich möchte ein paar Worte machen, um dies zu beenden, und ich würde sagen, dass die Codequalität eines der wichtigsten Dinge ist, um die wir uns als Entwickler kümmern müssen. Sonst würden wir in Zukunft unsere Zeit kosten, schlimmer noch, die Organisation und die Teams schwer kosten. Und wir können damit beginnen, die Qualität unseres Codes zu verbessern, indem wir sauberen Code implementieren .

Sauberer Code hat nicht nur Vorteile für Sie, sondern verbessert auch die Produktivität von Teams oder allen an den Projekten Beteiligten. Ihr Code wird verständlicher, lesbarer und pflegeleichter. Und ich denke, es ist eine entscheidende Fähigkeit, die jeder Entwickler beherrschen sollte.