Shortest way to extract last 3 characters of base (minus suffix) filename

Question

I'm trying to set a variable in an sh script to the last 3 characters of the base name of a file (by base name I mean without the path and without the suffix). I've succeeded in doing this but, purely out of curiosity, I'm wondering if there is a shorter, single command I can use. Originally I had a one-liner with awk, but it was rather long. Currently I have this two-line script (assuming a complete filename is in $1):

filebase=`basename "$1"`
lastpart=`echo -n ${filebase%.*} | tail -c3`

So for example, "/path/to/somefile.txt" ends up with "ile" in $lastpart.

Can I somehow combine basename and the bit to strip the suffix into a single command, and is there a way to send it to tail (or something else I can use) without using a pipe? The suffix is unknown so I can't base it as a parameter to basename.

The main goal isn't actually so much to be as short as possible, as to be as readable at a glance as possible. The actual context of all of this is this question on Superuser, where I'm trying to come up with a reasonably simple answer.

Answer 1

var=123456
echo "${var#"${var%???}"}"

###OUTPUT###

456

That first removes the last three characters from $var then removes from $var the results of that removal - which returns the last three characters of $var. Here are some examples more specifically aimed at demonstrating how you might do such a thing:

touch file.txt
path=${PWD}/file.txt
echo "$path"

/tmp/file.txt

