Categoria ‘Sviluppo’


iPhone: il WAP è morto?

iphonebrowser.jpg Chi ha avuto la possibilità e la pazienza di vedere l’ultimo Keynote di Steve Jobs, dove viene presentato il nuovo iPhone Apple, avrà sicuramente trovato affascinante l’ultima meraviglia tecnologia multi-touch di Cupertino.
Fantasticherie alla “Minority Report” a parte (la realtà spesso supera davvero la fantasia), quello che mi ha colpito maggiormente, anche se già presente in molti smart-phone da tempo in commercio, è la possibilità di navigare su Internet alla stregua di un PC casalingo. L’iPhone entra in diretta concorrenza con i classici cellulari e non con gli smart-phone attualmente in commercio. La Apple ha presentato la sua soluzione per il mobile, seguendo le sue classiche line guida: semplicità – quindi – diffusione di massa, come è accaduto con l’iPod.

Se gli smart-phone attualmente in commercio, quelli con Windows Mobile a bordo per esempio, permettono di navigare su Internet, sono tuttavia percepiti dal “mass-market” come soluzione ibrida tra un cellulare e un notebook. Insomma qualcosa di diverso dal “cellulare” di tutti i giorni. Ad oggi un cellulare è un “cellulare”, nel senso che navigare su Internet è relegato a pochi – alcuni nemmeno sanno che è possibile farlo – (visti anche i costi) con soluzioni davvero lontane da quelle casalinghe di un PC; per le dimensioni del display, per la velocità di banda, per la difficoltà di interazione con la tastiera o mouse simulati, ecc…

Tuttavia, quasi in sordina, mi sembra che ci sia una piccola rivoluzione in atto di notevole interesse, almeno per gli sviluppatori Web.

Poter navigare un sito dalla “strada”, senza modificare la tecnologia utilizzata è un grandissimo passo avanti. Ad oggi alcune realtà sul Web sono doppie – se non triple: WAP, Flash Lite (versione per Windows Mobile o Symbian) e Internet standard. Far convergere e unificare le tecnologie di browsing è una conquista importante, l’anticamera alla vera diffusione della navigaione via mobile.
Il WAP, ad esempio, per quanto si sia sforzato di emulare il Web vero e proprio è fallito miseramente. In questo mi ricorda il digitale terrestre!

La Net TV, ad esempio, in questa nuova situazione potrebbe trovare un terreno fertile per attecchire ancor di più rispetto a qualche anno fa. Esistono quindi tutti i presupposti per dare ulteriore slancio alla seconda giovinezza di Internet. Da un lato le nuove forme di aggregazione delle community e dall’altro la possibilità di sfruttare queste “esperienze” oltre che da casa anche nella “mobilità” più totale.

Continua...

Creare un RSS Reader in PHP e Javascript

Visto che siamo su un Blog (Weblog) e lo scambio di file RSS è diventato uno standard, ecco alcuni semplici estratti di codice utili per manipolare Feed-RSS.
Sappiamo tutti che i file RSS sono – alla fine – dei semplici file testuali che rispettano lo standard XML. Ne deriva che manipolarli non è poi così complesso.

La prima classe che presentiamo, in PHP, permette di “leggere” un file RSS da qualsiasi indirizzo, permettendo di elaborare il risultato e di riproporlo da qualsiasi parte.

Continua...

Come inserire Google Map nel proprio Web

Web2.0 significa anche software distribuito tramite API (Interfaccia di Programmazione di un’Applicazione). La possibilità di sfruttare funzioni e funzionalità remote altrove risulta estremamente utile in realtà come Internet. Oltre a Yahoo, con il suo ToolKit 2.0 style, anche Google – nell’ambito della geo-referenzazione – propone i suoi strumenti free, in questo caso per la manipolazione e gestione delle mappe.

Google Maps API permette di inserire Google Maps nelle proprie pagine Web tramite Javascript.

