Die 20 häufigste Codierungsprobleme für Anfänger

German (Deutsch) translation by Nikol Angelowa (you can also view the original English article)

Unabhängig von unserem aktuellen Kenntnisstand waren wir einmal Anfänger. Klassische Anfängerfehler zu machen ist ganz normal. Heute haben wir verschiedene Autoren von Nettuts+ Mitarbeitern gebeten, sich mit ihrer Liste von Fallstricken und Lösungen in einer Vielzahl von Sprachen einzuschalten.

Lernen Sie aus unseren Fehlern und machen Sie sie nicht!

JavaScript-Tipps

1 - Unnötige DOM-Manipulation

Das DOM ist langsam. Wenn Sie Ihre Interaktion damit einschränken, wird die Leistung Ihres Codes erheblich gesteigert. Betrachten Sie den folgenden (schlechten) Code:

1	// anti-pattern
2	for (var i = 0; i < 100; i++){
3	var li = $("<li>").html("This is list item #" + (i+1));
4	$("#someUL").append(li);
5	}

Dieser Code ändert das DOM tatsächlich 100 Mal und erstellt unnötigerweise 100 jQuery-Objekte. 100! Ein korrekterer Ansatz wäre, entweder ein Dokumentfragment zu verwenden oder eine Zeichenfolge zu erstellen, die die 100 <li/> -Elemente enthält, und diesen HTML-Code dann an das enthaltende Element anzuhängen. Auf diese Weise springen Sie insgesamt einmal in das DOM. Hier ist ein Beispiel:

var liststring = "";

for (var i = 100; i > 0; i--){
	liststring += "<li>This is list item #" + (99- i);
}

document.getElementById("someUL").innerHTML(liststring);

Wie oben erwähnt, berühren wir mit dieser Technik das DOM nur einmal, was eine Verbesserung darstellt, aber es beruht auch auf der Verkettung von Zeichenfolgen, um eine große Zeichenfolge zu erstellen. Es gibt eine andere Möglichkeit, dies mithilfe von Arrays zu erreichen.

var liststring = "<li>"
var lis = [];

for (var i = 100; i > 0; i--){
	lis.push("This is list item #" + (99- i));
}

liststring += lis.join("</li><li>") + "</li>";
document.getElementById("someUL").innerHTML(liststring);

Wenn Sie große Zeichenfolgen erstellen, ist das Speichern jedes Teils der Zeichenfolge als Element in einem Array-Element und das Aufrufen von join() wohl eleganter als die Verkettung von Zeichenfolgen. Dies ist eine der schnellsten und einfachsten Möglichkeiten, sich wiederholendes HTML in JavaScript zu erstellen, ohne eine Vorlagenbibliothek oder ein Framework zu verwenden.

2 - Inkonsistente Variablen- und Funktionsnamen in JavaScript

Dieses nächste Element ist kein Leistungsproblem, aber äußerst wichtig - insbesondere, wenn Sie an Code arbeiten, an dem auch andere Personen arbeiten. Halten Sie Ihre Bezeichner (Variablen- und Funktionsnamen) konsistent. Betrachten Sie die folgenden Variablen als Beispiel:

1	var foo = "bar";
2	var plant = "green";
3	var car = "red";

Es wäre nicht sinnvoll, eine weitere Variable namens Something hinzuzufügen. Dies führt zu Inkonsistenzen in Ihrem Variablenbenennungsmuster, was dazu führt, dass Ihr Gehirn diese Variable kognitiv als anders oder speziell kennzeichnet. Aus diesem Grund werden Konstanten in den meisten Sprachen traditionell mit Großbuchstaben definiert.

Sie können noch einen Schritt weiter gehen, indem Sie bei der Benennung von Funktionen eine ähnliche Länge, grammatikalische Struktur und Erklärung beibehalten. Betrachten Sie beispielsweise die folgende erfundene Funktion:

1	function subtractFive(number){
2	return number - 5;
3	}

Die Benennung einer Funktion, die einer bestimmten Zahl fünf hinzufügt, sollte dem hier gezeigten Muster folgen:

1	function addFive(number){
2	return number + 5;
3	}

Manchmal können Sie eine Funktion benennen, um ihren Rückgabewert anzugeben. Sie können beispielsweise eine Funktion benennen, die eine HTML-Zeichenfolge getTweetHTML() zurückgibt. Sie können dem Namen einer Funktion auch do voranstellen, wenn die Funktion einfach eine Operation ausführt und keinen Wert zurückgibt, z. B.: doFetchTweets().

