Newsgroup: it.comp.lang.javascript
Titolo: RegExp

Ciao a tutti
Potete per cortesia aiutarmi con questa regular expression?
Una parola deve avere da 6 a 12 lettere. può contenere solo caratteri
a-z A-Z 0-9 + - * / = ed almeno uno di ogni tipo(è indiferente
minuscolo o maiuscolo)
Grazie mille

 non č solo "questa", ma direi piů di un controllo.
Beh, si puň fare anche tutto in una singola regexp; a volte č utile
non aggiugere strutture di controllo esterne, ma limitarsi a solo a
un "test" su una regular expression.
-- 
~ "E' impossibile svegliare chi fa finta di dormire."
(Proverbio navaho)

 basta farne una funzione a parte...
E' proprio quello che sto dicendo che delle volte è utile evitare :)
-- 
~ Se i miei cattivi pensieri non fossero caricati a salve, ogni giorno
sarebbe una strage.

 E così poi ti ritrovi a risolvere problemi che potevi evitare... :-P
Mhm, no, di solito sono cose che faccio sempre con cognizione di causa
:) (difatti non ho mai avuto problemi in tal senso)
-- 
~ "La fantasia è come la marmellata,
bisogna spalmarla su un solido pezzo di pane."
(Gore Vidal)

grazie mille per l'aiuto ragazzi.
ma in realtà non ho capito bene come fare, se fosse possibile io
preferirei un espressione unica, si può?



Per potere si può, ma se hai seguito il thread ti viene sconsigliato
un approccio del genere, se non ti è davvero necessario.
Questo perché la regexp deve ovviare a una differenza implementativa
nei browser, e quindi diventa più complicata.
A meno che tu non debba farla solo per Gecko (Firefox, Mozilla).
Se sei andato a vedere questo link:
 
http://www.ex-parrot.com/~pdw/Mail-RFC822-Address.html
Sai quanto possano diventare complesse le regexp.
Se non hai "paletti" di design particolari, segui ciò che ti è stato
detto da Sembro la Carta nel primo post.
-- 
~ "E' nei cambiamenti che troviamo uno scopo."
(Eraclito)



Io sono arrivato a questa:
/^(?=.*[a-zA-Z])(?=.*[0-9])(?=.*[+\-*\/=].*)^[a-zA-Z0-9+\-*\/=]{4,12}$/
che però ha una limitazione che non sono riuscito a risolvere.
I tre caratteri obbligatori (alfabetico, numerico, speciale) devono 
essere i primi digitati, anche se in ordine casuale...
-- 
    * b *
  *   y   *
*   Piero   *
[ /summum ius summa iniuria/ ] 

ultime due question:
allora usao questi 3 codici simultaneamente, è il vostro consiglio
definitivo? : )
---
per almeno uno del primo gruppo: /[a-z]/i
per almeno uno del secondo gruppo: /[0-9]/
per almeno uno del terzo gruppo: /[+\-*\/=]/
---
cosa vuol dire la i dopo l'espressione?

 cosa vuol dire la i dopo l'espressione?
http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:RegExp#Parameters
-- 
~ Se i sintomi persistono, insultare il medico.


Al di là del problema che citi, non può andar bene per via dei
problemi di cross-browsing a cui accennavo.


 diversi linguaggi
Per dover di cronaca e curiositŕ mia, quali sono questi "diversi"
linguaggi che implementano le regexp perl-like in questo modo?
Cosě se mi ci imbatto, almeno so come comportarmi.


 boh... 
...
Glissiamo, va'. :)


 gaurda che non c'č nulla da glissare, 
Data la risposta, direi proprio di si, scusami eh.


 problemi di cross-browsing a cui accennavo.
Come ho scritto sopra, nessun problema con i tre browser citati.
Forse tu l'hai testata con altri, od altre versioni.
P.S. Magari aiutami ad eliminare il problema citato. ;-)
-- 
    * b *
  *   y   *
*   Piero   *
[ /in medio stat virtus/ ] 

 P.S. Magari aiutami ad eliminare il problema citato. ;-)
