# Amélioration de la lisibilité du code et de la maintenance

Discussion avec Copilot peut vous suggérer des moyens de rendre votre code plus facile à comprendre et à maintenir.

Le code avec une lisibilité médiocre est difficile pour les autres développeurs de maintenir et d’étendre. Discussion avec Copilot peut vous aider de plusieurs façons. Par exemple, en :

* [Suggérer des améliorations apportées aux noms de variables](#improving-variable-names)
* [Éviter les vérifications conditionnelles séquentielles](#avoiding-sequential-conditional-checks)
* [Réduction de la logique imbriquée](#reducing-nested-logic)
* [fractionner les grandes méthodes en méthodes plus petites et plus lisibles](#splitting-up-large-methods)

La documentation de votre code est une autre façon d’améliorer la maintenance de votre code. Pour plus d'informations sur l'utilisation de Discussion avec Copilot afin d'ajouter des commentaires utiles à votre code, consultez les exemples d'invites dans la section [Documentation du code](/fr/copilot/copilot-chat-cookbook/documenting-code).

> \[!NOTE] Les réponses décrites dans cet article sont des exemples. Les réponses Discussion avec Copilot ne sont pas déterministes, vous pouvez donc obtenir des réponses différentes de celles affichées ici.

## Amélioration des noms de variables

Les noms de variables descriptifs et les noms de paramètres facilitent la compréhension de leur objectif.

### Exemple de scénario

Ce code JavaScript consigne un message sur l’âge d’une personne dans la console. Les noms de paramètres abstraits rendent difficile la compréhension de l’objectif du code.

```javascript id=log-persons-age
function logPersonsAge(a, b, c) {
  if (c) {
    console.log(a + " is " + b + " years old.");
  } else {
    console.log(a + " does not want to reveal their age.");
  }
}
```

### Exemple d’invite

Dans l'éditeur, sélectionnez la fonction que vous souhaitez modifier, puis demandez Discussion avec Copilot :

```copilot copy prompt ref=log-persons-age
Improve the variable names in this function
```

### Exemple de réponse

Copilot propose des noms de variables descriptifs.

```javascript
function logPersonAge(name, age, revealAge) {
  if (revealAge) {
    console.log(name + " is " + age + " years old.");
  } else {
    console.log(name + " does not want to reveal their age.");
  }
}
```

## Éviter les contrôles conditionnels séquentiels

```
          `if...else` chaînes peuvent être difficiles à lire, en particulier lorsqu’elles sont longues.
```

### Exemple de scénario

Ce code Python imprime le son que les différents animaux fabriquent, s’ils sont définis ou « Animal inconnu » si le type d’animal n’est pas reconnu. Toutefois, la chaîne d’instructions `if...else` rend le code inefficace et fastidieux.

```python id=animal-sound
class Animal:
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        return "Woof!"

class Cat(Animal):
    def speak(self):
        return "Meow!"

class Bird(Animal):
    def speak(self):
        return "Tweet!"

def animal_sound(animal_type):
    if animal_type == "dog":
        return Dog().speak()
    elif animal_type == "cat":
        return Cat().speak()
    elif animal_type == "bird":
        return Bird().speak()
    else:
        return "Unknown animal"

print(animal_sound("dog"))
print(animal_sound("cat"))
print(animal_sound("bird"))
print(animal_sound("fish"))
```

### Exemple d’invite

```copilot copy prompt ref=animal-sound
Simplify this code. Avoid using if/else chains but retain all function return values.
```

### Exemple de réponse

Copilot propose d'utiliser un dictionnaire pour associer les types d'animaux aux classes correspondantes.

```python
class Animal:
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        return "Woof!"

class Cat(Animal):
    def speak(self):
        return "Meow!"

class Bird(Animal):
    def speak(self):
        return "Tweet!"

def animal_sound(animal_type):
    animals = {
        "dog": Dog,
        "cat": Cat,
        "bird": Bird
    }
    animal_class = animals.get(animal_type, Animal)
    return animal_class().speak() if animal_class != Animal else "Unknown animal"

print(animal_sound("dog"))
print(animal_sound("cat"))
print(animal_sound("bird"))
print(animal_sound("fish"))
```

## Réduire la logique imbriquée

Les structures profondément imbriquées peuvent rendre le code difficile à suivre, ce qui complique la modification ou l'extension de la logique du code à l'avenir.

### Exemple de scénario

Ce code Ruby imprime des informations sur un compte d’utilisateur en fonction de trois paramètres. L’utilisation d’instructions `if...else` imbriquées rend le code inutilement complexe.

```ruby id=determine-access
def determine_access(user_role, has_permission, is_active)
  if user_role == "admin"
    if has_permission
      if is_active
        "Active admin account with full access."
      else
        "Inactive admin account."
      end
    else
      "Admin account lacks necessary permissions."
    end
  else
    "Access denied."
  end
end

puts determine_access("admin", true, true)
puts determine_access("admin", true, false)
puts determine_access("admin", false, true)
puts determine_access("user", true, true)
```

### Exemple d’invite

```copilot copy prompt ref=determine-access
Rewrite this code to avoid the nested if/else statements
```

### Exemple de réponse

Copilot suggère d'utiliser des clauses de garde pour traiter les conditions au plus tôt et renvoyer les messages appropriés.

```ruby
def determine_access(user_role, has_permission, is_active)
  return "Access denied." unless user_role == "admin"
  return "Admin account lacks necessary permissions." unless has_permission
  return "Inactive admin account." unless is_active

  "Active admin account with full access."
end

puts determine_access("admin", true, true)
puts determine_access("admin", true, false)
puts determine_access("admin", false, true)
puts determine_access("user", true, true)
```

## Fractionnement des méthodes volumineuses

Il peut être difficile de saisir exactement ce qu’une méthode ou une fonction fait s’il est trop long, ce qui rend difficile à maintenir. Les méthodes ou fonctions qui effectuent plusieurs tâches peuvent ne pas être réutilisables dans d’autres contextes. Il peut également être difficile de tester chaque tâche en isolation.

### Exemple de scénario

Cette méthode Java traite une commande client et imprime un message. Elle exécute plusieurs tâches en une seule méthode.

```java id=process-order
public void processOrder(Order order) {
  if (order == null || order.getItems().isEmpty()) {
    throw new IllegalArgumentException("Order is invalid.");
  }

  double totalPrice = 0.0;
  for (Item item : order.getItems()) {
    totalPrice += item.getPrice() * item.getQuantity();
  }
  order.setTotalPrice(totalPrice);

  if (totalPrice > 0) {
    order.setStatus("Processed");
  } else {
    order.setStatus("Pending");
  }

  System.out.println("Order for customer " + order.getCustomerName() + " has been processed. Total price: " + totalPrice);
}
```

### Exemple d’invite

```copilot copy prompt ref=process-order
How could the processOrder method be refactored to be more useful and easier to maintain
```

### Exemple de réponse

Copilot suggère de décomposer cette méthode en méthodes plus petites et plus ciblées.

```java
public void processOrder(Order order) {
    validateOrder(order);
    double totalPrice = calculateTotalPrice(order);
    updateOrderStatus(order, totalPrice);
    printOrderSummary(order, totalPrice);
}

private void validateOrder(Order order) {
    if (order == null || order.getItems().isEmpty()) {
        throw new IllegalArgumentException("Order is invalid.");
    }
}

private double calculateTotalPrice(Order order) {
    double totalPrice = 0.0;
    for (Item item : order.getItems()) {
        totalPrice += item.getPrice() * item.getQuantity();
    }
    order.setTotalPrice(totalPrice);
    return totalPrice;
}

private void updateOrderStatus(Order order, double totalPrice) {
    if (totalPrice > 0) {
        order.setStatus("Processed");
    } else {
        order.setStatus("Pending");
    }
}

private void printOrderSummary(Order order, double totalPrice) {
    System.out.println("Order for customer " + order.getCustomerName() + " has been processed. Total price: " + totalPrice);
}
```

## Pour approfondir

* [Ingénierie rapide pour GitHub Copilot Chat](/fr/copilot/using-github-copilot/prompt-engineering-for-github-copilot)
* [Meilleures pratiques pour l’utilisation de GitHub Copilot](/fr/copilot/using-github-copilot/best-practices-for-using-github-copilot)