<Direto ao Ponto 42> Os comandos de seleção

Artigos desta série: ( < ) Anterior | Índice | Seguinte ( > )

Olá, dev!

Este é mais um artigo da série DIRETO AO PONTO, que eu estou escrevendo para a DIO. Ele vai tratar de um dos blocos de programação com comandos múltiplos, os comandos de seleção.

Sumário

1. Introdução

2. Comandos de seleção antigos

3. Algoritmo para seleção

4. Comandos de seleção atuais

5. Considerações finais

6. Referências

1 – Introdução

Eu criei a série de artigos DIRETO AO PONTO com o objetivo de apresentar, de forma simples e direta, conhecimentos básicos da programação e de computação, principalmente, para os iniciantes.

Aqui, são tratados temas como lógica de programação, linguagens, hardware dos computadores, história da computação e assuntos relacionados à plataforma da DIO, como a escrita de artigos e os desafios de código.

Neste artigo, eu vou falar sobre um dos blocos de programação com comandos múltiplos, os comandos de seleção.

Estes comandos são responsáveis por desviar o fluxo da execução sequencial do programa de acordo com o resultado de testes lógicos ou do valor de variáveis. Existem 2 tipos principais, os comandos de seleção simples e os de seleção múltipla.

Desde as primeiras linguagens de programação, os comandos de seleção já existiam.

Vamos ver o que eles nos oferecem!

2 – Comandos de seleção antigos

Os comandos de seleção oferecidos pelas linguagens de programação atuais são o IF-ELSE e o SWITCH-CASE, com algumas variações. As primeiras linguagens de programação ofereciam outros tipos de comandos de seleção e direcionamento de fluxo da execução do programa. Veja os que a linguagem Fortran IV oferecia, antes da versão estruturada (Fortran 77).

COMANDOS DE SELEÇÃO DA LINGUAGEM FORTRAN

IF Lógico (IF Simples) – Se a condição for verdadeira, executa uma instrução única; ainda não existia a parte do ELSE. Exemplo de trecho de código:

IF (X .GT. 0) PRINT *, 'X EH POSITIVO'

OBS: .GT. é o operador maior que ("Greater Than"). 

GOTO Condicional – Era um comando IF Lógico que desviava o fluxo para uma instrução com um rótulo (label), ao invés de executar uma instrução no próprio comando. Exemplo:

   IF (X .LT. 0) GOTO 100
   PRINT *, 'X EH POSITIVO OU ZERO'
   GOTO 200
100  PRINT *, 'X EH NEGATIVO'
200  CONTINUE

OBS: .LT. é o operador maior que ("Less Than").

IF Aritmético – Esta era uma das formas mais antigas de decisão em Fortran. Após a avaliação de uma expressão aritmética, o fluxo era direcionado para um dos 3 rótulos (labels) com 1 linha de código cada, com base no resultado da avaliação. Exemplo:

   IF (A - B) 10, 20, 30
10 PRINT *, 'A EH MENOR QUE B'
   GOTO 40
20 PRINT *, 'A EH IGUAL A B'
   GOTO 40
30 PRINT *, 'A EH MAIOR QUE B'
40 CONTINUE

Explicação: Se a expressão for:

negativa, será executado o comando do primeiro rótulo (10);

positiva, será executado o comando do terceiro rótulo (30);

zero, será executado o comando do segundo rótulo (20).

OBS: EH signifca É, naquele tempo não havia caracteres acentuados e a gente usava essa gambiarra ortográfica. E só eram oferecidos caracteres maiúsculos, por causa da perfuradora de cartões.

GOTO COMPUTADO – Com base no valor de uma variável, que funciona como um índice (1, 2...), a execução salta para uma das várias linhas de código, de acordo com um rótulo:

   GOTO (10, 20, 30), N
10   PRINT *, 'PRIMEIRO CASO'
   GOTO 40
20   PRINT *, 'SEGUNDO CASO'
   GOTO 40
30   PRINT *, 'TERCEIRO CASO'
40   CONTINUE

Explicação: Se o valor da variável N for

1, será executado o comando do primeiro rótulo (10);

2, será executado o comando do terceiro rótulo (30);

3, será executado o comando do segundo rótulo (20).

Depois que foi lançada a versão estruturada da linguagem Fortran, Fortran 77, foi recomendado não se usar mais o comando GOTO e novas formas de decisão foram oferecidas por ela, como o IF-ELSE.

Na execução deste comando, os blocos que seriam executados caso a condição fosse verdadeira eram delimitados pela palavra-chave IF e ELSE (primeiro bloco) e por ELSE e END IF (segundo bloco), caso contrário.