Non ho guardato nel dettaglio quella regexp, ma con i look-ahead non
hai quel genere in un'implementazione corretta.
Il problema è sempre lo stesso al quale accennavo, e si ha solo come
codice crossbrowsing:
Copiando così com'è la regexp in soggetto su Javascript 1.5:
	salve1aa+ // true
	1aa+salve // true
Su JScript 5.6:
	salve1aa+ // false
	1aa+salve // true
Però da come ne parlavi, sembrava il tuo un problema che aveva a che
vedere con tutte le implementazioni (FF, IE, Opera..).


 vedere con tutte le implementazioni (FF, IE, Opera..).
Infatti! Mi spiego:
la regexp valida una psw con 6/12 caratteri (come ha chiesto l'OP), a condizione
che i primi tre caratteri (uno per tipo, non importa l'ordine) facciano parte
dell'elenco [a-zA-Z] primo tipo, [0-9] secondo tipo, [+-*/=] terzo tipo.
E questo lo fa. :-)
Se perň nei primi tre caratteri replico uno o piů caratteri dello stesso tipo
(es. ++aa11 che sono 6 caratteri), non la valida, a meno ché non ne aggiunga altri
due. E non va bene, perché la regexp dovrebbe validare psw da 6/12 caratteri. :-/
Comunque io l'ho testata con questo: (scusa eventuali errori, conosco molto poco JS)
<html><head>
<script type="text/javascript">
function controlla() {
psw=/^(?=.*[a-zA-Z])(?=.*[0-9])(?=.*[+\-*\/=])[a-zA-Z0-9+\-*\/=]{4,12}$/;
if (psw.test(document.modulo.psw_scelta.value));
else
{alert("password non valida!");
return false;}
}
</script>
</head>
<body>
<form name="modulo" method="get" action="
http://www.pippo.it/
" onsubmit="return controlla();">
Digita la password <input type="password" size="30" name="psw_scelta" />
<input type="submit" value="invia" onsubmit="return modulo(this);" /></form>
<p>Una password valida deve avere da 6 a 12 caratteri.<br />
Deve contenere solo caratteri "a-zA-Z" "0-9" "-+*/=" (con almeno uno di ogni tipo)</p>
</body></html>
Provalo e dimmi il risultato.
-- 
    * b *
  *   y   *
*   Piero   *
[ /cogito ergo sum/ ] 

 Comunque io l'ho testata con questo: (scusa eventuali errori, conosco molto poco JS)
Copiata e incollata, testata giusto su FF con la stringa "salve1aa+"
che dicevi comunque che ti restituiva false.
Come dalle prove di prima, restituisce true.
Sempre su macchine differenti, solita tua versione (2.0.0.4).


 Sempre su macchine differenti, solita tua versione (2.0.0.4).
A questo punto non ho altro da aggiungere, se non riconfermare che i test
da me effettuati, hanno dato esito positivo (salvo il problema accennato)
-- 
    * b *
  *   y   *
*   Piero   *
[ /carpe diem/ ] 

 da me effettuati, 
Hai provato a eseguire gli stessi test su macchine diverse, e
magari da persone diverse?
Non ne so il motivo, ma dati i tuoi risultati, o c'è qualcosa
che non va sulla tua macchina, oppure nel come esegui i test.
Ho eseguito la tua regexp su tre macchine differenti (tra cui
un paio Windows e una Mac OSX), e giusto per meticolosità, ho
chiesto ad altre persone di testare a loro volta (tra l'altro
una di queste è del NG).
Tutti i risultati sono stati uguali a quelli che mi aspettavo
e che sono conformi alle reference circa l'uso dei look-ahead
(con le differenze note su IE, in questa situazione).
Ignoro il perché a te dia risultati del tutto diversi.
Inviterei per chi avesse seguito il thread, di fare dei test,
e postare il risultato: nel caso in cui si riscontrassero dei
casi simili al tuo, forse si potrebbe capirne il perché.


 casi simili al tuo, forse si potrebbe capirne il perché.
Ne sarei felice. :-) (mi aspettavo anche un commento da Renato, ma...)
Confermo ancora che: se all'inizio della password vengono inseriti SOLO
i tre tipi di carattere (uno per tipo, non importa l'ordine) la regexp
ha funzionato correttamente in TUTTE le prove che ho effettuato.
-- 
    * b *
  *   y   *
*   Piero   *
[ /errare humanum est/ ] 

 IE non mi ha mai dato problemi con il lookahead, 
Per forza, perché dai tuoi test parrebbe che TUTTI i browser abbiano
i difetti che ha IE con i look-ahead. :)
I look-ahead per loro stessa definizione non consumano caratteri. Su
IE, in regexp come quella in soggetto invece, ciò avviene.
E questo è un errore, non è corretto.


 E questo č un errore, non č corretto.
