javascript - parametro - Motivo detrás de esta autoinvocación de la variante de función anónima

pasar funcion como parametro javascript

Question

Mientras miraba el code en github, encontré lo siguiente:

(function() {

}).call(this);

Esta es claramente una función anónima que invoca a sí misma. Pero, ¿por qué está escrito de esta manera? Estoy acostumbrado a ver la variante canónica (function() {})() .

¿Hay alguna ventaja en particular al usar .call(this) para una función anónima de invocación automática?

Editar: parece que algunos entornos commonjs establecen this en un valor no global en el nivel superior de un módulo. ¿Cuáles y qué es lo que establecen para que usted quiera preservar?

Answer 1

La función de invocación automática es útil para ejecutar su contenido de forma inmediata cuando se carga la secuencia de comandos. Esto es conveniente para inicializar elementos de alcance global.

Answer 2

Mediante el uso:

> (function() {
>   ...
> }).call(this);`

entonces esto en el alcance del código (probaby el objeto global) se establece como el objeto de la función. Por lo que puedo decir, es equivalente a:

(function(global) {
  // global references the object passed in as *this*
  // probably the global object
})(this);

En un navegador, generalmente la ventana es (o se comporta como si fuera) un alias para el objeto global.

Answer 3

Por defecto, al invocar una función como (function(){/*...*/})() establecerá el valor de this en la función para window (en un navegador) independientemente de lo que sea el valor de this en el adjuntando el contexto donde se creó la función.

El uso de call permite establecer manualmente el valor de this en lo que desee. En este caso, lo establece en cualquiera que sea el valor de this en el contexto adjunto.

Toma este ejemplo:

var obj = {
    foo:''bar''
};

(function() {
    alert( this.foo ); // "bar"
}).call( obj );

http://jsfiddle.net/LWFAp/

Puede ver que pudimos establecer manualmente el valor de this para el objeto al que hace referencia la variable obj .

Answer 4

.call(this) (en realidad fue just () hasta que lo cambié) asegura que tu nivel superior sea coherente a través del modo estricto, --bare opción y / o el entorno en ejecución (donde el nivel superior this no apunta al objeto global) )

Answer 5

C={
    descript: "I''m C!<br>",
    F: function() {
        //set this to the caller context''s ''this''
        (function() {
            document.write(this.descript);
        }).call(this);

        //set this to ''window'' or ''undefined'' depend the mode
        (function() {
            document.write(this.descript);
        })();

        //member function''s ''this'' is the object self
        document.write(this.descript);
    }
}

window.descript="I''m window!<br>";

C.F();

(function() {}).call(this); podría establecer this en el contexto anónimo al que llama this , en la parte superior es C (function() {})(); configurará this en la window o undefined depende del modo.