Skillbook Logo
foto profilo

Skill Factory

Tutte le categorie


Impariamo a programmare con JavaScript - Lezione 13

Gino Visciano | Skill Factory - 08/09/2017 23:20:20 | in Tutorials

Benvenuti alla tredicesima lezione, nella lezione precedente abbiamo creato un Server Web Statico con il Framework Node.js, adesso creiamo un Server Web Dinamico che gestisce richieste di tipo GET.

Un Server Web Statico carica le pagine HTML, richieste dal Browser, direttamente dal disco e non gestisce parametri (dati).
Le pagine HTML caricate dal disco del Server Web  sono sempre uguali, quindi vengono chiamate pagine HTML statiche. 

Un Server Web Dinamico  fornisce ai Browser  sia pagine HTML statiche, sia pagine HTML dinamiche.
Una  pagine HTML dinamica viene creata ogni volta dal  Server Web utilizzando un linguaggio di programmazione. Di solito la pagina viene formattata in base ai parametri (dati) inviati dal Browser
linguaggi di programmazione più usati dai Server Web Dinamici per creare pagine HTML dinamiche sono: PHP, Java, C# e oggi con Node.js anche JavaScript.


Come inviare parametri ad un Server Web Dinamico

I parametri sono dati che il Browser trasmette al Server Web per richiedere o fornire informazioni, sono strutturati nel modo seguente:

nomeparametro1=valoreparametro1&nomeparametro2=valoreparametro2&nomeparametro3=valoreparametro3

La "&" serve a separare i parametri tra loro.

Esempio 1

Se i dati da trasmettere al Server Web sono:

nome=Marco
cognome=Bianchi
eta=30

il Browser li organizza nel modo seguente:

nome=Marco&cognome=Bianchi&eta=30

Per trasmettere i parametri  al Server Web, il Browser usa il protocollo HTTP e l'oggetto request.

Le request possono essere di tipo GET oppure di tipo POST, la differenza dipende dalla posizione in cui i parametri vengono inseriti nella request.

In una request di tipo GET i parametri vengono inseriti nella prima riga, quella che corrisponde all'URL, come mostra lo schema seguente:

GET /?a=1&b=2 HTTP/1.1
Host: localhost    
User-Agent: my browser details
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8    
Accept-Language: en-gb,en;q=0.5    
Accept-Encoding: gzip, deflate    
Connection: keep-alive

Per questo tipo di request i parametri inviati al Server Web sono sempre visibili anche nell'URL della barra degli indirizzi del Browser:

http://localhost:8080/replica?nome=Marco&cognome=Bianchi&eta=30.

Quindi una request di tipo GET  è meno sicura.

In HTML le richieste di tipo GET si possono creare in due modi:

1) utilizzando un tag <a> che permette di impostare un link;
2) utilizzando un tag <form>, impostando l'attributo method con il valore get.


In una request di tipo POST, i parametri vengono inseriti alla fine, come mostra lo schema seguente:

POST / HTTP/1.1
Host: localhost   
User-Agent: my browser details
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8    
Accept-Language: en-gb,en;q=0.5    
Accept-Encoding: gzip, deflate    
Connection: keep-alive
Content-Type: application/x-www-form-urlencoded
Content-Length: 7
a=1&b=2

Per questo tipo di request i parametri inviati al Server Web non sono visibili nell'URL della barra degli indirizzi del Browser:: 

http://localhost:8080/replica.

Quindi una request di tipo POST è più sicura.

Le richieste di tipo POST si possono creare solo con un tag <form>, impostando l'attributo method con il valore post.

 

Esempio 2

Trasmettere le informazioni seguenti, alla risorsa replica, utilizzando un link in una pagina HTML:

nome=Marco
cognome=Bianchi
eta=30
email=marco.bianchi@mail.com

Ricordate che le request generate da un link sono sempre di tipo GET.

Per eseguire l'operazione richiesta serve il comando HTML seguente:

<a href="replica?nome=Marco&cognome=Bianchi&eta=30&email=marco.bianchi@mail.com">
clicca qui per trasmettere i parametri</a>

Cliccando sul link:

clicca qui per trasmettere i parametri

viene inviata alla risorsa replica del Server Web una request di tipo GET, con i parametri richiesti.

I parametri inviati sono visibili anche nell'URL generato dal Browser per richiamare la risorsa replica, come mostra l'esempio eguente:

http://localhost:8090/replica?nome=Marco&cognome=Bianchi&eta=30&email=marco.bianchi@mail .com

 

Esempio 3

Creare la Scheda seguente ed inviare i dati alla risorsa replica, con una request di tipo GET:

Per creare la Scheda serve il codice HTML seguente:

<div style="background-color:#7aa45e;padding:10px;left:50px;top:50px;width:300px;height:150px;border:2px solid #000000;border-radius:6px">
<form name="0.1_scheda" method="get" action="replica" >  
<table>
<tr><td>Nome:</td><td><input type="text" name="nome"></td></tr>
<tr><td>Cognome:</td><td><input type="text" name="cognome"></td></tr>
<tr><td>Età:</td><td><input type="text" name="eta"></td></tr>  
<tr><td>e-mail:</td><td><input type="text" name="email"></td></tr>
<tr><td><input type="submit" value="SALVA"></td><td><input type="reset" value="RESET"></td></tr>
</table>
</form>
</div>

 

Come leggere i parametri inviati dal Browser con una request di tipo GET

I Parametri, indipendentemente dal tipo, arrivano al Server Web come stringhe, se necessario possono essere convertiti nel formato richiesto dopo la lettuara.

Per leggere i parametri trasmessi dal Browser, con una request di tipo GET, bisogna creare un oggetto di tipo querystring.

L'oggetto querystring contiene  attributi di tipo stringa con lo stesso nome e gli stessi valori dei parametri della request.

Esempio 4

Leggere i parametri dalla request di tipo GET inviata alla risorsa replica:

Per eseguire l'operazione richiesta serve Il comando JavaScript seguente:

var queryData = url.parse(request.url, true).query

Nell'oggetto queryData di tipo querystring sono presenti tre attributi di tipo stringa, con lo stesso nome e gli stessi valori dei parametri trasmessi dal Browser:

queryData.nome
queryData.cognome
queryData.eta
queryData.email
 

che contengono rispettivamente i valori: Marco, Bianchi, 30, marco.bianchi@mail.com.

 

 

Come creare una pagina HTML con JavaScript

