Que se passe-t-il si je ne passe pas de paramètre dans une fonction Javascript?

Je suis nouveau dans le monde de Javascript et je suis en train de bricoler avec l'écriture de fonctions très basiques et je suis tombé sur l'exemple ci-dessous par accident et je ne sais pas pourquoi cela fonctionne lorsque je ne passe pas un paramètre lorsque la fonction l'exige.

Exemple de fonction

function myfunction(x) {
    alert("This is a sample alert");
}

Maintenant, si j'appelle la fonction, on myfunction();me présente l'alerte. Pourquoi est-ce que je suis capable d'appeler la fonction sans aucune erreur ou avertissement alors que je n'ai pas passé de paramètre?

ÉDITER

Je ne m'attendais pas à autant de bonnes réponses et je ne suis en aucun cas en mesure de dire quelle réponse est la meilleure, je suis donc en mesure de demander aux gens de suggérer la meilleure réponse et je vais accorder l'acceptation à cette personne.

Rien ne se passera, ce qui signifie que vous n'obtiendrez pas d'erreur ou d'avertissement car la transmission des paramètres en javascript est facultative.
Tous les paramètres qui n'ont pas été "fournis" auront la undefinedvaleur .

function foo(x, y, z){
    //...
}

foo(1);

À l'intérieur de la foofonction maintenant:

function foo(x, y, z){
    x === 1
    y === undefined
    z === undefined
}

Vous pouvez même passer plus d'arguments, comme:

foo(1,2,3,4,5,7); // Valid!

Vous pouvez connaître les quantités de paramètres fournis par l' arguments.lengthintérieur de la fonction.

function foo(x, y, z) {
    console.log('x value: ' + x);
    console.log('y value: ' + y);
    console.log('z value: ' + z);
    console.log('Arguments length: ' + arguments.length);
}
console.log('Zero parameters');
foo();
console.log('Four parameters');
foo(1, 2, 3, 4);

Exemple de fonction utile qui gère n'importe quelle quantité de paramètres:

function max() {
    var maxValue = arguments[0];
    for (var i = 1; i < arguments.length; i++) {
        if (maxValue < arguments[i]) {
            maxValue = arguments[i];
        }
    }
    return maxValue;
}

alert(max(1, 5, 7, 2, 88, 32, 44));

Tous les arguments des fonctions JavaScript sont facultatifs (lisez «typé de manière lâche»).

Les fonctions JavaScript peuvent être appelées avec n'importe quel nombre d'arguments, quel que soit le nombre d'arguments nommés dans la définition de fonction. Comme une fonction est mal typée, il n'y a aucun moyen pour elle de déclarer le type d'arguments qu'elle attend, et il est légal de passer des valeurs de n'importe quel type à n'importe quelle fonction. Lorsqu'une fonction est appelée avec moins d'arguments que ceux déclarés, les arguments supplémentaires ont la valeur non définie.

Vous pouvez faire référence aux arguments d'une fonction dans la fonction en utilisant les variables d'argument nommé ou l'objet arguments. Cet objet contient une entrée pour chaque argument passé à la fonction, l'index de la première entrée commençant à 0. Par exemple, si une fonction reçoit trois arguments, vous pouvez faire référence à l'argument comme suit:

arguments[0]
arguments[1]
arguments[2]

• JavaScript - Le guide définitif, 5e édition

C'est ainsi que fonctionne JavaScript. Les paramètres sont facultatifs et auront la valeur pas vraiment une valeur "indéfinie" dans la fonction s'ils sont absents d'un appel de fonction.

Par «facultatif», je veux simplement dire cela: invoquer une fonction implique une liste arbitrairement longue de paramètres. Il n'y a pas besoin de relation entre le nombre de paramètres passés à une fonction et le nombre déclaré . La meilleure façon de penser à cette déclaration, alors:

function x(a, b, c) {
  // ...
}

est que vous déclarez une fonction et que vous liez le nom "a" au premier paramètre, "b" au second et "c" au troisième. Il est nullement garanti, cependant, que l' un de ceux qui seront effectivement être lié à une valeur dans une invocation donnée de la fonction plus tard.

