Newsgroup: it.comp.lang.javascript
Titolo: numero random

Ciao,
ho provato varie soluzioni ma non ne vengo a capo.
Dovrei estrarre un (solo) numero da 1 a 10, ma dall'estrazione devono 
essere esclusi dei numeri presenti in un array.
Ho provato così, poi mi sono reso conto che non può andare.
// possono uscire tutti i numeri tranne questi:
a = [2, 3, 4, 5];
for (i=0; i<10; i++) {
	do {
		xt = Math.floor(Math.random()*10);
	} while (xt == a[i]);
}
Qualcuno che mi aiuta?   :-)

 essere esclusi dei numeri presenti in un array.
La Contain può esserti d'aiuto?
 
http://www.criosoftware.it/default50.aspx
-- 
"Ho smesso di fumare.
 Vivrò una settimana di più.
 E in quella settimana pioverà a dirotto"
									    W.A.

 La Contain puņ esserti d'aiuto?
ammetto di non capire bene in che modo...

 ammetto di non capire bene in che modo...
Riprendendo il tuo esempio, al volo senza testare:
var a = [2, 3, 4, 5], xt=Math.floor(Math.random()*10);
while(a.Contain(xt))
 xt = Math.floor(Math.random()*10);
-- 
"Voi abili a tenere sempre un piede qua e uno lą
 avrete un avvenire certo in questo mondo qua
 perņ la dignitą
 dove l'avete persa?"
									    V.R.

 ha scritto:

Personalmente, innanzitutto genererei un numero casuale "confinato" nei
limiti necessari... mi spiego meglio.
Nel tuo esempio, 4 numeri devono essere esclusi (2,3,4 e 5), quindi devi
generare un numero casuale in un insieme di 6 possibilità; pertanto
genererei un numero casuale intero tra 0 e 5 (sei valori) con
  xt = Math.floor(Math.random()*6)
(NB: Math.random() restituisce, se non erro, un numero 0<=x<1)
Se si tratta solo di 10 "scelte", poi, puoi pensare di tenere un array con
i numeri consentiti, e non con quelli proibiti; nel tuo caso sarebbe
  allowedNumbers = [1,6,7,8,9,10]
A questo punto, il numero casuale che ti serve sarebbe
  rndNumber =
allowedNumbers[Math.floor(Math.random()*allowedNumbers.length)]
o, per renderlo più leggibile:
  rndIndex = Math.floor(Math.random()*allowedNumbers.length);
  rndNumber = allowedNumbers(rndIndex);
-- 
Nando [?]
Apostolo della Prova


Se devi estrarre un solo numero non capisco il ciclo for (i=0; i<10;
i++) a cosa serve
hai il tuo numero aleatorio xt = Math.floor(Math.random()*10)
poi devi controllare che non sia uguale ad un numero contenuto
nell'array a
a = [2, 3, 4, 5];
for (i=0; i<a.length; i++){if (xt==a[i]) { xt =
Math.floor(Math.random()*10);i=0 }}
così dovrebbe funzionare senza problemi

 Math.floor(Math.random()*10);i=0 }}
ho riadattato la soluzione di Cristiano Larghi, che ringrazio, anche 
perché mi fa scoprire sempre cose interessanti (per me)  :-)
Quanto alla tua soluzione, non capisco il senso di questo:
{if (xt==a[i]) { xt = Math.floor(Math.random()*10);i=0 }}
Vediamo se ho capito (ho qualche dubbio):
se xt è uguale a uno tra 2,3,4 e 5, tu riestrai.
Ma cosa mi dice che ri-estraendo non avrò un numero tra 2,3,4 e 5?
Questo sempre se ho capito e senza offesa.

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

 Questo sempre se ho capito e senza offesa.
Certamente puoi riaverlo, infatti in quel caso la variabile i viene
posta a zero, quindi il ciclo inizia di nuovo. Il ciclo terminerà solo
dopo che la condizione sia stata soddisfatta. Si tratta naturalmente di
una fra le tante soluzioni, forse neanche la più elegante, ma ho
voluto contribuire frettolosamente alla soluzione del tuo problema.

