Documentação | Linguagem Égua

# Fluxo de Controle

A programação envolve o controle de fluxo, que determina a ordem em que as instruções são executadas em um programa. A linguagem de programação égua oferece uma variedade de opções de controle de fluxo que permitem tomar decisões, repetir a execução de blocos de código e lidar com erros.

# Valores booleanos

No controle de fluxo de todas as linguagens de programação, os valores booleanos desempenham um papel importante. Em égua, os valores booleanos são representados pelos termos "verdadeiro" e "falso". O controle de fluxo, como a instrução se, será executado somente se a condição for avaliada como verdadeira. Por exemplo, se(verdadeiro){} será executado porque a condição é verdadeira, enquanto se(falso){} não será executado porque a condição é falsa.

# Comparação de igualdade

Para comparar se dois objetos são iguais em Egua, é necessário que sejam do mesmo tipo e tenham o mesmo valor. Essa comparação é avaliada como "verdadeira" se os valores forem iguais, e "falsa" caso contrário. Veja alguns exemplos:

1 == 1; // Verdadeiro
"1" == "1"; // Verdadeiro
nulo == nulo; // Verdadeiro

"1" == "2"; // Falso
1 == 2; // Falso
1 == "1"; // Falso

A comparação é baseada apenas na igualdade dos valores.

# Avaliação da veracidade

Em égua, todos os tipos de dados, exceto "nulo" e "falso", são avaliados como verdadeiros. Veja alguns exemplos:

{}; // Verdadeiro
1; // Verdadeiro
verdadeiro; // Verdadeiro
[]; // Verdadeiro

1 == '1'; // Falso devido à avaliação de falso
nulo; // Falso
falso; // Falso

# Palavras-chave de controle

A linguagem égua possui várias palavras-chave que auxiliam no controle de fluxo:

  • e - Retorna verdadeiro se ambos os valores forem verdadeiros.
  • ou - Retorna verdadeiro se pelo menos um dos valores for verdadeiro.
  • em - Retorna verdadeiro se o valor da esquerda estiver contido no valor da direita.
verdadeiro e verdadeiro; // Verdadeiro
verdadeiro e falso; // Falso

falso ou falso; // Falso
verdadeiro ou falso; // Verdadeiro

'a' em ['b']; // Falso
'b' em ['b']; // Verdadeiro
'c' em 'abc'; // Verdadeiro
'chave' em {'chave': 'valor'};

# Se - Senão se - Senão

A linguagem Egua fornece as instruções se, senão se e senão para controle de fluxo condicional eficiente. As instruções senão se e senão são opcionais e devem ser anexadas à instrução se. Você pode ter apenas uma instrução senão se adicional. Cada instrução é seguida por um bloco de código que será executado com base na condição da instrução. O bloco de código de uma instrução se é executado se a condição for avaliada como verdadeira. Caso contrário, as instruções senão se serão avaliadas em ordem, e se qualquer uma das condições for verdadeira, o bloco de código correspondente será executado. Somente um bloco senão se pode ser executado. Se a instrução se não for executada e nenhuma instrução senão se for executada, o bloco senão será executado, se fornecido.

// Exemplo: Imprime "sim"
se (verdadeiro) {
  escreva('sim');
}

// Exemplo: Imprime "correspondente 2"
var a = 2;
se (a == 1) {
  escreva('correspondente 1');
} senão se (a == 2) {
  escreva('correspondente 2');
} senão {
  escreva('sem valor correspondente');
}

// Exemplo: Imprime "sem comparação"
var a = 3;
se (a == 1) {
  escreva('correspondente 1');
} senão se (a == 2) {
  escreva('correspondente 2');
} senão {
  escreva('Sem valor correspondente');
}

# Enquanto

A instrução enquanto em Egua é usada para criar um loop que executa repetidamente um bloco de código enquanto uma condição específica for avaliada como verdadeira. Antes de cada execução do bloco de código, a condição é verificada para determinar se o bloco deve continuar a ser executado. Se a condição for falsa no início, o bloco nunca será executado.

// Exemplo: Loop infinito
enquanto (verdadeiro) {
  escreva("sim");
}

# Para

A instrução para é usada para criar um laço que executa um bloco de código um número específico de vezes. Ela possui quatro partes: um inicializador, uma condição, um passo e um corpo. Qualquer uma dessas partes pode ser deixada em branco. O inicializador é executado antes do laço para, a condição decide se o corpo deve ser executado, a passo é executada após cada execução do corpo e o corpo contém as instruções a serem repetidas. A instrução para é definida com o inicializador, a condição e a passo separados por ponto e vírgula, seguidos pelo bloco de código do corpo.

// Exemplo: Imprime números de 0 a 4
// Inicializador, condição, passo
para (var i = 0; i < 5; i = i + 1) {
  // Corpo
  escreva(i);
}

// Exemplo: Inicializador e passo omitidos
// Imprime infinitamente porque a condição é sempre verdadeira
para (; verdadeiro; ) {
  escreva("sim");
}

# Faça - Enquanto

A instrução faça - enquanto é usada para criar um laço que executa um bloco de código pelo menos uma vez e continua a executá-lo enquanto uma condição específica for avaliada como verdadeira. Primeiro, o bloco de código é executado e, em seguida, a condição é verificada. Se a condição for verdadeira, o bloco de código será executado novamente. Se a condição for falsa, o loop será encerrado.

// Exemplo: "sim" é escrito uma vez
faça {
  escreva("sim");
} enquanto (falso);

// Exemplo: Imprime números de 0 a 4
var i = 0;
faça {
  escreva(i);
  i = i + 1;
} enquanto (i < 5);

# Escolha - Caso

As instruções escolha e caso são usadas para encadear várias condições e executar diferentes blocos de código com base em uma expressão de seleção. A expressão de seleção é avaliada e comparada aos valores de cada caso. Se houver uma correspondência, o bloco de código correspondente ao caso será executado. Se nenhum caso corresponder, o bloco de código padrão será executado, se fornecido.

// Exemplo: Imprime "correspondente à opção 2"
escolha (1) {
  caso "1":
    escreva("correspondente à opção 1");

  caso 1:
    escreva("correspondente à opção 2");

  padrão:
    escreva("Sem opção correspondente");
}

// Exemplo: Imprime "Sem opção correspondente"
escolha (2) {
  caso "1":
    escreva("correspondente à opção 1");

  caso 1:
    escreva("correspondente à opção 2");

  padrão:
    escreva("Sem opção correspondente");
}

# Tente - Pegue - Finalmente

A estrutura tente - pegue - finalmente é usada para lidar com exceções ou erros que podem ocorrer durante a execução do código. O bloco pegue e o bloco finalmente são opcionais. Primeiro, o bloco tente é executado e, se ocorrer algum erro durante a execução, ele será capturado e o bloco pegue será executado. O bloco tente garante que os erros não interrompam o programa. Após a tentativa e, se fornecido, a execução do bloco pegue, o bloco finalmente é executado.

// Exemplo: Imprime "sucesso" e "pronto"
tente {
  escreva("sucesso");
} pegue {
  escreva("pegue");
} finalmente {
  escreva("pronto");
}

// Exemplo: Imprime "captura" e "pronto"
tente {
  // Lança um erro
  1 > "1";

  escreva("sucesso");
} pegue {
  escreva("captura");
} finalmente {
  escreva("pronto");
}

Essas são as principais instruções de controle de fluxo em Egua. Com o entendimento dessas instruções, você pode criar programas mais complexos e controlar o fluxo de execução de maneira eficiente.

← Funções →