Konstruktorfunktionen folgen normalerweise der Tradition von Klassen in anderen Sprachen, wobei der erste Buchstabe groß geschrieben wird:

1	function Dog(color){
2	this.color = color;
3	}

Als allgemeine Faustregel sollten Sie bei der Benennung Ihrer Bezeichner beschreibend sein. Klassifizieren Sie sie zusammen mit anderen ähnlichen Bezeichnern, indem Sie ein lesbares Namensmuster beibehalten, das Hinweise auf die Art des Zwecks einer Variablen oder Funktion bietet.

3 - Verwenden Sie `hasOwnProperty()` in `for...in` Loops

Die Arrays von JavaScript sind nicht assoziativ. Der Versuch, sie als solche zu benutzen, wird von der Gemeinschaft verpönt. Objekte hingegen können als Hash-Tabellen behandelt werden, und Sie können die Eigenschaften eines Objekts durchlaufen, indem Sie die for...in-Schleife wie folgt verwenden:

1	for (var prop in someObject) {
2	alert(someObject[prop]); // alert's value of property
3	}

Das Problem ist jedoch, dass die for...in-Schleife jede aufzählbare Eigenschaft in der Prototypenkette des Objekts durchläuft. Dies kann problematisch sein, wenn Sie nur die Eigenschaften verwenden möchten, die für das tatsächliche Objekt vorhanden sind.

Sie können dieses Problem mithilfe der Methode hasOwnProperty() lösen. Hier ist ein Beispiel:

for (var prop in someObject) {
    if (someObject.hasOwnProperty(prop)) {
        alert(someObject[prop]); // alert's value of property
    }
}

Diese Version warnt nur die Werte der Eigenschaften, die sich direkt auf someObject befinden.

4 - Vergleichen von Booleschen Werten

Das Vergleichen von Booleschen Werten in einer Bedingung ist eine Verschwendung von Rechenzeit. Schauen Sie sich das folgende Beispiel an:

if (foo == true) {
    // do something for true
} else {
    // do something for false
}

Beachten Sie die Bedingung: foo == true. Der Vergleich von foo und true ist nicht erforderlich, da foo bereits ein boolescher Wert ist (oder ein wahrer oder falscher Wert). Anstatt foo zu vergleichen, verwenden Sie es einfach als Bedingung wie folgt:

if (foo) {
    // do something for true
} else {
    // do something for false
}

Verwenden Sie den logischen NOT-Operator wie unten gezeigt, um auf false zu testen:

if (!foo) {
    // do something if foo is false
} else {
    // do something if foo is true
}

5 - Ereignisbindung

Ereignisse sind in JavaScript ein kompliziertes Thema. Vorbei sind die Zeiten der Inline-onclick-Ereignishandler (außer in einigen sehr seltenen Fällen von "Begrüßungsseiten"). Verwenden Sie stattdessen Ereignisblasen und Delegierung.

Stellen Sie sich vor, Sie haben ein Raster mit Bildern, die zum Starten eines modalen Leuchtkastenfensters erforderlich sind. Folgendes sollten Sie nicht tun. Hinweis: Wir verwenden hier jQuery, vorausgesetzt, Sie verwenden eine ähnliche Bibliothek. Wenn nicht, gelten die gleichen Prinzipien auch für Vanille-JavaScript.

Der relevante HTML:

<div id="grid-container">
	<a href="someimage.jpg"><img src="someimage-thumb.jpg"></a>
	<a href="someimage.jpg"><img src="someimage-thumb.jpg"></a>
	<a href="someimage.jpg"><img src="someimage-thumb.jpg"></a>
	...
</div>

Das (schlechte) JavaScript:

1	$('a').on('click', function() {
2	callLightbox(this);
3	});

In diesem Code wird davon ausgegangen, dass beim Aufrufen des Leuchtkastens ein Ankerelement übergeben wird, das auf das Bild in voller Größe verweist. Anstatt an jedes Ankerelement zu binden, binden Sie stattdessen an das #grid-container-Element.

1	$("#grid-container").on("click", "a", function(event) {
2	callLightbox(event.target);
3	});

In diesem Code beziehen sich sowohl this als auch event.target auf das Ankerelement. Sie können dieselbe Technik für jedes übergeordnete Element verwenden. Stellen Sie einfach sicher, dass Sie das Element definieren, das das Ziel des Ereignisses sein soll.

6 - Vermeiden Sie ternäre Redundanz