Per creare una pagina HTML con JavaScript è molto semplice, basta scriverla nella response con il metodo write, come mostra il codice seguente:

response.write("<html>");
response.write("<head>");
response.write("</head>");
response.write("<body>");
response.write("<h1>Hello World</h1>");
response.write("</body>");
response.write("</html>");
// Invia la response con la pagina HTML al Browser che la interpreta e la visualizza
response.end();

 

Come creare un Server Web Dinamico con Node.js

Come abbiamo già visto nella lezione precedente, per creare un Server Web (HTTP) con JavaScript  bisogna eseguire la funzione createServer(... del modulo http, come mostra il codice seguente:

// Crea il Server Web Dinamico
var server = http.createServer(function(request, response){ ...
// Imposta il Server in ascolto sulla porta 8090

server.listen(8090, function() {
console.log("Listening...8090");
});

Un Server Web Dinamico prima di tutto deve garantire le funzionalità di un Server Web Statico, per permettere anche la visualizzazione di pagine HTML statiche.
Il codice JavaScript seguente serve per implementare questa funzionalità:

fs.readFile(__dirname + path, function(error, data){
            if (error){
               send404(response);
            }
            else {
                response.writeHead(200, {"Content-Type": "text/html"});
                response.write(data, "utf8");
            }
            response.end();
});
 

 

Il codice JavaScript seguente serve per implementare le funzionalità del Server Web Dinamico per la gestione di request di tipo GET:

if (request.method == 'GET'){
        var body='';
        var queryData;
        request.on('end',function(){
            queryData = url.parse(request.url, true).query;
            if (queryData.nome==null || queryData.cognome==null || queryData.eta==null || queryData.email==null) {
              // Invia il messaggio risposta errata!!!
             send500(response);
            } else {
            response.write("<html>");
            response.write("<head>");
            response.write("</head>");
            response.write("<body>");
            response.write("<table>");
            response.write("<tr><td>Nome:</td><td>queryData.nome</td></tr>");
            response.write("<tr><td>Cognome:</td><td>queryData.cognome</td></tr>");
            response.write("<tr><td>Età:</td><td>queryData.eta</td></tr>");
            response.write("<tr><td>Mail:</td><td>queryData.email</td></tr>");
            response.write("</table>");
            response.write("</body>");
            response.write("</html>");
            // Invia la response con la pagina HTML al Browser che la interpreta e la visualizza
            response.end();
            };
        });

 

 

 

Implementiamo e Testiamo il ServerWeb Statico

Gli steps seguenti mostrano come implementare il Server Web Dinamico di tipo GET:

1) Aprite il prompt del vostro Sistema Operativo e create la directory ServerWebDinamico;
2) Copiate il codice del programma JavaScript (Appendice) StartServerWebDinamicoGet nel blocco note e salvatelo nella directory ServerWebDinamico con il nome StartServerWebDinamicoGet.js;
3) Nella directory ServerWebDinamico create la sottodirectory public;
4) Copiate il codice della pagina Html (Appendice) index nel blocco note e salvatelo nella sottodirectory public con il nome index.html;
5) Copiate il codice della pagina Html (Appendice) form nel blocco note e salvatelo nella sottodirectory public con il nome form.html;

node StartServerWebDinamicoGet

Se il Server Web non parte, installate i moduli richiesti, ad esempio:

npm install querystring.

 

A P P E N D I C E


StartServerWebDinamicoGet

var http = require('http');
var url = require('url');
var fs = require('fs');
var qs = require('querystring');
var server = http.createServer(function(request, response){
    var path = url.parse(request.url).pathname;
    switch(path){

        // Caso attivato se la risorsa richiesta è /
        case '/':
        fs.readFile("public" + '/index.html', function(error, data){
            if (error){
               send404(response);
            }
            else {
                response.writeHead(200, {"Content-Type": "text/html"});
                response.write(data, "utf8");
            }
            response.end();
        });
        break;

        // Caso attivato se la risorsa richiesta è form.html
        case '/form.html':
        fs.readFile("public" + path, function(error, data){
            if (error){
               send404(response);
            }
            else {
                response.writeHead(200, {"Content-Type": "text/html"});
                response.write(data, "utf8");
            }
            response.end();
        });
        break;

        // Caso attivato se la risorsa richiesta è replica
        case '/replica':
       if (request.method == 'GET'){
           var body='';
           var queryData;
               queryData = url.parse(request.url, true).query;
               if (queryData.nome==null || queryData.cognome==null || queryData.eta==null || queryData.email==null) {
                    // Invia il messaggio risposta errata!!!
                    send500(response);
               } else {
                 // Scrittura pagina HTML nell'oggetto response
                 response.write("<html>");
                 response.write("<head>");
                 response.write("<meta charset='UTF-8' />");
                 response.write("</head>");
                 response.write("<body>");
                 response.write("<table>");
                 response.write("<tr><td>Nome:</td><td>"+queryData.nome+"</td></tr>");
                 response.write("<tr><td>Cognome:</td><td>"+queryData.cognome+"</td></tr>");
                 response.write("<tr><td>Età:</td><td>"+queryData.eta+"</td></tr>");
                 response.write("<tr><td>Mail:</td><td>"+queryData.email+"</td></tr>");
                 response.write("</table>");
                 response.write("<a href='/'>Torna alla home</a>");
                 response.write("</body>");
                 response.write("</html>");
                 // Invia la response con la pagina HTML al Browser che la interpreta e la visualizza
                 response.end();
               }
              
         }        // Se il path non corrisponde a nessuno dei casi previsti viene visualizzato un messaggio d'errore
         break;
        default:
        send404(response);
        break;
    }
});

// Imposta il Server in ascolto sulla porta 8090
server.listen(8090, function() {
console.log("Listening...8090");
});

// Funzione per la gestione degli errori 404
function send404(response) {
    response.writeHead(404, {'Content-Type': 'text/plain'});
    // Scrive nella response il messaggio "Error 404: not found"
    response.write("Error 404: not found");
    // Invia la risposta al Client
    response.end();
}

// Funzione per la gestione degli errori 500
function send500(response) {
    response.writeHead(500, {'Content-Type': 'text/plain'});
    // Scrive nella response il messaggio "Error 500: internal server error"
    response.write("Error 500: internal server error");
    // Invia la risposta al Client
    response.end();
}

index

<html>
    <head>
        <meta charset="UTF-8" />
        <title>Home Page</title>
    </head>
