Corrispondenza singola parola, con possibile punteggiatura o pluralizzazione alla fine (Regex)

Question

Mi sono migliorato con Regex, ma ho trovato qualcosa che va oltre ciò che sono attualmente in grado di fare.

Voglio costruire una funzione per testare (restituisce true o false) per verificare se una parola viene trovata all'interno di una stringa. Ma non vorrei avere una corrispondenza positiva se la parola fosse trovata all'interno di un'altra parola. Mi piacerebbe anche costruire la possibilità di verificare la pluralizzazione.

Ecco alcuni esempi dei risultati che ci si aspetta di ottenere:

Parola da cercare: "bar"

"Stringhe per la ricerca in" // quello che dovrebbe ritorno,

"foo bar" // vero

"foo bar." // true

"foo bar!" // true (sarebbe vero con qualsiasi altra punteggiatura prima o dopo "bar")

"foo bar". // true

"foo bares". // true (anche se bares ha un significato diverso da bar, sarei ok con questo ritorno vero dato che avrei bisogno di verificare le parole che pluralizzano con "es" e non mi aspetterei di costruire una regex per sapere quali parole plurale con "s" e che a "es")

"il mio nome è bart simpson" // false (bar è in realtà parte di "bart")

"bart simpson andato al bar." // vero

sarò con JavaScript/jQuery per verificare la presenza di partite

Grazie mille per l'aiuto!

Answer 1

var rgx = new RegExp('\\b' + word + '(?:es|s)?\\b'); 
rgx.test(string); 

Ciò restituirà true per tutte le stringhe che hai specificato nella richiesta. \b rappresenta un "limite di parole", che credo sia un qualsiasi carattere in \W (compresi punto e punto esclamativo) nonché l'inizio o la fine della stringa.

Answer 2

/ (bar((e)?s)?)[ !?.]/ 

a seconda di ciò che serve esattamente questo potrebbe funzionare. non troverà due barre nella stringa "barre" a causa degli spazi sovrapposti.

/ (bar((e)?s)?)(?=[ !?.])/ 

che dovrebbe funzionare con "Bar Bar" (due partite) dal js1.5 che è supportato da tutti i browser in ogni caso al giorno d'oggi.

Answer 3

Questo è già stato risposto e accettato, ma ho pensato di fornire un leggermente approccio over-engineered che fa un lavoro migliore di abbinare le forme plurali.Oltre a questo, si utilizza esattamente la stessa logica soluzione @ExplosionPills':

(function() { 
    var isWord = function(word) { return /^[a-z]+$/i.test(word); }, 

     exceptions = { 
     man: 'men', 
     woman: 'women', 
     child: 'children', 
     mouse: 'mice', 
     tooth: 'teeth', 
     goose: 'geese', 
     foot: 'feet', 
     ox: 'oxen' 
     }, 

     pluralise = function(word) { 
     word = word.toLowerCase(); 

     if (word in exceptions) { 
      // Exceptions 
      return '(?:' + word + '|' + exceptions[word] + ')'; 

     } else if (word.match(/(?:x|s|[cs]h)$/)) { 
      // Sibilants 
      return word + '(?:es)?'; 

     } else if (word.match(/[^f]f$/)) { 
      // Non-Geminate Labio-Dental Fricative (-f > -ves/-fs) 
      return '(?:' + word + 's?|' + word.replace(/f$/, 'ves') + ')'; 

     } else if (word.match(/[^aeiou]y$/)) { 
      // Close-Front Unround Pure Vowel (-Cy > -Cies) 
      return '(?:' + word + '|' + word.replace(/y$/, 'ies') + ')'; 

     } else if (word.substr(-1) == 'o') { 
      // Mid-Back Round Vowel (-o > -oes/-os) 
      return word + '(?:e?s)?'; 

     } else { 
      // Otherwise 
      return word + 's?'; 
     } 
     }; 

    String.prototype.containsNoun = function(singularNoun) { 
    if (!isWord(singularNoun)) throw new TypeError('Invalid word'); 
    var check = new RegExp('\\b' + pluralise(singularNoun) + '\\b', 'gi'); 
    return check.test(this); 
    }; 

    String.prototype.pluralException = function(plural) { 
    if (!isWord(this) || !isWord(plural)) throw new TypeError('Invalid exception'); 

    var singular = this.toLowerCase(); 
    plural = plural.toLowerCase(); 

    if (!(singular in exceptions)) { 
     exceptions[singular] = plural; 
    } 
    }; 
})(); 

Si estende la String oggetto nativo, in modo da utilizzare in questo modo:

'Are there some foos in here?'.containsNoun('foo'); // True 

Vedi the gist per qualche quick- test di unità sporche eseguite in Node.js.