Voglio ottenere il nome file (senza estensione) e l'estensione separatamente.

La migliore soluzione che ho trovato finora è:

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

Questo è sbagliato perché non funziona se il nome del file contiene più .caratteri. Se, diciamo, ho a.b.js, prenderà in considerazione ae b.js, invece di a.be js.

Può essere facilmente eseguito in Python con

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

ma preferirei non accendere un interprete Python solo per questo, se possibile.

Qualche idea migliore?

Innanzitutto, ottieni il nome del file senza il percorso:

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

In alternativa, puoi concentrarti sull'ultimo "/" del percorso anziché su "." che dovrebbe funzionare anche se hai estensioni di file imprevedibili:

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

Potresti voler controllare la documentazione:

• Sul Web alla sezione " 3.5.3 Espansione dei parametri della shell "
• Nella manpage di bash nella sezione chiamata "Espansione dei parametri"

~% FILE="example.tar.gz"

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

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

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

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

Per maggiori dettagli, consultare l' espansione dei parametri della shell nel manuale di Bash.

Di solito conosci già l'estensione, quindi potresti voler usare:

basename filename .extension

per esempio:

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

e otteniamo

filename

Puoi usare la magia dell'espansione dei parametri POSIX:

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

C'è un avvertimento nel senso che se il nome del file è di forma ./somefile.tar.gzquindi echo ${FILENAME%%.*}eliminerebbe avidamente il match più lungo al .e che avresti avuto la stringa vuota.

(Puoi aggirare quello con una variabile temporanea:

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

)

Questo sito spiega di più.

${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

Ciò non sembra funzionare se il file non ha estensione o nome file. Ecco cosa sto usando; utilizza solo builtin e gestisce più (ma non tutti) nomi di file patologici.

#!/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

E qui ci sono alcuni test:

$ 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 = ""
/ Home / me /:
    dir = "/ home / me /"
    base = ""
    ext = ""
/ Home / me / file:
    dir = "/ home / me /"
    base = "file"
    ext = ""
/home/me/file.tar:
    dir = "/ home / me /"
    base = "file"
    ext = "tar"
/home/me/file.tar.gz:
    dir = "/ home / me /"
    base = "file.tar"
    ext = "gz"
/home/me/.hidden:
    dir = "/ home / me /"
    base = ".hidden"
    ext = ""
/home/me/.hidden.tar:
    dir = "/ home / me /"
    base = ".hidden"
    ext = "tar"
/ Home / me / ..:
    dir = "/ home / me /"
    base = ".."
    ext = ""
.:
    dir = ""
    base = "."
    ext = ""

È possibile utilizzare basename.

Esempio:

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

È necessario fornire il nome di base con l'estensione che deve essere rimossa, tuttavia se si esegue sempre tarcon -zallora si sa che l'estensione sarà .tar.gz.

Questo dovrebbe fare quello che vuoi:

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

funziona bene, quindi puoi semplicemente usare:

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

I comandi, tra l'altro, funzionano come segue.

Il comando NAMEsostituisce un "."carattere seguito da un numero qualsiasi di non "."caratteri fino alla fine della riga, senza nulla (ovvero rimuove tutto dalla "."fine alla fine della riga, incluso). Questa è sostanzialmente una sostituzione non avida usando l'inganno regex.

Il comando EXTENSIONsostituisce un numero qualsiasi di caratteri seguito da un "."carattere all'inizio della riga, senza nulla (cioè rimuove tutto dall'inizio della riga al punto finale, compreso). Questa è una sostituzione avida che è l'azione predefinita.

Mellen scrive in un commento su un post di blog:

