Funções em JavaScript
Funções são um conjunto de instruções que podem ser chamadas repetidamente em diferentes partes do programa pelo nome da função. Em geral, a sintaxe para definir uma função é a seguinte:
function nomeDaFuncao(parametros) {
// Instruções
}
A definição de uma função começa com a palavra-chave function
, seguida pelo nome da função. O nome da função segue as mesmas regras que o nome de uma variável: pode conter apenas dígitos, letras, sublinhados e o cifrão $
e deve começar com uma letra, um sublinhado ou um cifrão.
Após o nome da função, os parâmetros são listados entre parênteses. Mesmo se a função não tiver parâmetros, ainda assim aparecerão parênteses vazios. Em seguida, o corpo da função é delimitado por chaves, contendo um conjunto de instruções.
Vamos definir a função mais simples:
function hello() {
console.log("Hello www.programicio.com");
}
Esta função é chamada hello()
. Ela não aceita nenhum parâmetro e tudo o que faz é imprimir a string "Hello www.programicio.com"
no console do navegador.
Para que a função execute seu trabalho, precisamos chamá-la. A sintaxe geral para chamar uma função é:
nomeDaFuncao(parametros);
Quando chamada, após o nome da função especificada, uma lista de parâmetros é colocada entre parênteses. Se a função não tiver parâmetros, então parênteses vazios são usados.
Por exemplo, vamos definir e chamar a função mais simples:
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8" />
<title>Programício</title>
</head>
<body>
<script>
// definição da função
function hello() {
console.log("Hello www.programicio.com");
}
// chamada da função
hello();
</script>
</body>
</html>
Neste caso, a função hello não aceita parâmetros, portanto, ao chamá-la, parênteses vazios são usados:
hello();
Uma característica distintiva das funções é que elas podem ser chamadas repetidamente em diferentes locais do programa:
// definição da função
function hello() {
console.log("Hello www.programicio.com");
}
// chamada da função
hello();
hello();
hello();
Variáveis e Constantes como Funções
Assim como valores simples (números, strings etc.) são atribuídos a constantes e variáveis, funções também podem ser atribuídas a elas. Em seguida, através dessa variável ou constante, você pode chamar a função atribuída:
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8" />
<title>Programício</title>
</head>
<body>
<script>
// definição da função
function hello() {
console.log("Hello from www.programicio.com");
}
// passando a referência da função hello para a constante message
const message = hello;
message(); // chamamos a função cuja referência está armazenada na constante message
</script>
</body>
</html>
Ao atribuir uma função a uma constante ou variável:
const message = hello;
Então podemos chamar essa função pelo nome da constante/variável:
message();
Também podemos mudar dinamicamente as funções armazenadas em uma variável:
function goodMorning() {
console.log("Bom dia");
}
function goodEvening() {
console.log("Boa noite");
}
let message = goodMorning; // atribuímos a função goodMorning à variável message
message(); // Bom dia
message = goodEvening; // mudamos a função na variável message
message(); // Boa noite
Funções-Expressão e Funções Anônimas
Não é necessário dar um nome específico às funções. Você pode usar funções anônimas. Essas funções, ao serem definidas, são atribuídas a uma constante ou variável. Essas funções também são chamadas de funções-expressão (function expression):
const message = function () {
console.log("Hello JavaScript");
};
message();
Usando o nome da constante ou variável à qual a função foi atribuída, você pode chamar essa função.
Funções Locais
JavaScript permite a definição de funções locais - funções dentro de outras funções. Funções locais só são visíveis dentro da função externa em que são definidas. Por exemplo:
function print() {
printHello();
printHello();
printHello();
function printHello() {
console.log("Hello");
}
}
print();
printHello(); // Uncaught ReferenceError: printHello is not defined - a função local só pode ser chamada de sua função circundante
Aqui, dentro da função print
, uma função local printHello
é definida, que simplesmente imprime a string "Hello". Dentro da função print
, podemos chamar a função local printHello
, mas fora da função circundante, não é possível chamar a função local.
Este exemplo é bastante simples e não tem grande significado. No entanto, geralmente, funções locais são definidas para ações que são aplicadas repetidamente apenas dentro de uma função específica e em nenhum outro lugar. Uma desvantagem das funções locais é que elas são criadas cada vez que a função externa é chamada.