Quel est le point d'exclamation faire avant la fonction?

La syntaxe JavaScript 101. Voici une déclaration de fonction:

function foo() {}

Remarque qu'il n'y a pas de point-virgule: c'est juste une fonction déclaration. Vous auriez besoin d'une invocation, foo(), pour exécuter la fonction.

Maintenant, lorsque nous ajoutons de l'apparence anodins point d'exclamation: !function foo() {} il les transforme en une expression. Il est maintenant un expression de fonction.

La ! ne suffit pas d'invoquer la fonction, bien sûr, mais nous pouvons maintenant mettre () à la fin: !function foo() {}() qui a une priorité plus élevée que ! et immédiatement les appels de la fonction.

Donc, ce que l'auteur est en train de faire est de sauver un octet par la fonction d'expression, un moyen plus lisible de l'écriture, ce serait celui-ci:

(function(){})();

Enfin, ! rend l'expression renvoie la valeur true. C'est parce que par défaut, tous les IIFE retour undefined, ce qui nous laisse avec !undefined qui est true. Pas particulièrement utile.

OriginalL'auteur Neil

Il est un bon point pour l'utilisation de ! pour l'invocation de la fonction marqué sur airbnb JavaScript guide

Généralement l'idée d'utiliser cette technique sur des fichiers séparés (aka modules) qui, plus tard, d'obtenir concaténées. L'inconvénient ici est que les fichiers censé être concaténés par des outils qui mettent le nouveau fichier à la nouvelle ligne (qui de toute façon est un comportement commun pour la plupart des concat outils). Dans ce cas, à l'aide de ! aidera à éviter les erreurs dans le cas concaténées module manqué point-virgule de fin, et pourtant qui donnera la souplesse nécessaire pour mettre dans n'importe quel ordre avec pas de soucis.

!function abc(){}();
!function bca(){}();

Travail sera le même que

!function abc(){}();
(function bca(){})();

mais permet d'économiser les deux personnages et l'arbitraire de l'air mieux.

Et par la manière de +,-,~,void les opérateurs ont le même effet, dans les conditions de l'invocation de la fonction, pour sûr, si vous devez utiliser quelque chose pour le retour de cette fonction qu'ils agissent différemment.

abcval = !function abc(){return true;}() //abcval equals false
bcaval = +function bca(){return true;}() //bcaval equals 1
zyxval = -function zyx(){return true;}() //zyxval equals -1
xyzval = ~function xyz(){return true;}() //your guess?

mais si vous utilisez IIFE modèles pour un fichier un module de séparation du code et à l'aide de concat outil pour l'optimisation (ce qui fait une ligne d'un fichier de travail), puis la construction

!function abc(/*no returns*/) {}()
+function bca() {/*no returns*/}()

Fera fort de l'exécution du code, de même que d'un premier exemple de code.

Celui-ci va jeter cause d'erreur JavaScript ASI ne sera pas en mesure de faire son travail.

!function abc(/*no returns*/) {}()
(function bca() {/*no returns*/})()

Une remarque concernant les opérateurs unaires, ils font un travail semblable, mais seulement dans le cas, ils ont utilisé des pas dans le premier module. Donc ils ne sont pas si sûr, si vous n'avez pas un contrôle total sur la concaténation de l'ordre.

Cela fonctionne:

!function abc(/*no returns*/) {}()
^function bca() {/*no returns*/}()

Ce pas:

^function abc(/*no returns*/) {}()
!function bca() {/*no returns*/}()

OriginalL'auteur dmi3y

Point d'Exclamation fait toute fonction retourne toujours une valeur booléenne. La valeur finale est la négation de la valeur retournée par la fonction.

!function bool() { return false; }() //true
!function bool() { return true; }() //false

Omettant ! dans les exemples ci-dessus serait un SyntaxError.

function bool() { return true; }() //SyntaxError

Cependant, la meilleure façon d'atteindre ce serait:

(function bool() { return true; })() //true

OriginalL'auteur oozzal

Sa juste pour sauver un octet de données, lorsque nous ne nous en javascript minification.

examiner le dessous de fonction anonyme

function (){}

À faire la-dessus que l'auto en invoquant la fonction généralement, nous vous modifiez le code ci-dessus comme

(function (){}())

Maintenant, nous avons ajouté deux caractères supplémentaires (,) en dehors de l'ajout de () à la fin de la fonction que nécessaire pour appeler la fonction. Dans le processus de minification nous se concentrent généralement de réduire la taille du fichier. Donc nous pouvons écrire la fonction ci-dessus comme

!function (){}()

Encore les deux sont auto invocation de fonctions et de nous sauver d'un octet. Au lieu de 2 caractères (,) nous avons juste utilisé un caractère !

OriginalL'auteur Varatharaj

! réduit à néant (en face de) tout ce que vous attendez comme un résultat, j'.e si vous avez

var boy = true;
undefined
boy
true
!boy
false

lorsque vous appelez boy, votre résultat sera true, mais au moment où vous ajoutez le ! lors de l'appel de boy, j'.e !boy, votre résultat sera false. Qui, en d'autres mots, vous dire NotBoy, mais cette fois, c'est essentiellement un résultat booléen, soit true ou false.

C'est la même chose qui arrive à la !function () {}(); expression, en cours d'exécution uniquement function () {}(); vous marquera une erreur, mais ajouter ! juste en face de votre function () {}(); expression, en fait tout le contraire de la function () {}(); qui devrait revenir vous true. L'exemple peut être vu ci-dessous:

function () {}();
SyntaxError: function statement requires a name
!function () {}();
true

OriginalL'auteur antzshrek