Die Überbeanspruchung ternärer Anweisungen ist sowohl in JavaScript als auch in PHP weit verbreitet.

1	// javascript
2	return foo.toString() !== "" ? true : false;

1	// php
2	return (something()) ? true : false;

Ein Bedingungsausdruck gibt immer einen true oder false Wert zurück, was bedeutet, dass Sie nicht explizit true/false als ternäre Werte hinzufügen müssen. Stattdessen können Sie einfach die Bedingung zurückgeben:

1	// javascript
2	return foo.toString() !== "";

1	// php
2	return something();

PHP-Tipps

7 - Verwenden Sie Ternary, wenn dies angemessen ist

if...else-Anweisungen sind ein zentraler Bestandteil der meisten Sprachen. Aber machen Sie etwas Einfaches, wie das Zuweisen eines Werts zu einer Variablen basierend auf einer Bedingung - nun, sie können Ihren Code verschmutzen. Betrachten Sie den folgenden Code:

if ($greeting) 
{
    $post->message = 'Hello';
} 
else 
{
    $post->message = 'Goodbye';
}

Dieser Code kann auf eine Zeile reduziert werden, während die Lesbarkeit mithilfe des ternären Operators wie folgt erhalten bleibt:

1	$post->message = $greeting ? 'Hello' : 'Goodbye';

Es ist klar, präzise und bietet Ihnen die Funktionalität, die Sie benötigen.

So nützlich der ternäre Operator auch ist, die wichtigste Richtlinie ist, ihn nicht zu stark zu verwenden! Das Ziel der Codierung besteht nicht darin, Ihre Logik in so wenige Zeilen wie möglich zu beschränken.

8 - Auslösen von Ausnahmen anstelle von Verschachtelung im Inception-Stil

Seien wir ehrlich: Viele Verschachtelungsebenen sind hässlich und schwer zu pflegen / zu lesen. Der folgende Code ist ein relativ vereinfachtes Beispiel, das sich jedoch mit der Zeit erheblich verschlechtert:

// anti-pattern
$error_message = null;

if ($this->form_validation->run())
{
	if ($this->upload->do_upload())
	{
		$image = $this->upload->get_info();

		if ( ! $this->image->create_thumbnail($image['file_name'], 300, 150))
		{
			$error_message = 'There was an error creating the thumbnail.';
		}
	}
	else
	{
		$error_message = 'There was an error uploading the image.';
	}
}
else
{
	$error_message = $this->form_validation->error_string();
}

// Show error messages
if ($error_message !== null)
{
	$this->load->view('form', array(
		'error' => $error_message,
	));
}

// Save the page
else
{
	$some_data['image'] = $image['file_name'];

	$this->some_model->save($some_data);
}

Das ist ein böser Code, aber Sie können ihn drastisch sauberer machen, indem Sie Ausnahmen verwenden, wie zum Beispiel:

try
{
	if ( ! $this->form_validation->run())
	{
		throw new Exception($this->form_validation->error_string());
	}

	if ( ! $this->upload->do_upload())
	{
		throw new Exception('There was an error uploading the image.');
	}

	$image = $this->upload->get_info();

	if ( ! $this->image->create_thumbnail($image['file_name'], 300, 150))
	{
		throw new Exception('There was an error creating the thumbnail.');
	}
}

// Show error messages
catch (Exception $e)
{
	$this->load->view('form', array(
		'error' => $e->getMessage(),
	));

	// Stop method execution with return, or use exit
	return;
}

// Got this far, must not have any trouble
$some_data['image'] = $image['file_name'];

$this->some_model->save($some_data);

Es kann die gleiche Anzahl von Zeilen sein, aber es ermöglicht wesentlich besser lesbaren und wartbaren Code. Außerdem werden schwierige Debugging-Sitzungen vermieden, bei denen Sie einen möglichen Pfad durch die if-Anweisung verpasst haben. Halte es einfach!

Zweite Meinung: Seien Sie sehr, sehr vorsichtig, wenn Sie Ausnahmen für die Flusskontrolle verwenden. Weitere Informationen finden Sie hier.

9 - `False`-Glückliche Methoden

Ausnahmefreudig zu sein ist weitaus vorteilhafter als falschglücklich zu sein.

Ruby- oder Python-Entwickler sind es gewohnt, nach trivialen Ausnahmen zu suchen. Das klingt zwar langweilig, ist aber eigentlich eine gute Sache. Wenn etwas schief geht, wird eine Ausnahme ausgelöst und Sie wissen sofort, wo das Problem liegt.

