Rückspeichern in Argument

[Rolf B]

Hallo effel,

zunächst einmal: Code ist deutlich besser lesbar, wenn man ihn passend einrückt. Und hier im Forum hilft es dann noch, wenn man JavaScript-Code nicht einfach mit ~~~ einleitet, sondern mit ~~~js. Dann weiß der Codeformatierer, dass er den Syntax-Highlighter für JavaScript aktivieren muss.

Weitere Helfer sind:

• Leerstellen

• Zusammenfassen von Deklaration und Initialisierung

• Keine unnötige Initialisierung (bei anzx), die gleich wieder überschrieben wird

• Bei Namen, die zusammengesetzt sind, helfen BinnenMajuskeln bei der Lesbarkeit.

• Variablennamen sollten aussagen, was sich darin befindent. z0, z1, z2, arg1, arg2 - das ist unlesbares Kauderwelsch. Dein drei Monate älteres Ich wird Dich dafür hassen.

• Dass man heute var eher vermeidet und let verwendet, ist ein Detail.

• Wenn ich das richtig sehe, ist anzX eine Kopie von arg1. Du erzeugst ein leeres Array und kettest den Inhalt von arg1 daran. Das geht aber einfacher, wenn Du die slice-Methode verwendest. Mit array.slice(start, end) kopierst Du die Arrayeinträge von Index start bis end. Lässt man start und end weg, kopiert die Funktion alles. Alternativ kannst Du auch den Spread-Operator ... verwenden: anzX = [... arg1]

• Aber: Du änderst nichts an arg1 oder an anzX. Das Anfertigen einer Kopie ist daher unnötig.

• Es ist sinnlos, einen Wert als Parameter zu übergeben (arg3), wenn man ihn innerhalb der Funktion dann gleich überschreibt (du setzt arg3 auf 0 bevor Du es verwendest)

• Du verwendest z1 und z2, um Werte an anzX01 und anzX02 anzuhängen. Das geht einfacher mit der push-Methode: anzX01.push(korr005(anzX[z0])). Kein z1 nötig.

• Du programmierst eine while-Schleife um einen Zähler von 0 bis "< anzX.length" zu realisieren. Das geht in erster Näherung einfacher mit einer for(;;)-Schleife, und in zweiter Näherung gibt's auch for..of. Alle relevanten Browser können das (der IE nicht, aber der ist seit ein paar Monaten irrelevant).

• Du benutzt arg3 als Index für die Ausgabe. Wenn Du etwas zugewiesen hast, setzt Du arg3 um 1 hoch. Dafür ist der Post-Inkrement Operator ++ nützlich. Er erhöht die Variable und gibt den Wert vor der Erhöhung zurück.

  // Speichere y an Position pos und erhöhe pos danach um 1 x[pos++] = y;

• Warum ist es Dir wichtig, das Ergebnis in ein Array zu schreiben, das Du als Parameter übergibst? Du erzeugst - je nach Inhalt von arg1 - null bis zwei Ergebnisarrays, die auf den Positionen 0 und 1 von m16a gespeichert werden. Du weißt aber nicht, ob auf Position 0 die korr005-Werte für die geraden oder ungeraden Werte in anz_1 stehen, weil Du ja anzX01 und anzX02 nur speicherst - und nur dann den Index hochsetzt - wenn mindestens ein Wert drinsteht. Ist das für Dich sinnvoll?

Meine erste Überarbeitung der Funktion würde so aussehen:

Aufruf: /*m16a=*/ trennen1(anz_1,m16a); //ergeb in m16.. gespeichert 

function trennen1(werte, resultate) {
   let anzGerade = [],
       anzUngerade = [];

   for (let wert of arg1) {
      if (wert % 2 == 0)
         anzGerade.push(korr005(wert));
      else
         anzUngerade.push(korr005(wert));
   }

   let resultatPos = 0;  

   if (anzGerade.length > 0) {
      resultate[resultatPos++] = anzGerade;
   }
   if (anzUngerade.length > 0) {
      resultate[resultatPos++] = anzUngerade;
   }
}

Man könnte statt for..of auch die forEach-Methode verwenden, das bringt aber nach meinem Dafürhalten keinen Mehrwert. Und statt eines if könnte man den ternären Operator nutzen,um das Zielarray für push auszuwählen - das macht es aber aus meiner Sicht schlechter lesbar. Oder wie gefiele Dir dies:

   for (let wert of arg1) {
      (wert % 2 == 0 ? anzGerade : anzUngerade).push(korr005(wert));
   }

oder gar

   arg1.forEach(wert => (wert % 2 ? anzUngerade : anzGerade).push(korr005(wert));

Ich finde das erste grenzwertig und das zweite scheußlich 😉

Aber hattest Du nun eigentlich eine Frage? Oder wolltest Du deinen Code einfach vorstellen? Was wäre deine Erwartungshaltung dazu?

Rolf