Warum sauberer Code wichtig ist

In verschiedenen Beratungsprojekten ist mir in letzter Zeit aufgefallen, dass sich immer wieder das Gleiche wiederholt: Clustered Code. Was meine ich damit? Nun, lassen Sie es mich so sagen. Wenn Sie programmieren, sollten Sie an sauberen Code denken. Ja, ich weiß, da draußen redet noch jemand über sauberen Code. Warum solltest du mir zuhören? Seit ich 12 Jahre alt war, interessierte ich mich für Computer und wie Dinge funktionieren. Als ich 15 Jahre alt war, fing ich an, Pluralsight anzuschauen, eine Reihe von Videos über MVVM, MVC, Architektur usw. Ich habe mir jede Menge Videos angeschaut, wusste aber noch nicht, wie man programmiert. Ich habe mitgemacht, aber ich erinnere mich, dass ich vieles nicht verstand, was vor sich ging.

In den letzten Jahren habe ich als Architekt und leitender Softwareentwickler für verschiedene Unternehmen gearbeitet. Mein Hintergrund liegt in der Informatik und einer IT-Ausbildung. Und wie Sie alle wissen, versuche ich, mit Ihnen zu teilen, was ich weiß, um Menschen zu helfen, aber auch um Bekanntheit zu erlangen, wie alle Menschen da draußen auf LinkedIn. Ja, sie lieben das Schreiben nicht so sehr, wie Sie denken; Es ist ein reines Geschäftsmodell. Aber das spielt keine Rolle, oder? Also hier ist es. Hoffentlich kaufen Sie eines Tages eines meiner Produkte. ;)

Jetzt möchte ich Ihnen erzählen, was ich in letzter Zeit bei verschiedenen Projekten gesehen habe. Ich denke, dass der Grund dafür, dass sauberer Code nicht immer angewendet wird, nicht unbedingt darin liegt, dass die Leute nicht über das nötige Wissen verfügen. Dabei geht es oft um strenge Fristen und Druck durch unterschiedliche Projekte. Wenn Sie ein Softwareentwickler wie ich oder ein Projektmanager sind, wissen Sie, dass es bestimmte Einschränkungen und Zeitdruck gibt, damit ein Projekt erfolgreich ist.

Um den Kunden zu beliefern, und selbst wenn Sie intern arbeiten, sind Sie mit Fristen und unterschiedlichen Interessengruppen konfrontiert. Unternehmen arbeiten häufig mit einem Abonnementmodell, bei dem Kunden regelmäßig neue Funktionen erwarten. Das bringt viele Herausforderungen mit sich. Entwickler und Projektplaner müssen das Projekt vorantreiben, ohne in die Falle architektonischer Schulden zu tappen, weil sie nicht genug Zeit hatten, die Lösung gründlich zu durchdenken.

Sobald das Problem einmal da ist, ist es wirklich schwierig, es wieder zu beheben. Meiner Erfahrung nach kehren die Leute nicht oft zurück, um ihre Projekte umzugestalten – zumindest nicht die Leute, die ich kenne. Lassen Sie mich wissen, wenn Sie anders sind. Es gibt verschiedene Dinge, die Sie zum Refactoring tun können, und es hilft sehr, aber das Problem ist, dass es keine Priorität hat. Wenn der Code funktioniert und der Kunde zufrieden ist, steht Refactoring nicht ganz oben auf der Liste. Aber denken wir zwei, drei Jahre im Voraus. Was passiert, wenn der Code immer mehr geclustert wird?

Am Ende müssen Sie möglicherweise viele Entwickler einstellen, um die monolithische Architektur in eine Microservices-Architektur umzuwandeln, was viel Geld kostet. Aus diesem Grund sollten Sie über sauberen Code nachdenken – nicht nur, wenn Sie ein Projekt starten, nicht nur, wenn Sie aufwachen, sondern jederzeit. Denn irgendwann wird es dich wieder beißen, wenn du es nicht anwendest.

Praktische Strategien für sauberen Code

Konsistente Codeüberprüfungen
Regelmäßige Codeüberprüfungen stellen die Einhaltung von Codierungsstandards sicher und erkennen potenzielle Probleme frühzeitig.

Automatisiertes Testen
Die Implementierung automatisierter Tests, einschließlich Unit-Tests, Integrationstests und End-to-End-Tests, hilft dabei, Probleme zu erkennen, bevor sie in die Produktion gelangen.

Regelmäßiges Refactoring
Planen Sie in Ihrem Projektplan speziell Zeit für das Refactoring ein, um die Anhäufung technischer Schulden zu verhindern und die Wartbarkeit Ihrer Codebasis zu gewährleisten.

Einführung solider Prinzipien
Die SOLID-Prinzipien (Single Responsibility, Open-Closed, Liskov Substitution, Interface Segregation und Dependency Inversion) bieten einen Rahmen zum Schreiben von sauberem und wartbarem Code.

Klare Dokumentation
Das Schreiben einer klaren und prägnanten Dokumentation hilft neuen Entwicklern, die Codebasis schneller zu verstehen und verringert die Wahrscheinlichkeit von Fehlern.

Paarprogrammierung
Durch die Paarprogrammierung können zwei Entwickler gemeinsam am selben Code arbeiten, Fehler frühzeitig erkennen und Wissen unter den Teammitgliedern teilen.

