Newsgroup: it.comp.lang.javascript
Titolo: ancora su json

Ciao a tutti!
Ho provato a guardare un po' nei post precedenti ma non ho trovato la
risposta a quello che cercavo. In pratica... Lato client ho un
prototipo, del tipo:
function prot1 () {
     this.a = "";
     this.b = "";
     this.c = function( x ) {
           // do something
     }
}
vorrei istanziare un array di oggetti prot1 con i dati passati dal
server con una stringa del tipo:
[ { a : "pippo", b : "pluto" } ]
Il che verrebbe fuori una cosa del genere:
var stringa_passata_dal_server = '[ { a : "pippo", b : "pluto" } ]';
var arr = eval(  stringa_passata_dal_server );
In questo modo arr è un array di Object. A me serve che gli oggetti
siano di tipo prot1, perché ho bisogno del metodo c.
Per ovviare al problema, al momento, faccio una cosa del tipo:
var array_definitivo = []
for ( x in arr ){
      var obj_tmp = new prot1;
      obj_tmp.a = x.a;
      obj_tmp.b = x.b;
      array_definitivo.push( obj_tmp );
}
E' una cosa abbastanza orribile, imho. Vorrei quindi istanziare
direttamente degli oggetti di tipo prot1. Si può? Se no, quale tecnica
abbastanza elegante ed efficiente mi consigliate?
Grazie mille!
--
Ciao
Blue

 var arr = eval(  stringa_passata_dal_server );
(premesso che non conosco gli eventuali limiti di questo json):
 e perché dal server non passi [new prot1("pippo","pluto")]
 e la function diventa function prot1(a,b) {this.a=a;....}
?
-- 
"La realtà è un'illusione causata dall'assenza di alcool."
									      A.

 abbastanza elegante ed efficiente mi consigliate?
Puoi rendere il codice più elegante, implementando un oggetto del tipo
"Serializable":
function Serializable(){}
Serializable.prototype.toString = function(){
	// metti qui il codice per trasformare l'oggetto
	// in una stringa object initializer
}
Serializable.prototype.parse = function( o ){
	if ( typeof o == "string" )
		o = eval(o);
 
	for ( var prop in o )
		this[prop] = o[prop];
	return this;
}
Questo è solo un abbozzo giusto per mostrarti l'approccio. Ora, prendi
il tuo Prot1:
function Prot1(){
	this.a = "";
	this.b = "";
}
Prot1.prototype = new Serializable;
Prot1.prototype.c = function( x ){
	// do something
}
E quando ti arriva il codice dal server:
var arr = eval(  stringa_passata_dal_server );
for (var i=0;i<arr.length;i++)
	arr[i] = new Prot1().parse( arr[i] );
Avendo definito un oggetto Serializable puoi applicarlo a tutti i tuoi
oggetti "custom" che devono essere "serializzati".
P.S.
Se vuoi utilizzare "json", ti consiglio la seguente lettura:
http://yuiblog.com/blog/2007/04/10/json-and-browser-security/
-- 
~ Se i sintomi persistono, insultare il medico.

 
http://yuiblog.com/blog/2007/04/10/json-and-browser-security/
Grazie mille ad entrambi!
Alla fine sono tornato indietro sulla mia idea di istanziare
direttamente l'oggetto dalla stringa passata dal server... In effetti
il server dovrebbe inviare solo i dati utilizzando un protocollo
neutro rispetto all'implementazione lato client. E' il client poi che
dovrebbe occuparsi di istanziare gli oggetti che servono in base ai
dati trasmessi. Altrimenti se modificassi l'oggetto javascript lato
client (magari cambio il costruttore), poi dovrei modificare anche il
codice lato server. Non mi sembra un buon modo di programmare.
La serializzazione era quello che volevo evitare, a favore di qualcosa
di più semplice. Rimarrò con la stringa json che mi semplifica un po'
la vita e lascia il codice più leggibile. Inoltre dubito che la
serializzazione mi porti vantaggi a livello di performance, almeno
finché la quantità di dati trasmessi è ridotta.
Grazie ancora a te e Cristiano.
--
Ciao
Blue

 La serializzazione era quello che volevo evitare, 