Continua...

browsershots.org: multiple browser output

Ecco la risposta alla drammatica incompatibilità con i vari browser attualmente disponibili. Browsershots.org è un servizio – gratuito per ora e open source – che fornisce un modo semplice per verificare se un sito è visualizzato allo stesso modo su varie piattaforme e vari browser.

Grazie ad una piccola server-farm casalinga, gli autori di questo utilissimo servizio mettono a disposizione gli output video delle schermate generate dal vostro Web, così da poter verificare la correttezza dell’interpretazione HTML/CSS su varie macchine e browser: Linux PLD 2.0 (Ac), Windows 2003 (Server), Windows NT 5.1 (XP), Mac OS X 10.4 (Tiger) ed altre.

browsershot-serverform

Il sito è davvero ben curato, con tanto di documentazione wiki, sorgenti, roadmap e timeline. Inoltre è possibile visualizzare gli ultimi screenshots, lo stato delle code-di-processo e lo stato della factories. Unica nota dolente, ma superabile, è il tempo richiesto per la generazione degli screen-shot, un po’ lento! Tuttavia è un grosso aiuto ai Web Developer per verificare la correttezza del loro lavoro, senza dover installare browser e/o macchine virtuali per far convivere – ad esempio – Internet Explorer 6 e 7. Sono supportati praticamente tutti i browser, da FireFox a Safari. Interessante è la possibilità di verifcare IE6 e IE7, insieme alle versioni 5.01 e 5.5.
Bravi!

Continua...

Ajax: Rich Internet Application?

Domanda: possiamo considerare le applicazioni Ajax come vere e prorie RIA (Rich Internet Application – una RIA è un’applicazione web con tutte le caratteristiche e funzionalità di una tradizionale applicazione desktop per PC)?
Secondo Ryan Stewart, no – o almeno non ora.

The role of the desktop in Rich Internet Applications by ZDNet‘s Ryan Stewart — Rich Internet Applications have helped change the face of the web. It’s more interactive, designers have been able to leave their mark and innovation in web development has soared. Rich Internet Applications helped open up the web to better experiences and now they are doing the same for desktop applications. Where do RIAs fit into the world of desktop development?

In effetti la concorrenza con altri “approcci” – per così dire – è davvero elevata. La recente esplosione del fenomeno Net TV, ad esempio, dimostra che l’unione fa la forza. In “Ajax” non è possibile visualizzare un Video, tanto per dirne una. Come non è possibile realizzare tante altre cosine. Non credo che Ajax sarà il futuro assoluto. Io vedo in Ajax più che altro un’estensione del browser e un nuovo modo per affrontare alcune dinamiche relative all’UI prima neanche prese in considerazione.

Tuttavia, se qualcuno non se ne fosse accorto, esistono ancora degli ostacoli da superare. Ad esempio:

  • Migliorare la compatibilità tra i vari browser in commercio, argomento largamento discusso su questo stesso Blog
  • Permettere una maggiore interazione tra le pagine Web e il sistema operativo “ospitante”, ad esempio un Drag & Drop dal desktop alla pagina Web
  • Standardizzazione degli scripting: JScript, Javascript (1.3, 1.7, …), VBScript
  • Accessibilità, usabilità e sicurezza, vista che stiamo sulla rete!!

Librerie, Prototype/Script.aculo.us e YUI components: il vero intoppo?

Quando uno sviluppatore crea una libreria o un frame-work per risolvere (una volta per tutte) una serie di necessità, inizia a creare un mostro. Spesso non ce ne accorgiamo ma il legame sviluppatore end-user è davvero contorto. Si inizia, ad esempio, con la creazione di una libreria Javascript in grado di creare delle semplici finestre. Basta poco e qualcun’altro crea una libreria simile che permette di creare finestre modali, ridimensionabili e con la gestione dell’ordinamento e sovrapposizione. Dopo un po’ ne arriva un’altro che implementa anche la personalizzazione grafica… e così via.

