Esercizi Incapsulamento JavaScript

Codegrind Team•Jul 12 2024

Ecco degli esercizi con soluzione per praticare l’uso dell’incapsulamento in JavaScript.

Esercizio 1: Incapsulamento di proprietà con simboli

Utilizzare i simboli per incapsulare una proprietà all'interno di una classe.

const _saldo = Symbol("saldo");

class ContoBancario {
  constructor() {
    this[_saldo] = 0;
  }

  deposita(importo) {
    if (importo > 0) {
      this[_saldo] += importo;
    }
  }

  preleva(importo) {
    if (importo > 0 && this[_saldo] >= importo) {
      this[_saldo] -= importo;
    }
  }

  getSaldo() {
    return this[_saldo];
  }
}

const conto = new ContoBancario();
conto.deposita(100);
conto.preleva(50);
console.log(conto.getSaldo()); // 50
console.log(conto[_saldo]); // undefined

Esercizio 2: Incapsulamento con WeakMap

Utilizzare un `WeakMap` per incapsulare proprietà private.

const privati = new WeakMap();

class ContoBancario {
  constructor() {
    privati.set(this, { saldo: 0 });
  }

  deposita(importo) {
    if (importo > 0) {
      privati.get(this).saldo += importo;
    }
  }

  preleva(importo) {
    if (importo > 0 && privati.get(this).saldo >= importo) {
      privati.get(this).saldo -= importo;
    }
  }

  getSaldo() {
    return privati.get(this).saldo;
  }
}

const conto = new ContoBancario();
conto.deposita(100);
conto.preleva(50);
console.log(conto.getSaldo()); // 50

Esercizio 3: Getter e Setter

Utilizzare getter e setter per incapsulare una proprietà.

class ContoBancario {
  constructor() {
    this._saldo = 0;
  }

  deposita(importo) {
    if (importo > 0) {
      this._saldo += importo;
    }
  }

  preleva(importo) {
    if (importo > 0 && this._saldo >= importo) {
      this._saldo -= importo;
    }
  }

  get saldo() {
    return this._saldo;
  }

  set saldo(valore) {
    if (valore >= 0) {
      this._saldo = valore;
    }
  }
}

const conto = new ContoBancario();
conto.deposita(100);
conto.preleva(50);
console.log(conto.saldo); // 50
conto.saldo = 200;
console.log(conto.saldo); // 200
conto.saldo = -100;
console.log(conto.saldo); // 200 (valore non cambiato)

Esercizio 4: Incapsulamento con Chiusure (Closure)

Utilizzare le chiusure per incapsulare proprietà private.

function ContoBancario() {
  let saldo = 0;

  return {
    deposita: function (importo) {
      if (importo > 0) {
        saldo += importo;
      }
    },
    preleva: function (importo) {
      if (importo > 0 && saldo >= importo) {
        saldo -= importo;
      }
    },
    getSaldo: function () {
      return saldo;
    },
  };
}

const conto = ContoBancario();
conto.deposita(100);
conto.preleva(50);
console.log(conto.getSaldo()); // 50

Esercizio 5: Incapsulamento in una Classe con ES6

Utilizzare la sintassi ES6 per incapsulare proprietà in una classe.

class ContoBancario {
  #saldo = 0; // Proprietà privata

  deposita(importo) {
    if (importo > 0) {
      this.#saldo += importo;
    }
  }

  preleva(importo) {
    if (importo > 0 && this.#saldo >= importo) {
      this.#saldo -= importo;
    }
  }

  getSaldo() {
    return this.#saldo;
  }
}

const conto = new ContoBancario();
conto.deposita(100);
conto.preleva(50);
console.log(conto.getSaldo()); // 50
console.log(conto.#saldo); // SyntaxError: Private field '#saldo' must be declared in an enclosing class

Esercizio 6: Incapsulamento di Metodi Privati

Utilizzare simboli per incapsulare metodi privati all'interno di una classe.

const _calcolaInteressi = Symbol("calcolaInteressi");

class ContoBancario {
  constructor() {
    this.saldo = 0;
  }

  deposita(importo) {
    if (importo > 0) {
      this.saldo += importo;
    }
  }

  preleva(importo) {
    if (importo > 0 && this.saldo >= importo) {
      this.saldo -= importo;
    }
  }

  [_calcolaInteressi]() {
    return this.saldo * 0.05;
  }

  aggiungiInteressi() {
    this.saldo += this[_calcolaInteressi]();
  }

  getSaldo() {
    return this.saldo;
  }
}

const conto = new ContoBancario();
conto.deposita(1000);
conto.aggiungiInteressi();
console.log(conto.getSaldo()); // 1050
console.log(conto[_calcolaInteressi]()); // TypeError: conto[_calcolaInteressi] is not a function