1.1.6 Expressões Condicionais e Predicados

O poder expressivo da classe de funções que podemos definir neste ponto é muito limitado, porque não temos como fazer testes e realizar diferentes operações dependendo do resultado de um teste. Por exemplo, não podemos declarar uma função que calcula o valor absoluto de um número testando se o número é não-negativo e tomando diferentes ações em cada caso de acordo com a regra:

|x| = \begin{cases} x & \text{se } x \geq 0 \\ -x & \text{caso contrário} \end{cases}

Esse construto é uma análise de caso e pode ser escrito em JavaScript usando uma expressão condicional como:¹

Exemplo de Código

function abs(x) {
  return x >= 0 ? x : - x;
}

function abs(x) {
  return x >= 0 ? x : - x;
}

⛓ sessãoCódigo editável · Ctrl+Enter executa · Esc solta o foco

que poderia ser expresso em português como "Se x é maior ou igual a zero, retorne x; caso contrário, retorne -x."

A forma geral de uma expressão condicional é:

predicado ? expressão-consequente : expressão-alternativa

Expressões condicionais começam com um predicado - ou seja, uma expressão cujo valor é true ou false, dois valores booleanos distintos em JavaScript. Os expressões booleanas primitivas true e false avaliam trivialmente para os valores booleanos verdadeiro e falso, respectivamente. O predicado é seguido por um ponto de interrogação, a expressão-consequente, dois-pontos e, finalmente, a expressão-alternativa.

Para avaliar uma expressão condicional, o interpretador começa avaliando o predicado da expressão. Se o predicado é avaliado como verdadeiro, o interpretador avalia a expressão-consequente e retorna seu valor como o valor da condicional. Se o predicado é avaliado como falso, ele avalia a expressão-alternativa e retorna seu valor como o valor da condicional.

A palavra predicado é usada para operadores e funções que retornam verdadeiro ou falso, bem como para expressões que avaliam para verdadeiro ou falso. A função de valor absoluto abs faz uso do predicado primitivo >=, um operador que recebe dois números como argumentos e testa se o primeiro número é maior ou igual ao segundo número, retornando verdadeiro ou falso de acordo.

Se preferirmos lidar com o caso zero separadamente, podemos especificar a função que calcula o valor absoluto de um número escrevendo:

|x| = \begin{cases} x & \text{se } x > 0 \\ 0 & \text{se } x = 0 \\ -x & \text{caso contrário} \end{cases}

Em JavaScript, expressamos uma análise de caso com múltiplos casos aninhando expressões condicionais como expressões alternativas dentro de outras expressões condicionais:

Exemplo de Código

function abs(x) {
  return x > 0
         ? x
         : x === 0
         ? 0
         : - x;
}

function abs(x) {
  return x > 0
         ? x
         : x === 0
         ? 0
         : - x;
}

⛓ sessãoCódigo editável · Ctrl+Enter executa · Esc solta o foco

Parênteses não são necessários ao redor da expressão alternativa x === 0 ? 0 : - x, porque a forma sintática da expressão condicional é associativa à direita. O interpretador ignora espaços e quebras de linha, aqui inseridos para legibilidade para alinhar os ? e : sob o primeiro predicado da análise de caso.

A forma geral de uma análise de caso é:

p₁
? e₁
: p₂
? e₂
...
: pₙ
? eₙ
: expressão-alternativa-final

Chamamos um predicado pᵢ junto com sua expressão consequente eᵢ de uma cláusula. Uma análise de caso pode ser vista como uma sequência de cláusulas, seguida por uma expressão alternativa final.

De acordo com a avaliação de expressões condicionais, uma análise de caso é avaliada primeiro avaliando o predicado p₁. Se seu valor for falso, então p₂ é avaliado. Se o valor de p₂ também for falso, então p₃ é avaliado. Este processo continua até que um predicado seja encontrado cujo valor seja verdadeiro, caso em que o interpretador retorna o valor da expressão consequente correspondente da cláusula como o valor da análise de caso. Se nenhum dos p for encontrado como verdadeiro, o valor da análise de caso é o valor da expressão alternativa final.

Operadores Lógicos

Além de predicados primitivos como >=, >, <, <=, === e !== que são aplicados a números, existem operações de composição lógica, que nos permitem construir predicados compostos. Os três mais frequentemente usados são:

Conjunção Lógica: expressão₁ && expressão₂