In pratica quando si ottiene qualcosa, nell’istante immediatamente successivo questo qualcosa sembra non bastare più, sembra diventare lo standard e quindi si cercano nuovi accessori per migliorarne ancora di più le performance o l’aspetto. Tutte richieste dell’end-user! E lo sviluppatore corre, quasi come un cagnolino intimidito; l’end-user ha sempre ragione!

Questa continua corsa, in un universo come quello di Internet, rischia a lunga gettata di portare più confusione che altro.

Web 3.0?

Negli ultimi tempi esperienze (beta) nell’ambito del Web2.0 sono proliferate sulla rete a ritmi impressionanti. Ognuno ha portato all’attenzione la sua applicazione Ajax-style, ognuno con le sue soluzioni embedded, appoggiandosi a librerie note, scrivendo frame-work proprietari, ecc…
Ogni esperienza aveva le sue peculiarità: qualcuna era graficamente accattivante, alcune estremamente veloci, altre estrememente personalizzabili e altre estremamente usabili.
Ma nessuno, fino ad ora, è riuscito ad unire tutto questo in un unico ambiente.

Ragionandoci attentamente risulta evidente che il motivo è nello scarso supporto fornito dal browser stesso e dall’immensa complessità del problema.

Anche se qualcuno ha assimilato il browser ad un sistema operativo, quest’ultimo detiene ancora un’enorme vantaggio. Primo fra tutti è il cosidetto Kernel. Qual’è il Kernel di Explorer o di FireFox? Entrambi, come Opera o Safari, supportano a mala pena quel linguaggio di scripting chiamato Javascript (o JScript a secondo dei casi). Mozilla, nel suo FireFox sta per rilasciare la versione di Javascript 1.7, davvero interessante. Ma Microsoft Explorer che farà? Toccherà installare un ActiveX che lo emuli, attendere il 2012 per l’uscita di IE8 o utilizzare una miriade di if per capire su che piattaforma si sta lavorando?

Non posso che essere d’accordo con Ryan Stewart. Per il momento Ajax è un tecnica di notevole aiuto in ben determinati casi, ma paragonare questa tecnica (e sottolineo tecnica non tecnologia) ad una RIA mi sembra – almeno per ora – davvero eccesivo.

Macromedia/Adobe

Interessanti, invece, sono le tecnologie (e sottolineo tecnologie e non tecniche) Flex/Flash ed Apollo, che dopo l’acquisizione di Macromedia da parte di Adobe stanno per vivere una seconda giovinezza.
Consiglio vivamente a tutti gli interessati di visionare gli Adobe Labs, dove si evince una simpatica nuova politica che ispira sicuramente più fiducia nel futuro di Script.aculo.us – senza offesa e senza nulla togliere allo sviluppatore.

Tuttavia Internet ha una caratteristica unica, quella di sorprendere, quindi non mi stupirei affatto di aver detto – a breve – una miriade di sciocchezze!

Continua...

Geni: il social albero genealogico

Geni! È proprio vero che la fantasia non ha limiti. Probabilmente Ajax ci porterà li dove nessun developer è mai giunto prima! Comunque bravi. Questo tool, free, è davvero simpatico. Permette di creare “al volo” il proprio albero genealogico, fatto salvo che abbiate tutti i dati. La registrazione è “nascosta” nel primo inserimento, ovvero voi stessi.

Si procede abbastanza spediti, tiene in cosiderazione praticamento tutto (divorsi, parenti in vita, sesso, …) ogni “persona” ha una vera e propria scheda personale, quasi da rubrica o agenda clienti. L’interfaccia princpale ha un risposta abbastanza rapida, cosa che non si può dire dell’interfaccia a schede per i singoli elementi aggiunti: ogni volta che si clicca su un TabStrip viene eseguita una richiesta Ajax davvero lenta.
A parte qualche “baghetto” quà e la, la lentezza cronica di alcune fasi, l’idea è simpatica. Da provare almeno una volta…

