can we print the last word of each line in linux using sed command?

Question

suppose , if there is a file consisting of following lines , if they are

12345 567 7878 66

   er3   t45t y6y46y 


 4y6 y656y y5y

   46y6 65y7 y66uyuy

 yy46y6y

The output has to look like:

66

y6y46y

y5y

y66uyuyy

y46y6y

I have tried the command sed 's/.* //g' filename and several other sed commands, but it is not working.

Can I know what is the exact sed command?

Answer 1

You can try :

• sed 's/.* //'
• awk '{print $NF}'

If your file has lines ending with whitespaces, you can remove said trailing whitespaces beforehand with sed 's/ +$//'. Both actions can be combined in the one-liner:

• sed -e 's/ +$//' -e 's/.* //'

Answer 2

awk '{print $NF}'
sed 's/[[:blank:]]*$//;s/.*[[:blank:]]//'

That would still print an empty line for every blank line (the whole line with awk as the $ operator would be applied to 0 which would yield the full record). To avoid it:

awk 'NF{print $NF}'
sed 's/[[:blank:]]*$//;s/.*[[:blank:]]//;/./!d'

Answer 3

The awk variable $NF is the last field of every record; you can use it to print only the last fields of your file like so:

awk '{print $NF}' file

Answer 4

You're almost there. Just specify the last word:

sed 's/^.* \([^ ][^ ]*\)/\1/g'

What it does:

1. '^.* ' deletes everything within the start of the line and any spaces.
2. '\(...)\' matches a pattern and returns it as \1.
3. '[^ ]' matches anything without a space in it.

(Edited to add better solution. Thanks Hildred!)

Answer 5

You could use some adequate pattern of grep instead of sed, for instance:

grep -o "[a-Z0-9]*$"

In this example, the [...] contains ranges of characters considered appropriate for a "word" (alphanumerics in this case, other symbols could be added, some of which must be escaped).

Answer 6

If you qualify word to mean any sequence of 1 or more non-blank characters then the answer is definitely yes, and it is very simply done as well. This is because [[:blank:]]* and [^[:blank:]]* are boolean complements and - provided all characters in a string are complete - [[:blank:]]*U[^[:blank:]]* can describe any possible string in much the same way .* does.

If an incomplete character or otherwise invalid byte sequence exists within a string neither can successfully describe it head to tail - as can sometimes occur when interpreting a string in the wrong encoding. To ensure a complete character per byte in any string, the C locale can be forced like:

LC_ALL=C sed ...

...which would avoid any issues describing the string from head to tail with an all-inclusive pattern such as .* or ([ ]*[^ ]*)*

A fully complementary pattern can repeat as many times as is necessary from left to right the length of any string to land on the last possible occurrence without any break in the pattern. This is, definitively, regular language.

BRE:

sed 's/\(\([^[:blank:]]*\)[[:blank:]]*\)*/\2/'

ERE:

sed -E 's/(([^[:blank:]]*)[[:blank:]]*)*/\2/'

Both of these versions will still print blank lines, and this is because the Kleene * star matches zero or more occurrences of a pattern. It first matches zero or more not blank characters, then zero or more blank characters, then zero or more occurrences of the grouped matches until it has matched the string in its entirety.

Having matched all of this, the magic happens in the replacement - the references returned by groups \1 and \2 are the last occurrences of each. So when the replacement is made all of the string is replaced with only the last occurrence on a line of zero or more not blank characters - or the subgroup \2.

Of course this works for any possible string - even an empty one - which means both forms will print newline characters for lines which contain only blank characters or none at all. To handle this there are a couple things you can do, but first let's make the character class a little easier to type:

b='[:blank:]'

Now, to print only if a line contains one or more not blank characters you can do:

BRE:

sed -n "s/\(\([^$b]*\)[$b]*\)*/\2/;/./p"

ERE:

sed -En "/[^$b]/s/(([^$b]*)[$b]*)*/\2/p"

1. BRE case - the substitution is always performed and only pattern spaces with at least one remaining character are printed.
2. ERE case - the substitution is only ever attempted on a pattern space containing at least one not blank char.

Either form will work with either method - as long as the syntax is correct.

The -n switch disables auto-printing of pattern space, and the p flag to the s///ubstitution or the /address/ commands prints its results only if successful.

