6 Tipps zum Schreiben von gutem, sauberem Code

Zusammenfassung: Als Entwickler ist es wichtig, sauberen Code zu schreiben. Daher listet der Autor in diesem Artikel zunächst einige Vorteile des Schreibens von sauberem Code auf und schlägt dann 6 Tipps zum Schreiben von sauberem Code für Entwickler vor um daraus zu lernen. ...

Sauberen Code zu schreiben ist keine leichte Aufgabe und erfordert das Ausprobieren verschiedener Techniken und Praktiken. Das Problem ist, dass es zu diesem Thema so viele Vorgehensweisen und Techniken gibt, dass es für Entwickler schwierig ist, sich zu entscheiden. Vereinfachen Sie das Problem also ein wenig. In diesem Artikel besprechen wir zunächst einige der Vorteile des Schreibens von sauberem Code und besprechen dann sechs Tipps oder Vorgehensweisen zum Schreiben des gängigsten sauberen Codes.

Das Folgende ist der Inhalt des Verzeichnisses:

Vorteile des Schreibens von sauberem Code
Einfacher, ein Projekt zu starten und fortzusetzen
2. Förderlich für die Schulung neuer Teammitglieder
3. Erleichtern Sie das Befolgen von Codierungsmustern

Tipps zum Schreiben von sauberem Code
1. Schreiben Sie lesbaren Code
2. Verwenden Sie aussagekräftige Namen für Variablen, Funktionen und Methoden
3. Lassen Sie jede Funktion oder Methode nur eine Aufgabe ausführen
4. Verwenden Sie Kommentare, um Code zu erläutern
5. Behalten Sie die Konsistenz des Codestils bei
6. Überprüfen Sie Ihren Code regelmäßig

Einige Ideen zum Schreiben von sauberem Code

Vorteile des Schreibens von sauberem Code

Erfahren Sie zunächst einige Vorteile des Schreibens von sauberem Code . Einer der Hauptvorteile besteht darin, dass sauberer Code den Zeitaufwand für das Lesen und Verstehen des Codes reduziert. Unordentlicher Code verlangsamt jeden Entwickler und erschwert die Arbeit des Entwicklers. Je verwirrender der Code, desto mehr Zeit müssen Entwickler aufwenden, um ihn vollständig zu verstehen, damit sie den Code verwenden können. Und wenn der Code zu chaotisch ist, können Entwickler entscheiden, ihn nicht mehr zu lesen und ihn selbst von Grund auf zu schreiben.

1． Einfacher, ein Projekt zu starten und fortzusetzen
Beginnen wir mit einem einfachen Beispiel, um dieses Problem zu veranschaulichen. Nehmen wir an, wir kehren nach längerer Zeit zu einem früheren Projekt zurück. Vielleicht kontaktiert uns während dieser Zeit ein Kunde, um einen anderen Auftrag zu erledigen. Stellen Sie sich nun vor, wie schlimm und verwirrend es wäre, wenn Sie damals keinen sauberen Code geschrieben hätten, nachdem Sie den Code zum ersten Mal gesehen hatten. Außerdem können Sie sehen, wie schwierig es ist, mit dem Codieren dort zu beginnen, wo Sie aufgehört haben.

Jetzt muss also mehr Zeit für das Projekt aufgewendet werden, da wir den Code verstehen müssen, den wir zuvor geschrieben haben. Dies hätte vermieden werden können, wenn von Anfang an sauberer Code geschrieben worden wäre, aber jetzt muss der Preis dafür bezahlt werden. Außerdem ist der alte Code so chaotisch und schlecht, dass wir uns möglicherweise dazu entschließen, ganz von vorne anzufangen. Kunden sind möglicherweise nicht erfreut, dies zu hören.

Andererseits besteht dieses Problem bei sauberem Code normalerweise nicht. Angenommen, das vorherige Beispiel wäre das Gegenteil und der vorherige Code wäre sauber und elegant. Wie lange würde es dauern, ihn zu verstehen? Vielleicht würde es nur ein paar Minuten dauern, den Code zu lesen, um zu verstehen, wie alles funktioniert, und wir hätten vielleicht schreiben müssen es für eine Weile, so dass der Energieaufwand in diesem Fall deutlich geringer sein wird als im ersten Fall, und gleichzeitig wird sich der Kunde nicht allzu sehr darum kümmern.