In PHP - und insbesondere bei Verwendung älterer Frameworks wie CodeIgniter - erhalten Sie das, was ich als "falsch-fröhlichen Code" bezeichne (im Gegensatz zu ausnahmefreudigem Code). Anstatt eine Ausnahme in Ihrem Gesicht zu haben, gibt sie nur einen false Wert zurück und weist die Fehlerzeichenfolge einer anderen Eigenschaft zu. Dies zwingt Sie, es mit einem get_error(); aus der Klasse zu fischen Methode.

Ausnahmefreudig zu sein ist weitaus vorteilhafter als falschglücklich zu sein. Wenn in Ihrem Code ein Fehler auftritt (z. B. konnte keine Verbindung zu S3 hergestellt werden, um ein Bild hochzuladen, oder ein Wert ist leer usw.), lösen Sie eine Ausnahme aus. Sie können auch bestimmte Arten von Ausnahmen auslösen, indem Sie die Exception-Klasse wie folgt erweitern:

1	class CustomException extends Exception {}

Das Auslösen einer benutzerdefinierten Ausnahme erleichtert das Debuggen erheblich.

Tipp 10 - Verwenden Sie Schutzklauseln

Es ist üblich, if-Anweisungen zu verwenden, um den Ausführungspfad einer Funktion oder Methode zu steuern. Es ist verlockend, eine Bedingung zu testen und viel Code auszuführen, wenn die Bedingung true ist, nur um einfach in die else-Anweisung zurückzukehren. Zum Beispiel:

function someFunction($param) {
    if ($param == 'OK') {
       $this->doSomething();
       return true;
    } else {
       return false;
    }
}

Diese Art von Lösung stellt jedoch ein Potenzial für Spaghetti-Code dar. Sie können das Lesen dieses Codes erleichtern, indem Sie die Bedingung umkehren. Hier ist die bessere Version:

function someFunction($param) {
    if ($param != 'OK') return false;

    $this->doSomething();
    return true;
}

Ist das nicht einfacher zu lesen? Es ist eine einfache Änderung, die die Lesbarkeit Ihres Codes drastisch verbessert.

Tipp 11 - Verwenden Sie `while` für einfache Iterationen

Die for-Schleife wird häufig verwendet, wenn Sie beispielsweise einen Zähler benötigen. Hier ist eine einfache for-Schleife:

1	for (var i = 0; i < x; i++) {
2	...
3	}

Es gibt einige sehr gute Gründe, eine for-Schleife zu verwenden, aber eine while-Schleife ist möglicherweise besser, wenn Sie nur etwas Einfaches wie das folgende benötigen:

1	var i = x;
2
3	while (i--) {
4	...
5	}

Es funktioniert nicht in jeder Situation, aber es ist eine Alternative.

Tipp 12 - Methoden wartbar halten

Dies ist leicht einer der häufigsten Fehler, die Neulinge gemacht haben.

Eine Methode ist die Arbeitseinheit eines Objekts. Wenn Sie Ihre Methoden auf eine wartbare Größe beschränken, können Sie Ihren Code leichter lesen und warten. Schauen Sie sich die folgende Monstermethode an:

class SomeClass {

	function monsterMethod() {
		if($weArePilots) {
			$this->goAndDressUp();
			$this->washYourTeeth();
			$this->cleanYourWeapon();
			$this->takeYourHelmet();
			if($this->helmetDoesNotFit())
				$this->takeAHat();
			else
				$this->installHelmet();
			$this->chekcYourKnife();
			if($this->myAirplain() == "F22")
				$this->goToArmyAirport();
			else
				$this->goToCivilianAirport();
			$this->aim();
			$this->prepare();
			$this->fire();
		}
	}

}

Teilen Sie diese Monstermethode in kleinere, beschreibende Teile auf, die jeweils für die Ausführung einer gut abstrahierten Aktion verantwortlich sind. Dies ist leicht einer der häufigsten Fehler, die Neulinge gemacht haben.

class SomeClass {

	function monsterMethod() {
		if($weArePilots) {
			$this->prepareYourself();
			$this->tryHelmet();
			$this->findYourAirport();
			$this->fightEnemy();
		}
	}

	private function prepareYourself() {
		$this->goAndDressUp();
		$this->washYourTeeth();
		$this->cleanYourWeapon();
		$this->chekcYourKnife();
	}

