Macht die bash-support-Wort-Grenze reguläre Ausdrücke?

tl;dr

• Sicher zu sein, nicht mit einem regex wörtliche mit =~.
  
  Verwenden Sie stattdessen:

  • entweder: ein Hilfs-variable - siehe @Eduardo Ivancec Antwort.
  • oder: eine Kommando-substitution, die Ausgänge ein string-literal - siehe @ruakh Kommentar @Eduardo Ivancec Antwort
  • Beachten Sie, dass beide verwendet werden muss nicht börsennotierten als =~ RS.

• Ob \b und \< /\> sind unterstützt hängt von der die host-Plattform, nicht Bash:

  • Sie funktionieren auf Linux,
  • aber NICHT auf BSD-basierte Plattformen wie macOS; dort verwenden [[:<:]] und [[:>:]] statt, die im Rahmen einer nicht börsennotierten regex wörtliche, die geschützt werden müssen, wie [[:\<:]] und [[:\>:]]; das folgende funktioniert wie erwartet, aber nur auf BSD/macOS:
    • [[ ' myword ' =~ [[:\<:]]myword[[:\>:]] ]] && echo YES # OK

• Den problem würde nicht entstehen - auf jeder Plattform - , wenn Sie beschränkt Ihre regex, um die Konstrukte in der POSIX-ERE (extended regular expression) - Spezifikation.

  • Leider POSIX-EREs tun nicht support-Wort-Grenze Behauptungen, aber Sie können emulieren Sie - siehe den letzten Abschnitt.

  • Als auf macOS, keine \-Präfix-Konstrukte werden unterstützt, so dass der praktische Charakter-Klasse Verknüpfungen wie \s und \w sind nicht verfügbar.

  • Jedoch, die up-Seite ist, dass solche ERE-konform regexes sind dann portable (arbeiten auf Linux-und macOS zum Beispiel)

=~ ist der seltene Fall (der einzige Fall?) der built-in Bash-Funktion, deren Verhalten ist Plattform-abhängigen: Er verwendet die regex-Bibliotheken, die von der Plattform ausgeführt wird, was in verschiedenen regex-Aromen, die auf verschiedenen Plattformen.

So, es ist in der Regel nicht trivial und erfordert zusätzliche Pflege, um zu schreiben portable code, der verwendet die =~ Betreiber.
Kleben mit POSIX-EREs ist der einzige robuste Ansatz, was bedeutet, dass Sie arbeiten müssen, um Ihre Einschränkungen - siehe unten Abschnitt.

Wenn Sie mehr wissen wollen, Lesen Sie weiter.

Auf Bash v3.2+ (es sei denn, die compat31 shopt option gesetzt ist), die RHS (right-hand side-operand) der =~ Betreiber muss nicht börsennotierten, um zu erkennen, wie ein regex (wenn Sie zitieren der rechten Operanden =~ führt regelmäßig string-Vergleich statt).

^{genauer, zumindest die spezielle regex-Zeichen und Sequenzen müssen ohne Anführungszeichen, so ist es OK und sinnvoll zu zitieren, diejenigen Teilstrings, die ergriffen werden sollten buchstäblich; z.B. [[ '*' =~ ^'*' ]] entspricht, weil ^ ist nicht börsennotierten und damit richtig erkannt, der start-of-string-Anker, in der Erwägung, dass *, die in der Regel eine spezielle regex-char, Spiele buchstäblich aufgrund der Quotierung.}

Jedoch, es scheint sich um ein design-Einschränkung in (mindestens) bash 3.x dass verhindert die Verwendung von \-Präfix regex-Konstrukte (z.B., \<, \>, \b, \s, \w, ...) in einem wörtliche =~ RHS; die Einschränkung betrifft Linux, in der Erwägung, dass BSD/macOS-Versionen sind nicht betroffen, aufgrund der grundsätzlich nicht unterstützt jede \-Präfix regex-Konstrukte:

# Linux only:
# PROBLEM (see details further below): 
#   Seen by the regex engine as: <word>
#   The shell eats the '\' before the regex engine sees them.
[[ ' word ' =~ \<word\> ]] && echo MATCHES # !! DOES NOT MATCH
#   Causes syntax error, because the shell considers the < unquoted.
#   If you used \\bword\\b, the regex engine would see that as-is.
[[ ' word ' =~ \\<word\\> ]] && echo MATCHES # !! BREAKS
#   Using the usual quoting rules doesn't work either:
#   Seen by the regex engine as: \\<word\\> instead of \<word\>
[[ ' word ' =~ \\\<word\\\> ]] && echo MATCHES # !! DOES NOT MATCH

