What does ''this'' mean when we are working with objects in javascript?

In JavaScript thisit works a bit differently than in most object-oriented languages.

• When used thisin a function that is not called by any object, it is equivalent to the global object window.

  function hacerAlgo() {
      console.log(this); // window
  }
  

• When we make use of thisinside a function that exists inside a claseu objeto, it refers to the claseu objetoitself.

  function Persona() {
      this.edad = 22; // this = Persona
  }
  
  var Persona = {
      calcAge: function() {
          console.log(this); // this = Persona
      }
  }
  

Why put "this" at the beginning instead of just putting "wheels = 4" or "seats = 1"?

This is a matter of design. In JavaScript it is required to use this in classes to denote that said variable is a property of the class. If you don't use this, that variable is stored in the global scope .

Correct me if I'm wrong:

I am going to generalize about the keyword thissince it is used by various programming languages ​​to refer to the "scope" of the element being used.

Imagine we have the following code:

class Miclase
{
    private int X;
    public void SetX(int X)
    {
        this.X = X;
    }
}

There are programming languages ​​whose main focus is on local variables, before anything else, I mean, if the SetX(X)following had been put in the code:

X = X; 

The compiler wouldn't know what to do, telling you to "assign the value of parameter X to parameter X" . So it thisrefers to the object that could always be present throughout the instance.

By doing this.X = Xso I am telling the compiler to assign the value of my parameter Xinto the private variable Xthat exists in my class.

The same happens with any element, when using the word thisyou are defining that the element you want to call has the lowest priority level, so to speak.

Where you could define the priority levels as:

Variables/Funciones Locales  (Prioridad 1)
Variables/Funciones Globales (Prioridad 0)

The same thing happens with functions, imagine that there is a function called in the System Restar()and you have an element defined with the same name within a class or any other object:

funcion Restar()  
{
    // Implementacion ...
}

By default in any programming language, this element belongs to a class or a higher category object, so if we call from the same instance to Restar(), the System function will have more importance than the one you have defined.

funcion Main()
{
    Restar(); // Llama a la función del Sistema.
    this.Restar(); 
    // ^ Llama a tu definición siempre que se encuentre dentro de la misma clase
}    

Lastly, the keyword thisworks as a "pointer" (if it can be called that) to the current instance of the object, so all of the above can work.

this : MDN (English) :

As other answers say, keyword thisis used in various languages. Typically in object-oriented languages ​​with classes (C++ and Java in particular). In these languages, thisit is a reference to "this object", and is used to specify which scope we are referring to when using a variable (or field, or property) name. In Javascript it is similar, but a little more varied and complicated.

To a first approximation: thisit will be inside a function that is part of an object; when we call the function using this object then it thiswill reference that object. Example:

var persona = {
     edad : 25,
     esMayor : function() {
         console.log("evaluando esMayor() , this=" + this + " edad=" + this.edad);
         return this.edad >= 18;
     }
}

console.log(persona.esMayor());
persona.edad = 17;
console.log(persona.esMayor());

If the above is clear, there are a couple of things to note (especially for those of us who come from OOP with classes). First: notice that we haven't declared anything resembling a "person" class, but an object; Contrary to appearances, we cannot (at least not easily) create multiple instances of this "person". Second: we could ask ourselves "Is the reference really thisresolved at runtime? In fact, here, thisit will always correspond to persona, right?" No, not necessarily. Example:

var perro = { edad : 10, esViejo : persona.esMayor } ;
console.log("perro:" + perro.esViejo());

(This is important to clarify that it is the object that is used to call the function that matters, not the object where the function is "declared".)

Now, there is another slightly different scenario, special and important (in fact, it corresponds to the example in the question). There is a very particular type of functions in Javascript, constructors (the language, unfortunately, does not differentiate between them at a syntactic level - in principle, any function can be used as a constructor - in fact, it is not usually the case - the convention is to use capital letters in name).

var Car = function() {  // esto es (casi seguramente) un constructor
  this.wheels = 4;
  this.seats = 1;
};

The "normal" use of a constructor is with the keyword new, which allows you to instantiate various objects (not based on a "class", but on a constructor, which defines a prototype)

var car1 = new Car();
var car2 = new Car();

What happens with the constructor invocation with new... important to understand but what is relevant here is the behavior of this: in this case, Javascript first creates a new object and then calls the constructor using that object. So , thisin that context, points to the newly created object.

Finally, what if it is used thisin a global context, (outside a function, or in a function that is not called as an object property)? In such a case, it thispoints to the "global object" ( window). It is rare that one is interested in this.

For more details, similar question on SO (English)