(function(){})() ???

[andr3a]

No Mega ... quella variabile si è una stringa, non una funzione, la stringa tornata dalla funzione.

scrivere questo:

var si = function(){return "... ma non sempre"}();

o scrivere questo (sempre preferibile)

var si = (function(){return "... ma non sempre"})();

è l'equivalente, usando una funzione piuttosto che una anonima, come scrivere questo:

function dimmiQualcosa(){
	return "... ma non sempre";
};
var	si = dimmiQualcosa();

[Mega69]

Ho capito, però non mi spiego perchè questo funziona:

var si = function(){return "... ma non sempre"}()

e questo no:

function(){return "... ma non sempre"}()

L'assegnazione centrerà qualcosa...
Quello che voglio dire io è che sì è una stringa, ma prima di esserlo era una funzione:

(si = function(){return "... ma non sempre"})()

PS: Probabilmente sto dicendo un sacco di boiate

[H5N1_Aviaria]

Nell'assegnazione dichiari che si è il risultato di una funzione (anonima) e non la funzione.
Anche nel primo caso vale la stessa cosa.

[Mega69]

MI sa che mi devo ripetere le basi fondamentali di javascript
Solo adesso mi sono accorto che l'ultimo esempio da me postato è semplicemente sbagliato perchè si è una funzione e non una stringa...

[andr3a]

Originariamente inviato da Mega69

(si = function(){return "... ma non sempre"})()

no Mega ... NO!

si = (function(){return "... ma non sempre"})()
si = (function(){return "... ma non sempre"}())
si = function(){return "... ma non sempre"}()

riguardo l'assegnazione, se omessa, ottieni un syntax error ma se utilizzi le tonde non avrai problemi a prescindere che ci sia o meno un return

function(){}(); // syntax error
(function(){})(); // nessun errore

[Mega69]

Ho fatto la solita figura di m... ma almeno ho capito qualcosa di nuovo
Grazie dell'ennesimo chiarimento

Ps: l'ultimo messaggio non serviva, me ne ero accorto che quel codice non centrava assolutamente na mazza visto che quello è un caso dove effettivamente si è una funzione.
Cmq grazie lo stesso

[pietro09]

per andr3a

Scusa se riesumo il post, ma era solo per dire che col tuo suggerimento sono finalmente riuscito senza trucchi ad assegnare eventi parametrizzati con un ciclo:

Giusto per capire, se ho alcuni input e voglio in un ciclo assegnare all'evento click di ognuno, la funzioone alert(i) faccio come hai suggerito:

window.onload = function()
{
    var bs = document.getElementsByTagName("input");
    var n = bs.length;
    
    for(var i = 0; i < n; i++)
    {
        var b = bs[i];
        b.onclick = (function(s){return function(){alert(++s);};})(i);
        
    }
}

è solo un esempio semplice naturalmente, ma mostra tutta la potenza di quel costrutto.
Non usandolo probabilmente il codice divverrebbe più complesso :master:
Ciao

[andr3a]

esatto pietro, quello è uno dei tanti modi per sfruttare le cosiddette closures di JavaScript... andiamo avanti con l'approfondimento?

window.onload = function(){
	for(var
		bs = document.getElementsByTagName("input"),
		i = 0;
		i < bs.length;
		i++
	){
		bs[i].onclick = (function(i){
			// la i che arriva in questa funzione
			// non c'entra niente con la i esterna
			// ed avrà il giusto valore
			// del momento e non l'ultimo assegnato
			// dal ciclo for esterno
			

			return	function(){
				// questa funzione può chiamare
				// variabili nella closure esterna
				// (quella con la nuova i)
				// e fuori ancora fino alla window
				// passando per l'onload ...
				// quindi anche bs sarà raggiungibile
				alert(++i);
				// il primo input al primo onlcick
				// mostrerà 1, il secondo 2 e via dicendo
			};
		})(i);	// la i del for che alla fine sarà === bs.length
	};
};

fin qui è tutto chiaro, bello e semplice ... ma se vogliamo preoccuparci anche della memoria utilizzata e delle performances dobbiamo valutare cosa accade in questo esempio: 2 funzioni nuove memorizzate per ogni input!

Anche se quella "esterna" viene utilizzata solo per racchiudere quella i, nell'esempio di pietro quella s, questa non potrà essere eliminata dal Garbage Collector finchè il nodo associato non verrà rimosso e cancellato (reso non riutilizzabile).

Sebbene il trucchetto sia comodo ed in questo caso di semplice gestione anche per i PC più datati, qualora le operazioni fossero molte di più, cosa che capita facilmente, sarebbe un sistema di difficile digestione e/o portabilità.

In questi casi è sempre consigliabile utilizzare lo scope dell'oggetto al fine di sfruttare e memorizzare una sola funzione piuttosto che N.
Per evitare infatti di ritrovarsi una variabile i ormai incrementata e con valore pari alla length degli input basta salvarla nel nodo occupando memoria per un'intero, memoria irrisoria se confrontata a quella necessaria per immagazzinare dozzine di funzioni alla volta più le variabili inviate a queste funzioni (la i nel mio esempio, la s in quello di pietro) che possono essere numerose.

Ecco quindi come ottimizzare il tutto ottenendo lo stesso risultato:

function onBSClick(){
	alert(++this.i);
};

window.onload = function(){
	for(var
		bs = document.getElementsByTagName("input"),
		i = 0;
		i < bs.length;
		i++
	){
		bs[i].i = i;			// assegno questa i al nodo
		bs[i].onclick = onBSClick;	// assegno un riferimento alla funzione
						// invece di usare 2 closures
						// ogni nodo per fare sempre la stessa cosa
	};
};

Questo ha poco a che fare con le closures ma in realtà è una conseguenza naturale per evitare bad practices di programmazione anche dove consentite, ovvero utilizzando miriade di closures non sempre indispensabili come in questo semplice esempio.

[pietro09]

Me lo leggerò con calma e per me puoi continure all'infinito: leggo di sicuro

[pietro09]

l'ultimo esempio lo usavo già; ma non sapevo le sue prestazioni