Почему вам нужно вызывать анонимную функцию в той же строке?

Отбросьте точку с запятой после определения функции.

(function (msg){alert(msg)})
('SO');

Выше должно работать.

ДЕМО-страница: https://jsfiddle.net/e7ooeq6m/

В этом посте я обсуждал этот тип шаблона:

jQuery и $ questions

РЕДАКТИРОВАТЬ:

Если вы посмотрите спецификацию сценария ECMA, там есть 3 способа определить функцию. (Стр. 98, Раздел 13 Определение функций)

1. Использование конструктора функций

var sum = new Function('a','b', 'return a + b;');
alert(sum(10, 20)); //alerts 30

2. Использование объявления функции.

function sum(a, b)
{
    return a + b;
}

alert(sum(10, 10)); //Alerts 20;

3. Функциональное выражение

var sum = function(a, b) { return a + b; }

alert(sum(5, 5)); // alerts 10

Вы можете спросить, в чем разница между объявлением и выражением?

Из спецификации сценария ECMA:

FunctionDeclaration: идентификатор функции (FormalParameterListopt) {FunctionBody}

FunctionExpression: функция Identifieropt (FormalParameterListopt) {FunctionBody}

Если вы заметили, «идентификатор» является необязательным для выражения функции. А когда вы не даете идентификатор, вы создаете анонимную функцию. Это не значит, что вы не можете указать идентификатор.

Это означает, что верно следующее.

var sum = function mySum(a, b) { return a + b; }

Важно отметить, что вы можете использовать mySum только внутри тела функции mySum, но не снаружи. См. Следующий пример:

var test1 = function test2() { alert(typeof test2); }

alert(typeof(test2)); //alerts 'undefined', surprise! 

test1(); //alerts 'function' because test2 is a function.

Живая демонстрация

Сравните это с

 function test1() { alert(typeof test1) };

 alert(typeof test1); //alerts 'function'

 test1(); //alerts 'function'

Вооружившись этими знаниями, попробуем проанализировать ваш код.

Когда у вас есть такой код,

    function(msg) { alert(msg); }

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

    (function(msg) { alert(msg); })('SO'); //alerts SO.

Это называется автоматически запускаемой функцией.

Когда вы вызываете (function(){}), вы возвращаете объект функции. Когда вы добавляете к нему (), он вызывается, и все, что находится в теле, выполняется. ; обозначает конец оператора, поэтому второй вызов не выполняется.

Одна вещь, которая меня смутила, - это то, что «()» - это операторы группировки.

Вот ваша основная заявленная функция.

Ex. 1:

var message = 'SO';

function foo(msg) {
    alert(msg);
}

foo(message);

Функции являются объектами и могут быть сгруппированы. Итак, давайте обведем функцию скобками.

Ex. 2:

var message = 'SO';

function foo(msg) {  //declares foo
    alert(msg);
}

(foo)(message);     // calls foo

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

Ex. 3.

var message = 'SO';

(function foo(msg) {
    alert(msg);
})(message);          // declares & calls foo

Наконец, нам не нужен этот дополнительный foo, потому что мы не используем имя для его вызова! Функции могут быть анонимными.

Ex. 4.

var message = 'SO';

(function (msg) {   // remove unnecessary reference to foo
    alert(msg);
})(message);

Чтобы ответить на ваш вопрос, вернитесь к примеру 2. Первая строка объявляет некоторую безымянную функцию и группирует ее, но не вызывает ее. Вторая строка группирует строку. Оба ничего не делают. (Первый пример Винсента.)

(function (msg){alert(msg)});  
('SO');                       // nothing.

(foo); 
(msg); //Still nothing.

Но

(foo)
(msg); //works

Анонимная функция не является функцией с именем "". Это просто функция без имени.

Как и любое другое значение в JavaScript, для создания функции не требуется имя. Хотя гораздо полезнее привязать его к имени, как и к любому другому значению.

Но, как и любое другое значение, вы иногда хотите использовать его без привязки к имени. Это самозапускающийся шаблон.

Вот функция и число, не связанные, они ничего не делают и никогда не могут быть использованы:

function(){ alert("plop"); }
2;

Поэтому мы должны сохранить их в переменной, чтобы иметь возможность использовать их, как и любое другое значение:

var f = function(){ alert("plop"); }
var n = 2;

Вы также можете использовать синтаксический сахар для привязки функции к переменной:

function f(){ alert("plop"); }
var n = 2;

Но если их именование не требуется и приведет к еще большей путанице и меньшей удобочитаемости, вы можете просто использовать их прямо сейчас.

(function(){ alert("plop"); })(); // will display "plop"
alert(2 + 3); // will display 5

Здесь моя функция и мои числа не привязаны к переменной, но их все равно можно использовать.

Сказано так, похоже, что самозапускающаяся функция не имеет реальной ценности. Но вы должны помнить, что разделителем области видимости JavaScript является функция, а не блок ({}).

Таким образом, самозапускающаяся функция фактически имеет то же значение, что и блок C ++, C # или Java. Это означает, что переменная, созданная внутри, не будет «просачиваться» за пределы области видимости. Это очень полезно в JavaScript, чтобы не загрязнять глобальную область видимости.

