mjhjmtu

With bash 4.2 and above, you can do:

$var::-1

Example:

$ a=123
$ echo "$a::-1"
12

Notice that for older bash ( for example, bash 3.2.5 on OS X), you should leave spaces between and after colons:

$var: : -1

for removing the last n characters from a line that makes no use of sed OR awk:

> echo lkj | rev | cut -c (n+1)- | rev

so for example you can delete the last character one character using this:

> echo lkj | rev | cut -c 2- | rev

> lk

from rev manpage:

DESCRIPTION

The rev utility copies the specified files to the standard output,
reversing the order of characters in every line. If no files are speci-
fied, the standard input is read.

UPDATE:

if you don't know the length of the string, try:

$ x="lkj"
$ echo "$x%?"
lk

Using sed it should be as fast as

sed 's/.$//'

Your single echo is then echo ljk | sed 's/.$//'.

Using this, the 1-line string could be any size.

A few options depending on the shell:

• POSIX: t=$t%?
  


• Bourne: t=`expr " $t" : ' (.*).'`
  


• zsh/yash: t=$t[1,-2]
  


• bash/zsh: t=$t:0:-1
  


• ksh93/bash/zsh/mksh: t=$t:0:$#t-1
  


• ksh93/bash/zsh/mksh: t=$t/%?
  


• ksh93: t=$t/~(E).$/
  


• es: @ t=$1 ~~ $t *?
  

Note that while all are supposed to strip the last character, you'll find that some implementations (those that don't support multi-byte characters) strip the last byte instead (so would likely corrupt the last character if it was multi-byte).

The expr variant assumes $t doesn't end in more than one newline character. It will also return a non-zero exit status if the resulting string ends up being 0 (or 000 or even -0 with some implementations). It could also give unexpected results if the string contains invalid characters.

t=lkj
echo $t:0:$#t-1

You get a substring from 0 to the string length -1. Note however that this substraction is bash specific, and won't work on other shells.

For instance, dash isn't able to parse even

echo $t:0:$(expr $#t - 1)

For example, on Ubuntu, /bin/sh is dash

The most portable, and shortest, answer is almost certainly:

$t%?

This works in bash, sh, ash, dash, busybox/ash, zsh, ksh, etc.

It works by using old-school shell parameter expansion. Specifically, the % specifies to remove the smallest matching suffix of parameter t that matches the glob pattern ? (ie: any character).

See "Remove Smallest Suffix Pattern" here for a (much) more detailed explanation and more background. Also see the docs for your shell (eg: man bash) under "parameter expansion".

As a side note, if you wanted to remove the first character instead, you would use $t#?, since # matches from the front of the string (prefix) instead of the back (suffix).

Also worth noting is that both % and # have %% and ## versions, which match the longest version of the given pattern instead of the shortest. Both $t%%? and $t##? would do the same as their single operator in this case, though (so don't add the useless extra character). This is because the given ? pattern only matches a single character. Mix in a * with some non-wildcards and things get more interesting with %% and ##.

Understanding parameter expansions, or at least knowing about their existence and knowing how to look them up, is incredibly useful for writing and deciphering shell scripts of many flavors. Parameter expansions often look like arcane shell voodoo to many people because... well... they are arcane shell voodoo (although pretty well documented if you know to look for "parameter expansion"). Definitely good to have in the tool belt when you're stuck in a shell, though.

You can also use head to print out all but the last character.

$ s='i am a string'
$ news=$(echo -n $s | head -c -1)
$ echo $news
i am a strin

But unfortunately some versions of head do not include the leading - option. This is the case for the head that comes with OS X.

Thank you SteelDriver and Networker!

if you don't know the length of the string, try:

$ x="lkj"
$ echo "$x%?"
lk

It is easy enough to do using regular expression:

n=2
echo "lkj" | sed "s/(.*).$n/1/"

Some refinements. To remove more than one character, you can add multiple question marks. For example, to remove the last two characters from the variable: $SRC_IP_MSG, you can use:

SRC_IP_MSG=$SRC_IP_MSG%??

Just to complete some possible usages of pure bash:

#!/bin/bash

# Testing substring removal
STR="Exemple string with trailing whitespace "
echo "'$STR'"
echo "Removed trailing whitespace: '$STR:0:$#STR-1'"
echo "Removed trailing whitespace: '$STR/% /'"

The first syntax takes a substring from a string, the syntax is
$STRING:OFFSET:LENGTH

For the second one, do notice the % sign, which means 'from end of line' and the syntax is
$STRING/PATTERN/SUBSTITUTION

And here are two shorter forms of the above mentioned

echo "Removed trailing whitespace: '$STR::-1'"
echo "Removed trailing whitespace: '$STR% '"

Here notice again the % sign, meaning 'Remove ( that is, replace with '' ) the shortest matched pattern (here represented by escaped space ' ' from the end of the PARAMETER - here named STR

As we can also use php in command line, or shell scripts.
It is sometimes useful for surgical parsing.

php -r "echo substr('Hello', 0, -1);" 
// Output hell

With piping:

echo "hello" | php -r "echo substr(trim(fgets(STDIN)), 0, -1);"
// Output hell

In ksh:

echo $ORACLE_SID/%?/