javascript e funzioni

[aeroxr1]

ciao,
sono sempre io , siccome devo imparare html,css,javascript,php per una materia mi sto togliendo i dubbi più grossi che ho grazie a voi.
Ora sono qui con un dubbio sulle funzioni in javascript .

creo un "oggetto" macchina :

funtion macchina(modello,colore)
{
     this.modello=modello;
     this.colore=colore;
}

se io voglio associarvi una funzione motore , in teoria posso fare o

function prova()
{
   ...
}

funtion macchina(modello,colore)
{
     this.modello=modello;
     this.colore=colore;
     this.motore=prova();
}

o

macchina.prototype.motore= function()
{
    ....
}

giusto ? ma quali sono le differenze tra i due metodi ??? perchè sui libri avevo letto il primo metodo, poi nelle applicazioni pratiche mi sono ritrovato il secondo senza alcuna spiegazione



un altra domanda è invece quanda usare Function() e come ,
var gestore = new Function("funzione(this,'click')");

gestore cosa è alla fine ?


un altra cosa che ho poco capito e che ogni tanto mi crea dubbi è la differenza tra doppi apici e singolo apice in javascript .


mi scuso per le millemila domande , ma qui mi sembra che mi spieghino le cose all'incontrario..

[simo8]

Sono anche io agli inizi ma provo a risponderti per quello che ho capito .

Credo che la differenza tra scrivere il metodo direttamente nell'oggeto o usare il metodo prototype sia puramante grammaticale, non cambia niente .
Anche se ad esempio, ad un certo punto del mio programma, mi accorgo che mi servirebbe un metodo che non avevo definito nell'oggeto, allora posso usare prototype senza andare a modificare l'oggetto stesso ed avere il metodo a disposizione.

Tra apici e doppi apici anche qui non cambia niente anche se potrebbe tornare utile nella creazione di stringhe :

"Siamo nell'anno 2013."

lo posso scrivere così senza usare caratteri di escape nel caso avessi usato i singli apici.

Per quanto riguarda

var gestore = new Function("funzione(this,'click')");

dovrebbe assegnare il valore ritornato dalla funzione appena definita , tramite Function , alla variabile gestore . Ma scritta così sembra che hai appena definito una funzione che accetta come parametro in ingresso un'altra funzione e basta , non è definito il corpo . Per capire meglio bisognerebbe vedere cosa fa la funzione "funzione".

[__ZERO_UNO__]

Originariamente inviato da aeroxr1

funtion macchina(modello,colore)
{
     this.modello=modello;
     this.colore=colore;
}

se io voglio associarvi una funzione motore , in teoria posso fare o

function prova()
{
   ...
}

funtion macchina(modello,colore)
{
     this.modello=modello;
     this.colore=colore;
     this.motore=prova();
}

o

macchina.prototype.motore= function()
{
    ....
}

Nel primo caso, per assegnare alla variabile motore una funzione, la funzione prova deve ritornare a sua volta una funzione, oppure devi togliere le parentesi così:

funtion macchina(modello,colore)
{
     this.modello=modello;
     this.colore=colore;
     this.motore=prova;
}

e this.motore e prova saranno (o possiamo dire puntano) la stessa funzione.

Comunque fra i due codici c'è una grande differenza: nel primo caso ogni oggetto creato con il costruttore macchina avrà la propria funzione motore. La funzione è propria dell'oggetto ed il lookup di tale metodo si ferma al livello dell'oggetto. Nel secondo caso stiamo aggiungendo una funzione all'oggetto prototipo di macchina, e dunque quel metodo è condiviso da tutti gli oggetti sono creati con il costruttore macchina. In fase di lookup di tale metodo, la catena sarà risalita fino all'oggetto prototipo (prototype) di macchina.

Il secondo metodo (quello di assegnare i metodi al prototipo) è più efficiente e maggiormente usato. Il primo caso è utile, invece, quando il metodo e personalizzato per ogni oggetto che viene creato, che io sappia.

