javascript - sur - ponctuation




Que fait le point d'exclamation avant la fonction? (6)

C'est une autre façon d'écrire IIFE (expression de fonction invoquée immédiatement).

Son autre façon d'écrire -

(function( args ) {})()

pareil que

!function ( args ) {}();
!function () {}();

Et voici quelque chose de plus que j'ai compris de la console. Comme mentionné précédemment, le point d'exclamation rend la fonction retourne un booléen.

Pour le dernier de la syntaxe:

( function my_function() {} )()

Nous pouvons faire quelque chose comme:

(function add_them(a,b) { return a+b;} )(9,4)

Comme une définition de fonction et un appel simultanés.

Modifier:
Maintenant, vous demandez quelle est l'utilisation de '!' définition de la fonction de type. Considérons ce qui suit:

!function a_would_be_function() { alert("Do some junk but inside a function"); }()

vous voudriez exécuter une fonction comme ci-dessus, mais sans '!' générerait une erreur. J'espère que je suis clair.


Il y a un bon point à utiliser ! pour l'invocation de fonction marquée sur le guide JavaScript airbnb

Généralement idée d'utiliser cette technique sur des fichiers séparés (alias modules) qui seront plus tard concaténés. Attention ici sont les fichiers censés être concaténés par des outils qui mettent un nouveau fichier à la nouvelle ligne (ce qui est de toute façon un comportement commun pour la plupart des outils de concat). Dans ce cas en utilisant ! aidera à éviter l'erreur si le module précédé d'un point-virgule a manqué le point-virgule, et cela donnera la flexibilité de les mettre dans n'importe quel ordre sans souci.

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

Va travailler comme

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

mais enregistre deux caractères et l'apparence arbitraire mieux.

Et d'ailleurs, tous les opérateurs void , + , - , ~ ont le même effet, en termes de fonction d'invocation, à coup sûr si vous avez utilisé quelque chose pour revenir de cette fonction, ils agiraient 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 des modèles IIFE pour un fichier une séparation de code de module et en utilisant l'outil concat pour l'optimisation (ce qui rend une ligne un travail d'un fichier), que la construction

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

Fera l'exécution sûre de code, même comme un premier échantillon de code.

Celui-ci va lancer une erreur car JavaScript ASI ne pourra pas faire son travail.

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

Une note concernant les opérateurs unaires, ils feraient un travail similaire, mais seulement dans le cas où ils ne l'utilisent pas dans le premier module. Donc, ils ne sont pas si sûrs si vous n'avez pas un contrôle total sur l'ordre de concaténation.

Cela marche:

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

Ce n'est pas:

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

La fonction:

function () {}

ne renvoie rien (ou indéfini).

Parfois, nous voulons appeler une fonction correctement lorsque nous la créons. Vous pourriez être tenté d'essayer ceci:

function () {}()

mais il en résulte une SyntaxError .

En utilisant le ! opérateur avant que la fonction le fasse traiter comme une expression, nous pouvons donc l'appeler:

!function () {}()

Cela retournera aussi le booléen opposé de la valeur de retour de la fonction, dans ce cas true , car !undefined est true . Si vous voulez que la valeur de retour réelle soit le résultat de l'appel, essayez de le faire de la façon suivante:

(function () {})()

! annulera (vis-à-vis) ce que vous attendez, c'est-à-dire si vous avez

var boy = true;
undefined
boy
true
!boy
false

quand vous appelez un boy , votre résultat sera true , mais au moment où vous ajoutez le ! Quand vous appelez boy , c'est-à-dire !boy , votre résultat sera false . En d'autres termes, vous voulez dire NotBoy , mais cette fois c'est un résultat booléen, true ou false .

C'est la même chose qui arrive à la !function () {}(); expression, exécutant uniquement function () {}(); vous signaler une erreur, mais ajoutez ! juste en face de votre function () {}(); expression, fait l'opposé de la function () {}(); ce qui devrait vous rendre true . Exemple peut être vu ci-dessous:

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

! est un opérateur NOT logique, c'est un opérateur booléen qui va inverser quelque chose à son opposé.

Bien que vous puissiez ignorer les parenthèses de la fonction invoquée en utilisant le BANG (!) Avant la fonction, il inversera toujours le retour, ce qui pourrait ne pas être ce que vous vouliez. Comme dans le cas d'un IEFE, il renverrait undefined , qui, lorsqu'il est inversé, devient le booléen vrai.

Au lieu de cela, utilisez la parenthèse fermante et le BANG ( ! ) Si nécessaire.

// I'm going to leave the closing () in all examples as invoking the function with just ! and () takes away from what's happening.

(function(){ return false; }());
=> false

!(function(){ return false; }());
=> true

!!(function(){ return false; }());
=> false

!!!(function(){ return false; }());
=> true

D'autres opérateurs qui fonctionnent ...

+(function(){ return false; }());
=> 0

-(function(){ return false; }());
=> -0

~(function(){ return false; }());
=> -1

Opérateurs combinés ...

+!(function(){ return false; }());
=> 1

-!(function(){ return false; }());
=> -1

!+(function(){ return false; }());
=> true

!-(function(){ return false; }());
=> true

~!(function(){ return false; }());
=> -2

~!!(function(){ return false; }());
=> -1

+~(function(){ return false; }());
+> -1






function