Так работает JavaScript. Вы можете объявить именованную функцию:

function foo(msg){
   alert(msg);
}

И назовите это:

foo("Hi!");

Или вы можете объявить анонимную функцию:

var foo = function (msg) {
    alert(msg);
}

И назовите это:

foo("Hi!");

Или вы просто никогда не можете привязать функцию к имени:

(function(msg){
   alert(msg);
 })("Hi!");

Функции также могут возвращать функции:

function make_foo() {
    return function(msg){ alert(msg) };
}

(make_foo())("Hi!");

Ничего не стоит, что любые переменные, определенные с помощью "var" в теле make_foo, будут закрыты каждой функцией, возвращаемой make_foo. Это закрытие, и это означает, что любое изменение значения, сделанное одной функцией, будет видно другой.

Это позволяет вам инкапсулировать информацию, если вы хотите:

function make_greeter(msg){
    return function() { alert(msg) };
}

var hello = make_greeter("Hello!");

hello();

Так работает почти любой язык программирования, кроме Java.

Код, который вы показываете,

(function (msg){alert(msg)});
('SO');

состоят из двух операторов. Первое - это выражение, которое возвращает объект функции (который затем будет собираться сборщиком мусора, потому что он не сохраняется). Второй - это выражение, которое возвращает строку. Чтобы применить функцию к строке, вам нужно либо передать строку в качестве аргумента функции при ее создании (что также показано выше), либо вам нужно будет фактически сохранить функцию в переменной, чтобы вы могли примените его позже, на досуге. Вот так:

var f = (function (msg){alert(msg)});
f('SO');

Обратите внимание, что, сохраняя анонимную функцию (лямбда-функцию) в переменной, вы фактически даете ей имя. Следовательно, вы можете также определить обычную функцию:

function f(msg) {alert(msg)};
f('SO');

Резюмируя предыдущие комментарии:

function() {
  alert("hello");
}();

если не присвоено переменной, выдает синтаксическую ошибку. Код анализируется как оператор (или определение) функции, что делает закрывающие круглые скобки синтаксически неверными. Добавление круглых скобок вокруг функциональной части сообщает интерпретатору (и программисту), что это выражение функции (или вызов), как в

(function() {
  alert("hello");
})();

Это самозапускающаяся функция, то есть она создается анонимно и запускается немедленно, потому что вызов происходит в той же строке, где он объявлен. Эта самозапускающаяся функция обозначается знакомым синтаксисом для вызова функции без аргументов, плюс добавлены круглые скобки вокруг имени функции: (myFunction)();.

Существует хороший синтаксис функции JavaScript для обсуждения SO < / а>.

Этот ответ не имеет прямого отношения к вопросу, но вам может быть интересно узнать, что такая синтаксическая функция не является специфической для функций. Например, мы всегда можем сделать что-то вроде этого:

alert(
    {foo: "I am foo", bar: "I am bar"}.foo
); // alerts "I am foo"

Относится к функциям. Поскольку они являются объектами, которые наследуются от Function.prototype, мы можем делать такие вещи, как:

Function.prototype.foo = function () {
    return function () {
        alert("foo");
    };
};

var bar = (function () {}).foo();

bar(); // alerts foo

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

var x = function () {} (); // this function is executed but does nothing

function () {} (); // syntax error

Еще одна вещь, которую вы можете сделать с функциями, как только вы их объявите, - это вызвать над ними оператор new и получить объект. Следующие варианты эквивалентны:

var obj = new function () {
    this.foo = "bar";
};

var obj = {
    foo : "bar"
};

Есть еще одно свойство, которое имеет функция JavaScript. Если вы хотите рекурсивно вызывать ту же анонимную функцию.

(function forInternalOnly(){

  //you can use forInternalOnly to call this anonymous function
  /// forInternalOnly can be used inside function only, like
  var result = forInternalOnly();
})();

//this will not work
forInternalOnly();// no such a method exist

Мое понимание вопроса задающего вопрос таково, что:

Как работает эта магия:

(function(){}) ('input')   // Used in his example

Я могу ошибаться. Однако обычная практика, с которой люди знакомы, такова:

(function(){}('input') )

Причина в том, что скобки JavaScript AKA () не могут содержать операторов, и когда синтаксический анализатор встречает ключевое слово функции, он знает, что нужно анализировать его как выражение функции, а не как объявление функции.

Источник: сообщение в блоге Immediately-Invoked Function Expression (IIFE)

примеры без скобок:

void function (msg) { alert(msg); }
('SO');

(это единственное реальное использование void, afaik)

or

var a = function (msg) { alert(msg); }
('SO');

or

!function (msg) { alert(msg); }
('SO');

тоже работать. void вызывает оценку выражения, а также присваивание и взрыв. последний работает с ~, +, -, delete, typeof, некоторыми унарными операторами (void также является одним). не работают из-за ++, -- из-за требования переменной.

разрыв строки не нужен.

Это самоисполняющаяся анонимная функция. Первый набор скобок содержит выражения, которые должны быть выполнены, а второй набор скобок выполняет эти выражения.

