Refactoring - Convertir les attributs en ensembles-js tutoriel-php.cn

Refactoring - Convertir les attributs en ensembles

Barbara Streisand

Libérer： 2024-10-20 11:33:02

original

715 Les gens l'ont consulté

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

Refactoring - Convert Attributes to Sets

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

Identifier les attributs représentant les états
Remplacez les attributs par des ensembles : un pour chaque état
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

Copier après la connexion

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

Copier après la connexion

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é