funkcja javascript prowadząca bang! składnia

Widziałem tę składnię w kilku bibliotekach i zastanawiam się, jaka jest z tego korzyść. (uwaga: jestem świadomy zamknięć i tego, co robi kod, martwię się tylko różnicami składniowymi)

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

Jako alternatywa dla bardziej powszechnych

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

do samodzielnego wywoływania anonimowych funkcji.

Zastanawiam się kilka rzeczy. Po pierwsze, co pozwala na działanie najlepszego przykładu? Dlaczego huk jest konieczny, aby to stwierdzenie było poprawne pod względem składniowym? Powiedziano mi również, że to +działa i jestem pewien, że niektórzy zamiast tego!

Po drugie, jaka jest korzyść? Wszystko, co mogę powiedzieć, to to, że ratuje jedną postać, ale nie wyobrażam sobie, że jest to tak ogromna korzyść, aby przyciągnąć wielu adopcyjnych. Czy brakuje mi innej korzyści?

Jedyną inną różnicą, jaką widzę, byłaby wartość zwracana przez funkcję wywołującą, ale w obu tych przykładach tak naprawdę nie dbamy o wartość zwracaną przez funkcję, ponieważ służy ona jedynie do utworzenia zamknięcia. Czy ktoś może mi powiedzieć, dlaczego można zastosować pierwszą składnię?

Idealnie powinieneś być w stanie zrobić to wszystko po prostu jako:

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

Oznacza to, że zadeklaruj anonimową funkcję i uruchom ją. Ale to nie zadziała ze względu na specyfikę gramatyki JS.

Najkrótszą formą osiągnięcia tego jest użycie wyrażenia np. UnaryExpression (a więc CallExpression):

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

Lub dla zabawy:

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

Lub:

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

Lub nawet:

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

W języku Javascript wiersz rozpoczynający się od functionpowinien być instrukcją funkcji i powinien wyglądać

function doSomething() {
}

Funkcja samo-wywołująca się jak

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

nie pasuje do tej formy (i spowoduje błąd składniowy przy pierwszym otwierającym paren, ponieważ nie ma nazwy funkcji), więc nawiasy służą do określenia anonimowego wyrażenia funkcji .

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

Ale zrobi wszystko, co tworzy wyrażenie (w przeciwieństwie do instrukcji funkcji), więc stąd !. Mówi tłumaczowi, że to nie jest instrukcja funkcji. Poza tym pierwszeństwo operatora narzuca, że ​​funkcja jest wywoływana przed negacją.

Nie byłem świadomy tej konwencji, ale jeśli stanie się powszechna, może przyczynić się do jej czytelności. Chodzi mi o to, że każdy, kto czyta !functionna górze dużego bloku kodu, spodziewa się samodzielnego wywołania, tak jak jesteśmy już uwarunkowani, aby oczekiwać tego samego, kiedy widzimy (function. Tyle że stracimy te irytujące nawiasy. Spodziewałbym się, że to jest powód, w przeciwieństwie do oszczędności prędkości lub liczby postaci.

Oprócz rzeczy, które zostały już powiedziane, składnia z! jest przydatny, jeśli piszesz javascript bez średników:

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

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

Pierwszy przykład zwraca „ham” zgodnie z oczekiwaniami, ale drugi zgłosi błąd, ponieważ instrukcja i = 2 nie została zakończona z powodu następującego nawiasu.

Również w połączonych plikach javascript nie musisz się martwić, jeśli w poprzednim kodzie brakuje średników. Więc nie ma potrzeby wspólnego; (function () {}) (); aby upewnić się, że twoje własne się nie złamie.

Wiem, że moja odpowiedź jest trochę spóźniona, ale myślę, że jeszcze nie została wymieniona :)

Po pierwsze, jsPerf pokazuje, że używanie !(UnaryExpression) jest zwykle szybsze. Czasem wyjdzie być równe, ale jeśli tak nie jest, ja nie widziałem non-waliły jeden triumf zbytnio nad innymi jeszcze: http://jsperf.com/bang-function

Zostało to przetestowane na najnowszym Ubuntu z najstarszym (powiedzmy ..) Chrome, wersja 8. Więc wyniki mogą się oczywiście różnić.

Edycja: A może coś szalonego delete?

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

czy void?

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

Jak widać tutaj , najlepszym sposobem na wykonywanie samodzielnie wywoływanych metod w javascript jest:

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

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

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

Więc z negacją „!” i wszystkie inne jednoargumentowe operatory, takie jak +, -, ~, delete, void, wiele zostało powiedziane, aby podsumować:

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

Lub

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

Lub

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

I jeszcze kilka przypadków z operatorami binarnymi dla zabawy :)

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

Lub

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

Lub

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

Lub nawet

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

Pozostawiając trójkę dla kogoś innego :)