JavaScript passo passo

Un esempio di cifratore JavaScript

Questo è un esempio di cifratore realizzato in JavaScript. Il criterio di realizzazione è molto semplice; l'utente digita un codice di cifratura a suo piacimento, in base al quale verrà definito un apposito alfabeto di cifratura attraverso cui avverrà la "criptazione" del testo. Il codice dovrà rispettare le seguenti condizioni: dovrà essere composto di sole lettere, non importa se maiuscole o minuscole, non potrà quindi comprendere spazi o altri simboli grafici quali punti, virgole, etc. Le lettere del codice dovranno essere tutte diverse tra loro. Una stessa lettera, quindi, non potrà ripetersi. Per esempio: la parola "casa" non sarebbe un codice valido perché la lettera "a" si ripete per due volte. La parola "caso", invece, sarebbe accettata perché composta di quattro lettere diverse. Ovviamente il codice può anche essere una sequenza di lettere indefinita priva di qualsiasi significato, purché rispetti le regole enunciate.

Qui sotto viene mostrato il listato del codice dello script con i relativi commenti. Per eseguire lo script premere il pulsante appena sotto il listato.

/*dichiarazione delle variabili globali; i due array "alfabeto" e "alfabeto_Cifrato" vengono riempiti rispettivamente con le 26 lettere dell'alfabeto e con le lettere del codice, piú le lettere rimanenti copiate in ordine inverso.*/

var alfabeto=new Array(26), alfabeto_Cifrato=new Array(26), codice, codice_Errato, testo;

function esegui()
{

//Se il campo del testo è vuoto viene visualizzato un messaggio d'errore.

   if (!document.form.testo.value) {
     alert('Digitare prima il testo da cifrare.');
     document.form.testo.focus();
   }

/*Analogamente, se il campo del codice è vuoto viene visualizzato un altro messaggio d'errore.*/

   else if (!document.form.codice.value) {
     alert('Digitare il codice di cifratura.');
     document.form.codice.focus();
   }

/*Se la variabile "codice", che contiene la stringa del codice eventualmente già digitato dall'utente, è diversa dal campo del codice, viene aggiornata con la stringa del nuovo codice convertita in lettere minuscole.*/

   else {
      document.form.codice.value=document.form.codice.value.toLowerCase();
       if (codice!=document.form.codice.value) {
         codice=document.form.codice.value;

/*Tramite l'utilizzo dell'istruzione di controllo switch viene analizzato il valore restituito dalla funzione controlla_Codice(). Tale funzione può restituire tre valori interi: 0 se il codice è corretto, 1 se vi sono simboli diversi da lettere, 2 se una lettera è presente piú di una volta. Questa differenziazione del valore restituito permette di visualizzare due messaggi d'errore appropriati al tipo di errore commesso. L'istruzione return senza argomenti causa l'interruzione dell'esecuzione dello script.*/

         switch (controlla_Codice()) {
            case 0:
               break;
            case 1:
               alert('Codice non valido:' + '\n' + 'I caratteri devono essere composti da sole lettere.');
               document.form.codice.select();
               return;
            case 2:
               alert('Codice non valido:' + '\n' + 'Una stessa lettera non deve comparire piú di una volta.');
               document.form.codice.select();
               return;
         }

/*Se la funzione di controllo restituisce valore 0 lo script può proseguire l'esecuzione chiamando la funzione di riempimento degli array; il codice è valido.*/

         riempi_Array();
     }

/*La variabile booleana "codice_Errato" serve per non ripetere controlli inutili; se tale variabile globale viene impostata a "true" dalla funzione controlla_Codice vuol dire che il codice digitato precedentemente non era valido. Se l'utente proverà nuovamente a eseguire il programma senza cambiare il codice, grazie al controllo booleano su questa variabile, sarà possibile visualizzare subito un messaggio d'errore senza chiamare inutilmente la funzione di controllo del codice.*/

     else if (codice_Errato) {
       alert('Digitare un nuovo codice.');
       document.form.codice.select();
       return;
     }

/*Se tutte le condizioni vengono soddisfatte viene effettuato il controllo di quale opzione è stata selezionata; se l'opzione scelta è cifra viene chiamata la funzione di cifratura altrimenti quella di decifratura. checked è una proprietà dell'oggetto Radio, mentre opzioni[] è un array predefinito che prende il nome assegnato all'elemento.*/

     if (document.form.opzioni[0].checked) {
       cifra();
     }
     else {
       decifra()
     }
   }
}

