La richiesta fantasma

Listato 21. La funzione caricaXML() con time-out

function caricaXML(link) {
  var  
    ajax = assegnaXMLHttpRequest(),
    elemento = prendiElementoDaId("contenuto-dinamico"),
    usaLink = true,

    // variabili di controllo del tempo
  
    // data di inizio interazione
    dataChiamata = new Date(),
    // tempo in millisecondi dell'inizio
    inizioChiamata = dataChiamata.getTime(),
    // secondi di attesa prima di fermare l'interazione
    massimaAttesa = 5,
    // variabile cui assegnare la funzione di verifica
    verificaTempoTrascorso;

  if(ajax) {
    usaLink = false;

    // parametro fittizio all'elemento link
    // per evitare un doppio click
    if(!link.clicked) {

      // se il parametro è risultato undefined o false
      // entriamo e gli assegnamo true
      link.clicked = true;

      // NOTA. Qualora l'elemento dovesse essere parte di un form si potrebbe
      // sfruttare il parametro "disabled", assegnandolo solo quando necessario.

      // effettuiamo la chiamata sul parametro href
      ajax.open("get", link.href, true);
      ajax.setRequestHeader("connection", "close");
      
      ajax.onreadystatechange = function() {

        // se la richiesta è già stata completata
        if(ajax.readyState === readyState.COMPLETATO) {
          // annulliamo la funzione di verifica tempo
          verificaTempoTrascorso = function(){};

          // e continuiamo con i normali controlli
          if(statusText[ajax.status] === "OK") {
            if(ajax.responseXML)
              elemento.innerHTML = parsaXml(ajax.responseXML);
            else
              elemento.innerHTML =
                "L'XML restituito dalla richiesta non è valido.<br />" +
                ajax.responseText.split('<').join("<").split('>').join(">");
          }
          else
            elemento.innerHTML =
              "Impossibile effettuare l'operazione richiesta.<br />" +
              "Errore riscontrato: " + statusText[ajax.status];

          // se il link non dovesse esser sovrascritto, come invece accade in questo esempio,
          // è importante ricordarsi di riabilitarlo reimpostando il parametro fittizio
          // Esempio: link.clicked = false;
        }

        // se la richiesta non è stata ancora ultimata
        // è possibile sfruttare la variabile massimaAttesa
        // per verificare se il controllo sul tempo trascorso
        // sia stato creato o meno.
        // Essendo tale valore un intero rappresentante i secondi
        // ma non essendo ancora stato riassegnato nel corrispettivo
        // in millesimi, questo else if può garantire che
        // il codice al suo interno verrà eseguito una sola volta
        else if(massimaAttesa < 1000) {           // conversione di massimaAttesain millisecondi
          massimaAttesa = massimaAttesa * 1000;

          // il controllo sul tempo trascorso deve essere
          // asincrono a questa funzione poichè non è detto
          // che il cambio di stato della richiesta
          // venga effettuato in tempi utili.
          // Una funzione apposita per la verifica
          // è la soluzione più indicata
          verificaTempoTrascorso = function() {

            // ogni chiamata asincrona a questa funzione
            // dovrà verificare la durata dell'interazione
            // è necessario quindi ridichiarare la variabile
            // al fine di ottenere il nuovo oggetto Date
            dataChiamata = new Date();

            // Se il tempo trascorso è maggiore della
            // massima attesa ...
            if((dataChiamata.getTime() - inizioChiamata) > massimaAttesa) {

              // ... interrompiamo la richiesta ed
              // informarmiamo l'utente di quanto avvenuto.

              // Quindi riassegnamo onreadystatechange ad una
              // funzione vuota, poichè quest'evento sarà
              // sollevato chiamando il metodo abort()
              ajax.onreadystatechange = function(){return;};

              // è possibile a questo punto richiamare il metodo abort
              // ed annullare le operazioni dell'oggetto XMLHttpRequest
              ajax.abort();

              // creiamo un elemento per avvertire l'utente
              // del fallimento della richiesta da aggiungere
              // a quello predisposto per mostrare il risultato.
              // Usiamo il metodo createElement() del document e
              // non innerHTML,che potrebbe riscrivere il link selezionato
              // annullando l'assegnazione del parametro fittizio.
              // Avendo annullato l'utilità dell'oggetto XMLHttpRequest
              // è possibile anche riciclare la variabile 'ajax'.
              ajax = document.createElement("p");
              ajax.innerHTML =
                 "Spiacente, richiesta fallita.<br />" +
                 "La prego di ritentare tra qualche istante.";

              elemento.appendChild(ajax);
       
       
              // è possibile ripristinare il parametro fittizio del link
              // su 'false' sia subito che con qualche istante di latenza,
              // Infatti l'attuale situazione può essere generata dalla
              // risposta lenta di un server sovraccarico e qualche attimo
              // di tranquillità in più non guasta.
              // Tuttavia per semplificare il codice ripristiniamo il link qui.
              link.clicked = false;
            }

            // se invece il tempo è inferiore al timeout
            else
              // si richiama questa stessa funzione, con un tempo
              // che non dovrà essere ne alto ne troppo basso.
              setTimeout(verificaTempoTrascorso, 100);
          };

          // definita la funzione non resta che avviarla
          verificaTempoTrascorso();
        };
      };
      ajax.send(null);
    };
  };
  return usaLink;
};