Newsgroup: it.comp.lang.javascript
Titolo: aggiungere funzioni ad un oggetto letterale

Salve, in realtà non so molto bene se sono funzioni o quanto meno, ma
comunque cerco di spiegare meglio col codice:
 ciao = function() { return new prova.prima(); }
 var prova = { prima:function() { alert ("in prima"); } }
ciao();
Ok sappiamo che funziona bene, ma perché se faccio così non va:
 ciao = function() { return new prova.uno.prima(); }
 var prova.uno = { prima:function() { alert ("in prima"); } }
ciao();
cioè, uno dovrebbe essere trattato come prototipo o cosa?
come dovrei fare per fare andare il secondo codice?
grazie

  var prova.uno = { prima:function() { alert ("in prima"); } }
perché "var"? non è una variabile ... toglilo.

 perché "var"? non è una variabile ... toglilo.
Scusa, non è la stessa cosa? cosa cambia? ho visto molti framework che
la usano, e riescono ad accedere comunque all'oggetto...
ma toglimi una curiosità, nel secondo esempio, prova.uno, cos'è in
questo caso 'uno'? è un oggetto?
poi come posso far si che le variabili dichiarate nelle funzioni
rimangano in quello scope, cioè di 'prova'?
ho anteposto this.nomevariabile nella funzione 'prima()', ma se creo
un altra funzione e cerco di accedere alla variabile in questa
funzione non accede, perché?
grazie comunque...

 accede, perché?
non ho capito, fai un esempio.

 wrote:

allora, se ad esempio, nell'oggetto prova.uno, ho due funzioni,
chiamate tizio e caio, se eseguo la funzione caio, e all'interno ho
delle variabile dichiarate come ad esempio: caiovar = "prova";, vorrei
quando eseguo la funzione tizio accedere a questa variabile, ma non
attraverso lo scope globale, cioè window.caiovar, perché così
funziona, vorrei praticamente che le variabili dichiarate
nell'oggetto .uno, rimangano solo li, e non vanno nello scope globale,
non so se hai capito, casomai scivo qualche esempio.
grazie...

 scivo qualche esempio. grazie...
Se intendi un qualcosa del tipo:
 var prova= {
	uno: { 
	tizio:function() {
	alert(typeof caiovar);
},
	caio:function() {
	var caiovar="prova dentro caiovar";
	alert(caiovar);
}
}}
prova.uno.caio();
prova.uno.tizio();
si comporta come una qualsiasi function: una var dichiarata all'interno 
di una function ha come scope la function stessa (infatti l'alert in tizio
() ti dirà "undefined").
Se vuoi accederci da entrambe le function devi dichiararla dentro 
l'oggetto ma al di fuori della function; un qualcosa del tipo:
 var prova= {
	uno: { 
	tizio:function() {
	alert(typeof this.caiovar);
	alert(this.caiovar);
},
	caio:function() {
	this.caiovar="prova dentro caiovar";
	alert(this.caiovar);
},
	caiovar:""
}}
prova.uno.caio();
prova.uno.tizio();
alert(prova.uno.caiovar);
alert(typeof caiovar);

 wrote:

Ok grazie mille, ora non ho più dubbi ^_^
grazie.

 (javascript non è propriamente un linguaggio ad oggetti),
Scusa, perche'?

 wrote:

ciao, scusa ma io ho ancora dubbi su come fare per far funzionare sta
cosa, sto facendo prove da ieri ma manco va, allora questo:
ciao.uno = {
	cia:'',
	prima: function() {  ciao.uno.due();
	                    alert (this.cia);
	                  },
	due:   function() {
		               this.cia = "ciao";
		              }
	        }
praticamente quando richiamo ciao.uno.prima(), e al suo interno chiama
ciao.uno.due(), dovrebbe impostare la variabile 'cia' con il valore
'ciao', ma quando poi esegue l'alert nella funzione 'prima' mi dice
che non è stata definita. Hai qualche consiglio?
grazie...

 non è stata definita. 
Molto strano ... 
Ho copiancollato il tuo oggetto (ovviamente ho dovuto definire prima 
ciao, con var ciao={}), e a me funziona (proprio perché esiste "ciao"):
var ciao={};
ciao.uno = {
	cia:'',
	prima: function() {  ciao.uno.due();
	                    alert (this.cia);
	                  },
	due:   function() {
		               this.cia = "ciao";
		              }
	        }