Dr J R Stockton ha scritto:
come dicevo, ho riadattato la soluzione di Cristiano Larghi.
In questo modo:
function test(t, ra) {
	var raLen = ra.length;
	for (var i = 0; i<raLen; i++) {
		if (ra[i] == t) {
			return true;
		}
	}
	return false;
}
var a = [2, 3, 4, 5];
var xt = a[0];
while (test(xt, a)) {
	xt = Math.floor(Math.random()*10);
}

 a = [2, 3, 4, 5];
So che la problematica è già stata risolta; inoltre l'approccio che ti
propongo non risponde esattamente alla domanda. Ma quantomeno potrebbe
essere un modo differente di vedere la cosa che potrebbe tornare utile
in futuro.
Dico che "non risponde alla domanda", perché elimina l'array. In altri
termini, il codice ti genera un numero compreso tra 1 e 10, escludendo
i numeri 2, 3, 4 e 5:
	n = (5 + ( Math.floor( Math.random()*6) ))%10 + 1;
-- 
~ "Ciò che il cuore conosce oggi, la testa comprenderà domani"
(Seneca)


perchè così lunga?
questa è uguale ma più corta
a = [2, 3, 4, 5];
for (i=0; i<a.length; i++){
if (xt==a[i]) {
xt =Math.floor(Math.random()*10);
i--;
}
}

 i--;
uhm ... seguiamo i passi 
xt iniziale=4
i=0, 4=2 false
i=1, 4=3 false
i=2, 4=4 true => i=i--=1
 ricalcolo xt e esce 2
i=1, 3=2 false
i=2,4=2 false
i=3,5=2 false
e cosě restituisce 2 (che č errato)...
se vuoi seguire questa logica devi ricontrollare tutto (i=-1, non i--)
-- 
"Ti sei salvato
 o sei entrato in banca pure tu?"
									    A.V.

 se vuoi seguire questa logica devi ricontrollare tutto (i=-1, non i--)
Giustissimo, ma mica tutto solo i=-1
Ti ringrazio per aver avuto la pazienza di testare il codice, una
ragione in più per incoraggiare il lavoro in rete e la collaborazione
fra programmatori.
ho provato il codice così:
<html>
<head>
</head>
<script type="text/javascript">
function lavispateresa(){
var risultato = document.getElementById('risultato');
var xt = 2;
a = [2, 3, 4, 5];
for (var i=0; i<a.length; i++){
if (xt==a[i]) {
xt =Math.floor(Math.random()*10);
i=-1;
}
}
risultato.appendChild(document.createTextNode(risultato.value+'xt =
'+xt+'\n'));
}
</script>
<body>
<button onClick="JavaScript:lavispateresa();">Vai</button>
<br /><br />
Risultato<br />
<textarea id="risultato" rows="30" cols="10"></textarea>
</body>
</html>
La soluzione di Zero è la più elegante, tutto ciò che può evitare
un ciclo ricorsivo è sempre meglio perchè fa risparmiare tempo.
Bisognerebbe pensare ad una formula generale, che valga per altri casi.

 Bisognerebbe pensare ad una formula generale, che valga per altri casi.
Come ho detto la mia soluzione parte dal presupposto che l'array sia
presente come parte di una soluzione, non dei dati di partenza. Come
tale può essere eliminato, se si opta per un approccio diverso.
La soluzione usata è ovviamente applicabile anche in altri casi dove
si ha un insieme discreto e continuo di valori non ammessi, come nel
caso preso in esame.
Se invece abbiamo una lista di valori non continui, o l'array non si
può eliminare perché fa parte del problema; va da sè che l'approccio
non è più utilizzabile. E' comunque possibile avere una versione più
ottimizzata anche in quel caso: usare un object al posto di un array
ad esempio, o fare dei calcoli a monte per evitare cicli ridondanti,
se si deve per forza avere una lista in forma di array.
-- 
~ Io sono il più importante dei miei problemi.

 se si deve per forza avere una lista in forma di array.
È vero, però sai che dati una serie di valori conosciuti è quasi
sempre possibile estrapolare una formula matematica che li rappresenta,
il fatto è che si tratta di un esercizio lungo, con un ciclo si crea
il codice più velocemente a scapito della velocità di esecuzione.
È difficile conciliare il tempo disponibile e l'eleganza nella
programmazione.

 programmazione.
Non sempre è immediato o facile, è vero, ma ci si può provare. :)
E poi tiene in allenamento il cervello.. un po' come la settimana
enigmistica, o i classici problemi matematici.
-- 
~ L'ingegnere non vive, funziona.

 ~ L'ingegnere non vive, funziona.
Ancora più giusto

 On 26 Jan 2007 03:30:52 -0800, Oreste wrote:
sono dovuto andare a leggere tutto il thread su Google Gruppi perché 
Thunderbird ha "saltato" (non so perché) un po' di messaggi: la 
soluzione di ZERO era su Google Gruppi, ma non nel mio newsreader, per 
intenderci. Detto questo, devo dire due cose: 1) avrei usato la cosa in 
Flash (forse è antipatico a dirsi, ma su AS non ci sono forum di cui mi 
fido abbastanza, anche se la speranza ce la metto sempre), 2) l'array è 
lineare con indici numerici, che in AS, che io sappia, è più veloce 
dell'Object (o array associativo) quando si cicla.
Si tratta di un meccanismo di cache: dei numeri vengono accodati via 
push ad un array in determinate condizioni. Prima del push c'è un 
controllo di quello che c'è già nell'array. Se un valore è già presente, 
insomma, non può essere reinserito.
In altre condizioni, lo stesso array viene svuotato ed in altre ancora, 
shift e push fanno passare il primo elemento ad ultimo, spingendo il 
primo in fondo all'array e facendo sì che il secondo diventi primo.
Tutto questo, fatto con un Object, avrebbe comportato qualche 
grattacapo: l'array era più flessibile, imho.
Quando, però, stavo per ri-architettare il tutto è giunta la risposta 
giusta. Ancora grazie   ;-)

 grattacapo: l'array era più flessibile, imho.
