Refactoring - Convertir les attributs en ensembles

Favoriser l'immuabilité en convertissant les attributs en ensembles

TL;DR : L'utilisation d'ensembles pour les attributs simplifie votre code et facilite la gestion de l'état

Problèmes résolus

• Mutabilité
• Complexité
• Les attributs deviennent pollués
• Setteurs

Odeurs de code associées

Code Odeur 35 - État en tant que propriétés

Maxi Contieri ・ 27 novembre 2020

#oop #tutoriel #webdev #programmation

Code Odeur 28 - Setters

Maxi Contieri ・ 19 novembre 2020

#oop #codenewbie #programmation #webdev

Code Smell 34 - Trop d'attributs

Maxi Contieri ・ 25 novembre 2020

#oop #codenewbie #programmation

Mesures

1. Identifier les attributs représentant les états
2. Remplacez les attributs par des ensembles : un pour chaque état
3. Ajustez les méthodes pour déplacer les éléments entre les ensembles au lieu de muter les attributs

Exemple de code

Avant

class Bill {
  amount: number;
  paid: boolean;

  constructor(amount: number) {
    this.amount = amount;
    this.paid = false;
  }

  pay() {
    if (!this.paid) {
      this.paid = true;
    }
  }
}

const bill = new Bill(100);
console.log(bill.paid); // false
bill.pay();
console.log(bill.paid); // true

Après

// 1. Identify attributes representing states

class Accountant {  
   // 2. Replace the attributes with sets: one for each state
  unpaidBills: Set<Bill>;
  paidBills: Set<Bill>;

  constructor() {
    this.unpaidBills = new Set();
    this.paidBills = new Set();
  }

  addBill(bill: Bill) {
    this.unpaidBills.add(bill);
  }

  payBill(bill: Bill) {    
    // 3. Adjust methods to move items
    // between sets instead of mutating attributes
    if (this.unpaidBills.has(bill)) {
      this.unpaidBills.delete(bill);
      this.paidBills.add(bill);
    }
  }
}

class Bill {
  amount: number;

  constructor(amount: number) {
    this.amount = amount;
  }
}

const bill = new Bill(100);
const accountant = new Accountant();
accountant.addBill(bill);
console.log(accountant.unpaidBills.has(bill)); // true
accountant.payBill(bill);
console.log(accountant.paidBills.has(bill)); // true

Taper

[X] Semi-automatique

Sécurité

Cette refactorisation est sûre lorsque vos attributs ne reposent pas sur un comportement d'indexation spécifique.

Puisque les ensembles ne maintiennent pas l'ordre des éléments, vérifiez si votre logique dépend de l'ordre.

Pourquoi le code est-il meilleur ?

Les entités sont immuables par essence.

L'utilisation d'ensembles garantit l'unicité et simplifie la logique.

Vous n'avez plus besoin de vérifier les doublons avant d'ajouter des éléments.

Les opérations telles que l'union, l'intersection et la différence deviennent simples, ce qui rend votre code plus maintenable et flexible.

Limites

Les ensembles ne préservent pas l'ordre des éléments.

Si votre logique dépend de la séquence, la conversion en un ensemble peut ne pas être appropriée et vous devez utiliser une collection ou un tableau ordonné

Refactorisation de l'IA

Vous pouvez demander à vos assistants IA de réaliser cette refactorisation pour vous.

Essayez-les !

Without Proper Instructions	With Specific Instructions
ChatGPT	ChatGPT
Claude	Claude
Perplexity	Perplexity
Copilot	Copilot
Gemini	Gemini

Balises

• Mutabilité

Refactorisations associées

https://dev.to/mcsee/refactoring-001-remove-setters-26cg

Voir aussi

Les pouvoirs maléfiques des mutants

Maxi Contieri ・ 19 décembre 20

#webdev #programmation #mutation #oop

Crédits

Image d'Angelo Giordano dans Pixabay

---

Cet article fait partie de la série Refactoring.

Comment améliorer votre code avec des refactorisations faciles

Maxi Contieri ・ 24 octobre 22

#webdev #débutants #programmation #tutoriel

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!