ciao.uno.prima();
Quanto sopra, testato con firefox, mi scrive "ciao".
Comunque sia, non è buona programmazione usare "ciao.uno.due()", perché 
si riferisce a una var dichiarata esternamente all'oggetto (ossia: se 
cambi "ciao" con un altro nome non funziona più). 
Quindi io, anziché ciao.uno.due(), userei this.due();

 Scusa, perche'?
Perché é un linguaggio basato su prototype, non è un linguaggio OOP (per 
esempio non esistono "classi", ma usa delle function *come* delle classi).
Dai una lettura qua che, a una veloce lettura, mi sembra ben spiegato:
 
https://developer.mozilla.org/en/Introduction_to_Object-
Oriented_JavaScript

 wrote:

ciao, ho capito ora funziona come voglio, solo un ultima curiosità, ti
dico dove sbagliavo io, visto che l'oggetto lo scatenavo in un altra
funzione esterna mettevo come ritorno della funzione un: return new
ciao.uno.prima();, facendo in questo modo la variabile manteneva il
suo valore solo nella funzione dove veniva settata, e infatti quando
cercavo di utilizzarla dentro un altra funzione era indefinita, cioè
senza volore, ora ho risolto semplicemente togliendo new, e non
capisco perché succedeva questo, tu hai qualche idea? c'è,
praticamente facevo come fa jquery... ciao.

 , ma usa delle function *come* delle classi).
Non come classi, ma come costruttori di oggetti... nel libro "Object
Oriented Javascript" di Stefanov vengono esaminati, se non ricordo
male, 13 pattern di cui quello che simula le classi e' solamente il
primo.

 ciao.uno.prima();
non ho capito come usavi new ... new ciao.uno.prima(), così a naso, 
restituisce un oggetto *solo* della function prima()

>           o Role-oriented
ok, diciamo che è un tipo di OOP. 
Normalmente per OOP si intendono linguaggi java-like, almeno nell'uso 
comune del termine; per questo ho pensato di specificare quanto sopra.

 wrote:

Sisi, proprio così, quindi ritornando l'oggetto solo della funzione
prima(), è come se rimanesse in quel scope? o no? :D
Comunque, io sto continuado a fare delle prove ancora devo decidere su
come sviluppare sta cosa, praticamente ora stavo cercando di
racchiudere un oggetto in un altro, così:
var ciao = {
	var cia: {
	cial:'',
	prima: function() {
		alert(this);
					ciao.due();
	                    alert (this.cial);
	                  }},
	due:   function() {
		               this.cial = "ciao";     alert
(this.cial);
		              }
	        }
ciao.cial.prima();
e questo mi dice che ciao non è definito, ma anche se antepongo var
ciao = {} mi dice sempre che non è definito l'oggetto.
Ah, ma perchè se faccio sempre dentro l'oggetto: var cial = { ...} mi
dice che manco qualcosa, non è il giusto questo modo di fare? cioè
meglio se faccio come nell'esempio?
thx...

 come nell'esempio?
perché si usano i : e non l'uguale ...
Attenzione che la "due" è nell'oggetto "ciao", mentre la "prima" è 
nell'oggetto "cia" in "ciao" (quindi, a naso, l'alert di "cial" di 
"prima" di darà "" e non "ciao", perché this si riferisce all'oggetto ...
p.s. firefox ti segnala molto bene gli errori tipo usare = anziché : , se 
stai usando IE per questa cosa ... buttalo! :-)

 	var cia={
cia: {
(firefox segnala molto bene l'errore:
Errore: missing : after property id
File sorgente: file:prova.htm
Riga: 34, Colonna: 5
Codice sorgente:
 var cia= { 
)

> se stai usando IE per questa cosa ... buttalo! :-)
non faccio per insistere, ma stai usando firefox e la sua console degli 


> se stai usando IE per questa cosa ... buttalo! :-)
non faccio per insistere, ma stai usando firefox e la sua console degli 


 wrote:

Avevo cancellato l'ultimo messaggio perché me n'ero accorto
dell'errore, e l'ho risolto :D
comunque si ho sempre usato firefox e continuerò ad usarlo :D
ciao e grazie :)