Newsgroup: it.comp.lang.javascript
Titolo: Numerici interi

Ciao a tutti, devo implementare un metodo che mi permetta di distinguere se
il valore immesso in campo di input sia un numerico o no!!
Il valore numerico deve essere un valore intero e non decimale!
Sono riuscito a trovare il modo per distinguere un valore numerico da una
stringa o un carattere ma non riesco a far distinguere un numerico decimale
da un numerico intero!
Grazie per l'aiuto.
Ciao ciao

fai un ciclo che controlla che ogni carattere della stringa sia solamente
numerico, quindi compreso tra
il codice ascii 0 e il 9


 da un numerico intero!
una volta che hai una variabile numerica, ti basta verificare che la
divisione per 1 non dia resto.
if ( n%1==0){
    alert("E' un numero intero")
}else{
    alert("Non e' intero")
}
--------------------------------
Inviato via 
http://usenet.libero.it

Io farei un qualcosa del tipo:
for(var x=0;x<String(tuonumero).length;x++)
if(String("0123456789").indexOf(String(tuonumero).substr(x,1))==-1) return
false;
return true;


Se vuoi scrivere meno possibile (perň per niente elegante anzi quasi
sbagiato ma funzionante), fai come ha detto ZERO ma anche senza sapere che č
un numero:
if(!n%1)
    alert('Non hai inserito un numero intero');
Altrimenti usa una procedura come suggeriva Cristiano, perň cosě
ottimizzata:
var max=String(tuonumero).length
var tuastringa=String(tuonumero);
for(var i=0;i<max;++i)
    if("0123456789".indexOf(tuastringa.charAt(i))==-1)
        return false;
return true;

 alert('Non hai inserito un numero intero');
Al di la' dell'elegantezza.. Questo modo non e' corretto, e cosi' scritto
non funziona. L'hai testato? Non si ottimizza diminuendo di un carattere, o
sbagliando le condizioni. :)
E poi, un numero si dice intero quando la divisione per uno non da' resto.
Quindi direi che questa e' la trascrizione informatica del corrispettivo
matematico.
Una volta risposi anche io erroneamente ad una domanda del genere.. ero
proprio nel pallone :)


 for(var i=0;i<max;++i)
++i incrementa PRIMA => stai saltando il primo carattere (charAt è a base
0), devi fare i++
Da cosa deduci che questa è ottimizzata mentre la mia no? IMHO mi
sembrerebbe il contrario...

 sbagliando le condizioni. :)
Lo so, però funziona, e l'ho già scritto in una parentesi



a) Non e' cmq ottimizzato, quindi non vedo perche' scrivere qualcosa di
"scorretto" anche sintatticamente se non serve a qualcosa (ad esempio, per
un'ottimizzazione appunto).
b) Ho scritto "al di la' dell'elegantezza", ovvero avevo letto cio' che
avevi scritto tra parentesi. Solo che avevi scritto anche che funziona, ed
invece non funziona affatto. Forse non l'hai testato.
Prova un po':
<script>
var n="1.1"
if(!n%1)
    alert('Non hai inserito un numero intero');
</script>
L'alert non viene visualizzato, quando invece dovrebbe.


 sembrerebbe il contrario...
E' ottimizzata perchè evita di chiama <<String(tuonumero).length>> volte la
funzione substr() e una volta sola la proprietà  length.
Ergo la mia è più veloce (si sta parlando di nanosecondi però...).
Paolo
Ciao.


E' vero ho sbagliato, cosě funziona:
<script>
var n="1.1"
if(n%1!=0)
    alert('Non hai inserito un numero intero');
</script>
comunque hai ragione su tutto
Ciao.

, 
c.largh...@executive.it
 says...

Scusate e perche' non: 
Questa funzione fa scattare l'alert se nel campo testo sono presenti 
caratteri diversi dalle cifre da 0 a 9
<PRE CLASS="codice">&lt;HTML>
&lt;HEAD>
   &lt;TITLE>CheckSoloNumeri&lt;/TITLE>