<body>
<h4>Scegli il metodo di invio dati</h4>
<a href="replica?nome=Mario&cognome=Bianchi&eta=30&email=marco.bianchi@mail.com">Utilizza il metodo GET</a></br>
<a href="form.html">Utilizza il Form</a>
</body>
</html>


form

<html>
<head>
        <meta charset="UTF-8" />
</head>
<body>
<div>

<div style="background-color:#7aa45e;padding:10px;left:50px;top:50px;width:300px;height:150px;border:2px solid #000000;border-radius:6px">
<form name="0.1_scheda" method="get" action="replica" >  
<table>
<tr><td>Nome:</td><td><input type="text" name="nome"></td></tr>
<tr><td>Cognome:</td><td><input type="text" name="cognome"></td></tr>
<tr><td>Età:</td><td><input type="text" name="eta"></td></tr>  
<tr><td>e-mail:</td><td><input type="text" name="email"></td></tr>
<tr><td><input type="submit" value="SALVA"></td><td><input type="reset" value="RESET"></td></tr>
</table>
</form>
</div>

</div>
</html>
<a href="/">Torna alla home</a>
</body></html>


Arrivederci alla prossima lezione!!!


<< Lezione precedente


T U T O R I A L S    S U G G E R I T I


Share Button

Impariamo a programmare con JavaScript - Lezione 12

Gino Visciano | Skill Factory - 20/07/2017 15:02:36 | in Tutorials

Benvenuti alla dodicesima lezione, in questa lezione costruiamo un Server Web statico con il Framework Node.js

Un Server Web statico è un servizio che permette di richiamare da un Browser (lato Client) pagine HTML statiche.
Le pagine HTML statiche sono le classiche pagine Web, create dai programmatori front-end con il linguaggio Html e salvate sul disco del Server.
Ricordate che le pagine HTML dinamiche sono diverse da quelle statiche, perché non esistono, vengono create ogni volta dal Server Web attraverso l'uso di linguaggi di tipo Back-End come: PHP, Java ed oggi grazie a Node.js anche  JavaScript.

Quando il  Client invia una request con l'URL (indirizzo web) di una pagina HTML  statica, il Server di destinazine la carica dal disco e gliela  invia attraverso una response.

Lo scambio delle informazione tra il Client ed il Server avviene grazie al protocollo applicativo HTTP, che regola e gestisce tutte le fasi del "Ciclo di vita di una richiesta", vedi immagine seguente.

CICLO DI VITA DI UNA RICHIESTA

 

Un Server Web è sempre identificato da un indirizzo di PORTA ed un indirizzo IP, nel nostro esempio usiamo come PORTA l'indirizzo 8090 e come IP l'indirizzo locale del computer 127.0.0.1 (chiamato anche localhost), perché sia il Client che il Server sono implementati sullo stesso computer.

 

Come creare il Server Web, con Node.js

Per creare il Server Web, dobbiamo prima di tutto caricare i moduli che permettono di gestire:

  • il protocollo applicativo HTTP
  •  il FIle System
  • il path per gestire file e directory
  • il mime (Multimedia Internet Mail Extensions) che imposta il tipo di contenuto restituito:

    text/html Documento HTML
    text/plain Documento di testo non formattato
    text/xml Documento XML
    image/jpeg Immagine di formato JPEG

Il codice JavaScript seguente permette di caricare i moduli che servono:
 

var http = require("http");
var fs = require("fs");d
var path = require("path");
var mime = require("mime");


Non dimenticate che per caricare i moduli in JavaScript devono già essere stati installati nella directory del progetto con il comando:

npm install nome_modulo

Per visualizzare l'elenco dei moduli installati usate il comando:

npm ls

aggiungete al comando l'opzione -g se volete vedere tutti i pacchetti installati e non solo quelli della directory di lavoro corrente.

Per usare il comando npm dovete accedere al prompt del vostro Sistema Operativo e spostarvi nella directory di lavoro dove state creando il progetto.

Per creare il Server Web usiamo la funzione createServer che appartiene al modulo http, come mostra il codice seguente:

 

var server = http.createServer(function(request, response) {

// Inserire il codice di gestione del Server Web ...

});

 

L'argomento della funzione http.createServer è una funzione anonima che ha per argomenti gli oggeti request e response, che permettono di gestire le informazioni inviate dal Client  ed impostare la risposta del Server (Ciclo di vita della richiesta).

L'oggetto server è il riferimento che dobbiamo usare per configurare e gestire il Server Web che abbiamo appena creato. Con il codice seguente impostiamo la PORTA e l'indirizzo IP su cui è in ascolto.

 

server.listen(8090, "127.0.0.1", function() {
    console.log("Listening port: 8090 ...");
});


Il terzo argomento del metodo server.listen è una funzione anonima di collback che attraverso il messaggio "Listening port: 8090 ..." visualizza la porta su cui è in ascolto il Server Web.
Una funzione di collback  è una funzione che resta in attesa fino a quando non  si verifica un evento oppure uno stato, nel nostro esempio la funzione s'interrompe quando eseguite <ctrl> c per chiudere il Server Web da prompt.

Ecco il codice completo JavaScript per creare il Server Web:

 

var server = http.createServer(function(request, response) {

var filePath = false;

// Se nella richiesta non è stata indicata una pagina Html viene impostata quella di default
if(request.url == "/") {
   filePath = "public/index.html";
} else {

   // Aggiunge all'url il prefisso /public/, dove sono state salvate tutte le pagine Html
   filePath = "/public/" + request.url;
}

// Impostia il percorso per caricare la pagina Hml richiesta dal Client
var absPath = "./" + filePath;

// La funzione serverStatic legge la pagina Html richiesta e la invia al Client
serverStatic(response, cache, absPath);

});

server.listen(8080, "127.0.0.1", function() {
console.log("Listening port: 8090 ...");
});

 

Come rendere più performante il Server Web

Per rendere più performante il nostro Server Web creiamo un meccanismo di cache utilizzando una Collection di tipo Dizionario in cui memorizziamo le pagine Html richieste dal Client, quando viene richiesta la stessa pagina Html, invece di leggerla dal disco, che richiede più tempo, la leggiamo dalla cache.

Il codice  JavaScript seguente vi mostra come creare e gestire una Collection di tipo Dizionario:

// Dichiarazione ed inizializzazione della Collection
var cache = {};

