Aprenda Programação: Operações Relacionais e Comparações

Créditos para a imagem: Imagem criada pelo autor usando o programa Spectacle.

Pré-Requisitos

Na introdução sobre ambientes de desenvolvimento, indiquei Python, Lua e JavaScript como boas escolhas de linguagens de programação para iniciantes. Posteriormente, comentei sobre GDScript como opção para pessoas que tenham interesse em programar jogos digitais ou simulações. Para as atividades de introdução a programação, você precisará de, no mínimo, um ambiente de desenvolvimento configurado em uma das linguagens anteriores.

Caso queira experimentar programação sem configurar um ambiente, você pode usar um dos editores online que criei:

Contudo, eles não possuem todos os recursos dos interpretadores para as linguagens. Assim, cedo ou tarde, você precisará configurar um ambiente de desenvolvimento. Caso precise configurar um, confira os recursos a seguir.

Assim, se você tem um Ambiente Integrado de Desenvolvimento (em inglês, Integrated Development Environment ou IDE) ou a combinação de editor de texto com interpretador, você está pronto para começar. Os exemplos assumem que você saiba executar código em sua linguagem escolhida, como apresentado nas páginas de configuração.

Caso queira usar outra linguagem, a introdução provê links para configuração de ambientes para as linguagens C, C++, Java, LISP, Prolog e SQL (com SQLite). Em muitas linguagens, basta seguir os modelos da seção de experimentação para adaptar sintaxe, comandos e funções dos trechos de código. C e C++ são exceções, por requerem o uso de ponteiros para acesso à memória.

Comparações

Com operações aritméticas, é possível manipular valores. Com operações relacionais, é possível comparar valores manipulados.

Comparações utilizam operadores denominados operadores relacionais, pois eles permitem relacionar dois valores para se fazer uma afirmação sobre eles. A afirmação, no caso, é uma resposta que será um valor lógico Verdadeiro ou Falso.

Para um exemplo, pode-se considerar duas variáveis que relacionem se um alimento pode ser consumido ou está vencido. Elas poderiam chamar dia_hoje e dia_validade, assumindo que o mês e o ano sejam os mesmos. Como informar o computador se o alimento pode ser consumido com segurança?

A resposta é comparar valores usando a operação relacional adequada para se obter a resposta Verdadeiro (pode-se consumir o alimento) ou Falso (o alimento está vencido).

Operações e Operadores Relacionais

Operadores relacionais são operadores binários (isto é, que possuem exatamente dois operandos), no formato x OP y, no qual OP é o operador. Assim, toda comparação é feita entre dois valores, que devem ser de tipos equivalentes ou compatíveis.

Linguagens de programação comumente fornecem seis operadores relacionais para comparações de valores:

Igualdade (comumente == ou =).
A operação corresponde à igualdade em Matemática (). Linguagens de programação que adotam = como atribuição normalmente definem == para igualdade. Linguagens que utilizam outro operador para atribuição (como <- ou :=) tendem a utilizar um = para igualdade.
Se x == y, os valores de x e y são iguais;
Diferença (comumente != ou <>).
A operação corresponde à diferença em Matemática (). Se x != y, então os valores de x e y são distintos;
Maior (normalmente >).
A operação é idêntica à operação Matemática de mesmo nome (). Se x > y, o valor de x é maior que o de y. Em outras palavras, y é menor ou igual a x;
Menor (normalmente <).
A operação é idêntica à operação Matemática de mesmo nome (). Se x < y, o valor de x é menor que o de y. Em outras palavras, y é maior ou igual a x;
Maior ou igual (normalmente >=).
A operação é idêntica à operação Matemática de mesmo nome (). Se x >= y, então ou o valor de x é igual ao de y, ou é maior. Portanto, y é menor que x.
Menor ou igual (comumente <=, por vezes =<).
A operação é idêntica à operação Matemática de mesmo nome (). Se x <= y, então ou o valor de x é igual ao de y, ou é menor. Portanto, y é maior que x.

Com um pouco de prática, a leitura de operadores em código-fonte torna-se imediata. Alguns editores de texto ou IDEs podem apresentar o operador com o símbolo matemático. Caso isso seja de seu interesse, pode ser interessante verificar se o seu editor ou IDE favorito fornecem a opção.