No, anzi, direi il contrario. Almeno per quanto riguarda il check di
valori non ammessi (e quindi anche duplicati).
A questo punto però non capisco il tuo primo post.. cosa c'entrano i
numeri random?
-- 
~ "Affronta gli ostacoli e fa qualcosa per superarli.
Scoprirai che non hanno neanche la metà della forza che pensavi
avessero." (Norman Vincent Peale)

 salvo quache volta fare una "spanciata"
:)
 
-- 
~ Non ci sono certezze, solo ragionevoli probabilità.
(W. Howe)

 numeri random?
ZERO, č una lunga storia troppo lunga, non ce la faccio... :-)
Mi dici, perņ (se tu ce la fai), come avresti usato l'Object?
Avresti aggiunto dinamicamente una proprietą? Tipo obj.randomN = 13; ?

 Avresti aggiunto dinamicamente una proprietà? Tipo obj.randomN = 13; ?
Con un Object puoi fare un test del tipo:
x in obj
per verificare se il valore di x è una proprietà dell'oggetto obj, quindi
non c'è bisogno di cicli.
Prova ad esempio questo codice:
Array.prototype.containsElement=function(val) {
  // Verifica se val è nell'array
  // Necessita di ciclare su tutti gli elementi d'ellarray
  for (var i=this.length-1;i>=0;i--) if (this[i]==val) return true;
  return false;
};
Object.prototype.hasProperty=function(val) {
  // Verifica se val è una proprietà dell'oggetto
  // Non ci sono cicli, basta un solo controllo
  return (val in this);
};
var a = [1,2,3]; //array
var o = {1:"dummy",2:"dummy",3:"dummy"}; //oggetto
alert(a.containsElement(42)); //false
alert(a.containsElement(2)); //true
alert(o.hasProperty(24)); //false
alert(o.hasProperty(3)); //true
Tanto per completezza, tieni presente che sono valide anche le seguenti:
  alert(a.hasProperty("length")); //true
  alert(a.hasProperty(0)); //true
  alert(a.hasProperty(3)); //false
ma non serve a molto nel tuo caso.


 Avresti aggiunto dinamicamente una proprietà? Tipo obj.randomN = 13; ?
