Gostaria de saber se existe alguma razão - ou se é apenas um acidente da história - que não existem operadores !>
e !<
na maioria das linguagens de programação?
a >= b
(um OR maior igual a b) pode ser escrito como !(a < b)
(a NÃO menor b) , igual a a !< b
.
Essa pergunta me ocorreu quando eu estava no meio da codificação do meu próprio construtor de árvores de expressão. A maioria das linguagens de programação tem a != b
operador para !(a=b)
, então por que não !>
e !<
?
ATUALIZAR:
!<
(não menor) é mais fácil de pronunciar do que>=
(maior ou igual)!<
(não menor) é mais curto para digitar do que>=
(maior ou igual)!<
(não menor) é mais fácil de entender * do que>=
(maior ou igual)
* porque OR
é um operador binário, seu cérebro precisa operar dois operandos (ralador, iguais), enquanto NOT
é um operador unário e seu cérebro precisa operar apenas com um operando (menor).
syntax
comparison
operators
Alex Burtsev
fonte
fonte
Respostas:
A linguagem de programação D e a extensão do DMC para C e C ++ deram suporte a esses operadores (todas as 14 combinações), mas, curiosamente, D vai depreciar esses operadores , principalmente porque
a !< b
? Éa>=b || isNaN(a) || isNaN(b)
. não!<
é o mesmo que , porque é verdadeiro enquanto é falso. O IEEE 754 é difícil de dominar, portanto, usar o para causar confusão no manuseio do NaN - você pode procurar por esses operadores na Phobos (biblioteca padrão do D), e vários usos têm comentários ao lado para lembrar aos leitores que o NaN está envolvido,>=
NaN !< NaN
NaN >= NaN
a !< b
!(a < b)
, ou se alguém quiser ser explícitoa >= b || isNaN(a) || isNaN(b)
, e eles são mais fáceis de ler.Além disso, as relações (≮, ≯, ≰, ≱) raramente são vistas na matemática básica, ao contrário de
!=
(≠) ou>=
(≥), por isso é difícil de entender para muitas pessoas.Provavelmente, esses também são os motivos pelos quais a maioria dos idiomas não os suporta.
fonte
seldomly seen in basic math
- mais como, nunca vi. Nós aprendemos volta na álgebra apenas para lançá-lo ao que matematicamente equivalente (especialmente desde queNaN
não aparece em matemática básica)double
exceção para seusNaN
comportamentos. Em muitos casos, o código que pode executar qualquer tipo de comparaçãoNaN
desejaNaN
comparar maior que tudo, comparar menor que tudo ou lançar uma exceção na tentativa de comparação. Permitir que o código especifique declarativamente comoNaN
deve ser considerado reduziria a necessidade de usar código imperativo para obter o comportamento correto.<fenv.h>
funções comofesetexceptflag
.Porque não faz muito sentido ter dois operadores diferentes com exatamente o mesmo significado.
!>
) é exatamente o mesmo que “menor ou igual” (<=
)!<
) é exatamente o mesmo que “maior ou igual” (>=
)Isso não se aplica a "não é igual a" (
!=
), não há operador com o mesmo significado.Portanto, sua modificação tornaria o idioma mais complicado sem nenhum benefício.
fonte
x = x + 1
,x += 1
ex++
?<>
é um operador com o mesmo significado que o!=
Python 2 possui os dois.<>
foi preterido por um longo tempo e foi removido desde o 3.0 (e lembre-se, a última versão 2.x de sempre , 2.7, foi lançada no verão de 2010).!<
é sinônimo de>=
. Mais tarde, é apenas uma maneira de digitar um símbolo matemático bem definido≥
. Você está certo de que "não menos que" é usado na linguagem falada, no entanto, é coloquial e pode ser ambíguo (pode ser interpretado≥
ou mal interpretado como>
). Por outro lado, programação e matemática usam terminologia claramente definida e inequívoca.Mesmo na lógica de 3 valores, como ANSI SQL,
not x < y
é equivalente ax >= y
, pois ambos fornecemNULL
se éx
ouy
éNULL
. No entanto, existem dialetos SQL não compatíveis com ANSI, onde não são equivalentes, e eles possuem!<
.fonte
NaN
é falso, então!(2 < NaN) == true
, enquanto(2 >= NaN) == false
.NaN
s. Todos eles param de se comportar normalmente.a !< b = not (a < b)
, poderíamos apenas dizer (! <) = (> =).O Transact-SQL possui operadores !> (Não maiores que) e ! <(Não menores que) .
Então, além de você, alguém da
SybaseMicrosoft também achou que seria uma boa ideia. Assim como o Microsoft Bob! :)fonte
Eu acho que a resposta é simplesmente que não há necessidade de um
!<
operador. Como você apontou na sua pergunta, já existe>=
e<=
com a possibilidade de negar uma expressão existente, então por que adicionar outro operador?fonte
!<
não é mais curto para digitar do que>=
, ou estou faltando alguma coisa?From RFC 1925
A adição de operadores adicionais que duplicam a funcionalidade existente não faz nada além de adicionar complexidade (desnecessária) ao idioma (e, portanto, tokenizer e analisador).
Considere também nos idiomas em que a sobrecarga do operador é possível, você teria outro operador para sobrecarregar. Considere a confusão quando
bool operator<=
ebool operator!>
pode retornar coisas diferentes (sim, eu sei que já é possível fazer comparações inconsistentes).Por fim, pense nas linguagens em que os métodos ou operadores são multiplamente definidos (Ruby - estou olhando para você ) e você tem um programador que usa <= enquanto outro usa!> E você tem vários estilos de código para a mesma expressão.
fonte
! <é igual a> = Agora, porque temos o segundo, não o primeiro, porque toda a linguagem implementa o operador positivo primeiro e depois a abordagem ao operador negativo, Como a implementação> = também abrange! <e <= abrange!>. e pensei que eles seriam redundantes e os ignorariam.
Sempre tente implementar o caso positivo primeiro e depois o caso negativo (:) pensamento positivo, apenas minha visão pessoal)
fonte
A razão é que os operadores de linguagens de programação tomam emprestado da tradição matemática e, na matemática, ninguém realmente usa "não maior" e "não menor", pois "menor ou igual" e "maior ou igual" fazem o mesmo trabalho.
Portanto, nas linguagens de programação, geralmente obtemos um símbolo parecido com ≠ para não igual (
!=
ou/=
, a menos que alguém se interesse por<>
um operador textual)e coisas que se parecem com ≤ e ≥ (
<=
e>=
)Btw, eu não concordo com a sua afirmação de que NÃO é mais simples de entender e raciocinar sobre então OU. Em matemática, as provas que envolvem muitas negações (como a redução ao absurdo) geralmente são desaprovadas, se houver uma alternativa mais direta disponível. Além disso, no caso de pedidos, o conhecimento básico que temos (e que é usado ao pensar ou provar algo) é a tricotomia entre <, = e> para que qualquer declaração! <Provavelmente tenha que ser convertida em> = se você quiser fazer qualquer coisa útil com isso.
fonte
Eu culparia parcialmente o conjunto de instruções de montagem. Você tem instruções como
jge
"pular se for maior ou igual". Ao contrário de "pular se não for menor que".Os criadores de compiladores podem ter optado pelo que os criadores de montagem criaram, o que presumivelmente se baseou em como ele foi rotulado ao ser projetado no chip.
...possivelmente.
fonte
Eu acho que vi algumas línguas há alguns anos atrás, onde, em vez do
!=
operador (não é igual a), algo como<>
foi usado. Mas não consigo lembrar os nomes deles ...Eu acho que é mais difícil de ler
!(a < b)
ou doa !< b
quea >= b
. Provavelmente, essa é a razão pela qual!<
não é usado (parece feio na minha opinião).fonte
<>
é (foi?) usado principalmente pelos dialetos BASIC, SQL e Pascal.<>
, embora tenha sido removido em 3. #!=
é mais geral do que<>
, uma vez que você pode ter coisas (como números complexos) em que a igualdade é bem definida, mas realmente não existe uma ordem útil.