Ho inziato le prove con questa regexp:
/^(?=.*[a-zA-Z])(?=.*[0-9])(?=.*[+\-*\/=])[a-zA-Z0-9+\-*\/=]{6,12}$/
ed ho constatato che con FF ed Opera faceva quel che doveva, cioč:
validare una password da 6 a 12 caratteri dei tre tipi permessi con
almeno uno per tipo, qualsiasi fosse la conbinazione digitata.
E le numerose prove fatte l'hanno confermato. :-)
Quando l'ho provata con IE ho riscontrato il problema descritto, quello
che hai definito "consumare i caratteri"; allora per renderla compatibile
anche con IE  in <l-39-07.06.22$bcE7ecG49feAA.peoir@response> ho scritto:
.............. _*Beginning of the citation*_ ..............
I tre caratteri obbligatori (alfabetico, numerico, speciale) devono
essere i primi digitati, anche se in ordine casuale...
............... _*The end of the citation*_ ...............
e contemporaneamente ho portato il quantificatore minimo da 6 a 4 "{4,12}"
in modo che anche su IE si potesse utilizzare la regexp.
Ad onor del vero, con FF ed Opera, questa regexp valida anche psw con 4
caratteri, ma su questo ho preferito sorvolare. ^_^
Ora dopo averti spiegato tutta la trafila, almeno credo, sarei curioso di
sapere se anche tu ottieni gli stessi risultati.
-- 
    * b *
  *   y   *
*   Piero   *
[ /deus ex machina/ ] 


E finalmente assodato ciň, mi spieghi come puoi affermare che:
"la regexp valida una psw con 6/12 caratteri (come ha chiesto l'OP),"
(<news:Z-39-07.06.24$1567dfAL233259.peoir@response>)
Cosa che, dopo che te l'ho ripetuto, hai tu stesso smentito in questo
post :)
E che ti risulti i test con stringhe come:
	"salve1aa+" e "1aa+salve"
"Con la mia regexp risultano tutte false con i tre browser."
?
Questo, non mi torna.
Perché su implementazioni conformi alle specifiche, come tu stesso hai
constatato con le tue "prime prove", non vi č alcun problema.
-- 
~ L'ingegnere non vive, funziona.

 constatato con le tue "prime prove", non vi è alcun problema.
Ok, visti i miei limiti, adesso mi aspetto da te una regexp *veramente*
crossbrowsing, che validi una password con 6/12 caratteri, qualsiasi sia la
conbinazione digitata. :-P
-- 
    * b *
  *   y   *
*   Piero   *
[ /audaces fortuna iuvat/ ] 

 conbinazione digitata. :-P
Come ho già detto, si può fare ma diventa una palla, e se non ce n'è
una necessità effettiva è altamente preferibile fare diversi check a
livello di codice, come il thread stesso ha consigliato all'OP.
Il mio post iniziale voleva solo indicarne la possibilità. :)


 Il mio post iniziale voleva solo indicarne la possibilità. :)
Ed io c'ho provato. ;-)
-- 
    * b *
  *   y   *
*   Piero   *
[ /ad maiora/ ]