Qu'est-ce que le Clean Code et pourquoi c'est important

L'écriture de code qui ne doit être utilisé qu'une seule fois peut être effectuée comme vous le souhaitez. Mais, dans la plupart des cas, il est essentiel d’adhérer aux meilleures pratiques et de maintenir un code propre.

N'oubliez pas que votre code sera probablement lu par un autre développeur, ou même par vous-même, à une date ultérieure. Le moment venu, votre code devrait être explicite. Chaque variable, fonction et commentaire doit être précis, clair et facile à comprendre. Cette approche facilite non seulement la maintenance, mais favorise également la collaboration et l'efficacité au sein de votre équipe de développement.

Ainsi, lorsque quelqu'un (ou vous) reviendra pour ajouter ou modifier votre code, il sera facile de comprendre ce que fait chaque ligne de code. Sinon, la plupart de votre temps sera consacré à simplement essayer de comprendre le code. Le même problème se posera pour un nouveau développeur travaillant sur votre base de code. Ils ne comprendront pas le code s’il n’est pas propre. Par conséquent, il est très important d’écrire du code propre.

Qu’est-ce que le Clean Code ?

Le code propre fait essentiellement référence au code qui est

1. Facile à comprendre
2. Facile à déboguer
3. Facile à entretenir
4. Les commentaires sont bien rédigés, courts et compréhensibles
5. Pas de code en double (redondant) et suit la règle KISS (restez simple, stupide !)

Avec cela, pour écrire du code propre, le développeur doit maintenir la cohérence du code et le développeur doit suivre les meilleures pratiques pour le langage particulier.

Pourquoi le Clean Code est-il important ?

Lorsque les équipes suivent les principes d'un code propre, la base de code devient plus facile à lire et à naviguer. Cela aide les développeurs à comprendre rapidement le code et à commencer à contribuer. Voici quelques raisons pour lesquelles un code propre est important.

1. Lisibilité et maintenance : Il est facile de lire et de comprendre le code lorsqu'il est bien écrit, contient de bons commentaires et suit les meilleures pratiques. Une fois le problème ou le bug survenu, vous savez exactement où le trouver.

2. Débogage : Le code propre est conçu avec clarté et simplicité, ce qui facilite la localisation et la compréhension de sections spécifiques de la base de code. Une structure claire, des noms de variables significatifs et des fonctions bien définies facilitent l'identification et la résolution des problèmes.

3. Qualité et fiabilité améliorées : Un code propre suit les meilleures pratiques de langages particuliers et donne la priorité au code bien structuré. Cela ajoute de la qualité et améliore la fiabilité. Cela élimine ainsi les erreurs qui pourraient survenir en raison d'un code bogué et non structuré.

Maintenant que nous comprenons pourquoi un code propre est crucial, examinons quelques bonnes pratiques et principes pour vous aider à écrire du code propre.

---

Principes du code propre

Pour créer un code de qualité, il faut adhérer aux principes et pratiques d'un code propre, comme l'utilisation de petites méthodes bien définies.

Voyons cela en détail.

1. Évitez les numéros codés en dur

Au lieu d'utiliser directement la valeur, nous pouvons utiliser une constante et lui attribuer cette valeur. Ainsi, à l'avenir, si nous devons mettre à jour cette valeur, nous devrons la mettre à jour à un seul endroit.

Exemple

function getDate() {
  const date = new Date();
  return "Today's date: " + date;
}

function getFormattedDate() {
  const date = new Date().toLocaleString();
  return "Today's date: " + date;
}

Dans ce code, à un moment donné, il y a un changement : au lieu de « Date du jour : » le besoin devient « Date : ». Cela peut être amélioré en attribuant cette chaîne à une variable.

Code amélioré :

const todaysDateLabel = "Today's date: ";

function getDate() {
  const date = new Date();
  return todaysDateLabel + date;
}

function getFormattedDate() {
  const date = new Date().toLocaleString();
  return todaysDateLabel + date;
}

Dans le code ci-dessus, il devient facile de modifier la chaîne de date lorsque cela est nécessaire. Cela améliore la maintenabilité.

2. Utilisez des noms significatifs et descriptifs
Au lieu d'utiliser des noms de variables communs partout, nous pouvons utiliser des noms un peu plus descriptifs et explicites. Le nom de la variable lui-même doit définir son utilisation.

Règles de noms

1. Choisissez des noms descriptifs et sans ambiguïté.
2. Faites une distinction significative.
3. Utilisez des noms prononçables.
4. Utilisez des noms consultables.
5. Remplacez les nombres magiques par des constantes nommées.
6. Évitez les encodages. N'ajoutez pas de préfixes et ne saisissez pas d'informations.

Exemple

// Calculate the area of a rectangle
function calc(w, h) {
    return w * h;
}

