Fade .....

[whisher]

function setOpacity(el,value) {
    el.style.opacity = value/10;
    el.style.mozOpacity = value/10;
    el.style.filter = 'alpha(opacity=' + value*10 + ')';
}
function fade(o,s,d,el){
    var opt=  (o == undefined || o=='')?10:o;
    var stop= (s == undefined || s=='')?3:s;
    var delay= (d == undefined || d=='')?100:d;
    if(!el){return;}
          var self= el;
          var timeoutID = window.setInterval(f, delay);
    
    function f(){    
        if(opt>stop){
            opt--;
            setOpacity(self,opt);
        }
        else {
            window.clearTimeout(timeoutID);
        }
    }
}

window.onload= function(){
    var _img= document.getElementsByTagName('img')[0];
    _img.onclick=function(){
        fade(9,6,100,this);
    }
} 

Suggerimenti

[andr3a]

Originariamente inviato da whisher
Suggerimenti

ho letto poco e parto con questo ....

var opt=  (o == undefined || o=='')?10:o;

undefined || '' portano allo stesso risultato.

Se vuoi evitare di ignorare lo zero devi usare il typeof (in casi particolari anche il constructor)

var opt=  o || 10;

questo di solito basta ... ma se si tratta di evitare lo zero ...

var opt = typeof o == "number" || o instanceof Number ? o : 10;

questo è il modo giusto per avere quel valore (accetta numeri o istance di Number ... come new Number(N) che non è un typeof "number")

Nel tuo caso ... null sarebbe ambiguo, false o new Boolean(false) ? ambiguo ... ed un valore ambiguo non va mica bene (error prone)


[edit]
se usi un nome globale come setOpacity non ha sensoi usare poi il ridondante window per arrivare al clearTimeout, dato che non ci sono variabili con quel nome in quello scope

[whisher]

Grazie per i suggerimenti

ma se si tratta di evitare lo zero ...

var opt = typeof o == "number" || o instanceof Number ? o : 10;

questa però non mi torna

var o=0;
var opt = typeof o == "number" || o instanceof Number ? o : 10;
alert(opt); 

typeof o == "number" (è true)

quindi torna 0
va bene se accetti solamente valori numerici o sbaglio ?

se usi un nome globale come setOpacity non ha sensoi usare poi il ridondante window per arrivare al clearTimeout, dato che non ci sono variabili con quel nome in quello scope

buono a sapersi praticamente

     var timeoutID = setInterval(f, delay); 
     
    function f(){     
        if(opt>stop){ 
            opt--; 
            setOpacity(self,opt); 
        } 
        else { 
            clearTimeout(timeoutID); 
        } 
    } 

ero convinto che si dovesse usare sempre window.
almeno in tutti gli esempi anche in MDC ci mettono window.

[andr3a]

Originariamente inviato da whisher
questa però non mi torna ...

beh, è logico che se sei tu a dichiarare la variabile subito prima non serve a niente fare alcuna verifica ... sai già di che tipo è e che valore contiene, o sbaglio?

Originariamente inviato da whisher
ero convinto che si dovesse usare sempre window.
almeno in tutti gli esempi anche in MDC ci mettono window.

non nei miei ... comunque sia sempre il solito discorso, JS è come se fosse sempre eseguito in questo modo

with(window){
// tutto il JS che vuoi
}

quindi window.this, window.window, window.self, window.window.window ... sono tutti riferimenti al globale window ... ergo aggiungere window davanti a qualsiasi cosa è ridondante e non serve a niente a meno che tu non abbia definito una variabile/funzione con lo stesso nome all'interno di uno scope diverso

function pippo(callback){
	function setTimeout(delay){
		(self || window || this).setTimeout(callback, delay);
	};
	setTimeout(1000);
};

pippo(function(){
	alert("è passato circa un secondo");
});

solitamente in questo singolo caso si preferisce usare il self (anche this ma è più particolare) giusto perchè è più corto a scriversi

Per concludere, qualora tu abbia paura che altri possano ridefinire window o self, per avere in qualunque parte del codice il riferimento globale puoi fare così

// pippo sarà === a window.pippo e === a self.pippo o this.pippo
var	pippo = "function(){alert(window.pippo); alert((function(){return this})().pippo)}";
(function(){
	// se ridefinite possono confondere
	var	self = "bye bye",
		window = self;
	
	alert(window.pippo);	// undefined
	alert(self.pippo);	// undefined
	alert(pippo);		// stringa funzione
	eval(pippo)();		// prima undefined poi stringa funzione
})();

caso atipico poichè sul global scope non puoi ridefinire window ... quindi, alla fine, se non hai dichiarato variabili usando nomi globali di funzione o di variabili stesse, scrivere window.quelloCheTiPare o quelloCheTiPare e basta è la stessa identica cosa solo che nel secondo caso è addirittura meglio perchè:

window.quelloCheTiPare cerca la variabile globale window e poi cerca quelloCheTiPare dentro la stessa

mentre

quelloCheTiPare cerca direttamente nella variabile globale, 1 passaggio in meno (appunto perchè è ridondante)

spero sia più chiaro

[whisher]

Che dire grazie