Newsgroup: it.comp.lang.javascript
Titolo: Caricare 2 banner random ogni 6 secondi

Devo caricare contemporaneamente 2 banner a caso su 4 all'interno del sito
e caricarne altri due ogni 6 secondi.
Sotto c'è un esempio correttamente funzionante ma che ne carica 1 random
su 4 ogni 6 secondi.
Dovrei adattare lo script per caricare 2 ogni 6 secondi.
Qualcuno saprebbe dirmi come modificare questo script per fare questo?
<script>
//Carico dal database 4 banner e creo un array
var adv = new Array
('<a title="title1" href="
http://www.site1.com
"><img src="1.gif" alt="1"
border=0 ></a>','
<a title="title2" href="
http://www.site2.com
"><img src="2.gif" alt="1"
border=0 ></a>','
<a title="title3" href="
http://www.site3.com
"><img src="3.gif" alt="1"
border=0 ></a>','
<a title="title4" href="
http://www.site4.com
"><img src="4.gif" alt="1"
border=0 ></a>',')
//Funzione che ogni 6 secondi mi fa cambiare banner
function randomBanner(){ 
changeBanner();
setInterval("changeBanner()", 6000);
}
//Funzione che prende 1 banner a caso tra i 4 dell'array ->> Invece dovrei
fare in modo che ne prendesse 2 a caso contemporaneamente
function changeBanner(){
var rnd = Math.floor(Math.random() * adv.length);
document.getElementById('banner').innerHTML = adv[rnd];
}
</script>
//Spazio primo banner
<span id="banner[0]"></span>
//Spazio secondo banner
<span id="banner[1]"></span>
 
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

 }
Non vedo dove sia la complicazione...
function changeBanner( ){
        var rnd1 = Math.floor(Math.random() * adv.length);
        var rnd2 = rnd1;
        while( rnd2 == rnd1 )
                rnd2 = Math.floor(Math.random() * adv.length);
        document.getElementById('banner1').innerHTML = adv[rnd1];
        document.getElementById('banner2').innerHTML = adv[rnd2];
}
Si potrebbe fare anche più generico, volendo.
-- 
Ciao.
Blue

 TP/BP/Delphi/jscr/&c, FAQ items, links.

 while ( (rnd1=Random(L)) == (rnd2=Random(L)) ) ;
interessante questa istruzione
(X*Math.random())|0
 
Puoi spiegarla? Perché usi |0 anziché Math.floor?
-- 
Ciao.
Blue

 Prisco55 wrote:






-- 
questo articolo e` stato inviato via web dal servizio gratuito 


 E se i banner da pubblicare fossero 6?
non cambia nulla. Dal momento che lo script calcola l'indice in base
alla lunghezza dell'array con i riferimenti ai banner se questo
contiene 6,10,100 elementi lo script sceglierà comunque fra tutti
questi.
Il riferimento al farlo più generico era riferito al numero di banner
da visualizzare contemporaneamente.
--
Ciao
Blue

 Perché usi |0 anziché Math.floor?
a) è più breve da scrivere
b) floor è una funzione/metodo; | è un operatore: sulla carta, è più
veloce, benché la differenza non sia effettivamente apprezzabile nel
contesto in cui siamo.
-- 
~ "Io non vorrei subire un'ingiustizia nè commetterla, ma se
dovessi scegliere, preferirei subirla."
(Platone - "Gorgia")

 Blue


 Puoi spiegarla? Perché usi |0 anziché Math.floor?
Spero in una sua risposta anche in inglese, visto che non sembra parli 
italiano, nel frattempo diciamo che l'ipotesi piu' probabile e' che sia 
una questione di prestazioni dato che un'operazione a livello di bit e' 
piu' veloce in esecuzione rispetto alla chiamata ad un metodo.
Data la questione in oggetto non ritengo la differenza rilevante.

 talvolta si č usato ">>0", ad esempio.
Mea culpa quello, credo.
Rispondendo su un newsgroup non sacrificherei piu' la leggibilita' 
(intesa come leggibilita' anche per i neofiti) a meno che l'incremento 
di prestazioni non sia sostanziale.

 di prestazioni non sia sostanziale.
Corretto, ma non è neppure sbagliato mostrare delle alternative non
sempre note; può essere uno stimolo per approfondire.
E' poi, i bitwise operator sono i bitwise operator.. Riportano alla
memoria la vecchia e cara programmazione di un tempo. :)
-- 
~ "L'amore è la risposta.
Ma mentre aspetti la risposta,
il sesso fa nascere alcune buone domande."
(Woody Allen)

 ha scritto
:

Là, |0 è bitwise il numero intero O.
K_ = 500000
D0_ = new Date()
Q_ = K_ ; while (Q_--) { (123.45)|0 }
D1_ = new Date()
Q_ = K_ ; while (Q_--) { Math.floor(123.45) }
D2_ = new Date()
Q_ = [D1_-D0_, D2_-D1_] //       ->   187,860 // ms
        (X*Math.random())|0
        Math.floor(X*Math.random())
È più piccolo e più velocemente.
È una buona idea leggere il newsgroup c.l.j ed il relativo FAQ. Veda sotto.


 vengono prima convertiti perdendo quindi la loro parte decimale.
Grazie della spiegazione. In effetti tendo a spiegarmi male... avendo
studiato c (ed altri programmi con sintassi simile) immaginavo cosa
fosse |, comunque avevo cercato e trovato che si trattava dell'operatore di
or logico bit a bit. Ho usato anch'io operatori su bit in passato (per
verificare se un numero intero era pari oppure per moltiplicarlo/dividerlo
per 2). 
Però non capivo perché un'operazione di questo genere restituisse un valore
identico a quello ottenuto da Math.floor(), ora l'ho capito.
Grazie.
-- 
Ciao.
Blue

 di prestazioni non sia sostanziale.
Concordo con Zero, usarli può essere uno spunto. Ad esempio io ho imparato
una cosa nuova, che probabilmente non avrei visto altrimenti. Imho, più che
evitare certe tecniche è meglio darne una breve spiegazione. Soprattutto,
come in questo caso, in cui dalle specifiche non è proprio immediato capire
il perché funzionano (in questo caso sapere cosa fa non era sufficiente,
almeno per me).
-- 
Ciao.
Blue

 sotto.
Grazie dei link, sono molto utili! 
-- 
Ciao.
Blue

 almeno per me).
Si', concordo totalmente con voi: ma non introdurrei piu' cosi' "a 
casaccio" l'utilizzo di forme tipo "n >> 0" o "n | 0" come feci allora.
Quando la discussione si approfondisce e' solo bene mettere un qualcosa 
in piu', altrimenti i newsgroup sarebbero solo un domanda e risposta e 
sarebbe piuttosto noioso...

 Č una buona idea leggere il newsgroup c.l.j ed il relativo FAQ. Veda sotto.
Doc, finalmente parli italiano! Vai avanti cosě ^__-
[ Doc, you are speaking italian finally! Go ahead ^__-  ]
-- 
mailto: y = i
------------------------------------------------------
http://www.catarsi.it
Vivo nel terrore di non essere frainteso (Oscar Wilde)

 banner scelti a caso tra 10 che estraggo dal database.
Beh... mano a mano che il numero di banner da visualizzare cresce diventa
sempre più complesso verificare che non ci siano doppioni. Un algoritmo
implementato stupidamente potrebbe avere complessità O(n*n).
Per evitarlo ti serve l'appoggio di una struttura dati adeguata. Qui di
sotto ti posto un esempio. Tieni conto che l'ho scritto mentre ero al
telefono... quindi probabilmente si può migliorare. Ad ogni modo dovrebbe
funzionare.
Sarebbe interessante, invece, sapere come Dr J R lo ottimizzerebbe, al di là
della strategia usata.
function Random(X) { return (X*Math.random())|0 }
       
var L = adv.length;
// array contenente gli id degli oggetti dove inserire i banner
var array_id = [ 
        "banner1",
        "banner2",
        "banner3",
        "banner4",
        "banner5",
        "banner6" 
        ];
var num_banner_da_vis = array_id.length;
var array_indici = [];
// uso --num_banner_da_vis >= 0 perché riuso num_banner_da_vis come indice
// per array_id, quindi devo partire da num_banner_da_vis -1 fino a 0
// compreso
while( --num_banner_da_vis >= 0 ) {
    var indice = Random(L);
    // ricalcolo l'indice finché non ne ottengo uno non usato
    while ( array_indici[ indice ] )
        indice = Random(L);
    // segno nell'array d'appoggio che l'indice è stato usato
    array_indici[ indice ] = 1;
    // assegno il banner
    var banner = document.getElementById( array_id[ num_banner_da_vis ] );
    banner.innerHTML = adv[ indice ]; 
}
Il tutto (tranne la funzione Random) può essere messo all'interno di una
funzione, passando adv e array_id come parametri.
-- 
Ciao.
Blue

 Doc, finalmente parli italiano! Vai avanti cosě ^__-
Lo sai, vero, che ti aspettavo al varco?
Non so te, ma io sono rimasto affezionato a "Doc" da quando lessi questa 
frase sul suo sito:
"there is a person of my name from UT who seems to have been talented at 
the public competitive insertion of spherical objects into nominally 
wicker receptacles".
Giusto per essere educati, ora mi tocca tentare di spiegarlo anche in 
inglese... so: "I've been fond of 'Doc' since I've read that sentence on 
his website [citation above]".
Ad maiora

 del numero reale. 
Beh, in verità anche questo lo si capisce dalla documentazione. Dal
link che ti ho scritto nell'altro reply:
"The operands of all bitwise operators are converted to signed 32-bit
integers in big-endian order and in two's complement format."
-- 
~ Se potete leggere questo, la mia donna è caduta.
(Letta sul retro di una maglietta di un motociclista)

 integers in big-endian order and in two's complement format."
Ah.. Mi era sfuggito...
--
Ciao
Blue

 inglese... 
Io evito, ché siccome son le 9:30, vorrei terminare e inviare il post
prima del tramonto :-)
Cerco di cavarmela con una sintesi forse un po' caramellosa, ma di certo
inequivocabile: 
Dr J R Stockton, you're welcome.


 della strategia usata.
Ah... una cosa che ho dato per scontata... Se devi visualizzare 6
banner su 10 è molto probabile che  l'algoritmo dovrà ricalcolare
molte volte gli indici perché già usati. Nel caso in cui devi
visualizzare una buona parte dei banner disponibile userei una
strategia diversa...
Ipotizzando di avere un array contenenti i banner
arr_ban = [ b1, b2, b3, b4, b5, b6, b7, b8, b9, b10 ]
lo mescolerei in modo che diventi tipo
arr_ban = [ b4, b8, b1, b5, b10, b9, b3, b7, b2, b6 ]
quindi visualizzerei i primi 6
div_ban1.innerHTML = arr_ban[1];
div_ban2.innerHTML = arr_ban[2];
div_ban3.innerHTML = arr_ban[3];
div_ban4.innerHTML = arr_ban[4];
div_ban5.innerHTML = arr_ban[5];
div_ban6.innerHTML = arr_ban[6];
Il tutto quindi dipende dall'efficienza dell'algoritmo usato per
mescolare l'array.
Un esempio:
function scambia(  elemento1, elemento2  ){
  var tmp = elemento2;
 elemento2 = elemento1;
 elemento1 = elemento2;
}
function mescola( array ) {
  for( var i=0, max=array.length; i<max; i++)
     scambia( array[i], array[ random( max ) ] );
}
Sono sicuro però che in internet puoi trovare qualcosa di migliore.
--
Ciao
Blue

 smisurata di insulti gratuiti
E' vero me ne sono accorto anch'io,
ieri sono rimasto quasi sbalordito per un thread che girava in
it.programmare o informatica o non lo so' piu' perche' l'ho gia' tolto
dalla mia lista
e per tanti altri post

 - see 00index.htm
 Dates - miscdate.htm moredate.htm js-dates.htm pas-time.htm critdate.htm etc.

 Timo Salmi's Turbo Pascal FAQ.

Ciao Dr J R Stockton,
Te e BluSky siete molto esperti io sono invece un junior in javascript e
non riesco a capirci nulla della tua guida.
Potresti gentilmente scrivere il codice che devo inserire nel mio sito per
fare girare questo script?
Vorrei semplicemente poterlo inserire all'interno del mio sito. 
Non capisco niente delle funzioni che scrivi quindi sarebbe impossibile
potere adattare un tuo script alla mie esigenze.
Grazie dell'aiuto.
Prisco55








-- 
questo articolo e` stato inviato via web dal servizio gratuito 


 non riesco a capirci nulla della tua guida.
