[Javascript] Object literal ?

[CercoAiutoo]

Qualcuno conosce una guida online per object literal ? Ho trovato questo codice ma non ci capisco niente:

var ciao = {
    versione: "0.11"
};
ciao.Base = new Class({
    initialize: function () {
        this.versione = ciao.versione
    },
    RegisterModule: function (a) {
        a.Base = this
    }
});


var boh = new ciao.Base();

Cos'è quel "new Class" ? Istanzia un' oggetto della classe Class ?

Non riesco a trovare niente su internet

[_Claudio]

var ciao = {
    versione: "0.11"
};
ciao.Base = new Class({ /* classe Class, scelta infelice come nome */
    initialize: function () {
        this.versione = ciao.versione
    },
    RegisterModule: function (a) {
        a.Base = this
    }
});

var boh = new ciao.Base(); /* boh ora ha come tipo Class */

Purtroppo js ha una tipizzazione obrobriosa.

[CercoAiutoo]

Originariamente inviato da _Claudio

var ciao = {
    versione: "0.11"
};
ciao.Base = new Class({ /* classe Class, scelta infelice come nome */
    initialize: function () {
        this.versione = ciao.versione
    },
    RegisterModule: function (a) {
        a.Base = this
    }
});

var boh = new ciao.Base(); /* boh ora ha come tipo Class */

Purtroppo js ha una tipizzazione obrobriosa.

and so ?

edit: ah non avevo letto i commenti

[CercoAiutoo]

Ma come fa poi a creare una classe in quel modo ?
Non capisco la sintassi!!

[MEMon]

Quello è il framework mootools, non centra nulla con la classica sintassi javascript.

Se vuoi creare un oggetto literal devi fare in questo modo:

var myObject={
	x:10,
	y:20,
	sum:function(a,b){
		return a+b;
	}
}

In questo modo hai creato UN singolo oggetto che disponde di due proprietà(x e y) e un metodo(sum).

var x=myObject.x;  // x è 10
var z=myObject.sum(3,5); // z è 8

Se invece ti interessa creare una classa, e quindi istanziare i tuoi oggetti con new MyClass, allora il discorso è diverso, e leggermente più complesso perchè javascript è di tipo protipale.

[CercoAiutoo]

Originariamente inviato da MEMon

Quello è il framework mootools, non centra nulla con la classica sintassi javascript.

Se vuoi creare un oggetto literal devi fare in questo modo:

var myObject={
	x:10,
	y:20,
	sum:function(a,b){
		return a+b;
	}
}

In questo modo hai creato UN singolo oggetto che disponde di due proprietà(x e y) e un metodo(sum).

var x=myObject.x;  // x è 10
var z=myObject.sum(3,5); // z è 8

Se invece ti interessa creare una classa, e quindi istanziare i tuoi oggetti con new MyClass, allora il discorso è diverso, e leggermente più complesso perchè javascript è di tipo protipale.

Grazie ho capito tutto
Complesso ? Fa niente... sai dove posso trovare qualche guida o tutorial al riguardo ?

Su internet non si trova quasi niente su object literal eppure è strausato

[_Claudio]

Mi sembrava anche a me una sintassi strana... ho ragionato per deduzione e sulla struttura del linguaggio...

[MEMon]

Originariamente inviato da CercoAiutoo

Grazie ho capito tutto
Complesso ? Fa niente... sai dove posso trovare qualche guida o tutorial al riguardo ?

Su internet non si trova quasi niente su object literal eppure è strausato

Se cerchi su google javascript literal object trovi moltissima roba.

Complesso nel senso che è un pò diverso da come si ragiona di solito con i linguaggi OO, ti scrivo qualcosa.

Come ti ho detto javascript è prototipale nel senso che ogni classe contiene un "oggetto" chimato prototype il quale contiene tutti i metodi e talvolta anche le proprietà che suddetta classe dovrà avere.

function MyClass(s){
	this.name=s;
}
MyClass.prototype.getName=function(){
	return this.name;
}
MyClass.prototype.setName=function(s){
	this.name=s;
}

var c=new MyClass("bla bla");
c.getName(); //  ritorna bla bla

COme vedi hai creato una classe MyClass, al suo prototype hai "dato" due metodi, in questo modo ogni istanza di MyClass possiede questi due metodi.
La particolarità del prototype è che se ora fai una cosa del genere:

MyClass.prototype.clearName=function(){
	this.name="";
}

c.clearName(); // questo è possibile, magia della forma prototipale

Tutte le istanze di MyClass avranno a disposizione il nuovo metodo!

Ti starai adesso chiedendo come fare una bella ereditarietà della tua nuova e fiammante classe, ti viene sempre in aiuto il prototype.

function Shape(vertices){
	this.vertices=vertices;
	this.color="black";
}
Shape.prototype.setColor=function(c){
	this.color=c;
}


function Square(side){
	Shape.apply(this,4);
	this.side=side;
}
Square.prototype=new Shape;
Square.prototype.constructor=Square;
Square.prototype.calcArea=function(){
	return this.side*this.side;
}

var sq=new Square(10);
sq.setColor("white");  //possibile perchè ha ereditato il metodo
sq.calcArea();  //return 100

sq instanceof Square;  //return true
sq instance of Shape;  //return true, è una eredità a tutti gli effetti!!

In questo modo crei due splendide classi, Shape e Square, la seconda estende la prima aggiungendo nuove carattersistiche(calcArea), il tutto attraverso il prototype.
In particolare come vedi viene assegnato al prototype di Square una istanza di Shape, in questo modo Square ottiene il prototype di Shape.
Ricorda poi di riassegnare il constructor a Square, in quanto dopo l'operazione

Square.prototype=new Shape;

anche il constructor di Square diventa quello di Shape, e ciè non va bene.
Il constructor come dice la parola stessa è il costruttore, quello che contiene il codice da eseguire quando si creano nuove istanze con new.

Nel costruttore di Square puoi noatre una cosa strana

Shape.apply(this,4);

Questo non fa altro che eseguire il costruttore di Shape nello scope di Square, per farla semplice è come se in Java avresti fatto

super(4);   //super riferito a Shape

sperando che tu sia pratico di Java...

[CercoAiutoo]

Bene credo di aver capito
Avevo letto da qualche parte infatti che tramite prototype era possibile diciamo estendere dinamicamente una classe.

L' unica cosa che non ho capito è che MyClass, Shape e Square sono funzioni... perchè le chiami classi ? O forse tu hai indicato solo i costruttori delle classi ?

[MEMon]

Originariamente inviato da CercoAiutoo

Bene credo di aver capito
Avevo letto da qualche parte infatti che tramite prototype era possibile diciamo estendere dinamicamente una classe.

L' unica cosa che non ho capito è che MyClass, Shape e Square sono funzioni... perchè le chiami classi ? O forse tu hai indicato solo i costruttori delle classi ?

Non sono funzioni, sono classi. Ok la differenza è lieve, diciamo che ogni funzione in javascript è una classe.

function doSomethng(){
	// some stuff
}

Questa è ovviamente una funzione, ma è anche una classe, in particolare è il costruttore della classe, infatti il codice //some stuff viene eseguito in entrambi i modi:

doSomething();  // usata come semplice funzione

var o=new doSomething();  //usata come costruttore di una classe

In javascript la vera e propria classe non esiste, esistono gli oggetti.

[CercoAiutoo]

ah ecco ora è tutto chiaro grazie