Usando Bash, c'è anche ${file%.*}per ottenere il nome del file senza l'estensione e ${file##*.}per ottenere l'estensione da solo. Questo è,

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

Uscite:

filename: thisfile
extension: txt

Non c'è bisogno di perdere tempo con awko sedo anche perlper questo semplice compito. Esiste una os.path.splitext()soluzione compatibile con Pure Bash che utilizza solo espansioni di parametri.

Implementazione di riferimento

Documentazione di os.path.splitext(path):

Dividere il percorso path in una coppia (root, ext)tale che root + ext == path, ed ext è vuota o inizia con un periodo e contiene al massimo un periodo. I periodi iniziali sul nome di base vengono ignorati; splitext('.cshrc')ritorna ('.cshrc', '').

Codice Python:

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

Implementazione di Bash

Onorare i periodi principali

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

Ignorando i periodi iniziali

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

test

Ecco alcuni casi di test per l' implementazione Ignora periodi iniziali, che devono corrispondere all'implementazione di riferimento Python su ogni input.

|---------------|-----------|-------|
|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' |
|---------------|-----------|-------|

Risultati del test

Tutti i test sono passati.

È possibile utilizzare il cutcomando per rimuovere le ultime due estensioni (la ".tar.gz"parte):

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

Come notato da Clayton Hughes in un commento, questo non funzionerà per l'esempio reale nella domanda. Quindi, in alternativa, propongo di utilizzare sedcon espressioni regolari estese, in questo modo:

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

Funziona rimuovendo le ultime due estensioni (alfanumeriche) incondizionatamente.

[Aggiornato di nuovo dopo il commento di Anders Lindahl]

Ecco alcuni suggerimenti alternativi (principalmente in awk), inclusi alcuni casi d'uso avanzati, come l'estrazione dei numeri di versione per i pacchetti 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 '^[/]\|^~/'

Tutti i casi d'uso utilizzano come input il percorso completo originale, senza dipendere da risultati intermedi.

La risposta accettata funziona bene nei casi tipici , ma fallisce nei casi limite , vale a dire:

• Per i nomi di file senza estensione (chiamato suffisso nel resto di questa risposta), extension=${filename##*.}restituisce il nome del file di input anziché una stringa vuota.
• extension=${filename##*.}non include l'iniziale ., contrariamente alla convenzione.
  • L'anticipo cieco .non funzionerebbe con nomi di file senza suffisso.
• filename="${filename%.*}"sarà la stringa vuota, se il nome del file di input inizia con .e non contiene altri .caratteri (ad esempio, .bash_profile), contrariamente alla convenzione.

---------

Pertanto, la complessità di una soluzione solida che copre tutti i casi limite richiede una funzione - vedere la sua definizione di seguito; si può tornare tutti i componenti di un percorso .

Esempio di chiamata:

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

Si noti che gli argomenti dopo il percorso di input sono liberamente scelti, nomi di variabili posizionali .
Per saltare le variabili non di interesse che precedono quelle che sono, specificare _(per utilizzare la variabile usa e getta $_) o ''; ad esempio, per estrarre solo la radice e l'estensione del nome file, utilizzare 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

Codice di prova che esercita la funzione:

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

Uscita prevista - notare i casi limite:

• un nome file senza suffisso
• un nome file che inizia con .( non considerato l'inizio del suffisso)
• un percorso di input che termina con /(il trailing /viene ignorato)
• un percorso di input che è solo un nome file ( .viene restituito come percorso principale)
• un nome file che ha più di .token prefissato (solo l'ultimo è considerato il suffisso):

----- /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 soluzione più piccola e più semplice (in linea singola) è:

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

Penso che se hai solo bisogno del nome del file, puoi provare questo:

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"

E questo è tutto = D.

È possibile forzare il taglio per visualizzare tutti i campi e quelli successivi che si aggiungono -al numero del campo.

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

Quindi, se FILE lo è eth0.pcap.gz, l'estensione saràpcap.gz

Utilizzando la stessa logica, puoi anche recuperare il nome del file usando '-' con cut come segue:

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

Funziona anche con nomi di file che non hanno alcuna estensione.

Riconoscimento magico dei file

Oltre alle molte buone risposte su questa domanda Stack Overflow, vorrei aggiungere:

Sotto Linux e altri unixen, c'è un comando magico chiamato file, che fa il rilevamento del tipo di file analizzando alcuni primi byte di file. Questo è uno strumento molto vecchio, usato inizialmente per i server di stampa (se non creato per ... Non ne sono sicuro).

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

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

Le estensioni degli standard possono essere trovate in /etc/mime.types(sul mio desktop Debian GNU / Linux. Vedi man filee man mime.types. Forse devi installare l' fileutilità e i mime-supportpacchetti):

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

È possibile creare un bashfunzione per determinare l'estensione corretta. C'è un piccolo esempio (non perfetto):

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##*[/.-]}
}

Questa funzione potrebbe impostare una variabile Bash che può essere utilizzata in seguito:

(Questo si ispira alla risposta giusta di @Petesh):

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

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

Ok, quindi, se ho capito bene, il problema qui è come ottenere il nome e l'estensione completa di un file che ha più estensioni, ad es stuff.tar.gz.

Questo funziona per me:

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

Questo ti darà stuffcome nome file e .tar.gzcome estensione. Funziona con qualsiasi numero di estensioni, incluso 0. Spero che questo aiuti per chiunque abbia lo stesso problema =)

Uso il seguente script

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

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

Questo si rivolge a più punti e spazi in un nome file, tuttavia se non c'è estensione restituisce il nome file stesso. Facile da verificare però; basta verificare che il nome file e l'estensione siano uguali.

Naturalmente questo metodo non funziona con i file .tar.gz. Tuttavia, ciò potrebbe essere gestito in due fasi. Se l'estensione è gz, controlla di nuovo per vedere se c'è anche un'estensione tar.

Come estrarre il nome file e l'estensione nei pesci :

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

Avvertenze: si divide sull'ultimo punto, che funziona bene per i nomi di file con punti all'interno, ma non bene per le estensioni con punti all'interno. Vedi esempio sotto.

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.

Probabilmente ci sono modi migliori per farlo. Sentiti libero di modificare la mia risposta per migliorarla.

Se hai a che fare con un set limitato di estensioni e le conosci tutte, prova questo:

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

Questo non ha l'avvertenza come primo esempio, ma devi gestire ogni caso in modo che possa essere più noioso a seconda di quante estensioni puoi aspettarti.

Ecco il codice con AWK . Può essere fatto più semplicemente. Ma non sono bravo in 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

Basta usare ${parameter%word}

Nel tuo caso:

${FILE%.*}

Se vuoi testarlo, tutto il seguente funziona e rimuovi l'estensione:

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

Costruendo dalla risposta Petesh , se è necessario solo il nome file, sia il percorso che l'estensione possono essere eliminati in una sola riga,

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

Basandomi in gran parte sull'eccellente e pieno zeppo di bashismi casuali e utili di @ mklement0 - nonché su altre risposte a questa / altre domande / "che maledettamente internet" ... ho concluso tutto in un po ', un po' più comprensibile, funzione riutilizzabile per il mio (o il tuo) .bash_profileche si occupa di ciò che (considero) dovrebbe essere una versione più solida di dirname/ basename/ cosa hai ..

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
}     

Esempi di utilizzo ...

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 semplice risposta:

Per espandere la risposta delle variabili POSIX , tenere presente che è possibile eseguire modelli più interessanti. Quindi, per il caso dettagliato qui, potresti semplicemente fare questo:

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

Ciò interromperà l'ultima occorrenza di .tar. <qualcosa> .

Più in generale, se si desidera rimuovere l'ultima occorrenza di. <qualcosa> . <something-else> quindi

${1.*.*}

dovrebbe funzionare bene.

Il link con la risposta sopra sembra essere morto. Ecco una grande spiegazione di un mucchio di manipolazioni di stringhe che puoi fare direttamente in Bash, da TLDP .

Se vuoi anche consentire estensioni vuote , questa è la più breve che potrei trovare:

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

Spiegazione della prima riga: corrisponde a PATH.EXT o ANYTHING e lo sostituisce con EXT. Se è stato trovato ANYTHING, il gruppo ext non viene acquisito.

Questo è l'unico che ha funzionato per me:

path='folder/other_folder/file.js'

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

>> file

Questo può essere utilizzato anche nell'interpolazione di stringhe, ma sfortunatamente è necessario impostare in baseanticipo.

Ecco l'algoritmo che ho usato per trovare il nome e l'estensione di un file quando ho scritto uno script Bash per rendere i nomi univoci quando i nomi erano in conflitto rispetto al case.

#! /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 

L'esecuzione del test.

$ 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=
$ 

A proposito: il programma completo di traslitterazione e altri casi di test sono disponibili qui: https://www.dropbox.com/s/4c6m0f2e28a1vxf/avoid-clashes-code.zip?dl=0

Utilizzando il file di esempio /Users/Jonathan/Scripts/bash/MyScript.sh, questo codice:

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

si tradurrà in ${ME}essere MyScripted ${MY_EXT}essere .sh:

script:

#!/bin/bash
set -e

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

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

Alcuni test:

$ ./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

Dalle risposte sopra, il più breve oneliner per imitare Python

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

supponendo che il tuo file abbia davvero un'estensione, lo è

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