3

I'm using awk '{ gsub(/BAR|WIBBLE/, "FOO"); print }' to replace text in data like:

SOMETHING [BAR, WIBBLE] SOMETHING [BAR]

This gives the desired result of:

SOMETHING [FOO, FOO] SOMETHING [FOO]

But now I've had to update the text that requires replacing to be something like:

awk '{ gsub(/BAR|WIBBLE|ME/, "FOO"); print }'

Which turns text like:

SOMETHING [ME, WIBBLE]

into:

SOFOOTHING [FOO, FOO]

How can I limit my replacement to just the text between the brackets (i.e. leave the SOMETHING alone)?

EDIT

I also need robustness across whatever text SOMETHING might be (e.g. SHE GAVE ME THAT shouldn't have ME replaced).

Improve this question

6 Answers 6

Reset to default
7

Must that be awk? Is much easier in other languages where the substitution's replacement part can be a function call. For example perl:

perl -pe 'sub c{$s=shift;$s=~s/\b(BAR|WIBBLE|ME)\b/FOO/g;$s}s/\[.*?\]/c$&/ge'

Or shorter, without using a sub:

perl -pe 's/\[.*?\]/$&=~s!\b(BAR|WIBBLE|ME)\b!FOO!gr/ge'

Try it online!

Improve this answer
5
  • Thanks! That did it. @choroba and @Guru word boundary would have been great too, but I want to be robust in what text the SOMETHING should be. I'll update the question to make that clearer. Commented Oct 24, 2012 at 16:30
  • Using @Thor 's example input, I get the input word SOMMER (inside brackets) converted to SOMFOOR. Commented Nov 1, 2024 at 19:01
  • 1
    You are right @jubilatious1, thank you. Seems I didn't revisited this question for long time, so also added an improved version. Commented Nov 2, 2024 at 1:12
  • I personally like using s{...}{...} when nesting them, I find it more legible but that may be just me: perl -pe 's{\[.*?\]}{$& =~ s{\b(BAR|WIBBLE|ME)\b}{FOO}gr}ge'. The x flag and breaking it down on several lines may also help for legibility. Commented Nov 2, 2024 at 8:04
  • (like this) Commented Nov 2, 2024 at 8:11
3

With GNU awk you can set RS to the contents of brackets and then do the replacement on RT (matched record separator):

awk -v RS='\\[[^]]*\\]' '{ gsub(/\<(BAR|WIBBLE|ME)\>/, "FOO", RT); printf "%s%s", $0, RT }' infile

infile:

cat << EOF > infile SHE GAVE ME THAT SOMETHING [ME, WIBBLE, SOMMER] EOF

output:

SHE GAVE ME THAT SOMETHING [FOO, FOO, SOMMER]
Improve this answer
0
2

Awk lacks backreferences in regular expression replacements, so it can't easily do replacements in context. Sed can do it:

sed -e 's/\(\[[^]]*\)BAR/\1FOO/' 's/\(\[[^]]*\)ME/\1FOO/'

If your sed supports alternations in regexps:

sed -e 's/\(\[[^]]*\)\(BAR\|ME\)/\1FOO/'

This only handles a single replacement inside each bracket pair, even with the g suffix, because [^]]* matches the longest close-bracket-free sequence. To replace all of them, use an explicit loop; note that this only works if FOO isn't a substring of BAR or ME.

sed -e ': a' -e 's/\(\[[^]]*\)BAR/\1FOO/' -e 't a' \ -e 's/\(\[[^]]*\)ME/\1FOO/' -e 't a'

If you need something more complicated, use perl.

Improve this answer
0

Using Raku (formerly known as Perl_6)

~$ raku -ne '.subst(:global:exhaustive, / "[" ~ "]" [ .*? <|w> <( [BAR|WIBBLE|ME] )> <|w> .*? ] /, "FOO").put;' file #OR: ~$ raku -ne 'BEGIN my @a = <BAR WIBBLE ME>; .subst(:global:exhaustive, / "[" ~ "]" [ .*? <|w> <(@a)> <|w> .*? ] /, "FOO" ).put;' file

Above is an answer written in Raku, a member of the Perl-family of programming languages:

  1. It uses Raku's ~ tilde construct for nested structures, in order to substitute to only those matches found within brackets.
  2. To match elements but then exclude a portion of the match(es) from the capture (i.e. the segment of the matches slated for alteration), use Raku's <( )> capture-markers.
  3. To essentially 'saturate' the substitutions, use the :exhaustive parameter.
  4. Raku's word-boundary zero-width atom is spelled <|w> or <?wb>. Alternatively, you can use << or « left word boundary, and >> or » right word boundary.

Sample Input:

SHE GAVE ME THAT SOMETHING [ME, WIBBLE, SOMMER] SHE GAVE ME THAT [SHE GAVE ME THAT]

Sample Output:

SHE GAVE ME THAT SOMETHING [FOO, FOO, SOMMER] SHE GAVE ME THAT [SHE GAVE FOO THAT]

See the first link below for making multiple different substitutions at once.

https://unix.stackexchange.com/a/767403/227738 https://docs.raku.org/language/regexes#Tilde_for_nesting_structures
https://docs.raku.org/language/regexes#Capture_markers:_%3C(_)%3E
https://raku.org

Improve this answer
0

Here is an unusual method that avoids long and cryptic regex expressions altogether - using basic tr and sed commands.

Let's say we want to change "this" to "THIS" and "that" to "THAT" only inside brackets in the following text file:

$ cat inbetween two brackets [that and this] middle [this and that] one bracket that and that middle [this and that] no brackets that and this middle this and that three brackets [that and this] middle 1 [this and that] middle 2 [this and that]

This chain of commands does the job:

$ <inbetween tr '\n' '#' | tr '][' '\n' | sed '2~2 {s/this/THIS/g;s/that/THAT/g}'| sed '2~2s/.*/[&]/' | tr -d '\n' | tr '#' '\n' two brackets [THAT and THIS] middle [THIS and THAT] one bracket that and that middle [THIS and THAT] no brackets that and this middle this and that three brackets [THAT and THIS] middle 1 [THIS and THAT] middle 2 [THIS and THAT]

Inversely, we can edit text outside brackets, leaving bracket contents intact. To do that we change 2~2 in the first sed above to 1~2 (address of odd numbered lines) :

$ <inbetween tr '\n' '#' | tr '][' '\n' | sed '1~2 {s/this/THIS/g;s/that/THAT/g}'| sed '2~2s/.*/[&]/' | tr -d '\n' | tr '#' '\n' two brackets [that and this] middle [this and that] one bracket THAT and THAT middle [this and that] no brackets THAT and THIS middle THIS and THAT three brackets [that and this] middle 1 [this and that] middle 2 [this and that]

Explanation:

  • first tr replaces linefeeds(\n) with # (or any character that does not appear in input file)
  • second tr breaks up the resulting string to lines at every ] or [
  • original bracket contents are now on even lines
  • first sed edits even lines with sed using 2~2 as address
  • second sed puts even lines back in brackets using s/.*/[&]/
  • reverse the actions of the original tr commands

This works for editing text inside/outside all paired symbols such as brackets and quotes.

Improve this answer
-3 
awk '{ gsub(/\bBAR\b|\bWIBBLE\b|\bME\b/, "FOO"); print }'
Improve this answer

You must log in to answer this question.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.