Clases: Métodos de Instancia en JavaScript

Los métodos de instancia en JavaScript son funciones definidas dentro de una clase que operan sobre las instancias creadas a partir de esa clase. Estos métodos permiten acceder y modificar las propiedades específicas de cada objeto, proporcionando un comportamiento personalizado para cada instancia.

En este artículo exploraremos cómo definir métodos de instancia en clases, cómo funcionan, y cuándo utilizarlos, con ejemplos prácticos que demuestran su utilidad en el desarrollo de aplicaciones.

¿Qué es un Método de Instancia?

Un método de instancia es una función definida dentro de una clase que puede ser invocada en cualquier objeto creado a partir de esa clase. Los métodos de instancia tienen acceso a las propiedades del objeto a través de la palabra clave this, lo que les permite operar sobre el estado del objeto.

Sintaxis Básica de un Método de Instancia

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

  // Método de instancia
  saludar() {
    console.log(`Hola, soy ${this.nombre} y tengo ${this.edad} años.`);
  }
}

const persona1 = new Persona('Ana', 30);
persona1.saludar();

"Hola, soy Ana y tengo 30 años."

En este ejemplo el método saludar() es un método de instancia que accede a las propiedades nombre y edad de la instancia persona1 para generar un mensaje personalizado.

Características de los Métodos de Instancia

1. Acceso a las Propiedades del Objeto: Los métodos de instancia pueden acceder y modificar las propiedades del objeto a través de this. Esto les permite interactuar con el estado del objeto.
2. Definidos Dentro de la Clase: Se declaran directamente en el cuerpo de la clase, fuera del método constructor y no necesitan la palabra clave function para su definición.
3. Compartidos por Todas las Instancias: Aunque cada objeto tiene su propio estado (propiedades), los métodos definidos en la clase se comparten entre todas las instancias. Esto es eficiente en términos de memoria ya que los métodos no se replican en cada objeto.

Modificar el Estado del Objeto con Métodos de Instancia

Los métodos de instancia se utilizan a menudo para modificar las propiedades del objeto. Por ejemplo, se pueden crear métodos que cambien el valor de una propiedad o realicen cálculos basados en las propiedades del objeto.

Ejemplo: Método para Modificar una Propiedad

class CuentaBancaria {
  constructor(titular, saldo = 0) {
    this.titular = titular;
    this.saldo = saldo;
  }

  depositar(monto) {
    this.saldo += monto;
    console.log(`Depósito de ${monto} realizado. Saldo actual: ${this.saldo}`);
  }

  retirar(monto) {
    if (monto <= this.saldo) {
      this.saldo -= monto;
      console.log(`Retiro de ${monto} realizado. Saldo actual: ${this.saldo}`);
    } else {
      console.log('Fondos insuficientes.');
    }
  }
}

const cuenta = new CuentaBancaria('Luis', 500);
cuenta.depositar(200);
cuenta.retirar(100);

"Depósito de 200 realizado. Saldo actual: 700"
"Retiro de 100 realizado. Saldo actual: 600"

En el anterior este ejemplo los métodos depositar() y retirar() son métodos de instancia que modifican la propiedad saldo de la instancia cuenta.

Diferencias entre Métodos de Instancia y Métodos Estáticos

Es importante distinguir entre los métodos de instancia, que se aplican a instancias específicas de una clase, y los métodos estáticos, que se aplican a la clase en sí y no requieren una instancia.

Métodos de Instancia:

• Se invocan en instancias de la clase.
• Acceden al estado del objeto mediante this.

Métodos Estáticos:

• Se invocan directamente en la clase, no en sus instancias.
• No tienen acceso a this relacionado con la instancia, solo a la clase.

Uso Avanzado de Métodos de Instancia: Encadenamiento de Métodos

El encadenamiento de métodos es una técnica que permite llamar varios métodos en una sola línea de código, devolviendo this en cada método para que la cadena continúe.

Ejemplo: Encadenamiento de Métodos

class Calculadora {
  constructor(valor = 0) {
    this.valor = valor;
  }

  sumar(n) {
    this.valor += n;
    return this;  // Devuelve `this` para permitir el encadenamiento
  }

  restar(n) {
    this.valor -= n;
    return this;  // Devuelve `this` para permitir el encadenamiento
  }

  resultado() {
    console.log(`Resultado: ${this.valor}`);
    return this;
  }
}

const calculo = new Calculadora(10);
calculo.sumar(5).restar(3).resultado();

"Resultado: 12"

En este ejemplo los métodos sumar() y restar() devuelven this, lo que permite encadenar múltiples llamadas de métodos.

Buenas Prácticas para Definir Métodos de Instancia

Usar Métodos de Instancia para Manipular el Estado del Objeto: Siempre que necesites modificar o interactuar con las propiedades de una instancia, utiliza un método de instancia.

Evitar Métodos Estáticos para Funcionalidades que Requieran this: Si el método necesita acceder a this, debe ser un método de instancia, no un método estático.

Definir los Métodos de Instancia Después del Constructor: Coloca los métodos de instancia después del método constructor para mantener una estructura de clase organizada.

Errores Comunes al Usar Métodos de Instancia

1. No Usar this Correctamente: Si this no se refiere a la instancia actual, el método de instancia no funcionará correctamente. Asegúrate de que los métodos se invoquen en instancias creadas con new.
2. No Retornar this al Encadenar Métodos: Si planeas permitir el encadenamiento de métodos, asegúrate de retornar this en cada método.
3. Acceder a Propiedades que No Existen: Intenta evitar acceder a propiedades que no están definidas en la instancia. Esto podría lanzar errores o devolver undefined.

Conclusión

Los métodos de instancia son fundamentales para definir el comportamiento de los objetos en JavaScript. Al utilizar estos métodos puedes acceder y modificar el estado del objeto, proporcionando funcionalidades específicas para cada instancia. Además, técnicas como el encadenamiento de métodos permiten escribir código más fluido y expresivo.

En el próximo artículo, exploraremos el uso de Propiedades y Métodos Estáticos, para entender cómo agregar funcionalidades que no están vinculadas a instancias específicas de la clase.