Guarda che è esattamente quello che già stai facendo. :) quello che
chiami "stringa json" è la serializzazione di oggetti javascript.
-- 
~ "It may be that the old astrologers had the truth exactly reversed,
when they believed that the stars controlled the destinies of men.
The time may come when men control the destinies of stars."
(Arthur C. Clarke)

 chiami "stringa json" è la serializzazione di oggetti javascript.
Si, ok... hai ragione... ogni tanto ometto parte dei miei pensieri e
la gente non capisce... Intendevo che non volevo creare una routine di
serializzazione da dati "raw"... usando la stringa con sintassi json è
il motore javascript che si occupa di creare gli oggetti. Usando una
stringa "raw" (o xml o qualunque altro formato di rappresentazione dei
dati su una stringa) però avrei più controllo sull'uso della memoria,
mentre creando tutti gli oggetti attraverso json no.
Qui però nasce un dubbio... le stringhe sono oggetti immutevoli come
in java? Ovvero, se ho due oggetti
a.x = "prova";
b.x = a.x;
a.x e b.x puntano allo stesso oggetto, in quanto a.x passa in realtà
il puntatore all'oggetto stringa? Quindi in realtà la stringa "prova"
in memoria è residente solo una volta?
Grazie ancora.
--
Ciao
Blue

 una volta?
Dovrebbe, ma tra le ennemila implementazioni mai mettere la mano sul
fuoco. :)
-- 
~ Non ci sono certezze, solo ragionevoli probabilità.
(W. Howe)

 oggetto (riferimento, con "puntatore" si rischia confusione).
Qui ho fatto un po' di confusione (colpa in parte del fatto che lavoro
molto con JScript che tratta i literal un po' diversamente e delle ore 
piccole di ieri sera :) ), come mi hanno fatto notare.
JS non trasforma subito un literal in un oggetto String; lo fa solo se
ci "lavori" sopra. Quindi con un codice del tipo:
	a.x = "prova";
	b.x = a.x;
Gestirai due oggetti stringa differenti. Mentre, con:
	a.x = new String("prova");
	b.x = a.x;
Rimane quanto detto in precedenza.
-- 
~ Non sono disordinato. Sono solo un massimizzatore di entropia.

 Dovrebbe, ma tra le ennemila implementazioni mai mettere la mano
ok, grazie mille (anche della correzione che hai postato dopo)!
--
Ciao
Blue

 quale sarebbe la differenza?
Tra riferimento e puntatore? Il puntatore è un tipo di dato specifico,
di alcuni linguaggi di programmazione (vedi pascal, c...).
JS come linguaggio non fa uso di puntatori; le variabili si gestiscono
per valore o per riferimento (come Java). Ad esempio:
	function f(v){
		alert(v);
	}
	var b = 134;
	f(b);
"b" viene passato per valore, essendo un dato primitivo.
Quindi, "v" contiene il valore di "b".
Mentre con:
	var b = new Array("hello","world");
	f(b);
"b" viene passato per riferimento, essendo un oggetto.
Quindi "v" si riferisce allo stesso oggetto di "b". E come abbiamo già
detto, anche facendo così:
	var b = new String("Hello World");
	f(b);
passi un riferimento.
-- 
~ "Il semble que la perfection soit atteinte non quand il n'ya plus
rien à ajouter, mais quand il n'ya plus rien à retrancher"
(A. de Saint-Exupéry)

 per inciso... trovo json comodissimo, ma soprattutto per le CGI :-)
Per inciso... preferisco metterlo tra virgolette per lo stesso motivo
di "AJAX" :)
-- 
~ "Il debito pubblico è abbastanza grande da badare a sé stesso."
(Ronald Regan)

 per valore o per riferimento (come Java).
ok, capito. :)
Grazie della precisazione.
--
Ciao
Blue