// Inserimento di una pagina Html in cache
cache[absPath]=paginaHtml;

// absPath è il percorso assoluto della pagina Html richiesta e paginaHtml è il contenuto della pagina

// Lettura della pagina Html dalla cache
paginaHtml=cache[absPath];

// paginaHtml è il contenuto della pagina e absPath è l'indice della Collection che permette di leggere dalla cache la pagina Html richiesta

 

Come leggere la pagina Html richiesta ed inviarla al Client

La funzione serverStatic legge la pagina Html indicata nell'URL della richiesta, utilizzando il percorso absPath, se non ci sono errori la invia al Client utilizzando la funzione sendFile, altrimenti invia un messaggio d'errore attraverso la funzione send404.

function serverStatic(response, cache, absPath) {
// Controlliamo se la pagina Html richiesta è già presente in cache, in caso affermativo viene subito inviata al CLient
if (cache[absPath]) {
   // La funzione sendFile invia al Client la pagina Html richiesta leggendola dalla cache
     sendFile(response, absPath, cache[absPath]);
} else {
          // Se la pagina Html non è in cache, con la funzione exists del modulo fs, controlliamo se esiste sul disco
          fs.exists(absPath, function(exists) {
                  if (exists) {
                             // Se la pagina Html esiste, viene letta e caricata nell'oggetto data, l'oggetto err permette di capire se si sono verificati errori durante la lettura
                            fs.readFile(absPath, function(err, data) {                      
                            if (err) {
                                  // Inviamo al Client il messaggio d'Errore 404, pagina non trovata
                                 send404(response);
                           } else {
                                 // Carichiamo in cache la pagina Html letta e successivamente inviamo la pagina Html al Client
                                cache[absPath] = data;
                               sendFile(response, absPath, data);
                          }
                          }); // Chiude funzione readFile
                 } else {
                            // Se la pagina Html richiesta dal Client non esiste inviamo al Client il messaggio d'Errore 404, pagina non trovata
                            send404(response);
                 }
               }); // Chiude funzione exists
}
}

 

 

La funzione send404 imposta nell'Header della response lo stato 404, corrispondente a risorsa not found ed invia al Client il messaggio d'Errore: "Error 404: not found".

// Invia al Client il messaggio d'Errore: "Error 404: not found"

function send404(response) {
response.writeHead(404, {'Content-Type': 'text/plain'});
// Scrive nella response il messaggio "Error 404: not found"
response.write("Error 404: not found");
// Invia la risposta al Client
response.end();
}

 

La funzione sendFile imposta nell'Header della response lo stato 200, corrispondente a OK ed invia al Client la pagina Html.

// Inviamo al Client la pagina Html richiesta dal Client
function sendFile(response, filePath, fileContents) {
//  Impostiamo nell'Header della response lo stato 200, corrispondente a OK
response.writeHead(200, {"content-type": mime.lookup(path.basename(filePath))});
response.end(fileContents);
}

 

I Codici di risposta più comuni

200 OK. Il server ha fornito correttamente il contenuto nella sezione body.
301 Moved Permanently. La risorsa che abbiamo richiesto non è raggiungibile perché è stata spostata in modo permanente.
302 Found. La risorsa è raggiungibile con un altro URI indicato nel header Location. Di norma i browser eseguono la richiesta all'URI indicato in modo automatico senza interazione dell'utente.
400 Bad Request. La risorsa richiesta non è comprensibile al server.
404 Not Found. La risorsa richiesta non è stata trovata e non se ne conosce l'ubicazione. Di solito avviene quando l'URI è stato indicato in modo incorretto, oppure è stato rimosso il contenuto dal server.
500 Internal Server Error. Il server non è in grado di rispondere alla richiesta per un suo problema interno.
505 HTTP Version Not Supported. La versione di http non è supportata.

 

Implementiamo e Testiamo il ServerWeb Statico

Gli steps seguenti mostrano come implementare il Server Web Statico:

1) Aprite il prompt del vostro Sistema Operativo e create la directory ServerWebStatico;
2) Copiate il codice del programma JavaScript (Appendice) StartServerWebStatico nel blocco note e salvatelo nella directory ServerWebStatico con il nome StartServerWebStatico.js;
3) Nella directory ServerWebStatico create la sottodirectory public;
4) Copiate il codice della pagina Html (Appendice) index nel blocco note e salvatelo nella sottodirectory public con il nome index.html;
5) Copiate il codice della pagina Html (Appendice) bandieraItalia nel blocco note e salvatelo nella sottodirectory public con il nome bandieraItalia.html;
6) Copiate il codice della pagina Html (Appendice) bandieraFrancia nel blocco note e salvatelo nella sottodirectory public con il nome bandieraFrancia.html;
7) Copiate il codice della pagina Html (Appendice) bandieraBelgio nel blocco note e salvatelo nella sottodirectory public con il nome bandieraBelgio.html;
8) Avviate il ServerWebStatico con il comando:

node StartServerWebStatico

Se il Server Web non parte, installate i moduli richiesti, ad esempio:

npm install mime

 

Gli steps seguenti mostrano come testare il Server Web Statico:

1) Avviate il vostro Browser e digitate l'URL seguente:

http://localhost:8090/

deve apparire la pagina index.html:

2) Testate i 3 link del Menu Bandiere, devono apparire le pagine seguenti:

bandieraItalia.html

bandieraFrancia.html

bandieraBelgio.html

3) Digitate l'URL seguente:

http://localhost:8090/paginaNonEsiste.html

deve apparire il messaggio seguente:

Error 404: not found

 

A P P E N D I C E


StartServerWebStatico.js

var http = require("http");
var fs = require("fs");
var path = require("path");
var mime = require("mime");
var cache = {};
function send404(response) {
    response.writeHead(404, {"Content-Type": "text/plain"});
    response.write("Error 404: not found");
    response.end();
}
function sendFile(response, filePath, fileContents) {
    response.writeHead(200, {"content-type": mime.lookup(path.basename(filePath))});
    response.end(fileContents);
}
function serverStatic(response, cache, absPath) {
    if (cache[absPath]) {
        sendFile(response, absPath, cache[absPath]);
    } else {
        fs.exists(absPath, function(exists) {
            if (exists) {
                fs.readFile(absPath, function(err, data) {
                if (err) {
                send404(response);
                } else {
                cache[absPath] = data;
                sendFile(response, absPath, data);
                }
                });
            } else {
            send404(response);
            }
        });
    }
}
var server = http.createServer(function(request, response) {
    var filePath = false;

    if(request.url == "/") {
        filePath = "public/index.html";
    } else {
        filePath = "/public/" + request.url;
    }
    var absPath = "./" + filePath;
    serverStatic(response, cache, absPath);
});