NOTE:
Fa uso di Prototype/Script.aculo.us e i componenti YUI (Yahoo). Forse è per questo che è molto lento.

Continua...

IE Developer Toolbar Beta 3

Microsoft ha rilasciato la Beta 3 di IE Developer Toolbar, la sua versione di FireBug, il noto Add-in per FireFox utilizzato per il debugging e controllo delle pagine Web. IE Developer Toolbar è tuttavia ancora allo stato embrionale rispetto al suo diretto conconrrente FireBug. Sono assenti molte funzionalità, come il tracking della rete ad esempio. Inoltre, almeno sulla mia macchina, è andato in crash un paio di volte…

IE developer toolbar

Comunque l’impegno va premiato e visto che siamo alla Beta 3 siamo fiduciosi di poter – a breve – ottenere uno strumento almeno paragonabile a FireBug, per ora il migliore nel suo genere.

Continua...

Javascript Object (parte I)

Se si ha bisogno di istanziare più oggetti di una classe, un metodo è quello di definire la classe tramite lo pseudo-costruttore function().

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// class definition
function CmyClass(param1,param2) {
    this.myProperty = param1;
    this.myAdding = param1+param2;
    //
    this.myMethod = function(param1) {
         alert( "add: "+this.myAdding+" - Param: "+param1);
    }
}
//
var obj1 = new CmyClass(10,20);
var obj2 = new CmyClass(20,40);
//
obj1.myMethod("Hi from obj1");
//
obj2.myMethod("Hi from obj2");

Definita la classe – con tanto di parametri iniziali – posso creare n istanze del mio oggetto, personalizzandole durante la creazione con la keyword new.
Posso anche inserire una chiamata ad un metodo durante la fase di inizializzazione dell’oggetto, stando solo attento ad inserirlo per ultimo – vedi riga 14:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// class definition
function CmyClass(param1,param2) {
  this.myProperty = param1;
  this.myAdding = param1+param2;
  //
  this.myMethod = function(param1) {
     alert( "Result: "+this.myResult );
  }
  //
  this._init = function() {
    this.myResult = this.myProperty*100;
  }

  this._init();

}
//
var obj1 = new CmyClass(10,20);
var obj2 = new CmyClass(20,40);
//
obj1.myMethod("Hi from obj1");
//
obj2.myMethod("Hi from obj2");

Un modo sbagliato sarebbe – vedi riga 6:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
// class definition
function CmyClass(param1,param2) {
  this.myProperty = param1;
  this.myAdding = param1+param2;

  this._init();

  //
  this.myMethod = function(param1) {
     alert( "Result: "+this.myResult );
  }
  //
  this._init = function() {
    this.myResult = this.myProperty*100;
  }


}
//
var obj1 = new CmyClass(10,20);
var obj2 = new CmyClass(20,40);
//
obj1.myMethod("Hi from obj1");
//
obj2.myMethod("Hi from obj2");

Un’altro modo per creare un oggetto al volo (on-fly) è quello di dichiarare una variabile/funzione, mono uso:

1
2
3
4
5
6
7
8
9
var myObject = {
  myProperty: 10,
 
  myMethod: function() {
    alert("Hi from "+this.myProperty);
  }
};

myObject.myMethod();

Questa tecnica è comoda quando si vuole creare una sola istranza di un oggetto, e trattarlo come tale. Questa viene spesso usata nei recenti framework Ajax, come prototype e derivati. A partire da questa, infatti, non è possibile istanziare un nuovo oggetto, in quanto la classe è andata persa.

Si può poi ricorrere all’uso di prototype per estendere una classe, anche vuota. Ad esempio:

1
2
3
4
5
6
7
8
9
10
11
12
13
function CmyClass() {}

CmyClass.prototype = {
  myProperty: 10,
 
  myMethod: function() {
    alert( "Hi from " + this.myProperty);
  }
}