<SPAN CLASS="rosso">&lt;SCRIPT>
&lt;!--
function Controlla()
   {
   a=document.modulo.testo.value;
   var RegExp=/\D/
   if (RegExp.test(a))
   alert("Nel campo devi inserire solo numeri.");
   }
//-->
&lt;/SCRIPT></SPAN>
&lt;/HEAD>
&lt;BODY BGCOLOR="#ffffff">
&lt;FORM NAME='modulo'>
&lt;INPUT TYPE='text' NAME='testo'> &lt;BR>
&lt;INPUT TYPE='button' VALUE='Clicca' <SPAN CLASS="rosso">
onClick='Controlla()'</SPAN>>
&lt;/FORM>
&lt;/BODY>
&lt;/HTML></PRE>
al di la' dell'esattezza del metodo in termini di Matematica ?
-- 
Ciao, Riccardo
------------------------------------------------------------------------
http://www.jsdir.com
 ---- Bring Your Site To Life!!!!
------------------------------------------------------------------------
http://www.dev2dev.it
 - La rete ha connesso nuove particelle - D2D006
------------------------------------------------------------------------
 ----> itALY = it <----


Sì volevamo evitare di usare i Reg test. Comunque io farei qualcosa del
genere!
Paolo
Ciao.

 [ ... cut ... ]
Ehm, sorry.
Ho aggiornato una faq (la 221) con questo codice ed in copYincolla avevo 
il codice puro testo per il database :-))
Riporto sotto:
<HTML>
<HEAD>
	<TITLE>CheckSoloNumeri</TITLE>
<SCRIPT>
<!--
function Controlla()
	{
	a=document.modulo.testo.value;
	var RegExp=/\D/
	if (RegExp.test(a))
		alert("Nel campo devi inserire solo numeri.");
	}
//-->
</SCRIPT>
</HEAD>
<BODY BGCOLOR="#ffffff">
<FORM NAME='modulo'>
<INPUT TYPE='text' NAME='testo'> <BR>
<INPUT TYPE='button' VALUE='Clicca' onClick='Controlla()'>
</FORM>
</BODY>
</HTML>


 al di la' dell'esattezza del metodo in termini di Matematica ?
E perche' la gente continua a usare il Napalm per schiacciare una mosca? :)
Istanziare in memoria un'oggetto RegExp (con tutti i suoi metodi,
proprieta', etc), farlo eseguire, solo per verificare un numero intero?
.. Meno male che con l'avvento dei palmari ed i nuovi cellulari si torna a
dover essere obbligati a porre attenzione a quel che si fa, evitando
sprechi..


 sprechi..
Non posso che darti ragione.
Paolo
Ciao.

 sembrerebbe il contrario...
Riguardando il tutto effettivamente non è ottimizzata, ma è di brutto
ottimizzata!!! (Evito ulteriore ironia)
Allora il tuo capolavoro di velocità:
for(var x=0;x<String(tuonumero).length;x++)
if(String("0123456789").indexOf))==-1) return
false;
return true;
Supponendo che String(tuonumero).length sia 10, succede che per 10 volte
vengono chiamate una marea di funzioni e proprietà inutilmente!!
-    String(tuonumero).length (che vale per 2)
-    String("0123456789") (dove String è mostruosamente inutile)
-    String(tuonumero) (di nuovo inutile)
-    .substr(x,1) (no coment)
Quindi usando il tuo metodo:
var max=String(tuonumero).length
var tuastringa=String(tuonumero); //se non è già una stringa
for(var i=0;i<max;++i)
    if("0123456789".indexOf(tuastringa.charAt(i))==-1)
        return false;
return true;
Paolo
Ciao.

 </script>
Che e' esattamente la sintassi che ho scritto io :) Ergo mi pare un post
ridondante.


 Ergo la mia è più veloce (si sta parlando di nanosecondi però...).
