OOP

[polliotto]

Qualcuno sa dirmi che differenza c'è tra :

- proprietà di istanza

function MyClass(prop1) {
	this.prop1 = prop1;
}

///////////////////////////////////////////
- proprietà statica
MyClass.prototype.prop2 = "cheNeso";
grazie mille

[negatyve]

function MyClass(prop1) {
	this.prop1 = prop1;
}

La proprietà viene definita per ogni singola istanza, quindi avrai più memoria occupata (una proprietà per ogni istanza).

MyClass.prototype.prop2 = "cheNeso";

La proprietà viene definita una sola volta per tutte le istanze, che la ereditano tramite l'oggetto prototype, quindi meno memoria occupata (una proprietà per tutte le istanze).

[polliotto]

Allora solo questione di memoria?
ho fatto questa prova :

function MyClass(prop1) {
	this.prop1 = prop1;
}
MyClass.prototype.prop2 = "ciao";
MyClass.prototype.getProp = function(qualeProp) {
	trace(this[qualeProp]);
};
MyClass.prototype.setProp = function(qualeProp, newProp) {
	this[qualeProp] = newProp;
};
prova = new MyClass('by');
prova1 = new MyClass('hello');
prova.getProp('prop2');
prova.setProp('prop2', 'good');
prova.getProp('prop2');

quello che ho notato, e che guardando debugger, fin che non faccio setProp, prova mi fa vedere solo 'by'come nel prova1 hello.
Pero se faccio un "for in" mi fa vedere tutti 2 proprietà.
Vorebbe dire che dicherando cosi

   MyClass.prototype.prop2 = "ciao";

sarebbe una prorietà nascosta?
Scusami negatyve, ma facendo le ricerce ogni sito ha la sua spiegazione, se mi potresti dire il vero utilizzo delle due tipi di dichierazioni.
Grazie ancora per la pazienza

[negatyve]

>sarebbe una prorietà nascosta?

E' un discorso abbastanza lungo..

- prop1 è scritta direttamente nell'istanza, quindi la vedi nel debugger.
- prop2 è scritta nell'oggetto prototype della classe generante, quindi non la vedi nel debugger, ma la puoi leggere con il trace.

come funziona: quando richiedi una proprietà, l'oggetto la cerca in se stesso. se non la trova, la cerca nell'oggetto prototype della classe generante, e così via secondo l'ereditarietà.

function MyClass(prop1) {
	this.prop1 = prop1;
}
MyClass.prototype.prop2 = "ciao";
MyClass.prototype.getProp = function(qualeProp) {
	trace(this[qualeProp]);
};
MyClass.prototype.setProp = function(qualeProp, newProp) {
	this[qualeProp] = newProp;
};
prova = new MyClass('by');
prova1 = new MyClass('hello');
// traccia "ciao", anche se non l'hai scritta
// direttamente nell'istanza
// questo perchè non trovandola in se stessa,
// la cerca nell'oggetto prototype della
// classe generante
prova.getProp('prop2');

quando scrivi:

prova.setProp('prop2', 'good');

stai "coprendo" la proprietà ereditata con una proprietà "locale", che quindi vedi nel debugger. Ma la proprietà ereditata è ancora lì a disposizione. Ad esempio:

function MyClass(){
	// non faccio niente
};
MyClass.prototype.getProp = function(qualeProp) {
	trace(this[qualeProp]);
};
MyClass.prototype.setProp = function(qualeProp, newProp) {
	this[qualeProp] = newProp;
};
// setto l'ereditarietà
MyClass.prototype.prop = "ciao";
// creo l'istanza
prova = new MyClass();
// traccio prop, e mi appare "ciao"
// anche se non la vedo nel debugger
// e non l'ho scritta nell'istanza
prova.getProp('prop');


// a questo punto la setto nell'istanza

prova.setProp('prop', 'pippo');

// traccio prop, e mi appare "pippo"
// perchè ho coperto la proprietà
// ereditata, e quella locale viene
// trovata per prima.
// adesso la vedo nel debugger
prova.getProp('prop');

// cancello la proprietà locale
// e sparisce dal debugger
delete prova.prop

// traccio la proprietà, e mi appare
// di nuovo "ciao". questo perchè quella
// locale non esiste più, e allora
// viene ereditata
prova.getProp('prop');

[polliotto]

Grazie Grazie Grazie Grazie
Sei grande!!! Se ho qualche dubbio, potro rivolgrmi a te?
Grazie ancora.

[negatyve]

Naturalmente.. :)

ciao