var obj = new CmyClass();

obj.myMethod();

Oppure:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
function CmyClass() {
  this.myOldProperty = 1000;
  }

CmyClass.prototype = {
  myProperty: 10,
 
  myMethod: function() {
    alert( "Hi from " + this.myProperty);
    alert( "Hi from " + this.myOldProperty);
  }
}

var obj = new CmyClass();

obj.myMethod();

Continua...

Consigli folli da Microsoft: JScript vs Javascript (parte 1)

Ormai da Microsoft ci aspettiamo davvero di tutto, soprattutto quando si parla di browser. Offendere l’intelligenza della comunità, tuttavia, risulta un po’ sgradevole da accettare.
Sul Blog di IE7 è uscito oggi un articolo (IE+JScript Performance Recommendations Part 3: JavaScript Code Inefficiencies), se così possiamo definirlo di Peter Gurevich, Performance PM for IE, con la parte III dei suoi “consigli” per gli sviluppatori.

Primo appunto: perchè Microsoft si ostina ad implementare una sua versione di Javascript – che chiama appunto JScript – complicando la vita a tutti?

Secondo appunto: proprio perchè il motore di JScript è proprietà della Microsoft, invece di perdere tempo a dire a “noi” come aggirare i difetti, perchè non li sistemano una volta per tutte?

Lasciando stare il primo consiglio di questa III parte, che potete leggere direttamente sul Blog o su Ajaxian, il secondo è davvero eclatante, e sinceramente non lo diregisco proprio.

Don’t use Property Accessor Functions

Quando si dice il progresso! In pieno 2007, un Project Manager della Microsoft viene a dire a noi sviluppatori di Non usare le funzioni di get e set in JScript!
La follia, evidentemente, è uno strano male, che colpisce in modo repentino e fuorviante. JScript – sullo stile di Javascript – è implementato seguendo un modello ad oggetti! È un linguaggio ad oggetti, sulla scia del C++. Il fatto che le variabili siano accessibili dall’esterno (come sottolineato nell’articolo – cosa ovvia tra l’altro) non è assolutamente un vanto, anzi. La tecnica dell’incapsulamento è propria della filosofia della programmazione OO. Incapsulare le proprietà, passando dai virtual-method get e set è una forza del linguaggio Object Oriented, non un limite. Consigliare di non farne uso è a dir poco criminale, e gli eventuali problemi di performance sono a carico dell’interprete e dei suoi autori, non certo dell’end-developer.
Quindi, alla fine, JScript va usato come un semplice C, guai a trattarlo come C++, pena “impallare” il browser o chissà cos’altro.

Inoltre, come segnalato sul Blog, il tutto è un falso problema in quanto JScript NON implementa le vere funzioni di get e set, solo Javascript lo fa!

Ma il problema, evidentemente, rimane. In Javascript (scusate ma JScript non riesco proprio a digerirlo) ci sono varie tecniche per creare un oggetto. Ad esempio lo si può creare in modo immediato in questo modo:

1
2
3
4
5
   var myObject = {
       miaProprieta: 0,

       mioMethodo: function() { alert("Hello"); }
   };

In questo modo non ho dichiarato una classe. L’oggetto viene per così dire dichiarato e creato contemporaneamente. È un modo rapido quando l’oggetto che ci serve è unico.

Oppure, il che è equivalente ai fini pratici:

1
2
3
4
5
6
7
8
function CmyObject() {
    this.miaProprieta = 0;

    this.mioMetodo = function () { alert("Hello") }

}
//
var iMyObject = new CmyObject();

In questo caso prima si definisce la classe – tramite una function- (CmyObject) e poi si crea esplicitamente l’oggetto con new.

A parte le questioni stilistiche relative al singolo sviluppatore, il problema di come accedere alle proprietà di una classe rimane. Consiglio vivamente a tutti gli interessati, comumque, di leggere le risposte al Blog di Microsoft, davvero interessanti.

