Warum sollte man in JavaScript Inkrement- ("++") und Dekrement-Operatoren ("--") vermeiden?

Question

Einer der Tipps für jslint Werkzeug ist:

++ y --
Die ++ (Inkrement) und -- (Dekrement) Operatoren sind dafür bekannt, dass sie zu schlechtem Code beitragen, indem sie zu übermäßiger Trickserei ermutigen. Sie sind nach einer fehlerhaften Architektur der zweitwichtigste Faktor zu Viren und anderen Sicherheitsbedrohungen Sicherheitsbedrohungen. Es gibt eine Plusplus Option, die die Verwendung dieser Operatoren verbietet.

Ich weiß, dass PHP-Konstrukte wie $foo[$bar++] kann leicht zu Fehlern führen, aber ich konnte keinen besseren Weg finden, die Schleife zu kontrollieren als a:

while( a < 10 ) do { /* foo */ a++; }

ou

for (var i=0; i<10; i++) { /* foo */ }

Ist die jslint hervorzuheben, da es einige ähnliche Sprachen gibt, denen das " ++ " und " -- "Syntax zu verwenden oder anders zu handhaben, oder gibt es andere Gründe für die Vermeidung von " ++ " und " -- ", die ich vielleicht übersehen habe?

Answer 1

Ich bin der Meinung, dass ++ und -- immer in einer einzigen Zeile verwendet werden sollten, z. B:

i++;
array[i] = foo;

anstelle von

array[++i] = foo;

Alles, was darüber hinausgeht, kann für einige Programmierer verwirrend sein und ist es meiner Meinung nach nicht wert. For-Schleifen sind eine Ausnahme, da die Verwendung des Inkrement-Operators idiomatisch und somit immer eindeutig ist.

Answer 2

Dieser Ratschlag verwirrt mich ehrlich gesagt. Ein Teil von mir fragt sich, ob es mehr mit einem Mangel an Erfahrung (wahrgenommen oder tatsächlich) mit Javascript-Codierern zu tun hat.

Ich kann mir vorstellen, dass jemand, der nur an einem Beispielcode "herumhackt", einen unschuldigen Fehler mit ++ und -- machen könnte, aber ich verstehe nicht, warum ein erfahrener Profi sie vermeiden sollte.

Answer 3

In C gibt es eine Geschichte, in der Dinge wie diese getan wurden:

while (*a++ = *b++);

um eine Zeichenkette zu kopieren, ist dies vielleicht die Quelle der übertriebenen Trickserei, auf die er sich bezieht.

Und es stellt sich immer die Frage, was

++i = i++;

ou

i = i++ + ++i;

tatsächlich tun. In einigen Sprachen ist es definiert, in anderen gibt es keine Garantie, was passieren wird.

Abgesehen von diesen Beispielen glaube ich nicht, dass es etwas Idiomatischeres gibt als eine for-Schleife, die mit ++ zu erhöhen. In einigen Fällen könnte man mit einer foreach-Schleife oder einer while-Schleife auskommen, die eine andere Bedingung überprüft. Aber Ihren Code zu verzerren, um Inkrementierung zu vermeiden, ist lächerlich.

Answer 4

Wenn Sie JavaScript The Good Parts lesen, werden Sie feststellen, dass Crockfords Ersatz für i++ in einer pour Schleife ist i+=1 (nicht i=i+1). Das ist ziemlich sauber und lesbar, und es ist weniger wahrscheinlich, dass es sich in etwas "Trickreiches" verwandelt.

Crockford hat das Verbot der automatischen Erhöhung und Verringerung der Option in jsLint. Sie entscheiden, ob Sie den Rat befolgen oder nicht.

Meine persönliche Regel ist, nichts zu tun, was mit Autoinkrement oder Autodekrement kombiniert wird.

Ich habe aus jahrelanger Erfahrung in C gelernt, dass ich keine Pufferüberläufe (oder Array-Index außerhalb der Grenzen) bekomme, wenn ich die Verwendung einfach halte. Aber ich habe entdeckt, dass ich Pufferüberläufe bekomme, wenn ich in die "übermäßig trickreiche" Praxis verfalle, andere Dinge in derselben Anweisung zu tun.

Für meine eigenen Regeln bedeutet also die Verwendung von i++ als Inkrement in einer pour Schleife ist in Ordnung.

Answer 5

In einer Schleife ist es harmlos, aber in einer Zuweisungsanweisung kann es zu unerwarteten Ergebnissen führen:

var x = 5;
var y = x++; // y is now 5 and x is 6
var z = ++x; // z is now 7 and x is 7

Leerzeichen zwischen der Variablen und dem Operator können ebenfalls zu unerwarteten Ergebnissen führen:

a = b = c = 1; a ++ ; b -- ; c; console.log('a:', a, 'b:', b, 'c:', c)

Bei einem Abschluss können auch unerwartete Ergebnisse ein Problem darstellen:

var foobar = function(i){var count = count || i; return function(){return count++;}}

baz = foobar(1);
baz(); //1
baz(); //2

var alphabeta = function(i){var count = count || i; return function(){return ++count;}}

omega = alphabeta(1);
omega(); //2
omega(); //3

Außerdem wird nach einem Zeilenumbruch automatisch ein Semikolon eingefügt:

var foo = 1, bar = 2, baz = 3, alpha = 4, beta = 5, delta = alpha
++beta; //delta is 4, alpha is 4, beta is 6

Die Verwechslung von Vorinkrementen und Nachinkrementen kann zu Fehlern führen, die extrem schwer zu diagnostizieren sind. Glücklicherweise sind sie auch völlig unnötig. Es gibt bessere Möglichkeiten, 1 zu einer Variablen hinzuzufügen.

Referenzen

• JSLint Hilfe: Inkrement- und Dekrement-Operatoren