Das ist der erste Vorteil des Schreibens von sauberem Code, und das gilt nicht nur für Ihre eigenen Projekte, sondern auch für die Arbeit anderer Entwickler. Mit sauberem Code geht es schneller los, niemand muss stundenlang über Code grübeln, sondern wir können direkt mit der Arbeit beginnen.

2. Förderlich für die Schulung neuer Mitarbeiter im Team
Ein weiterer Vorteil des Schreibens von sauberem Code hängt eng mit dem ersten Vorteil zusammen, das heißt, es kann es einfacher und einfacher machen schneller für neue Mitarbeiter Setzen Sie Code mit Bedacht ein. Angenommen, wir müssen eine Entwicklerin einstellen. Wie lange wird es dauern, bis sie den Code versteht und lernt, ihn zu verwenden? Das hängt natürlich von der Situation ab. Wenn unser Code chaotisch und schlecht geschrieben ist, muss sie mehr Zeit damit verbringen, den Code zu lernen. Wenn der Code hingegen sauber, lesbar und einfach zu verstehen ist, kann sie schneller mit der Arbeit beginnen.

Einige sagen vielleicht, dass dies kein Problem sei, weil andere Entwickler ihr helfen könnten. Das ist natürlich richtig, aber die Hilfe sollte nur kurze Zeit dauern, zwei oder drei Mal oder ein oder zwei Tage, nicht zwei oder drei Wochen. Die Entscheidung, einen anderen Entwickler einzustellen, wurde daher getroffen, um unsere Arbeit zu beschleunigen, nicht um sie zu verlangsamen oder mehr Zeit damit zu verbringen, ihr beim Erlernen des Programmierens zu helfen.

Wenn wir danach streben, sauberen Code zu schreiben, werden andere von uns lernen und es wird einfacher sein, unserem Beispiel zu folgen und sauberen Code zu schreiben. Natürlich muss noch etwas Zeit eingeplant werden, um jedem neuen Entwickler das Erlernen und Verstehen des Codes zu erleichtern. Natürlich meine ich Tage, nicht Wochen. Darüber hinaus wird sauberer Code dem Team helfen, mehr Entwickler an Bord zu holen und ihnen gleichzeitig dabei zu helfen, den Code zu verstehen. Einfach ausgedrückt: Je einfacher der Code, desto einfacher ist er zu interpretieren und desto weniger Missverständnisse treten auf.

3． Codierungsmuster sind einfacher zu befolgen
Man sollte sich daran erinnern, dass das Verstehen und Erlernen der Verwendung von Code dasselbe ist. Dies ist jedoch erst der Anfang und wir müssen auch sicherstellen, dass Entwickler bereit sind, unserem Codierungsmodell zu folgen. Natürlich lässt sich dieses Ziel mit sauberem Code einfacher erreichen als mit unordentlichem Code. Dies ist wichtig, da das Team nicht nur sauberen Code schreiben möchte, sondern dieses Muster auch über einen längeren Zeitraum beibehalten möchte, was ebenfalls langfristiges Denken erfordert.

Und was passiert, wenn der Entwickler sich nicht an das aktuelle Codierungsmuster hält? Dieses Problem kann normalerweise selbst gelöst werden. Angenommen, es gibt eine Gruppe von Personen, die an derselben Codebasis arbeiten, und einer von ihnen beginnt, vom Standardstil abzuweichen. Der Rest des Teams wird diesen Entwickler dann dazu drängen, dem Standard zu folgen. Sie wird den Rat befolgen, weil sie die Gruppe nicht verlassen möchte.

Es gibt auch eine Situation, in der ein Entwickler den Rest des Teams davon überzeugt, sein Codierungsmuster zu übernehmen und zu befolgen. Es ist sicherlich eine gute Sache, wenn Entwickler Codierungsmuster entwickeln, die sauberer sind und zu besseren Ergebnissen führen. Das Schreiben und Pflegen von sauberem Code bedeutet in der Tat nicht, dass jede Gelegenheit zur Verbesserung ignoriert werden sollte. Ich glaube, dass man immer eine verbesserungswürdige Einstellung gegenüber der aktuellen Praxis bewahren und hart daran arbeiten sollte, Möglichkeiten für Verbesserungen zu finden.