server.listen(8090, "127.0.0.1", function() {
    console.log("Listening port: 8090 ...");
});


index.html

<html>
<head>
<title>Skill Factory - Impariamo a programmare con JavaScript: Lezione 12 - (Server Web Statico)</title>
</head>
<body>
<h1>Menu Bandiere</h1>
<h4>
<a href="bandieraItalia.html">1) Italia</a><br/>
<a href="bandieraFrancia.html">2) Francia</a><br/>
<a href="bandieraBelgio.html">3) Belgio</a><br/><br/>
</h4>
</body>
</html>


bandieraItalia.html

<html>
<head>
<title>Skill Factory - Impariamo a programmare con JavaScript: Lezione 12 - (Server Web Statico)</title>
</head>
<body>
<div style="width:210px;text-align: center;">
ITALIA
</div>
<div style="float:left;background-color: #009246; width:70px; height:100px; border: 1px solid #000000;" >
</div>
<div style="float:left;background-color: #ffffff; width:70px; height:100px; border: 1px solid #000000;">
</div>
<div style="float:left;background-color: #ce2b37; width:70px; height:100px; border: 1px solid #000000;">
</div>
<div style="width:210px;text-align: center;">
<a href="index.html">Torna al menu</a><br/><br/>
</div>
</body>
</html>


bandieraFrancia.html

<html>
<head>
<title>Skill Factory - Impariamo a programmare con JavaScript: Lezione 12 - (Server Web Statico)</title>
</head>
<body>
<div style="width:210px;text-align: center;">
FRANCIA
</div>
<div style="float:left;background-color: #002e7b; width:70px; height:100px; border: 1px solid #000000;" >
</div>
<div style="float:left;background-color: #ffffff; width:70px; height:100px; border: 1px solid #000000;">
</div>
<div style="float:left;background-color: #de0029; width:70px; height:100px; border: 1px solid #000000;">
</div>
<div style="width:210px;text-align: center;">
<a href="index.html">Torna al menu</a><br/><br/>
</div>
</body>
</html>


bandieraBelgio.html

<html>
<head>
<title>Skill Factory - Impariamo a programmare con JavaScript: Lezione 12 - (Server Web Statico)</title>
</head>
<body>
<div style="width:210px;text-align: center;">
BELGIO
</div>
<div style="float:left;background-color: #000000; width:70px; height:100px; border: 1px solid #000000;" >
</div>
<div style="float:left;background-color: #ffd100; width:70px; height:100px; border: 1px solid #000000;">
</div>
<div style="float:left;background-color: #e3001b; width:70px; height:100px; border: 1px solid #000000;">
</div>
<div style="width:210px;text-align: center;">
<a href="index.html">Torna al menu</a><br/><br/>
</div>
</body>
</html>


 

Arrivederci alla prossima lezione!!! 


<< Lezione precedente           Lezione successiva >>


T U T O R I A L S    S U G G E R I T I


Share Button

Impariamo a programmare con JavaScript - Lezione 11

Gino Visciano | Skill Factory - 16/07/2017 14:42:51 | in Tutorials

Benvenuti all'undicesima lezione, da questa lezione in poi iniziamo  a lavorare con Node.js, che permette di creare Web Application utilizzando il linguaggio JavaScript, sia lato client, sia lato server.

Node.js è un framework molto efficace perché, grazie al linguaggio JavaScript, comunica in modo asincrono, cioè può eseguire altre istruzioni senza dover attendere che l'istruzione precedente sia finita.

L'Html e Java, a differenza di JavaScript, comunicano  in modo sicrono, Java per eseguire più istruzioni parallelamente deve far uso dei Thread, molto complessi da gestire.

Node.js non è un Web Server, ma permette di implementarlo attraverso un'applicazione JavaScript che gestisce il protocollo applicativo HTTP ed il ciclo di vita delle richieste (request) e delle risposte (response).

Per i non esperti di Web, le richieste (request) contengono i parametri inviati dal Browser al Server, si genera una richiesta ogni volta che fate un submit oppure cliccate su un link.

Le risposte (response) sono i pacchetti inviati dal Server al Browser, possono contenere una pagina Html oppure dati in formato Testo, XML o JSON.

Il protocollo applicativo HTTP permette di gestire lo scambio dei pacchetti tra il Client ed il Server, è un'attività trasparente al programmatore, ma fondamentale per la comunicazione Web, nel formato HTTPS questo protocollo permette di gestire la trasmissione dei dati in modo sicuro (SSL).

Per scaricare Node.js dobbiamo collegarci al sito https://nodejs.org/it/ , selezionare la voce di menu download, e scaricare il file d'installazione corrispondente alla nostra piattaforma di lavoro, come mostra l'immagine seguente:

 

Una volta scaricato il pacchetto installabile eseguitelo, durante l’installazione vi verrà chiesto se installare anche npm, accettate, completata l’installazione, riavviate il vostro sistema.

Per verificare se Node.js è stato installato correttamente, aprite il prompt del vostro sistema operativo ed eseguite i comandi seguenti:

node -v

npm -v

se l'installazione è stata fatta correttamente, dovrebbero apparire le versioni di node e di npm installate.

Il REPL (Read-Eval-Print-Loop) è uno strumento di  Node.js per la programmazione interattiva, che permette di scrivere una operazione JavaScript ed eseguirla.

Per avviare il REPL,  aprite il prompt del vostro sistema operativo ed eseguite il comando node.

Per uscire dall'ambiente REPL,  potete scrivere il comando .exit (attenzione il punto fa parte del comando), come mostra l'esempio seguente:

 

Di seguito vi indico i principali comandi di REPL:

.help = visualizza la lista dei comandi di REPL.
.ckear = resetta la sessione di lavoro corrente di REPL.
.save ./percorsoenomefile.js = permette di salvare il programma JavaScript corrente .
.load ./percorsoenomefile.js = permette di caricare il programma JavaScript richiesto.
.editor = abilita l'editor  per scrivere a tutto schermo un programma JavaScript, usare <ctrl> D per uscire dall'editor ed eseguire il programma, <ctrl> C per annullare.

Esempio 1