Non ci dovrebbe essere differenza fra singoli e doppi apici in JS.

Per la risposta all'ultima domanda ti invito a leggere https://developer.mozilla.org/en-US/...jects/Function

[aeroxr1]

Innanzitutto Grazie a entrambi

Originariamente inviato da __ZERO_UNO__

Nel primo caso, per assegnare alla variabile motore una funzione, la funzione prova deve ritornare a sua volta una funzione, oppure devi togliere le parentesi così:

funtion macchina(modello,colore)
{
     this.modello=modello;
     this.colore=colore;
     this.motore=prova;
}

e this.motore e prova saranno (o possiamo dire puntano) la stessa funzione.

si mi sono sbagliato le parentesi non le volevo mettere

Originariamente inviato da __ZERO_UNO__

Comunque fra i due codici c'è una grande differenza: nel primo caso ogni oggetto creato con il costruttore macchina avrà la propria funzione motore. La funzione è propria dell'oggetto ed il lookup di tale metodo si ferma al livello dell'oggetto. Nel secondo caso stiamo aggiungendo una funzione all'oggetto prototipo di macchina, e dunque quel metodo è condiviso da tutti gli oggetti sono creati con il costruttore macchina. In fase di lookup di tale metodo, la catena sarà risalita fino all'oggetto prototipo (prototype) di macchina.

Il secondo metodo (quello di assegnare i metodi al prototipo) è più efficiente e maggiormente usato. Il primo caso è utile, invece, quando il metodo e personalizzato per ogni oggetto che viene creato, che io sappia.

fase di lookup cosa sarebbe ? Cerco subito su internet

non capisco il risparmio di memoria dove sia , ho letto sul libro e dice che con il secondo metodo si risparmia memoria poichè tutte le istanze della classe ereditano i medesimi metodi , che non vengono quindi duplicati per ogni oggetto

Non capisco questa definizione, se io creo tre oggetti macchina tutti e tre gli oggetti macchina non hanno ereditato la funzione motore che ho definito nel secondo modo e quindi l'occupazione di memoria non dovrebbe esser uguale al primo metodo ?

facendo un esercizio di laboratorio in cui dovevo creare questa pagina html con i relativi gestori javascript mi sono imbattuto nuovamente nell'uso di Function http://tweb.ing.unipi.it/book/exe/laboratori/1.4/

// marge.js

// La funzione 'dettaglia' aggiunge i dettagli di un evento
// all'elemento area di testo "area_testo" presente nel form
// "mio_form". Viene invocata da vari gestori evento.

function dettaglia(elemento, evento) {
    var t = elemento.form.area_testo;
    var nome_elemento = elemento.name;
		var valore = " ";
    if ((elemento.type == "select-one") || (elemento.type == "select-multiple")){
        for(var i = 0; i < elemento.options.length; i++)
            if (elemento.options[i].selected) 
                valore += elemento.options[i].value + " ";
    }
    else if (elemento.type == "textarea") valore = "...";
    else valore = elemento.value;
    var mess = evento + ": " + nome_elemento + ' (' + valore + ')\n';
		t.value += mess;
}

// La funzione aggiungi_gestori installa un insieme di gestori di eventi su
// ogni elemento di un form f, senza controllare se l'elemento supporta
// tutti questi tipi di eventi

function aggiungi_gestori(f) {
    var gestore_click       = new Function("dettaglia(this, 'Click')");
    var gestore_change      = new Function("dettaglia(this, 'Change')");
    var gestore_focus       = new Function("dettaglia(this, 'Focus')");
    var gestore_blur        = new Function("dettaglia(this, 'Blur')");
    var gestore_select      = new Function("dettaglia(this, 'Select')");
		var gestore_dblclick    = new Function("dettaglia(this, 'dblClick')");
		
	
    for(var i = 0; i < f.elements.length; i++) {
        var e = f.elements[i];
        e.onclick    = gestore_click;
        e.onchange   = gestore_change;
        e.onfocus    = gestore_focus;
        e.onblur     = gestore_blur;
        e.onselect   = gestore_select;
				e.ondblclick = gestore_dblclick;
		}

    // Gestori speciali per i bottoni:
    f.bottone_svuota.onclick = 
        new Function("this.form.area_testo.value=''; dettaglia(this, 'Click');");
    f.bottone_sottometti.onclick = 
        new Function("dettaglia(this, 'Click'); return false");
    f.bottone_azzera.onclick = 
        new Function("this.form.reset(); dettaglia(this, 'Click'); return false");
}
// Attiviamo il form aggiungendo i possibili gestori
aggiungi_gestori(document.mio_form);