Esta operação expressa conjunção lógica, significando aproximadamente o mesmo que a palavra em português "e". Assumimos que esta forma sintática é açúcar sintático para:

expressão₁ ? expressão₂ : false
Disjunção Lógica: expressão₁ || expressão₂

Esta operação expressa disjunção lógica, significando aproximadamente o mesmo que a palavra em português "ou". Assumimos que esta forma sintática é açúcar sintático para:

expressão₁ ? true : expressão₂
Negação Lógica: ! expressão

Esta operação expressa negação lógica, significando aproximadamente o mesmo que a palavra em português "não". O valor da expressão é verdadeiro quando a expressão é avaliada como falso, e falso quando a expressão é avaliada como verdadeiro.

Observe que && e || são formas sintáticas, não operadores; sua expressão do lado direito nem sempre é avaliada. O operador !, por outro lado, segue a regra de avaliação da seção 1.1.3. É um operador unário, o que significa que recebe apenas um argumento, enquanto os operadores aritméticos e predicados primitivos discutidos até agora são binários, recebendo dois argumentos. O operador ! precede seu argumento; nós o chamamos de operador prefixo. Outro operador prefixo é o operador de negação numérica, um exemplo do qual é a expressão - x nas funções abs acima.

Como exemplo de como esses predicados são usados, a condição de que um número x esteja no intervalo 5 < x < 10 pode ser expressa como:

x > 5 && x < 10

A forma sintática && tem precedência mais baixa que os operadores de comparação > e <, e a forma sintática de expressão condicional tem precedência mais baixa que qualquer outro operador que encontramos até agora, uma propriedade que usamos nas funções abs acima.

Como outro exemplo, podemos declarar um predicado para testar se um número é maior ou igual a outro como:

Exemplo de Código

function maior_ou_igual(x, y) {
  return x > y || x === y;
}

function maior_ou_igual(x, y) {
  return x > y || x === y;
}

⛓ sessãoCódigo editável · Ctrl+Enter executa · Esc solta o foco

ou alternativamente como:

Exemplo de Código

function maior_ou_igual(x, y) {
  return ! (x < y);
}

function maior_ou_igual(x, y) {
  return ! (x < y);
}

⛓ sessãoCódigo editável · Ctrl+Enter executa · Esc solta o foco

A função maior_ou_igual, quando aplicada a dois números, se comporta da mesma forma que o operador >=. Operadores unários têm precedência mais alta que operadores binários, o que torna os parênteses neste exemplo necessários.

Exercícios

Exercício 1.1

Abaixo está uma sequência de instruções. Qual é o resultado impresso pelo interpretador em resposta a cada instrução? Suponha que a sequência deve ser avaliada na ordem em que é apresentada.

10;

5 + 3 + 4;

9 - 1;

6 / 2;

2 * 4 + (4 - 6);

const a = 3;

const b = a + 1;

a + b + a * b;

a === b;

b > a && b < a * b ? b : a;

a === 4
? 6
: b === 4
? 6 + 7 + a
: 25;

2 + (b > a ? b : a);

(a > b
 ? a
 : a < b
 ? b
 : -1)
*
(a + 1);

Os parênteses ao redor das expressões condicionais nas últimas duas instruções são necessários porque a forma sintática de expressão condicional tem precedência mais baixa que os operadores aritméticos + e *.

💡 Mostrar solução — tente primeiro!💡 Esconder solução

Ideia. Basta avaliar na ordem, lembrando que declarações têm valor undefined e que os operadores seguem precedência e associatividade usuais.

Instrução	Valor	Observação
`10;`	`10`
`5 + 3 + 4;`	`12`
`9 - 1;`	`8`
`6 / 2;`	`3`
`2 * 4 + (4 - 6);`	`6`	`8 + (-2)`
`const a = 3;`	`undefined`	declarações não têm valor
`const b = a + 1;`	`undefined`	agora `b` é `4`
`a + b + a * b;`	`19`	`3 + 4 + 12`
`a === b;`	`false`
`b > a && b < a * b ? b : a;`	`4`	predicado é `true && true`
`a === 4 ? 6 : b === 4 ? 6 + 7 + a : 25;`	`16`	cai no ramo `b === 4`
`2 + (b > a ? b : a);`	`6`	`2 + 4`
`(a > b ? a : a < b ? b : -1) * (a + 1);`	`16`	`4 * 4`

Confira executando a sequência (o eco é o valor da última instrução; os demais aparecem com display):

Exemplo de Código