Non vedo questo cosa c'entri col discorso dei duplicati.. Senza delle
maggiori spiegazioni da parte tua, non c'è alcun legame apparente tra
le due cose. Come ho scritto nel post precedente, a questo punto cosa
c'entrano i numeri random?
Hai detto che non ce la fai a spiegare tutta la storia, quindi dovrai
accontentarti delle risposte che possiamo darti con i "frammenti" che
abbiamo; ma non è detto che siano le risposte migliori dato che manca
il concetto generale. :)
-- 
~ Se i sintomi persistono, insultare il medico.

 var o = {1:"dummy",2:"dummy",3:"dummy"}; //oggetto
Evita l'uso di stringhe per questo genere di cose. Non hai idea del
pastrocchio che JS e JScript fanno in presenza di "literal string".
Usale se puoi solo se serve; e soprattutto mai nei cicli.


 Usale se puoi solo se serve; e soprattutto mai nei cicli.
Questo non l'ho capito. In realtą avrei usato un booleano, ho scritto
"dummy" solo per far capire che, in questo caso, i valori non erano
importanti.


 importanti.
Per intenderci, sarebbe stato meglio qualcosa di questo tipo:
	var dmy = "dummy";
 
	var o = {1:dmy,2:dmy,3:dmy};
Il mio comunque era un discorso generalizzato, sull'uso consecutivo
delle stessa stringa literal; in particolar modo nei cicli, come ho
detto precedentemente. Ho solamente approfittato del tuo codice per
sottolineare la cosa.


 essere esclusi dei numeri presenti in un array.
Alternativa:
visto che hai solo pochi numeri da cui estrarre perche' non fai il
contrario?
Array con i numeri non esclusi, valore random come indice dell'array.
'bye





Ops, lo era, ma non avevo visto il msg perche' il "simpatico" news server
non me lo aveva mandato... 
'bye

 detto precedentemente.
E ma non ho capito il perché... del resto, non so neanche come js gestisca
le stringhe literal.
Cioè, tu dici che una cosa del tipo (tanto per fare un esempio)
var a=new Array();
for (var i=0;i<20;i++)
  a[i]={
        nome:"Non definito",
        cognome:"Non definito",
        nick:"Non definito
  );
potrebbe dare problemi? Ma perché?


 potrebbe dare problemi? Ma perché?
Ho solo detto che andrebbe evitato. Non che possa "dare problemi" (se
con questo s'intende "errori"). Ed il discorso è legato alle stringhe
literal in sé, quindi sarebbe da evitare anche una cosa tipo:
	for (var i=0;i<20;i++)
		a[i] = "Non definito";
Optando per:
	var nd = "Non definito";
	for (var i=0;i<20;i++)
		a[i] = nd;
Al di là degli Object.
Per quanto riguarda il "perché", sebbene sia facilmente intuibile (in
fondo, cos'è una stringa? E cos'è una stringa literal?) mi piacerebbe
tu lo scoprissi eventualmente da solo. :)
Un modo, potrebbe essere un rapido benchmark per confrontare i codici
di cui sopra; con un numero elevato di cicli per ottenere misurazioni
quantificabili.
Ammettilo, ti mancavano questo genere di post! ;)


 Ammettilo, ti mancavano questo genere di post! ;)
Lo ammetto? Uhm... non so... vabbč, lo ammetto, sě :)
I benchmark domani.
Buon fine-settimana.


 quantificabili.
Provato fino a 2000000 cicli: non noto sostanziali differenze in termini di
tempo di esecuzione, impiego di memoria, carico sulla cpu... anzi,
l'utilizzo della variabile č un pelo pelo piů lento. Non capisco :(


 l'utilizzo della variabile è un pelo pelo più lento. Non capisco :(
Temo che tu abbia provato solo su JS e non su JScript, come avevo
detto. La gestione delle problematiche sulle literal è più chiara
con quest'ultimo. In JS lo vedi solo in determinati casi ( sempre
inerenti al loro uso all'interno dei cicli).