O resultado de uma operação relacional é um valor lógico. Por exemplo, 2 > 1 resulta Verdadeiro, assim como 2 == 2, 2 != 1, 2 != 1 e 2 >= 2. Por outro lado, 2 < 1 resulta Falso, assim como 2 = 1, 2 <= 1 e 1 > 2.

Qual é o Contrário de Maior? Qual é o Contrário de Menor?

É importante notar que o contrário de > não é <, mas <=. Se um número não é maior que outro, ele pode ser menor ou igual ao outro. O mesmo é válido para <, cujo contrário é >=.

Por exemplo, 1 < 2 é Verdadeiro. 2 > 1 também é Verdadeiro, assim como 2 >= 1.

Portanto, pensar em comparações genéricas como x > y segue o mesmo raciocínio. Se x > y for Falso, pode-se concluir que y > x ou que y = x. Qualquer um dos resultados é possível. Para saber qual é o caso exato, deve-se fazer uma nova comparação.

Linguagens de Programação com Poucos Operadores Relacionais

Algumas linguagens de programação definem apenas três operadores relacionais: igual, menor e maior. Para se obter os demais operadores, pode-se combinar resultados por meio de operações lógicas, que serão o próximo tópico de estudo (na próxima página).

Como uma introdução intuitiva, pode-se afirmar que:

!= () corresponde a não igual;
>= () corresponde a > ou =. Outra possibilidade é pensar em maior ou igual como não menor;
<= () corresponde a < ou =. Outra possibilidade é pensar em menor ou igual como não maior.

Os três principais operadores lógicos são e (and), ou (or), e não (not). Nos itens anteriores, o uso do operador lógico é destacado com ênfase em estilo itálico.

Compatibilidade de Tipos para Comparações

Para se comparar valores de tipos diferentes, deve-se convertê-los para um mesmo tipo. As exceções são:

Os tipos inteiro e real, que normalmente podem ser comparados sem conversões explícitas (embora existam linguagens de programação que requeiram conversão explícita). Quando a conversão é feita de usando conversão implícita, é comum que um bom compilador forneça um aviso (warning). Alguns interpretadores também podem gerar avisos;
Linguagens que fazem coerção para conversão automática de tipos.

Na realidade, o primeiro caso é uma particularização do segundo. Muitas linguagens de programação consideram a parte inteira do número real para comparações entre números reais e inteiros. O número real pode ser arrendondado para baixo (piso ou floor), com a parte decimal truncada. Arredondamentos para baixo podem resultar em erros, pois um valor como 1.99999 tornar-se-ia 1.0, quando o esperado poderia ser 2.0.

Pessoalmente, eu prefiro explicitar a conversão quando é necessário comparar um número inteiro com um número real, para esclarecer a minha intenção. Assim, também é possível realizar o arredondamento mais apropriado, seja ele para baixo (piso ou floor), para cima (teto or ceiling), ou para o valor mais próximo (round).

Comparações de Valores e Comparações de Referências

Em algumas linguagens de programação e para alguns tipos de dados, pode haver diferenças de convenções para comparações entre variáveis que armazenam valores e variáveis que armazenam referências (ou endereços de memória).

Por exemplo, para comparações de cadeias de caracteres em Java, deve-se usar equals() ao invés do operador ==. O operador compara endereços de memória (x == y), ao passo que o método (x.equals(y)) compara os valores armazenados.

Além disso, em muitas linguagens de programação, a comparação de tipos compostos usando o operador pode ser feita por referência. Nesse caso, deve-se usar a subrotina (função, procedimento ou método) adequada para comparações de valores ou verificar pela existência de operadores personalizados, com processamentos redefinidos por sobrecarga.

Definição de Operadores Personalizados para Tipos Compostos

Algumas linguagens de programação permitem especializar operadores aritméticos, relacionais e/ou lógicos para tipos compostos de dados. Isso é normalmente chamado sobrecarga de operador (operator overloading), que é um exemplo de polimorfismo.

Embora a explicação e exemplificação sobre o conceito não estejam no escopo desta página em específico, é importante conhecê-lo por causa de uma ressalva. Nem toda linguagem de programação permitem usar operadores relacionais pré-definidos com tipos compostos.

