La forma más corta de extraer los últimos 3 caracteres del nombre de archivo base (menos sufijo)

Estoy tratando de establecer una variable en un script sh para los últimos 3 caracteres del nombre base de un archivo (por nombre base quiero decir sin la ruta y sin el sufijo). He logrado hacer esto pero, por pura curiosidad, me pregunto si hay un comando único más corto que pueda usar. Originalmente tenía una sola línea awk, pero fue bastante larga. Actualmente tengo este script de dos líneas (suponiendo que haya un nombre de archivo completo $1):

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

Entonces, por ejemplo, "/path/to/somefile.txt" termina con "ile" en $lastpart.

¿Puedo combinar de alguna manera basenamey el bit para pelar el sufijo en un solo comando, y hay alguna forma de enviarlo tail(o algo más que pueda usar) sin usar una tubería? El sufijo es desconocido, por lo que no puedo basarlo como un parámetro basename.

El objetivo principal no es en realidad ser lo más corto posible, sino ser lo más legible posible de un vistazo. El contexto real de todo esto es esta pregunta en Superusuario , donde estoy tratando de encontrar una respuesta razonablemente simple.

Ese es un trabajo típico para expr:

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

Si sabe que sus nombres de archivo tienen el formato esperado (contiene uno y solo un punto y al menos 3 caracteres antes del punto), eso puede simplificarse para:

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

Tenga en cuenta que el estado de salida será distinto de cero si no hay coincidencia, pero también si la parte coincidente es un número que se resuelve en 0. (como para a000.txto a-00.txt)

Con zsh:

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

( :tpara cola (nombre base), :rpara descanso (con extensión eliminada)).

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

###OUTPUT###

456

Eso primero elimina los últimos tres caracteres y $varluego elimina $varlos resultados de esa eliminación, que devuelve los últimos tres caracteres de $var. Aquí hay algunos ejemplos más específicamente dirigidos a demostrar cómo puede hacer tal cosa:

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

No tiene que difundir todo esto a través de tantos comandos. Puedes compactar esto:

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

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

La combinación $IFScon setlos parámetros de shell ting también puede ser un medio muy eficaz de analizar y perforar a través de variables de shell:

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

Eso hará que sólo los tres caracteres inmediatamente anterior al primer período siguiente a la última /en $path. Si desea recuperar solo los primeros tres caracteres inmediatamente anteriores al último .en $path (por ejemplo, si existe la posibilidad de más de uno .en el nombre del archivo) :

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

En ambos casos puedes hacer:

newvar=$(IFS...)

Y...

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

... imprimirá lo que sigue al .

Si no le importa usar un programa externo, puede hacer lo siguiente:

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

Si existe la posibilidad de un \ncarácter ewline en el nombre del archivo (no aplicable para las soluciones de shell nativas, todos manejan eso de todos modos) :

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

Si puedes usar perl:

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

sed funciona para esto:

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

O

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

Si sedno es compatible -r, simplemente reemplace las instancias de ()con \(y \), y luego -rno es necesario.

Si perl está disponible, creo que puede ser más legible que otras soluciones, específicamente porque su lenguaje regex es más expresivo y tiene el /xmodificador, que permite escribir expresiones regulares más claras:

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

Esto no imprime nada si no existe dicha coincidencia (si el nombre base no tiene extensión o si la raíz antes de la extensión es demasiado corta). Dependiendo de sus requisitos, puede ajustar la expresión regular. Esta expresión regular impone las restricciones:

1. Coincide con los 3 caracteres antes de la extensión final (la parte posterior e incluyendo el último punto). Estos 3 caracteres pueden contener un punto.
2. La extensión puede estar vacía (excepto el punto).
3. La parte coincidente y la extensión deben ser parte del nombre base (la parte posterior a la última barra inclinada).

El uso de esto en una sustitución de comando tiene los problemas normales con la eliminación de demasiadas nuevas líneas finales, un problema que también afecta la respuesta de Stéphane. Se puede tratar en ambos casos, pero es un poco más fácil aquí:

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

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

Creo que esta función bash, pathStr (), hará lo que estás buscando.

No requiere awk, sed, grep, perl o expr. Utiliza solo bash builtins, por lo que es bastante rápido.

También he incluido las funciones dependientes argsNumber e isOption pero sus funcionalidades podrían incorporarse fácilmente en pathStr.

La función dependiente ifHelpShow no está incluida, ya que tiene numerosas subdependencias para generar el texto de ayuda en la línea de comandos del terminal o en un cuadro de diálogo de la GUI a través de YAD . El texto de ayuda que se le pasa se incluye para documentación. Indique si desea ifHelpShow y sus dependientes.

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
}

RECURSOS

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