	private function tryHelmet() {
		$this->takeYourHelmet();
		if($this->helmetDoesNotFit())
			$this->takeAHat();
		else
			$this->installHelmet();
	}

	private function findYourAirport() {
		if($this->myAirplain() == "F22")
			$this->goToArmyAirport();
		else
			$this->goToCivilianAirport();
	}

	private function fightEnemy() {
		$this->aim();
		$this->prepare();
		$this->fire();
	}

}

Los geht's: sauberer und einfacher zu debuggen!

Schritt 13 - Vermeiden Sie tiefes Verschachteln

Zu viele Verschachtelungsebenen erschweren das Lesen und Verwalten von Code. Folgendes berücksichtigen:

function doSomething() {
    if ($someCondition) {
        if ($someOtherCondition) {
            if ($yetSomeOtherCondition) {
                doSomethingSpecial();
            }

            doSomethingElse();
        }
    }
}

Sie können sich auf Tipp 10 beziehen, um das Lesen dieses Codes zu vereinfachen, indem Sie einige der Bedingungen umkehren.

function doSomething() {
    if (!$someCondition) {
        return false;
    }

    if (!$someOtherCondition) {
        return false; 
    }

    if ($yetSomeOtherCondition) {
        doSomethingSpecial();
    }

    doSomethingElse();
}

Dieser Code ist erheblich sauberer und führt zu den gleichen Ergebnissen wie zuvor.

Wenn Sie verschachtelte if-Anweisungen haben, überprüfen Sie Ihren Code genau. Ihre Methode führt möglicherweise mehr als eine Aufgabe aus. Hier ist ein Beispiel:

function someFunc() {
	if($oneThing) {
		$this->doSomething();
		if($anotherThing)
			$this->doSomethingElse();
	}
}

Extrahieren Sie in diesen Fällen die verschachtelten Methoden in ihre eigene Methode:

function someFunc() {
	if($oneThing) {
		$this->doSomething();
		$this->doAnotherThing($anotherThing);
	}
}

private doAnotherThing($anotherThing) {
	if($anotherThing)
		$this->doSomethingElse();
}

Tipp 14 - Vermeiden Sie magische Zahlen und Zeichenfolgen

Magische Zahlen und Strings sind böse. Definieren Sie Variablen oder Konstanten mit den Werten, die Sie in Ihrem Code verwenden möchten.

An Stelle von:

function someFunct() {
	$this->order->set(23);
	$this->order->addProduct('superComputer');
	$this->shoppingList->add('superComputer');
}

Geben Sie an, was diese Zahlen und Zeichenfolgen bedeuten, und weisen Sie sie einer Variablen mit einem aussagekräftigen Namen zu:

function someFunct() {
	$orderId = 23;
	$selectedProductName = 'superComputer';

	$this->order->set($orderId);
	$this->order->addProduct($selectedProductName);
	$this->shoppingList->add($selectedProductName);
}

Während einige argumentieren könnten, dass wir unnötig Variablen erstellen, ist der Leistungseinbruch vernachlässigbar. Die Lesbarkeit hat immer Vorrang. Denken Sie daran: Optimieren Sie die Leistung erst, wenn Sie beschreiben können, warum dies erforderlich ist.

Schritt 15 - Verwenden Sie integrierte Array-Funktionen

Verwenden Sie die integrierten Array-Funktionen anstelle von foreach().

Nicht ideal:

1	foreach (&$myArray as $key =>$element) {
2	if ($element > 5) unset ($myArray[$key]);
3	}

Besser:

1	$myArray = array_filter($myArray, function ($element) { return $element <= 5;});

PHP bietet eine Vielzahl von Array-Methoden. Sie sind zunächst verwirrend, aber nehmen Sie sich einen Tag Zeit und versuchen Sie, so viele wie möglich zu lernen.

Tipp 16 - Variablen nicht überbeanspruchen

Es ist leicht, Variablen zu überbeanspruchen, aber denken Sie daran, dass Variablen im Speicher gespeichert sind. Für jede von Ihnen erstellte Variable muss das System Speicher für diese Variable zuweisen. Schauen Sie sich diesen Code an:

public function get_posts() {
	$query = $this->db->get('posts');
	$result = $query->result();
	return $result;
}

Die Variable $result ist nicht erforderlich. Der folgende Code lässt diese Variable weg:

1	public function get_posts() {
2	$query = $this->db->get('posts');
3	return $query->result();
4	}

