Какова цель самоисполняющейся функции в JavaScript?

Question

В javascript, когда вы захотите использовать это:

(function(){
    //Bunch of code...
})();

через это:

//Bunch of code...

Answer 1

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

Например:

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

alert(foo); 

Сначала будет выдано предупреждение «3», а затем выдается ошибка при следующем предупреждении, поскольку foo не определен.

Answer 2

Упрощенный.Выглядит вполне нормально, это почти успокаивает:

var userName = "Sean";

console.log(name());

function name() {
  return userName;
}

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

Ждать...что?

Я имею в виду.Если кто-то вводит символ с каким-либо акцентом (например, французский или испанский), а мне нужны только «английские» символы?А-Я в моей программе?Хорошо...Испанские символы «n~» и французские «e/» (я использовал для них по два символа, но вы, вероятно, сможете мысленно перейти к символу, обозначающему акценты), эти символы можно перевести в базовые символы «н» и «е».

Итак, кто-то приятный человек написал комплексный преобразователь символов, который я могу включить на свой сайт...Я включаю это.

Одна проблема:в нем есть функция под названием «имя», такая же, как и моя функция.

Это то, что называется столкновением.У нас есть две функции, объявленные в одном и том же объем с тем же именем.Мы хотим избежать этого.

Поэтому нам нужно как-то ограничить область действия нашего кода.

Единственный способ ограничить область действия кода в JavaScript — это обернуть его в функцию:

function main() {
  // We are now in our own sound-proofed room and the 
  // character-converter libarary's name() function can exist at the 
  // same time as ours. 

  var userName = "Sean";

  console.log(name());

  function name() {
    return userName;
  }
}

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

У нас есть функция в функции...что странно смотреть, но совершенно законно.

Только одна проблема.Наш код не работает.Наша переменная userName никогда не отображается в консоли!

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

function main() {
  // We are now in our own sound-proofed room and the 
  // character-converter libarary's name() function can exist at the 
  // same time as ours. 

  var userName = "Sean";

  console.log(name());

  function name() {
    return userName;
  }
}

main();

Или раньше!

main();

function main() {
  // We are now in our own sound-proofed room and the 
  // character-converter libarary's name() function can exist at the 
  // same time as ours. 

  var userName = "Sean";

  console.log(name());

  function name() {
    return userName;
  }
}

Второстепенная проблема:Какова вероятность того, что имя «main» еще не использовалось?... такой очень, очень тонкий.

Нам нужно БОЛЬШЕ возможностей.И какой-то способ автоматического выполнения нашей функции main().

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

((){})();

Синтаксис неуклюж как грех.Однако это работает.

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

Итак, давайте еще раз посмотрим на наш код с самоисполняющимся синтаксисом:

(function main() {
  var userName = "Sean";

    console.log(name());

    function name() {
      return userName;
    }
  }
)();

Итак, в большинстве руководств, которые вы читаете, вас будут засыпать термином «анонимное самовыполнение» или чем-то подобным.

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

Если что-то пойдет не так (а это произойдет), вы будете проверять обратную трассировку в своем браузере.Это всегда легче сузить проблемы с кодом, когда записи в трассировке стека имеют имена!

Очень многословно, и я надеюсь, что это поможет!

Answer 3

Самоинвокация (также известная как автоинвокация)-это когда функция выполняется сразу же по ее определению.Это основной шаблон, который служит основой для многих других моделей разработки JavaScript.

Я большой поклонник :) этого, потому что:

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

Чрезвычайно – (Почему вы должны говорить, что это хорошо?)

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

Более здесь.

Answer 4

Пространство имен.Области действия JavaScript являются функциональными.

Answer 5

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

А (function(){})() конструкция не защищает от неявных глобальных переменных, что меня больше всего беспокоит, см. http://yuiblog.com/blog/2006/06/01/global-domination/

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

