Le campane della cattedrale risuonano gioiose in festa.
Dopo le ultime piogge intense finalmente il cielo è sereno e le temperature cominciano a scaldarsi.
La città è tutta in fermento per il giorno della promozione dei cadetti paladini.
Il duro addestramento durato numerosi anni sta finalmente per giungere al termine e i più meritevoli allievi dell’ordine della Sacra Fiamma vengono proclamati di fronte a tutta la popolazione.
L’emozione è palpabile e la gente si accalca per applaudire i suoi futuri eroi.
Ogni anziano paladino presenta il suo discepolo sul palco montato per l’occasione nella piazza centrale e gli offre le vestigia e i decori del primo rango.
Tutti i neo promossi, a cerimonia terminata, ricevono poi dal proprio mentore un ultimo compito personale da portare a termine e così Tormund riceve l’incarico di entrare nella Foresta dei Sussurri e comprendere i segreti della sacra pergamena che dovrà portare con se.
Il giovane paladino è eccitatissimo e non vede l’ora di intraprendere l’avventura e si precipita a raccogliere le sue cose.
Uscendo dalla città si imbatte in suo vecchio amico ranger al quale racconta il felice evento e lo invita a partecipare alla nuova avventura.
L’amico di numerose scampate ma simpatiche disavventure è all’inizio dubbioso perchè conosce anche solo alcuni dei pericoli della foresta e dei suoi sentieri che più volte a battuto ma accetta comunque di accompagnarlo e mostrargli la via.
La Foresta dei Sussurri è un fitto bosco che si estende per numerosi ettari, i cui alberi sono così da oscurare quasi del tutto la luce del sole.
Una volta addentrati nel cuore della foresta i due giovani avventurieri si imbattono in uno strano abitante della foresta, un druido, che li accoglie amichevolmente nonostante lo stupore di vedere dei viandanti dal quelle parti.
Si presenta come un druido custode della foresta e dei suoi segreti e decide di unirsi al gruppo per capire meglio le loro intenzioni e il vero motivo della loro presenza in quel posto.
Proprio quando la tensione si stava rilassando viste le ore di cammino nelle profondità della foresta e la tranquillità del paesaggio, ciò che prima sembrava a prima vista semplice rugiada e umidità del sottobosco, lentamente si trasforma in una nebbiolina densa e bassa quasi ad impedire dove mettere i piedi.
Le chiome degli alberi sembrano incurvarsi per oscurare i raggi del sole quasi del tutto e i variopinti colori di funghi e fiori diventano sempre più spenti quasi a lasciare posto ad un colore piatto dalle sfumature bluastre.
Si sentono di tanto in tanto delle voci, sottili e distanti ma come se parlassero tutte intorno e la tensione dei tre eroi diventa palpabile.
Cominciano a camminare molto più guardinghi, mano sull’elsa e freccia in corda, pronti a scattare al primo sentore di pericolo.
In una piccola radura, si imbattono un figura di eterea di una bambina, che seduta su una roccia gioca con il suo vestitino e una piccola bambola.
Ad un certo punto sembra notare gli sguardi attoniti e un po’ impauriti su di lei e si rivolge ai viandanti con una voce delicata e gioiosa dicendo “volete giocare con me?” e sorridendo e saltellando si inoltra nella foresta.
Un bagliore intorno sembra quasi illuminarla mentre si allontana dal gruppo e ombre vengono proiettate danzanti sui tronchi.
I tre avventurieri prendono coraggio e decidono di seguirla.
Tormund con in un attimo di concentrazione apre gli occhi e una piccola fiammella azzurra esce dai suoi occhi.
Nella sua mente tutto intorno a se diventa chiaro e nitido e la realtà tutto intorno a se si deforma e piega lo spazio al suo volere: è in grado di vedere lontano e vicino allo stesso tempo, avvertire le presenze intorno a se e percepire le energie magiche che li circondano.
Flussi di potere come folate di vento avvolgono e attraversano la foresta, ma nulla che indichi malefici o incantesimi pronti a scattare.
Il paladino tornato in se rassicura il gruppo e procede dove lo spirito li aveva invitati.
La bambina si gira più volte, incalzandoli a tenere il passo e li guida fino all’ingresso di una caverna ma una volta arrivata, quasi sorpresa o spaventata da qualcosa ne fugge all’interno.
Il ranger silenziosamente ispeziona i dintorni della grotta e nota poco a lato altre due sagome questa volta adulte che distrattamente parlano tra loro di come la loro bambina non obbedisca mai e faccia sempre come vuole.
Come se l’accaduto avesse del tutto spezzato la tensione, i tre si addentrano nella caverna con un nuovo e rinvigorato coraggio.
La luce pallida della foresta illumina malamente l’antro, ma funghi e muschi fluorescenti permettono comunque una certa visibilità.
C’è molta umidità e
Si avvicinano ad uno specchio d’acqua sotterraneo e notano che su un piccolo scoglio che affiora c’è uno strano oggetto che riflette la fioca luce.
Tormund si sveste e si tuffa nelle scure acque per raggiungere la roccia affiorante e mentre raccoglie il misterioso oggetto dall’acqua emergono dei giganteschi granchi destati dal loro sonno.
Con rapidità fulminea li ranger scocca frecce per proteggere la ritirata del paladino che si rituffa in acqua, mentre il druido con il suo bastone cerca di tenere lontani altri due granchi che si erano avvicinati.
Lo scontro è breve ma comunque rischioso data la sorpresa dell’assalto ma i tre granchi vengono uccisi a colpi di giavellotto e spade.
L’oggetto raccolto si rivela essere un pezzo di runa ma purtroppo troppo piccolo per poterne decifrare il significato, quindi messo da parte nello zaino i tre eroi continuano ad addentrarsi nella caverna.
Proprio all’imbocco di lungo corridoio naturale incontrano uno strano vecchietto bisbetico che dichiara di essere alla ricerca del suo libro.
Nonostante l’offerta di aiuto però si rifiuta di dare altre spiegazioni e continua il suo girovagare per la caverna fino a scomparire nell’oscurità.
Con gli sguardi perplessi riprendono il cammino nel corridoio e oltre alla nuda roccia naturale cominciano ad apparire delle modeste e improvvisate impalcature di sostegno e qualche fiaccola per illuminare il cammino.
Ad un certo punto si sentono degli strani versi di grugniti e stridii e il gruppo si imbatte in un piccolo drappello di Coboldi che intorno al fuoco danzano e si spingono tra di loro.
Stanno evidentemente festeggiando la cattura di un piccolo halfling imprigionato in una gabbia.
L’attacco è veloce e i Coboldi vengono eliminati, ma uno di loro riesce a fuggire tra le frecce che saettano, quindi gli eroi sono costretti e liberare velocemente il malcapitato e preparasi ad una seconda ondata.
L’halfling è una maga e mostrando uno strano cubo racconta che era alla ricerca di questo suo oggetto sottrattole proprio da alcuni Coboldi ma le sue energie non sono state sufficienti ed era stata sopraffatta.