On Sun, 28 Jan 2007 19:05:26 +0100, ZER0 wrote:
Mi sono reso conto ora di aver fatto una dimenticanza che mi sono
portato dietro per tutto il thread, per la fretta.
Rileggendolo con calma ora ho notato che ho sempre usato stringhe
literal anche quando parlavo di stringhe. Quindi non era:
	var nd = "Non definito";
Ma:
	var nd = new String("Non definito");
Altrimenti sempre a literal ci si riferisce, ovviamente :) Questo
non dovrebbe influenzare i benchmark che hai fatto, e vale sempre
il discorso sulla differenza tra JS e JScript che ti ho detto nel
precedente post.


 inerenti al loro uso all'interno dei cicli).
Ok, all'aumentare del numero di cicli tempo e memoria impiegati aumentano
vertiginosamente. Ovviamente, non immagino neanche il perché...


 non c'è bisogno di cicli.
x in obj in AS non è consentito: devi fare un for in e "luppare" 
inserendo un condizionale   :-)   Oppure, direttamente fai if(obj.prop)...
Comunque, la soluzione trovata in precedenza è ottimale...    :-)

 Oppure, direttamente fai if(obj.prop)...
Solo che con la classica "dot notation", prop non può essere una
stringa dinamica, e quindi perdi il vantaggio di usare un Object
al posto di un array, ad esempio.
-- 
~ "Un uomo è più 'grande' di un altro solo se sale sulle sue spalle."
(Bertold Brecht)

 Comunque, la soluzione trovata in precedenza è ottimale...    :-)
Ah beh, si chiacchierava.
Comunque non sono d'accordo sul fatto che utilizzare un array e ciclare sia
la soluzione ottimale, in questo caso: te ne sono state suggerite due che,
secondo il mio modesto parere di inesperto, sono migliori. Ma dove c'è
gusto, dice il detto, non c'è perdenza :)


 vertiginosamente. Ovviamente, non immagino neanche il perché...
Potremmo continuare questo thread per chissà quanto, ma voglio darti
un suggerimento: guarda nella guide di JS. Dovresti poi capire anche
cos'è che combina JScript, rispetto a JS.
Una piccola nota: credo che in JS 1.7 abbiano migliorato la gestione
delle literals, rispetto a ciò che dice la Guide (che fa riferimento
ancora alla 1.5).. Molti vecchi benchmark danno risultati differenti
rispetto a prima.
-- 
~ Neanche il futuro e' piu' quello di una volta.

 gusto, dice il detto, non c'è perdenza :)
Concordo su tutta la linea. Ma quel detto, almeno in quella forma, non
l'avevo mai udito. E' delle tue parti?
-- 
~ "La realtà è ciò che, quando smetti di crederle, non va via."
(Philip K. Dick)

 cos'è che combina JScript, rispetto a JS.
Ah, il vecchio, caro suggerimanto... RTFM :-)
Sì, lo farò...


 l'avevo mai udito. E' delle tue parti?
Beh sì, qua si usa... pensavo fosse italiano :-S


 Beh sì, qua si usa... pensavo fosse italiano :-S
Di certo è "italiano" perché non mi pare dialettale; ma immagino che
sia originario delle tue parti. Solitamente da noi si usa dire:
	"De gustibus non disputandum est"
O un tautologico:
	"I gusti son gusti.."
Ma aggiungerò anche quella che hai detto alla "lista", dato che vi è
una sottile differenza, e potrebbe tornare utile :)
-- 
~ "Ho avuto la fortuna di unire mestiere e passione,
che secondo Stendhal equivale alla felicità."
(Roland Barthes)

 Sì, lo farò...
Allora ci ritroviamo qua, dopo.


 gusto, dice il detto, non c'è perdenza :)
Ottimale è, credo, ciò che (a patto che sia ben architettato nel 
complesso, e spero nel mio caso lo sia, sebbene non abbia potuto 
dilungarmi sui dettagli) funziona correttamente e alla prova del 
benchmark è accettabilmente veloce. C'è anche da dire che cose come questa:
obj = {1:3,3:5}
in AS (che "sarebbe" ECMAScript) non sono consentite perché il nome 
della proprietà non può cominciare con un numero. La notazione [] si può 
usare, quella sì. Comunque, mi ripeto, quella soluzione, mi fa 
"spendere" un massimo di 3 millisecondi, che vanno benone!    :-)

 "spendere" un massimo di 3 millisecondi, che vanno benone!    :-)
