Categorie
Javascript Programmazione

{JS} Adapter Pattern

Cos’è l’Adapter Pattern?

Il pattern Adapter permette di sostituire l’interfaccia/struttura di un oggetto originario, quindi pre-esistente, con una interfaccia che risponda meglio alle necessità del nostro progetto.
Possiamo modificare, sostituire, aggiungere funzionalità e semplicemente rinominare nomi delle proprietà in modo da riadattarle al meglio al nostro programma, il tutto sfruttando le caratteristiche del linguaggio OOP Javascript come l’incapsulamento ed il passaggio per riferimento delle proprietà di un oggetto.

Scopo

Lo scopo di questo pattern è il riadattamento di una struttura di un OGGETTO-PRE-ESISTENTE, ed è possibile, mediante la creazione di un NUOVO-OGGETTO che sostituirà l’originale.
Si procederà con il modificare il costruttore dell’oggetto, suo prototipo, in modo che esso renda possibile la generazione di un nuovo oggetto, modificato nella struttura.
Modificando il costruttore, otterremo la modifica della struttura anche per le successive istanze.
Questo processo ci evita di modificare ad-una-ad-una le proprietà dell’oggetto interessato e di modificare la struttura anche per futuri istanziamenti di nuovi oggetti , ottimizzando il lavoro ed eseguendo il mapping-delle proprietà solo per una volta.
Avremo quindi aggiornato, il vecchio-oggetto e la struttura dei successivi oggetti che potremo successivamente creare.
Abbiamo ri-adattato gli oggetti del nostro programma.

In questo pattern saranno utilizzate diverse caratteristiche/concetti del linguaggio come:
– L’oggetto this
– Il passaggio di valori per riferimento
– L’incapsulamento

L’esempio più calzante che possiamo ritrovare nella realtà è quello di un caricatore di un device:

Porta micro-USB > Porta USB > Presa di corrente
Vecchio oggetto (partenza) > Adapter (soluzione) > Nuovo oggetto (risultato finale)

Scenario

Oggetto pre-esistente

L’oggetto originario, pre-esistente, è l’obbiettivo del riadattamento; è quindi l’oggetto di cui vogliamo cambiare la struttua.

var oggettoPreEsistente = {
    metodo: function(){
            console.log("Ciao");
}
}

Vecchio costruttore

“CostruttoreVecchioOggetto” è il vecchio costruttore ed il prototipo dell’oggetto pre-esistente.

var CostruttoreVecchioOggetto = function(){
    this.metodo = function(){
        console.log("Ciao");
    }
}

Esso ad ogni istanziamento creerà un oggetto con un solo metodo che prevede il saluto “Ciao”.

“oggettoPreEsistente” è stato creato mediante la seguente stringa di codice:

var oggettoPreEsistente = new CostruttoreVecchioOggetto();

Lo scenario completo prevede quindi un oggetto-pre-esistente ed il suo costruttore.

Adapter Pattern

Per attuare il processo di adattamento mediante l’Adapter Pattern avremo bisogno di un nuovo-costruttore.

Nuovo Costruttore

var CostruttoreNuovoOggetto = function(){
    this.primoMetodo = function(){
        console.log("Ciao");
    this.secondoMetodo = function(){
        console.log("Buon pomeriggio");
    this.terzoMetodo = function(){
        console.log("Buona serata");
    }
}}

Il nuovo-costruttore modifica, rispetto al vecchi-costruttore, il nome della prima proprietà da “metodo” a “primoMetodo” ed aggiunge due nuovi metodi “secondoMetodo” e “terzoMetodo”.

Ri-adattamento (Adapter)

Per eseguire il riadattamento mediante l’Adapter Pattern procederemo con la ridefinizione del costruttore-originario “CostruttoreVecchioOggetto”.

var CostruttoreVecchioOggetto = function(){
    var oggettoDiComodo = new CostruttoreNuovoOggetto;
    this.primoMetodo = oggettoDiComodo.primoMetodo;
    this.secondoMetodo = oggettoDiComodo.secondoMetodo;
    this.terzoMetodo = oggettoDiComodo.secondoMetodo;
    }

Nella ridefinizione del vecchio-costruttore la nostra attenzione è catturata dalla stringa di codice:

...
var oggettoDiComodo = new CostruttoreNuovoOggetto;
...

Stiamo creando un oggetto-di-comodo, mediante il nuovo-costruttore, all’interno della ridefinizione del vecchio-costruttore.
In questo modo possiamo utilizzare questo oggetto nel cotesto di esecuzione e ci sarà utile per riassociare, per effetto del passaggio di valori per-riferimento, le proprietà vecchie con le nuove proprietà.

Risultato

Potremo ora quindi, creare una nuova istanza per l’oggetto-pre-esistente che sarà di fatto un nuovo-oggetto; inoltre potremo creare molteplici istanze con la medesima struttura del nuovo-oggetto.

var nuovoOggettoPreEsistente = new CostruttoreVecchioOggetto();

nuovoOggettoPreEsistente.primoMetodo();
// Ciao
nuovoOggettoPreEsistente.secondoMetodo();
// Buon pomeriggio
nuovoOggettoPreEsistente.terzoMetodo();
// Buona serata
Chiarimento

Durante questo processo articolato non sitiamo sostituendo o eliminando oggetti ma stiamo solo implementando nuovi oggetti e nuove strutture. L’unica sovrascrittura/sostituzione che eseguiamo è quella del costruttore principale “CostruttoreVecchioOggetto” per effetto della ridefinizione.
“oggettoPreEsistente” continuerà ad esistere, ma per nostra utilità continueremo, nel nostro programma, con “nuovoOggettoPreEsistente” e le nuove istanze generate dopo l’implementazione del pattern.
Potremo sintetizzare come se stessimo ragionando: “da questo momento in poi… questi sono i miei oggetti”.

Un’alternativa potrebbe essere quella associare il valore del vecchio-oggetto al nuovo:

oggettoPreEsistente = nuovoOggettoPreEsistente;

ad ogni modo, uno dei due oggetti, rimarrebbe abbandonato.

Lascia un commento

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *