En JavaScript, cela fait-il une différence si je l'appelle une fonction avec des parenthèses?

Ce Pekka dit est correct, mais je veux dire un peu avec un exemple qui vous permettra d'expliquer à quelqu'un qui ne veut pas comprendre pleinement les pointeurs de fonction ou de délégués.

Je ne les utilise pas window.onload parce que c'est un peu artificiel à démontrer. Je vais utiliser un simple multiplier la fonction de démonstration à la place:

function Multiply(operator, operand) {
    return operator * operand;
}

Il pourrait tout aussi bien être écrit:

Multiply = function(operator, operand) {
    return operator * operand;
}

Alors que dans le premier exemple, l'implication ne peut pas être évident, le second exemple montre plus clairement que nous sommes en affectant une fonction qui a 2 paramètres à une variable appelée Multiply, et ce concept de fonctions que des affectations est commun à l'ensemble de JavaScript. C'est une petite démonstration du fait que les fonctions sont "première classe des citoyens", c'est qu'ils peuvent être passés exactement comme si nous étions de passage autour de valeurs.

Alors maintenant, à la différence de l'affectation:

var operator = 3;
var operand = 4;
var ret = Multiply(operator, operand);

Au point de la définition de la variable ret, Multiply est exécuté et la valeur de retour est assignée - ret devient égal à 12.

Essayons encore une fois de façon différente:

var operator = 3;
var operand = 4;
var ret = Multiply;

Maintenant, au point de définir ret, ret devient votre Multiply fonction plutôt que le résultat obtenu à partir de votre Multiply fonction. Les appels à ret() sera la cause de votre Multiply de la fonction à exécuter, et vous pouvez l'appeler exactement comme si vous aviez appelé Multiply(operator, operand):

var out = ret(3, 4);

est le même que

var out = Multiply(3, 4);

Que vous avez dit que vous allez utiliser ret en tant que délégué pour Multiply(). Lors de l'appel de ret, nous sommes vraiment se référant à la Multiply fonction.

Retour à votre window.onload. Pensez à ce que:

window.onload = function() {
    //Doing what all good window.onload functions should do...
}

initAll = function() {
    return 12;
}

Donc, comme vous pouvez le voir, window.onload est une fonction comme une autre fonction, il n'y a rien de spécial à ce sujet. Vous pouvez lui affecter une valeur, de lui attribuer une fonction, la valeur null si vous le désirez, le point est qu'il n'y a plus rien de spécial à propos de window.onload qu'il y a sur votre propre fonction. La seule légèrement différent, c'est qu'il est appelé par la fenêtre quand il est chargé. [Disclaimer: je n'ai jamais réellement annulée par la fenêtre de fonctions, donc je ne suis pas sûr si cela va entraîner des répercussions négatives. On espère qu'ils vérifier pour voir si une fonction est attribuée avant de l'appeler c'est à dire if (window.onload) window.onload();].

Appelle maintenant initAll() ce que nous disons, c'est:

window.onload = initAll();

qui pourrait tout aussi bien dire:

window.onload = 12;

Mais quand nous disons initAll sans les parenthèses, ce que nous sommes vraiment dire, c'est: je veux remplacer quelle que soit ma fenêtre.onload fonction est, avec une nouvelle fonction, c'est à dire que je veux le remplacer par mon initAll fonction, de sorte que tous les appels à window.onload va mon initAll code.

Donc:

window.onload = function() {
    //Doing what all good window.onload functions should do...
}

est remplacé par:

window.onload = function() {
    return 12;
}

Donc tout appel à window.onload exécutera votre initAll fonction de la place de ce que window.onload était à l'origine. Vous avez remplacé la fonction d'origine avec votre nouvelle fonction.

En fait, vous pourrait également écrire:

window.onload = function() {
    //Write all your init code right in here instead of having a separate 
    //initAll function.
}

Un autre exemple qui peut démontrer le mieux, c'est ce:

var d = new Date();
var currentTime = d.getTime();

Quel que soit le temps était à l'époque d est défini finit attribué à currentTime. Grande, mais qui est seulement utile si nous voulons savoir à quelle heure la fonction contenant le code a été appelée à - dire au temps de chargement de page. Si nous voulons l'heure actuelle tout le temps que currentTime est appelé?

var currentTime = function() {
    var d = new Date();
    return d.getTime();
}

var a = currentTime(); //The current time at the point a is defined...
var b = currentTime;   //b is a functional reference to currentTime...
var c = b(); //The current time when variable c is defined
var d = c; //The current time when variable c was defined

Notez comment nous appeler b() dans notre c et d affectations exactement comme l'on pourrait appeler currentTime()?

initAll est une référence à une valeur de la fonction et les supports de l'opérateur ajouté le nom de la fonction s'EXÉCUTE cette fonction de l'objet.

Donc, si vous faites quelque chose comme

a = initAll

puis a va devenir le même que initAll - par exemple, vous pouvez faire a() - mais avec

a = initAll()

la variable a obtiendrez la valeur de retour de la initAll fonction