Функция javascript, ведущая к удару! синтаксис

Я видел этот синтаксис в нескольких библиотеках сейчас, и мне интересно, в чем преимущество. (заметьте, я хорошо осведомлен о закрытии и о том, что делает код, меня беспокоят только синтаксические различия)

!function(){
  // do stuff
}();

В качестве альтернативы более распространенным

(function(){
  // do stuff
})();

для самостоятельного вызова анонимных функций.

Мне интересно несколько вещей. Во-первых, что позволяет на самом деле работать сверху? Почему необходим сигнал, чтобы синтаксически корректно это утверждение выглядело? Мне также говорят, что + работает, и я уверен, что некоторые другие, вместо !

Во-вторых, какая польза? Все, что я могу сказать, это то, что он спасает одного персонажа, но я не могу представить, что такая огромная выгода привлекает многочисленных усыновителей. Есть ли какая-то другая польза, которую я не вижу?

Единственное отличие, которое я могу видеть, - это возвращаемое значение функции self-invoking, но в обоих этих примерах мы действительно не заботимся о возвращаемом значении функции, поскольку она использовала только для создания замыкания. Так может кто-то сказать мне, почему можно использовать первый синтаксис?

Ответ 1

В идеале вы должны иметь возможность делать все это просто как:

function(){
  // do stuff
}();

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

Самая короткая форма достижения этого - использовать некоторое выражение, например. UnaryExpression (и так CallExpression):

!function(){
  // do stuff
}();

Или для удовольствия:

-function(){
  // do stuff
}();

Или:

+function(){
  // do stuff
}();

Или даже:

~function(){
  // do stuff
  return 0;
}( );

Ответ 2

В Javascript ожидается, что строка, начинающаяся с function, будет выражением функции и должна выглядеть как

function doSomething() {
}

Функция самозапускания, подобная

function(){
  // do stuff
}();

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

(function(){
  // do stuff
})();

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

Я не знал об этом соглашении, но если он станет общим, это может способствовать читабельности. Я имею в виду, что любой, кто читает !function в верхней части большого блока кода, будет ожидать самозапуска, так как мы уже ожидаем того же, когда видим (function. За исключением того, что мы потеряем эти раздражающие круглые скобки. Я бы ожидал, что причина, в отличие от любой экономии скорости или количества символов.

Ответ 3

Помимо того, что уже было сказано, синтаксис с помощью! полезно, если вы пишете javascript без запятой:

var i = 1
!function(){
  console.log('ham')
}()

i = 2
(function(){
  console.log('cheese')
})()

Первый пример выводит "ветчину", как ожидалось, но второй вызывает ошибку, потому что оператор я = 2 не завершается из-за следующей скобки.

Также в конкатенированных файлах javascript вам не нужно беспокоиться, если в предыдущем коде отсутствовали точки с запятой. Поэтому нет необходимости в общем; (function() {})(); чтобы убедиться, что ваш собственный не сломается.

Я знаю, что мой ответ довольно поздний, но я думаю, что он еще не упоминался:)

Ответ 4

С одной стороны, jsPerf показывает, что использование ! (UnaryExpression) обычно выполняется быстрее. Иногда они выходят на равные, но когда их нет, я не видел, чтобы один из них не побеждал слишком много над остальными: http://jsperf.com/bang-function

Это было протестировано на последнем Ubuntu с самым старым (для каждого..) Chrome, версия 8. Таким образом, результаты могут отличаться, конечно.

Изменить: как насчет чего-то сумасшедшего, как delete?

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

или void?

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

Ответ 5

Как вы можете видеть здесь, лучший способ делать самоисключаемые методы в javascript:

(function(){}()); -> 76,827,475 ops/sec

!function(){}();  -> 69,699,155 ops/sec

(function(){})(); -> 69,564,370 ops/sec

Ответ 6

Итак, с отрицанием "!" и все остальные унарные операторы, такие как +, -, ~, delete, void, много сказано, просто подытожим:

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

или

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

или

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

И еще несколько случаев с бинарными операторами для удовольствия:)

1 > function() {
   alert("Hi!"); 
}();

или

1 * function() {
   alert("Hi!"); 
}();

Или

1 >>> function() {
   alert("Hi!"); 
}();

Или даже

1 == function() {
   alert("Hi!"); 
}();

Оставив троянец для кого-то другого:)