¿Cuál es la diferencia entre este, auto, ventana y window.self

Question

Si abro una página vacía y corro el siguiente comando en la consola de JavaScript puedo obtener el mismo resultado:

>>> this 
    DOMWindow 

    >>> self 
    DOMWindow 

    >>> window 
    DOMWindow 

    >>> window.self 
    DOMWindow 

Qué es lo que se refieren a ? ... el mismo objeto o qué más?

Answer 1

window es la referencia a la ventana actual del navegador donde se ejecuta el script. window.self es obviamente una autorreferencia de eso dentro de sí mismo. Y dado que self aquí es una propiedad del objeto global window, también se puede acceder como si fuera una variable "global": solo self.

Por lo tanto, los últimos tres son en la mayoría de los casos la misma cosa.

this Sin embargo, es completamente diferente: es una variable que apunta al alcance actual. Si se ejecuta el código siguiente en la consola:

> var myPackage = {} 
> myPackage.method = function() {console.log(this)} 
> myPackage.method() 

this estará apuntando a la myPackage objeto (el alcance de method).

Answer 2

this 
DOMWindow 

this es siempre el contexto actual de una expresión de JavaScript fue llamado. Así que en su caso su contexto global, que es el objeto de la ventana cuando el se ejecutan en el navegador. Tenga en cuenta que ejecutar lo mismo en nodeJs le dará otro resultado.

self 
//DOMWindow 

From the MDN Docs:

Devuelve una referencia de objeto al objeto de ventana.

window 
// DOMWindow 

Es lo que ha llamado: el objeto de la ventana.

window.self 
//DOMWindow 

Es lo mismo que llamar a uno mismo porque su contexto es la ventana. Por lo tanto, si llama al window.self o solo a self o this.self, cuando se encuentre dentro del alcance global, es lo mismo.

Answer 3

Siempre esta palabra clave se refiere al contexto en el que se invocó. Sin embargo, sí mismo y la ventana incluso después de cambiar el contexto se refiere a la ventana en sí.

// Log function 
function logAll(){ 
    console.log("this >", this); 
    console.log("self >", self); 
    console.log("window >", window); 
    console.log("window.self >", window.self); 
    console.log("this.self >", this.self); 
}; 

// Class Car 
function Car(){ 
    this.self = 6; 
}; 

// Instance of Car 
var honda = new Car(); 
honda.self = 5; 

// logAll() called in context Gloabal 
logAll(); 

// Outputs 
this > Window 
self > Window 
window > Window 
window.self > Window 
this.self > Window 

// logAll() called in context honda 
logAll.call(honda); 

// Outputs 
this > Car { self= 5 } 
self > Window 
window > Window 
window.self > Window 
this.self > 5 

Aquí se puede ver this.self ventana de rendimientos en cuando se le llama en el ámbito global, porque en el ámbito global

this = windows 
this.self = windows.self 
this.self = Windows 

Pero mientras se encuentra en el contexto de honda, una instancia de coches:

this = honda 
this.self = honda.self 
this.self = 5 

El contexto juega un papel importante en Javascript, mientras trabaja con OOP y herencia.