Supponiamo di voler realizzare un widget per la ricerca che sia composto da un campo di testo con validazione e un bottone. L’utente dovrà avere la possibilità di inserire del testo ma questo non deve contenere alcun numero all’interno.

Gli elementi HTML di cui avremo bisogno saranno un input per inserire il testo, un button per eseguire il controllo sui numeri e uno spazio che dovrà essere di default invisibile da dedicare ai messaggi di avviso.

Cominciamo quindi a mettere i tre elementi dentro un div contenitore per tenerli raggruppati e poter piazzare il nostro widget ovunque all’interno della pagina senza perderne il controllo.

<div class="search-widget">
  <input type="text"/>
  <button>Check</button>
</div>

Per quanto riguarda il JavaScript definiamo una classe che SearchComponent che accetti in input il dom del nostro widget e definisca quindi i comportamenti agli elementi interni.

function SearchComponent (widgetDom) {
  var input = widgetDom.querySelector("input"),
      button = widgetDom.querySelector("button");
  button.onclick = function () {};
  input.onkeypress = function () {};
}

Al click del bottone usiamo una semplice regex per controllare se ci sono presenti numeri all’interno del testo inserito e nel caso aggiungere una classe CSS al widget per gestire l’errore.

function SearchComponent (widgetDom) {
  var errorClass = " error", // we have to use some space to concat CSS classes
      input = widgetDom.querySelector("input"),
      button = widgetDom.querySelector("button");
  button.onclick = function () {
    widgetDom.className = widgetDom.className.replace(errorClass); // remove previous validation
    if (input.value.match(/[0-9]/)) {
      widgetDom.className += errorClass;
    }
  };
  input.onkeypress = fucntion () {};
}