A linguagem COBOL já oferecia o comando IF-ELSE e a ALGOL 60 oferecia o comando IF-THEN-ELSE.

3 – Algoritmos para seleção

Em um dos artigos anteriores desta série, eu falei da importância de se esboçar um algoritmo antes de começar a codificar um programa de computador. Além de dar uma visão geral do que se quer criar, ele ajuda a dividir o problema em pedaços menores, que podem ser codificados separadamente e com mais facilidade, como uma montagem de blocos estruturados.

Um dos blocos usados na programação estruturada é o de comandos de seleção, aqueles que podem alterar o fluxo da execução do programa com base em condições testadas ao longo de sua execução. São os famosos comandos IF-ELSE.

Existem dois tipos básicos de comandos de seleções, os de seleção simples e os de seleção múltipla.

O comando de seleção simples testa uma condição e, dependendo do resultado, direcionam o fluxo para um de 2 caminhos possíveis. São os comandos IF-ELSE e suas variações. Um possível algoritmo para ele é:

Se condição for verdadeira, execute comando1

Senão, execute comando 2

O fluxograma para este algoritmo é:

Um exemplo usando códigos da linguagem Scratch é:

O de seleção múltipla testa o valor de uma variável e, dependendo do resultado, direciona o fluxo para um de vários comandos. São os comandos SWITCH-CASE e suas variações. Um possível algoritmo para ele é:

Se o valor da variável for

v1, execute o comando 1

v2, execute o comando 1

...

vN, execute o comando 1

caso contrário, execute o comando padrão (default)

O fluxograma para este algoritmo é:

4 – Comandos de seleção atuais

Os comandos de decisão atuais são aqueles citados na seção anterior, com algumas variações de implementação de uma linguagem para outra.

COMANDOS DE SELEÇÃO ÚNICA

IF - Se a condição for verdadeira, executa uma instrução única ou um bloco de instruções. Exemplo em Pascal:

var x: integer; 
begin 
x := 10; 
if x > 5 then 
begin
   writeln('número maior que 5') 
   writeln(‘Fim do programa’);
end 
end.

Note que os delimitadores do bloco que seria executado (com instruções writeln) são begin e end, diferentes das chaves - { } - usadas atualmente.

IF-ELSE - Se a condição for verdadeira, executa uma instrução única ou um bloco de instruções, caso contrário, executa outra instrução única ou outro um bloco de instruções. Veja a seguir exemplos em C. No primeiro, cada resultado tem apenas uma instrução, no segundo, cada um tem um bloco de comandos:

 // Usando um comando único para cada resultado
 if (nota > 7)
     printf("A nota é maior que 7\n");
 else
     printf("A nota é menor ou igual a 7\n");

 // Usando blocos de comandos
 if (nota > 7) {
     printf("A nota é maior que 7\n");
     printf("Você foi aprovado!\n");
 } else {
     printf("A nota é menor ou igual a 7\n");
     printf("Você não foi aprovado... Ainda!\n");
 }

Os delimitadores dos blocos deste comando são os caracteres de abrir chave ( { ) e fechar chave ( } ). Uma variação deste comando foi apresentada pela linguagem BASIC, que usava as palavras-chave “IF THEN”, para iniciar o bloco da condição verdadeira, e “ELSE”, caso contrário.

IF-ELSE-IF-ELSE – Caso a condição seja falsa, será executado um novo outro comando IF-ELSE dentro do primeiro, dependente dele, para testar uma nova condição. Exemplo em Javascript:

let num = 5;
 
if (num > 0) {
 console.log("O número é positivo");
} else if (number < 0) {
 console.log("O número é negativo");
} else {
 console.log("O número é zero");
}

O uso em excesso de instruções IF-ELSE aninhadas gera o efeito conhecido como IF-ELSE HELL , com muitas condições sendo testadas, muitas ações. Isso cria muita dificuldade de acompanhamento, manutenção e escalabilidade do código (veja a figura de capa deste artigo). Veja um exemplo deste efeito, em Java:

if (x > 0) {
 if (y > 0) {
     if (z > 0) {
         // Faz alguma coisa
     } else {
         // Faz outra coisa
     }
 } else {
     // Bloco de código
 }
} else {
 // Outro bloco de código
}

DOLZANE [1] mostra várias maneiras para evitar o IF-ELSE HELL em códigos que precisem de múltiplas condições.