Langfristige Vorteile von Clean Code

Reduzierte Wartungskosten
Sauberer Code ist einfacher zu warten, wodurch Zeit und Geld für die Behebung von Fehlern und die Implementierung neuer Funktionen reduziert werden.

Verbesserte Lesbarkeit und Verständlichkeit
Eine saubere Codebasis ist leichter zu lesen und zu verstehen, entscheidend für das Onboarding neuer Entwickler und für die langfristige Projektnachhaltigkeit.

Verbesserte Leistung
Gut strukturierter Code führt zu einer besseren Leistung, indem er unnötige Komplexität vermeidet und die Ressourcennutzung optimiert.

Größere Skalierbarkeit
Sauberer Code ermöglicht eine einfachere Skalierung von Anwendungen, vereinfacht das Hinzufügen neuer Funktionen und die Anpassung an sich ändernde Anforderungen.

Erhöhte Entwicklerzufriedenheit
Die Arbeit mit sauberem Code reduziert Frustration und erhöht die Arbeitszufriedenheit der Entwickler, was zu höherer Produktivität und geringeren Fluktuationsraten führt.

Beispiel für unordentlichen Code

<?php

class User extends security\Session
{
  protected $app;

  public function __construct($app)
  {
    $this->app = $app;
  }

  public function addSkill(Application $app, Request $request)
  {
    $userInput['id'] = $request->request->get('id', null);
    $userInput['id'] = preg_replace("/[^0-9,.]/", "", $userInput['id']);

    $app['checkpoint']->minimumRole(1);
    $user = $app['session']->get('user', []);
    $userId = $user['profile']['easyJobAddressId'];

    if ($userInput['id'] === null) {
      return $app->json(['ok' => true]);
    }

    $app['dbs']['appMySql']->insert('skills', [
      'skillId' => $userInput['id'],
      'userId' => $userId,
      'rank' => 0
    ]);

    return $app->json(['ok' => true]);
  }
}

Refactored Code

Der überarbeitete Code entspricht den Clean-Code-Prinzipien, indem er Verantwortlichkeiten aufschlüsselt, Abhängigkeitsinjektion verwendet und SOLID-Prinzipien befolgt.

Abhängigkeitsinjektion und Konstruktor

public function __construct(
    UserRoleService $userRoleService, RequestStack $requestStack,
    UserRepository $userRepository,
    EasyJobServiceInterface $easyJobService,
    SkillsRepository $skillsRepository,
    AppDataService $appDataService
) {
    $this->userRoleService = $userRoleService;
    $this->requestStack = $requestStack;
    $this->userRepository = $userRepository;
    $this->easyJobService = $easyJobService;
    $this->skillsRepository = $skillsRepository;
    $this->appDataService = $appDataService;
}

Durch das Einfügen von Abhängigkeiten stellen wir sicher, dass jede Klasse eine einzige Verantwortung hat und einfach getestet und gewartet werden kann.

Einzelne Verantwortung für das Hinzufügen von Fähigkeiten

#[Route('/profile/experience/add', name: 'profile_experience_add', methods: ['POST'])]
public function addExperience(Request $request): JsonResponse
{
    $this->denyAccessUnlessGranted('ROLE_USER');
    $skillId = $request->request->get('id');

    if (!is_numeric($skillId)) {
        return $this->json(['status' => 'error', 'message' => 'Invalid skill ID']);
    }

    $userId = $this->getUser()->getId();
    $result = $this->appDataService->addSkillToUser($userId, (int) $skillId);

    return $this->json(['status' => 'ok', 'added' => $result]);
}

Hier verwenden wir eine spezielle Methode, um das Hinzufügen von Fähigkeiten zu handhaben. Es gewährleistet die Validierung und folgt einer klaren, prägnanten Struktur.

Trennung der Belange

public function index(): Response {
    $user = $this->getUser();
    $userId = $user->getId();

    $allSkills = [90, 10, 11, 12, 13, 20, 21, 22, 23, 30, 31];
    $skills = array_fill_keys($allSkills, 0);

    $userSkills = $this->appDataService->getSkillsByUserId($userId);
    foreach ($userSkills as $skill) {
        $skillId = $skill->getSkillId();
        if (array_key_exists($skillId, $skills)) {
            $skills[$skillId] = 1;
        }
    }
}

Beachten Sie, wie wir appDataService verwenden, um das System zu entkoppeln.
Durch die Trennung von Belangen konzentrieren wir jede Methode auf eine einzelne Aufgabe, wodurch der Code einfacher zu lesen und zu warten ist.

Fazit

Denken Sie abschließend immer an sauberen Code. Es mag jetzt vielleicht nicht dringend erscheinen, aber es zu vernachlässigen, kann später zu erheblichen Problemen führen. Die Priorisierung von sauberem Code wird in Zukunft Zeit, Geld und Kopfschmerzen sparen. Regelmäßiges Refactoring und die Einhaltung von Codierungsstandards sind der Schlüssel zur Aufrechterhaltung einer gesunden Codebasis. Denken Sie daran, dass sich der Aufwand, den Sie heute in das Schreiben von sauberem Code stecken, auf lange Sicht auszahlt und Ihre Projekte skalierbarer, wartbarer und angenehmer macht.

Das obige ist der detaillierte Inhalt vonWarum sauberer Code wichtig ist. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!