Avaliação Curto-Circuito e Lógica Booleana

Sabe aquelas aulinhas de lógica da época da faculdade que você odiava? Pois é, elas podem ser muito úteis em programação. Você deve estar pensando que o que eu estou falando é evidente, mas aposto como alguns programadores desconhecem algo chamado avaliação curto-circuito que está presente no C, no Java, no ActionScript e em outras linguagens.

Para explicar o que é avaliação curto-circuito vamos considerar o seguinte código em ActionScript.

var index:Number = findItem(item);

if (item.findable == true && index != -1) {
trace(“item encontrado “);
} else {
trace(“item NÃO encontrado”);
}

Aqui temos uma condicional composta por duas outras expressões condicionais simples: a do lado esquerdo e a do lado direito do operador && (and). A função “findItem(item)”, executada antes da condifional, busca por um “item” numa lista e armazena em “index” a posição em que o item se encontra; ou “-1″ caso o item não seja encontrado na lista. Poderíamos ler o trecho de código acima da seguinte maneira:

se um item que pode ser encontrado for encontrado
imprima ‘item encontrado ’
senão
imprima ‘item NÃO encontrado ”.

A expressão condicional simples do lado esquerdo verifica se o item é um item que pode ser encontrado ou não. Isso é controlado pela propriedade “findable” do item. Um “item.findable=true” é um item findable (pode ser encontrado); já um “item.findable=false” é um item não-findable (não pode ser encontrado). Oras, então, os itens não-findable não precisam nem ser procurados. Mas no código em ActionScript acima todos os itens serão procurados. Isto acarreta num processamento desnecessário para itens não-findables. Você pode resolver este problema usando a avaliação de curto-circuito como no exemplo abaixo:

if (item.findable == true && findItem(item) != -1) {
trace(“item encontrado “);
} else {
trace(“item NÃO encontrado”);
}

Neste exemplo, a busca não será efetuada para um item não-findable. Por quê? É aqui que entram aquelas aulinhas de lógica maçantes e a implementação interna da linguagem de programação. Tratemos da lógica em primeiro lugar.

Um operador condicional “&&” diz que uma condicional composta só será verdadeira se as duas simples também forem. Lembra da tabela verdade?

V V = V
V F = F
F V = F
F F = F

Um detalhe interessante nesta tabela é que ela nos mostra que se o primeiro elemento é “F” o segundo pode ser ignorado – o resultado será sempre F. Agora, voltando à implementação das linguagens de programação, algumas linguagens como Java, C e ActionScript lançam mão deste conhecimento lógico na avaliação de expressões condicionais compostas. Isto quer dizer que se o resultado da expressão da esquerda em uma condicional composta for “F” a expressão da direita será ignorada. Votemos ao exemplo mais uma vez.

if (item.findable == true && findItem(item) != -1) {
trace(“item encontrado “);
} else {
trace(“item NÃO encontrado”);
}

Se “item.findable” for falso, “findItem(item)” será ignorado porque já se sabe que o resultado do “if” será falso de qualquer modo. Agora imagine que a função “findItem” tem que percorrer uma lista de 1000 elementos. Esta seria uma boa maneira de economizar processamento para itens não-findables.

Muitas vezes nos deparamos com matérias num curso que pensamos serem totalmente dispensáveis. Mas quase sempre estamos errados. Dispensáveis são aqueles professores que além de não ensinar nada fazem com que o aluno crie total aversão a determinados assuntos de suma importância. Espero que eu tenha sido capaz de fazê-lo compreender este post, caso contrário… bem, espero que você leia novamente e não crie aversão alguma sobre os assuntos aqui tratados. Se você ainda não conhecia a avaliação curto-circuito e compreendeu o que eu acabei de explicar, pode tentar implementar um pequeno exemplo para ver com isto pode ser interessante.