I found out that with ${string:0:3} one can access the first 3 characters of a string. Is there a equivalently easy method to access the last three characters?
Add a comment |
7 Answers
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 character specified by offset. If length is omitted, expands to the substring of parameter starting at the character specified by offset. length and offset are arithmetic expressions (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 offset from the end of the value of parameter. If length evaluates to a number less than zero, and parameter is not ‘@’ and not an indexed or associative array, it is interpreted as an offset from the end of the value of parameter rather than a number of characters, and the expansion is the characters between the two offsets. If parameter is ‘@’, the result is length positional parameters beginning 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 the maximum index of the specified array. Substring expansion applied to an associative array produces undefined results. Note that a negative offset must be separated from the colon by at least one space to avoid being confused with the ‘:-’ expansion. Substring indexing is zero-based unless the positional parameters are used, in which case the indexing starts 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 removed prefix=${string%???} # The new string is obtained by removing the prefix a from string newstring=${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.
9 Comments
John Rix
Note that this doesn't work if your string is shorter than the negative offset you supply. You just get an empty string in such instances.
deppfx
@gniourf_gniourf How can use this along with command substitution ? I'm trying to extract the last three characters of my hostname
deppfx@localhost:/tmp$ echo ${$(hostname): -3} -bash: ${$(hostname): -3}: bad substitution
gniourf_gniourf
@deppfx: you can't in Bash. Use a temporary variable:
temp=$(hostname); echo "${temp: -3}". Bash also has the HOSTNAME variable (that may or may not differ from the output of hostname). If you want to use it, just do echo "${HOSTNAME: -3}".gniourf_gniourf
@MichaelHays: Just assign the output of your function:
string=$(some func) and then echo "${string: -3}".gniourf_gniourf
@КонстантинВан You can't do parameter expansion within parameter expansion (you can't nest them!). You have to use a temporary variable for that.
|
You can use tail:
$ foo="1234567890" $ echo -n $foo | tail -c 3 890 A somewhat roundabout way to get the last three characters would be to say:
echo $foo | rev | cut -c1-3 | rev 
4 Comments
vskubriev
The "tail" also useful in dash, when bash unavailable. E.g. upstart script section.
Ömer GÜZEL
I also found
tail useful however it is not useful when you wanted to print last 3 char at every line. I mean if you pipe the string from a file by cat
access_granted
tail: cannot open '3': No such file or directory <= Solaris
mcoolive
tail -c 3 counts three bytes, not three characters. It may be an issue if you manage an accented characters.1. Generalized Substring
To generalise the question and the answer of gniourf_gniourf (as this is what I was searching for), if you want to cut a range of characters from, say, 7th from the end to 3rd from the end, you can use this syntax:
${string: -7:4} Where 4 is the length of course (7-3).
2. Alternative using cut
In addition, while the solution of gniourf_gniourf is obviously the best, I just wanted to add an alternative solution using cut:
echo $string | cut -c $((${#string}-2))- Here, ${#string} is the length of the string, and the trailing "-" means cut to the end.
3. Alternative using awk
This solution instead uses the substring function of awk to select a substring which has the syntax substr(string, start, length) going to the end if the length is omitted. length($string)-2) thus picks up the last three characters.
echo $string | awk '{print substr($1,length($1)-2) }' 
2 Comments
michael
a variant not mentioned in the other answer is to combine this
cut approach of calculating the start/stop first and then just using these variables in the parameter expansion (also worth mentioning that cut and bash offsets start at 1 and zero, respectively, so this would need to be figured into the calculations, which I'm not doing here): start=$((${#string}-3)); stop=$((${#string})); and then echo ${string: $start : $stop} vs echo $string | cut -c "$start"-"$stop"michael
(oh, never mind -- I see that my comment doesn't address the problem of the string being too short, and then causing no output at all -- both the cut and string param expansion. Still, breaking it out into variables (without necessarily calling out to extra commands) makes it easier to read & would still be a good idea, I think.)
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 characters.
Comments
Guess the easiest way is:
$ str=123456789 $ echo ${str:(-3)} 789 Or you could do some math:
$ cnt=$((${#str}-3)) $ echo $cnt 6 $ echo ${str:cnt:3} 789 Here ^ ${#str} will give you the number of symbols in string and then it decreased by 3, so the final echo is like print 3 symbols starting from 6.
Comments
If you want to get the maximum last N characters of a string OR the entire string, if the string length does not exceed maximum N characters, then you can use:
str=1234567890 echo $(N=8 && [ ${#str} -gt ${N} ] && echo ${str:0-${N}} || echo ${str}) 34567890 echo $(N=20 && [ ${#str} -gt ${N} ] && echo ${str:0-${N}} || echo ${str}) 1234567890 