De la même manière, vous pouvez définir une fonction sans aucun paramètre, puis les "trouver" via l' argumentsobjet:

function noArgs() {
  var a = arguments[0], b = arguments[1], c = arguments[2];
  // ...
}

Ce n'est donc pas tout à fait la même chose que la première fonction, mais c'est proche de la plupart des façons qui comptent pratiquement.

La valeur "indéfinie" en JavaScript est une valeur, mais sa sémantique est plutôt inhabituelle dans les langages. En particulier, ce n'est pas exactement la même que la nullvaleur. De plus, "indéfini" n'est pas en soi un mot clé; c'est juste un nom de variable semi-spécial!

JavaScript n'a pas de valeurs par défaut pour les paramètres de fonction comme le font d'autres langages. Ainsi, vous pouvez transmettre autant ou aussi peu d'arguments que vous le souhaitez.

Si vous ne transmettez pas de valeur, le paramètre est undefined.

function myfunction(x) {
    alert(x);
}

myfunction(); // alerts undefined
myfunction(1); // alerts 1
myfunction(1,2,3); // alerts 1

Si vous transmettez plus de paramètres que dans la signature, vous pouvez utiliser arguments.

function myfunction(x) {
    alert(x);
    console.log(arguments);
}

myfunction(1,2,3); // alerts 1, logs [1,2,3]

Vous pouvez également fournir plus d'arguments que celui mentionné dans la fonction

myFunction(1,2,3,4,5,6,7,'etc');

Vous pouvez utiliser la argumentspropriété qui est un tableau afin de visualiser les arguments fournis.

Parce qu'il n'y a pas d'erreur tant que la fonction ne s'attend pas à pouvoir travailler avec le paramètre que vous êtes censé transmettre.

Par exemple:

function myfunction(x) {
    return x*2;
}

Jetterait une erreur; bien que probablement seulement un NaN(dans ce cas) ou un variable is undefined.

Si vous omettez l'argument, sa valeur sera undefined. Cela vous permet de créer des paramètres facultatifs assez facilement.

Une autre fonctionnalité est la possibilité de définir une fonction sans paramètres et de l'appeler avec des arguments avec succès, en utilisant l' argumentsobjet. Cela vous permet de créer facilement des tableaux d'arguments de longueur variable.

En javascript console.log à l'intérieur d'une fonction donne undefined comme sortie pour les paramètres non passés mais en dehors de la fonction, il donne une erreur non définie car à l'intérieur d'une fonction, les navigateurs déclarent explicitement la variable. Pour par exemple

console.log(x) 

donne VM1533: 1 Uncaught ReferenceError: x n'est pas défini alors que

function test(x) {
console.log(x)
}
test(); 

donne undefined. C'est parce que la fonction test () est réécrite par le navigateur comme:

function test(x) {
    var x;
    console.log(x)
    }

Un autre exemple : -

var x =5 ;
function test(x) {
console.log(x)
}
test(); 

est toujours indéfinie lorsque la fonction devient

function test(x) {
    var x;
    console.log(x)
    }

L'alerte dans l'exemple ci-dessous donnera undefined: -

    var x =5;
    function test() {
    alert(x);
    var x =10;
    }

test(); 

La fonction ci-dessus deviendra: -

 function test() {
    var x;
    alert(x);
    x =10;
    }

La portée de la variable javascript à l'intérieur d'une fonction est la portée au niveau de la fonction et non au niveau du bloc. Pour par exemple

function varScope() {

for(var i = 0; i < 10; i++){
    for(var j = 0; j < 5; j++){}
        console.log("j is "+j)
    }
    console.log("i is "+i);


}
varScope();

donnera la sortie comme:

j is 5 
i is 10

Encore une fois, la fonction est devenue comme: -

  function varScope() {
    var i;
    var j;
    for(i = 0; i < 10; i++){
        for(j = 0; j < 5; j++){}
            console.log("j is "+j)
        }
        console.log("i is "+i);
    }