Der Unterschied ist subtil, aber wir konnten dieses einfache Beispiel verbessern. Wir haben die Variable $query beibehalten, da sie sich auf die Datenbank bezieht, während sich $result mehr auf unsere Logik bezieht.

Allgemeine Programmierempfehlungen

Tipp 17 - Verlassen Sie sich auf das Datenbankmodul

Alles andere ist ein Code-Geruch.

Eine Datenbank dient zum Arbeiten mit Daten. Verwenden Sie seine Tools und Fähigkeiten, um Ihre Anwendung effizienter zu gestalten.

Beispielsweise können Sie redundante Datenbankabfragen unter vielen Umständen vermeiden. Die meisten Plug-and-Play-Benutzerverwaltungsskripte verwenden zwei Abfragen für die Benutzerregistrierung: eine, um zu überprüfen, ob die E-Mail / der Benutzername bereits vorhanden ist, und eine, um sie tatsächlich zur Datenbank hinzuzufügen. Ein viel besserer Ansatz besteht darin, das Feld Benutzername auf UNIQUE zu setzen. Sie können dann native MySQL-Funktionen verwenden, um zu überprüfen, ob der Datensatz zur Datenbank hinzugefügt wurde oder nicht.

Tipp 18: Benennen Sie Ihre Variablen richtig

Die Tage der Benennung Ihrer Variablen x, y, z sind vorbei (es sei denn, Sie haben es natürlich mit einem Koordinatensystem zu tun). Eine Variable ist ein wichtiger Teil Ihrer Logik. Sie möchten keinen langen Namen eingeben? Holen Sie sich eine bessere IDE. Moderne IDEs vervollständigen Variablennamen im Handumdrehen automatisch.

Codieren Sie in sechs Monaten immer. Sind Sie sicher, dass Sie sich daran erinnern werden, worauf sich diese $sut-Variablen in einem Jahr beziehen? Wahrscheinlich nicht: beschreibend sein. Alles andere ist ein Code-Geruch.

Tipp 19 - Methoden repräsentieren Aktionen

Fehler passieren; Der Schlüssel ist, von ihnen zu lernen.

Benennen Sie Ihre Methoden mit Verben, die die von ihnen ausgeführte Aktion darstellen. Das Hauptkonzept ist das genaue Gegenteil des Variablennamensschemas. Verwenden Sie einen kurzen, aber beschreibenden Namen in einem großen Bereich (dh öffentliche Methoden) und einen längeren und detaillierteren Namen in einem kurzen Bereich (dh private / geschützte Methoden). Dies hilft dabei, Ihren Code wie eine gut geschriebene Prosa zu lesen.

Vermeiden Sie auch andere Sprachen als Englisch, wenn Sie Ihre Methoden benennen. Es ist ärgerlich, Funktionsnamen wie 做些什麼() oder делатьчтото() in Ihrem Projekt zu lesen. Für andere Programmierer ist es möglicherweise unmöglich, Ihre Absicht zu verstehen. Während es arrogant erscheinen mag, ist Englisch die angenommene Sprache des Codes. Versuchen Sie es zu benutzen, wenn wir in einem großen Team arbeiten.

Tipp 20: Strukturempfehlungen

Schließlich ist die Codestruktur für die Lesbarkeit und Wartbarkeit genauso wichtig wie alles andere, worüber wir heute gesprochen haben. Hier sind zwei Empfehlungen:

Einrückung mit vier oder zwei Leerzeichen. Alles andere, z. B. acht Leerzeichen, ist zu viel und erschwert das Lesen Ihres Codes.
Stellen Sie eine angemessene Linienbreite ein und respektieren Sie diese. Vierzig Zeichen in einer Zeile? Wir sind nicht mehr in den 70ern; Setzen Sie Ihr Limit auf 120 Zeichen, markieren Sie den Bildschirm und zwingen Sie sich oder Ihre IDE, dieses Limit einzuhalten. 120 Zeichen geben Ihnen eine schöne Breite, ohne dass Sie scrollen müssen.

Abschluss

"Ich habe noch nie einen dummen Programmierfehler gemacht." -- Niemand.

Fehler passieren. Der Schlüssel ist, von ihnen zu lernen. Wir bei Nettuts+ haben Fehler gemacht und werden dies auch weiterhin tun. Wir hoffen, dass Sie aus unseren Fehlern lernen, damit Sie sie in Zukunft vermeiden können. Aber um ehrlich zu sein, ist der beste Weg, die besten Sachen zu lernen, die Fehler selbst zu machen!

Danke fürs Lesen!