const w = 5;
const h = 10;
const a = calc(w, h);
console.log(`Area: ${a}`);

Ici, le code est correct mais il y a un certain flou dans le code. Voyons le code où les noms descriptifs sont utilisés.

Code amélioré

// Calculate the area of a rectangle
function calculateRectangleArea(width, height) {
    return width * height;
}

const rectangleWidth = 5;
const rectangleHeight = 10;
const area = calculateRectangleArea(rectangleWidth, rectangleHeight);
console.log(`Area of the rectangle: ${area}`);

Ici, tous les noms de variables sont explicites. Ainsi, il est facile de comprendre le code et cela améliore la qualité du code.

3. N'utilisez le commentaire que là où c'est nécessaire
Vous n'avez pas besoin d'écrire des commentaires partout. Écrivez simplement là où cela est nécessaire et écrivez de manière courte et facile à comprendre. Trop de commentaires entraîneront de la confusion et une base de code désordonnée.

Règles des commentaires

1. Always try to explain yourself in code.
2. Don't be redundant.
3. Don't add obvious noise.
4. Don't use closing brace comments.
5. Don't comment out code. Just remove.
6. Use as explanation of intent.
7. Use as clarification of code.
8. Use as warning of consequences.

Example

// Function to get the square of a number
function square(n) {
    // Multiply the number by itself
    var result = n * n; // Calculate square
    // Return the result
    return result; // Done
}

var num = 4; // Number to square
var squared = square(num); // Call function

// Output the result
console.log(squared); // Print squared number

Here we can see comments are used to define steps which be easily understand by reading the code. This comments are unnecessary and making code cluttered. Let's see correct use of comments.

Improved code

/**
 * Returns the square of a number.
 * @param {number} n - The number to be squared.
 * @return {number} The square of the input number.
 */
function square(n) {
    return n * n;
}

var num = 4;
var squared = square(num); // Get the square of num

console.log(squared); // Output the result

In above example comments are used only where it is needed. This is good practice to make your code clean.

4. Write Functions That Do Only One Thing
When you write functions, don't add too many responsibilities to them. Follow the Single Responsibility Principle (SRP). This makes the function easier to understand and simplifies writing unit tests for it.

Functions rules

1. Keep it Small.
2. Do one thing.
3. Use descriptive names.
4. Prefer fewer arguments.
5. Split method into several independent methods that can be called from the client.

Example

async function fetchDataAndProcess(url) {
    // Fetches data from an API and processes it in the same function
    try {
        const response = await fetch(url);
        const data = await response.json();

        // Process data (e.g., filter items with value greater than 10)
        const processedData = data.filter(item => item.value > 10);

        console.log(processedData);
    } catch (error) {
        console.error('Error:', error);
    }
}

// Usage
const apiUrl = 'https://api.example.com/data';
fetchDataAndProcess(apiUrl);

In the above example, we can see a function that fetches data using an API and processes it. This can be done by another function. Currently, the data processing function is very small, but in a production-level project, data processing can be very complex. At that time, it is not a good practice to keep this in the same function. This will make your code complex and hard to understand in one go.
Let's see the clean version of this.

Improved code

async function fetchData(url) {
    // Fetches data from an API
    try {
        const response = await fetch(url);
        return await response.json();
    } catch (error) {
        console.error('Error:', error);
        throw error;
    }
}

function processData(data) {
    // Processes the fetched data (e.g., filter items with value greater than 10)
    return data.filter(item => item.value > 10);
}

// Usage
const apiUrl = 'https://api.example.com/data';

fetchData(apiUrl)
    .then(data => {
        const processedData = processData(data);
        console.log(processedData);
    })
    .catch(error => {
        console.error('Error:', error);
    });

In the this example, the responsibilities are separated: the fetchData function handles the API call, and the processData function handles data processing. This makes the code easier to understand, maintain, and test.

5. Avoid Code Duplication (Follow DRY Principle - Don't Repeat Your Self)

To enhance code maintainability and cleanliness, strive to create reusable functions or reuse existing code whenever possible. For instance, if you are fetching data from an API to display on a page, you would write a function that retrieves the data and passes it to a renderer for UI display. If the same data needs to be shown on another page, instead of writing the same function again, you should move the function to a utility file. This allows you to import and use the function in both instances, promoting reusability and consistency across your codebase.

Other General Rules for writing Clean Code

• Follow standard conventions(For JavaScript Camel Case).
• Keep it simple stupid. Simpler is always better. Reduce complexity as much as possible.
• Boy scout rule. Leave the campground cleaner than you found it.
• Always find root cause. Always look for the root cause of a problem.
• Write code which is easy to understand

Implement this Practices and Principles from today to write Clean Code.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!