Ist es sinnvoll, toten Code zu schreiben?

Finden Sie es nützlich, toten Code zu schreiben?

Einige sagen: "Wenn Sie zwei Logikfunktionen haben, um eine Operation auszuführen, machen Sie den Code tot, anstatt einen anderen Logikcode zu kommentieren oder zu entfernen, da dies die Operation nicht beeinträchtigt."

Beispiel:-

if(true){
    // logic - 1
} else {
    // logic - 2  // dead code
}

Ist es wahr?

Normalerweise schreibe ich keine toten Codes, sondern entferne nur die zweite Logik.

IMO ist es schlimmer als sinnlos.

Darüber hinaus ist eine Verschwendung von Zeit zu sein, gibt es Ihnen (oder den nächsten Mann) die Illusion , dass Sie einen Code haben , die , wenn Sie ändern arbeiten truezu false. Es ist nur eine Illusion ... es sei denn, Sie testen es.

Und natürlich ist es Unordnung, die das Lesen des Codes erschwert.

Wenn Sie irgendeine Art von totem SCM-Code verwenden, ist dieser selten nützlich. Sie sollten es stattdessen löschen, und wenn Sie jemals den Code für Logik 2 sehen müssen, rufen Sie ihn aus dem SCM-Repository ab.

Bearbeiten:

Wenn Sie toten Code haben und andere Teile des Codes warten, können Sie versuchen, einen Code zu verwenden, der möglicherweise den toten Code aufdeckt. Wenn jemand anderes die Wartung durchführt, kann es sein, dass er den tatsächlich toten Code nicht kennt, und selbst wenn er dies tut, wird er mit Sicherheit nicht wissen, warum er noch vorhanden ist.

Wenn Sie dann annehmen, dass eine Methode gelöscht werden könnte, da sie nicht von "lebendem" Code, sondern nur von totem Code verwendet wird, müssen Sie entweder Ihren toten Code ändern (und höchstwahrscheinlich brechen) oder den Code der anderen Methode selbst tot machen.

Am Ende würden Sie mit Sicherheit in eine Art Wartungshölle geraten.

Der beste Code ist also gelöschter Code, da er nicht zu falschen Ergebnissen führen oder Maintainer ablenken kann. :)

Nein, das ist schlecht, weil es Ihren Code überfüllt und die Wartbarkeit verringert.

Normalerweise gibt es einen klaren Grund, eine der alternativen "Logiken" zu bevorzugen. Dieser Grund (und das Vorhandensein einer abgelehnten Alternative) sollte in einem Codekommentar dokumentiert werden. In dem relativ unwahrscheinlichen Fall, dass der Grund ungültig wird, kann der alternative Code aus dem Repository-Verlauf abgerufen werden (sofern dies die zuvor bevorzugte, implementierte Lösung war) oder unter Verwendung des vollständigen aktuellen Wissens und der aktuellen Anforderungen ausgearbeitet und implementiert werden (sofern dies nur vage ist) Idee).

Der Betrieb wird dadurch nicht beeinträchtigt, die Wartung wird jedoch beeinträchtigt. Sie möchten den Code so sauber wie möglich halten, um die Wartung zu vereinfachen.

Ich bin ehrlich verwirrt von dem, was du tust.

In absteigender Reihenfolge:

1. Sie sollten Codeänderungen irgendwo aufzeichnen , damit Sie sie vergleichen können, wenn der neue Code nicht funktioniert. Dies sollte immer in der Quellcodeverwaltung sein. Ich nehme an, Sie machen das schon. Wenn nicht, tun Sie alles, um irgendeine Form der Quellcodeverwaltung zu erhalten. Wenn Sie unbedingt darauf verzichten müssen (und ich habe in meinem Leben noch nie von einem Anlass gehört, bei dem dies eine gute Idee ist), sollten Sie zumindest regelmäßige Sicherungen des Zustands der Quelle leicht zugänglich machen.

2. Angenommen, Sie führen Nummer 1 aus, damit Sie bei Bedarf toten Code wiederherstellen können. Behalten Sie ihn NICHT langfristig im Live-Code. Es wird nur verwirrend sein, zusätzliche Komplexität für keinen Wert hinzufügen, Wartung erfordern, nicht mehr mit dem Live-Code synchronisiert werden und die Leute in Zukunft irreführen, usw. usw.