Dr J sicuramente, è anni luce avanti a me.
Comunque Dr J ha semplicemente suggerito come rendere più intelligente
l'algoritmo che ho scritto per mescolare l'array. In pratica "critica" il
fatto che non è in grado di mescolare bene l'array, in quanto è probabile
che alcune combinazioni capitino molto più spesso di altre. E questo, in
genere, è male.
L'accorgimento di Dr J è quello di passare come parametro alla funzione
random il contatore del loop, anziché la dimensione dell'array, così da
aumentare le combinazioni possibili.
Puoi quindi usare il codice che ho scritto prima, con unica variante la
funzione mescola, così come la riscrivo qui sotto.
function mescola( array ) {
  for( var i=0, max=array.length; i<max; i++)
     scambia( array[i], array[ random( i ) ] );
}
Questo almeno quanto suggerito nel post, non ho ancora avuto tempo di
leggere cosa scrive sul sito a tal proposito.
-- 
Ciao.
Blue

         the Banners?
Ma se l'array di Banners è costituito da stringhe, nell'array effettivamente
non compaiono i riferimenti (della dimensione di un intero)? Quindi perché
dovrebbe esserci un aumento di efficenza lavorando con array di numeri
anziché con array di stringhe?
-- 
Ciao.
Blue

 constant.
