Variáveis no pseudocódigo essencial: nomes, tipos e escopo

O que são variáveis no pseudocódigo essencial

Variáveis são “nomes” que guardam valores que mudam ao longo do algoritmo. No pseudocódigo essencial, a meta é que o leitor entenda rapidamente: o que a variável representa, que tipo de valor ela guarda e onde ela pode ser usada (escopo).

Uma variável bem escolhida reduz dúvidas e evita erros comuns como: usar o mesmo nome para coisas diferentes, depender de valores “escondidos” em outras partes do algoritmo, ou misturar tipos (por exemplo, somar texto com número).

Convenções de nomeação: clareza acima de tudo

Regras práticas de nomeação

• Seja descritivo: o nome deve indicar o significado do valor (ex.: totalCompra, idadeCliente, dataNascimento).
• Evite abreviações obscuras: prefira quantidadeItens a qtdIt; valorDesconto a vlDesc.
• Use um padrão consistente: escolha um estilo e mantenha (ex.: camelCase como precoUnitario).
• Use singular/plural com intenção: item (um), itens (lista/coleção).
• Evite nomes genéricos: valor, dados, aux só quando o contexto for extremamente óbvio. Se precisar de “auxiliar”, descreva o papel: indiceAtual, textoNormalizado.
• Inclua unidade quando relevante: tempoLimiteSegundos, distanciaKm.
• Prefira nomes afirmativos para booleanos: estaAtivo, temDesconto, pagamentoAprovado. Evite dupla negação como naoInvalido.

Checklist rápido para validar um nome

• Se alguém ler só o nome, entende o que representa?
• O nome evita ambiguidade (ex.: taxa pode ser “percentual” ou “valor fixo”)?
• O nome combina com o tipo (ex.: dataEntrega não deveria ser texto livre)?

Categorias comuns de variáveis (com intenção clara)

1) Contadores

Guardam quantidades de ocorrências ou itens processados. Normalmente começam em 0 e aumentam de 1 em 1 (ou por um passo).

contadorErros <- 0Para cada tentativa em tentativas    Se tentativa.falhou Então        contadorErros <- contadorErros + 1    FimSeFimPara

Boas práticas: nome com “contador” ou com o que conta (quantidadeErros), inicialização explícita, incremento claro.

2) Acumuladores

Somam valores ao longo do processamento (total, soma, saldo). Normalmente começam em 0 (para números) ou vazio (para texto/listas).

Continue em nosso aplicativo e ...

• Ouça o áudio com a tela desligada
• Ganhe Certificado após a conclusão
• + de 5000 cursos para você explorar!

ou continue lendo abaixo...

Baixar o aplicativo

totalCompra <- 0Para cada item em itens    totalCompra <- totalCompra + item.precoFimPara

Boas práticas: nome com “total”, “soma”, “saldo”; cuidado para não misturar tipos (ex.: somar texto).

3) Flags (sinalizadores booleanos)

Indicam se uma condição aconteceu ou se um estado está ativo. Guardam verdadeiro ou falso.

encontrouProduto <- falsoPara cada produto em catalogo    Se produto.codigo = codigoBuscado Então        encontrouProduto <- verdadeiro    FimSeFimPara

Boas práticas: nome que “soa” como pergunta respondida por sim/não (encontrouProduto, usuarioAutenticado), inicialização explícita.

Outras categorias úteis

• Índices/posições: indiceAtual, posicaoSelecionada.
• Temporárias: valores intermediários com papel claro, como precoComImposto (evite temp).
• Parâmetros de entrada: valores recebidos por uma rotina, como valorInicial, dataInicio.
• Resultados de saída: valores devolvidos, como mediaFinal, mensagemErro.

Tipos no pseudocódigo: declarar ou inferir sem amarrar a linguagens

Mesmo sem escolher uma linguagem, é útil indicar o tipo esperado para evitar interpretações erradas. No pseudocódigo essencial, você pode:

• Declarar o tipo quando isso aumenta a clareza (principalmente em entradas/saídas e variáveis críticas).
• Inferir o tipo quando o contexto e a atribuição deixam evidente.

Tipos mais comuns

Forma 1: declaração explícita (quando ajuda)

Use uma seção de declarações ou anotações junto da variável. O importante é ser consistente.

Variáveis:    quantidadeItens: inteiro    totalCompra: real    nomeCliente: texto    temDesconto: booleano    dataEntrega: data/hora

Quando declarar: quando há risco de confusão (ex.: codigo pode ser inteiro ou texto), quando o algoritmo depende de operações específicas (ex.: datas), ou quando há entradas/saídas documentadas.

Forma 2: inferência por atribuição (quando é óbvio)

contador <- 0precoUnitario <- 19.90nome <- "Carla"pagamentoAprovado <- falsodataAtual <- agora()

Cuidados: inferência pode ficar ambígua se você atribuir valores de naturezas diferentes em momentos distintos. Evite:

codigo <- 123codigo <- "123"  // ambíguo: afinal é inteiro ou texto?

Passo a passo: escolhendo tipo sem travar em linguagem

1. Liste as entradas e saídas do algoritmo e defina o tipo esperado para cada uma.
2. Para cada cálculo, identifique se precisa de inteiro ou real (ex.: média geralmente é real).
3. Para cada comparação, verifique se está comparando tipos compatíveis (texto com texto, data com data).
4. Para cada flag, force o tipo booleano (inicialize com falso ou verdadeiro).
5. Se houver dúvida, declare o tipo explicitamente para remover ambiguidade.

Escopo: onde a variável “existe” e pode ser usada

Escopo é a região do pseudocódigo em que uma variável é válida. No padrão essencial, pense em dois níveis simples:

• Global: acessível por várias rotinas/partes do algoritmo.
• Local: existe apenas dentro de uma rotina (procedimento/função) ou bloco específico.

Escopo local (preferido)

Variáveis locais reduzem dependências invisíveis, porque tudo que a rotina usa fica explícito nela (entradas, variáveis internas e saídas).

Função calcularTotal(itens): real    Variáveis:        total: real    total <- 0    Para cada item em itens        total <- total + item.preco    FimPara    Retornar totalFimFunção

A variável total é local: ninguém fora de calcularTotal consegue alterá-la diretamente.

Escopo global (use com cautela)

Variáveis globais podem ser úteis para configurações estáveis e compartilhadas, mas criam risco de “efeitos colaterais”: uma rotina altera algo que outra rotina depende, sem ficar evidente.

Variáveis globais:    taxaImposto: realProcedimento calcularPrecoFinal(precoBase: real): real    Retornar precoBase + (precoBase * taxaImposto)FimProcedimento

Boa prática: se taxaImposto for global, trate-a como configuração (definida uma vez, lida muitas vezes) e evite que várias rotinas a modifiquem.

Dependências invisíveis: o problema e como evitar

Uma dependência invisível acontece quando uma rotina depende de uma variável que não aparece nas suas entradas, nem é criada dentro dela.

Exemplo problemático (depende de global e ainda altera global):

Variáveis globais:    totalCompra: realProcedimento adicionarItem(preco: real)    totalCompra <- totalCompra + precoFimProcedimento

Quem chama adicionarItem precisa “saber” que totalCompra existe e já foi inicializada, senão o resultado pode ser incorreto.

Versão mais explícita (sem dependência invisível):

Função adicionarAoTotal(totalAtual: real, preco: real): real    Retornar totalAtual + precoFimFunção

Passo a passo: padronizando escopo no seu pseudocódigo

1. Comece assumindo tudo como local: declare dentro da rotina.
2. Transforme em parâmetro o que vem de fora (entradas).
3. Retorne o que precisa sair (saídas), em vez de escrever em global.
4. Use global apenas para constantes/configurações ou estados realmente compartilhados e controlados.
5. Nomeie globais de forma destacada (ex.: configTaxaImposto) para sinalizar que são especiais.

Exercícios práticos

1) Exercício de renomeação (clareza e intenção)

Reescreva os nomes abaixo para ficarem descritivos, sem abreviações obscuras, e coerentes com o papel (contador, acumulador, flag etc.).

Passo a passo sugerido:

1. Identifique a categoria (contador, acumulador, flag, índice, data/hora).
2. Escreva um nome que descreva o significado, não a forma.
3. Se for booleano, use forma afirmativa (tem..., esta..., foi...).
4. Se houver unidade (dias, segundos), inclua no nome.

2) Exercício: identificar variáveis necessárias vs. supérfluas

Analise o pseudocódigo e marque quais variáveis são necessárias e quais podem ser removidas sem perder clareza (ou podem ser substituídas por uma expressão direta).

Função calcularMediaAprovacao(nota1: real, nota2: real, nota3: real): texto    Variáveis:        soma: real        media: real        resultado: texto        limite: real        temp: real    limite <- 7.0    temp <- 0    soma <- nota1 + nota2 + nota3    media <- soma / 3    Se media >= limite Então        resultado <- "Aprovado"    Senão        resultado <- "Reprovado"    FimSe    Retornar resultadoFimFunção

• Quais variáveis podem ser eliminadas? Justifique.
• Quais nomes você renomearia para ficarem mais específicos?
• Você manteria limite como variável local, parâmetro de entrada, ou “configuração” global? Explique a escolha.

3) Exercício: escopo e dependências invisíveis

Reescreva para evitar dependência invisível de global.

Variáveis globais:    saldo: realProcedimento registrarCompra(valor: real)    saldo <- saldo - valorFimProcedimento

• Transforme em uma função que receba o saldo atual e retorne o novo saldo.
• Escolha nomes que indiquem claramente entrada e saída.