Aggiungiamo anche un controllo sul campo di testo nel caso in cui l’utente voglia premere invio anzichè usare il bottone. In questo caso possiamo sfruttare la definizione dell’evento sul bottone per invocarlo senza riscriverlo. Ciò ci permette facilmente di gestire la validazione in un unico punto soltanto.

function WidgetSearch (widgetDom) {
  var errorClass = "error", // setting up some default classes for validation
      successClass = "success",
      input = widgetDom.querySelector("input"), // find elements inside the current widget
      button = widgetDom.querySelector("button");
  button.onclick = function () {
    widgetDom.className = widgetDom.className.replace(errorClass, "").replace(successClass, ""); // remove previous validation classes
    if (input.value.length === 0) {
      return; // don't perform validation if there is no text to validate
    }
    if (input.value.match(/[0-9]/)) { // regex validation
      widgetDom.className += " " + errorClass; // add a css class to handle error
    } else {
      widgetDom.className += " " + successClass;
    }
  };
  input.onkeypress = function (event) {
    if (event.keyCode === 13) { // 13 is the key code for return button
      var click = new Event("click"); // define the click event programmatically
      button.dispatchEvent(click) // fire the event on the button simulating the user click
    }
  }
}

Le funzionalità del nostro widget sono ora pronte e rimane da gestire la messaggistica della validazione.

<div class="widget-search">
  <div class="input">
    <input type="text"/>
    <button>Check</button>
  </div>
  <div class="message">
    <div class="message-error">There are numbers in the text.</div>
    <div class="message-success">The text is clear.</div>
  </div>
</div>

Impacchettando gli elementi HTML possiamo meglio gestirne gli stili usando dei selettori CSS parlanti.

Definiamo un set di regole semplici per avere una base di grafica che possa rispecchiare le specifiche dell’esercizio.

Mettiamo il campo di testo e il bottone allineati uno vicino all’altro e i messaggi sotto.

.input * {margin-right: -5px;}  // stick the inputs together
.input input {border-radius: 10px 0 0 10px;}  // add some cool style
.input button {border-radius: 0 10px 10px 0;}
.message * {display: none;}  // the messages
.message-error {color: red;}
.message-success {color: green;}
.error .message-error {display: block;} // show relative message to validation result
.success .message-success {display: block;}

Il nostro widget è finalmente completato nella sua struttura. Per poterlo usare nella nostra applicazione ora dobbiamo solo invocarlo al caricamento della pagina istanziando un nuovo widget di tipo WidgetSearch.

window.onload = function () {
  var widget = document.querySelector(".widget-search");
  new WidgetSearch(widget)
}

Ci sono ora un paio di regole che devono essere tenute a mente usando un componente così definito con CSS e JavaScript.

Gli stili che abbiamo creato potrebbero essere troppo generici all’interno della nostra applicazione, quindi il consiglio è quello di usare, per tutto ciò che non vogliamo sia condiviso con altri elementi HTML in pagina, una root riferita al contenitore per limitare il più possibile overrides.

.widget-search .input * {margin-right: -5px;}
.widget-search .input input {border-radius: 10px 0 0 10px;}
.widget-search .input button {border-radius: 0 10px 10px 0;}
.widget-search .message * {display: none;}
.widget-search .message-error {color: red;}
.widget-search .message-success {color: green;}
.widget-search .error .message-error {display: block;}
.widget-search .success .message-success {display: block;}

Inoltre se volessimo usare più volte nella stessa pagina questo componente dobbiamo tenere presente che va istanziato un nuovo WidgetSarch per ogni elemento. Quindi dovremo aggiungere un ciclo per scorrere tutti i widget in pagina e inizializzarli.

window.onload = function () {
  var widgets = document.querySelectorAll(".widget-search");
  widgets.forEach(function(widget) {
    new WidgetSearch(widget)
  })
}

Infine potremmo creare un sistema automatizzato di inizializzazione di tutti i possibili widget in pagina passando per i data attribute.

Aggiungiamo un data-widget al nostro componente in modo da passargli il valore della classe JavaScript da istanziare e cambiamo il ciclo dentro window.onload per leggere tutti i data-widget in pagina.