Per caritа, come и giа stato detto "De gustibus non disputandum
est", e inoltre senza avere ben chiaro il quadro complessivo si
puт fare ben poco. Ma in linea generale, e per ciт che riguarda
quel che и stato detto in questo thread, ciclare un array non и
propriamente una soluzione ottimale.
Questo detto piщ per i posteri che per te, dato che appunto sei
soddisfatto del codice che hai. :)
-- 
~ "Finestre, finestre, finestre! Sennт prevalgono i muri."
(Marco Paolini)

 "spendere" un massimo di 3 millisecondi, che vanno benone!    :-)
E mi ripeto anch'io: dove c'è gusto, non c'è perdenza :-D


 Allora ci ritroviamo qua, dopo.
L'unica cosa che sembra entrarci è questa:
String Literals are Not String Objects
The String object is a wrapper around the string primitive data type. Do
not confuse a string literal with the String object. [...]
You can call any of the methods of the String object on a string literal
value—JavaScript automatically converts the string literal to a temporary
String object, calls the method, then discards the temporary String object.
You can also use the String.length property with a string literal.
You should use string literals unless you specifically need to use a String
object, because String objects can have counterintuitive behavior. For
example:
s1 = "2 + 2" //creates a string literal value
s2 = new String("2 + 2")//creates a String object
eval(s1) //returns the number 4
eval(s2) //returns the string "2 + 2"
Ecco, mi chiedo: e allora? Dov'è la chiave dell'arcano? Io azzarderei: il
punto è nel fatto che "JavaScript automatically converts the string literal
to a temporary String object, calls the method, then discards the temporary
String object". Ci sono almeno vicino? :)


 Ecco, mi chiedo: e allora? Dov'è la chiave dell'arcano? 
L'arcano è esattamente quello che tu ha elencato fin'ora. E a onor del
vero mi sembra che si spieghi in modo sufficientemente chiaro. :)
Se viene creato un oggetto "temporaneo" ogni volta che si "lavora" con
una stringa literals, e poi questo viene "distrutto", non sarebbe bene
evitare queste due operazioni creando direttamente un'oggetto Stringa,
invece di far uso delle literals, laddove è possibile? In special modo
in quelle operazioni "cicliche".
Dai benchmark su JScript invece, dovresti esserti accorto di come, con
tutta probabilità, quest'ultimo crei "direttamente" un'oggetto stringa
ogni qual volta incontra una literals; o faccia un'operazione analoga.
Va da sè che questa è solo una mia deduzione fatta tempo addietro, per
"spiegarmi" le differenze di performance.
-- 
~ "Non ci si uccide per amore, basta aspettare."
"Allora non mi uccido per amore, mi uccido per impazienza."
(A.O. e M.T.)

 E mi ripeto anch'io: dove c'è gusto, non c'è perdenza :-D
mi dispiace che sia una cosa davvero troppo lunga da spiegare e che ci 
siano davvero molte cose di mezzo (classi AS 2, interazione 
client/server)... Il PHP con gli array fa cose davvero comode, tanto che 
sono stato tentato di spostare una serie di cose sul lato-server. Solo 
che diventavano poco comode per altri motivi, per cui ho rinunciato. Non 
so: ciclare su un array di massimo dieci elementi mettendoci 3 
millisecondi a me pare una soluzione ottimale eccome.

 "spiegarmi" le differenze di performance.
Questo è un po' meno chiaro... ma non ti tedio ulteriormente, cercherò di
spremere le meningi: se ci sono, serviranno pure a qualcosa, no?


 millisecondi a me pare una soluzione ottimale eccome.
Ho un opinione diversa: se si puň usare un'altra soluzione, che non ci
mette piů di 3ms, che č piů snella, piů leggibile, con meno codice etc,
allora l'array non č ottimale. Ma si tratta di opinioni, non voglio mica
convincerti :)


 Questo è un po' meno chiaro... 