Sul Blog erano presenti tre modi di accesso: con le funzioni get e set, diretto e passando da prototype. Alla fine la cosa simpatica è stata che sul Blog c’è un codice per eseguire un Testdrive, una prova dei tre metodi indicati sopra. Il codice è presente sul Blog ma lo riporto qui per completezza:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
<script>
// Slow Car definition
function SlowCar()
{
      this.m_tireSize = 17;
      this.m_maxSpeed = 250; // One can always dream!
      this.GetTireSize = SlowCar_get_tireSize;
      this.SetTireSize = SlowCar_put_tireSize;
}
function SlowCar_get_tireSize()
{
      return this.m_tireSize;
}
function SlowCar_put_tireSize(value)
{
      this.m_tireSize = value;
}
</script>


<script>
// Faster Car, no more property accessors
function FasterCar()
{
      this.m_tireSize = 17;
      this.m_maxSpeed = 250; // One can always dream!
}
</script>


<script>
// Prototype Car, use the language features!
function PrototypeCar()
{
      this.m_tireSize = 17;
      this.m_maxSpeed = 250; // One can always dream!
}

PrototypeCar.prototype.GetTireSize = function() { return this.m_tireSize; };
PrototypeCar.prototype.SetTireSize = function(value) { this.m_tireSize = value; };
</script>


<script>
function TestDrive()
{
      var slowCar = new SlowCar(); // Safe and reliable, probably not fast
      var fasterCar = new FasterCar(); // Lacks air-bags, probably faster
      var protoCar = new PrototypeCar(); // Can technology win the day?


      var start = (new Date()).getTime();
      for(var i = 0; i < 100000; i++) { slowCar.SetTireSize(slowCar.GetTireSize() + 1); }
      var end = (new Date()).getTime();
      output.innerHTML += "Slow Car " + (end - start) + "<br>";
     

      start = (new Date()).getTime();
      for(var i = 0; i < 100000; i++) { fasterCar.m_tireSize += 1; }
      end = (new Date()).getTime();
      output.innerHTML += "Faster Car " + (end - start) + "<br>";


      start = (new Date()).getTime();
      for(var i = 0; i < 100000; i++) { protoCar.SetTireSize(protoCar.GetTireSize() + 1); }
      end = (new Date()).getTime();
      output.innerHTML += "Prototype Car " + (end - start) + "<br>";
}
</script>

<button onclick="TestDrive();">Test Drive Cars!</button>
<div id="output"></div>

Ora, questo è l’output (relativo alla mia macchina) con IE7:
Slow Car 515
Faster Car 63
Prototype Car 547

Con FireFox (v.2.0.0.1):
Slow Car 156
Faster Car 47
Prototype Car 172

Con Opera (v.9.10):
Slow Car 172
Faster Car 47
Prototype Car 172

Insomma :) IE7 ne esce davvero male… non so se notate l’enorme differenza. Quindi direi che JScript potrebbe essere abolito, eliminato, cancellato, vaporizzato. Speriamo che Microsoft si decida anche lei ad adottare Javscript e non i surrogati.

Continua...

Classi Javascript e PHP per validare un’indirizzo di posta elettronica

Riprendendo il post Validare email in Javascript e PHP, ecco una simpatica classe Javascript in grado di verificare e controllare indirizzi di posta elettronica. Il suo uso è davvero semplice, anche se è un controllo lato client, quindi facilmente bypassabile; basta infatti disabilitare Javascript (propongo petizione contro questa possibilità ;) oramai tutti i browser permettono di eludere Javascript, e quindi tutti i controlli associato – a breve non funzionerà più nulla su Internet, vedi Ajax :o ).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
/*
** @name              : ckmail.js
** @description       : Check email syntax
** @author            : =undo=
** @author-web        : http://www.undolog.com
** @author-email      : g.fazioli@undolog.com - g (dot) fazioli (at) undolog (dot) com
** @date              : 21/09/2006 21.24
** @ver               : 1.0
*/