le domande che mi pongo sono :

1) se all'interno del for evidenziato facevo direttamente

 e.onclick=dettaglia(this, 'Click');

ottenevo lo stesso risultato ?
presumo che la soluzione a questa domanda sia nella pagina da voi linkata :

Note: Functions created with the Function constructor do not create closures to their creation contexts; they always run in the window context (unless the function body starts with a "use strict"; statement, in which case the context is undefined).

2) il this , usato nell'ultima parte evidenziata non dovrebbe puntare all'oggetto cliccato ? quindi il bottone svuota del form f ? a vedere dal codice non funziona esattamente cosi

[wingman87]

Originariamente inviato da aeroxr1

non capisco il risparmio di memoria dove sia , ho letto sul libro e dice che con il secondo metodo si risparmia memoria poichè tutte le istanze della classe ereditano i medesimi metodi , che non vengono quindi duplicati per ogni oggetto

In sostanza esiste un'area comune a tutti gli oggetti di tipo macchina che è il prototype (di macchina). Se aggiungi il metodo al prototype, tutti gli oggetti possiedono il metodo ma il riferimento ad esso è unico (nel prototype). Se invece aggiungi il metodo ad ogni oggetto, tutti gli oggetti possiedono il metodo ma il riferimento ad esso è situato in ogni singolo oggetto, quindi è replicato n volte (dove n è il numero degli oggetti).

Originariamente inviato da aeroxr1

1) se all'interno del for evidenziato facevo direttamente

 e.onclick=dettaglia(this, 'Click');

ottenevo lo stesso risultato ?

No, perché scrivendo dettaglia in quel modo lo stai evocando, quindi in e.onclick stai mettendo il valore restituito dall'evocazione del metodo, cioè nulla. Piuttosto l'uso di function in questo caso è equivalente a questo:

 e.onclick=function(){this.form.area_testo.value=''; dettaglia(this, 'Click')};

Infatti il valore restituito da Function è una funzione. Prima riga del link che ti è stato consigliato:

Every function in JavaScript is actually a Function object.

Originariamente inviato da aeroxr1

presumo che la soluzione a questa domanda sia nella pagina da voi linkata :

Note: Functions created with the Function constructor do not create closures to their creation contexts; they always run in the window context (unless the function body starts with a "use strict"; statement, in which case the context is undefined).

In realtà questa è la risposta alla tua domanda successiva

Originariamente inviato da aeroxr1

2) il this , usato nell'ultima parte evidenziata non dovrebbe puntare all'oggetto cliccato ? quindi il bottone svuota del form f ? a vedere dal codice non funziona esattamente cosi

Il valore di this dipende dal contesto, quindi come dice la frase che hai estrapolato dal link, this è window.

Edit: in effetti il codice non sembra corretto, se funziona significa che ho sbagliato qualcosa nella spiegazione

[banryu79]

Ciao,
posto solo per consigliare questa risorsa all'utente aeroxr1, se leggi l'inglese ti chiarirà la questione:
http://superherojs.com/#language

in particolare il punto 4:
http://msdn.microsoft.com/en-us/magazine/ff852808.aspx

[nico159]

Credo che la differenza tra scrivere il metodo direttamente nell'oggeto o usare il metodo prototype sia puramante grammaticale, non cambia niente .

Non è corretto

