Как делает (функция () {}) () создают работу и почему люди используют ее? [закрытый]

Это метод, используемый для ограничения области действия переменной; это единственный способ не допустить, чтобы переменные загрязняли глобальное пространство имен.

var bar = 1; // bar is now part of the global namespace
alert(bar);

(function () {
   var foo = 1; // foo has function scope
   alert(foo); 
   // code to be executed goes here
})();

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

(function(){ ... })();

работает как:

temp = function(){ ... };
temp();

Вы также можете сделать то же самое с именованной функцией:

function temp() { ... }
temp();

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

Вы можете сделать то же самое в два шага, и вы можете сделать это с любыми параметрами, которые вам нравятся:

temp = function(answer){ ... };
temp(42);

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

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

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

var i = 0;
alert("The magic number is " + i);

(function() {
   var i = 99;
   alert("The magic number inside the closure is " + i);
})();

alert("The magic number is still " + i);

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

• Магическое число - 0
• Магическое число внутри закрытия - 99
• Магическое число все еще равно 0

It ' как самозапускающаяся функция. Что-то вроде сокращения для записи

function DoSomeStuff($)
{
}

DoSomeStuff(jQuery);

function(){ // some code here }

- это способ определения анонимной функции в javascript. Они могут дать вам возможность выполнять функцию в контексте другой функции (в противном случае у вас может не быть такой возможности).

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

;(function($){
   ... your jQuery code here...
})(jQuery);

Передав оператор $ в качестве параметра и вызвав его в jQuery, оператор $ в функции заблокирован для jQuery, даже если у вас загружены другие фреймворки.

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

Переменные ограничены на уровне функций в javascript. Это отличается от того, к чему вы могли бы привыкнуть на таких языках, как C # или Java, где переменные привязаны к блоку. Это означает, что если вы объявите переменную внутри цикла или оператора if, она будет доступна для всей функции.

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

(function() {
  var myProperty = "hello world";
  alert(myProperty);
})();
alert(typeof(myProperty)); // undefined

Как говорили другие, обе они определяют анонимные функции, которые вызываются немедленно. Обычно я оборачиваю свои объявления классов JavaScript в эту структуру, чтобы создать статическую частную область видимости для класса. Затем я могу поместить в эту область постоянные данные, статические методы, обработчики событий или что-либо еще, и это будет видно только экземплярам класса:

// Declare a namespace object.
window.MyLibrary = {};

// Wrap class declaration to create a private static scope.
(function() {
  var incrementingID = 0;

  function somePrivateStaticMethod() {
    // ...
  }

  // Declare the MyObject class under the MyLibrary namespace.
  MyLibrary.MyObject = function() {
    this.id = incrementingID++;
  };

  // ...MyObject's prototype declaration goes here, etc...
  MyLibrary.MyObject.prototype = {
    memberMethod: function() {
      // Do some stuff
      // Maybe call a static private method!
      somePrivateStaticMethod();
    }
  };
})();

В этом примере класс MyObject назначен для пространство имен MyLibrary , поэтому оно доступно. incrementingID и somePrivateStaticMethod () недоступны напрямую за пределами области анонимной функции.

Они часто используются в плагинах jQuery. Как объясняется в Руководстве по созданию подключаемых модулей jQuery , все переменные, объявленные внутри {} , являются закрытыми и не видны снаружи, что позволяет улучшить инкапсуляцию.

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

for (var i = 0; i < 3; i++) {
    $("#button"+i).click(function() {
        alert(i);
    });
}

Приведенный выше код заставит все три кнопки отобразить "3". С другой стороны:

for (var i = 0; i < 3; i++) {
    (function(i) {
        $("#button"+i).click(function() {
            alert(i);
        });
    })(i);
}

Это заставит три кнопки выскочить «0», «1» и «2», как и ожидалось.

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

Потому что хороший код ответы уже взяты :) Я предложу посмотреть видео Джона Ресига видео 1 , видео 2 (изобретатель jQuery и мастер JavaScript).

Некоторые действительно хорошие идеи и ответы, представленные в видео.

Именно этим я занимался в тот момент, когда увидел ваш вопрос.

1) Он определяет анонимную функцию и сразу выполняет ее.

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

3) Вам нужно раскрыть некоторые методы из него, все, что объявлено внутри, будет "частным", например:

MyLib = (function(){
    // other private stuff here
    return {
        init: function(){
        }
    };

})();

Или, альтернативно:

MyLib = {};
(function({
    MyLib.foo = function(){
    }
}));

Дело в том, что есть много способов его использования, но результат остается прежним.

Это в основном для пространства имен вашего кода JavaScript.

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

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

(function($) {

    // Now I can use $, but it won't affect any other library like Prototype
})(jQuery);

Эван Тримболи описывает остальное в своем ответе .

Приведенный выше код создает анонимную функцию в строке 1, а затем вызывает ее в строке 3 с 0 аргументами. Это эффективно инкапсулирует все функции и переменные, определенные в этой библиотеке, потому что все функции будут доступны только внутри этой анонимной функции.

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

Чтобы прояснить, как вызывается функция, рассмотрим простой пример:

Если у вас есть эта единственная строка Javascript, она будет вызываться автоматически, без явного ее вызова:

alert('hello');

Итак, возьмите эту идею и примените ее к этому примеру:

(function() {
    alert('hello')
    //anything I define in here is scoped to this function only
}) (); //here, the anonymous function is invoked

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