Newsgroup: it.comp.lang.javascript
Titolo: regex esclusa parola

Non riesco ad ottenere una regex valida quando non ï¿œ presente la parola
"feed" oppure "match" nella url:
http://www.url.com/feed/
 
 


Questa regexp fa quello che chiedi:
valida "true" quando manca/no  quella/e parola/e, "false" al contrario.
 
copia/incolla:
 
<html>
<body>
    <script type="text/javascript">
 
      function validateStr(aString)
      {
          var e=/\bfeed\b|\bmatch\b/;
          if(e.test(aString)) {  return false; }
          else {  return true; }
      }
    </script>
 
    <form>
    <input type="text" name="testfield">
    <input type="button" onclick="alert(validateStr(this.form.testfield.value))" value="valida">
    </form>
</body>
</html>
 
-- 
    * b *
  *   y   *
*   Piero   *
#v+
Ho nascosto qualche grammo di cervello per uso personale.
#v-
 
 

           else {  return true; }
 
Puoi semplicemente restituire:
 
return !e.test(aString);
 
:)
 

> return !e.test(aString);
cosï¿œ non vale ;)
a me serva che torni vero o falso giï¿œ da regex senza invertirlo con js.
 

"ZER0" [by Mozilla/5.0 (Macintosh; Intel Mac OS X 10.7; rv:17.0)

Ma grazie, ne ho imparata un'altra. :-)
-- 
    * b *
  *   y   *
*   Piero   *
#v+
-ad maiora-
#v-
 


Puoi provare a giocare un po' con il negative lookahead, qualcosa tipo:
 
    /^(?!.*\b(?:feed|match)\b)/.test("
http://www.url.com/feed/
")
 
https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/RegExp
 


Non ho ben capita la richiesta, se vuoi usare il replace:
replace(/.*\bfeed\b.*|.*\bmatch\b.*/,"false")
 
-- 
    * b *
  *   y   *
*   Piero   *
#v+
-audaces fortuna iuvat-
#v-
 
 

 Non ho ben capita la richiesta
 
Intende dire, a occhio, che non puï¿œ usare JavaScript, ma che ha bisogno
di una regexp che sia di per sï¿œ "vera" se non contiene quei dati termini.
 
Un esempio di tale limitazione puï¿œ essere dato da un sistema di
validazione (di un framework) che accetti solo regexp, ad esempio.

 
Perchï¿œ questa variazione non mi funziona?
 
alert(/^http:\/\/nomesito\.it\/(.*?)^(?!.*\b(?:feed|match)\b).*?\/$/.test("
http://nomesito.it/testo-uno/testo-titolo/
"));
 
 

 alert(/^http:\/\/nomesito\.it\/(.*?)^(?!.*\b(?:feed|match)\b).*?\/$/.test("
http://nomesito.it/testo-uno/testo-titolo/
"));
 
Dovrebbe essere qualcosa del genere:
 
    /^http:\/\/nomesito\.it\/(?!.*\b(?:feed|match)\b.*?\/$/
 
Anche se, a mio avviso, ï¿œ piuttosto ridondante.

ty :)
 

 validazione (di un framework) che accetti solo regexp, ad esempio.
 
Vediamo se ho capito:
 
<html>
<body>
 
    <script type="text/javascript">
 
      alert(/.*\bfeed\b.*|.*\bmatch\b.*/.test("
http://www.url.com/feed/
"));  //true
      alert(/.*\bfeed\b.*|.*\bmatch\b.*/.test("
http://www.url.com/feedi/
")); //false
 
    </script>
 
</body>
</html>
-- 
    * b *
  *   y   *
*   Piero   *
#v+
Guardo il cielo e sorrido, spero in una foto satellitare.
#v-
 
 


alert(/.*\bfeed\b.*|.*\bmatch\b.*/.test("
http://www.url.com/feedi/
"));
//false
 
Avrebbe dovuto restituire `true`.
 
Quindi, la logica iniziale che avevi scritto andava bene, ma si
appoggiava a codice JavaScript in aggiunta alla regexp: negavi il
risultato ottenuto per avere il valore che ti serviva.

 risultato ottenuto per avere il valore che ti serviva.
 
Che avevo ottenuto il risultato opposto me n'ero accorto. :-)
 
All'atto pratico non capisco cosa cambi, con true sa che ha matchato una
o due parole, con false il contrario.
 
Perï¿œ vorrei capire come ottenere il risultato opposto, poichï¿œ le regexp
son fatte per matchare e di conseguenza ottieni true se trova e false se
non trova.
 
Pensa che ho provato anche lookahead e lookbehind, e con le positive
ovvio che facevano quel che dovevano fare, ma le negative (che avrebbero
dovuto fare il contrario) davano lo stesso risultato sia con "feed" che
con "feedi", true per lookahead e false per lookbehind o viceversa, ora
non ricordo, ma ho constatato che *non funzionavano!*
 
A te l'ardua sentenza. :-)
-- 
    * b *
  *   y   *
*   Piero   *
#v+
-audaces fortuna iuvat-
#v-
 

 A te l'ardua sentenza. :-)
 
La mia soluzione utilizza una negative lookahead, e fa quel che deve
fare, non so se hai avuto modo di provarla:
 
    // restituisce `false`
    /^(?!.*\b(?:feed|match)\b)/.test("
http://www.url.com/feed/
")
 
    // restituisce `true`
    /^(?!.*\b(?:feed|match)\b)/.test("
http://www.url.com/feedi/
")
 
 

     /^(?!.*\b(?:feed|match)\b)/.test("
http://www.url.com/feedi/
")
 
GRANDE!
certo che avevo provato la negative lookhaed, ma io l'avevo scritta con
le square bracket, che scemo...
 
/^(?!.*\b[feed|match]\b)/.test("
http://www.url.com/feed/
")
/^(?!.*\b[feed|match]\b)/.test("
http://www.url.com/feedi/
")
entrambe mi restituivano true
 
Grazie, ho imparato ancora...
 
P.S. "?:" mi risulta che non serve.
-- 
    * b *
  *   y   *
*   Piero   *
#v+
Alzhaimer e... cammina.
#v-
 

 P.S. "?:" mi risulta che non serve.
 
Se lo ometti, te lo ricorda come gruppo. Preferisco sempre evitare di
"sporcare" i gruppi, se non mi serve:
 
    /foo(bar)/.test("foobar");
    alert(RegExp.$1) // "bar"
 
    /foo(?:bar)/.test("foobar");
    alert(RegExp.$1) // ""
 
Conta che queste proprietï¿œ ($1 etc) sono deprecated, sebbene siano
comunque accessibili il loro uso ï¿œ sconsigliato; le ho usate solo per
farti vedere che i gruppi vengono appunto "ricordati".

 farti vedere che i gruppi vengono appunto "ricordati".
 
Sai, non sapevo che ($1 etc) erano deprecate, ora capisco la funzione di
"?:".
 
Thanks
-- 
    * b *
  *   y   *
*   Piero   *
#v+
Tutto il futuro è racchiuso nella sacra sillaba "bo!".
#v-