(function () {
    return ( 10 + 20 );
})();

Питер Мишо обсуждает разницу в важной паре круглых скобок.

Это полезная конструкция при попытке скрыть переменные из родительского пространства имен. Весь код внутри функции содержится в закрытой области видимости функции, то есть к нему вообще нельзя получить доступ извне функции, что делает его действительно закрытым.

Видеть:

1. Closure (информатика)
2. Пространство имен JavaScript
3. Важная пара круглых скобок Javascript

Другая точка зрения

Во-первых, вы можете объявить анонимную функцию:

var foo = function(msg){
 alert(msg);
}

Тогда вы называете это:

foo ('Few');

Поскольку foo = function (msg) {alert (msg);}, вы можете заменить foo как:

function(msg){
 alert(msg);
} ('Few');

Но вы должны заключить всю анонимную функцию в пару фигурных скобок, чтобы избежать синтаксической ошибки объявления функции при синтаксическом анализе. Тогда у нас есть

(function(msg){
 alert(msg);
}) ('Few');

Таким образом, для меня это легко понять.

Когда вы это сделали:

(function (msg){alert(msg)});
('SO');

Вы завершили функцию перед ('SO') из-за точки с запятой. Если просто написать:

(function (msg){alert(msg)})
('SO');

Это будет работать.

Рабочий пример: http://jsfiddle.net/oliverni/dbVjg/

Простая причина, по которой это не работает, заключается не в том, что ; указывает на конец анонимной функции. Это потому, что без () в конце вызова функции это не вызов функции. То есть,

function help() {return true;}

Если вы вызываете result = help();, это вызов функции, которая вернет истину.

Если вы звоните result = help;, это не звонок. Это задание, в котором справка рассматривается как данные, которые необходимо присвоить результату.

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

(function (msg) { /* Code here */ });

а затем попытался вызвать его в другом операторе, используя только круглые скобки ... Очевидно, потому что функция не имеет имени, но это не сработает:

('SO');

Интерпретатор видит круглые скобки во второй строке как новую инструкцию / оператор, и поэтому он не работает, даже если вы сделали это следующим образом:

(function (msg){/*code here*/});('SO');

Он по-прежнему не работает, но работает, когда вы удаляете точку с запятой, потому что интерпретатор игнорирует пробелы и каретки и видит весь код как один оператор.

(function (msg){/*code here*/})        // This space is ignored by the interpreter
('SO');

Заключение: вызов функции не является вызовом функции без () на конце, если только при определенных условиях, таких как вызов другой функции, то есть onload = 'help' будет выполнять функцию справки, даже если круглые скобки не были включены. Я считаю, что setTimeout и setInterval также допускают этот тип вызова функции, и я также считаю, что интерпретатор в любом случае добавляет круглые скобки за кулисами, что возвращает нас к «вызов функции не является вызовом функции без круглых скобок».

(function (msg){alert(msg)})
('SO');

Это распространенный метод использования анонимной функции в качестве закрытия, который используют многие фреймворки JavaScript.

Эта функция вызывается автоматически при компиляции кода.

Если поместить ; в первую строку, компилятор рассматривает ее как две разные строки. Таким образом, вы не можете получить те же результаты, что и выше.

Это также можно записать как:

(function (msg){alert(msg)}('SO'));

Дополнительные сведения см. В JavaScript / анонимные функции.

1. Анонимные функции - это функции, которые динамически объявляются во время выполнения. Они называются анонимными функциями, потому что им не дается имя, как обычным функциям.

   Анонимные функции объявляются с использованием оператора функции вместо объявления функции. Вы можете использовать оператор функции для создания новой функции везде, где допустимо поместить выражение. Например, вы можете объявить новую функцию как параметр для вызова функции или присвоить свойство другому объекту.

   Вот типичный пример именованной функции:

   функция flyToTheMoon () {alert ("Масштаб! Масштаб! Масштаб!"); } flyToTheMoon (); Вот тот же пример, созданный как анонимная функция:

   var flyToTheMoon = function () {alert ("Масштаб! Масштаб! Масштаб!"); } flyToTheMoon ();

   Подробности читайте здесь:

   http://helephant.com/2008/08/23/javascript-anonymous-functions/

IIFE просто разделяет функцию и скрывает переменную msg, чтобы не «загрязнять» глобальное пространство имен. На самом деле, просто сохраняйте простоту и делайте, как показано ниже, если только вы не создаете веб-сайт на миллиард долларов.

var msg = "later dude";
window.onunload = function(msg){
  alert( msg );
};

Вы можете создать пространство имен для своего msg свойства, используя шаблон модуля выявления, например:

var myScript = (function() {
    var pub = {};
    //myscript.msg
    pub.msg = "later dude";
    window.onunload = function(msg) {
        alert(msg);
    };
    //API
    return pub;
}());

Анонимные функции предназначены для одноразового использования, когда вы определяете функцию на лету, чтобы она генерировала вывод от вас из вводимых вами данных. За исключением того, что вы не предоставили ввод. Вместо этого вы написали что-то во второй строке («SO»); - независимое утверждение, не имеющее отношения к функции. Что вы ожидали? :)