IF-ELSEIF-ELSE – Comando semelhante ao anterior, só que usa uma única palavra-chave para substituir as palavras-chave ELSE e IF dos comandos intermediários, dando mais legibilidade ao código. Exemplo em Python (IF-ELIF-ELSE):

valor = 2
 
if valor == 1: 
print("Um")
elif valor == 2: 
print("Dois") 
else: 
print("Outro")

Python usa a palavra-chave IF, para iniciar o bloco da condição verdadeira, ELIF para iniciar cada bloco subsequente e ELSE apenas no bloco final, para a condição default. O Fortran 77 já tinha um comando semelhante a este (IF-ELSEIF-ELSE), usado para simular um SWITCH-CASE, não oferecido pela linguagem.

COMANDOS DE SELEÇÃO MÚLTIPLA

SWITCH-CASE - Neste comando, o valor de uma variável é testado e o fluxo é desviado para um dos comandos listados, de acordo com o valor dela. Exemplo em Java:

int dia = 3; 
switch (dia) {
case 1: 
   System.out.println("Domingo");
   break;
case 2:
   System.out.println("Segunda-feira");
   break;
case 3:
  System.out.println("Terça-feira");
  break;
default:
  System.out.println("Outro dia");
 }

Várias linguagens também oferecem o mesmo comando, como C, C++, C#, Javascript, Java, PHP etc. Pascal possui um comando semelhante, mas com outras palavras-chave (CASE x OF), onde x é uma variável, e ELSE é usado para o caso padrão. Python não possui um comando SWITCH-CASE nativo como outras linguagens, mas o comportamento pode ser simulado com IF-ELIF-ELSE ou dicionários.

WHEN - Este comando, oferecido pela linguagem Kotlin, é mais poderoso e flexível que o SWITCH-CASE. Veja um exemplo:

val x = 2
 when (x) {
 1 -> println("Um")
 2 -> println("Dois")
 3 -> println("Três")
 else -> println("Outro")
 }

 Inicialmente, o comando SWITCH-CASE só aceitava variável inteira e char, mas atualmente algumas linguagens aceitam o tipo enumerado (enum), booleano, e strings.

5 – Considerações finais

Este é mais um artigo da série DIRETO AO PONTO, que eu estou escrevendo para a DIO.

Desta vez, eu falei sobre os comandos de seleção, um dos comandos de blocos múltiplos. São aqueles comandos que direcionam o fluxo de execução das instruções com base em resultados de operações condicionais ou lógicas.

Desde as primeiras linguagens de programação, como ALGOL 60, COBOL e FORTRAN, já havia comandos desse tipo, como o comando IF e IF-ELSE.

Naquele tempo, muitas instruções para desvio de fluxo eram baseadas nos comandos GO TO, como no FORTRAN. Era muito difícil escrever, entender, acompanhar e manter os programas que tinham estas construções.

Posteriormente, com a chegada das versões estruturadas das linguagens, estes comandos passaram a ser oferecidos para executar um bloco de instruções no caso de condições verdadeiras e outro bloco, caso contrário. Antes eles eram usados com uma instrução única para cada resultado.

Mais tarde, surgiu um novo comando, chamado SWITCH-CASE, que não dependia do resultado de operações lógicas, mas do valor de uma variável (ou expressão) para desviar o fluxo do programa.

Os comandos mais comuns oferecidos pela maioria das linguagens de programação atuais são o IF-ELSE, e suas variações, para seleção única, e SWITCH-CASE e suas variações para seleção múltipla.

Mesmo assim, ainda surgem novas variantes dos comandos tradicionais, como o comando WHEN, da linguagem Kotlin, que é mais moderno que o SWITCH-CASE, permitindo mais flexibilidade.

No próximo artigo, eu vou começar a falar sobre outro bloco de comandos múltiplos, os comandos de repetição.

6 – Referências

Praticamente todo o conteúdo deste artigo foi tirado do que eu aprendi (e me lembro) sobre o assunto desde o início da minha carreira como programador, desde os anos 80 até agora.

Para a elaboração dos códigos com os detalhes dos comandos oferecidos pelas diversas linguagens de programação usadas aqui, eu consultei as ferramentas ChatGPT e Copilot.

A única referência que vou listar aqui é uma que trata do problema do IF-ELSE HELL (excesso de comandos IF_ELSE) e de como evitar este problema nos seus códigos.

[1] Henrique DOLZANE, Fuja do IF-ELSE-HELL. Disponível em: https://henriquedolzane.medium.com/fuja-do-if-else-hell-53cbceb74367. Acesso em: 05/09/2024.

Artigos desta série: ( < ) Anterior | Índice | Seguinte ( > )