Esempio 2

 

Arrivederci alla prossima lezione!!!

 


<< Lezione precedente           Lezione successiva >>


T U T O R I A L S    S U G G E R I T I


Share Button

Impariamo a programmare con JavaScript - Lezione 10

Gino Visciano | Skill Factory - 11/07/2017 22:57:03 | in Tutorials

Benvenuti alla decima lezione, in questa lezione vediamo come si gestisce la validazione dei dati inseriti in un Form Html.
La validazione lato Client viene eseguita dal Browser utilizzando il linguaggio JavaScript, questo tipo di controllo serve per evitare di delegare unicamente al Server la gestione degli errori.
Comunque per essere più sicuri  e rendere più performante la vostra applicazione vi consiglio di eseguire il controllo degli errori sia lato Client, sia lato Server.

Creazione del Form "Scheda"

Il Form "scheda" serve per l'inserimento dei dati da validare.

Per creare la scheda usate il codice Html seguente:

<div style="background-color: #7AA45E; position:relative; padding:10px; left:50px; top:50px; width:300px; height:150px; border: 2px solid #000000; border-radius: 6px;">
<form name="scheda" method="post" action="successo.html">  
<table>
<tr><td>Nome:</td><td><input type="text" name="nome" placeholder="inserisci il nome"></td></tr>
<tr><td>Cognome:</td><td><input type="text" name="cognome" placeholder="inserisci il cognome"></td></tr>
<tr><td>Età:</td><td><input type="text" name="eta" placeholder="inserisci l'Età"></td></tr>  
<tr><td>e-mail:</td><td><input type="text" name="email" placeholder="inserisci l'e-mail"></td></tr>
<tr><td><input type="submit" onclick="return validateForm(event)" value="SALVA" /></td><td><input type="reset" value="RESET"></td></tr>
</table>
</form>
</div>

Il Tag  div permette d'impostare lo sfondo della scheda, l'attributo border-radius crea gli angoli smussati.

<div style="background-color: #7AA45E; position:relative; padding:10px; left:50px; top:50px; width:300px; height:150px; border: 2px solid #000000; border-radius: 6px;">

L'attributo method="post" del Tag  form imposta l'invio dei dati al Server senza renderli visibili nell'url, come invece avverrebbe impostando method="get".

L'attributo action si usa per indicare la risorsa/pagina a cui vengono inviati i dati sotto forma di richiesta, se la validazione va a buon fine, altrimenti vengono visualizzati dei messaggi d'errore.
Nel nostro caso, non disponendo ancora di un Server, utlizzeremo la pagina successo.html che ci segnalerà quando i dati inseriti nel Form "scheda" sono corretti.
 

<form name="scheda" method="post" action="successo.html">  

L'evento onclick del Tag <input type="submit" onclick="return validateForm(event)" value="SALVA" /> viene usato per avviare la funzione JavaScript validateForm quando premete sul bottone "SALVA".

Assegnazione dei dati inseriti nel Form "scheda" a variabili JavaScript

Per controllare  i dati inseriti nel Form "scheda", li dobbiamo assegnare a variabili  JavaScript, utilizzando il metodo getElementsByName, come mostra il codice seguente:

var nome=document.getElementsByName("nome")[0].value;  
var cognome=document.getElementsByName('cognome')[0].value;
var eta=document.getElementsByName('eta')[0].value;
var email=document.getElementsByName('email')[0].value;

Il metodo getElementsByName restituisce un vettore con i riferimenti dei Tag Html che hanno lo stesso nome dell'argomento passato al metodo.

Ad esempio, il comando JavaScript seguente:

var eta=document.getElementsByName("eta")[0].value;

permette di assegnare alla variabile eta il valore contenuto nella casella di testo con name="eta".

L'indice [0] serve ad utilizzare il primo riferimento presente nel vettore, che in questo esempio corrisponde alla casella di testo eta.
Se nel vettore ci fossero altri riferimenti con lo stesso nome, per leggerli bastarebbe incrementare l'indice: [1], [2], ... 

In alternativa, per evitare di usare un vettore, avreste potuto utilizzare il metodo getElementsById, ma in questo caso avreste dovuto aggiungere ai Tag l'attributo id="nome" oltre a quello name="nome".


Validazione dei dati

Prima di procedere con la validazione dei dati inseriti nel Form "scheda", dobbiamo fare prima tre cose importanti:

1) Impostiamo i pattern corrispondenti alle Espressioni  Regolari che servono per fare il controllo di validazione dell'età e dell'email:

var regExpEta=/^[0-9]{1,3}$/;
var regExpEmail=/^([a-zA-Z0-9_\.\-])+\@(([a-zA-Z0-9\-]{2,})+\.)+([a-zA-Z0-9]{2,})+$/;

2) Inizializziamo un vettore dove aggiungere gli eventuali messaggi d'errore:

var errori=[];

3) Impostiamo un'area al di sotto del Form "scheda" dove visualizzare i messaggi d'errore:

<div name="elencoErrori" style="position:relative; top:80px; left:50px; width:300px;color:red;">
</div>

Con il codice seguente puliamo  l'area appena creata, dove verranno visualizzati i messaggi d'errore:

var elencoErrori=document.getElementsByName('elencoErrori')[0];
elencoErrori.innerHTML="";

Il metodo innerHTML permette di inserire nel Tag di riferimento il codice Html indicato tra le virgolette.

A questo punto, con il codice seguente,  possiamo controlliare se i dati inseriti nel Form "scheda" sono corretti:

if (nome==null || nome==""){  
   errori.push("Il nome è obbligatorio;<br>");
}  
if (cognome==null || cognome==""){  
   errori.push("Il cognome è obbligatorio;<br>");
}  
if (eta==null || eta==""){  
   errori.push("L'età è obbligatoria;<br>");
} else if(!regExpEta.test(eta) || (parseInt(eta)<=0) || (parseInt(eta)>120)){
   errori.push("L'età non è valida;<br>");
}    
if (email==null || email==""){  
   errori.push("L'e-mail è obbligatoria;");
} else if(!regExpEmail.test(email)){
   errori.push("L'e-mail non è corretta;");
}
//Se ci sono errori, i messaggi d'errore vengono visualizzati nell'area elencoErrori
if (errori.length>0) {
for(var x=0;x<errori.length;x++){
    elencoErrori.innerHTML+=errori[x];
}
//Restitusce false, in questo modo l'operazione di submit s'interrompe e non viene inviata la richiesta al server
return false;
} else {

//Esegue il submit inviando la richiesta al server con i dati inseriti nel Form, perché i dati sono corretti
document.forms[0].submit();
}

 

