Procedimentos (ou Funções sem retorno - Parte 1)
Tags: javascript, algorithms
Published: 2021-09-14 16:30:46

## Definição

Procedimento é uma função com um determinado número de etapas, que pode ser usada mais de uma vez. Essa função é escrita uma única vez. Sempre que precisar de um procedimento, é só fazer uma chamada. A estrutura de um procedimento é a seguinte:

```javascript
function nomeDoProcedimento (parametro1, parametro2) {
	// Bloco de código
}

nomeDoProcedimento()
```

Um conceito muito importante dos procedimentos é a passagem de parâmetros. Existem dois tipos de passagens de parâmetro: por valor e por referência.

## Passagem de Parâmetro por Valor

Para ver como a passagem de parâmetro por valor funciona, vamos ver um exemplo. Vou criar uma função (procedimento) para verificar se um determinado número digitado pelo usuário é par ou ímpar.

```javascript
function parOuImpar(valor) {
	console.log(`Recebendo o número ${valor}`);
  
	if (valor % 2 === 0) {
  	console.log(`O número digitado ${valor} é par.`);
     } else {
  	console.log(`O número digitado ${valor} é ímpar.`);
     }
}
```

Criei uma função chamada `parOuImpar` com um parâmetro chamado `valor`. Dentro da função coloquei a lógica para verificar se um número é par ou ímpar e um `console.log()` para mostrar qual valor foi recebido pela função. Agora vou criar uma variável fora dessa função para guardar o número inteiro digitado pelo usuário.

```javascript
const valorQualquer = Number(prompt("Digite um número inteiro qualquer"));
```

Depois dessa variável, vou chamar a função `parOuImpar()`:

```javascript
const valorQualquer = Number(prompt("Digite um número inteiro qualquer"));

parOuImpar(valorQualquer);
```

Vamos imaginar que o número digitado foi 5. Veja como o resultado aparece no console:

```javascript
// Recebendo o número 5
// O número digitado 5 é ímpar
```

O número 5 da variável `valorQualquer` foi recebido pelo parâmetro valor da função `parOuImpar()`. A lógica foi executada e verificou que 5 é um número ímpar.

Vamos ver mais um exemplo?! Uma função para a soma de dois números inteiros.

```javascript
function soma(a, b) {
  console.log(`Recebendo o valor ${a}`);
  console.log(`Recebendo o valor ${b}`);
  let somaDosValores = a + b;
  console.log(`Resultado da soma: ${somaDosValores}`);
}
```

O mesmo mecanismo da função anterior. Criei uma função chamada soma com dois parâmetros, chamados `a` e `b`. Dentro da função coloquei uma variável para fazer a soma e `console.log()` para mostrar quais números foram recebidos pela função. Agora vou criar duas variáveis fora dessa função para guardar os números inteiros digitados pelo usuário.

```javascript
const valor1 = Number(prompt("Digite o primeiro valor inteiro"));
const valor2 = Number(prompt("Digite o segundo valor inteiro"));
```

Depois dessas variáveis, vou chamar a função `soma()`:

```javascript
const valor1 = Number(prompt("Digite o primeiro valor inteiro"));
const valor2 = Number(prompt("Digite o segundo valor inteiro"));
soma(valor1, valor2);
```

Os números digitados foram 20 e 400. Veja como o resultado aparece no console:

```javascript
// Recebendo o valor 20
// Recebendo o valor 400
// Resultado da soma: 420
```

Os números que estão guardados nas variáveis `valor1` e `valor2` foram recebidos pelos parâmetros `a` e `b` da função `soma()`. Porém, podemos ver que tem uma variável dentro dessa função:

```javascript
let somaDosValores = a + b;
```

O que essa variável está fazendo dentro da função `soma()`?! A resposta nos leva ao...

## Escopo

O que é escopo?! É o local onde uma determinada variável vai funcionar. Existem dois tipos de escopo: escopo global e escopo local.

### O que é variável de escopo global?!

É uma variável que funcionará em qualquer parte do código.

### O que é variável de escopo local?!

É uma variável que funcionará em um bloco de código específico.

### Mais um exemplo:

Vejamos o seguinte código:

```javascript
const num1 = Number(prompt("Digite um número inteiro qualquer"));
const num2 = Number(prompt("Digite um número inteiro qualquer"));

function rotina(a, b) {
	let x = a;
    let y = b;
    console.log(num1, num2, a, b, x, y);
}

const val1 = num1;
const val2 = num2;
rotina(val1, val2);
console.log(num1);
console.log(num2);
console.log(a);
console.log(b);
console.log(x);
console.log(y);
```

Vamos ver o passo a passo:

* Foram criadas duas variáveis chamadas `num1` e `num2`, que receberão números inteiros.
* Dentro da função `rotina()`, foram criadas duas variáveis chamadas `x` e `y`, que também receberão números inteiros. Além disso, a função `rotina()` tem dois parâmetros, `a` e `b`.
* A variável `num1` vai receber o número 5 e a variável `num2` vai receber o número 9. A partir daí a função `rotina()` é chamada, passando as variáveis `num1` e `num2` como parâmetros.
* As variáveis `num1` e `num2` funcionarão por todo o código, porque são variáveis de escopo global.
* A função `rotina()` é um escopo local, no qual funcionarão as variáveis `x` e `y` e os parâmetros `a` e `b`. Essas variáveis e parâmetros funcionam apenas dentro dessa função porque são de escopo local, o que significa que não vão funcionar fora da função `rotina()`, apenas as variáveis `num1` e `num2`.

## Passagem de Parâmetro por Referência

O funcionamento da passagem de parâmetro por referência é um pouco diferente do da passagem de parâmetro por valor. Vamos ver um exemplo.

```javascript
function soma(a, b) {
	console.log(a++);
    console.log(b++);
    console.log(`Valor da soma: ${a + b}`);
}

const x = Number(prompt("Digite o primeiro valor"));
const y = Number(prompt("Digite o segundo valor"));

soma(x, y);
```

Vamos ver o passo a passo:

* Foi criada uma função chamada `soma()` (falta de originalidade!!! 🤦🏾‍♀️) que tem dois parâmetros, `a` e `b`.
* Dentro da função, o parâmetro `a` receberá o valor e somará 1 (para entender melhor: `a++` é o mesmo que `a + 1`) e o parâmetro `b` receberá o valor e somará 1 também (`b++` é o mesmo que `b + 1`).
* No código principal, vamos criar duas variáveis chamadas `x` e `y` que serão de escopo global e receberão números inteiros.
* Digamos que o usuário digite 4 para a variável `x` e 5 para a variável `y`. Ao chamar a função `soma()`, a referência da variável `x` é passada para o parâmetro `a` e a referência da variável `y` é passada para o parâmetro `b`.
* `x`, que é referência de `a`, receberá `a++` (`a + 1`), ou seja:

```javascript
x = 4 + 1;
x = 5;
```

* `y`, que é referência de `b`, receberá `b++` (`b + 1`), ou seja:

```javascript
y = 5 + 1;
y = 6;
```

O resultado da soma inserida na função `soma()` será 11 em vez de 9.

E aí? Gostaram? Até a próxima anotação? 😊