Qué es una propiedad

Las Propiedades son una característica de ciertos lenguajes de programación orientados a objetos que permiten definir métodos getter y setter de forma más concisa y legible.

La gestión de acceso y modificación de las propiedades de una clase es fundamental para la integridad de los datos. Tradicionalmente, para esto se usan los métodos getter y setter que vimos en el artículo anterior.

Muchos lenguajes de programación modernos ofrecen una alternativa más intuitiva y conveniente en forma de propiedades.

Las propiedades permiten a los usuarios acceder a los campos privados de una clase como si fueran variables públicas, mientras que internamente se utiliza métodos para obtener o establecer el valor.

Por lo demás, no dejan de ser “syntactic sugar” para crear y utilizar métodos getter y setter, de una forma más cómoda para el programador.

Caso practico

Supongamos que tenemos una clase Persona que tiene una variable privada nombre. Vamos a convertir esta variable en una propiedad.

Los detalles cambiarán de una lenguaje a otro. Al final os pongo ejemplos en distintos lenguajes. Por ejemplo en C# se haría así.

class Persona {
	string Nombre { get; set; }
}

Más allá de la forma de definirla, que como digo en este caso cambia mucho de un lenguaje a otro, lo importante es que:

• Hemos creado una propiedad Nombre
• Se han creado dos métodos getter y setter por nosotros
• Existe una variable interna privada, que ni siquiera vemos

Para usar nuestra propiedad, simplemente la usamos como si fuera una variable pública, con =.

Persona persona = new Persona();
persona.Nombre = "Luis";       // invoca el setter
var nombre = persona.Nombre;   // invoca el getter

Internamente se invocará al método getter y setter oportuno, sin que tengamos que hacer nada más. Por lo que vemos que mantenemos la ventaja de los métodos, con la sencillez de uso de una variable.

Ejemplos en distintos lenguajes

Veamos como se realiza la implementación del concepto de Propiedad en distintos lenguajes de programación.

public class Persona
{
    private string nombre;

    // Propiedad
    public string Nombre
    {
        get { return nombre; }
        set
        {
            if (!string.IsNullOrEmpty(value))
            {
                nombre = value;
            }
        }
    }
}

// Uso
Persona persona = new Persona();
persona.Nombre = "Juan";
Console.WriteLine(persona.Nombre);

class Persona {
private:
    std::string nombre;

public:
    void setNombre(const std::string& valor) {
        if (!valor.empty()) {
            nombre = valor;
        } else {
            throw std::invalid_argument("El nombre no puede estar vacío");
        }
    }

    std::string getNombre() const {
        return nombre;
    }

    __declspec(property(get = getNombre, put = setNombre)) std::string Nombre;
};

int main() {
    Persona persona;
    persona.Nombre = "Juan";
    std::cout << persona.Nombre << std::endl; // "Juan"
    return 0;
}

class Persona {
    constructor() {
        this._nombre = '';
    }

    // Propiedad
    get nombre() {
        return this._nombre;
    }

    set nombre(valor) {
        if (valor) {
            this._nombre = valor;
        }
    }
}

// Uso
const persona = new Persona();
persona.nombre = "Juan";
console.log(persona.nombre);

class Persona {
    private _nombre: string;

    // Propiedad
    get nombre(): string {
        return this._nombre;
    }

    set nombre(valor: string) {
        if (valor) {
            this._nombre = valor;
        }
    }
}

// Uso
const persona = new Persona();
persona.nombre = "Juan";
console.log(persona.nombre);

class Persona:
    def __init__(self):
        self._nombre = None

    # Propiedad
    @property
    def nombre(self):
        return self._nombre

    @nombre.setter
    def nombre(self, valor):
        if valor:
            self._nombre = valor

# Uso
persona = Persona()
persona.nombre = "Juan"
print(persona.nombre)

Buenas prácticas Consejos

Como vemos, las propiedades son todo ventajas. Permiten tener las ventajas de los métodos getter y setter, con la facilidad de uso de una variable.

Los únicos consejos que hay que tener en cuenta son los que ya vimos al ver los métodos getter y setter. Es decir, principalmente los métodos tienen que ser cortos y sencillos.

Nada de realizar tareas pesadas, bloqueantes, o con side-effects dentro de una propiedad. El código dentro de los métodos set y get de una propiedad tiene que ser el mínimo posible.

En la mayoría de los casos, únicamente devolver o modificar el valor de la propiedad. Como mucho, lo necesario para validar y mantener la integridad de los datos de tu objeto.

Si tienes que hacer algo más “pesado”, hay que hacer un método independiente (por ejemplo, GetFromDatabase()) que indique claramente el efecto que va a tener su ejecución.