concordo; personalmente preferisco considerare "ottimizzato" un mix tra
prestazioni e compattezza; quindi, per pochi dati, personalmente scriverei
sempre la mia...però va a gusti, le variazioni di performance sono
irrisorie; hai comunque ragione.


Sarà un bug , comunque !n%1 op n%1!=0 dà 2 risultati diversi.
Ripeto n%1!=0 funziona è uno schifo, è concettualmete vomitevole....però
funziona!
Comunque non lo userei mai, sia chiaro!
Paolo
Ciao.

Ripeto e sottoscrivo quanto detto in altra risposta: il discorso del for è
concettualmente errato, e IMHO erra javascript a lasciare passare questa
sintassi (e vorrei proprio sapere in quanti nel mondo sanno che possono
mettere ++i in un ciclo for e ottenere lo stesso risultato di i++); per la
velocità ("il mio capolavoro", come dici te, mister simpatia) preferisco la
compattezza ad aumenti di prestazioni irrisorie...in questo caso,
ovviamente; e, come sempre, IMHO.
Hai comunque ragione (dato che la variabile viene controllata dopo il primo
ciclo dovrebbe essere indifferente l'incremento), genera solo confusione
(quantomeno a me la genera, non so ad altri) ed è inutile; ergo: non vedo il
perché di tutta questa ironia; se vuoi parto anch'io ma non so se è il caso
(anzi, IMHO non è proprio il caso).
Imho.


allora usa questo
if(!parseInt(String(tuonumero))){
    alert('deve essere un intero!');
    return 0;
}
Paolo
Ciao.

 anzi quasi sbagiato ma funzionante), fai come ha detto ZERO
Il mondo č bello perché č vario :-)
Perň non mi sarei aspettato che la procedura proposta da ZERO fosse
giudicata per niente elegante.
Maurizio.


Rispondo anche io. Mancavo all'appello in questo mostruoso thread...
var a="Quello che vi pare"
alert(a>>0==a)


No, non intendevo che la procedura di Zero non fosse elegante, anzi!!!!
La procedura sbagliata e non elegante era quella che proponevo io:
mandando in pasto all'if n%1 senza aver accertato che n fosse un numero.
Infatti "as564asd"%1 cosa dovrebbe restituire?
Però come ho già detto così funziona, quindi chi vuole...
Paolo
Ciao.


Perņ aspetta non funziona se:
var a="535345.0";
alert(a>>0==a);
Quindi?



Gia', sinceramente io la trovo elegante nonche' funzionale.. tant'e' che e'
, cmq, andando a vedere i post vecchi, la stessa procedura che avevi
proposto te nel topic in cui avevo dato una risposta un po' fuori di zucca
:)
.. Gia' ci fu un'altra richiesta relativa ai numeri interi dopo quella e
prima di questa, a cui diedi la medesima risposta, ma non ricordavo affatto
che si trattava della stessa questione, e "di fatto" me la ricavai ex novo.
:)
.. Mi sono ricordato con questo post, spulciando indietro, che si trattava
della solita problematica. ;)



Funziona. Difatti il numero e' intero.

> Gia', sinceramente io la trovo elegante nonche' funzionale..
Però mi sono accorto di una cosa, se fosse così:
var tuonumero="234243.0";
if(tuonumero%1)
    alert('Deve essere un intero!');
Tanto funzionale, tanto bella, tanto elegante ma non funge!
Paolo
Ciao.


Ok, però Andromeda (l'iniziatore della discussione) non voleva che nel campo
in cui si inserisce sto numero ci fossero nè "." nè ","
Quindi?

 Infatti "as564asd"%1 cosa dovrebbe restituire?
Restituisce sempre la risposta corretta:
    "as564asd"%1 == 0
riporta false. Quindi "as564asd""non è un numero intero.
Maurizio.


Post di Andromeda:
"Ciao a tutti, devo implementare un metodo che mi permetta di distinguere se
il valore immesso in campo di input sia un numerico o no!!
Il valore numerico deve essere un valore intero e non decimale!
Sono riuscito a trovare il modo per distinguere un valore numerico da una
stringa o un carattere ma non riesco a far distinguere un numerico decimale
da un numerico intero!"
Non si parla di punti o virgole, ma di intero o decimale. Mi sembra di aver
risposto correttamente (e poi, piu' performante di uno shift binario che
c'e'?).
Se poi si vuole (per quale motivo?) eliminare anche la tua possibilita', era
perfetta senza ulteriori possibili discussioni la prima soluzione di Zer0:
n%1==0

 n%1==0
Non è vero: es. "100.0"%1 lo considera uguale "100"%1

 Tanto funzionale, tanto bella, tanto elegante ma non funge!
Invece funziona, in quell'esempio e' il vostro approccio tramite
charAt/substr/regexp che e' errato.
234243.0 e' un numero intero. :)
Infatti la divisione tramite uno non da' resto.
..la matematica, almeno a questi livelli, fortunatamente non e' un opionione
:)
Ipoteticamente, qualsiasi numero intero puo' avere "n" zeri dopo la virgola.
Infatti prova a fare:
<script>
var n=12.00000
alert(n)
</script>
Vieni considerato (giustamente) alla stregua di 12.. perche' E' 12. Mentre i
vs script non lo riconoscerebbero come tale.



Ok bravo, ora supponi che si tratti di un campo dove và inserito un numero
di tel. e non si vogliono i seguenti caratteri: "." "," ":" "/" "\" e
neppure " "
Quindi si tratta di un intero però evidentemente "099423424.00" non si deve
accettare...
Allora?

 Non è vero: es. "100.0"%1 lo considera uguale "100"%1
Ovvio perche' il resto e' lo stesso. Sono anche un po' invornito.
Se vuoi che proprio non ci siano altri caratteri oltre ai numeri:
valoreInput.replace(/\d/g,"").length==0

, 
ascartab...@codice.it
 says...

E io che avevo detto? :-))
Solo che invece del replace() ho usato una test  -^_^-


 Allora?
function gfC_interoIntero(){
    switch(arguments[1]){
        case 1:return
arguments[0]%1==0?arguments[0]==String(Number(arguments[0]))?true:false:fals
e
        case 2:return arguments[0].match(/^[0-9]+$/)?true:false;
    }
}
alert(gfC_interoIntero("099423424.00",1))
alert(gfC_interoIntero("099423424.00",2))
--
Ciao
  [web]   
www.gfcarlotti.it
   [mail]   
fra...@gfcarlotti.it
    [pgp]  
www.gfcarlotti.it/pgp/franco.asc

 Solo che invece del replace() ho usato una test  -^_^-
Rispetto al problema posto da Andromeda, e' un di piu'. Rispetto a quello
che poneva Paolo... stessa cosa, anzi: se non avessi dichiarato la variabile
e avessi usato come letterale il pattern della RegExp sarebbe stata anche
migliore, comunque pardon.
Esca buttata. Che mi abbia fregato non rispondendomi?

 migliore, comunque pardon.
Pardon di niente.
Indovina indovinello.... chi e' che mi ha risposto "E perche' la gente 
continua a usare il Napalm per schiacciare una mosca? :)" ? :-))
In effetti non e' che ci bazzico tanto con le RegExp, ho buttato giu' la 
variabile e tutto il resto perche' avevo intuito che (come nel 99% degli 
altri casi) la domanda originale era che voleva un numero intero 
intendendo che voleva solamente cifre.


 Allora?
