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

88

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.

ArachidesMonkey
la source
2
Pourrait également être utile: developer.mozilla.org/en/JavaScript/Guide/Functions
Felix Kling
1
Il n'y a pas de surcharge basée sur les signatures de fonction dans JS, donc il ne se soucie pas vraiment du nombre de paramètres que la fonction "attend". Vous pouvez même passer des paramètres que la fonction n'est pas définie pour prendre et utiliser simplement les arguments de mot-clé pour les récupérer.
scrappedcola
@scrappedcola - Qu'entendez-vous par surcharge et par transmission de paramètres que la fonction n'est pas définie pour prendre? Pouvez-vous donner des exemples?
PeanutsMonkey
2
@PeanutsMonkey. Il voulait dire, vous ne pouvez pas avoir deux fonctions: function foo(x){...}et function foo(x,y,z){...}vous ne pouvez avoir qu'une seule fonction pour chaque nom.
gdoron soutient Monica le
2
@PeanutsMonkey. Oui, vous ne pouvez pas avoir function overloadingdans js, vous avez d'autres moyens de vous en moquer.
gdoron soutient Monica le

Réponses:

111

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));

gdoron soutient Monica
la source
Merci pour la démo en direct. Je ne m'attendais pas à tant de bonnes réponses. Donc, si j'ai une fonction telle que function myfunction (a,b){}et que j'ai passé les valeurs myfunction (1,2,3,4,5), je suppose qu'elle est toujours valide? Est-ce que l'on s'attend à ce qu'il y ait un avertissement ou une erreur?
PeanutsMonkey
Pardon, pourriez-vous préciser ce que fait la commande console.logainsi que arguments.length?
PeanutsMonkey
@PeanutsMonkey. Valide! pas d'avertissement pas d'erreur, ce sera même utile, je vais vous donner une démo dans un instant
gdoron soutient Monica le
1
@PeanutsMonkey. Cela fonctionne également avec IE si la console des développeurs est installée, je pense qu'elle est installée par défaut à partir d'IE8 +. Je n'ai pas compris ce que vous avez écrit alert.
gdoron soutient Monica le
1
@PeanutsMonkey. 1. Vous ne pouvez pas avoir de code après returnl'avoir ignoré. 2. vous n'obtiendrez pas d'erreurs ou d'avertissements. Voir cette DEMO
gdoron soutient Monica le
9

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
j08691
la source
7

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!

Pointu
la source
Pourriez-vous préciser davantage ce que vous entendez par optionalainsi que la valeur «pas vraiment une valeur» undefined?
PeanutsMonkey
@PeanutsMonkey - Si la variable n'est pas donnée, elle le sera undefined.
Derek 朕 會 功夫
@Pointy - Qu'entendez-vous par il n'y a aucune garantie que l'un des paramètres déclarés sera réellement lié à une valeur?
PeanutsMonkey
1
@PeanutsMonkey JavaScript est un langage dynamique . Lors de l' appel d' une fonction, la déclaration de la fonction n'est pas importante, y compris le nombre de paramètres. Ainsi, vous pouvez déclarer une fonction avec autant de paramètres que vous le souhaitez, mais cela n'impose aucune restriction sur le nombre de paramètres réellement transmis lorsque votre fonction est appelée. (De cette façon, c'est un peu comme C, au moins C dans l'ancien temps.) Ainsi, si vous déclarez un paramètre et qu'un appel est effectué sans aucune valeur de paramètre fournie, le paramètre sera undefined.
Pointy
3

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]
Fusée Hazmat
la source
Merci. Plutôt que de publier des messages croisés, pouvez-vous voir mon exemple que j'ai fourni à David Thomas car j'obtiens toujours l'erreurundefined
PeanutsMonkey
@PeanutsMonkey: Hein? Quel est votre problème?
Rocket Hazmat
Pas un problème en soi. Je faisais référence à ma question complémentaire à David concernant la transmission d'autres paramètres que vous avez inclus dans votre réponse. Ce que je ne comprends pas tout à fait, c'est ce que vous entendez par logs? Où le consigne-t-il?
PeanutsMonkey
1
@PeanutsMonkey: Il le connecte à votre "console JavaScript". Dans la plupart des navigateurs, vous pouvez appuyer sur F12ou Ctrl+Shift+Jpour y accéder.
Rocket Hazmat
1
La première phrase est obsolète à compter de l' ES2015 ...
Heretic Monkey
2

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.

AlbertVanHalen
la source
@albert arguments n'est pas un tableau de son tableau comme l'objet voir
Mahi
1

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.

David dit de réintégrer Monica
la source
D'accord, tant que je ne référence pas le paramètre dans la fonction, je n'obtiendrai pas d'erreur? Est-ce correct?
PeanutsMonkey
Maintenant, si j'élabore sur l'exemple que vous fournissez, c'est-à function myfunction(a,b) { var calc = a+b; return;}- dire , puis j'appelle la fonction, document.write(myfunction(1.2));pourquoi est-ce que j'obtiens toujours la valeur de undefinedmême si je passe un paramètre?
PeanutsMonkey
1
Parce que vous ne retournez rien. Vous devez explicitement, dans votre exemple, renvoyer une valeur: soit return calc; ou return a+b;(comme dernière ligne, évidemment; et cette dernière returnà la place de var calc).
David dit de réintégrer Monica le
Vous voulez dire que je n'ai pas à déclarer une variable si je le fais return a+b;?
PeanutsMonkey
@PeanutsMonkey - Vous pouvez en savoir plus return ici .
Derek 朕 會 功夫
0

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.

Kendall Frey
la source
0

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);
    }
Goyal Vicky
la source