3. Es gibt jedoch bestimmte Situationen, in denen eine Umschaltung der Kompilierungszeit zwischen zwei Codepfaden sinnvoll ist. Während der Entwicklung des neuen Codes und unmittelbar danach kann es zweckmäßig sein, beide zu haben, sodass Sie problemlos zwischen diesen wechseln können. Wenn Sie wahrscheinlich zurückschalten oder eine externe Konfigurationsoption hinzufügen müssen, gibt ein auf einer Konstante basierendes if diesen einen vernünftigen Aktualisierungspfad. Also, wie viele Dinge - wenn es ein bestimmtes Problem löst, mach es. Wenn nicht, meide es.

Ich gehe davon aus, dass die Leute dies zu oft tun, weil sie (oftmals zu Recht) Zweifel haben, dass die Leute die Versionskontrollhistorie tatsächlich lesen, wenn sie ein Problem haben. Aus Angst, der neue Code wird nicht funktionieren und eine einfache Option zum Umkehren wünschen. Ein Kompromiss, um zu versuchen, Sie beide zu erfüllen, könnte darin bestehen, einen Kommentar "Geändert, um zu berechnen ... am (Datum). Wenn Probleme auftreten, siehe alte Version in der Quellcodeverwaltung" oder ähnliches.

Nein, es ist nicht nützlich. Dieser elseBlock erfüllt keinen Zweck. Wenn Sie sich nicht sicher sind, welche Implementierung Sie verwenden sollen, kommentieren Sie sie aus, erstellen Sie separate Klassen oder speichern Sie sie an einer anderen Stelle. Außerdem verfügen Sie meistens über einen lokalen oder fernen Verlauf Ihrer Quelldateien oder sollten dies zumindest tun.

Der tote Code sollte vom Compiler entfernt werden, wenn die Bedingung von einer Kompilierungszeitkonstante abhängt, so dass es technisch nicht schaden würde, ihn beizubehalten. Ich ziehe es jedoch vor, ihn zu kommentieren, da dies die Lesbarkeit des Codes verbessert.

Wenn Sie schnell zwischen zwei Codealternativen wechseln möchten, können Sie das folgende praktische Kommentarkonstrukt verwenden:

//*
alternative 1 is active
/*/
alternative 2 is commented out
//*/

Wenn Sie nur das erste /in der ersten Kommentarzeile entfernen , wird dies zu:

/*
alternative 1 is commented out
/*/
alternative 2 is active
//*/

Mit dieser Option können Sie zwischen den Alternativen wechseln, indem Sie nur eine einzelne /im Code hinzufügen oder entfernen .

Dies mag auf den ersten Blick etwas seltsam aussehen, aber sobald Sie sich daran gewöhnt haben, werden Sie es leicht als eine Art Muster erkennen.

Sie können dies sogar verketten und so mehrere Blöcke gleichzeitig mit einem einzigen Zeichen schalten:

//*
first block of code for alternative 1
/*/
first block of code for alternative 2
/*/
second block of code for alternative 1
/*/
second block of code for alternative 2
//*/

Ich würde es nicht so benutzen, aber es funktioniert.

Es gibt einige sehr seltene Fälle, in denen der alte Code und die Tatsache, dass er ersetzt wurde, wirklich im Quellcode verbleiben sollten, damit zukünftige Programmierer vor etwas gewarnt werden, das nicht intuitiv ist. In diesem Fall muss auch in einer Art Kommentar erklärt werden, warum es noch da ist und was passiert ist.

Wie immer geht es beim Schreiben von Programmen, die einfach zu warten sind, darum, die Dinge klarer zu gestalten und nicht nur strengen Regeln zu folgen. Wenn das Belassen des toten Codes das Verstehen der Vorgänge erleichtert, lassen Sie ihn an. Wenn nicht, nehmen Sie ihn heraus.

Es wird vom Compiler ignoriert. Ich stimme Ihnen jedoch zu und würde nur die else-Anweisung entfernen. Angenommen, Sie verwenden die Versionskontrolle, können Sie den alten Code weiterhin anzeigen, indem Sie den Verlauf der Datei anzeigen.