<div class="widget-search" data-widget="WigetSearch">
  ...
</div>

window.onload = function () {
  var widgets = document.querySelectorAll("[data-widget]");  // get all elements with that data attribute
  widgets.forEach(function (widget) {
    var className = widget.dataset.widget;  // read the data attribute value
    new window[className](widget);  // get the class from the container of all of them, from window if it's defined at global level, otherwhise other variables
  })
}

In JavaScript qualunque oggetto ha una struttura che lo definisce con proprietà e metodi nativi che non possiamo ne sovrascrivere ne modificare. Sebbene i valori nativi siano disponibili in sola lettura, possiamo aggiungerne di nuovi e manipolarli a piacimento.

Vediamo ora come applicare questo alla programmazione ad oggetti e scoprire quali vantaggi può offrirci.

Definiamo una semplice classe Person che costruiremo man mano ampliandone il suo prototype.

function Person () {};

Person.prototype // {constructor: function(){...}, ...}

Il suo prototype nativo conterrà solo il metodo constructor che viene invocato quando generiamo una nuova istanza e va ad eseguire il codice della classe stessa, e altri metodi ereditati dalla super classe Object.

Aggiungiamo due nuovi metodi per scrivere e leggere il nome della persona

Person.prototype.setName = function (value) { this.name = value };
Person.prototype.getName = function () { this.name = value };

var p = new Person();
p.setName("John");
p.getName(); // "John"

I metodi appena definiti sono diventati nativi per la funzione Person e quindi disponibili alle sue istanze e a ciascuna di queste andranno a rispettivamente a creare e leggere la proprietà name.

Possiamo migliorare l’efficienza di questi due metodi fondendoli in uno solo.

Person.prototype.name = function (value) {
  if (value) {
    this._name = value
  } else {
    return this._name
  }
}

In questa maniera ora avremo un solo metodo name al quale se passiamo un parametro setterà la proprietà altrimenti la leggerà.

var p = new Person();
p.name("John");
p.name(); // "John"

Importante. Abbiamo dovuto però rinominare this.name in this._name per evitare di fare confusione tra metodo e proprietà, altrimenti, una volta invocato il metodo name con un parametro in input andiamo a ridefinire cosa sia name stesso, trasformandolo in un valore e quindi non potendolo più usare successivamente come funzione, ottenendo in console un errore come il seguente.

var p = new Person();
p.name("John");
p.name(); // "Uncaught TypeError: p.name is not a function(…)"
p.name; // "John"
p.name("Smith"); // "Uncaught TypeError: p.name is not a function(…)"
p.name = "Smith";
p.name; // "Smith"

I vantaggi di aggiungere metodi al prototype di una function riguardano soprattutto l’aspetto computazione e occupazione di risorse di memoria. Infatti questi metodi, visti allo stesso livello di quelli nativi, vengono allocati una sola volta e associati ad ogni istanza successiva pur mantenendo il contesto indipendente l’una dall’altra.

In altre parole non viene allocato uno spazio di memoria per ogni metodo name di ogni eventuale var p1, p2, …, ma ne viene allocato uno solo al momento della definizione di Person e poi ereditato dalle istanze e su grandi numeri sia di metodi che di istanze è sicuramente da tenere a conto per le performance.

D’altro canto però per scambiare informazioni tra due metodi diversi o uno con condizioni all’interno come l’esempio precedente di name, dobbiamo per forza definire delle variabili di classe con il rischio innanzitutto di name overriding e in secondo luogo di rendere visibili delle proprietà che preferiremmo rimanessero nascoste all’utente.

Nell’esempio precedente infatti abbiamo voluto mettere a disposizione dell’utente un semplice metodo per manipolare la proprietà name ma per fare ciò abbiamo dovuto creare una proprietà _name di supporto per salvare e leggere il valore, rendendo a questo punto superfluo il metodo stesso.

Per situazioni del genere sicuramente una soluzione migliore potrebbe essere quella di definire all’interno della funzione Person stessa metodi e variabili di supporto nascoste, a patto di accettare un uso maggiore di memoria.

function Person () {
  var name;
  this.name = function (value) {
    if (value) name = value;
    else return name;
  }
}

var p = new Person();
p.name("John");
p.name(); // "John"
p.name; // function ...