Accessing last x characters of a string in Bash

Last three characters of string:

${string: -3}

or

${string:(-3)}

(mind the space between : and -3 in the first form).

Please refer to the Shell Parameter Expansion in the reference manual:

${parameter:offset}${parameter:offset:length}Expands to up to length characters of parameter starting at the characterspecified by offset. If length is omitted, expands to the substring of parameterstarting at the character specified by offset. length and offset are arithmeticexpressions (see Shell Arithmetic). This is referred to as Substring Expansion.If offset evaluates to a number less than zero, the value is used as an offsetfrom the end of the value of parameter. If length evaluates to a number less thanzero, and parameter is not ‘@’ and not an indexed or associative array, it isinterpreted as an offset from the end of the value of parameter rather than anumber of characters, and the expansion is the characters between the twooffsets. If parameter is ‘@’, the result is length positional parametersbeginning at offset. If parameter is an indexed array name subscripted by ‘@’ or‘*’, the result is the length members of the array beginning with${parameter[offset]}. A negative offset is taken relative to one greater than themaximum index of the specified array. Substring expansion applied to anassociative array produces undefined results.Note that a negative offset must be separated from the colon by at least onespace to avoid being confused with the ‘:-’ expansion. Substring indexing iszero-based unless the positional parameters are used, in which case the indexingstarts at 1 by default. If offset is 0, and the positional parameters are used,$@ is prefixed to the list.

Since this answer gets a few regular views, let me add a possibility to address John Rix's comment; as he mentions, if your string has length less than 3, ${string: -3} expands to the empty string. If, in this case, you want the expansion of string, you may use:

${string:${#string}<3?0:-3}

This uses the ?: ternary if operator, that may be used in Shell Arithmetic; since as documented, the offset is an arithmetic expression, this is valid.

Update for a POSIX-compliant solution

The previous part gives the best option when using Bash. If you want to target POSIX shells, here's an option (that doesn't use pipes or external tools like cut):

# New variable with 3 last characters removedprefix=${string%???}# The new string is obtained by removing the prefix a from stringnewstring=${string#"$prefix"}

One of the main things to observe here is the use of quoting for prefix inside the parameter expansion. This is mentioned in the POSIX ref (at the end of the section):

The following four varieties of parameter expansion provide for substring processing. In each case, pattern matching notation (see Pattern Matching Notation), rather than regular expression notation, shall be used to evaluate the patterns. If parameter is '#', '*', or '@', the result of the expansion is unspecified. If parameter is unset and set -u is in effect, the expansion shall fail. Enclosing the full parameter expansion string in double-quotes shall not cause the following four varieties of pattern characters to be quoted, whereas quoting characters within the braces shall have this effect. In each variety, if word is omitted, the empty pattern shall be used.

This is important if your string contains special characters. E.g. (in dash),

$ string="hello*ext"$ prefix=${string%???}$ # Without quotes (WRONG)$ echo "${string#$prefix}"*ext$ # With quotes (CORRECT)$ echo "${string#"$prefix"}"ext

Of course, this is usable only when then number of characters is known in advance, as you have to hardcode the number of ? in the parameter expansion; but when it's the case, it's a good portable solution.

You can use tail:

$ foo="1234567890"$ echo -n $foo | tail -c 3890

A somewhat roundabout way to get the last three characters would be to say:

echo $foo | rev | cut -c1-3 | rev

Another workaround is to use grep -o with a little regex magic to get three chars followed by the end of line:

$ foo=1234567890$ echo $foo | grep -o ...$890

To make it optionally get the 1 to 3 last chars, in case of strings with less than 3 chars, you can use egrep with this regex:

$ echo a | egrep -o '.{1,3}$'a$ echo ab | egrep -o '.{1,3}$'ab$ echo abc | egrep -o '.{1,3}$'abc$ echo abcd | egrep -o '.{1,3}$'bcd

You can also use different ranges, such as 5,10 to get the last five to ten chars.