Qué es this en programación

En programación orientada a objetos el concepto de this en una método de instancia, es una referencia a la propia instancia que posee el método.

Este mecanismo que permite a los métodos acceder y modificar los atributos de la instancia, así como invocar otros métodos definidos en la misma.

Dependiendo del lenguaje de programación, se utiliza una palabra clave específica (this, self, me, entre otros) para referirse a esta referencia interna.

Pero, aunque se implementan de manera distinta en diferentes lenguajes de programación, básicamente cumplen la misma función.

Por otro lado, por su propia naturaleza, this solo puede usarse en métodos de instancia. En métodos estáticos no hay instancia, por lo que no tiene sentido usar this.

Caso práctico

Veamos un ejemplo del uso de this. En los lenguajes que incorporan el concepto, este permite referirse al objeto actual dentro de sus métodos de instancia.

Supongamos el siguiente ejemplo, con nuestra clase Persona. En este caso, tenemos una variable de instancia llamada nombre. Pero a su vez, en un método (en este caso en el constructor) estamos recibiendo una variable nombre

class Persona
{
    string nombre;

    Persona(string nombre)
    {
        this.nombre = nombre; // 'this' se refiere al campo 'nombre' de la clase
    }

    void MostrarNombre()
    {
        Console.WriteLine("Nombre: " + this.nombre);
    }
}

En este caso, ante poner this nos permite desambiguar entre los miembros de la clase y los parámetros del método que tienen el mismo nombre.

En este ejemplo, this.nombre se refiere al campo nombre de la clase Persona, mientras que nombre por sí solo se refiere al parámetro del constructor.

¿Qué podría ser mejor no usar el mismo nombre? Pues sí, no te lo voy a negar 🤷‍♀️. Pero es solo un ejemplo sencillo para ilustrar el uso de this.

Return this

En el contexto de un método, this es una referencia a un objeto. Algo especial, pero una referencia. Así que posible devolver this. De hecho, no es algo raro.

class Persona
{
    string Nombre;

    Persona()
    {
        // ... no nos importa en este ejemplo
    }

    Persona DoSomething()
    {
        return this;  // puede devolverse a si mismo
    }
}

Además, esto posibilita la creación de ciertos mecanismos, como el patrón de encadenamiento de métodos o el patrón builder. Los veremos en su momento.

Ejemplos

Finalmente, veamos un ejemplo de como funcionan las auto referencias en distintos lenguajes de programación,

public class Persona
{
    private string nombre;

    public Persona(string nombre)
    {
        this.nombre = nombre;
    }

    public void Saludar()
    {
        Console.WriteLine("Hola, mi nombre es " + this.nombre);
    }
}

// Uso
Persona persona = new Persona("Luis");
persona.Saludar();  // Salida: Hola, mi nombre es Luis

#include <iostream>
#include <string>

class Persona {
private:
    std::string nombre;

public:
    Persona(const std::string& nombre) : nombre(nombre) {}

    void saludar() const {
        std::cout << "Hola, mi nombre es " << this->nombre << std::endl;
    }
};

// Uso
int main() {
    Persona persona("Luis");
    persona.saludar();  // Salida: Hola, mi nombre es Luis
    return 0;
}

class Persona {
    private nombre: string;

    constructor(nombre: string) {
        this.nombre = nombre;
    }

    saludar(): void {
        console.log("Hola, mi nombre es " + this.nombre);
    }
}

// Uso
const persona = new Persona("Luis");
persona.saludar();  // Salida: Hola, mi nombre es Luis

class Persona {
    constructor(nombre) {
        this.nombre = nombre;
    }

    saludar() {
        console.log("Hola, mi nombre es " + this.nombre);
    }
}

// Uso
const persona = new Persona("Luis");
persona.saludar();  // Salida: Hola, mi nombre es Luis

class Persona:
    def __init__(self, nombre):
        self.nombre = nombre

    def saludar(self):
        print(f"Hola, mi nombre es {self.nombre}")

# Uso
persona = Persona("Luis")
persona.saludar()  # Salida: Hola, mi nombre es Luis