Quiero obtener el nombre de archivo (sin extensión) y la extensión por separado.

La mejor solución que encontré hasta ahora es:

NAME=`echo "$FILE" | cut -d'.' -f1`
EXTENSION=`echo "$FILE" | cut -d'.' -f2`

Esto está mal porque no funciona si el nombre del archivo contiene varios .caracteres. Si, digamos, tengo a.b.js, considerará ay b.js, en lugar de a.by js.

Se puede hacer fácilmente en Python con

file, ext = os.path.splitext(path)

pero preferiría no encender un intérprete de Python solo por esto, si es posible.

¿Alguna idea mejor?

Primero, obtenga el nombre del archivo sin la ruta:

filename=$(basename -- "$fullfile")
extension="${filename##*.}"
filename="${filename%.*}"

Alternativamente, puede centrarse en el último '/' de la ruta en lugar del '.' que debería funcionar incluso si tiene extensiones de archivo impredecibles:

filename="${fullfile##*/}"

Es posible que desee consultar la documentación:

• En la web en la sección " 3.5.3 Expansión del parámetro Shell "
• En la página de manual de bash en la sección llamada "Expansión de parámetros"

~% FILE="example.tar.gz"

~% echo "${FILE%%.*}"
example

~% echo "${FILE%.*}"
example.tar

~% echo "${FILE#*.}"
tar.gz

~% echo "${FILE##*.}"
gz

Para obtener más detalles, consulte la expansión de parámetros de shell en el manual de Bash.

Por lo general, ya conoce la extensión, por lo que es posible que desee utilizar:

basename filename .extension

por ejemplo:

basename /path/to/dir/filename.txt .txt

y obtenemos

filename

Puede usar la magia de la expansión de parámetros POSIX:

bash-3.2$ FILENAME=somefile.tar.gz
bash-3.2$ echo "${FILENAME%%.*}"
somefile
bash-3.2$ echo "${FILENAME%.*}"
somefile.tar

Hay una advertencia de que si su nombre era de la forma ./somefile.tar.gza continuación, echo ${FILENAME%%.*}eliminaría con avidez el partido más largo de la .y que tendría la cadena vacía.