Wenn also ein Entwickler vom aktuellen Modell abweicht und sein Modell besser ist, dann könnte es für uns angebracht sein, die Änderung vorzunehmen. Daher sollten wir die Codierungspraktiken anderer Leute nicht ignorieren, bevor wir andere Muster ausprobieren, und wir sollten weiterhin nach Verbesserungsmöglichkeiten suchen. Zum Schluss das dritte Szenario. Der Entwickler hat beschlossen, weder unsere Praktiken zu übernehmen noch uns davon zu überzeugen, ihre zu übernehmen. Denn sie wird sich entscheiden, das Team zu verlassen.

Tipps zum Schreiben von sauberem Code

Neben der Besprechung der Vorteile des Schreibens von sauberem Code ist es nun auch an der Zeit, einige Techniken zu erlernen, die uns dabei helfen, dieses Ziel zu erreichen. Wie Sie weiter unten sehen werden, besteht sauberer Code aus einigen Methoden und folgt ihnen. Diese Methoden machen den Code sauberer, lesbarer, verständlicher und einfacher. Natürlich ist es nicht notwendig, alle Methoden umzusetzen, es reicht aus, ein oder zwei Maßnahmen umzusetzen und zu befolgen, um positive Ergebnisse zu erzielen.

1． Schreiben Sie lesbaren Code
Es ist wahr, dass der geschriebene Code von der Maschine interpretiert wird. Dies bedeutet jedoch nicht, dass die Lesbarkeit und Verständlichkeit des Codes ignoriert werden sollte, da es in Zukunft immer eine andere Person geben wird Wer wird den von uns geschriebenen Code verwenden? Selbst wenn wir unseren Code für andere unzugänglich machen, können wir ihn möglicherweise in Zukunft wieder abrufen. Aus diesen Gründen liegt es in unserem eigenen Interesse, unseren Code leicht lesbar und verständlich zu machen. Wie kann man es erreichen?

Der einfachste Weg ist die Verwendung von Leerzeichen. Sie können Ihren Code verkleinern, bevor Sie ihn veröffentlichen, es besteht jedoch keine Notwendigkeit, ihn miniaturisiert aussehen zu lassen. Verwenden Sie stattdessen Einrückungen, Zeilenumbrüche und Leerzeilen, um die Lesbarkeit Ihrer Codestruktur zu verbessern. Wenn Sie sich für diesen Weg entscheiden, wird Ihr Code deutlich lesbarer und verständlicher. Wenn Sie sich dann den Code ansehen, ist es einfacher, ihn zu verstehen. Schauen wir uns zwei einfache Beispiele an.
Code:

// Badconst userData=
[{userId: 1, userName: 'Anthony Johnson', memberSince: '08-01-2017', fluentIn: [ 'English', 'Greek', 'Russian']},
{userId: 2, userName: 'Alice Stevens', memberSince: '02-11-2016', fluentIn: [ 'English', 'French', 'German']},
{userId: 3, userName: 'Bradley Stark', memberSince: '29-08-2013', fluentIn: [ 'Czech', 'English', 'Polish']},
{userId: 4, userName: 'Hirohiro Matumoto', memberSince: '08-05-2015', fluentIn: [ 'Chinese', 'English', 'German', 'Japanese']}];
// Betterconst userData = [
  {
    userId: 1,
    userName: 'Anthony Johnson',
    memberSince: '08-01-2017',
    fluentIn: [      'English',      'Greek',      'Russian'
    ]
  }, {
    userId: 2,
    userName: 'Alice Stevens',
    memberSince: '02-11-2016',
    fluentIn: [      'English',      'French',      'German'
    ]
  }, {
    userId: 3,
    userName: 'Bradley Stark',
    memberSince: '29-08-2013',
    fluentIn: [      'Czech',      'English',      'Polish'
    ]
  }, {
    userId: 4,
    userName: 'Hirohiro Matumoto',
    memberSince: '08-05-2015',
    fluentIn: [      'Chinese',      'English',      'German',      'Japanese'
    ]
  }
];

Code:

// Badclass 
CarouselLeftArrow extends Component{
render(){
return ( <a href="#" className="carousel__arrow carousel__arrow--left" onClick={this.props.onClick}> <span className="fa fa-2x fa-angle-left"/> </a> );}};
// Betterclass 
CarouselLeftArrow extends Component {
  render() {    return (
      <a
        href="#"
        className="carousel__arrow carousel__arrow--left"
        onClick={this.props.onClick}
      >
        <span className="fa fa-2x fa-angle-left" />
      </a>
    );
  }
};

2．为变量、函数和方法使用有意义的名称 
来看一看第二个技巧，它将帮助我们编写可理解和干净的代码。这个技巧是关于变量、函数和方法的有意义的名称。“有意义的”是什么意思?有意义的名字是描述性足够多的名字，而不仅仅是编写者自己才能够理解的变量、函数或方法。换句话说，名称本身应该根据变量、函数或方法的内容和使用方式来定义。 
代码：

// Badconst fnm = ‘Tom’;
const lnm = ‘Hanks’const x = 31;
const l = lstnm.length;const boo = false;
const curr = true;const sfn = ‘Remember the name’;
const dbl = [‘1984’, ‘1987’, ‘1989’, ‘1991’].map((i) => {  
return i * 2;
});
// Betterconst firstName = ‘Tom’;
const lastName = ‘Hanks’const age = 31;
const lastNameLength = lastName.length;
const isComplete = false;const isCurrentlyActive = true;
const songFileName = ‘Remember the name’;
const yearsDoubled = [‘1984’, ‘1987’, ‘1989’, ‘1991’].map((year) => {  
return year * 2;
});

然而需要注意的是，使用描述性名称并不意味着可以随意使用任意多个字符。一个好的经验则是将名字限制在3或4个单词。如果需要使用超过4个单词，说明这个函数或方法需要同时执行很多的任务，所以应该简化代码，只使用必要的字符。

3.让一个函数或方法只执行一个任务 
当开始编写代码时，使用的函数和方法看起来就像一把瑞士军刀，几乎可以处理任何事情，但是很难找到一个好的命名。另外，除了编写者，几乎没有人知道函数是用来做什么的以及该如何使用它。有时我就会遇到这些问题，我在这方面做的很不好。

然后，有人提出了一个很好的建议：让每个函数或方法只执行一个任务。这个简单的建议改变了一切，帮助我写出了干净的代码，至少比以前更干净了。从那以后，其他人终于能够理解我的代码了，或者说，他们不需要像以前一样花很多时间去读懂代码了，功能和方法也变得更好理解。在相同的输入下，总是能产生相同的输出，而且，命名也变得容易得多。

如果你很难找到函数和方法的描述性名称，或者需要编写冗长的指令以便其他人可以使用，那请考虑这个建议，让每个函数或方法只执行一个任务。如果你的功能和方法看起来像瑞士军刀一样无所不能，那请你执行这个方法，相信我，这种多才多艺不是一种优势。这是一个相当不利的情况，可能会产生事与愿违的结果。

附注:这种让每一个函数或方法只执行一项任务的做法被称为保持纯函数。这种编码实践来自于函数式编程的概念。如果你想了解更多，我推荐阅读《So You Want to be a Functional Programmer series[4]》。 
代码：

// Examples of pure functionsfunction subtract(x, y) {
    return x - y;
}function multiply(x, y) {
    return x * y;
}// Double numbers in an arrayfunction doubleArray(array) {
  return array.map(number => number * 2)
}

4．更容易遵循编码模式 
不管多么努力地为变量、函数和方法想出有意义的名字，代码仍然不可能完全清晰易懂，还有一些思路需要进行解释。问题可能不是代码很难理解或使用，相反，其他人可能不理解为什么要实现这个函数或方法，或者为什么要以特定的方式创建它。意思是，创建函数或方法的意图还不清楚。

有时可能不得不采用非传统的方法来解决问题，因为没有足够的时间来想出更好的解决方案，这也很难用代码来解释。所以，通过代码注释可以帮助解决这个问题，也可以帮助我们向其他人解释为什么写了这个方法，为什么要用这种特定的方式来写，那么其他人就不必猜测这些方法或函数的用途了。

更重要的是，当我们使用注来解释代码后，其他人可能会找到一个更好的方法来解决这个问题并改进代码。这是有可能的，因为他们知道问题是什么，以及期望的结果是什么。如果不知道这些信息，其他人就很难创建更好的解决方案，或者他们可能不会去尝试，因为他们认为没有必要去修改创建者自己的想法。

