operatore "()" in relazione ai metodi di un letterale oggetto

[nourdine]

domanda teorica sull'operatore "()". l'esempio è stupido e di nessuna utilità ma espone il problema.

se io ho un letterale oggetto:

var Foo = {
    name: null,
    setter: function(){
        this.name = "jack";
    }
} 

perchè invece di scrivere questo codice:

Foo.setter();
alert(Foo.name); 

non posso scrivere il letterale in questo modo:

var Foo = {
    name: null,
    setter: function(){
        this.name = "jack";
    }() // <- visto l'operatore alla fine del metodo??? 
} 

e ridurre la seconda parte del codice alla semplice istruzione:

alert(Foo.name); // setter è già stato eseguito durante la lettura dell'oggetto 

grazzie! ... si lo so che non è una domanda semplice ;-(

[ivenuti]

semplicemente perché non è un'operazione lecita seconda la sintassi JS.
Usi () su un oggetto (perché di questo si tratta quando dichiari una funzione) e non ha senso la notazione oggetto() ma ha senso qualcosa come oggetto.funzione(parametri)

FOrse cerchi qualcosa di simile ad un costruttore degli altri linguaggi OO? Prova a vedere l'uso di prototype (per esempio su http://www.javascriptkit.com/javatutors/proto.shtml)

[Mega69]

Non si può fare per un motivo ben preciso, ovvero mentre crei l'oggetto letterale non è possibile ottenere una referenza allo stesso...
In altre parole se la funzione setter la esegui durante la creazione dell'oggetto il this si riferirà alla finestra e non all'oggetto.

Come ti consigliava ivenuti potresti considerare di usare una classe ( che ovviamente non hanno lo steso difetto degli oggetti letterali ):

var Foo = new function() {
  this.name = null;
  this.setter = (function() {
    this.name = "jack";
  }).call(this);
};

Oppure potresti sforzarti a settare il metodo e a richiamarlo solo successivamente...

[nourdine]

Originariamente inviato da Mega69
Non si può fare per un motivo ben preciso, ovvero mentre crei l'oggetto letterale non è possibile ottenere una referenza allo stesso...
In altre parole se la funzione setter la esegui durante la creazione dell'oggetto il this si riferirà alla finestra e non all'oggetto.

Come ti consigliava ivenuti potresti considerare di usare una classe ( che ovviamente non hanno lo steso difetto degli oggetti letterali ):

var Foo = new function() {
  this.name = null;
  this.setter = (function() {
    this.name = "jack";
  }).call(this);
};

Oppure potresti sforzarti a settare il metodo e a richiamarlo solo successivamente...

si ok! in realtà mi interessava il motivo teorico della non referenza del this all'oggetto letterale. In effetti avevo notato che il metodo "setter" viene eseguito se uso la notazione:

    name: null,
    setter: function(){
        alert("metodo eseguito");
        this.name = "jack";
    }() // <- visto l'operatore alla fine del metodo???
}

Solo che non cambia l'attributo name dell'oggetto. Quindi this nella fase di caricamento del js si riferisce a window e setta "name" nello spazio globale dei nomi

[stefanomnn]

CIAAO!
this non funziona bene,
in realta anche this.name non va bene:

devi usare semplicemente "name"

il principio e' che una funzione all' iterno di u' altra contenitore, vede le variabili definite in quest' ultima!

usare this.name potrebbe non funzionarti in firefox, perche per firefox this e' la funzione medesima!
spero che mi sono spiegato!

[Mega69]

Originariamente inviato da stefanomnn
CIAAO!
this non funziona bene,
in realta anche this.name non va bene:

devi usare semplicemente "name"

il principio e' che una funzione all' iterno di u' altra contenitore, vede le variabili definite in quest' ultima!

usare this.name potrebbe non funzionarti in firefox, perche per firefox this e' la funzione medesima!
spero che mi sono spiegato!

Mi sa che ti stai confondendo con le closure... Noi stiamo parlando di oggetti letterali.
A meno che tu non intenda che bisogna a forza settare name:"valore" senza utilizzare una funzione.

Poi il this in Firefox e in ogni browser è sempre l'oggetto che possiede il metodo o con il quale è stato invocata la funzione tramite apply/call.

Per referenziarsi alla funzione medesima c'è un altro modo, ovvero invocare argument.callee... Oppure, se la funzione a un nome, richiamarlo tramite questo ( ovviamente ).

[stefanomnn]

mi sa che hai ragione :-(
non sapevo esattamente cosa fossero sti oggetti letterali!
grazie per lo spunto, me lo studiero!

[nourdine]

Originariamente inviato da stefanomnn
mi sa che hai ragione :-(
non sapevo esattamente cosa fossero sti oggetti letterali!
grazie per lo spunto, me lo studiero!

andiamo bene! hihihihih ;-)

http://www.wait-till-i.com/2006/02/1...bject-literal/

[nourdine]

Originariamente inviato da Mega69
Non si può fare per un motivo ben preciso, ovvero mentre crei l'oggetto letterale non è possibile ottenere una referenza allo stesso...
In altre parole se la funzione setter la esegui durante la creazione dell'oggetto il this si riferirà alla finestra e non all'oggetto.

Come ti consigliava ivenuti potresti considerare di usare una classe ( che ovviamente non hanno lo steso difetto degli oggetti letterali ):

var Foo = new function() {
  this.name = null;
  this.setter = (function() {
    this.name = "jack";
  }).call(this);
};

Oppure potresti sforzarti a settare il metodo e a richiamarlo solo successivamente...

bella pensata batman! pero' non funziona! cioe' se vai a verificare il valore di Foo.name dopo che l'oggetto e' stato processato a runtime (e il metodo setter lanciato via call) troverai ancora un valore null. Il metodo setter viene in effetti eseguito (prova a metterci un alert dentro) ma non setta l'attributo name al valore specificato. come per la versione da me suggerita si ha l'istanziazione di una variabile "name" nello spazio globale!

insomma siamo puntoa capo! che suggerisci??

:-(

Robin

[Mega69]

Batman era gay.

E il seguente codice funziona:

var Foo = new function() {
  this.name = null;
  this.setter = (function() {
    this.name = "jack";
  }).call(this);
}; 

alert(Foo.name);

C'è da dire che effettivamente setter diventa del tutto inutile e lo si può eliminare, a meno di non fare un "ritocchino":

var Foo = new function() {
  this.name = null;
  (this.setter = function() {
    this.name = "jack";
  }).call(this);
  /*Che è lo stesso di:
  this.setter = function() {
    this.name = "jack";
  };
  this.setter();
  */
};