javascript - significa - signos de admiracion e interrogacion

¿Qué hace el signo de exclamación antes de la función?

Question

!function () {}();

Answer 1

¡Guardemos algunos otros bytes!

(() => {})()

ejemplo:

(() => {return "yeah"})()

Answer 2

¡Hay buen punto para usar ! para la invocación de la función marcada en la guía de airbnb JavaScript

En general, la idea de usar esta técnica en archivos separados (también conocidos como módulos) que luego se concatenan. La advertencia aquí es que los archivos deben ser concatenados por herramientas que ponen el nuevo archivo en una nueva línea (que es de todos modos un comportamiento común para la mayoría de las herramientas de concat). En ese caso utilizando ! ayudará a evitar errores en si el módulo concatenado previamente perdió el punto y coma final, y sin embargo, eso le dará flexibilidad para ponerlos en cualquier orden sin preocupaciones.

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

Funcionará igual que

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

Pero guarda dos personajes y se ve mejor arbitrariamente.

Y, por cierto, cualquiera de los operadores + , - , ~ , void tienen el mismo efecto, en términos de función invocadora, seguro que si utiliza algo para devolver desde esa función, actuarían de manera diferente.

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?

pero si usa patrones IIFE para un archivo, la separación de código de un módulo y el uso de la herramienta concat para la optimización (lo que hace que una línea sea un trabajo de archivo), entonces la construcción

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

Hará ejecución segura del código, al igual que un primer ejemplo de código.

Esto producirá un error porque JavaScript ASI no podrá hacer su trabajo.

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

Una nota con respecto a los operadores unarios, harían un trabajo similar, pero solo en caso de que no se usaran en el primer módulo. De modo que no son tan seguros si no tiene control total sobre la orden de concatenación.

Esto funciona:

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

Esto no:

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

Answer 3

Devuelve si la sentencia puede evaluar a falso. p.ej:

!false      // true
!true       // false
!isValid()  // is not valid

Puedes usarlo dos veces para forzar un valor booleano:

!!1    // true
!!0    // false

Entonces, para responder más directamente a tu pregunta:

var myVar = !function(){ return false; }();  // myVar contains true

Edición: tiene el efecto secundario de cambiar la declaración de función a una expresión de función. Por ejemplo, el siguiente código no es válido porque se interpreta como una declaración de función a la que le falta el identificador requerido (o nombre de función ):

function () { return false; }();  // syntax error

Answer 4

Es otra forma de escribir IIFE (expresión de función inmediatamente invocada).

Su otra forma de escribir -

(function( args ) {})()

igual que

!function ( args ) {}();

Answer 5

La función:

function () {}

No devuelve nada (o indefinido).

A veces queremos llamar a una función como creamos. Usted podría estar tentado de intentar esto:

function () {}()

pero resulta en un SyntaxError .

Usando el ! Operador antes de que la función haga que se trate como una expresión, por lo que podemos llamarla:

!function () {}()

Esto también devolverá el opuesto booleano del valor de retorno de la función, en este caso true , porque !undefined es true . Si desea que el valor de retorno real sea el resultado de la llamada, intente hacerlo de esta manera:

(function () {})()

Answer 6

Los ! El símbolo muestra que es una expresión de función invocada de inmediato.

El signo de exclamación no invocará la función solo; Puedes poner () al final:

!function foo() {}()
() has higher precedence than ! and instantly calls the function.

() tiene mayor precedencia que! y al instante llama a la función.

También puedes mencionarlo como el siguiente:

(function(){})();

Los ! Permite que la expresión devuelva verdadero. Esto se debe a que, de forma predeterminada, todas las expresiones de función invocadas de inmediato vuelven indefinidas, por lo tanto, nos quedamos con! indefinido, lo cual es cierto.

Answer 7

Sintaxis de JavaScript 101. Aquí está una declaración de función :

function foo() {}

Tenga en cuenta que no hay punto y coma: esto es solo una declaración de función. Necesitaría una invocación, foo() , para ejecutar la función.

Ahora, cuando agregamos el signo de exclamación aparentemente inocuo:! !function foo() {} se convierte en una expresión . Ahora es una expresión de función .

El por sí solo no invoca la función, por supuesto, pero ahora podemos poner () al final !function foo() {}() que tiene mayor prioridad que ! y al instante llama a la función.

Entonces, lo que el autor está haciendo es guardar un byte por expresión de función; Una forma más legible de escribir sería esta:

(function(){})();

Por último, hace que la expresión se vuelva verdadera. Esto se debe a que, de forma predeterminada, todas las devoluciones de IIFE undefined están undefined , lo que nos deja con !undefined Undefined, lo cual es true . No es particularmente útil.

Answer 8

Y aquí hay algo más que me di cuenta de la consola. Como se mencionó anteriormente, el signo de exclamación hace que la función devuelva un valor booleano.

Para la última de la sintaxis:

( function my_function() {} )()

Podemos hacer algo como:

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

Como una definición de función simultánea y llamada.

Editar:
Ahora preguntarías para qué sirve ''!'' tipo de definición de la función. Consideremos lo siguiente:

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

querría ejecutar una función como la anterior, pero sin un ''!'' generaría un error. Espero que quede claro.

Answer 9

! negará (opuesto) lo que esté esperando como resultado, es decir, si tiene

var boy = true;
undefined
boy
true
!boy
false

cuando llames boy , tu resultado será true , pero en el momento en que agregues el ! Cuando llames a boy , ie !boy , tu resultado será false . En otras palabras, te refieres a NotBoy , pero esta vez es básicamente un resultado booleano, ya sea true o false .

Eso es lo mismo que le sucede a la !function () {}(); expresión, ejecutando solo la function () {}(); te marcará un error, pero añade ! justo en frente de su function () {}(); expresión, la hace opuesta a la function () {}(); Lo que debería devolverte true . El ejemplo se puede ver a continuación:

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

Answer 10

! es un operador lógico NO , es un operador booleano que invertirá algo en su opuesto.

Aunque puede omitir los paréntesis de la función invocada utilizando BANG (!) Antes de la función, seguirá invirtiendo el retorno, que podría no ser lo que quería. Como en el caso de un IEFE, se devolvería indefinido , que cuando se invierte se convierte en el verdadero booleano.

En su lugar, use el paréntesis de cierre y el BANG ( ! ) Si es necesario.

// 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

Otros operadores que trabajan ...

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

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

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

Operadores Combinados ...

+!(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

Answer 11

Es solo para guardar un byte de datos cuando hacemos la minificación de javascript.

considera la siguiente función anónima

function (){}

Para hacer lo anterior como una función de auto invocación, generalmente cambiaremos el código anterior como

(function (){}())

Ahora agregamos dos caracteres adicionales (,) además de agregar () al final de la función que sea necesario para llamar a la función. En el proceso de minificación, generalmente nos enfocamos en reducir el tamaño del archivo. Así que también podemos escribir la función anterior como

!function (){}()

Aún así, ambas son funciones de invocación automática y también guardamos un byte. En lugar de 2 caracteres (,) solo usamos un carácter !