Dies ist wahrscheinlich eine persönliche Meinung, aber ich finde toten Code störend, wenn ich einen Teil des Codes pflege. Für eine bestimmte Aufgabe haben Sie immer mehr als einen Weg, um sie zu erledigen. Sie müssen sich also für einen entscheiden. Recherchieren Sie, bewerten Sie die Algorithmen und wählen Sie eine aus. Danach muss der Code keine alternativen Methoden mehr enthalten.

Wenn es zwei sehr starke Konkurrenten gibt, schreiben Sie eine kleine Notiz über die Alternative und stecken Sie sie in ein Projekt-Wiki oder an eine andere Stelle, die Projektdokumentation enthält. Wenn Sie möchten, können Sie einen einzeiligen Kommentar einfügen, der sich auf dieses Dokument bezieht und erläutert, warum Sie es lesen möchten.

Ich kann mir nicht sofort eine Situation vorstellen, in der ich es nützlich fand, toten Code zu schreiben. Wenn es alternative Algorithmen gibt, dann:

• Entweder Sie behalten die nützlichste und eliminieren die andere,
• oder die Algorithmen sind auf verschiedene Umstände anwendbar, und dann behalten Sie beide bei, und die Bedingung identifiziert die Umstände, wenn Sie den ersten Algorithmus verwenden.

In beiden Fällen erhalten Sie keinen toten Code.

Wenn Sie Ihren toten Code nicht löschen oder kommentieren, müssen Sie ihn pflegen, um Compilerfehler zu vermeiden. Es ist Zeitverschwendung. Löschen Sie es einfach, wenn Sie ein SCM haben.

NEIN

Einige Programmierer verwenden diesen Stil als Alternative zu Kommentaren und finden ihn elegant.

if (1 == 0) 
{
    std::cout <<"I am a dead code capable of resurrection, once a programmer changes the condition!";
}

Die einfache Antwort ist ein einfaches Nein. Toter Code sorgt für Verwirrung und das Auftreten von Fehlern. Sobald Sie ein Zeichen in den Code eingeben, besteht ein Risiko. Fügen Sie also nicht mehr hinzu, als Sie müssen.

Das einzige Mal, dass ich etwas Ähnliches schreiben musste, war eine Problemumgehung für einen Compiler-Fehler. Es wurde sogar vom Compiler-Hersteller empfohlen, diese Problemumgehung zu verwenden.

Testen Sie toten Code, den Sie schreiben? Tun Sie irgendetwas, um zu bestätigen, dass es wahrscheinlich gut ist? Wenn nicht, lassen Sie es los.

Vergewissern Sie sich bei zukünftigen Codeänderungen, dass der tote Code noch funktioniert? Wenn nicht, lassen Sie es los.

Sie wollen keinen schlechten Code in Ihren Programmen, auch wenn er nicht verwendet wird. Wenn es dort ist, kann es verwendet werden. Normalerweise möchten Sie keine zwei Codeversionen verwalten, wenn Sie nicht beide verwenden, da dies zusätzliche Arbeit bedeutet und sich für die meisten Leute sinnlos anfühlt, den toten Code nicht gut zu verarbeiten.