funtion macchina(modello,colore)
{
this.modello=modello;
this.colore=colore;
this.motore=prova();
}

Facendo così ogni istanza di macchina (new macchina(...)) avrà una propria ed indipendente proprietà motore

macchina.prototype.motore= function()
{
....
}

Così invece avrai una unica proprietà motore condivisa tra tutte le istanze di macchina (risparmiando memoria)

[aeroxr1]

Originariamente inviato da wingman87

In sostanza esiste un'area comune a tutti gli oggetti di tipo macchina che è il prototype (di macchina). Se aggiungi il metodo al prototype, tutti gli oggetti possiedono il metodo ma il riferimento ad esso è unico (nel prototype). Se invece aggiungi il metodo ad ogni oggetto, tutti gli oggetti possiedono il metodo ma il riferimento ad esso è situato in ogni singolo oggetto, quindi è replicato n volte (dove n è il numero degli oggetti).


No, perché scrivendo dettaglia in quel modo lo stai evocando, quindi in e.onclick stai mettendo il valore restituito dall'evocazione del metodo, cioè nulla. Piuttosto l'uso di function in questo caso è equivalente a questo:

 e.onclick=function(){this.form.area_testo.value=''; dettaglia(this, 'Click')};

Infatti il valore restituito da Function è una funzione. Prima riga del link che ti è stato consigliato:

Every function in JavaScript is actually a Function object.

In realtà questa è la risposta alla tua domanda successiva


Il valore di this dipende dal contesto, quindi come dice la frase che hai estrapolato dal link, this è window.

Edit: in effetti il codice non sembra corretto, se funziona significa che ho sbagliato qualcosa nella spiegazione

Ho letto ora le vostre ultime risposte , oramai pensavo non mi avreste più risposto invece siete stati grandiosi

Grazie mi avete fatto capire cosa è il prototype

Comunque il this in quel caso non si riferisce al bottone premuto ? e quindi alla proprietà form del bottone premuto ? Dovrebbe essere quello il suo contesto no ? però in effetti il comportamento di quel this è ambiguo, perchè se fosse come dico io non rispetterebbe la frase che avevo evidenziato in precedenza
http://tweb.ing.unipi.it/book/exe/laboratori/1.4/
ma sembra funzionare quindi...

----------------------

Ora ho un altro paio di domandine , posso vivere anche con questi dubbi , ma magari se voi sapete che sono mi farebbe piacere togiermeli


quanti modi diversi ci sono per dichiarare una cavolo di funzione ? sono tutti equivalenti ?

var pippo = new Function ("dettaglia(this, 'Click')")

in pratica restituisce ad una variabile il riferimento alla funzione creata giusto ? quindi come nel caso sopra se premo il tasto onclick andrà a richiamare la funzione riferita , è corretto ciò che dico ?

Poi ci sono i seguenti due metodi :

funtion stampaNome()
{
....
}

poi un altro metodo è :

var stampaNome = function() {
  .....
}

La mia domanda è :

tutti questi metodi per dichiarare le funzioni a parte il metodo con il costruttore Function , sono identici ?
restituiscono tutti lo stesso risultato ?
in cosa differiscono nell'uso ?
posso richiamare stampaNome come una normale funzione in tutti e 2 i casi ?


Grazie ancora per le precedenti risposte

[DioBrando]

Originariamente inviato da aeroxr1

Ho letto ora le vostre ultime risposte , oramai pensavo non mi avreste più risposto invece siete stati grandiosi

Grazie mi avete fatto capire cosa è il prototype

Comunque il this in quel caso non si riferisce al bottone premuto ? e quindi alla proprietà form del bottone premuto ? Dovrebbe essere quello il suo contesto no ? però in effetti il comportamento di quel this è ambiguo, perchè se fosse come dico io non rispetterebbe la frase che avevo evidenziato in precedenza
http://tweb.ing.unipi.it/book/exe/laboratori/1.4/
ma sembra funzionare quindi...

----------------------

