No JavaScript, a função da função é um objeto.
Não há sobrecarga de método em js
No JavaScript, não há sobrecarga de conceito de método (função).
exemplo:
A cópia do código é a seguinte:
<html>
<head>
<script type = "text/javascript">
função add (número)
{
alerta (número + 20);
}
função add (número, número1)
{
alerta (número + 30);
}
add (10);
</script>
</head>
<Body>
</body>
</html>
A caixa de bala na página da web mostra 40.
Explicação Embora o segundo método seja dois parâmetros, ele ainda é chamado.
Depois de trocar a ordem dos dois métodos, a caixa pop-up exibe 30. Pode-se ver que, independentemente do número de parâmetros, o seguinte método com o mesmo nome é chamado.
Como explicar esse fenômeno?
Isso ocorre porque a declaração de função realmente cria um objeto:
A cópia do código é a seguinte:
<html>
<head>
<script type = "text/javascript">
função add (número)
{
alerta (número + 20);
}
/*
A função acima é equivalente a:
var add = function (número)
{
alerta (número + 20);
}
*/
função add (número, número1)
{
alerta (número + 30);
}
/*
A função acima é equivalente a:
var add = function (número, número1)
{
alerta (número + 30);
}
*/
add (10);
</script>
</head>
<Body>
</body>
</html>
Dessa maneira, add, na verdade, aponta para o objeto subsequente, e os parâmetros atribuídos quando o método é chamado será atribuído aos parâmetros formais do método em ordem, e os parâmetros que não serão atribuídos posteriormente são indefinidos.
Ao chamar funções JavaScript, não há verificação estrita do número de parâmetros. Não há problema em ter o número real de parâmetros menores que o número de parâmetros formais. Os parâmetros formais que não são atribuídos são valores indefinidos.
Também é possível que o número de parâmetros reais seja maior que o número de parâmetros formais. Dessa forma, apenas os parâmetros reais anteriores serão usados e os parâmetros reais adicionais não serão usados.
Objeto de função
Existe um objeto de função no JavaScript e todas as funções personalizadas são do tipo de objeto de função.
Todos os parâmetros recebidos pelo objeto de função são do tipo String, o último parâmetro é o corpo da função a ser executado e o parâmetro anterior são os parâmetros que a função realmente precisa receber.
exemplo:
A cópia do código é a seguinte:
<html>
<head>
<script type = "text/javascript">
var add = new function ("número", "número1", "alert (número + número1);");
var add = new function ("número", "alerta (número + 20);");
add (10, 30);
</script>
</head>
<Body>
</body>
</html>
Argumentos de objetos implícitos
No JavaScript, cada função possui argumentos de objeto implícitos, representando os parâmetros realmente passados para a função.
Os argumentos não têm nada a ver com os parâmetros formais da função e seu número.
Os argumentos têm um comprimento de atributo útil, indicando o comprimento do parâmetro real. Você pode usar isso para simular a sobrecarga da função:
Exemplos de exercícios:
A cópia do código é a seguinte:
<html>
<head>
<script type = "text/javascript">
função add (número1, número2)
{
alerta (argumentos.length);
alerta (argumentos [0]);
alerta (argumentos [1]);
alerta (argumentos [2]);
}
// add (2, 3, 4);
função add2 ()
{
if (1 == argumentos.length)
{
alerta (argumentos [0]);
}
caso contrário, se (2 == argumentos.length)
{
alerta (argumentos [0] + argumentos [1]);
}
caso contrário, se (3 == argumentos.length)
{
alerta (argumentos [0] + argumentos [1] + argumentos [2]);
}
}
add2 (3);
add2 (3, 4);
add2 (3, 4, 5);
</script>
</head>
<Body>
</body>
</html>
Cada objeto de função possui um atributo de comprimento, indicando o formato do parâmetro que a função espera receber.
É diferente dos argumentos da função. Argumentos.Length Representa o número de parâmetros realmente recebidos pela função.
exemplo:
A cópia do código é a seguinte:
<html>
<head>
<script type = "text/javascript">
var add = function (num, num2, num3)
{
alerta (num + num2 + num3);
}
alerta (add.length); // Saída 3
adicione (1, 2, 3);
var add2 = function ()
{
}
alerta (add2.Length); // saída 0
</script>
</head>
<Body>
</body>
</html>