Um exemplo é linguagem C, que não permite comparações de cadeias de caracteres usando os operadores = e !=, mas requer a criação de uma subrotina (função), ou de estruturas de condição e de repetição para realizar comparações.

Portanto, antes de realizar comparações, é importante consultar a documentação da linguagem para conhecer quais são os tipos de dados suportados pelos operadores pré-definidos.

Sensibilidade de Caixa

Comparações de cadeias de caracteres possuem outra peculiaridade. Comparações de igualdade e diferença podem distingüir letras maiúsculas (caixa alta) de letras minúsculas (caixa baixa), algo conhecido como sensibilidade de caixa (case sensitivity).

Linguagens de programação que fazem a distinção são chamadas de sensíveis à caixa (case-sensitive).

Por exemplo, em uma linguagem case-sensitive:

"Franco" == "Franco" é Verdadeiro;
"Franco" != "Franco" é Falso;
"Franco" == "franco" é Falso.
"FrAnCo" == "FrAnCo" é Verdadeiro.

Assim, a comparação de cada caractere correspondente em cada cadeia de caracteres deve ter a mesma letra e a mesma caixa. Para se ignorar a caixa, pode-se converter ambas as cadeias de caracteres para uma mesma caixa -- por exemplo, todos os caracteres para letras maiúsculas ou todos os caracteres para letras minúsculas.

Precisão de Números Reais

Comparações de números reais também requerem atenção, devido à imprecisões decorrentes do uso de ponto flutuante. Em geral, usar == e != para comparar números em ponto flutuante não é adequado.

Existem duas alternativas:

Usar <= ou >=, e considerar valores até o número desejado;
Utilizar um valor pequeno como margem de erro aceitável para comparações, normalmente chamado de epsilon ( ou ).

Algumas linguagens de programação definem uma constante EPSILON; outras, não. Por exemplo:

JavaScript: Number.EPSILON (documentação);
Python: sys.float_info.epsilon (documentação).

Em linguagens que não definem uma constante, você pode escolher um valor que julgar apropriado para as características de seu problema. Outra opção é usar o valor adotado pela linguagem C.

C: FLT_EPSILON (para o tipo float), DBL_EPSILON (para o tipo double), LDBL_EPSILON (para o tipo long double) (documentação).

Na minha máquina, o valor obtido foi 2.220446049250313e-16 (), que será usado para Lua e GDScript no próximo exemplo. Para ilustrar o problema, pode-se efetuar um cálculo como , cujo resultado esperado seria . Contudo, devido a problemas de precisão, o resultado tenderá a ser próximo, mas diferente, de zero.

let zero = 0.1 + 0.2 - 0.3
console.log(zero)
console.log(zero === 0.0) // false
console.log(Math.abs(zero) < Number.EPSILON) // true

import sys

zero = 0.1 + 0.2 - 0.3
print(zero)
print(zero == 0.0) # False
print(abs(zero) < sys.float_info.epsilon) # True

local EPSILON <const> = 2.220446049250313e-16

local zero = 0.1 + 0.2 - 0.3
print(zero)
print(zero == 0.0) -- false
print(math.abs(zero) < EPSILON) -- true

extends Node

const EPSILON = 2.220446049250313e-16

func _ready():
    var zero = 0.1 + 0.2 - 0.3
    print(zero)
    print(zero == 0.0) # false
    print(abs(zero) < EPSILON) # true

Executando-se os blocos de código anteriores, pode-se observar que a comparação com 0.0 falha, mas a comparação considerando a margem de erro EPSILON apresenta o resultado correto.

O exemplo anterior explica minha recomendação em Tipos de Dados para que iniciantes usem double ao invés de float em linguagens que permitam a escolha. A maior precisão resulta em valores mais próximos dos esperados na Matemática.

Operadores Relacionais em Programação

Tomando-se os cuidados para se comparar tipos de dados compatíveis e identificando-se o operador (ou a subrotina) apropriada para comparação de cadeias de caracteres, o uso de operadores relacionais é simples.

Fluxogramas: Flowgorithm

Flowgorithm permite usar os dois estilos mais tradicionais de operadores para igualdade e diferença, como descrito na documentação. Você pode escolher o que prefir; os exemplos usarão == e != para facilitar a identificação de uso em exemplos de código-fonte escrito.