L'esempio 1 mostra come si comporta l'applicazione se i dati non sono corretti.

Esempio 1

L'esempio 2 mostra come si comporta l'applicazione se i dati sono corretti.

Esempio 2

Se i dati sono corretti viene visualizzata la pagina successo.html, indicata nell'attributo action del form.
Questa pagina è provvisoria, in seguito, quando utilizzeremo un Server, verrà richiamata una risorsa allocata Lato Server che avrà il compito di gestire i dati inviati.

Codice completo pagina ValidaFormLatoClient.html


<html>
<meta charset="ISO 8859-1"/>
<head>
<script>
function validateForm(){
var nome=document.getElementsByName("nome")[0].value;  
var cognome=document.getElementsByName('cognome')[0].value;
var eta=document.getElementsByName('eta')[0].value;
var email=document.getElementsByName('email')[0].value;
var elencoErrori=document.getElementsByName('elencoErrori')[0];
elencoErrori.innerHTML="";
var errori=[];
var regExpEta=/^[0-9]{1,3}$/;
var regExpEmail=/^([a-zA-Z0-9_\.\-])+\@(([a-zA-Z0-9\-]{2,})+\.)+([a-zA-Z0-9]{2,})+$/;
if (nome==null || nome==""){  
   errori.push("Il nome è obbligatorio;<br>");
   }  
if (cognome==null || cognome==""){  
   errori.push("Il cognome è obbligatorio;<br>");
}  
if (eta==null || eta==""){  
   errori.push("L'età è obbligatoria;<br>");
} else if(!regExpEta.test(eta) || (parseInt(eta)<=0) || (parseInt(eta)>120)){
   errori.push("L'età non è valida;<br>");
}    
if (email==null || email==""){  
   errori.push("L'e-mail è obbligatoria;");
} else if(!regExpEmail.test(email)){
   errori.push("L'e-mail non è corretta;");
}
if (errori.length>0) {
for(var x=0;x<errori.length;x++){
    elencoErrori.innerHTML+=errori[x];
}
return false;
} else {
document.forms[0].submit();
}
}  
</script>  
</head>
<body >  
<div style="background-color: #7AA45E; position:relative; padding:10px; left:50px; top:50px; width:300px; height:150px; border: 2px solid #000000; border-radius: 6px;">
<form name="scheda" method="post" action="successo.html">  
<table>
<tr>
<td>Nome:</td><td><input type="text" name="nome" placeholder="inserisci il nome"></td>
</tr>
<tr>
<td>Cognome:</td><td><input type="text" name="cognome" placeholder="inserisci il cognome"></td>
</tr>
<tr>
<td>Età:</td><td><input type="text" name="eta" placeholder="inserisci l'Età"></td>
</tr>  
<tr>
<td>e-mail:</td><td><input type="text" name="email" placeholder="inserisci l'e-mail"></td>
</tr>
<tr>
<td><input type="button" onclick="return validateForm()" value="SALVA" /></td>  
<td><input type="reset" value="RESET"></td>  
</tr>
</table>
</form>
</div>
<div name="elencoErrori" style="position:relative; top:80px; left:50px; width:300px;color:red;">
</div>
</body>
</html>

 

Codice completo pagina successo.html


<html>
<head>
</head>
<body>
<div style="background-color: #7DFA00; position:relative; padding:10px; left:50px; top:50px; width:240px; height:50px; border: 2px solid #000000; border-radius: 6px;">
Salvataggio eseguito con successo!!!<br>
<a href="validazione_form01.html">Torna alla scheda</a>
</div>
</body>
</html>

 

Arrivederci alla prossima lezione!!!


<< Lezione precedente           Lezione successiva >>


T U T O R I A L S    S U G G E R I T I


Share Button

Impariamo a programmare con JavaScript - Lezione 9

Gino Visciano | Skill Factory - 09/07/2017 19:18:13 | in Tutorials

Benvenuti alla nona lezione, in questa lezione impariamo ad usare Le espressioni regolari RegExp. Le espressioni regolari si usano per eseguire operazioni di  ricerca, validazione oppure di ricerca e sostituzione  sul testo.

In JavaScript esistono due modi per dichiarare il pattern (sequenza di caratteri di controllo) di un'espressione regolare, il primo è attraverso una semplice stringa contenuta in una coppia di caratteri slash (/):

var espressione = /.../;

il secondo attraverso l'oggetto RegExp:

var espressione = new RegExp("...");

Per applicare il pattern di un'espressione regolare ad una stringa si usa il metodo test():

espressione.test(stringa);

Se l'espressione è verificata si ottiene True altrimenti False.

Per creare un'espressione regolare su usano:

  • Modificatori
  • Ancore
  • Qualificatori
  • Classi
  • Caratteri speciali

 

Modificatori
i - la ricerca diventa case-insensitive, cioè maiuscole e minuscole vengono considerate uguali;
m - la ricerca verrà considerate “per riga”, cioè le ancore tipo “^” e “$” verranno applicate per ogni riga di testo;
g - cerca tutte le ricorrenze e non solo la prima.

Esempio 1
In questo esempio il pattern /skill factory/ non verrà trovato perchè nel messaggio "Scuola Skill Factory" le iniziali delle parole sono maiuscole.

<html>
<head>
</head>
<body>
<script type="text/javascript">
var messaggio="Scuola Skill Factory";
// Ricerca di tipo case-sensitive
var pattern=/skill factory/;
if (pattern.test(messaggio)) {
  document.write("Pattern trovato!");
} else {
  document.write("Pattern non trovato!");
}
</script>
</body>
</html>

Esempio 2
In questo esempio il pattern /skill factory/i  verrà trovato perchè il modificatore  i rende la ricerca case-insensitive.

<html>
<head>
</head>
<body>
<script type="text/javascript">
var messaggio="Scuola Skill Factory";
// Ricerca di tipo case-insensitive
var pattern=/skill factory/i;
if (pattern.test(messaggio)) {
  document.write("Pattern trovato!");
} else {
  document.write("Pattern non trovato!");
}
</script>
</body>
</html>

Esempio 3
In questo esempio il metodo replace permette di ricercare il pattern /scuola/ in modalità case-insensitive e sostituisce la prima ricorrenza trovata.