Cosa ti è meno chiaro? Premettendo, ripeto, che sono mere deduzioni le
mie, e che JScript *non* è JS.
Secondo la Guide di JS, viene creato un oggetto temporaneo String solo
quando si deve "agire" su una literal, non prima. I risultati ottenuti
con JScript invece, fanno supporre che questo esegua alcune operazioni
appena incontra una literal; E' probabile che crei un oggetto String a
priori. Questo (a mio avviso) spiegherebbe il "divario" dei due codici
in termini di tempi e risorse.
-- 
~ "Il debito pubblico è abbastanza grande da badare a sé stesso."
(Ronald Regan)

 ha scritto:

Tu dovevi fare l'insegnante, sul serio.


 convincerti :)
difatti! Poi, nulla contro ZERO (ci mancherebbe: sono un pelo confinato 
in posti infimi del suo corpo a paragone), ma il cast della proprietà di 
un oggetto da numero a stringa non mi fa impazzire in quanto a pulizia e 
"buona pratica". Che poi parlo proprio io che sono sempre quel pelo...   :-D

 "buona pratica".
Liberissimo che la cosa non ti faccia impazzire a livello prettamente
personale, ci mancherebbe :) ma in Javascript/ECMAScript si tratta di
una features del linguaggio; e non di un hack, o di qualcosa di "poco
pulito".
-- 
~  "FINARMENTE  LI SFRATTATI AVRANNO UN TETTO SULLA  TESTA!
 ...però tirato ammodino, un  tegolo pe' vorta.." (Il vernacoliere)

 Tu dovevi fare l'insegnante, sul serio.
Delle volte ho l'impressione che ti burli di me. :P
-- 
~ "Solo i morti hanno visto la fine della guerra."
(Platone)

 (Platone)
Bellissima.


 pulito".
ZERO, da pelo ad esperto proprietario del pelo:
anche i cicli fanno parte dei linguaggi (e anche il loro uso non 
disinvolto). E penso che fin qui siamo d'accordo.
Ora:
<quoto>
Posso dirti come avrei
usando l'Object per evitare i duplicati e i cicli di cui sopra:
var o = {2:1,3:1,76:1,21:1};
if ( o[n] ){
	// è presente
}
Dove ovviamente "n" è l'elemento di cui controllare i duplicati. Come
vedi, niente cicli di sorta.
</quoto>
Ora, "n" è un numero random che va comunque estratto "randomicamente" 
prima di diventare parte dell'oggetto.
A quel punto, forse, ci si troverebbe in una situazione come questa:
do{
var ext = Math.floor(Math.random()*arr.length);
}
while{
// pseudocodice
ext == o[n];
};
o comunque, se già c'è, in ogni caso va ri-estratto. O no?
Questo non vuol dire che estrarre un numero finché non è assente? Non 
siamo sempre lì? Che mi sto perdendo?   :-)

 siamo sempre lì? Che mi sto perdendo?   :-)
Che hai eliminato un ciclo da zero a "n" elementi dell'array, per ogni
valore estratto non ammesso? :)
Come vedi, non "siamo sempre lì" per quel che riguarda la gestione dei
duplicati.
-- 
~ Se i sintomi persistono, insultare il medico.

 valore estratto non ammesso? :)
ok: ma, sempre se ho capito, non ho eliminato la possibilità di 
richiamare Math.random un numero n di volte. A questo punto, la 
soluzione del ciclo (dato che parliamo di piccoli array di massimo dieci 
elementi) a me (al pelo) appare più lineare   :-)

 elementi) a me (al pelo) appare più lineare   :-)
In sostanza, il risultato è che un codice di questo tipo:
	var bfound = false;
	for (var i=0;i<a.length;i++)
		if ( a[i] == n ){
			bfound = true;
			break;
		}
 
	if ( bfound )
		alert("elemento presente");
 
A te appare più lineare di:
	if ( a[n] )
		alert("elemento presente");
"Ma carissimo, con tutto il bene che ti voglio" (cit), oggettivamente
non mi è proprio possibile concordare sul fatto che il primo codice è
"più lineare" del secondo. :)
E questo senza tener di conto altri parametri, quali la performance.
-- 
~ "Affronta gli ostacoli e fa qualcosa per superarli.
Scoprirai che non hanno neanche la metà della forza che pensavi
avessero." (Norman Vincent Peale)

 Questa č una "best practices".
