C'è qualche ragione per cui la maggior parte dei linguaggi di programmazione non ha '!' (non maggiore di) e '!' (non meno di) operatori?

Il linguaggio di programmazione D e L'estensione di DMC a C e C ++ ha supportato questi operatori (tutte e 14 le combinazioni), ma interessante, D intenzione di deprecare questi operatori , principalmente perché

1. cos'è esattamente a !< b ? È a>=b || isNaN(a) || isNaN(b) . !< è non uguale a >= , perché NaN !< NaN è true mentre NaN >= NaN è false. IEEE 754 è difficile da padroneggiare, quindi usare a !< b causerà solo confusione sulla gestione di NaN - puoi cercare tali operatori in Phobos (libreria standard di D's), e un certo numero di usi ha commenti accanto a esso per ricordare ai lettori che è coinvolto NaN,
2. quindi, poche persone lo useranno, anche se tali operatori esistono come in D,
3. e uno deve definire altri 8 token per questi operatori usati di rado, il che complica il compilatore con poco beneficio,
4. e senza quegli operatori, si potrebbe ancora usare l'equivalente !(a < b) , o se si vuole che sia esplicito, a >= b || isNaN(a) || isNaN(b) , e sono più facili da leggere.

Inoltre, le relazioni (≮, ≯, ≰, ≱) si vedono raramente in matematica di base, a differenza di != (≠) o >= (≥), quindi è difficile capire per molte persone.

Questi sono probabilmente anche i motivi per cui la maggior parte delle lingue non li supporta.

Perché non ha molto senso avere due operatori diversi con esattamente lo stesso significato.

• "not greater" ( !> ) è esattamente uguale a "minore o uguale" ( <= )
• "non inferiore" ( !< ) è esattamente uguale a "maggiore o uguale" ( >= )

Questo non si applica a "non è uguale" ( != ), non c'è operatore con lo stesso significato.

Quindi la tua modifica renderebbe la lingua più complicata senza alcun vantaggio.

!< è sinonimo di >= . Più avanti è solo un modo di digitare il simbolo matematico ben definito ≥ . Hai ragione che "non meno di" è usato nella lingua parlata, tuttavia è colloquiale e può essere ambiguo (può essere interpretato ≥ o erroneamente interpretato come > ). D'altra parte la programmazione e la matematica usano una terminologia chiaramente definita e non ambigua.

Anche nella logica a 3 valori, come ANSI SQL, not x < y è equivalente a x >= y , dato che entrambi danno NULL se x o y è NULL . Tuttavia, esistono dialetti SQL non conformi ANSI, in cui non è equivalente e hanno !< .

Transact-SQL ha ! > (non superiore a) e ! < (non meno di) operatori.

Quindi, a parte te, qualcuno in Sybase Microsoft ha anche pensato che sarebbe stata una buona idea. Proprio come Microsoft Bob! :)

Penso che la risposta sia semplicemente che non è necessario un operatore !< . Come hai indicato nella tua domanda, c'è già >= e <= insieme alla possibilità di negare un'espressione esistente, quindi perché aggiungere un altro operatore?

Da RFC 1925

perfection has been reached not when there is nothing left to add, but when there is nothing left to take away.

L'aggiunta di operatori aggiuntivi che duplicano funzionalità esistenti non fa altro che aggiungere complessità (inutile) al linguaggio (e quindi a tokenizer e parser).

Considerare anche nelle lingue in cui è possibile il sovraccarico dell'operatore, si dovrebbe sovraccaricare un altro operatore. Considera la confusione quando bool operator<= e bool operator!> potrebbero restituire cose diverse (sì, so che si possono già fare confronti incoerenti).

Infine, pensa alle lingue in cui i metodi o gli operatori sono definiti in modo multiplo (Ruby - Sto guardando tu ) e hai un programmatore che usa < = mentre un altro usa! > e hai più stili di codice per la stessa espressione.

& lt!; è uguale a > = Ora, perché non abbiamo la seconda non prima perché tutta la lingua implementa prima l'operatore positivo e poi l'approccio all'operatore negativo, mentre l'implementazione di > = copre anche! < e < = covers! > .So il creatore di linguaggi si rivolge a questi e ha pensato che sarebbero stati ridondanti e li ignorerebbe.

Cerca sempre di implementare casi positivi prima di passare al caso negativo (:) pensiero positivo, solo visualizzazione personale)

Il motivo è che gli operatori dei linguaggi di programmazione prendono a prestito dalla tradizione matematica e in matematica nessuno usa davvero "non più grande" e "non più piccolo" poiché "più piccolo o uguale" e "maggiore o uguale" fanno altrettanto bene di un lavoro .

Quindi, nei linguaggi di programmazione di solito otteniamo un simbolo simile a ≠ per non eguali ( != o /= , a meno che qualcuno non sia di fantasia con <> o un operatore testuale)

e cose che assomigliano a ≤ e ≥ ( <= e >= )

A proposito, non sono d'accordo con la tua affermazione che NON è più semplice capire e ragionare su allora OR. In matematica, le prove che coinvolgono molte negazioni (come la riduzione all'assurdo) sono solitamente disapprovate se esiste un'alternativa più diretta. Inoltre, nel caso di ordinazione, la conoscenza di base che abbiamo (e che viene usata quando pensiamo o provando qualcosa) è la tricotomia tra & lt ;, = e > così qualsiasi! < probabilmente la dichiarazione deve essere convertita in > = se vuoi fare qualcosa di utile con esso.

Incolperei parzialmente il set di istruzioni di montaggio. Hai istruzioni come jge per "salta se maggiore o uguale". Al contrario di "saltare se non meno di".

I redattori di compilatori potrebbero essere andati fuori da ciò che gli scrittori di assembly hanno inventato, il che era presumibilmente basato su come è stato etichettato quando è stato progettato sul chip.

... forse.

Penso di aver visto alcune lingue qualche anno fa dove, invece dell'operatore != (non uguale a), è stato usato qualcosa come <> . Non ricordo i loro nomi, però ...

Penso che sia più difficile leggere !(a < b) o a !< b rispetto a a >= b . Probabilmente è questo il motivo per cui !< non viene usato (a mio parere è brutto).