const a = 3;
const b = a + 1;
display(a + b + a * b);
display(a === b);
display(b > a && b < a * b ? b : a);
display(a === 4 ? 6 : b === 4 ? 6 + 7 + a : 25);
display(2 + (b > a ? b : a));
(a > b ? a : a < b ? b : -1) * (a + 1);

const a = 3;
const b = a + 1;
display(a + b + a * b);
display(a === b);
display(b > a && b < a * b ? b : a);
display(a === 4 ? 6 : b === 4 ? 6 + 7 + a : 25);
display(2 + (b > a ? b : a));
(a > b ? a : a < b ? b : -1) * (a + 1);

Código editável · Ctrl+Enter executa · Esc solta o foco

Resolvi o exercício 1.1

Exercício 1.2

Traduza a seguinte expressão para JavaScript:

\frac{5 + 4 + (2 - (3 - (6 + \frac{4}{5})))}{3(6 - 2)(2 - 7)}

💡 Mostrar solução — tente primeiro!💡 Esconder solução

Ideia. É uma tradução direta — o cuidado todo está nos parênteses do numerador e em escrever o denominador como um produto.

Exemplo de Código

(5 + 4 + (2 - (3 - (6 + 4 / 5))))
/
(3 * (6 - 2) * (2 - 7));

(5 + 4 + (2 - (3 - (6 + 4 / 5))))
/
(3 * (6 - 2) * (2 - 7));

Código editável · Ctrl+Enter executa · Esc solta o foco

Por que funciona. O numerador vale $14{,}8$ e o denominador $3 \cdot 4 \cdot (-5) = -60$ , então o resultado é $-\frac{37}{150} \approx -0{,}2467$ .

Resolvi o exercício 1.2

Exercício 1.3

Declare uma função que recebe três números como argumentos e retorna a soma dos quadrados dos dois números maiores.

💡 Mostrar solução — tente primeiro!💡 Esconder solução

Ideia. Somar os quadrados dos dois maiores é o mesmo que excluir o menor dos três. Então basta descobrir quem é o menor e somar os quadrados dos outros dois.

Exemplo de Código

function square(x) {
  return x * x;
}

function sum_of_squares_of_two_larger(a, b, c) {
  return a <= b && a <= c
         ? square(b) + square(c)
         : b <= a && b <= c
         ? square(a) + square(c)
         : square(a) + square(b);
}

sum_of_squares_of_two_larger(1, 2, 3);

function square(x) {
  return x * x;
}

function sum_of_squares_of_two_larger(a, b, c) {
  return a <= b && a <= c
         ? square(b) + square(c)
         : b <= a && b <= c
         ? square(a) + square(c)
         : square(a) + square(b);
}

sum_of_squares_of_two_larger(1, 2, 3);

Código editável · Ctrl+Enter executa · Esc solta o foco

Por que funciona. Cada ramo do condicional identifica um candidato a menor (a, b ou c) e devolve a soma dos quadrados dos outros dois. Empates não atrapalham: se a === b, tanto faz qual dos dois é "excluído". Com (1, 2, 3) o resultado é $2^2 + 3^2 = 13$ .

Armadilha comum. Testar apenas a < b (sem o =) e esquecer os empates — com desigualdades estritas nos três ramos, entradas como (2, 2, 5) podem não casar com ramo nenhum, dependendo de como você organizar os testes.

Resolvi o exercício 1.3

Exercício 1.4

Observe que nosso modelo de avaliação permite aplicações cujas expressões de função são expressões compostas. Use esta observação para descrever o comportamento de a_plus_abs_b:

Exemplo de Código

function plus(a, b) { return a + b; }

function minus(a, b) { return a - b; }

function a_plus_abs_b(a, b) {
  return (b >= 0 ? plus : minus)(a, b);
}

function plus(a, b) { return a + b; }

function minus(a, b) { return a - b; }

function a_plus_abs_b(a, b) {
  return (b >= 0 ? plus : minus)(a, b);
}

⛓ sessãoCódigo editável · Ctrl+Enter executa · Esc solta o foco

💡 Mostrar solução — tente primeiro!💡 Esconder solução

Ideia. Numa aplicação, a expressão de função também é avaliada — e aqui ela é a expressão condicional b >= 0 ? plus : minus, cujo valor é uma função.

Por que funciona. Se b >= 0, a aplicação vira plus(a, b), ou seja a + b; caso contrário vira minus(a, b), ou seja a - b. Subtrair um número negativo é somar o seu valor absoluto — então, nos dois casos, o resultado é