Igualdade: == ou =;
Diferença: != ou <>;
Menor: <;
Menor ou igual: <=;
Maior: >;
Maior ou igual: >=.

Comparações entre cadeias de caracteres são case-sensitive. Contudo, o programa não fornece subrotinas pré-definidas para conversão de caixa. Embora seja possível criar um fluxograma para fazer a conversão, a implementação requereria recursos ainda não abordados (como estruturas de repetição).

Exemplo de operações relacionais em Flowgorithm: igualdade, diferença, menor, maior, menor e igual, e maior e igual.

O conteúdo da imagem está transcrito a seguir.

Principal

Saída 1 == 2
Saída 1 != 2
Saída 1 > 2
Saída 1 >= 2
Saída 1 < 2
Saída 1 <= 2

Saída 1.0 == 2.0
Saída 1.0 != 2.0
Saída 1.0 > 2.0
Saída 1.0 >= 2.0
Saída 1.0 < 2.0
Saída 1.0 <= 2.0

Saída True == True
Saída True != False

Saída "Franco" == "Franco"
Saída "Franco" != "Franco"
Saída "Franco" == "franco"
Saída "FrAnCo" == "FrAnCo"

Fim

Neste momento, os operadores podem ser usados no bloco de Saída (Output) ou Atribuição (Assign). Em próximos tópicos, eles também poderão ser utilizados para blocos de controle e repetição.

Linguagens de Programação Visual: Scratch

Operadores relacionais em Scratch estão no menu lateral Operadores (Operators). Scratch possui apenas três operadores relacionais: =, > e <. Para gerar os demais:

!=: usa-se um bloco não (not) com o bloco =;
>=: use-se um bloco ou (or). Na primeira posição, insere-se um bloco >. Na segunda posição, insere-se um bloco =. A ordem pode ser invertida;
<=: use-se um bloco ou (or). Na primeira posição, insere-se um bloco <. Na segunda posição, insere-se um bloco =. A ordem pode ser invertida.

Exemplo de operações relacionais em Scratch: igualdade, diferença, menor, maior, menor e igual, e maior e igual.

A linguagem não é case-sensitive, ou seja, letras maiúsculas e minúsculas correspondentes são consideradas iguais.

Como a linguagem não oferece constantes para valores lógicos, usou-se um bloco não (not) vazio como Verdadeiro e um bloco e (and) vazio como Falso.

Linguagens de Programação Textual: JavaScript, Python, Lua e GDScript

Com exceção de igual e diferente em JavaScript, e diferente em Lua, os operadores relacionais são idênticos em JavaScript, Python, Lua e GDScript.

Linguagem	Igual	Diferente	Maior	Menor	Maior ou Igual	Menor ou Igual
JavaScript	`===`	`!==`	`>`	`<`	`>=`	`<=`
Python	`==`	`!=`	`>`	`<`	`>=`	`<=`
Lua	`==`	`~=`	`>`	`<`	`>=`	`<=`
GDScript	`==`	`!=`	`>`	`<`	`>=`	`<=`

Além disso, as quatro linguagens permitem comparar cadeias de caracteres usando os operadores para igualdade e diferença. As quatro linguagens são case-sensitive. Para conversões entre letras maiúsculas e minúsculas:

JavaScript:
- Converter para minúsculas: toLowerCase() (documentação);
- Converter para maiúsculas: toUpperCase() (documentação).
Python:
- Converter para minúsculas: lower() (documentação);
- Converter para maiúsculas: upper() (documentação).
Lua:
- Converter para minúsculas: string.lower() (documentação);
- Converter para maiúsculas: string.upper (documentação).
GDScript:
- Converter para minúsculas: to_lower() (documentação);
- Converter para maiúsculas: to_upper() (documentação).

console.log(1 === 2)
console.log(1 !== 2)
console.log(1 > 2)
console.log(1 >= 2)
console.log(1 < 2)
console.log(1 <= 2)

console.log(1.0 === 2.0)
console.log(1.0 !== 2.0)
console.log(1.0 > 2.0)
console.log(1.0 >= 2.0)
console.log(1.0 < 2.0)
console.log(1.0 <= 2.0)

console.log(true === true)
console.log(true !== false)