(Puede solucionar eso con una variable temporal:

FULL_FILENAME=$FILENAME
FILENAME=${FULL_FILENAME##*/}
echo ${FILENAME%%.*}

)

Este sitio explica más.

${variable%pattern}
  Trim the shortest match from the end
${variable##pattern}
  Trim the longest match from the beginning
${variable%%pattern}
  Trim the longest match from the end
${variable#pattern}
  Trim the shortest match from the beginning

Eso no parece funcionar si el archivo no tiene extensión o no tiene nombre de archivo. Esto es lo que estoy usando; solo usa builtins y maneja más (pero no todos) nombres de archivos patológicos.

#!/bin/bash
for fullpath in "$@"
do
    filename="${fullpath##*/}"                      # Strip longest match of */ from start
    dir="${fullpath:0:${#fullpath} - ${#filename}}" # Substring from 0 thru pos of filename
    base="${filename%.[^.]*}"                       # Strip shortest match of . plus at least one non-dot char from end
    ext="${filename:${#base} + 1}"                  # Substring from len of base thru end
    if [[ -z "$base" && -n "$ext" ]]; then          # If we have an extension and no base, it's really the base
        base=".$ext"
        ext=""
    fi

    echo -e "$fullpath:\n\tdir  = \"$dir\"\n\tbase = \"$base\"\n\text  = \"$ext\""
done

Y aquí hay algunos casos de prueba:

$ basename-and-extension.sh / / home / me / / home / me / file /home/me/file.tar /home/me/file.tar.gz /home/me/.hidden / home / me / .hidden.tar / home / me / ...
/:
    dir = "/"
    base = ""
    ext = ""
/casa/:
    dir = "/ inicio / yo /"
    base = ""
    ext = ""
/ home / me / file:
    dir = "/ inicio / yo /"
    base = "archivo"
    ext = ""
/home/me/file.tar:
    dir = "/ inicio / yo /"
    base = "archivo"
    ext = "alquitrán"
/home/me/file.tar.gz:
    dir = "/ inicio / yo /"
    base = "file.tar"
    ext = "gz"
/home/me/.hidden:
    dir = "/ inicio / yo /"
    base = ".hidden"
    ext = ""
/home/me/.hidden.tar:
    dir = "/ inicio / yo /"
    base = ".hidden"
    ext = "alquitrán"
/casa/..:
    dir = "/ inicio / yo /"
    base = ".."
    ext = ""
.:
    dir = ""
    base = "."
    ext = ""

Puedes usar basename.

Ejemplo:

$ basename foo-bar.tar.gz .tar.gz
foo-bar

Debe proporcionar el nombre base con la extensión que se eliminará, sin embargo, si siempre está ejecutando tarcon, -zentonces sabe que la extensión será .tar.gz.

Esto debería hacer lo que quieras:

tar -zxvf $1
cd $(basename $1 .tar.gz)

pax> echo a.b.js | sed 's/\.[^.]*$//'
a.b
pax> echo a.b.js | sed 's/^.*\.//'
js

funciona bien, así que puedes usar:

pax> FILE=a.b.js
pax> NAME=$(echo "$FILE" | sed 's/\.[^.]*$//')
pax> EXTENSION=$(echo "$FILE" | sed 's/^.*\.//')
pax> echo $NAME
a.b
pax> echo $EXTENSION
js

Los comandos, por cierto, funcionan de la siguiente manera.

El comando para NAMEsustituye un "."carácter seguido de cualquier número de no "."caracteres hasta el final de la línea, sin nada (es decir, elimina todo desde el final "."hasta el final de la línea, inclusive). Esto es básicamente una sustitución no codiciosa que usa trucos regex.

El comando para EXTENSIONsustituye cualquier número de caracteres seguido de un "."carácter al comienzo de la línea, sin nada (es decir, elimina todo desde el inicio de la línea hasta el punto final, inclusive). Esta es una sustitución codiciosa, que es la acción predeterminada.

Mellen escribe en un comentario en una publicación de blog:

Usando Bash, también hay ${file%.*}que obtener el nombre de archivo sin la extensión y ${file##*.}obtener solo la extensión. Es decir,

file="thisfile.txt"
echo "filename: ${file%.*}"
echo "extension: ${file##*.}"

Salidas:

filename: thisfile
extension: txt

No hay necesidad de molestarse con awko sedo incluso perlpara esta tarea simple. Hay un puro Bash,os.path.splitext() solución compatible con que solo utiliza expansiones de parámetros.

Implementación de referencia

Documentación de os.path.splitext(path):

Dividir la ruta de nombre de ruta en un par (root, ext)de tal manera que root + ext == path, y ext está vacío o comienza con un período y contiene como máximo un periodo. Los períodos iniciales en el nombre base se ignoran; splitext('.cshrc')vuelve ('.cshrc', '').

Código de Python:

root, ext = os.path.splitext(path)

Implementación de Bash

Honrando los períodos principales

root="${path%.*}"
ext="${path#"$root"}"

Ignorando los períodos principales

root="${path#.}";root="${path%"$root"}${root%.*}"
ext="${path#"$root"}"

Pruebas

Aquí hay casos de prueba para la implementación de ignorar los períodos iniciales, que deben coincidir con la implementación de referencia de Python en cada entrada.

|---------------|-----------|-------|
|path           |root       |ext    |
|---------------|-----------|-------|
|' .txt'        |' '        |'.txt' |
|' .txt.txt'    |' .txt'    |'.txt' |
|' txt'         |' txt'     |''     |
|'*.txt.txt'    |'*.txt'    |'.txt' |
|'.cshrc'       |'.cshrc'   |''     |
|'.txt'         |'.txt'     |''     |
|'?.txt.txt'    |'?.txt'    |'.txt' |
|'\n.txt.txt'   |'\n.txt'   |'.txt' |
|'\t.txt.txt'   |'\t.txt'   |'.txt' |
|'a b.txt.txt'  |'a b.txt'  |'.txt' |
|'a*b.txt.txt'  |'a*b.txt'  |'.txt' |
|'a?b.txt.txt'  |'a?b.txt'  |'.txt' |
|'a\nb.txt.txt' |'a\nb.txt' |'.txt' |
|'a\tb.txt.txt' |'a\tb.txt' |'.txt' |
|'txt'          |'txt'      |''     |
|'txt.pdf'      |'txt'      |'.pdf' |
|'txt.tar.gz'   |'txt.tar'  |'.gz'  |
|'txt.txt'      |'txt'      |'.txt' |
|---------------|-----------|-------|

Resultados de la prueba

Todas las pruebas pasaron.

Puede usar el cutcomando para eliminar las dos últimas extensiones (la ".tar.gz"parte):

$ echo "foo.tar.gz" | cut -d'.' --complement -f2-
foo

Como señaló Clayton Hughes en un comentario, esto no funcionará para el ejemplo real en la pregunta. Entonces, como alternativa, propongo usar sedexpresiones regulares extendidas, como esta:

$ echo "mpc-1.0.1.tar.gz" | sed -r 's/\.[[:alnum:]]+\.[[:alnum:]]+$//'
mpc-1.0.1

Funciona eliminando las dos últimas extensiones (alfanuméricas) incondicionalmente.

[Actualizado nuevamente después del comentario de Anders Lindahl]

Aquí hay algunas sugerencias alternativas (principalmente en awk), incluidos algunos casos de uso avanzados, como extraer números de versión para paquetes de software.

f='/path/to/complex/file.1.0.1.tar.gz'

# Filename : 'file.1.0.x.tar.gz'
    echo "$f" | awk -F'/' '{print $NF}'

# Extension (last): 'gz'
    echo "$f" | awk -F'[.]' '{print $NF}'

# Extension (all) : '1.0.1.tar.gz'
    echo "$f" | awk '{sub(/[^.]*[.]/, "", $0)} 1'

# Extension (last-2): 'tar.gz'
    echo "$f" | awk -F'[.]' '{print $(NF-1)"."$NF}'

# Basename : 'file'
    echo "$f" | awk '{gsub(/.*[/]|[.].*/, "", $0)} 1'

# Basename-extended : 'file.1.0.1.tar'
    echo "$f" | awk '{gsub(/.*[/]|[.]{1}[^.]+$/, "", $0)} 1'

# Path : '/path/to/complex/'
    echo "$f" | awk '{match($0, /.*[/]/, a); print a[0]}'
    # or 
    echo "$f" | grep -Eo '.*[/]'

# Folder (containing the file) : 'complex'
    echo "$f" | awk -F'/' '{$1=""; print $(NF-1)}'

# Version : '1.0.1'
    # Defined as 'number.number' or 'number.number.number'
    echo "$f" | grep -Eo '[0-9]+[.]+[0-9]+[.]?[0-9]?'

    # Version - major : '1'
    echo "$f" | grep -Eo '[0-9]+[.]+[0-9]+[.]?[0-9]?' | cut -d. -f1

    # Version - minor : '0'
    echo "$f" | grep -Eo '[0-9]+[.]+[0-9]+[.]?[0-9]?' | cut -d. -f2

    # Version - patch : '1'
    echo "$f" | grep -Eo '[0-9]+[.]+[0-9]+[.]?[0-9]?' | cut -d. -f3

# All Components : "path to complex file 1 0 1 tar gz"
    echo "$f" | awk -F'[/.]' '{$1=""; print $0}'

# Is absolute : True (exit-code : 0)
    # Return true if it is an absolute path (starting with '/' or '~/'
    echo "$f" | grep -q '^[/]\|^~/'

Todos los casos de uso utilizan la ruta completa original como entrada, sin depender de resultados intermedios.

La respuesta aceptada funciona bien en típicos casos , pero no en los bordes de los casos , a saber:

• Para nombres de archivo sin extensión (llamado sufijo en el resto de esta respuesta), extension=${filename##*.}devuelve el nombre de archivo de entrada en lugar de una cadena vacía.
• extension=${filename##*.}no incluye la inicial ., contrario a la convención.
  • Pretender a ciegas .no funcionaría para nombres de archivo sin sufijo.
• filename="${filename%.*}"será la cadena vacía, si el nombre del archivo de entrada comienza con .y no contiene más .caracteres (p. ej. .bash_profile), contrario a la convención.

---------

Por lo tanto, la complejidad de una solución robusta que cubre todos los casos extremos requiere una función : consulte su definición a continuación; se puede volver todos los componentes de un camino .

Llamada de ejemplo:

splitPath '/etc/bash.bashrc' dir fname fnameroot suffix
# -> $dir == '/etc'
# -> $fname == 'bash.bashrc'
# -> $fnameroot == 'bash'
# -> $suffix == '.bashrc'

Tenga en cuenta que los argumentos después de la ruta de entrada se eligen libremente, nombres de variables posicionales .
Para omitir variables que no son de interés anteriores a las que sí lo son, especifique _(para usar la variable desechable $_) o ''; por ejemplo, para extraer la raíz y la extensión del nombre de archivo solamente, use splitPath '/etc/bash.bashrc' _ _ fnameroot extension.

# SYNOPSIS
#   splitPath path varDirname [varBasename [varBasenameRoot [varSuffix]]] 
# DESCRIPTION
#   Splits the specified input path into its components and returns them by assigning
#   them to variables with the specified *names*.
#   Specify '' or throw-away variable _ to skip earlier variables, if necessary.
#   The filename suffix, if any, always starts with '.' - only the *last*
#   '.'-prefixed token is reported as the suffix.
#   As with `dirname`, varDirname will report '.' (current dir) for input paths
#   that are mere filenames, and '/' for the root dir.
#   As with `dirname` and `basename`, a trailing '/' in the input path is ignored.
#   A '.' as the very first char. of a filename is NOT considered the beginning
#   of a filename suffix.
# EXAMPLE
#   splitPath '/home/jdoe/readme.txt' parentpath fname fnameroot suffix
#   echo "$parentpath" # -> '/home/jdoe'
#   echo "$fname" # -> 'readme.txt'
#   echo "$fnameroot" # -> 'readme'
#   echo "$suffix" # -> '.txt'
#   ---
#   splitPath '/home/jdoe/readme.txt' _ _ fnameroot
#   echo "$fnameroot" # -> 'readme'  
splitPath() {
  local _sp_dirname= _sp_basename= _sp_basename_root= _sp_suffix=
    # simple argument validation
  (( $# >= 2 )) || { echo "$FUNCNAME: ERROR: Specify an input path and at least 1 output variable name." >&2; exit 2; }
    # extract dirname (parent path) and basename (filename)
  _sp_dirname=$(dirname "$1")
  _sp_basename=$(basename "$1")
    # determine suffix, if any
  _sp_suffix=$([[ $_sp_basename = *.* ]] && printf %s ".${_sp_basename##*.}" || printf '')
    # determine basename root (filemane w/o suffix)
  if [[ "$_sp_basename" == "$_sp_suffix" ]]; then # does filename start with '.'?
      _sp_basename_root=$_sp_basename
      _sp_suffix=''
  else # strip suffix from filename
    _sp_basename_root=${_sp_basename%$_sp_suffix}
  fi
  # assign to output vars.
  [[ -n $2 ]] && printf -v "$2" "$_sp_dirname"
  [[ -n $3 ]] && printf -v "$3" "$_sp_basename"
  [[ -n $4 ]] && printf -v "$4" "$_sp_basename_root"
  [[ -n $5 ]] && printf -v "$5" "$_sp_suffix"
  return 0
}

test_paths=(
  '/etc/bash.bashrc'
  '/usr/bin/grep'
  '/Users/jdoe/.bash_profile'
  '/Library/Application Support/'
  'readme.new.txt'
)

for p in "${test_paths[@]}"; do
  echo ----- "$p"
  parentpath= fname= fnameroot= suffix=
  splitPath "$p" parentpath fname fnameroot suffix
  for n in parentpath fname fnameroot suffix; do
    echo "$n=${!n}"
  done
done

Código de prueba que ejerce la función:

test_paths=(
  '/etc/bash.bashrc'
  '/usr/bin/grep'
  '/Users/jdoe/.bash_profile'
  '/Library/Application Support/'
  'readme.new.txt'
)

for p in "${test_paths[@]}"; do
  echo ----- "$p"
  parentpath= fname= fnameroot= suffix=
  splitPath "$p" parentpath fname fnameroot suffix
  for n in parentpath fname fnameroot suffix; do
    echo "$n=${!n}"
  done
done

Resultado esperado: tenga en cuenta los casos límite:

• un nombre de archivo que no tiene sufijo
• un nombre de archivo que comienza con .( no considera el inicio del sufijo)
• una ruta de entrada que termina en /(final/ se ignora el )
• una ruta de entrada que es solo un nombre de archivo ( .se devuelve como la ruta principal)
• un nombre de archivo que tiene más de .un token prefijado (solo el último se considera el sufijo):

----- /etc/bash.bashrc
parentpath=/etc
fname=bash.bashrc
fnameroot=bash
suffix=.bashrc
----- /usr/bin/grep
parentpath=/usr/bin
fname=grep
fnameroot=grep
suffix=
----- /Users/jdoe/.bash_profile
parentpath=/Users/jdoe
fname=.bash_profile
fnameroot=.bash_profile
suffix=
----- /Library/Application Support/
parentpath=/Library
fname=Application Support
fnameroot=Application Support
suffix=
----- readme.new.txt
parentpath=.
fname=readme.new.txt
fnameroot=readme.new
suffix=.txt

La solución más pequeña y más simple (en una sola línea) es:

$ file=/blaabla/bla/blah/foo.txt
echo $(basename ${file%.*}) # foo

Creo que si solo necesita el nombre del archivo, puede intentar esto:

FULLPATH=/usr/share/X11/xorg.conf.d/50-synaptics.conf

# Remove all the prefix until the "/" character
FILENAME=${FULLPATH##*/}

# Remove all the prefix until the "." character
FILEEXTENSION=${FILENAME##*.}

# Remove a suffix, in our case, the filename. This will return the name of the directory that contains this file.
BASEDIRECTORY=${FULLPATH%$FILENAME}

echo "path = $FULLPATH"
echo "file name = $FILENAME"
echo "file extension = $FILEEXTENSION"
echo "base directory = $BASEDIRECTORY"

Y eso es todo = D.

Puede forzar el corte para mostrar todos los campos y los siguientes que se agregan -al número de campo.

NAME=`basename "$FILE"`
EXTENSION=`echo "$NAME" | cut -d'.' -f2-`

Entonces, si ARCHIVO es eth0.pcap.gz , la EXTENSIÓN serápcap.gz

Usando la misma lógica, también puede buscar el nombre del archivo usando '-' con el corte de la siguiente manera:

NAME=`basename "$FILE" | cut -d'.' -f-1`

Esto funciona incluso para nombres de archivo que no tienen ninguna extensión.

Reconocimiento de archivos mágicos

Además de la gran cantidad de buenas respuestas sobre esta pregunta de desbordamiento de pila, me gustaría agregar:

Bajo Linux y otros Unixen, hay un comando mágico llamado file, que detecta el tipo de archivo al analizar algunos primeros bytes del archivo. Esta es una herramienta muy antigua, utilizada inicialmente para servidores de impresión (si no se creó para ... no estoy seguro de eso).

file myfile.txt
myfile.txt: UTF-8 Unicode text

file -b --mime-type myfile.txt
text/plain

Se pueden encontrar extensiones de estándares en /etc/mime.types(en mi escritorio Debian GNU / Linux. Ver man filey man mime.types. Quizás tenga que instalar la fileutilidad y los mime-supportpaquetes):

grep $( file -b --mime-type myfile.txt ) </etc/mime.types
text/plain      asc txt text pot brf srt

Podrías crear un golpetazofunción para determinar la extensión correcta. Hay una pequeña muestra (no perfecta):

file2ext() {
    local _mimetype=$(file -Lb --mime-type "$1") _line _basemimetype
    case ${_mimetype##*[/.-]} in
        gzip | bzip2 | xz | z )
            _mimetype=${_mimetype##*[/.-]}
            _mimetype=${_mimetype//ip}
            _basemimetype=$(file -zLb --mime-type "$1")
            ;;
        stream )
            _mimetype=($(file -Lb "$1"))
            [ "${_mimetype[1]}" = "compressed" ] &&
                _basemimetype=$(file -b --mime-type - < <(
                        ${_mimetype,,} -d <"$1")) ||
                _basemimetype=${_mimetype,,}
            _mimetype=${_mimetype,,}
            ;;
        executable )  _mimetype='' _basemimetype='' ;;
        dosexec )     _mimetype='' _basemimetype='exe' ;;
        shellscript ) _mimetype='' _basemimetype='sh' ;;
        * )
            _basemimetype=$_mimetype
            _mimetype=''
            ;;
    esac
    while read -a _line ;do
        if [ "$_line" == "$_basemimetype" ] ;then
            [ "$_line[1]" ] &&
                _basemimetype=${_line[1]} ||
                _basemimetype=${_basemimetype##*[/.-]}
            break
        fi
        done </etc/mime.types
    case ${_basemimetype##*[/.-]} in
        executable ) _basemimetype='' ;;
        shellscript ) _basemimetype='sh' ;;
        dosexec ) _basemimetype='exe' ;;
        * ) ;;
    esac
    [ "$_mimetype" ] && [ "$_basemimetype" != "$_mimetype" ] &&
      printf ${2+-v} $2 "%s.%s" ${_basemimetype##*[/.-]} ${_mimetype##*[/.-]} ||
      printf ${2+-v} $2 "%s" ${_basemimetype##*[/.-]}
}

Esta función podría establecer una variable Bash que se pueda usar más tarde:

(Esto está inspirado en la respuesta correcta de @Petesh):

filename=$(basename "$fullfile")
filename="${filename%.*}"
file2ext "$fullfile" extension

echo "$fullfile -> $filename . $extension"

Ok por lo que si he entendido bien, el problema aquí es cómo conseguir que el nombre y la extensión completa de un archivo que tiene múltiples extensiones, por ejemplo, stuff.tar.gz.

Esto funciona para mi:

fullfile="stuff.tar.gz"
fileExt=${fullfile#*.}
fileName=${fullfile%*.$fileExt}

Esto le dará stuffcomo nombre de archivo y .tar.gzcomo extensión. Funciona para cualquier cantidad de extensiones, incluyendo 0. Espero que esto ayude a cualquiera que tenga el mismo problema =)

Yo uso el siguiente script

$ echo "foo.tar.gz"|rev|cut -d"." -f3-|rev
foo

$ F = "text file.test.txt"  
$ echo ${F/*./}  
txt  

Esto atiende a múltiples puntos y espacios en un nombre de archivo, sin embargo, si no hay extensión, devuelve el nombre de archivo en sí. Aunque es fácil de verificar; solo pruebe que el nombre de archivo y la extensión sean los mismos.

Naturalmente, este método no funciona para archivos .tar.gz. Sin embargo, eso podría manejarse en un proceso de dos pasos. Si la extensión es gz, verifique nuevamente para ver si también hay una extensión tar.

Cómo extraer el nombre de archivo y la extensión en peces :

function split-filename-extension --description "Prints the filename and extension"
  for file in $argv
    if test -f $file
      set --local extension (echo $file | awk -F. '{print $NF}')
      set --local filename (basename $file .$extension)
      echo "$filename $extension"
    else
      echo "$file is not a valid file"
    end
  end
end

Advertencias: se divide en el último punto, que funciona bien para nombres de archivo con puntos, pero no para extensiones con puntos. Ver ejemplo a continuación.

Uso:

$ split-filename-extension foo-0.4.2.zip bar.tar.gz
foo-0.4.2 zip  # Looks good!
bar.tar gz  # Careful, you probably want .tar.gz as the extension.

Probablemente hay mejores formas de hacer esto. Siéntase libre de editar mi respuesta para mejorarla.

Si hay un conjunto limitado de extensiones con las que se enfrentará y las conoce todas, intente esto:

switch $file
  case *.tar
    echo (basename $file .tar) tar
  case *.tar.bz2
    echo (basename $file .tar.bz2) tar.bz2
  case *.tar.gz
    echo (basename $file .tar.gz) tar.gz
  # and so on
end

Esto no tiene la advertencia como primer ejemplo, pero tiene que manejar cada caso, por lo que podría ser más tedioso dependiendo de cuántas extensiones pueda esperar.

Aquí hay un código con AWK . Se puede hacer de manera más simple. Pero no soy bueno en AWK.

filename$ ls
abc.a.txt  a.b.c.txt  pp-kk.txt
filename$ find . -type f | awk -F/ '{print $2}' | rev | awk -F"." '{$1="";print}' | rev | awk 'gsub(" ",".") ,sub(".$", "")'
abc.a
a.b.c
pp-kk
filename$ find . -type f | awk -F/ '{print $2}' | awk -F"." '{print $NF}'
txt
txt
txt

Simplemente use ${parameter%word}

En tu caso:

${FILE%.*}

Si quieres probarlo, todo lo siguiente funciona y simplemente elimina la extensión:

FILE=abc.xyz; echo ${FILE%.*};
FILE=123.abc.xyz; echo ${FILE%.*};
FILE=abc; echo ${FILE%.*};

A partir de la respuesta de Petesh , si solo se necesita el nombre de archivo, tanto la ruta como la extensión se pueden quitar en una sola línea,

filename=$(basename ${fullname%.*})

Basado en gran medida en los excelentes bashismos de @ mklement0 y repletos de bashismos útiles y aleatorios, así como otras respuestas a esta / otras preguntas / "ese maldito internet" ... Lo resumí todo en un poco, un poco más comprensible, función reutilizable para mi (o tu) .bash_profileque se encarga de lo que (considero) debería ser una versión más robusta de dirname/ basename/ lo que tienes ..

function path { SAVEIFS=$IFS; IFS=""   # stash IFS for safe-keeping, etc.
    [[ $# != 2 ]] && echo "usage: path <path> <dir|name|fullname|ext>" && return    # demand 2 arguments
    [[ $1 =~ ^(.*/)?(.+)?$ ]] && {     # regex parse the path
        dir=${BASH_REMATCH[1]}
        file=${BASH_REMATCH[2]}
        ext=$([[ $file = *.* ]] && printf %s ${file##*.} || printf '')
        # edge cases for extensionless files and files like ".nesh_profile.coffee"
        [[ $file == $ext ]] && fnr=$file && ext='' || fnr=${file:0:$((${#file}-${#ext}))}
        case "$2" in
             dir) echo      "${dir%/*}"; ;;
            name) echo      "${fnr%.*}"; ;;
        fullname) echo "${fnr%.*}.$ext"; ;;
             ext) echo           "$ext"; ;;
        esac
    }
    IFS=$SAVEIFS
}     

Ejemplos de uso ...

SOMEPATH=/path/to.some/.random\ file.gzip
path $SOMEPATH dir        # /path/to.some
path $SOMEPATH name       # .random file
path $SOMEPATH ext        # gzip
path $SOMEPATH fullname   # .random file.gzip                     
path gobbledygook         # usage: -bash <path> <dir|name|fullname|ext>

Una respuesta simple:

Para ampliar la respuesta de las variables POSIX , tenga en cuenta que puede hacer patrones más interesantes. Entonces, para el caso detallado aquí, simplemente puede hacer esto:

tar -zxvf $1
cd ${1%.tar.*}

Eso cortará la última aparición de .tar. <algo> .

En términos más generales, si desea eliminar la última aparición de. <algo> . <algo más> entonces

${1.*.*}

Debería funcionar bien.

El enlace de la respuesta anterior parece estar muerto. Aquí hay una gran explicación de un montón de manipulación de cadenas que puede hacer directamente en Bash, desde TLDP .

Si también desea permitir extensiones vacías , esto es lo más corto que se me ocurre:

echo 'hello.txt' | sed -r 's/.+\.(.+)|.*/\1/' # EXTENSION
echo 'hello.txt' | sed -r 's/(.+)\..+|(.*)/\1\2/' # FILENAME

Primera línea explicada: coincide con PATH.EXT o CUALQUIER COSA y lo reemplaza con EXT. Si CUALQUIER COSA coincide, el grupo ext no se captura.

Este es el único que funcionó para mí:

path='folder/other_folder/file.js'

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

>> file

Esto también se puede usar en la interpolación de cadenas, pero desafortunadamente debe configurarlo de baseantemano.

Aquí está el algoritmo que utilicé para encontrar el nombre y la extensión de un archivo cuando escribí un script Bash para hacer que los nombres sean únicos cuando los nombres entran en conflicto con respecto a la carcasa.

#! /bin/bash 

#
# Finds 
# -- name and extension pairs
# -- null extension when there isn't an extension.
# -- Finds name of a hidden file without an extension
# 

declare -a fileNames=(
  '.Montreal' 
  '.Rome.txt' 
  'Loundon.txt' 
  'Paris' 
  'San Diego.txt'
  'San Francisco' 
  )

echo "Script ${0} finding name and extension pairs."
echo 

for theFileName in "${fileNames[@]}"
do
     echo "theFileName=${theFileName}"  

     # Get the proposed name by chopping off the extension
     name="${theFileName%.*}"

     # get extension.  Set to null when there isn't an extension
     # Thanks to mklement0 in a comment above.
     extension=$([[ "$theFileName" == *.* ]] && echo ".${theFileName##*.}" || echo '')

     # a hidden file without extenson?
     if [ "${theFileName}" = "${extension}" ] ; then
         # hidden file without extension.  Fixup.
         name=${theFileName}
         extension=""
     fi

     echo "  name=${name}"
     echo "  extension=${extension}"
done 

La prueba de funcionamiento.

$ config/Name\&Extension.bash 
Script config/Name&Extension.bash finding name and extension pairs.

theFileName=.Montreal
  name=.Montreal
  extension=
theFileName=.Rome.txt
  name=.Rome
  extension=.txt
theFileName=Loundon.txt
  name=Loundon
  extension=.txt
theFileName=Paris
  name=Paris
  extension=
theFileName=San Diego.txt
  name=San Diego
  extension=.txt
theFileName=San Francisco
  name=San Francisco
  extension=
$ 

FYI: El programa completo de transliteración y más casos de prueba se pueden encontrar aquí: https://www.dropbox.com/s/4c6m0f2e28a1vxf/avoid-clashes-code.zip?dl=0

Usando el archivo de ejemplo /Users/Jonathan/Scripts/bash/MyScript.sh, este código:

MY_EXT=".${0##*.}"
ME=$(/usr/bin/basename "${0}" "${MY_EXT}")

resultará en ${ME}ser MyScripty ${MY_EXT}ser .sh:

Guión:

#!/bin/bash
set -e

MY_EXT=".${0##*.}"
ME=$(/usr/bin/basename "${0}" "${MY_EXT}")

echo "${ME} - ${MY_EXT}"

Algunas pruebas:

$ ./MyScript.sh 
MyScript - .sh

$ bash MyScript.sh
MyScript - .sh

$ /Users/Jonathan/Scripts/bash/MyScript.sh
MyScript - .sh

$ bash /Users/Jonathan/Scripts/bash/MyScript.sh
MyScript - .sh

De las respuestas anteriores, la línea más corta para imitar a Python

file, ext = os.path.splitext(path)

suponiendo que su archivo realmente tenga una extensión, es

EXT="${PATH##*.}"; FILE=$(basename "$PATH" .$EXT)