Gibt es einen Grund, warum die meisten Programmiersprachen keine Operatoren '!>' (Nicht größer als) und '! <' (Nicht kleiner als) haben?

Ich frage mich, ob es irgendeinen Grund gibt - oder ob es sich nur um einen Unfall in der Geschichte handelt -, dass es in den meisten Programmiersprachen keine !>und !<Operatoren gibt .

a >= b (ein größeres ODER ist gleich b) könnte geschrieben werden als !(a < b) (ein NICHT kleineres b) , das ist gleich a !< b.

Diese Frage traf mich, als ich gerade dabei war, meinen eigenen Ausdrucksbaum-Builder zu programmieren. Die meisten Programmiersprachen haben a != bOperator für !(a=b), warum also nicht !>und !<?

AKTUALISIEREN:

• !<(nicht weniger) ist leichter auszusprechen als >=(größer oder gleich)
• !<(nicht kleiner) ist kürzer als >=(größer oder gleich)
• !<(nicht weniger) ist leichter zu verstehen * als >=(größer oder gleich)

* Weil ORes sich um einen binären Operator handelt, muss Ihr Gehirn zwei Operanden (grater, equals) bedienen, während NOTes sich um einen unären Operator handelt und Ihr Gehirn nur mit einem Operanden (weniger) arbeiten muss.

Die Programmiersprache D und die DMC-Erweiterung auf C und C ++ haben diese Operatoren (alle 14 Kombinationen von ihnen) unterstützt, aber interessanterweise wird D diese Operatoren hauptsächlich deshalb ablehnen , weil

1. was genau ist a !< b? Es ist a>=b || isNaN(a) || isNaN(b). !<ist nicht dasselbe wie >=, weil NaN !< NaNwahr ist, während NaN >= NaNfalsch ist. IEEE 754 ist schwer zu beherrschen, daher führt die Verwendung von a !< bto nur zu Verwirrung über die Handhabung von NaN. Sie können in Phobos (Ds Standardbibliothek) nach solchen Operatoren suchen, und es gibt eine ganze Reihe von Kommentaren, die daran erinnern, dass NaN involviert ist.
2. daher werden es nur wenige Leute benutzen, auch wenn solche Operatoren wie in D existieren,
3. und man muss 8 weitere Token für diese selten verwendeten Operatoren definieren, was den Compiler für wenig Nutzen kompliziert.
4. und ohne diese Operatoren könnte man immer noch das Äquivalent verwenden !(a < b), oder wenn man es ausdrücklich möchte a >= b || isNaN(a) || isNaN(b), und sie sind leichter zu lesen.

Außerdem werden die Beziehungen (≮, ≯, ≰, ≱) im Gegensatz zu !=(≠) oder >=(≥) in der Grundrechenart selten gesehen , so dass es für viele Menschen schwer zu verstehen ist.

Dies sind wahrscheinlich auch die Gründe, warum die meisten Sprachen sie nicht unterstützen.

Weil es wenig Sinn macht, zwei verschiedene Operatoren mit genau der gleichen Bedeutung zu haben.

• "Nicht größer" ( !>) ist genau das gleiche wie "kleiner oder gleich" ( <=)
• "Nicht kleiner" ( !<) ist genau das gleiche wie "größer oder gleich" ( >=)

Dies gilt nicht für "nicht gleich" ( !=), es gibt keinen Operator mit der gleichen Bedeutung.

Ihre Änderung würde die Sprache also komplizierter machen, ohne dass dies von Nutzen wäre.

!<ist gleichbedeutend mit >=. Später können Sie nur ein genau definiertes mathematisches Symbol eingeben ≥. Sie haben Recht, dass "nicht weniger als" in der gesprochenen Sprache verwendet wird, es ist jedoch umgangssprachlich und kann mehrdeutig sein (kann interpretiert ≥oder falsch interpretiert werden als >). Andererseits verwenden Programmierung und Mathematik eine klar definierte, eindeutige Terminologie.

Sogar in der 3-wertigen Logik, wie ANSI SQL, not x < yist es äquivalent x >= y, wie sie beide geben, NULLwenn entweder xoder yist NULL. Allerdings gibt es nicht-ANSI - konformen SQL - Dialekte, in denen es nicht gleichwertig ist, und sie tun müssen!< .