console.log("Franco" === "Franco")
console.log("Franco" !== "Franco")
console.log("Franco" === "franco")
console.log("FrAnCo" === "FrAnCo")
console.log("fRaNcO".toLowerCase() === "FrAnCo".toLowerCase())
console.log("fRaNcO".toUpperCase() === "FrAnCo".toUpperCase())

print(1 == 2)
print(1 != 2)
print(1 > 2)
print(1 >= 2)
print(1 < 2)
print(1 <= 2)

print(1.0 == 2.0)
print(1.0 != 2.0)
print(1.0 > 2.0)
print(1.0 >= 2.0)
print(1.0 < 2.0)
print(1.0 <= 2.0)

print(True == True)
print(True != False)

print("Franco" == "Franco")
print("Franco" != "Franco")
print("Franco" == "franco")
print("FrAnCo" == "FrAnCo")
print("fRaNcO".lower() == "FrAnCo".lower())
print("fRaNcO".upper() == "FrAnCo".upper())

print(1 == 2)
print(1 ~= 2)
print(1 > 2)
print(1 >= 2)
print(1 < 2)
print(1 <= 2)

print(1.0 == 2.0)
print(1.0 ~= 2.0)
print(1.0 > 2.0)
print(1.0 >= 2.0)
print(1.0 < 2.0)
print(1.0 <= 2.0)

print(true == true)
print(true ~= false)

print("Franco" == "Franco")
print("Franco" ~= "Franco")
print("Franco" == "franco")
print("FrAnCo" == "FrAnCo")
print(string.lower("fRaNcO") == string.lower("FrAnCo"))
print(string.upper("fRaNcO") == string.upper("FrAnCo"))
-- Forma alternativa para cadeias de caracteres armazenadas em variáveis.
local x = "fRaNcO"
local y = "FrAnCo"
print(x:lower() == y:lower())
print(x:upper() == y:upper())

extends Node

func _ready():
    print(1 == 2)
    print(1 != 2)
    print(1 > 2)
    print(1 >= 2)
    print(1 < 2)
    print(1 <= 2)

    print(1.0 == 2.0)
    print(1.0 != 2.0)
    print(1.0 > 2.0)
    print(1.0 >= 2.0)
    print(1.0 < 2.0)
    print(1.0 <= 2.0)

    print(true == true)
    print(true != false)

    print("Franco" == "Franco")
    print("Franco" != "Franco")
    print("Franco" == "franco")
    print("FrAnCo" == "FrAnCo")
    print("fRaNcO".to_lower() == "FrAnCo".to_lower())
    print("fRaNcO".to_upper() == "FrAnCo".to_upper())

As comparações podem ser feitas tanto usando constantes quanto com variáveis. Em Lua, é possível usar a sintaxe alternativa para conversão de caixa em cadeias de caracteres armazenadas em variáveis.

Também convém relembrar os cuidados necessários para comparações entre números reais.

Além disso, deve-se atentar que JavaScript define os operadores == e !=; contudo, normalmente é preferível usar as versões um igual adicional (=== e !==). A diferença é que o operador == realiza conversões implícitas de tipos (usando coerção), não requerendo que os tipos sejam iguais para retornar true. O mesmo vale para a diferença com !=. O problema da conversão implícita em JavaScript é que existem vários casos a se considerar que não são intuitivos e podem levar a erros inesperados (para entender mais, pode-se consultar a MDN). Assim, os operadores === e !== em JavaScript são equivalente ao operadores == e != de muitas outras linguagens de programação.

Novos Itens para Seu Inventário

Habilidades:

Comparações.

Conceitos:

Igualdade;
Diferença;
Desigualdades: maior, menor, maior ou igual, menor ou igual.

Recursos de programação:

Operações relacionais.

Pratique

Operações relacionais permitem relacionar valores para a definição de possíveis decisões. Embora a definição de processamentos específicos para possíveis cenários dependam de estruturas condicionais, é possível armazenar os resultados como respostas e escrevê-los.

Por exemplo, uma divisão requer um numerador (dividendo) e um denominador (divisor). O denominador não pode ser zero, isto é, uma divisão válida requer .

let denominador = 1
let divisao_valida = denominador !== 0
console.log("O denominador ", denominador, " é válido para uma divisão? ", divisao_valida)

denominador = 0
divisao_valida = denominador !== 0
console.log("O denominador ", denominador, " é válido para uma divisão? ", divisao_valida)