Es kann Gründe geben, auskommentierten Code (oder in C oder C ++ #ifdefauskommentierten Code) beizubehalten. Dies sollte jedoch mit Kommentaren dahingehend begleitet werden, warum er noch vorhanden ist und welchem ​​Zweck er dient.

Beachten Sie, dass in Java aufgrund von nicht erreichbarem Code Folgendes nicht kompiliert werden kann:

int someFunc() {
    return 10;
    int x = 12;
    return x;
}

Wenn mit Ihrem Code etwas nicht in Ordnung ist, sollten Sie ihn so früh wie möglich finden, anstatt ihn in die Produktion gehen zu lassen und von Ihren Benutzern gefunden zu werden.

Wenn Ihr Compiler eine Fehlerklasse findet, lassen Sie ihn den Compiler finden. IMHO versucht jemand, durch das Schreiben von totem Code in der von Ihnen beschriebenen Weise, diesen Compilerfehler zu umgehen, sodass alle Probleme, die er verursachen könnte, zur Laufzeit auftauchen können.

Sie können argumentieren, dass toter Code nicht erreicht werden kann, also keine Probleme verursachen kann, aber beim Kommentieren, Klammern und Einrücken kann etwas schief gehen, was dazu führen könnte.

Der Grund, warum Leute eine alte Logik auskommentieren, ist, dass sie Angst haben, große Änderungen am Code vorzunehmen. Und in der Tat, eine Woche später zu realisieren, dass der alte Code tatsächlich korrekt war und man ihn jetzt von Grund auf neu schreiben muss, ist eine Hündin. Aber dafür ist die Quellcodeverwaltung gedacht. Wenn Sie sich entscheiden, eine Logik zu ändern, haben Sie keine Angst, den etwas funktionierenden aktuellen Code zu verlieren. Entfernen Sie es und überlassen Sie Ihrem SVN / Git / TFS die Versionsverwaltung.

Wenn dies nicht der Fall ist und Sie nur zwei verschiedene Logikelemente erstellt haben, um etwas zu tun, weil Sie sich nicht für YAGNI oder DRY interessieren, stellen Sie einfach sicher, dass Sie es an einem Ort ablegen, an dem die Leute es verwenden können. Vielleicht werfen Sie ein Strategiemuster, wenn Sie Lust dazu haben. Tun Sie diese "wenn ... sonst" -Dinge einfach nicht, es ist schlechtes Design und ein Problem, das es zu bewahren gilt. Wenn Sie wirklich der Meinung sind, dass ein Code das Recht hat, zu existieren, stellen Sie sicher, dass Sie ihn verwenden können.

Ein weiterer Aspekt ist, dass die meisten professionellen Programmierer der Meinung sind, dass die Größe des Codes der Feind ist. Schauen Sie sich diese Blog-Beiträge an: Der beste Code ist überhaupt kein Code von Jeff Atwood, dem schlimmsten Feind von Steve Yegge. Hier finden Sie noch viel mehr.

Die Leute tun eine Menge, um ihren Code präzise zu halten und zu verhindern, dass die Codebasis zu groß wird, oft sogar, indem sie Leistungseinbußen hinnehmen (wo es nicht wichtig ist). Glauben Sie wirklich, dass 100 Zeilen toter Code eine gute Sache sein können?

Ich habe nur festgestellt, dass dies in Fällen nützlich ist, in denen Sie schnell etwas deaktivieren und testen / nachfüllen möchten (Angenommen, das Programm führt die Schritte A, B, C aus - alles dauert lange. Während des Nachfüllens können Sie B und C deaktivieren vorläufig, um es zu beschleunigen, wenn Sie wissen, dass sie nicht notwendig sind).
Aber die Wahrheit ist, dass dies in allen Fällen sehr hackig ist. Und wenn Sie eine langfristige Nutzung Ihres Abfüllcodes feststellen, sollten Sie Ihren Code so schreiben, dass er mithilfe von config eine Auswahl trifft, anstatt solche Hacks zu verwenden.
Meine Faustregel lautet, dass diese Art von Code niemals eingecheckt wird. Wenn Sie eine Eincheck- / Versionskontrolle benötigen, bedeutet dies, dass Sie bald darauf zurückgreifen können, und dies ist angesichts sich ändernder Anforderungen immer eine schlechte Sache.

Tatsächlich gibt es eine Möglichkeit, "toten" Code zu haben: Wenn Ihr Programm eine große Ausnahme auslösen soll, weil es etwas erreicht hat, das niemals hätte passieren dürfen. Dies ist entweder ein Compilerfehler, oder wenn jemand in der Zeile die Logik in dem von Ihnen verwendeten Test geändert und den Fehler behoben hat. In jedem Fall sendet Ihr "sonst" ein Feuerwerk. In diesem Fall möchten Sie es zur Veröffentlichung freigeben.

Es ist von entscheidender Bedeutung, dass die Fehlermeldung so etwas wie "Panik: Wir sollten uns niemals in Zeile% d in Datei% s befinden" ...