Non si dovrebbe dire "una best practice"?
Cosě, giusto per il gusto di provare a correggerti una volta :)


 Non si dovrebbe dire "una best practice"?
Tu dici "films" o "film"? Il concetto č lo stesso, ma al contrario :)
In questo caso io considero "best practices" come fosse un'etichetta,
un termine unico, altrimenti lo tradurrei in italiano.. e soprattutto
non starei ad usare i doppi apici :)
Puoi anche vederla come una questione di punti di vista se vuoi. Come
c'č chi preferisce dire "nelle ASP" (pagine) o "in ASP" (enviroment).
Ma stiamo scendendo in discorso sulla lana caprina, IMVHO. :)


 Ma stiamo scendendo in discorso sulla lana caprina, IMVHO. :)
No, una discussione sull'italiano. Non ci sono regole precise sul plurale
dei termini stranieri ma la più usata è quella che prevede:
- nessuna variazione per i termini di larga diffusione
- la variazione così com'è nella lingua madre per i termini poco diffusi o
diffusi in un ambito ristretto.
Così si dice "i film", "i computer", e non "films" o "computers", però un
termine poco diffuso come "practice" andrebbe pluralizzato così come nella
lingua madre, e quindi "practices".
Eddai, per una volta, una volta sola, dì "hai ragione" :-D
P.S. ma tu, come lo pronunci "practice"? no, perché un mio professore dice
"practàis"...


 "practàis"...
Lascia perdere, la mia fonetica inglese fa veramente schifo..
-- 
~ "E' impossibile svegliare chi fa finta di dormire."
(Proverbio navaho)

 Ovvero vediamo la cosa da due punti di vista diversi.
Fanculo, allora. Mai che tu mi dia una piccola soddisfazione! :)
P.S. "scaleo" l'ho dovuto cercare sul vocabolario
P.P.S. in effetti č curioso che un napoletano azzardi una critica
linguistica nei confronti d'un fiorentino :-D


 (contento? :) )
Grazie, hai diradato le nubi e la giornata č piů luminosa :-D
Buon lavoro, io vado a studiare -.-


 Buon lavoro, io vado a studiare -.-
Cosa? ^_^ e grazie, altrettanto.
-- 
~ Non esiste la certezza: è solo l'illusione di una realtà soggettiva.
(Fabio Mornati)

 ^_^ e grazie, altrettanto.
;)


 diffusi in un ambito ristretto.
A dire il vero una regola c'e`: tutti i termini stranieri non vanno messi
al plurale, e sono tutti maschili.
Poi, purtroppo o per fortuna lascio decidere agli altri, ognuno fa come
gli pare, e spesso sono i giornali e soprattutto la TV a definire come si
dice qualcosa.
E se storpiano anche i nomi italiani dicendo Bénetton invece di Benettòn... :)
Bye.

 E se storpiano anche i nomi italiani dicendo Bénetton invece di Benettòn... :)
Da noi molti hanno la "sindrome dell'errore dialettale", così senti gente
che dice "càvur" per Cavour ("cavùr" suona troppo napoletano, deve essere
sbagliato per forza), o che chiama "i Cardarelli" l'ospedale, perché è
chiaramente plurale :)


 Questa è una "best practices".
è ok, capisco quello che dici perfettamente. Ma il discorso non è anche 
che il numero n di volte potrebbe essere più lungo dell'array su cui 
ciclo? O come sempre sono vittima di indesiderati momenti di scarsa 
lucidità?   :-)

, che elimina qualunque ciclo,
non ti andrebbe bene?


 non ti andrebbe bene?
devo dire una cosa: mi avete fatto venire uno scrupolo senza precedenti. 
Maledetti!   :-)   Penso che c'è tutta una parte che ristrutturerò. Vi 
lascio questo post su argomento AS/JS, se per caso non ne sapete già 
qualcosa (dubito): 
http://www.moock.org/blog/archives/000202.html
Grazie ad entrambi.   :-)

 Grazie ad entrambi.   :-)
Torna a trovarci e buon lavoro :)