base=${path##*/}
exten=${base#"${base%???}"}
base=${base%."$exten"}
{ 
    echo "$base" 
    echo "$exten" 
    echo "${base}.${exten}" 
    echo "$path"
}

file
txt
file.txt
/tmp/file.txt

You don't have to spread this all out through so many commands. You can compact this:

{
    base=${path##*/} exten= 
    printf %s\\n "${base%.*}" "${exten:=${base#"${base%???}"}}" "$base" "$path"
    echo "$exten"
}

file 
txt 
file.txt 
/tmp/file.txt
txt

Combining $IFS with setting shell parameters can also be a very effective means of parsing and drilling through shell variables:

(IFS=. ; set -f; set -- ${path##*/}; printf %s "${1#"${1%???}"}")

That will get you only the three characters immediately preceding the first period following the last / in $path. If you want to retrieve only the first three characters immediately preceding the last . in $path (for instance, if there is a possibility of more than one . in filename):

(IFS=.; set -f; set -- ${path##*/}; ${3+shift $(($#-2))}; printf %s "${1#"${1%???}"}")

In both cases you can do:

newvar=$(IFS...)

And...

(IFS...;printf %s "$2")

...will print what follows the .

If you don't mind using an external program you can do:

printf %s "${path##*/}" | sed 's/.*\(...\)\..*/\1/'

If there is a chance of a \newline character in the filename (not applicable for the native shell solutions - they all handle that anyway):

printf %s "${path##*/}" | sed 'H;$!d;g;s/.*\(...\)\..*/\1/'

Answer 2

That's a typical job for expr:

$ file=/path/to/abcdef.txt
$ expr "/$file" : '.*\([^/.]\{3\}\)\.[^/.]*$'
def

If you know your file names have the expected format (contains one and only one dot and at least 3 characters before the dot), that can be simplified to:

expr "/$file" : '.*\(.\{3\}\)\.'

Note that the exit status will be non-zero if there's no match, but also if the matched part is a number that resolves to 0. (like for a000.txt or a-00.txt)

With zsh:

file=/path/to/abcdef.txt
lastpart=${${file:t:r}[-3,-1]}

(:t for tail (basename), :r for rest (with extension removed)).

Answer 3

If you can use perl:

lastpart=$(
    perl -e 'print substr((split(/\.[^.]*$/,shift))[0], -3, 3)
            ' -- "$(basename -- "$1")"
)

Answer 4

sed works for this:

[user@host ~]$ echo one.two.txt | sed -r 's|(.*)\..*$|\1|;s|.*(...)$|\1|'
two

Or

[user@host ~]$ sed -r 's|(.*)\..*$|\1|;s|.*(...)$|\1|' <<<one.two.txt
two

If your sed doesn't support -r, just replace the instances of () with \( and \), and then -r isn't needed.

Answer 5

If perl is available, I find it can be more readable than other solutions, specifically because its regex language is more expressive and it has the /x modifier, which allows for writing clearer regexs:

perl -e 'print $1 if shift =~ m{ ( [^/]{3} ) [.] [^./]* \z }x' -- "$file"

This prints nothing if there is no such match (if the basename has no extension or if the root before the extension is too short). Depending on your requirements, you can adjust the regex. This regex enforces the constraints:

1. It matches the 3 characters before the final extension (the part after and including the last dot). These 3 characters can contain a dot.
2. The extension can be empty (except for the dot).
3. The matched part and the extension must be part of the basename (the part after the last slash).

Using this in a command substitution has the normal issues with removing too many trailing newlines, a problem which also affects Stéphane's answer. It can be dealt with in both cases, but is a little easier here:

lastpart=$(
  perl -e 'print "$1x" if shift =~ m{ ( [^/]{3} ) [.] [^./]* \z }x' -- "$file"
)
lastpart=${lastpart%x}  # allow for possible trailing newline

Answer 6

Python2.7

$ echo /path/to/somefile.txt | python -c "import sys, os; print '.'.join(os.path.basename(sys.stdin.read()).split('.')[:-1])[-3:]"
ile

$ echo file.one.two.three | python -c "import sys, os; print '.'.join(os.path.basename(sys.stdin.read()).split('.')[:-1])[-3:]"
two

Answer 7

I think this bash function, pathStr(), will do what you are looking for.

It doesn't require awk, sed, grep, perl or expr. It uses only bash builtins so it's quite fast.

I've also included the dependent argsNumber and isOption functions but their functionalities could be easily incorporated into pathStr.

The dependent function ifHelpShow is not included as it has numerous subdependencies for outputting the help text either on the terminal commandline or to a GUI dialog box via YAD. The help text passed to it is included for documentation. Advise if you would like ifHelpShow and its dependents.

function  pathStr () {
  ifHelpShow "$1" 'pathStr --OPTION FILENAME
    Given FILENAME, pathStr echos the segment chosen by --OPTION of the
    "absolute-logical" pathname. Only one segment can be retrieved at a time and
    only the FILENAME string is parsed. The filesystem is never accessed, except
    to get the current directory in order to build an absolute path from a relative
    path. Thus, this function may be used on a FILENAME that does not yet exist.
    Path characteristics:
        File paths are "absolute" or "relative", and "logical" or "physical".
        If current directory is "/root", then for "bashtool" in the "sbin" subdirectory ...
            Absolute path:  /root/sbin/bashtool
            Relative path:  sbin/bashtool
        If "/root/sbin" is a symlink to "/initrd/mnt/dev_save/share/sbin", then ...
            Logical  path:  /root/sbin/bashtool
            Physical path:  /initrd/mnt/dev_save/share/sbin/bashtool
                (aka: the "canonical" path)
    Options:
        --path  Absolute-logical path including filename with extension(s)
                  ~/sbin/file.name.ext:     /root/sbin/file.name.ext
        --dir   Absolute-logical path of directory containing FILENAME (which can be a directory).
                  ~/sbin/file.name.ext:     /root/sbin
        --file  Filename only, including extension(s).
                  ~/sbin/file.name.ext:     file.name.ext
        --base  Filename only, up to last dot(.).
                  ~/sbin/file.name.ext:     file.name
        --ext   Filename after last dot(.).
                  ~/sbin/file.name.ext:     ext
    Todo:
        Optimize by using a regex to match --options so getting argument only done once.
    Revised:
        20131231  docsalvage'  && return
  #
  local _option="$1"
  local _optarg="$2"
  local _cwd="$(pwd)"
  local _fullpath=
  local _tmp1=
  local _tmp2=
  #
  # validate there are 2 args and first is an --option
  [[ $(argsNumber "$@") != 2 ]]                        && return 1
  ! isOption "$@"                                      && return 1
  #
  # determine full path of _optarg given
  if [[ ${_optarg:0:1} == "/" ]]
  then
    _fullpath="$_optarg"
  else
    _fullpath="$_cwd/$_optarg"
  fi
  #
  case "$_option" in
   --path)  echo "$_fullpath"                            ; return 0;;
    --dir)  echo "${_fullpath%/*}"                       ; return 0;;
   --file)  echo "${_fullpath##*/}"                      ; return 0;;
   --base)  _tmp1="${_fullpath##*/}"; echo "${_tmp1%.*}" ; return 0;;
    --ext)  _tmp1="${_fullpath##*/}";
            _tmp2="${_tmp1##*.}";
            [[ "$_tmp2" != "$_tmp1" ]]  && { echo "$_tmp2"; }
            return 0;;
  esac
  return 1
}

function argsNumber () {
  ifHelpShow "$1" 'argsNumber "$@"
  Echos number of arguments.
  Wrapper for "$#" or "${#@}" which are equivalent.
  Verified by testing on bash 4.1.0(1):
      20140627 docsalvage
  Replaces:
      argsCount
  Revised:
      20140627 docsalvage'  && return
  #
  echo "$#"
  return 0
}

function isOption () {
  # isOption "$@"
  # Return true (0) if argument has 1 or more leading hyphens.
  # Example:
  #     isOption "$@"  && ...
  # Note:
  #   Cannot use ifHelpShow() here since cannot distinguish 'isOption --help'
  #   from 'isOption "$@"' where first argument in "$@" is '--help'
  # Revised:
  #     20140117 docsalvage
  # 
  # support both short and long options
  [[ "${1:0:1}" == "-" ]]  && return 0
  return 1
}

RESOURCES

• http://tldp.org/LDP/abs/html/arrays.html
• https://stackoverflow.com/questions/23207168/a-semantics-for-bash-scripts/23208014#23208014