Чем более лаконичен var App = {} Синтаксис обеспечивает аналогичный уровень защиты и может быть заключен в функциональный блок на «публичных» страницах.(видеть Эмбер.js или SproutCore для реальных примеров библиотек, использующих эту конструкцию)

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

Answer 6

Есть ли параметр, и «Куча кода» возвращает функцию?

var a = function(x) { return function() { document.write(x); } }(something);

Закрытие.Значение something используется функцией, назначенной a. something может иметь какое-то меняющееся значение (цикл for), и каждый раз a имеет новую функцию.

Answer 7

Я прочитал все ответы, здесь не хватает чего-то очень важного, Я ПОЦЕЛУЮ.Есть две основные причины, почему мне нужны самовыполняющиеся анонимные функции, или лучше сказать "Выражение немедленно вызываемой функции (IIFE)":

1. Лучшее управление пространством имен (предотвращение загрязнения пространства имен -> модуль JS)
2. Замыкания (имитация членов частного класса, как известно из ООП)

Первое очень хорошо объяснено.Для второго изучите следующий пример:

var MyClosureObject = (function (){
  var MyName = 'Michael Jackson RIP';
  return {
    getMyName: function () { return MyName;},
    setMyName: function (name) { MyName = name}
  }
}());

Внимание 1: Мы не назначаем функцию MyClosureObject, более того результат вызова этой функции.Быть в курсе () в последней строке.

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

Давайте проведем несколько экспериментов:

я могу получить MyName с использованием getMyName и это работает:

 console.log(MyClosureObject.getMyName()); 
 // Michael Jackson RIP

Следующий изобретательный подход не сработает:

console.log(MyClosureObject.MyName); 
// undefined

Но я могу задать другое имя и получить ожидаемый результат:

MyClosureObject.setMyName('George Michael RIP');
console.log(MyClosureObject.getMyName()); 
// George Michael RIP

Редактировать: В примере выше MyClosureObject предназначен для использования без newпрефикс, поэтому по соглашению его не следует писать с заглавной буквы.

Answer 8

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

Конечно, в половине реализаций JS они все равно будут.

Answer 9

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

for( var i = 0; i < 10; i++ ) {
  setTimeout(function(){
    console.log(i)
  })
}

Выход: 10, 10, 10, 10, 10...

for( var i = 0; i < 10; i++ ) {
  (function(num){
    setTimeout(function(){
      console.log(num)
    })
  })(i)
}

Выход: 0, 1, 2, 3, 4...

Answer 10

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

Answer 11

Самовызываемая функция в JavaScript:

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

Answer 12

Поскольку функции в Javascript являются объектами первого класса, то, определяя их таким образом, они фактически определяют «класс», очень похожий на C++ или C#.

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

Answer 13

Самоисполняющиеся функции используются для управления областью действия переменной.

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

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

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

var globalvar = "globalvar"; // this var can be accessed anywhere within the script

function scope() {
    alert(globalvar);
    localvar = "localvar" //can only be accessed within the function scope
}

scope(); 

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

Answer 14

Похоже, что на этот вопрос уже дан ответ, но я все равно опубликую свой вклад.

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

var myObject = {
    childObject: new function(){
        // bunch of code
    },
    objVar1: <value>,
    objVar2: <value>
}

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

object: {
    childObject: {
        childObject: {<value>, <value>, <value>}
    }, 
    objVar1: <value>,
    objVar2: <value>
}

Кодирование в целом имеет много неясных способов сделать много одинаковых вещей, заставляя вас задуматься: «Зачем беспокоиться?» Но новые ситуации продолжают появляться там, где вы больше не можете полагаться только на основные/основные принципы.

Answer 15

(function(){
    var foo = {
        name: 'bob'
    };
    console.log(foo.name); // bob
})();
console.log(foo.name); // Reference error

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

Основная цель заключения функции в закрывающие и открывающие круглые скобки — избежать загрязнения глобального пространства.

Переменные и функции внутри выражения функции стали частными (т. е. они не будут доступны вне функции).

Answer 16

IIRC позволяет создавать частные свойства и методы.