function controlla_Codice()
{

/*Il primo ciclo for scorre tutti i caratteri del codice, controllando che siano tutte lettere. Il metodo charCodeAt() restituisce un numero intero corrispondente al codice ASCII del carattere passato come argomento. Se durante l'esame del codice vengono rilevati simboli diversi da lettere, la funzione imposta la variabile codice_Errato a true e restituisce il valore di 1, corrispondente a un messaggio d'errore appropriato che verrà visualizzato dalla funzione chiamante esegui().*/

   for (var i=0; i<codice.length; i++) {
      if (codice.charCodeAt(i)<97 || codice.charCodeAt(i)>122) {
        codice_Errato=true;
        return 1;
      }

/*Il ciclo piú interno scorre anch'esso, partendo da un carattere piú avanti rispetto a quello esterno, la stringa del codice, verificando che non vi siano lettere uguali. Poiché il ciclo piú interno scorre piú velocemente di quello esterno, ogni singolo carattere del codice verrà confrontato con tutti i caratteri successivi. L'istruzione return 2 restituisce il valore corrispondente al secondo messaggio d'errore alla funzione chiamante esegui().*/

      for (var j=i+1; j<codice.length; j++) {
         if (codice.substr(i,1)==codice.substr(j,1)) {
           codice_Errato=true;
           return 2;
         }
      }
   }
   codice_Errato=false;
   return 0;
}

function riempi_Array()
{
   var lunghezza_Codice=codice.length;

/*Il primo ciclo for riempie l'array alfabeto[] con le 26 lettere dell'alfabeto. Il metodo fromCharCode() restituisce il carattere corrispondente al numero intero passato come argomento. La tabella di corrispondenza è quella del codice ASCII.*/

   for (var i=0, lettera=97; i<=25; i++, lettera++) alfabeto[i]=String.fromCharCode(lettera);

/*Il secondo ciclo riempie i primi n elementi dell'array alfabeto_Cifrato[] con le lettere del codice digitato dall'utente.*/

   for (i=0; i<=codice.length; i++) alfabeto_Cifrato[i]=codice.substr(i,1);

/*Successivamente l'array alfabeto_Cifrato[] viene riempito con le lettere rimanenti copiate in ordine inverso. Il ciclo for esterno scorre al contrario le lettere dell'alfabeto. Quello interno scorre le lettere del codice. L'istruzione if contenuta all' interno del secondo ciclo controlla se vi è corrispondenza tra le lettere nei due array. Se la trova, il ciclo si interrompe perché significa che è stata trovata una lettera del codice. È dunque necessario escluderla dal confronto e continuare per trovare quelle mancanti.*/

   for (i=25; i>=0; i--) {
      for (var j=0; j<=lunghezza_Codice; j++) {
         if (alfabeto[i]==alfabeto_Cifrato[j]) break;
      }

/*Se una lettera non è stata ancora inclusa nell'array alfabeto_Cifrato[] viene aggiunta partendo dal primo elemento libero dell'array. Questo viene ottenuto utilizzando la variabile lunghezza_Codice come indice dell'array alfabeto_Cifrato[]. La variabile lunghezza_Codice contiene inizialmente il valore della lunghezza del codice digitato, incrementato di volta in volta che nuovi caratteri vengono aggiunte all'array alfabeto_Cifrato[].*/

      if (alfabeto[i]!=alfabeto_Cifrato[j]) {
        alfabeto_Cifrato[lunghezza_Codice]=alfabeto[i];
        lunghezza_Codice++;
      }
   }
}

