Gagnez du temps et simplifiez votre code avec les DTO : L’astuce qui transforme la gestion de vos données !

Développement web Optimisation Backend Dev Bonnes pratiques
Architecture Logicielle PHP Laravel
Tim
February 26th, 2025
image description

Votre code est fragile ? Et si on arrêtait de bricoler ?

Imaginez : vous travaillez sur une plateforme qui collecte des leads (prospects) via des formulaires. Une fois collectés, ces leads sont envoyés à plusieurs partenaires.

👉 Problème : Chaque partenaire attend un format différent…

Partenaire

Champ Email

Champ Téléphone

Format Date

Partenaire A

email

phone

YYYY-MM-DD

Partenaire B

user_email

tel

DD/MM/YYYY

Partenaire C

courriel

mobile_number

MM-DD-YYYY

Et bien sûr, les données brutes collectées ne sont pas propres :

  • Certains emails sont en majuscules.

  • Les numéros de téléphone contiennent parfois des espaces.

  • La date d’inscription est dans un format ISO.

1️⃣ Approche classique : le code spaghetti

Sans DTO, vous finissez avec du code bordélique :

php 
function formatLeadForPartnerA($lead) {
    return [
        'email' => strtolower(trim($lead['email'])),
        'phone' => str_replace(' ', '', $lead['phone']),
        'date' => date('Y-m-d', strtotime($lead['created_at']))
    ];
}

function formatLeadForPartnerB($lead) {
    return [
        'user_email' => strtolower(trim($lead['email'])),
        'tel' => str_replace(' ', '', $lead['phone']),
        'date' => date('d/m/Y', strtotime($lead['created_at']))
    ];
}

function formatLeadForPartnerC($lead) {
    return [
        'courriel' => strtolower(trim($lead['email'])),
        'mobile_number' => str_replace(' ', '', $lead['phone']),
        'date' => date('m-d-Y', strtotime($lead['created_at']))
    ];
}

👎 Problèmes :

  • ❌ Code dupliqué partout 🚨.

  • ❌ Difficile à maintenir : si demain, on change le format de téléphone, on doit le modifier partout.

  • ❌ Risque élevé d'erreurs.

2️⃣ Solution propre : Utilisation d'un DTO

On va centraliser toute la logique dans une classe unique qui gère la transformation des leads.

Création du DTO

php 
class LeadDTO {
    public string $email;
    public string $phone;
    public string $createdAt;

    public function __construct(array $data) {
        $this->email = strtolower(trim($data['email']));
        $this->phone = str_replace(' ', '', $data['phone']);
        $this->createdAt = $data['created_at'];
    }

    public function formatForPartner(string $partner): array {
        switch ($partner) {
            case 'A':
                return [
                    'email' => $this->email,
                    'phone' => $this->phone,
                    'date' => date('Y-m-d', strtotime($this->createdAt))
                ];
            case 'B':
                return [
                    'user_email' => $this->email,
                    'tel' => $this->phone,
                    'date' => date('d/m/Y', strtotime($this->createdAt))
                ];
            case 'C':
                return [
                    'courriel' => $this->email,
                    'mobile_number' => $this->phone,
                    'date' => date('m-d-Y', strtotime($this->createdAt))
                ];
            default:
                throw new Exception("Format partenaire inconnu");
        }
    }
}

Utilisation du DTO

php 
$lead = new LeadDTO($rawLeadData);

$formattedLeadA = $lead->formatForPartner('A');
$formattedLeadB = $lead->formatForPartner('B');
$formattedLeadC = $lead->formatForPartner('C');

👍 Avantages immédiats :

  • 💘 Une seule classe centralise toute la logique.

  • ⚡ Ajout d’un nouveau partenaire ultra-simple (une seule méthode à modifier)

  • 🧹 Données toujours propres et cohérentes

3️⃣ Ça marche aussi ailleurs que pour les leads

Le principe du DTO est réutilisable dans d’autres situations :

  • ✅ E-commerce : normalisation des commandes avant envoi aux transporteurs

  • ✅ Facturation : transformation des données clients pour plusieurs systèmes comptables

  • ✅ Gestion RH : conversion des profils employés pour différents logiciels

💡 Exemple e-commerce : On envoie des commandes à plusieurs transporteurs qui ont des formats différents.

php 
class OrderDTO {
    public string $customerName;
    public string $address;
    public string $orderDate;

    public function __construct(array $data) {
        $this->customerName = trim($data['customer_name']);
        $this->address = trim($data['address']);
        $this->orderDate = $data['created_at'];
    }

    public function formatForCarrier(string $carrier): array {
        switch ($carrier) {
            case 'UPS':
                return [
                    'name' => $this->customerName,
                    'addr' => $this->address,
                    'date' => date('Y-m-d', strtotime($this->orderDate))
                ];
            case 'FedEx':
                return [
                    'recipient' => $this->customerName,
                    'location' => $this->address,
                    'shipping_date' => date('d/m/Y', strtotime($this->orderDate))
                ];
            default:
                throw new Exception("Transporteur inconnu");
        }
    }
}

Conclusion : DTO = moins de bugs, plus de sérénité

Un DTO est une solution puissante pour structurer et normaliser les données avant leur traitement ou leur export.

Avec cette approche :

  • 🎯 Les données sont centralisées : une seule source de vérité

  • 📖 Le code est plus lisible et facile à maintenir

  • 💪 On s’adapte facilement aux différents formats sans tout casser

Et surtout… on gagne du temps ! ⏱️

Merci encore d'avoir suivi jusqu'au bout. Je vous souhaite un bon code !