Matteo Pignatelli
a- a+

Mascheramento ed ereditarieta' in AS

Questo tutoria richiede ottime conoscenze di Action Script.

Partiamo da qui:

[code]
function myO(){
// base constructor
};

myO.prototype.setA = function(p){
trace("setting a to: " +p);
myO.a = p;
}

myO.prototype.getA = function(){
trace("a is: " + myO.a);
return myO.a;
}

myO.prototype.addProperty("a" ,myO.prototype.getA, myO.prototype.setA);

var newO = new myO();
newO.a = 10;
newO.a;

trace("---> tracing props in newO BEFORE masking:");
for(var i in newO) trace(i);

// masking all props
ASSetPropFlags(myO.prototype,null,7);
////////////////////

trace("
---> tracing props in newO AFTER masking:");
for(var i in newO) trace(i);
trace(" ^ as you see: none");
[/code]

 

Come funziona:

- si crea un costruttore base, che in AS è rappresentato da una function, in questo caso vuota (poi si capirà il perchè).
- creiamo due metodi sul prototipo, getter e setter
- aggiungiamo una proprietà, che chiamiamo a

Il metodo addproperty permette di aggiungere una qualsiasi proprietà ad un oggetto.
Di solito si preferisce aggiungerla direttamente o a run-time, magari con la parola chiave this.
Qui invece facciamo tutto secondo regola, anche se in AS non abbiamo a disposizione un ambiente ad oggetti veramente completo (come in c#, p.e.), possiamo cmq. "emulare" il comportamento di un vero oggetto, che di norma ha i suoi gestori per le proprietà, in visual basic si chiamerebbero Get e Set.

Quei due metodi prototipo che abbiamo creato servono a questo: quando settiamo o invochiamo quella data proprietà entreranno in azione, come vedremo.

Notare che addProperty è stato applicato al prototipo di myO, in questo modo ci garantiamo una corretta ereditarietà'.

A questo punto basta provare, creiamo un oggetto newO, ereditando da myO e settiamo la proprietà a=10, verra' invocata la setA() e la getA() quando scriviamo newO.a; che in questo caso non ha alcun scopo se non quello di mostrare il funzionamento di getA().
Con un'iterazione in newO andiamo a vedere quali sono gli attributi/oggetti che contiene, e constatiamo che in effetti, i due metodi e la proprietà che abbiamo creato sono stati correttamente presi in eredità da myO.

In seguito "mascheriamo" tali proprietà, tutte indistintamente, se avessimo continuato a creare proprietà/oggetti sul prototipo di myO, nel metodo che stiamo appunto illustrando, anche questi verrebbero nascosti al ciclo for ... in.
Per farlo usiamo un metodo non documentato ufficialmente da Macromedia, ma cmq. disponibile già da flash 5 (che funziona in modo leggermente diverso).

In breve

ASSetPropFlags accetta fino a quattro parametri, in questo esempio se ne usano tre, il primo è l'oggetto su cui applicare il mascheramento, il secondo rappresenta la lista degli attributi da nascondere, con null li nascondiamo tutti, il terzo è un flag binario che seleziona il tipo di mascheramento/scrittura/lettura.
Vale la pena di fare alcune prove per capire meglio il funzionamento. P.e. puo' essere un modo valido per costruire costanti in flash.

Infine, ripetendo l'iterazione su newO si nota che ciò che abbiamo costruito non si vede più, ma c'è e funziona.
Per realizzare tutto questo occorre evitare l'uso della parola chiave this, in questo modo verrebbero meno i presupposti per un corretto mascheramento.
Ricordo ancora una volta che l'uso di prototype si è reso necessario per poter implementare correttamente l'ereditarietà.
Possiamo infatti evitare di usarlo, ma avremmo un mascheramento su un solo oggetto, tanto lavoro per poco.

Che senso ha il masking?

Alla luce di quanto visto, ci si potrebbe chiedere perchè tutto questo lavoro, che ricordo, influisce in modo trascurabile sulle prestazioni.
Una mezza risposta l'ho già anticipata: creare costanti in flash non è compito banale, anche se addProperty da sola può bastare allo scopo.
Potrebbe essere utile nello sviluppo di componenti, o in generale di oggetti che dovranno essere usati da altri.
Chi lavora coi linguaggi ad oggetti sa quanto è importante "proteggere" dati sensibili, per garantire un corretto funzionamento e impedire che si metta mano a parti di codice sensibile, limitando il rischio di usi scorretti che potrebbero portare a malfunzionamenti.
Potrebbe servire anche allo sviluppatore esperto, che a distanza di tempo, guardando il proprio codice può capire dove ha deciso che una tale parte di codice non va toccata.
Un altro vantaggio è costituito dall'uso dei metodi setter e getter, che gestiscono per proprio conto una data proprietà, facilitando lo sviluppo e il refactoring (miglioramento) e minimizzando i problemi di retro-compatibilità.



Ti potrebbe interessare anche

commenta la notizia

C'è 1 commento
Staff
Ti interessano altri articoli su questo argomento?
Chiedi alla nostra Redazione!