# WORKAROUNDS
  # Aux. viarable.  
re='\<word\>'; [[ ' word ' =~ $re ]] && echo MATCHES # OK
  # Command substitution
[[ ' word ' =~ $(printf %s '\<word\>') ]] && echo MATCHES # OK

  # Change option compat31, which then allows use of '...' as the RHS
  # CAVEAT: Stays in effect until you reset it, may have other side effects.
  #         Using (...) around  the command confines the effect to a subshell.
(shopt -s compat31; [[ ' word ' =~ '\<word\>' ]] && echo MATCHES) # OK

Das problem:

^{Tipp der Hut, um Fólkvangr für seine Ideen.}

Eine wörtliche RHS von =~ ist von design analysiert anders als nicht börsennotierte Token als argument, in einer versuchen, dem Benutzer zu ermöglichen, den Fokus auf escaping von Zeichen nur für die regex, ohne auch sorgen über die üblichen shell Flucht-Vorschriften in nicht börsennotierten Token.

Beispielsweise

[[ 'a[b' =~ a\[b ]] && echo MATCHES  # OK

entspricht, weil die \ ist _passed durch die regex-engine (das ist der regex-engine sieht wörtliche a\[b), in der Erwägung, dass, wenn Sie das gleiche nicht börsennotierten token als eine reguläre argument, die üblichen shell-Erweiterungen angewendet, um nicht börsennotierte Token würde "Essen" die \, denn es wird interpretiert als ein shell escape-Zeichen:

$ printf %s a\[b
a[b  # '\' was removed by the shell.

Jedoch im Rahmen der =~ dieses außergewöhnliche Durchreise von \ wird nur angewendet, bevor die Zeichen werden in regex Metazeichen selbst, wie definiert durch die ERE (extended regular expressions), die POSIX-Spezifikation (um Ihnen zu entkommen für die regex -, so dass Sie behandelt sind wie Literale:

\ ^ $ [ { . ? * + ( ) |

Umgekehrt diese regex-Metazeichen kann ausnahmsweise verwendet werden nicht börsennotierten - und in der Tat muss gelassen werden ohne Anführungszeichen zu haben, die Ihre Besondere regex Bedeutung - obwohl die meisten von Ihnen erfordern in der Regel \-Flucht in nicht börsennotierten tokens zu verhindern, dass die shell von Sie zu interpretieren.

Noch ein Teilmenge der shell Metazeichen tun müssen noch die Flucht, für die shell's sake, um nicht zu brechen die syntax der [[ ... ]] bedingt:

& ; < > space

Da diese Charaktere nicht auch regex Metazeichen, besteht keine Notwendigkeit zu unterstützen und Ihnen zu entkommen, die auf den regex-Seite, so dass, zum Beispiel, die regex-engine zu sehen \& in der RHS als nur & funktioniert einwandfrei.

Für alle anderen Zeichen vorangestellt \ die shell entfernt die \ vor dem senden die Zeichenfolge an die regex-engine (wie bei normalen shell-Erweiterung), was bedauerlich ist, denn dann auch Zeichen, die die shell nicht betrachten besonderen können nicht übergeben werden, als \<char> an die regex-engine, weil die Schale immer übergibt Sie als nur <char>.

E. g, \b wird immer gesehen als nur b durch die regex-engine.

Deshalb ist es derzeit unmöglich, eine (per definition nicht-POSIX -) regex-Konstrukt in der form \<char> (z.B., \<, \>, \b, \s, \w, \d, ...) in einem buchstäblichen, nicht börsennotierten =~ RHS, weil keine form der Flucht können Sie sicherstellen, dass diese Konstrukte gesehen werden, die durch die regex engine als solche, nach der Analyse durch die shell:

Da weder <, > noch b sind regex Metazeichen der shell entfernt die \ aus \<, \>, \b (wie geschieht in regelmäßigen shell-expansion). Also, vorbei \<word\>, zum Beispiel, macht die regex-engine finden Sie unter <word>, das ist nicht die Absicht:

• [[ '<word>' =~ \<word\> ]] && echo YES entspricht, da die regex-engine sieht <word>.
• [[ 'boo' =~ ^\boo ]] && echo YES entspricht, da die regex-engine sieht ^boo.

Versuchen \\<word\\> bricht den Befehl, weil die shell behandelt jeden \\ als ein entflohener \, was bedeutet, dass Metazeichen < ist dann als nicht börsennotierten, was zu einer syntax-Fehler:

• [[ ' word ' =~ \\<word\\> ]] && echo YES verursacht einen Syntaxfehler.
• Dies wäre nicht geschehen, mit \\b, aber \\b ist Durchlaufen (aufgrund der \ vor einer regex metachar, \), die auch nicht funktioniert:
  • [[ '\boo' =~ ^\\boo ]] && echo YES entspricht, da die regex-engine sieht \\boo, was mit wörtlichen \boo.

Versuchen \\\<word\\\> - die durch die normalen shell-Erweiterung Regeln Ergebnisse in \<word\> (versuchen printf %s \\\<word\\\>) - auch nicht funktioniert:

• Was passiert, ist, dass die shell isst die \ im \< (dito für \b und andere \-Präfix-Sequenzen), und dann geht der vorhergehenden \\ durch die regex-engine ist (wieder, weil \ beibehalten wird, bevor ein regex metachar):

• [[ ' \<word\> ' =~ \\\<word\\\> ]] && echo YES entspricht, da die regex-engine sieht \\<word\\>, was mit wörtlichen \<word\>.

Kurz:

• Bash beim Parsen von =~ RHS Literale wurde mit single-Charakter regex-Metazeichen im Sinn und unterstützt nicht multi-Charakter Konstrukte, die beginnen mit \ wie \<.

  • Weil POSIX-EREs-Unterstützung keine solchen Konstrukte, =~ wie vorgesehen funktioniert, wenn Sie sich beschränken auf solche regexes.

  • Aber selbst innerhalb dieser Einschränkung für das design ist etwas umständlich, aufgrund der Notwendigkeit der mix-regex-und-shell-bezogenen \-Flucht (Zitat).

  • Fólkvangr fand die offizielle design Begründung in der Bash-FAQ hier, die jedoch weder Adressen, sagte Unbeholfenheit noch die fehlende Unterstützung für die (immer nicht-POSIX -) \<char> regex-Konstrukte; Sie erwähnt, dass mithilfe eines aux. variable als workaround, allerdings nur in Bezug auf so dass es leichter zu vertreten Leerzeichen.

• All diese parsing-Probleme gehen Weg, wenn die Zeichenfolge, die die regex-engine sehen sollten, ist vorgesehen, über eine variable oder über die Ausgabe von einer Substitutionen, wie oben gezeigt.

Optional zu Lesen: Ein Tragbarer emulation von word-boundary Behauptungen mit POSIX-konformen EREs (extended regular expressions):

• (^|[^[:alpha:][:digit:]_]) statt \< /[[:<:]]

• ([^[:alpha:][:digit:]_]|$) statt \> /[[:>:]]

Hinweis: \b können nicht emuliert werden, mit einem EINZIGEN Ausdruck - verwenden Sie die oben an den entsprechenden stellen.

Den potenziellen Nachteil ist, dass die oben genannten Ausdrücke werden auch erfassen das nicht-Wort-Zeichen übereinstimmen, in der Erwägung, dass wahre Behauptungen wie \< /[[:<:]] und nicht.

$foo = 'myword'
[[ $foo =~ (^|[^[:alpha:][:digit:]_])myword([^[:alpha:][:digit:]_]|$) ]] && echo YES

Den oben genannten Spiele, wie erwartet.

Nicht genau, "\b", aber für mich besser lesbar (und portable) als die anderen Vorschläge:

[[  $foo =~ (^| )myword($| ) ]]

Tangential auf deine Frage, aber wenn Sie verwenden können grep -E (oder egrep seine effektive, aber veraltete alias) in Ihrem Skript:

if grep -q -E "\b${myword}\b" <<<"$foo"; then

Landete ich mit diesem nach flailing mit der bash ist =~.

Beachten Sie, dass während der regex-Konstrukte \<, \>, und \b sind nicht POSIX-konform, sowohl die BSD (macOS) und GNU (Linux) Implementierungen von grep -E unterstützen, die diesen Ansatz weit nutzbar in der Praxis.

Kleine Einschränkung (kein Problem in dem Fall bei der hand): nicht mit =~, verlieren Sie die Fähigkeit zu inspizieren Erfassung Teilausdrücke (capture-Gruppen) über ${BASH_REMATCH[@]} später.

Können Sie mit grep, das ist mehr tragbar als bash den regexp so:

if echo $foo | grep -q '\<myword\>'; then 
    echo "MATCH"; 
else 
    echo "NO MATCH"; 
fi