Transact-SQL verfügt über die Operatoren !> (Nicht größer als) und ! <(Nicht kleiner als) .

Außer Ihnen hat also auch jemand bei Sybase Microsoft gedacht, dass dies eine gute Idee wäre. Genau wie Microsoft Bob! :)

Ich denke, die Antwort ist einfach, dass kein !<Bediener erforderlich ist . Wie Sie in Ihrer Frage darauf hingewiesen , gibt es bereits >=und <=zusammen mit der Möglichkeit , einen vorhandenen Ausdruck zu negieren, also warum ein anderen Betreiber hinzufügen?

Aus RFC 1925

Perfektion wurde nicht erreicht, wenn nichts mehr hinzuzufügen ist, sondern wenn nichts mehr wegzunehmen ist.

Das Hinzufügen zusätzlicher Operatoren, die vorhandene Funktionen duplizieren, bewirkt nichts anderes als das Hinzufügen (unnötiger) Komplexität zur Sprache (und damit zum Tokenizer und Parser).

Berücksichtigen Sie auch in Sprachen, in denen eine Überladung von Operatoren möglich ist, dass Sie noch einen weiteren Operator überladen müssen. Bedenken Sie die Verwirrung, wann bool operator<=und bool operator!>könnte verschiedene Dinge zurückgeben (ja, ich weiß, man kann bereits inkonsistente Vergleiche anstellen).

Denken Sie zuletzt an Sprachen, in denen Methoden oder Operatoren mehrfach definiert sind (Ruby - ich sehe Sie ) und Sie einen Programmierer haben, der <= verwendet, während ein anderer!> Verwendet, und Sie haben mehrere Codestile für denselben Ausdruck.

! <ist gleich> = Warum haben wir nun den zweiten, nicht den ersten, weil alle Sprachen zuerst einen positiven Operator implementieren und dann einen negativen Operator anfahren. Als Implementierung gilt> = auch! <und <=!> und dachte, sie wären überflüssig und überspringen sie.

Versuche immer zuerst einen positiven Fall zu implementieren, dann gehe zum negativen Fall (:) positives Denken, nur meine persönliche Sichtweise)

Der Grund dafür ist, dass Operatoren in Programmiersprachen der mathematischen Tradition entlehnen und in der Mathematik niemand wirklich "nicht größer" und "nicht kleiner" verwendet, da "kleiner oder gleich" und "größer oder gleich" genau so gute Arbeit leisten.

Daher erhalten wir in Programmiersprachen normalerweise ein Symbol, das wie folgt aussieht: ≠ für ungleich ( !=oder /=, es sei denn, jemand, der Lust dazu hat <>oder ein Textoperator ist)

und Dinge, die aussehen wie ≤ und ≥ ( <=und >=)

Übrigens stimme ich Ihrer Behauptung nicht zu, dass es NICHT einfacher ist, das zu verstehen und darüber nachzudenken, ODER. In der Mathematik werden Beweise mit vielen Negationen (wie die Reduktion auf Absurdes) normalerweise verpönt, wenn es eine direktere Alternative gibt. Im Bestellungsfall ist das Grundwissen, das wir haben (und das zum Nachdenken oder Beweisen von etwas verwendet wird), die Trikotomie zwischen <, = und>, sodass jede! <-Anweisung wahrscheinlich in> = konvertiert werden muss, wenn Sie dies tun möchten irgendetwas nützliches damit.

Ich würde den Montageanweisungssatz teilweise beschuldigen. Sie haben Anweisungen wie zum Beispiel jgefür "springen, wenn größer oder gleich". Im Gegensatz zu "springen, wenn nicht weniger als".

Compiler-Autoren haben sich möglicherweise von den Ideen der Assembly-Writer verabschiedet, die vermutlich darauf beruhten, wie sie beim Design auf dem Chip beschriftet wurden.

...möglicherweise.

Ich glaube, ich habe vor ein paar Jahren einige Sprachen gesehen, in denen anstelle des !=Operators (nicht gleich) so etwas <>verwendet wurde. Ich kann mich jedoch nicht an ihre Namen erinnern ...

Ich denke, dass es schwieriger ist zu lesen !(a < b)oder a !< bals a >= b. Wahrscheinlich ist das der Grund, warum !<nicht verwendet wird (es sieht meiner Meinung nach hässlich aus).