var oCKMail = {
    __release: "1.0",
    __filter: /^([\w-]+(?:\.[\w-]+)*)@((?:[\w-]+\.)*\w[\w-]{0,66})\.([a-z]{2,6}(?:\.[a-z]{2})?)$/i,
    __username: "",
    __domain: "",
    __ext: "",

    // TO DO
    getUsername: function(e) {
        if(this.__init(e)) return(this.__username);
        return(false);
    },

    // TO DO
    getDomain: function(e) {
        if(this.__init(e)) return(this.__domain);
        return(false);
    },

    // TO DO
    getExtension: function(e) {
        if(this.__init(e)) return(this.__ext);
        return(false);
    },

    // TO DO
    __init: function(e) {
        if( !this.__filter.test(e) ) return(false);
        var t = e.split("@");
        this.__username = t[0];
        this.__domain = t[1];
        t = this.__domain.split(".");
        this.__ext = t[1];
        return(true);
    },

    // TO DO
    // synopsis
    //    check(e,extlist,domainlist);
    // Esegue una serie di controlli standard su un indirizzo e-mail.
    //    extlist        - Si pu&ograve; passare un secondo parametro opzionale che corrisponde ad un array di estensioni che
    //                   sono ammesse o escluse (include/exclude extension) in base al primo valore dell'array, tutte le
    //                   altre saranno considerate errore.
    //                   Eg. [true,"it","com"] passano (include list)
    //                   Eg. [false,"it","com"] NON passano (exclude list)
    //                   Se -1 non viene preso in considerazione
    //    domainlist    - Si pu&ograve; passare un terzo parametro opzionale che corrisponde ad un array di domini che
    //                   sono ammessi o esclusi (include/exclude domain) in base al primo valore dell'array, tutte gli
    //                   altri saranno considerate errore.
    //                   Eg. [true,"alice.it","mac.com"] passano (include list)
    //                   Eg. [false,"alice.it","mac.com"] NON passano (exclude list)
    //                   Se -1 non viene preso in considerazione
    //
    check: function(e) {
        if( this.__init(e) ) {
            // check domainExt array check
            if( arguments.length > 1 ) {
                if( typeof( arguments[1] ) == "object" ) {
                    if( arguments[1][0] ) { // include list
                        for(var i=0; i < arguments[1].length; i++) {
                            if( this.__ext == arguments[1][i].toLowerCase() ) return(true);
                        }
                    } else { // exclude list
                        for(var i=0; i < arguments[1].length; i++) {
                            if( this.__ext == arguments[1][i].toLowerCase() ) return(false);
                        }
                        return(true);
                    }
                    return(false);
                }
            }
            // check domainName array check
            if( arguments.length > 2 ) {
                if( typeof( arguments[2] ) == "object" ) {
                    if( arguments[2][0] ) { // include list
                        for(var i=1; i < arguments[2].length; i++) {
                            if( this.__domain == arguments[2][i].toLowerCase() ) return(true);
                        }
                    } else { // exclude list

                        for(var i=1; i < arguments[2].length; i++) {
                            if( this.__domain == arguments[2][i].toLowerCase() ) return(false);
                        }
                        return(true);
                    }
                    return(false);
                }
            }
            return(true); // email correct
        }
        return(false); // error
    }
};

L’oggetto oCKMail mette a disposizione alcuni metodi per effettuare tutta una serie di controlli paralleli sull’indirizzo, come l’estensione, il dominio, ecc…