function cifra()
{

/*Alla variabile testo viene assegnata la stringa del testo digitato e viene usata solo per comodità, al fine di evitare di ripetere ogni volta document.form.testo.value. La variabile testo_Cifrato, invece, viene di volta in volta aggiornata con i caratteri cifrati che dovranno essere visualizzati al termine del processo di cifratura.*/

   var testo=document.form.testo.value, testo_Cifrato='';

/*Il primo ciclo for scorre il testo da cifrare carattere per carattere. Il secondo scorre invece i 26 elementi dell'array alfabeto[], per confrontare il contenuto di questo con il testo.*/

   for (var i=0; i<=testo.length; i++) {
      for (var j=0; j<=25; j++) {

/*Si verifica se il singolo carattere è stato digitato minuscolo o maiuscolo, in modo da conservarne tale caratteristica anche nella cifratura. Se il codice ASCII del carattere è compreso tra 65 e 90, estremi inclusi, significa che è una lettera maiuscola, nel qual caso viene convertita ricorrendo al metodo toUpperCase() che converte un carattere in maiuscolo; altrimenti se è compreso tra 97 e 122 vuol dire che è minuscola e viene cifrata cosí com'è.*/

         if (testo.charCodeAt(i)>=65 && testo.charCodeAt(i)<=90) {
           if (testo.substr(i,1).toLowerCase()==alfabeto[j]) {
              testo_Cifrato+=alfabeto_Cifrato[j].toUpperCase();
              break;
           }
         }
         else if (testo.charCodeAt(i)>=97 && testo.charCodeAt(i)<=122) {
            if (testo.substr(i,1).toLowerCase()==alfabeto[j]) {
              testo_Cifrato+=alfabeto_Cifrato[j];
              break;
            }
         }

/*Se il carattere non viene rilevato dai due controlli precedenti significa che non è una lettera e viene ricopiato cosí com'è stato digitato.*/

         else {
            testo_Cifrato+=testo.substr(i,1);
            break;
         }
       }
     }
     document.form.testo.value='';
     document.form.testo.value=testo_Cifrato;
}

function decifra() {

/*La funzione decifra() è esattamente speculare alla funzione cifra. Cambia l'array di riferimento, che è alfabeto_Cifrato[] e il nome della variabile che conterrà la stringa del testo decifrato, questo, per sola chiarezza. Si sarebbero anche potute accorpare le due funzioni in una sola ma si è scelto di crearne due per meglio suddividere il codice e renderlo piú leggibile.*/

   var testo=document.form.testo.value, testo_Decifrato='';
   for (var i=0; i<=testo.length; i++) {
      for (var j=0; j<=25; j++) {
         if (testo.charCodeAt(i)>=65 && testo.charCodeAt(i)<=90) {
           if (testo.substr(i,1).toLowerCase()==alfabeto_Cifrato[j]) {
              testo_Decifrato+=alfabeto[j].toUpperCase();
              break;
           }
         }
         else if (testo.charCodeAt(i)>=97 && testo.charCodeAt(i)<=122) {
            if (testo.substr(i,1).toLowerCase()==alfabeto_Cifrato[j]) {
              testo_Decifrato+=alfabeto[j];
              break;
            }
         }
         else {
            testo_Decifrato+=testo.substr(i,1);
            break;
         }
       }
     }
     document.form.testo.value='';
     document.form.testo.value=testo_Decifrato;
}



Nota: l'algoritmo di cifratura utilizzato per quest'esempio è reperibile nel libro:
"Introduzione alla programmazione in Visual Basic for Applications" di Claudio Fornaro, CELID editore.


chiudi la finestra| Home