Ora ho un altro paio di domandine , posso vivere anche con questi dubbi , ma magari se voi sapete che sono mi farebbe piacere togiermeli


quanti modi diversi ci sono per dichiarare una cavolo di funzione ? sono tutti equivalenti ?

var pippo = new Function ("dettaglia(this, 'Click')")

in pratica restituisce ad una variabile il riferimento alla funzione creata giusto ? quindi come nel caso sopra se premo il tasto onclick andrà a richiamare la funzione riferita , è corretto ciò che dico ?

Poi ci sono i seguenti due metodi :

funtion stampaNome()
{
....
}

poi un altro metodo è :

var stampaNome = function() {
  .....
}

La mia domanda è :

tutti questi metodi per dichiarare le funzioni a parte il metodo con il costruttore Function , sono identici ?
restituiscono tutti lo stesso risultato ?
in cosa differiscono nell'uso ?
posso richiamare stampaNome come una normale funzione in tutti e 2 i casi ?


Grazie ancora per le precedenti risposte

Premessa generale: JavaScript risulta piuttosto ostico, soprattutto per chi viene da altri linguaggi (Java, C#) sia per un problema di design, sia perché non viene compreso correttamente il meccanismo di ereditarietà/prototipizzazione che risiede sul fatto di non avere classi, bensì sul concetto de, la metto giù brutalmente "ogni cosa è un oggetto".

Per quanto riguarda il tuo dubbio:

function stampaNome()
{
....
}

non è esattamente equivalente a

var stampaNome = function()
{
...
}

La prima è un'istruzione, la seconda è un'espressione, ove lo statement (istruzione function) viene associato o se preferisci, meglio, contenuto nella variabile stampaNome.


Per usare le parole di Douglas Crockford, cito testualmente:

To use the language well, it is important to understand that functions are values.
function statements are subject to hoisting. This means that regardless of where a function is placed, it is moved to the top of the scope in which it is defined. This relaxes the requirement that functions should be declared before used, which I think leads to sloppiness. It also prohibits the use of function statements in if statements. It turns out that most browsers allow function statements in if statements, but they vary in how that should be interpreted. That creates portability problems.
The first thing in a statement cannot be a function expression because the official grammar assumes that a statement that starts with the word function is a function statement. The workaround is to wrap the function expression in parentheses:

(function () { var hidden_variable;
// This function can have some impact on // the environment, but introduces no new // global variables.
})( );

A proposito di prototipi e contesto, è prassi comune utilizzare l'espressione
var that = this oppure var self = this in modo da poter catturare, valutare se necessario, l'"istanza" corrente (o meglio oggetto) anche quando this ha già terminato il suo ciclo di vita.

Esempio: carichi la pagina con il suo bel scriptino JavaScript, l'oggetto viene creato e termina il suo scope.
Un utente scatena un evento (clicca un bottone o altro), a questo punto, viene invocata la funzione di quell'oggetto.
"this" non esiste più perché sei già fuori da quel contesto e l'esecuzione arriva in un secondo momento: il "this" a questo punto è una finestra piuttosto che altro.

Ecco perché usiamo "that" o "self", come reference all'oggetto che ha determinato la funzione eseguita in seconda battuta.


Consiglio spassionato: leggete il libro "The Good Parts" (ma ce ne sono diversi simili) del già citato Douglas Crockford ed i suoi articoli, in particolar modo quelli su convenzione e stile di stesura del codice.

[aeroxr1]

grazie di tutto

mi procurerò certamente i libri che mi hai consigliato


stavo un pò facendo dei test , e ho notato un comportamento strano che mi ha mandato un pò in confusione .

programmazione attraverso Dom e senza usare il Dom ..

Se uso il Dom per accedere agli elementi vuol dire accedere ai nodi e agli elementi della pagina tramite le funzioni getElementById ecc ecc , ma se non volessi usare il dom ? mi serve capirlo , perchè a forsa di fare esercizi sul dom mi è venuto il dubbio se ci sia realmente la differenza tra i due modi di programmazione . Aiuto confusioneeeeeeee


Volevo disabilitare un bottone di id startbutton usando il javascript e ho fatto nella seguente maniera :

pulsantea=document.getElementById("startbutton");
pulsantea.disabled=false;

e ho visto che non funziona invece :

pulsantea.setAttribute("disabled","false");

che avrei pensato fosse il modo più giusto di farlo .

Ho visto invece che funziona anche nella seguente maniera :

startbutton.disabled=false;

non ho capito come fa a non funzionare la seconda ,
la terza invece sarebbe la maniera di accedere al button senza usare il dom , con il solo utilizzo dell'id giusto ?

dato che volevo disabilitare il bottone appena premuto avrei potuto farlo anche con un this ?

[DioBrando]

Originariamente inviato da aeroxr1

grazie di tutto

mi procurerò certamente i libri che mi hai consigliato


stavo un pò facendo dei test , e ho notato un comportamento strano che mi ha mandato un pò in confusione .

programmazione attraverso Dom e senza usare il Dom ..

Se uso il Dom per accedere agli elementi vuol dire accedere ai nodi e agli elementi della pagina tramite le funzioni getElementById ecc ecc , ma se non volessi usare il dom ? mi serve capirlo , perchè a forsa di fare esercizi sul dom mi è venuto il dubbio se ci sia realmente la differenza tra i due modi di programmazione . Aiuto confusioneeeeeeee


Volevo disabilitare un bottone di id startbutton usando il javascript e ho fatto nella seguente maniera :

pulsantea=document.getElementById("startbutton");
pulsantea.disabled=false;

e ho visto che non funziona invece :

pulsantea.setAttribute("disabled","false");

che avrei pensato fosse il modo più giusto di farlo .

Ho visto invece che funziona anche nella seguente maniera :

startbutton.disabled=false;

non ho capito come fa a non funzionare la seconda ,
la terza invece sarebbe la maniera di accedere al button senza usare il dom , con il solo utilizzo dell'id giusto ?

dato che volevo disabilitare il bottone appena premuto avrei potuto farlo anche con un this ?

Capiamoci, cosa intendi con "non funziona"?
Stai provando su più browser? Occhio perché il comportamento soprattutto di IE a volte è un po' balengo.

Potresti usare questa sintassi:

document.getElementById("startbutton").disabled = true;

Puoi tra l'altro decorare il botton HTML con l'attributo onCommand, in modo che il cambio del valore della proprietà disabled sia soggetto ad un evento particolare


Piccola notazione tendenzialmente si usa il camel case per gli Id HTML, nomi funzioni ecc.

Altro consiglio, se vuoi manipolare il DOM, più che attraverso JavaScript (per interventi piccoli ok), ma è forse preferibile andare direttamente di jQuery....

[aeroxr1]

Originariamente inviato da DioBrando

Capiamoci, cosa intendi con "non funziona"?
Stai provando su più browser? Occhio perché il comportamento soprattutto di IE a volte è un po' balengo.

Potresti usare questa sintassi:

document.getElementById("startbutton").disabled = true;

Puoi tra l'altro decorare il botton HTML con l'attributo onCommand, in modo che il cambio del valore della proprietà disabled sia soggetto ad un evento particolare


Piccola notazione tendenzialmente si usa il camel case per gli Id HTML, nomi funzioni ecc.

Altro consiglio, se vuoi manipolare il DOM, più che attraverso JavaScript (per interventi piccoli ok), ma è forse preferibile andare direttamente di jQuery....

devo cercare e capire cosa siano le jquery, ma per ora dato che non rientrano nel programma dell'esame che devo sostenere evito di fare cose in più , finito l'esame con calma lo guarda che mi interessa a me

Comunque per non funziona intendo che proprio non va , non mi setta il valore .. non capisco dove sia il problema , ma il bottore mi rimane sempre disabilitato

Ora cerco onCommand

I metodi per risparmiare memoria in javascript sono il prototype delle funzioni e ? ci sono altri metodi ?
Io adesso stavo facendo un progettino in javascript , ma per ora avevo creato due oggetti , non aventi metodi . Però poichè ci sono delle function che ho scritto che vengono usate più volte , mi conviene ripulire il codice in maniera che vi sia un oggetto che contenga i prototype di queste funzioni spesso utilizzate ?

Grazie ancora

[aeroxr1]

Originariamente inviato da DioBrando

A proposito di prototipi e contesto, è prassi comune utilizzare l'espressione
var that = this oppure var self = this in modo da poter catturare, valutare se necessario, l'"istanza" corrente (o meglio oggetto) anche quando this ha già terminato il suo ciclo di vita.

Esempio: carichi la pagina con il suo bel scriptino JavaScript, l'oggetto viene creato e termina il suo scope.
Un utente scatena un evento (clicca un bottone o altro), a questo punto, viene invocata la funzione di quell'oggetto.
"this" non esiste più perché sei già fuori da quel contesto e l'esecuzione arriva in un secondo momento: il "this" a questo punto è una finestra piuttosto che altro.

Ecco perché usiamo "that" o "self", come reference all'oggetto che ha determinato la funzione eseguita in seconda battuta.


Consiglio spassionato: leggete il libro "The Good Parts" (ma ce ne sono diversi simili) del già citato Douglas Crockford ed i suoi articoli, in particolar modo quelli su convenzione e stile di stesura del codice.

stavo riflettendo sul contesto e sul this , e non ho capito molto , però credo sia andato in contro ad un errore che c'entra qualcosa con quanto mi hai detto .

In pratica ho creato un oggetto campo gioco :

function campogioco ()
{
    this.x=x;
    this.y=y;
}

poi ho creato una funzione gestore che gestisce la pressione dei tasti direzione associandola all'evento onkeydown, in questa maniera :

campogioco.prototype.gestore=function()
{

}

document.onkeydown=recinto.gestore;

creo un oggetto campogioco dal nome recinto ,

var recinto=new campogioco(100,200);

ma se adesso in gestore uso this, ad esempio this.x , le cose non vanno come previsto e non si riferisce alla x contenuta nell'oggetto campogioco , mentre se faccio recinto.x non ho problemi...

dove sbaglio ? mmm

[nico159]

document.onkeydown=recinto.gestore;

Questo cambia il contesto in cui lavora il metodo gestore con l'elemento html che ha sollevato l'evento. this è document
Se vuoi preservare il normale comportamento di gestore devi scrivere il codice così:

document.onkeydown = function (e) {
recinto.gestore();
};

[aeroxr1]

Originariamente inviato da nico159

document.onkeydown=recinto.gestore;

Questo cambia il contesto in cui lavora il metodo gestore con l'elemento html che ha sollevato l'evento. this è document
Se vuoi preservare il normale comportamento di gestore devi scrivere il codice così:

document.onkeydown = function (e) {
recinto.gestore();
};

perchè nel secondo metodo non cambia il contesto ? uffa sul mio libro di teoria tutte queste cose non sono spiegate..

document.onkeydown = function (e) {
recinto.gestore();
};

l'event e va ripassato anche a gestore giusto ? cioè recinto.gestore(e) ; vero ?
EDIT: ho provato e funziona anche senza ripassarglielo.. come è possibile ? l'evento passa automaticamente e alla funzione handler , e quindi in questo caso non a reconto.gestore()....

Sinceramente un altra cosa che ho poco chiara è la differenza tra fare :

var pippo = function()
{

}

e

function pippo()
{}

nella prima var pippo va il risultato della funzione ? no vero ?
(avete tentato di spiegarmela parecchie volte , ma niente sono duro )


Per cercare di capire meglio i contesti ho seguito la guida su html.it , ma questo mi ha rimandato in paranoia , poichè non capisco bene come possa dare il risultato corretto http://www.html.it/pag/18588/isolare...elle-funzioni/

[wingman87]

Originariamente inviato da aeroxr1

perchè nel secondo metodo non cambia il contesto ? uffa sul mio libro di teoria tutte queste cose non sono spiegate..

Leggi qui, è spiegato molto bene: https://developer.mozilla.org/en-US/...Operators/this

Originariamente inviato da aeroxr1

document.onkeydown = function (e) {
recinto.gestore();
};

l'event e va ripassato anche a gestore giusto ? cioè recinto.gestore(e) ; vero ?
EDIT: ho provato e funziona anche senza ripassarglielo.. come è possibile ? l'evento passa automaticamente e alla funzione handler , e quindi in questo caso non a reconto.gestore()....

Non ho capito...

Originariamente inviato da aeroxr1

Sinceramente un altra cosa che ho poco chiara è la differenza tra fare :

var pippo = function()
{

}

e

function pippo()
{}

nella prima var pippo va il risultato della funzione ? no vero ?

No, in pippo va il riferimento alla funzione. Direi che la differenza è che nel primo caso la funzione è anonima ed è riferita tramite una variabile, nel secondo no...

[aeroxr1]

document.onkeydown = function (e) {
recinto.gestore();
};

non dovrebbe essere :

document.onkeydown = function (e) {
recinto.gestore(e);
};

in linea teorica mi torna di più , invece in pratica torna in entrambi i modi


comunque a suon di provare e riprovare ho capito un pò meglio il this e il contesto Ora leggo anche l'ultimo link che mi hai passato


Un ultima cosa , è possibile ad un click di un bottone non associare una funziona ma far si che al click corrisponda un cambiamento di una variabile ?

del tipo :

var locale=0;
bottone.onclick= (locale =5);

[wingman87]

Originariamente inviato da aeroxr1

document.onkeydown = function (e) {
recinto.gestore();
};

non dovrebbe essere :

document.onkeydown = function (e) {
recinto.gestore(e);
};

in linea teorica mi torna di più , invece in pratica torna in entrambi i modi

Nel primo caso e viene passato a gestore, nel secondo caso no...

Originariamente inviato da aeroxr1

Un ultima cosa , è possibile ad un click di un bottone non associare una funziona ma far si che al click corrisponda un cambiamento di una variabile ?

del tipo :

var locale=0;
bottone.onclick= (locale =5);

Non puoi farlo senza usare una funzione

[aeroxr1]

sono quasi arrivato a fine progetto e di cose ne ho imparate molte grazie a voi

ho una domanda sul precaricamento delle immagini

ho precaricato tre immagini

 this.coda=new Image(20,20);     
 coda.src="./img/elemento.png";
 capo=new Image(20,20);
 capo.src="./img/testa.png";
 topo=new Image(20,20);
 topo.src="./img/topo.png";

e ora le volevo usare attraverso il dom per aggiornare lo stile di alcuni piccoli div

precedentemente attraverso il dom impostavo la classe di questi div e poi usavo un css esterno riferito a tale classe per modificare lo sfondo,
ma cosi facendo ho notato che prima che ogni tanto venivano visualizzati i div senza sfondo fino a che non veniva caricato il rispettivo sfondo in cache.

Per risolvere a questo problema avevo pensato invece di impostare gli sfondi di appendere ai vari div un immagine senza impostarla come sfondo (a me va bene tanto non devo mettere altro nel div a parte l'immagine ) , però cosi facendo uso troppe volte il dom e sapevo che era meglio evitare di usarlo troppo poichè causa di rallentamenti ..

Che mi dite ?


p.s : ho trovato un problema con internet explorer 8... non mi risponde ai comandi il mio caro serpente,

document.onkeydown=function(e)
	 {
	 		that.gestore(e);
	 }

          campogioco.prototype.gestore=function(e)     //gestione della pressione dei tasti
{
  e=(!e) ? window.event : e;
 
 var tasto = (e.which != null) ? e.which : e.KeyCode;
 
 switch (tasto)

...

mi sembra di aver fatto tutto correttamente... boh... eppure prima mi sembrava andasse