Una classe countDown in Javascript

Lunedì 13 Ottobre, 2008

Nel post 3D CountDown con FIVe3D (vedi anche How I Did It: scrivere un countdown in Flash), veniva proposta una classe per la creazione di un oggetto CountDown in Actionscript, eccone una versione simile in Javascript:

PLAIN TEXT
JavaScript:
  1. /**
  2. * CountDown Class
  3. *
  4. * @author        Giovambattista Fazioli
  5. * @email         g.fazioli@undolog.com
  6. * @web           http://www.undolog.com
  7. *
  8. * @param    dd   (string) 'month day, year'
  9. *
  10. */
  11. function countDown( dd ) {
  12.     // init target time
  13.     var target            = new Date( dd );
  14.     this.targetTime        = target.getTime();
  15.    
  16.     /**
  17.      * refresh countdown
  18.      */
  19.     this.refresh = function() {
  20.         var today                 = new Date();
  21.         var currentTime           = today.getTime();
  22.         // time left
  23.         this._leftMilliseconds    = (this.targetTime - currentTime);
  24.         this._leftSeconds         = Math.floor( this._leftMilliseconds / 1000 );
  25.         this._leftMinutes         = Math.floor( this._leftSeconds / 60 );
  26.         this._leftHours           = Math.floor( this._leftMinutes / 60 );
  27.         // no module
  28.         this.leftDays             = Math.floor( this._leftHours / 24 );
  29.         // for print
  30.         this.leftMilliseconds     = this._leftMilliseconds % 1000;
  31.         this.leftSeconds          = this._leftSeconds % 60;
  32.         this.leftMinutes          = this._leftMinutes % 60;
  33.         this.leftHours            = this._leftHours % 24;
  34.     }
  35.     this.refresh();
  36. }

Esempio

PLAIN TEXT
JavaScript:
  1. var cd = new countDown( '1 1, 2009' );
  2. // mostra quanti giorni, ore, minuti, secondi e millisecondi al primo gennaio 2009
  3. document.write( cd.leftDays + "," + cd.leftHours + "," + cd.leftMinutes + "," + cd.leftSeconds + "," + cd.leftMilliseconds );

Post correlati

Tags: , , , , , , , , ,
Pubblicato in Internet, Javascript, Sviluppo | 4 commenti »

Classi, Oggetti e Istanze

Martedì 29 Gennaio, 2008

Ho notato spesso confusione quando si parla di Classi, Oggetti ed Istanze. Chi non è particolarmente istruito sulla programmazione ad oggetti spesso confonde il vero significato di questi termini. Sapevo, tuttavia, che esistono due scuole di pensiero riguardo alla definizione di Classe e Oggetto. A me piace la "scuola" che indica la Classe come definizione di un possibile Oggetto e, quindi, l'Oggetto come Istanza della Classe.

Sembra banale, tuttavia mi è capitato - discorrendo con altri - di trovarmi in "conflitto" (per così dire) e poi cadere in equivoci, quando si usano questi termini, partendo casomai dal presupposto che "l'altro" li intenda esattamente come noi.

Io la vedo in questo modo; una Classe è una definizione! Viene appunto definita una classe di possibili oggetti. La Classe è l'insieme di metodi e proprietà (se volete possiamo aggiungere anche gli eventi - che altro non solo che speciali metodi...) che possiederà l'oggetto.

Ad esempio quando scriviamo in Actionscript, o qualsiasi altro linguaggio ad oggetti:

PLAIN TEXT
Actionscript:
  1. class MiaClasse {
  2.     function MiaClass() {}
  3.     function MioMetodo() {}
  4. }

Abbiamo definito una Classe e non un Oggetto. Al limite abbiamo "definito" un "possibile" oggetto. Potremmo addirittura sostenere, e non a torto, che l'Oggetto esiste a runtime mentre la Classe no (in verità esistono Classi dinamiche che possono essere definite - e poi usate per creare oggetti - anche a runtime). Escludo le classi statiche, ovviamente che - alla fine - altro non sono che sotto-istanze (o istanze nascoste) e quindi oggetti veri e propri.

Quando invece abbiamo:

PLAIN TEXT
Actionscript:
  1. var mioOggetto:MiaClasse = new MiaClasse();

Ecco che mioOggetto è una istanza di MiaClasse()! Cioè mioOggetto è un Oggetto - appunto - di tipo MiaClasse().

Ne deriva, proprio nella filosofia ad oggetti, che di Oggetti di tipo MiaClasse() ne posso avere quanti ne voglio, cosa che non può essere - per la definizione stessa - di MiaClasse(). Ad esempio, se vale ed ha senso la relazione:

PLAIN TEXT
Actionscript:
  1. var mioOggetto_1:MiaClasse = new MiaClasse();
  2. var mioOggetto_2:MiaClasse = new MiaClasse();
  3. var mioOggetto_3:MiaClasse = new MiaClasse();
  4. ...
  5. var mioOggetto_n:MiaClasse = new MiaClasse();

Non ha significato:

PLAIN TEXT
Actionscript:
  1. class MiaClasse {
  2.     function MiaClass() {}
  3.     function MioMetodo_2() {}
  4. }
  5.  
  6. class MiaClasse {
  7.     function MiaClass() {}
  8.     function MioMetodo_2() {}
  9. }
  10.  
  11. class MiaClasse {
  12.     function MiaClass() {}
  13.     function MioMetodo_3() {}
  14. }

Istanza e Oggetto, quindi, coincidono e sono usate alternativamente per lo stesso significato in diversi contesti.

Probabilmente non frega molto a nessuno... questione di esigenze di completezza... :)

Post correlati

Tags: , , , , , , , ,
Pubblicato in ActionScript, Sviluppo | 2 commenti »