This same logic can be applied to get any {num}th occurrence, as well, like:

BRE:

sed -n "s/\([$b]*\([^$b]\{1,\}\)\)\{num\}.*/\2/p"

ERE:

sed -En "s/([$b]*([^$b]+)){num}.*/\2/p"

...where the num in both regexps can be replaced with a number to print only the {num}th specified occurrence of a sequence of not blank characters. A slightly different form is used here to ensure the count is not skewed for leading space in a string.

Note that the -E ERE switch to sed is supported in both BSD and GNU versions, though it is not yet POSIX standard syntax.

Answer 7

sed 's/^ star.star //'  filename  or sed 's/^[[:blank:]]star.star[[:blank:]]//' filename

Analysis:

• s -- substitute

• / --beginning of expression to look for

• ^ -- from the beginning of the line

• [[:blank:]]* -- if there are blanks at the beginning of line in case

• .* -- any character

• [[:blank:]] -- and a blank character

• / -- beginning of expression to substitute

• / -- end of the command syntax

PS: i have written star in the commannd.

Answer 8

Using Raku (formerly known as Perl_6)

raku -ne 'put .words[*-1] // "" ;'

OR

raku -ne 'put .words.tail // "" ;'

Briefly, Raku's -ne non-autoprinting linewise flags are used. Input text is broken into whitespace-separated words (The leading . dot on .words means input couples to the $_ topic variable, by default).

Each line's last word is taken using either an index ([*-1]) or the tail command. Finally, because lines could be entirely blank, Raku's // "defined-OR" operator is used to return a "" empty string, preserving the original linespacing. Note, instead of "" empty string Raku also accepts () or the keyword Empty here, both signifying an empty list.

Sample Input:

12345 567 7878 66

   er3   t45t y6y46y 


 4y6 y656y y5y

   46y6 65y7 y66uyuy

 yy46y6y

Sample Output:

66

y6y46y


y5y

y66uyuy

yy46y6y

For persons preferring a regex approach, any one of the following four one-liners works. The first two leave trailing whitespace intact, while the latter two trim trailing whitespace:

raku -ne 'S/^ <(.* \s)> \S+? \s* $//.put;'  
#OR
raku -pe 's/^ <(.* \s)> \S+? \s* $//;' 

#OR

raku -ne 'S/^ .* \s (\S+?) \s* $/$0/.put;'
#OR
raku -pe 's/^ .* \s (\S+?) \s* $/$0/;' 

---

Finally, if the desired output is one with truly blank lines removed (retaining lines with the desired last word, and/or lines with whitespace characters only), that's straight-forward as well:

~$ raku -ne 'if .chars {put .words.tail // ""};' file
66
y6y46y
y5y
y66uyuy
yy46y6y

#OR

~$ raku -ne 'put .words.tail // "" if .chars;' file
66
y6y46y
y5y
y66uyuy
yy46y6y

https://raku.org

Answer 9

Yes. The following sed command first removes all trailing whitespaces (s/ *$//) and then everything up to and including the last whitespace (s/.* //). It is probably worthwhile replacing literal whitespace with [[:blank:]] in order to capture tabs and other space-like characters.

$ echo "  aaa bbb cc   " | sed -e 's/ *$//' -e 's/.* //'
cc
$ echo "  aaa bbb cc" | sed -e 's/ *$//' -e 's/.* //'
cc
$ echo "aaa bbb cc   " | sed -e 's/ *$//' -e 's/.* //'
cc
$ echo "aaa bbb cc" | sed -e 's/ *$//' -e 's/.* //'
cc
$ echo "  cc  " | sed -e 's/ *$//' -e 's/.* //'
cc
$ echo "cc" | sed -e 's/ *$//' -e 's/.* //'
cc

Answer 10

cat file_name | rev | cut -f1 -d ' ' | rev

Answer 11

Old thread but anyway, here's my 2 cents:

echo "This is a journey into South " |xargs|sed 's/.* //'
South

So: run through xargs to get rid of the trailing spaces (if any). Then remove everything up to and including the last space.

If you also want to ignore empty lines (not asked but your example suggests it), then add a delete of empty lines:

sed -e 's/.* //' -e '/^$/d'