Che cosa è una parola di confine in espressioni regolari?

Question

Sto usando Java espressioni regolari in Java 1.6 (tra l'altro per analizzare l'output numerico) e non riesce a trovare una definizione precisa di \b ( "limite di parola"). Ho dato per scontato che -12 sarebbe una "parola integer" (accompagnato da \b\-?\d+\b), ma sembra che questo non funziona. Sarei grato di sapere di modi di numeri corrispondenti separati da spazi.

Esempio:

Pattern pattern = Pattern.compile("\\s*\\b\\-?\\d+\\s*");
String plus = " 12 ";
System.out.println(""+pattern.matcher(plus).matches());
String minus = " -12 ";
System.out.println(""+pattern.matcher(minus).matches());
pattern = Pattern.compile("\\s*\\-?\\d+\\s*");
System.out.println(""+pattern.matcher(minus).matches());

Questa operazione riporta:

true
false
true

Answer 1

Un limite di parola, nella maggior parte dei dialetti regex, è una posizione tra \w e \W (non carattere di parola), o all'inizio o alla fine di una stringa se inizia o (rispettivamente) termina con un carattere di parola ([0-9A-Za-z_]) .

Quindi, nella "-12" stringa, sarebbe partita prima del 1 o dopo la 2. Il trattino non è un carattere di parola.

Answer 2

Un limite di parola può verificarsi in una delle tre posizioni:

1. Prima del primo carattere della stringa, se il primo carattere è un carattere di parola.
2. Dopo l'ultimo carattere della stringa, se l'ultimo carattere è un carattere di parola.
3. Tra due caratteri della stringa, in cui uno è un carattere di parola e l'altro non è un carattere di parola.

caratteri di Word sono alfanumerici; un segno meno non lo è. Tratto da Regex Tutorial .

Answer 3

Un limite di parola è una posizione che si sia preceduta da un carattere di parola e non seguito da uno, o seguito da un carattere di parola e non preceduto da uno.

Answer 4

parlo di quello che \b stile confini regex in realtà sono qui .

Il racconto è che sono condizionale . Il loro comportamento dipende da quello che stanno accanto.

# same as using a \b before:
(?(?=\w) (?<!\w)  | (?<!\W) )

# same as using a \b after:
(?(?<=\w) (?!\w)  | (?!\W)  )

A volte questo non è ciò che si desidera. Vedi la mia altra risposta per l'elaborazione.

Answer 5

Controlla la documentazione su condizioni al contorno:

http://java.sun.com/docs /books/tutorial/essential/regex/bounds.html

Dai un'occhiata a questo esempio:

public static void main(final String[] args)
    {
        String x = "I found the value -12 in my string.";
        System.err.println(Arrays.toString(x.split("\\b-?\\d+\\b")));
    }

Quando si stampa fuori, notare che l'uscita è questa:

[Ho trovato il valore -, nella mia stringa.]

Ciò significa che il carattere "-" non vengono presi come essere sul confine di una parola, perché non è considerato un carattere di parola. Sembra @brianary mi ha battuto un pò al punzone, così si ottiene un up-voto.

Answer 6

Mi sono imbattuto in un problema ancora peggio quando la ricerca di testo per parole come .NET, C++, C# e C. Si potrebbe pensare che i programmatori di computer avrebbero saputo meglio di per citarne qualcosa linguaggio che è difficile scrivere espressioni regolari per.