..
Sono senza parole.
E a quanto pare non sono stato l'unico a rimanere "basito".
Allora. Quel di cui abbiamo parlato fin'ora, e' la verifica se un numero (e
ripeto NUMERO) sia intero o meno. Parliamo di numeri, e matematica.
Adesso mi stai parlando del CHECK di un NUMERO DI TELEFONO.. Che
notoriamente in informatica viene considerato STRINGA, secondo un
determinato pattern (tra cui slash, spazi, punti, e soprattutto +0039, etc..
e quindi si fara' uso di una regexp).
E come se da una discussione al bar su delle belle donne, tu incominciassi a
parlare di come sara' la coltivazione della cicoria in patagonia quest'anno.
Ecco, c'incastra esattamente allo stesso modo. :)
Sono due discussioni, o problematiche, completamente differenti, di natura
differente, che necessitano di approcci altrettanto differenti.


 Ecco, c'incastra esattamente allo stesso modo. :)
ROTFL!

 > if(!n%1)


Anzi per la verità non torna nemmen così:
se dico if(!
e la espressione mi ritorna sempre false, allora DOVREBBE innescare l'alert
var n=1;
if(! (n%1) ){alert('ok')}
curiosamente funziona, come dicevo.
Ma la spiegazione che ho fornito sul perchè, benchè teoricamente plausibile,
dovrebbe condurre a risultati opposti a quelli che ho dedotto.
Proviamo questo:
var n=1;
var f=!n%1; //uhm... rain dance...
alert(typeof f)
il typeof è un number, dunque dovrebbe leggerlo come false.
[la prassi è legittima: prova:
var t=!1;
alert(t)//dà booleano false.
]
Ora, se il typeof è number, dovrebbe innescare l'alert.
Invece
n=1;
if(!n%1){alert("ciao")}
non parte...
n=1;
if(! (n%1) ){alert("ciao")}
parte...
La mia spiegazione è ipoteticamente plausibile, ma nei fatti è sconfessata.
Dunque allo stato attuale non saprei dire come mai se aggiungo le parentesi
funziona.
Mah. Sarà che è tardi!
Alberto
http://www.unitedscripters.com/

Comnque a parte tutto un metodo pratico è:
if( isNaN( parseFloat(n) ) || ( parseFloat(n)%1) ) alert('Non hai inserito
un numero intero');
La prima espressione si accerta sia un numero, la seconda che non sia
decimale.
Non effettua la conversione permanente della eventuale stringa in numero, ma
questo si può aggirare con:
n=parseFloat(n);
if( isNaN(n) || (n%1) )alert('Non hai inserito un numero intero');
il che tuttavia fa perdere n, per cui forse vuoi prima farne una copia,
dipende da quel che ti riprometti
ciao
Alberto

 ma nei fatti è sconfessata.
Perché è sconfessata? A me sembra molto realistica. Cerca di chiarirmi qual
è il fatto che la sconfessa.
Dando per scontato che l'operatore not logico ha la precedenza sul modulo,
io ragiono così:
    !n
converte n in boolean; il successivo modulo:
    !n % 1
converte di nuovo il risultato di !n in number. Infine, trovandosi questa
espressione in una espressione condizionale if (...), il risultato viene di
nuovo convertito in boolean.
Esempio:
    n = 12;
    !n = false;     // e cioè 0
    !n % 1 è uguale a 0 % 1 e quindi vale 0;
    if (0) equivale a if (false)
Invece, usando le parentesi:
    n % 1 = 0;
    !(n % 1)  è uguale a !0 = !false = true
Maurizio.

ciao Maurizio
sì, come dicevo il ragionamento che facevo mi pareva plausibile (e a
tutt'ora come tu sottolinei giustamente anche l'unico: infatti ipotizzare
che sia sbagliato ci lascia con... nulla!).
Il motivo per cui avevo avuto un ripensamento è questo:
if(! (n%1) )
qui l'operatore logico è tradizionale senza dubbio, il nostro problema è
perchè non lo era con
if( !n%1 )
la mia ipotesi era che l'unica spiegazione fosse che l'operatore ha la
precedenza sul modulo, dunque
!n= booleano
booleano/Number=0
Questo in effetti significa che l'operatore logico ! smarrisce del tutto la
sua natura legata al condizionale IF.
Una conseguenza forte, Maurizio!
E' questo che mi ha disorientato nonostante l'analisi fosse giusta.
In altre parole, il condizionale IF non è più un condizionale che controlla
se un valore sia false... ma controlla se sia true perchè il ! è già stato
"speso"
Il motivo per cui temevo che ci fosse una falla nel ragionamento è tanto
banale quanto curioso: l'abitudine (legittima, come la stessa aspettativa di
tutti gli utenti letti finora prova) a considerare un if(! come non
"consumabile" *altrove* che nell' IF.
Invece, hai ragione tu: il mio primo ragionamento era corretto: il ! si
"vaporizza" in !n, mentre nel mio ripensamento era come se mi dicessi "ma
come è possibile, sono così abituato a che un operatore logico sia
indissolubilmente legato alla espressione condizionale che lo contiene..."
Quindi hai ragione tu, contrordine sul contrordine.
Come sempre, si tratta di cose istruttive specie con queste interazioni fra
utenti che ragionano sui codici e non si limitano a prove ed errori. Infatti
abbiamo anche appurato che vi è una tendenza a ritenere cose come ! legate
alla espressione condizionale: ma se esse vengono "consumate" altrove non
sono più valide...
insomma, l'ora è tarda, ma è senza dubbio interessante notare che
if(!n%1) significa non se NO [ ! ] ma se SI, perchè il ! è "bruciato" su n.
wow.
Comunque una evoluzione interessante, quasi quasi salvo il thread su hd!
ciao
Alberto
http://www.unitedscripters.com/
"Maurizio." <mau...@libero.itA> ha scritto nel messaggio
news:yuIU9.2244$ZE.6...@twister2.libero.it...


 documentazioni sui funzionamenti interni dell'interprete).
Basta la reference del linguaggio. O penso qualsiasi manuale in vendita. In
ogni manuale su un certo linguaggio una delle prime cose che solitamente
viene detta e' appunto la priorita' degli operatori. Almeno, nel mio vecchio
manuale C ANSI delle superiori era cosi'. :)


 Comunque non lo userei mai, sia chiaro!
Ognuno e' libero di perseverare nei propri errori, e' questo il libero
arbitrio. ;)


 }
Non funziona.. Cerchi sempre di "ottimizzare" facendo smettere di far
funzionare lo script originale.. :) Mi ricorda un po' una tagline su qualche
vecchia BBS che recitava piu' o meno " DEL *.* e' il miglior programma per
compattare."
Cmq hai dimenticato la radice, questo talvolta puo' dar problemi nell'uso
del parseInt se si ha un numero in forma ottale (ovvero, con lo zero
davanti).


 ha scritto nel messaggio
news:213Z31Z202Z2Y1...@usenet.libero.it...


 precedenza degli operatori.
Io ho semplicemente risposto ad un'inesattezza letta in un post, come 
faccio normalmente. Se leggo:
"La cosa non č spiegabile con certezza (nel senso che non dispongo di
documentazioni sui funzionamenti interni dell'interprete)."
Riferito alla precedenza degli operatori, mi immagino con relativa 
certezza che la persona in questione (sia tu, sia chiunque altro), non 
ha mai avuto modo di mettere mano alla reference di JS in cui viene 
spiegata con precisione qual'e' la precedenza degli operatori.
Nessuno finisce mai d'imparare. Nell'informatica piu' che mai. 
L'umilta' di cui parli, va usata in questo senso. Incazzarsi perche' e' 
stata fatta notare una svista o una lacuna, e' assoluta mancanza di 
umilta' e non rende propositivi per imparare.
Poi, per carita'.. Ognuno agisce come meglio crede.
-- 
C'ya,
ZER0
  :. job profile - coder.gfxer.webDesigner
"When you have eliminated the impossible, whatever remains,
however improbable, must be the truth." (S.H.)