因此，每当自己决定使用一些快速修复或非传统的方法时，要用注释来解释为什么这么做。最好是用一两行注释来解释，而不用别人来猜测。

Dennoch sollten wir Kommentare nur bei Bedarf verwenden und schlechten Code nicht erklären. Das Schreiben endloser Kommentare wird nicht dazu beitragen, schlechten Code in sauberen Code umzuwandeln. Wenn der Code fehlerhaft ist, sollte das Problem durch eine Verbesserung des Codes gelöst werden, nicht durch das Hinzufügen einiger Anweisungen zu seiner Verwendung. Wichtiger ist es, sauberen Code zu schreiben.

5． Behalten Sie die Konsistenz des Codierungsstils bei
Wenn wir eine bestimmte Codierungsmethode oder einen bestimmten Codierungsstil haben, der uns gefällt, werden wir ihn immer und überall verwenden. Die Verwendung unterschiedlicher Codierungsstile in verschiedenen Projekten ist jedoch keine gute Idee und es ist unmöglich, auf natürliche Weise zum vorherigen Code zurückzukehren. Daher dauert es immer noch einige Zeit, den im Projekt verwendeten Codierungsstil zu verstehen.

Der beste Weg ist, eine Codierungsmethode zu wählen und diese in allen Projekten beizubehalten. Auf diese Weise ist es einfacher, zum alten Code zurückzukehren. Natürlich ist es eine gute Sache, neue Codierungsmethoden auszuprobieren und hilft uns, bessere Wege zu finden, unsere Arbeit zu erledigen. Es ist jedoch besser, unterschiedliche Codierungsstile bei verschiedenen Laborprojekten oder Übungen auszuprobieren, als beim Hauptprojekt.

Wenn wir uns außerdem dazu entschließen, einige Experimente durchzuführen, sollten wir es mehrmals versuchen und uns die Zeit nehmen, es gründlich durchzuführen. Sie sollten es nur dann umsetzen, wenn Sie wirklich davon überzeugt sind, dass es Ihnen gefällt und Sie sich damit wohl fühlen. Und wenn Sie sich dafür entscheiden, wenden Sie es am besten auf alle Projekte an. Ja, es braucht Zeit und zwingt uns auch dazu, richtig zu denken.

6. Überprüfen Sie Ihren Code

Dies ist der letzte Tipp. Es geht nicht nur darum, sauberen Code zu schreiben, sondern es muss auch die letzte Arbeit erledigt werden, nämlich die Aufrechterhaltung sauberen Codes. Wir sollten den Code regelmäßig überprüfen und versuchen, ihn zu verbessern. Andernfalls wird unser alter Code, genau wie unsere Geräte, schnell veraltet sein, wenn er nicht überprüft und aktualisiert wird. Wenn Sie möchten, dass Ihre Codes in Topform bleiben, müssen Sie sie regelmäßig aktualisieren.

Das Gleiche gilt für Code, den Sie täglich verwenden. Der Code wird komplexer und unübersichtlicher, daher sollte dies vermieden und der Code sauber gehalten werden. Der einzige Weg, dies zu erreichen, besteht darin, unseren Code regelmäßig zu überprüfen. Mit anderen Worten: Wir müssen es behalten. Bei Projekten, die Sie in Zukunft nicht mehr interessieren, ist dies möglicherweise nicht notwendig, bei anderen gehört die Pflege des Codes jedoch zum Job.

Einige Gedanken zum Schreiben von sauberem Code

Die sechs heute besprochenen Praktiken sind vielleicht nicht die wirkungsvollsten und vielleicht auch nicht die wichtigsten, aber sie sind diejenigen, die erfahrene Entwickler am häufigsten verwenden. erwähnt, weshalb ich sie ausgewählt habe. Ich hoffe, dass diese Vorgehensweisen oder Tipps Ihnen dabei helfen, sauberen Code zu schreiben. Jetzt ist es, wie bei allen Dingen, das Wichtigste, anzufangen. Wählen Sie also mindestens einen Tipp aus und probieren Sie ihn aus.

Das obige ist der detaillierte Inhalt von6 Tipps zum Schreiben von gutem, sauberem Code. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!