$a + |b|$

O exercício mostra que funções são valores como quaisquer outros: podem ser o resultado de uma expressão condicional e aplicadas em seguida.

Resolvi o exercício 1.4

Exercício 1.5

Ben Bitdiddle inventou um teste para determinar se o interpretador com o qual ele está lidando está usando avaliação de ordem aplicativa ou avaliação de ordem normal. Ele declara as seguintes duas funções:

Exemplo de Código

function p() { return p(); }

function test(x, y) {
  return x === 0 ? 0 : y;
}

function p() { return p(); }

function test(x, y) {
  return x === 0 ? 0 : y;
}

⛓ sessãoCódigo editável · Ctrl+Enter executa · Esc solta o foco

Então ele avalia a instrução:

test(0, p());

Que comportamento Ben observará com um interpretador que usa avaliação de ordem aplicativa? Que comportamento ele observará com um interpretador que usa avaliação de ordem normal? Explique sua resposta. (Suponha que a regra de avaliação para expressões condicionais é a mesma se o interpretador está usando ordem normal ou aplicativa: A expressão do predicado é avaliada primeiro, e o resultado determina se deve avaliar a expressão consequente ou a expressão alternativa.)

[1] Condicionais em JavaScript completo aceitam qualquer valor, não apenas um booleano, como resultado da avaliação da expressão do predicado. Os programas neste livro usam apenas valores booleanos como predicados de condicionais.

[2] "Interpretado como verdadeiro ou falso" significa isto: Em JavaScript completo, condicionais podem aceitar qualquer valor como resultado da avaliação da expressão predicado (veja a nota de rodapé na seção 4.1.2 para detalhes). Os programas neste livro usam apenas valores booleanos como predicados de condicionais.

💡 Mostrar solução — tente primeiro!💡 Esconder solução

Ideia. A definição function p() { return p(); } só causa problema se p() for de fato avaliada — e é exatamente nisso que os dois regimes diferem.

Ordem aplicativa (o que o JavaScript faz): os argumentos são avaliados antes de aplicar a função. Avaliar test(0, p()) exige avaliar p(), que chama p(), que chama p()… — o interpretador entra em recursão infinita e nunca responde. Experimente no bloco acima: acrescente test(0, p()); e execute — aqui no playground você verá um RangeError (estouro de pilha) ou a interrupção pelos 5 segundos, que são as formas práticas de "nunca responde".
Ordem normal: os argumentos só seriam avaliados quando necessários. test(0, p()) expandiria para 0 === 0 ? 0 : p(); o predicado é verdadeiro, o ramo p() nunca é avaliado, e o resultado é 0.

Por que o teste funciona. p() é um argumento que diverge se avaliado. A ordem aplicativa o avalia sempre; a ordem normal, nunca (neste caso). O comportamento observável — travar versus responder 0 — denuncia o regime do interpretador.

Resolvi o exercício 1.5

📝 Encontrou algo errado nesta página?

Sua ajuda é muito importante para melhorar a qualidade da tradução!

🐛 Encontrou um erro?

Se você encontrou:

Erro de tradução (palavra incorreta, termo técnico errado)
Erro de ortografia ou gramática
Link quebrado
Código de exemplo que não funciona
Problema de formatação

Reporte um bug →

❓ Tem uma dúvida?

Se você tem:

Dúvida sobre o conteúdo desta seção
Pergunta sobre um conceito do SICP
Dificuldade em entender algum exemplo
Questão sobre a tradução de algum termo

Inicie uma discussão →

💡 Tem uma sugestão de melhoria?

Se você quer sugerir:

Melhoria na explicação
Exemplo adicional
Recurso visual (diagrama, ilustração)
Qualquer outra ideia

Sugira uma melhoria →

🌍 Quer discutir a tradução?

Se você quer debater:

Escolha de tradução de algum termo
Consistência de terminologia
Nuances do português

Discussão de tradução →

Operadores Lógicos​

Exercícios​

Exercício 1.1​

Exercício 1.2​

Exercício 1.3​

Exercício 1.4​

Exercício 1.5​

📝 Encontrou algo errado nesta página?

🐛 Encontrou um erro?

❓ Tem uma dúvida?

💡 Tem uma sugestão de melhoria?

🌍 Quer discutir a tradução?

Operadores Lógicos

Exercícios

Exercício 1.1

Exercício 1.2

Exercício 1.3

Exercício 1.4

Exercício 1.5