Ok, interessante osservazione. Grazie per il suggerimento! Immaginavo che il
mio algoritmo non fosse validissimo sotto quest'aspetto. Ma se usassimo
ogni volta l'array mescolato la volta precedente, andrebbe meglio?
-- 
Ciao.
Blue

.
Č una buona idea leggere il newsgroup c.l.j ed il relativo FAQ. Veda sotto.
-- 


 Uso i pesci de Babele
Scusate, capito al volo e mi permetto di ridere: questa è
meravigliosa :-D
-- 
Nando [!]
Apostolo della Prova

 - FAQqish topics, acronyms & links;
  Astro stuff via astron-1.htm, gravity0.htm ; quotings.htm, pascal.htm, etc.
 No Encoding. Quotes before replies. Snip well. Write clearly. Don't Mail News.

 - FAQish topics, acronyms, & links.
 Proper <= 4-line sig. separator as above, a line exactly "-- " (SonOfRFC1036)
 Do not Mail News to me. Before a reply, quote with ">" or "> " (SonOfRFC1036)


function mescola( array ) { var T, j
  for( var i=0, max=array.length; i<max; i++) { j = random(i)
    //  scambia( array[i], array[j] );  // viene a mancare
    T = array[i] ; array[i] = array[j] ; array[j] = T }
  }
A = [0,1,2]
mescola(A)
A
-> [1,2,0] e [2,0,1] ; ma non [0,1,2] [0,2,1] [1,0,2] [2,1,0]
function Shuffle(Q) { var R, T, J
  for (J=Q.length-1 ; J>0 ; J--)
    { R=Random(J+1) ; T=Q[J] ; Q[J]=Q[R] ; Q[R]=T }
  return Q }
A = [0,1,2]
Shuffle(A)
A
-> [1,2,0] [2,0,1] [0,1,2] [0,2,1] [1,0,2] e [2,1,0]
Lo scambio dovrebbe essere scritto in linea piuttosto che come funzione,
entrambe per rendergli il lavoro e per renderlo più veloce.
-- 
 (c) John Stockton, Surrey, UK.  ?@
merlyn.demon.co.uk
   Turnpike v6.05   MIME.


 >}
Ehm... yes... I thougth this...
Ehm... si... pensavo a questo...
function scambia( array, index1, index2 ) {
   var tmp = array[ index1 ];
   array[ index1 ] = array[ index2 ];
   array[ index2 ] = tmp;
}
--
Ciao
Blue

 entrambe per rendergli il lavoro e per renderlo più veloce.
Scusa ma non riesco a capire "per rendergli il lavoro". Come lo
diresti in inglese?
Grazie.
--
Ciao
Blue

 ora ha e mostra
codice per ripetutamente la visualizzazione delle sei immagini
differenti (delle cifre) scelte a caso da dieci.
-- 
 (c) John Stockton, Surrey, UK.  ?@
merlyn.demon.co.uk
   Turnpike v6.05   MIME.