In ogni caso, questo è quello che ho scoperto (riassunto per lo più da http://www.regular-expressions.info , che è un ottimo sito): Nella maggior parte dei sapori della regex, personaggi che sono compensate da breve a mano classe di caratteri \w sono i personaggi che sono trattati come caratteri di parola dai confini di parola. Java è un'eccezione. Java supporta Unicode per \b ma non per \w. (Sono sicuro che c'era una buona ragione per questo, al momento).

Il \w sta per "carattere di parola". Si abbina sempre la [A-Za-z0-9_] caratteri ASCII. Si noti l'inclusione della sottolineatura e cifre (ma non Dash!). Nella maggior parte dei sapori che supportano Unicode, \w include molti personaggi provenienti da altri script. C'è un sacco di incoerenza su quali personaggi sono di fatto incluse. Lettere e cifre da script alfabetici e ideogrammi sono generalmente inclusi. punteggiatura connettore diverso da quello di sottolineatura e simboli numerici che non sono possono o non possono essere inclusi cifre. XML Schema e XPath includono anche tutti i simboli in \w. Ma Java, JavaScript, e PCRE partita solo caratteri ASCII con \w.

Qual è il motivo per cui le ricerche regex basati su Java per C++, C# o .NET (anche quando si ricorda di fuggire il periodo e vantaggi) sono chiavata del \b.

Nota: Non sono sicuro di cosa fare di errori nel testo, come quando qualcuno non mettere uno spazio dopo un periodo alla fine di una frase. Ho permesso per questo, ma non sono sicuro che sia necessariamente la cosa giusta da fare.

In ogni caso, in Java, se siete alla ricerca di testo per le quelle lingue strane nome, è necessario sostituire il \b con prima e dopo la spaziatura e la punteggiatura designatori. Ad esempio:

public static String grep(String regexp, String multiLineStringToSearch) {
    String result = "";
    String[] lines = multiLineStringToSearch.split("\\n");
    Pattern pattern = Pattern.compile(regexp);
    for (String line : lines) {
        Matcher matcher = pattern.matcher(line);
        if (matcher.find()) {
            result = result + "\n" + line;
        }
    }
    return result.trim();
}

Poi, nel tuo test o funzione principale:

    String beforeWord = "(\\s|\\.|\\,|\\!|\\?|\\(|\\)|\\'|\\\"|^)";   
    String afterWord =  "(\\s|\\.|\\,|\\!|\\?|\\(|\\)|\\'|\\\"|$)";
    text = "Programming in C, (C++) C#, Java, and .NET.";
    System.out.println("text="+text);
    // Here is where Java word boundaries do not work correctly on "cutesy" computer language names.  
    System.out.println("Bad word boundary can't find because of Java: grep with word boundary for .NET="+ grep("\\b\\.NET\\b", text));
    System.out.println("Should find: grep exactly for .NET="+ grep(beforeWord+"\\.NET"+afterWord, text));
    System.out.println("Bad word boundary can't find because of Java: grep with word boundary for C#="+ grep("\\bC#\\b", text));
    System.out.println("Should find: grep exactly for C#="+ grep("C#"+afterWord, text));
    System.out.println("Bad word boundary can't find because of Java:grep with word boundary for C++="+ grep("\\bC\\+\\+\\b", text));
    System.out.println("Should find: grep exactly for C++="+ grep(beforeWord+"C\\+\\+"+afterWord, text));

    System.out.println("Should find: grep with word boundary for Java="+ grep("\\bJava\\b", text));
    System.out.println("Should find: grep for case-insensitive java="+ grep("?i)\\bjava\\b", text));
    System.out.println("Should find: grep with word boundary for C="+ grep("\\bC\\b", text));  // Works Ok for this example, but see below
    // Because of the stupid too-short cutsey name, searches find stuff it shouldn't.
    text = "Worked on C&O (Chesapeake and Ohio) Canal when I was younger; more recently developed in Lisp.";
    System.out.println("text="+text);
    System.out.println("Bad word boundary because of C name: grep with word boundary for C="+ grep("\\bC\\b", text));
    System.out.println("Should be blank: grep exactly for C="+ grep(beforeWord+"C"+afterWord, text));
    // Make sure the first and last cases work OK.

    text = "C is a language that should have been named differently.";
    System.out.println("text="+text);
    System.out.println("grep exactly for C="+ grep(beforeWord+"C"+afterWord, text));

    text = "One language that should have been named differently is C";
    System.out.println("text="+text);
    System.out.println("grep exactly for C="+ grep(beforeWord+"C"+afterWord, text));

    //Make sure we don't get false positives
    text = "The letter 'c' can be hard as in Cat, or soft as in Cindy. Computer languages should not require disambiguation (e.g. Ruby, Python vs. Fortran, Hadoop)";
    System.out.println("text="+text);
    System.out.println("Should be blank: grep exactly for C="+ grep(beforeWord+"C"+afterWord, text));

P.S. I miei ringraziamenti a http://regexpal.com/ senza i quali il mondo regex sarebbe molto infelice!

Answer 7

Nel corso di apprendimento delle espressioni regolari, ero veramente bloccato nel metacarattere che è \b. Io davvero non capisco il suo significato, mentre mi chiedevo " quello che è, ciò che è " ripetutamente. Dopo alcuni tentativi utilizzando sito , guardo fuori i trattini verticali rosa a ogni inizio di parole e alla fine delle parole. Ho preso il suo significato anche in quel momento. Ora è esattamente parola (\w) -CONTORNO .

La mia opinione è semplicemente quello di immensamente comprensione-oriented. Logica dietro di esso dovrebbe essere esaminata da un altro risposte.

Answer 8

Vorrei spiegare risposta Alan Moore 's

  

Un limite di parola è una posizione che si sia preceduta da un carattere di parola e non seguito da uno, o seguito da un carattere di parola e non preceduto da uno.

Supponiamo che io sono una stringa "Questo è a c a t e lei è a wesome", e dovrei sostituire tutti occurance (s) la lettera 'a' solo se questa lettera esiste al "Boundry di una parola" vale a dire la lettera a dentro 'gatto' non dovrebbe essere sostituito.

Quindi io compio regex (in Python ) come

re.sub("\ba","e", myString.strip()) // sostituire a con e

in modo uscita sarà Questo è e c a t end lei è ewesome

Answer 9

Credo che il problema è dovuto al fatto che - non è un carattere di parola. Così, il limite di parola corrisponderà dopo la -, e così non catturarlo. I confini delle parole corrispondono prima della prima e dopo gli ultimi caratteri di parola in una stringa, così come ogni luogo dove prima si tratta di un personaggio carattere di parola o di non-parola, e dopo che è stato l'opposto. Si noti inoltre che confine di parola è un match di ampiezza zero.

Una possibile alternativa è

(?:(?:^|\s)-?)\d+\b

Questo prodotto risultati in nessun numeri che iniziano con un carattere di spazio e di un cruscotto opzionale, e termina al limite di una parola. Sarà anche corrispondere un numero a partire dall'inizio della stringa.

Answer 10

confine di parola \ b viene utilizzato quando una parola dovrebbe essere un carattere di parola e un altro un carattere non-parola. Espressione regolare per numero negativo deve essere

--?\b\d+\b

DEMO

Answer 11

Credo che sia il confine (cioè carattere che segue) dell'ultimo incontro o all'inizio o alla fine della stringa.

Answer 12

quando si utilizza \\b(\\w+)+\\b che significa corrispondenza esatta con una parola che contiene solo caratteri di parola ([a-zA-Z0-9])

nel tuo caso per l'impostazione \\b all'inizio di regex accetterà -12 (con lo spazio), ma ancora una volta non accetterà -12 (senza spazio) Esempio

di riferimento per sostenere le mie parole: https: // docs. oracle.com/javase/tutorial/essential/regex/bounds.html