<html>
<head>
</head>
<body>
<script type="text/javascript">
var messaggio="Scuola Skill Factory Scuola";
var pattern=/scuola/i;
//Contenuto messaggio prima della sostituzione
document.write(messaggio+"<br/>");
//Contenuto messaggio dopo la sostituzione
messaggio=messaggio.replace(pattern,"Azienda");
document.write(messaggio);
</script>
</body>
</html>

Esempio 4
In questo esempio il metodo replace permette di ricercare il pattern /scuola/ in modalità case-insensitive e sostituisce tutte le ricorrenza trovate.

<html>
<head>
</head>
<body>
<script type="text/javascript">
var messaggio="Scuola Skill Factory Scuola";
var pattern=/scuola/ig;
//Contenuto messaggio prima della sostituzione
document.write(messaggio+"<br/>");
//Contenuto messaggio dopo la sostituzione
messaggio=messaggio.replace(pattern,"Azienda");
document.write(messaggio);
</script>
</body>
</html>

 

Ancore
^ - identifica l'inizio della stringa;
$ - identifica la fine della stringa.

 

Esempio 5
In questo esempio il metodo replace permette di ricercare il pattern /scuola/ in modalità case-insensitive e sostituisce l'ultima ricorrenza trovata.

<html>
<head>
</head>
<body>
<script type="text/javascript">
var messaggio="Scuola Skill Factory Scuola";
var pattern=/scuola$/i;
//Contenuto messaggio prima della sostituzione
document.write(messaggio+"<br/>");
//Contenuto messaggio dopo la sostituzione
messaggio=messaggio.replace(pattern,"Azienda");
document.write(messaggio);
</script>
</body>
</html>

 

Qualificatori
* - indica 0 o più ricorrenze;
+ - indica 1 o più ricorrenze;
? - indica 1 o 0 ricorrenze;
{n} - ricerca esattamente n occorrenze;
{n,} - ricerca minimo n occorrenze;
{n,m} - ricerca esattamente minimo n occorrenze, massimo m.

 

Classi
Le classi determinano un elenco di caratteri, vengono racchiuse tra parentesi quadre e possono essere seguite dai quantificatori.

[0-9] una cifra da 0 a 9;
[0-9]+ almeno una cifra da 0 a 9;
[^0-9] qualunque carattere a parte i numeri;
[a-z] una lettera alfabetica minuscola;
[A-Z] una lettera alfabetica maiuscola;
[a-zA-Z] una lettera alfabetica minuscola o maiuscola;
[^a-zA-Z] qualunque carattere a parte le lettera alfabetica minuscole e maiuscole;
[0-9a-zA-Z] una lettera oppure un numero;
[0-9,]+ contiene almeno una cifra o una virgola.

 

Esempio 6
Un codice RGB è un numero esadecimale composto da sei cifre. Le cifre del sistema esadecimale sono 16: 0123456789ABCDEF.
L'esempio seguente permette di verificare se il codice esadecimale che corrisponde ad un colore RGB è corretto.

<html>
<head>
</head>
<body>
<script type="text/javascript">
//Codice RGB corretto
var numero_esadecimale="FFAA01";
var pattern_esadecimale=/[0-9A-F]{6}/i;
if (pattern_esadecimale.test(numero_esadecimale)) {
  document.write(numero_esadecimale+": ");
  document.write("Formato numero esadecimale corretto!<br/>");
} else {
  document.write(numero_esadecimale+": ");
  document.write("Formato numero esadecimale non corretto!<br/>");
}
//Codice RGB non corretto
numero_esadecimale="ROMA01";
var pattern_esadecimale=/[0-9A-F]{6}/i;
if (pattern_esadecimale.test(numero_esadecimale)) {
  document.write(numero_esadecimale+": ");
  document.write("Formato numero esadecimale corretto!<br/>");
} else {
  document.write(numero_esadecimale+": ");
  document.write("Formato numero esadecimale non corretto!<br/>");
}
</script>
</body>
</html>

 

Caratteri speciali
. - corrisponde ad un carattere qualsiasi (ex. [.]{5} parola di cinque caratteri);
\. - indica il carattere punto;
\( - indica il carattere parentesi;
| - indica oppure (ex. [r|t] parola che contiene un solo carattere che può essere r oppure t);
\d - ricerca cifre numeriche, corrisponde a [0-9]+;
\D - non contiene cifre numeriche, corrisponde a [^0-9]+;
\t - ricerca tabulazione (TAB);
\n - ricerca fine riga (LF);
\r - ricerca ritorno a capo (CR);
\s - ricerca lo spazio;
\S - non contiene lo spazio;
\uxxx - ricerca il carattere indicato con il codice unicode xxx;
\w - ricerca qualsiasi carattere alfanumerico inclusi "_" e lo spazio, corrisponde a [0-9a-zA-Z_ ];
\W - ricerca qualsiasi carattere non alfanumerico, corrisponde a [^0-9a-zA-Z_ ].
 

Esempi di Espressioni Regolari:

* equivale a {0,}
+ equivale a {1,}
? equivale a {1,0}

[uno]{3} equivale ad una delle seguenti parole:
uno, uon, nuo, nou, onu, oun.

Euro
\d*\.\d{2}

Codice Fiscale
[A-Z]{6}\d{2}[A-Z]\d{2}[A-Z]\d{3}[A-Z]

Partita IVA
\d{11}

Indirizzo email
[a-zA-Z0-9._%-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,4}

Linea vuota
^$

Data in formato gg/mm/aaaa
(0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])[-/.](19|20)\d\d

Nome utente formato da soli caratteri alfanumerici più  _ e – di lungezza min 3 e max 15
^[a-z0-9_-]{3,15}$

Password che deve contenere un numero, un carattere minuscolo, uno maiuscolo e un carattere speciale tra @#$% e deve avere lunghezza min 8 e max 20
((?=.*\d)(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%]).{8,20})

Tag HTML
<([A-Z][A-Z0-9]*)\b[^>]*>(.*?)

Estensione di un file immagine
([^\s]+(\.(?i)(jpg|png|gif|bmp))$)

Indirizzo IP
^([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\.([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\.([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\.([01]?\\d\\d?|2[0-4]\\d|25[0-5])$


Arrivederci alla prossima lezione!!!


<< Lezione precedente           Lezione successiva >>


T U T O R I A L S    S U G G E R I T I


Share Button
TOP