Пожалуйста, объясните принцип, лежащий в основе.

window.onload = initAll();

значения этого {{}} этого свойства

window.onload = initAll;

выполняет

window.onload = initAll();

this сразу же initAll() возвращаемое значение функции You возможно, потребуется сделать это, если другие опции не будут работать, не будут практичными или для соответствия другим связанным функциям. . Обычно это window.onload то, что вы хотите. не должен был бы вернуть функцию для этого, чтобы иметь смысл. initAll() это назначает

window.onload = initAll;

фактическую функцию — это возможно, потому что в JavaScript, как говорит @Felix, функции являются объектами первого класса — без их выполнения. window.onload будет выполнено событием загрузки. initAll То, что говорит Пекка, правильно, но я хочу немного подробнее остановиться на примере, который поможет объяснить тому, кто не полностью понимает указатели функций или делегаты.

Я не буду использовать

, потому что это немного надумано для демонстрации. Вместо этого я буду использовать простую функцию умножения для демонстрации: window.onload Это также можно записать так:

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

Хотя в первом примере значение может быть неочевидным, во втором примере более четко показано, что мы назначаем функцию которая имеет 2 параметра для переменной с именем

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

, и такое понятие функций как присваивания распространено во всем JavaScript. Это небольшая демонстрация того факта, что функции являются Multiply «гражданами первого класса» , то есть их можно передавать точно так же, как если бы мы передавали значения. Итак, теперь к разнице присваивания:

В момент определения переменной ret выполняется

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

и присваивается возвращаемое значение — Multiply становится равным 12. ret Давайте попробуем это снова по-другому:

Теперь, в точке определения

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

становится вашей ret, ret функцией, а не результатом, полученным из вашего Multiply, ваш Multiply функция. Вызывает ret() будет таким же, как Multiply функция должна быть выполнена, и вы можете вызывать ее точно так же, как если бы вы вызывали Multiply(operator, operand):

var out = ret(3, 4);

. фактически сказал, что вы собираетесь использовать

var out = Multiply(3, 4);

в качестве делегата для ret. При вызове Multiply() мы действительно имеем в виду ret Назад к вашему Multiply.

. Думайте об этом как: window.onload Итак, как вы можете видеть,

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

initAll = function() {
    return 12;
}

— это функция, как и любая другая функция, в этом нет ничего особенного. Вы можете присвоить ему значение, назначить ему функцию, обнулить ее, если хотите — дело в том, что нет ничего более особенного в window.onload Теперь вызывается window.onload, чем в вашей собственной функции. Единственное, что немного отличается, это то, что он вызывается окном при загрузке. [Отказ от ответственности: я никогда не отменял оконные функции, поэтому я не уверен, что это вызовет негативные последствия. Можно было бы надеяться, что они проверят, назначена ли функция перед вызовом, то есть if (window.onload) window.onload();].

то, что мы говорим: initAll(), что может хорошо скажем:

window.onload = initAll();

Но когда мы говорим

window.onload = 12;

без скобок, мы на самом деле говорим: я хочу заменить любую мою функцию window.onload новой функцией, то есть я хочу заменить ее своей initAll, так что любые вызовы initAll запускают мои window.onload. Таким образом, любой вызов initAll код.

Итак:

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

Итак, вы:

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

выполнит вашу функцию window.onload вместо того, что было изначально initAll. Вы заменили исходную функцию на новую. window.onload На самом деле, вы

в равной степени пишете: может Еще один пример, который может продемонстрировать лучшее, заключается в следующем:

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

Независимо от того, какое время было в то время, которое определено

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

, в конечном итоге назначаетсяd определено и назначено currentTime. Отлично, но это полезно, только если мы хотим выяснить, во сколько была вызвана функция, содержащая этот код, то есть во время загрузки страницы. Что если мы хотим узнать текущее время в любое время, когда вызывается currentTime?

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

Обратите внимание на то, как мы называем b() в наших c и d присваиваниях точно так же, как мы могли бы вызывать currentTime()?

Функции в javascript являются гражданами первого класса и, как таковые, могут быть назначены другим переменным или переданы в качестве аргументов.

Итак, когда вы задаете свойство

window.onload = initAll;

Вы устанавливаете объект onload объекта window для ссылки на саму функцию initAll.

Когда вы делаете свойство

window.onload = initAll();

Вы устанавливаете объект onload для хранения или его initAll, так как он будет выполняться на месте в этой строке.

initAll является ссылкой на значение функции, а оператор скобок, добавленный к имени функции, запускает этот объект функции.

Так что если вы сделаете что-то вроде

a = initAll

method: a, то же самое будет initAll — например, вы можете сделать a() — но с

a = initAll()

переменной a получите возвращаемое значение выполненной функции initAll функция

Я опоздал на 6 лет, но я чувствую, что это можно объяснить гораздо проще, чем приведенные выше ответы.

Итак, вот TLDR ; или с высоты птичьего полета при вызове функций с использованием, а не с использованием () ‘s

. Возьмем, к примеру, эту функцию :

function foo(){
return 123;
}

если вы регистрируете «foo» — без ()

console.log(foo); 

---outout------
function foo(){
return 123;
}

Использование no () означает выборку самой функции . Вы бы сделали это, если хотите, чтобы он передавался как обратный вызов.


, если вы записываете «foo ()» — 2 — это число цифр, до которого мы хотим округлить это число. ()

console.log(foo());
-----output-----
 123

массивов () после того, как функция означает выполнить функцию и вернуть ее значение Глядя на вывод