denominador = 1
divisao_valida = denominador != 0
print("O denominador ", denominador, " é válido para uma divisão? ", divisao_valida)

denominador = 0
divisao_valida = denominador != 0
print("O denominador ", denominador, " é válido para uma divisão? ", divisao_valida)

local denominador = 1
local divisao_valida = denominador ~= 0
print("O denominador ", denominador, " é válido para uma divisão? ", divisao_valida)

denominador = 0
divisao_valida = denominador ~= 0
print("O denominador ", denominador, " é válido para uma divisão? ", divisao_valida)

extends Node

func _ready():
    var denominador = 1
    var divisao_valida = denominador != 0
    print("O denominador ", denominador, " é válido para uma divisão? ", divisao_valida)

    denominador = 0
    divisao_valida = denominador != 0
    print("O denominador ", denominador, " é válido para uma divisão? ", divisao_valida)

Crie programas que realizem comparações para as seguintes situações, escrevendo o valor lógico resultante como saída:

A idade mínima para votar em um determinado país é 16 anos. Uma pessoa com uma idade armazenada na variável idade_anos poderia votar no país?
A média mínima para aprovação em uma escola é 6.5, baseada na média de 3 notas. Uma pessoa com notas n1, n2 e n3 (valores fornecidos pelo usuário via entrada) foi aprovada?
Para a questão anterior, pode-se considerar que, agora, a média é ponderada. n1 corresponde a 20% da média; n2 a 35%; n3 a 45%. Uma pessoa com as mesmas notas anteriores ainda seria aprovada?
Armazene o valor de um nome. O nome escolhido é Franco? Cuidado com diferenças entre letras maiúsculas e minúsculas. Por exemplo, FRANCO e franco correspondem ao nome Franco, assim com FRAnco.
Qual é o seu prato favorito? Qual é o prato favorito de sua melhor amiga ou de seu melhor amigo? Vocês tem o mesmo prato favorito?
Para o cálculo de uma equação do segundo grau da forma que admita raízes reais, o discriminante não pode ser negativo. Escreva um programa que armazene valores para a, b e c de uma equação do segundo grau e responda se a equação possui raízes reais.
Uma loja tem ocupação máxima permitida de numero_maximo_pessoas_permitidas. Um total de numero_pessoas estão na loja neste instante. A loja está cheia?
Solicite a entrada de um número. O número fornecido é par? Números pares são múltiplos de 2, isto é, o resto da divisão por 2 deve ser zero.
Escreva comparações para determinar a resposta das seguintes expressões:
- (atenção: a expressão requer uso de números reais)
Algumas pessoas dizem que é possível multiplicar a idade de um cão por 7 para ter uma estimativa da "idade humana" do canino. Solicite a entrada de um valor para a idade do cão. A idade do cão corresponde a 28 anos humanos ou mais?
Para uma estimativa mais científica da "idade humana" de um cão, você pode consultar esta página.

Próximos Passos

Embora operações relacionais possam parecer supérfluas quando analisadas individualmente, elas tornar-se-ão importantes para a escrita de escolhas e tomadas de decisão em programas.

Assim, caso você não identifique aplicações práticas imediatas para o uso de operadores relacionais, eles serão praticamente indispensáveis para o uso de estruturas de condição e de repetição.

Todavia, a leitura atenta do texto pode gerar uma dúvida pertinente. Operações relacionais utilizam dois operandos. O que fazer quando é necessário comparar mais de dois valores? Além disso, como combinar comparações que requeiram o uso de múltiplas variáveis, talvez não relacionadas diretamente?

Por exemplo, o acesso a uma página restrita pode requerer um endereço de e-mail e uma senha. O e-mail deve ser válido; a combinação de e-mail e senha deve ser corretas. O que fazer?

A resposta é combinar resultados intermediários por meio de operadores lógicos. A seção sobre Scratch forneceu um exemplo de criação dos operadores !=, >= e <= com as operações não (not) e ou (or). Convém formalizar o uso dos operadores e introduzir outros para que você possa usá-los em seus programas.

← Anterior:
Aprenda Programação: Aritmética e Matemática Básica

Próximo:→
Aprenda Programação: Operações Lógicas e Álgebra Booleana