Per essere proprio sicuri se disponete di PHP potete aggiungere un’ulteriore ed efficace controllo prima di eseguire il comando mail(). Ecco la classe PHP utile a tale scopo:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
/*
** @name              : cckmail.php
** @description       : Check email syntax
** @author            : =undo=
** @author-web        : http://www.undolog.com
** @author-email      : g.fazioli@undolog.com - g (dot) fazioli (at) undolog (dot) com
** @date              : 21/09/2006 23.58
** @ver               : 1.0
**
** EXAMPLES
**
**    // Controlla un indirizzo ESCLUDENDO quelle e-mail con dominio "e-lementi.com" e "mac.com"
**
**    $oCKMail = new CCKMail();
**    $oCKMail->check($email, NULL, array(false,"e-lementi.com","mac.com") );
**
**    // Controlla un indirizzo INCLUDENDO quelle e-mail con dominio "e-lementi.com" e "mac.com"
**
**    $oCKMail = new CCKMail();
**    $oCKMail->check($email, NULL, array(true,"e-lementi.com","mac.com") );
**
**    // Controlla un indirizzo ESCLUDENDO quelle e-mail con estensione "net","it","org"
**
**    $oCKMail = new CCKMail();
**    $oCKMail->check($email, array(false,"net","it","org") );
**
** HISTORY / CHANGE LOG
**
*/

    if (!function_exists('checkdnsrr')) {
        function checkdnsrr($host, $type = '') {
            if(!empty($host)) {
                if($type == '') $type = "MX";
                @exec("nslookup -type=$type $host", $output);
                while(list($k, $line) = each($output)) {
                    if(eregi("^$host", $line)) {
                        return true;
                    }
                }
                return false;
            }
        }
    }
    //
    class CCKMail {
        var $__release = "1.1";
        var $status = false;
        var $username;
        var $domain;
        var $ext;
        //
        function CCKMail() {}
        //
        function _test($e) {
            $this->status = false;
            $p = '/^.+\@(\[?)[a-zA-Z0-9\-\.]+\.([a-zA-Z]{2,4}|[0-9]{1,3})(\]?)$/';
            if( (preg_match($p, $e)) ) {
                $t               = explode("@",$e);
                $this->username  = strtolower( $t[0] );
                $this->domain    = strtolower( $t[1] );
                $t               = explode(".",$this->domain);
                $this->ext       = strtolower( $t[1] );
                //
                if(checkdnsrr($this->domain.'.', 'MX') )    $this->status = true;
                if(checkdnsrr($this->domain.'.', 'A') )     $this->status = true;
                if(checkdnsrr($this->domain.'.', 'CNAME') ) $this->status = true;
            }
        }
        //
        function check($m, $e=NULL,$d=NULL) {
            $this->_test($m);
            if( $this->status ) {
                // check domainExt array check
                if( !is_null($e) ) {
                    if( $e[0] ) { // include list
                        for($i=1; $i < sizeof($e); $i++) {
                            if( $this->ext == strtolower( $e[$i] ) ) return(true);
                        }
                    } else { // exclude list
                        for($i=1; $i < sizeof($e); $i++) {
                            if( $this->ext == strtolower( $e[$i] ) ) return(false);
                        }
                        return(true);
                    }
                    return(false);
                }
                // check domainName array check
                if( !is_null($d) ) {
                    if( $d[0] ) { // include list
                        for($i=1; $i < sizeof($d); $i++) {
                            if( $this->domain == strtolower( $d[$i] ) ) return(true);
                        }
                    } else { // exclude list
                        for($i=1; $i < sizeof($d); $i++) {
                            if( $this->domain == strtolower( $d[$i] ) ) return(false);
                        }
                        return(true);
                    }
                    return(false);
                }
                return(true);
            }
            return(false);
        }
    }
?>

La cosa ineteressante è la capacità di questa classe di connettersi ai server MX (vedi checkdnsrr() ) per verificare la presenza del dominio. Quindi oltre ad eseguire un controllo sintattico sull’indirizzo di posta elettronica viene eseguito un vero e proprio ping del dominio passato. Possiamo dire che questo metodo è sicuro all’80%…

Continua...



Stop SOPA