Uma função JavaScript não executa nenhuma verificação valores de parâmetros (argumentos).
Anteriormente neste tutorial, você aprendeu que funções podem ter parâmetros:
function functionName(parameter1, parameter2, parameter3) {
// code to be executed
}Os parâmetros de função são os nomes listados em a definição da função.
Os argumentos da função são os valores reais passado para (e recebido por) a função.
As definições de função JavaScript não especificam tipos de dados para parâmetros.
Funções JavaScript não realizam verificação de tipo no passado argumentos.
As funções JavaScript não verificam o número de argumentos recebidos.
Se uma função for chamada com argumentos faltantes (menos que o declarado), os valores faltantes serão definidos como indefinido.
Às vezes isso é aceitável, mas às vezes é melhor atribuir um padrão valor para o parâmetro:
function myFunction(x, y) {
if (y === undefined) {
y = 2;
}
}Experimente você mesmo →
<!DOCTYPE html>
<html>
<body>
<p>Setting a default value to a function parameter.</p>
<p id="demo"></p>
<script>
function myFunction(x, y) {
if (y === undefined) {
y = 2;
}
return x * y;
}
document.getElementById("demo").innerHTML = myFunction(4);
</script>
</body>
</html>
ES6 permite que os parâmetros de função tenham valores padrão.
Se y não for aprovado ou indefinido, então y=10.
function myFunction(x, y = 10) { return x + y;
}
myFunction(5);Experimente você mesmo →
<!DOCTYPE html>
<html>
<body>
<h1>JavaScript Functions</h1>
<h2>Default Parameter Values</h2>
<p>If y is not passed or undefined, then y = 10:</p>
<p id="demo"></p>
<script>
function myFunction(x, y = 10) {
return x + y;
}
document.getElementById("demo").innerHTML = myFunction(5);
</script>
</body>
</html>
O parâmetro rest (...) permite que uma função trate um número indefinido de argumentos como um array:
function sum(...args) {
let sum = 0;
for (let arg of args) sum += arg;
return sum;
}
let x = sum(4, 9, 16, 25, 29, 100, 66, 77);Experimente você mesmo →
<!DOCTYPE html>
<html>
<body>
<h1>JavaScript Functions</h1>
<h2>The Rest Parameter</h2>
<p>The rest parameter (...) allows a function to treat an indefinite number of arguments as an array:</p>
<p id="demo"></p>
<script>
function sum(...args) {
let sum = 0;
for (let arg of args) sum += arg;
return sum;
}
let x = sum(4, 9, 16, 25, 29, 100, 66, 77);
document.getElementById("demo").innerHTML = x;
</script>
</body>
</html>
As funções JavaScript têm um objeto integrado chamado argumentos objeto.
O objeto de argumento contém uma matriz dos argumentos usados quando a função foi chamado (invocado).
Desta forma, você pode simplesmente usar uma função para encontrar (por exemplo) o valor mais alto valor em uma lista de números:
x = findMax(1, 123, 500, 115, 44, 88);
function findMax() {
let max = -Infinity;
for (let i = 0; i < arguments.length; i++) {
if (arguments[i] > max) {
max = arguments[i];
}
}
return max;
}Experimente você mesmo →
<!DOCTYPE html>
<html>
<body>
<h2>JavaScript Functions</h2>
<p>Finding the largest number.</p>
<p id="demo"></p>
<script>
function findMax() {
let max = -Infinity;
for(let i = 0; i < arguments.length; i++) {
if (arguments[i] > max) {
max = arguments[i];
}
}
return max;
}
document.getElementById("demo").innerHTML = findMax(4, 5, 6);
</script>
</body>
</html>
Ou crie uma função para somar todos os valores de entrada:
x = sumAll(1, 123, 500, 115, 44, 88);
function sumAll() {
let sum = 0;
for (let i = 0; i < arguments.length; i++) {
sum += arguments[i];
}
return sum;
}Experimente você mesmo →
<!DOCTYPE html>
<html>
<body>
<h2>JavaScript Functions</h2>
<p>Sum of all arguments:</p>
<p id="demo"></p>
<script>
function sumAll() {
let sum = 0;
for(let i = 0; i < arguments.length; i++) {
sum += arguments[i];
}
return sum;
}
document.getElementById("demo").innerHTML = sumAll(1, 123, 500, 115, 44, 88);
</script>
</body>
</html>
Se uma função for chamada com muitos argumentos (mais do que o declarado), esses argumentos podem ser alcançados usando o objeto de argumentos.
Os parâmetros, em uma chamada de função, são os argumentos da função.
Argumentos JavaScript são passados por valor: somente a função conhece os valores, não a localização do argumento.
Se uma função altera o valor de um argumento, ela não altera o valor do parâmetro valor original.
As alterações nos argumentos não são visíveis (refletidas) fora da função.
Em JavaScript, as referências de objetos são valores.
Por causa disso, os objetos se comportarão como se fossem passados por referência:
Se uma função altera a propriedade de um objeto, ela altera o valor original.
As alterações nas propriedades do objeto são visíveis (refletidas) fora da função.