Je veux obtenir le nom de fichier (sans extension) et l'extension séparément.

La meilleure solution que j'ai trouvée jusqu'à présent est:

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

C'est faux car cela ne fonctionne pas si le nom de fichier contient plusieurs .caractères. Si, disons, je l'ai a.b.js, il considérera aet b.js, au lieu de a.bet js.

Cela peut être facilement fait en Python avec

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

mais je préfère ne pas lancer un interpréteur Python juste pour cela, si possible.

De meilleures idées?

Tout d'abord, obtenez le nom du fichier sans le chemin:

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

Alternativement, vous pouvez vous concentrer sur le dernier '/' du chemin au lieu du '.' qui devrait fonctionner même si vous avez des extensions de fichier imprévisibles:

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

Vous voudrez peut-être vérifier la documentation:

• Sur le Web à la section " 3.5.3 Expansion des paramètres du shell "
• Dans la page de manuel bash dans la section intitulée "Expansion des paramètres"

~% FILE="example.tar.gz"

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

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

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

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

Pour plus de détails, voir Extension des paramètres du shell dans le manuel de Bash.

Habituellement, vous connaissez déjà l'extension, vous pouvez donc utiliser:

basename filename .extension

par exemple:

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

et nous obtenons

filename

Vous pouvez utiliser la magie de l'expansion des paramètres POSIX:

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

Il y a une mise en garde: si votre nom de fichier était de la forme, ./somefile.tar.gzalors echo ${FILENAME%%.*}supprimerait avidement la correspondance la plus longue avec le .et vous auriez la chaîne vide.

(Vous pouvez contourner cela avec une variable temporaire:

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

)

Ce site explique plus.

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

Cela ne semble pas fonctionner si le fichier n'a pas d'extension ou pas de nom de fichier. Voici ce que j'utilise; il utilise uniquement des fonctions internes et gère plus (mais pas tous) les noms de fichiers pathologiques.

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

Et voici quelques testcases:

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

Vous pouvez utiliser basename.

Exemple:

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

Vous devez fournir le nom de base avec l'extension à supprimer, mais si vous exécutez toujours taravec, -zvous savez que l'extension le sera .tar.gz.

Cela devrait faire ce que vous voulez:

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

fonctionne bien, vous pouvez donc simplement utiliser:

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

Soit dit en passant, les commandes fonctionnent comme suit.

La commande pour NAMEsubstitue un "."caractère suivi d'un nombre quelconque de non- "."caractères jusqu'à la fin de la ligne, sans rien (c'est-à-dire qu'elle supprime tout de la finale "."à la fin de la ligne, inclus). Il s'agit essentiellement d'une substitution non gourmande utilisant la ruse regex.

La commande pour EXTENSIONsubstitue un nombre quelconque de caractères suivi d'un "."caractère au début de la ligne, sans rien (c'est-à-dire qu'elle supprime tout du début de la ligne au point final, inclus). Il s'agit d'une substitution gourmande qui est l'action par défaut.

Mellen écrit dans un commentaire sur un article de blog:

En utilisant Bash, il y a aussi ${file%.*}pour obtenir le nom de fichier sans l'extension et ${file##*.}pour obtenir l'extension seule. C'est,

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

Les sorties:

filename: thisfile
extension: txt

Pas besoin de s'embêter avec awkou sedou même perlpour cette tâche simple. Il existe une os.path.splitext()solution entièrement compatible avec Bash qui n'utilise que des extensions de paramètres.

Implémentation de référence

Documentation de os.path.splitext(path):

Divisez le chemin d'accès en une paire (root, ext)telle que root + ext == path, et ext est vide ou commence par un point et contient au plus un point. Les premières périodes sur le nom de base sont ignorées; splitext('.cshrc')retourne ('.cshrc', '').

Code Python:

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

Implémentation de Bash

Honorer les périodes marquantes

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

Ignorer les périodes principales

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

Les tests

Voici des cas de test pour l' implémentation Ignorer les périodes principales , qui doivent correspondre à l'implémentation de référence Python sur chaque entrée.

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

Résultats de test

Tous les tests ont réussi.

Vous pouvez utiliser la cutcommande pour supprimer les deux dernières extensions (la ".tar.gz"partie):

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

Comme l'a noté Clayton Hughes dans un commentaire, cela ne fonctionnera pas pour l'exemple réel de la question. Donc, comme alternative, je propose d'utiliser seddes expressions régulières étendues, comme ceci:

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

Il fonctionne en supprimant inconditionnellement les deux dernières extensions (alphanumériques).

[Mis à jour à nouveau après le commentaire d'Anders Lindahl]

Voici quelques suggestions alternatives (principalement en awk), y compris des cas d'utilisation avancés, comme l'extraction des numéros de version pour les packages logiciels.

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 '^[/]\|^~/'

Tous les cas d'utilisation utilisent le chemin complet d'origine comme entrée, sans dépendre des résultats intermédiaires.

La réponse acceptée fonctionne bien dans les typiques cas , mais échoue bord des cas , à savoir:

• Pour les noms de fichiers sans extension (appelé suffixe dans le reste de cette réponse), extension=${filename##*.}renvoie le nom de fichier d'entrée plutôt qu'une chaîne vide.
• extension=${filename##*.}ne comprend pas l'initiale ., contrairement à la convention.
  • Le préfixe aveugle .ne fonctionnerait pas pour les noms de fichiers sans suffixe.
• filename="${filename%.*}"sera la chaîne vide, si le nom du fichier d'entrée commence par .et ne contient aucun autre .caractère (par exemple, .bash_profile) - contrairement à la convention.

---------

Ainsi, la complexité d'une solution robuste qui couvre tous les cas marginaux appelle une fonction - voir sa définition ci-dessous; il peut renvoyer tous les composants d'un chemin .

Exemple d'appel:

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

Notez que les arguments après le chemin d'entrée sont des noms de variables de position librement choisis .
Pour ignorer les variables sans intérêt qui précèdent celles qui le sont, spécifiez _(pour utiliser la variable à jeter $_) ou ''; par exemple, pour extraire uniquement la racine et l'extension du nom de fichier, utilisez 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

Code de test qui exerce la fonction:

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

Sortie attendue - notez les cas de bord:

• un nom de fichier sans suffixe
• un nom de fichier commençant par .( non considéré comme le début du suffixe)
• un chemin d'entrée se terminant par /(fin/ est ignorée)
• un chemin d'entrée qui est uniquement un nom de fichier ( .est renvoyé comme chemin parent)
• un nom de fichier qui a plus d' .un jeton préfixé (seul le dernier est considéré comme le suffixe):

----- /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 solution la plus petite et la plus simple (en une seule ligne) est:

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

Je pense que si vous avez juste besoin du nom du fichier, vous pouvez essayer ceci:

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"

Et c'est tout = D.

Vous pouvez forcer la coupure pour afficher tous les champs et les suivants en ajoutant -au numéro de champ.

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

Donc, si FILE est eth0.pcap.gz, l'extension serapcap.gz

En utilisant la même logique, vous pouvez également récupérer le nom de fichier en utilisant '-' avec cut comme suit:

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

Cela fonctionne même pour les noms de fichiers sans extension.

Reconnaissance magique des fichiers

En plus des nombreuses bonnes réponses à cette question sur le débordement de pile, je voudrais ajouter:

Sous Linux et autres Unixen, il existe une commande magique nommée file, qui fait la détection de type de fichier en analysant les premiers octets de fichier. Il s'agit d'un outil très ancien, initialement utilisé pour les serveurs d'impression (s'il n'est pas créé pour ... je n'en suis pas sûr).

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

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

Des extensions de standards peuvent être trouvées dans /etc/mime.types(sur mon bureau Debian GNU / Linux. Voir man fileet man mime.types. Peut-être devez-vous installer l' fileutilitaire et les mime-supportpaquets):

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

Vous pouvez créer un frapperfonction pour déterminer l'extension droite. Il y a un petit échantillon (pas parfait):

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

Cette fonction pourrait définir une variable Bash pouvant être utilisée ultérieurement:

(Ceci est inspiré de la bonne réponse @Petesh):

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

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

Ok donc si je comprends bien, le problème ici est de savoir comment obtenir le nom et l'extension complète d'un fichier qui a plusieurs extensions, par exemple stuff.tar.gz.

Cela fonctionne pour moi:

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

Cela vous donnera stuffcomme nom de fichier et .tar.gzcomme extension. Cela fonctionne pour n'importe quel nombre d'extensions, y compris 0. J'espère que cela aide pour toute personne ayant le même problème =)

J'utilise le script suivant

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

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

Cela prend en charge plusieurs points et espaces dans un nom de fichier, mais s'il n'y a pas d'extension, il renvoie le nom de fichier lui-même. Facile à vérifier cependant; testez simplement que le nom de fichier et l'extension sont identiques.

Naturellement, cette méthode ne fonctionne pas pour les fichiers .tar.gz. Cependant, cela pourrait être géré en deux étapes. Si l'extension est gz, vérifiez à nouveau pour voir s'il existe également une extension tar.

Comment extraire le nom de fichier et l'extension dans le poisson :

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

Avertissements: fractionnements sur le dernier point, ce qui fonctionne bien pour les noms de fichiers contenant des points, mais pas bien pour les extensions contenant des points. Voir l'exemple ci-dessous.

Usage:

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

Il y a probablement de meilleures façons de le faire. N'hésitez pas à modifier ma réponse pour l'améliorer.

S'il y a un ensemble limité d'extensions que vous allez traiter et que vous les connaissez toutes, essayez ceci:

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

Cela n'a pas la mise en garde comme premier exemple, mais vous devez gérer chaque cas, donc cela pourrait être plus fastidieux en fonction du nombre d'extensions que vous pouvez attendre.

Voici le code avec AWK . Cela peut être fait plus simplement. Mais je ne suis pas bon 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

Utilisez simplement ${parameter%word}

Dans ton cas:

${FILE%.*}

Si vous voulez le tester, tous les travaux suivants, et supprimez simplement l'extension:

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

Construire à partir de la réponse Petesh , si seul le nom de fichier est nécessaire, le chemin et l'extension peuvent être supprimés sur une seule ligne,

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

Basé en grande partie sur l'excellent et le plein de bashismes aléatoires et utiles de @ mklement0 - ainsi que d'autres réponses à cette / d'autres questions / "ce sacrément Internet" ... J'ai résumé le tout dans un petit peu, fonction réutilisable pour mon (ou votre) .bash_profilequi s'occupe de ce que (je considère) devrait être une version plus robuste de dirname/ basename/ ce que vous avez ..

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
}     

Exemples d'utilisation ...

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>

Une réponse simple:

Pour développer la réponse des variables POSIX , notez que vous pouvez faire des modèles plus intéressants. Donc, pour le cas détaillé ici, vous pouvez simplement faire ceci:

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

Cela coupera la dernière occurrence de .tar. <quelque chose> .

Plus généralement, si vous souhaitez supprimer la dernière occurrence de. <quelque chose> . <something-else> alors

${1.*.*}

devrait bien fonctionner.

Le lien de la réponse ci-dessus semble être mort. Voici une excellente explication d'un tas de la manipulation de chaînes que vous pouvez faire directement dans Bash, à partir de TLDP .

Si vous souhaitez également autoriser les extensions vides , c'est la plus courte que j'ai pu trouver:

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

1ère ligne expliquée: elle correspond à PATH.EXT ou à TOUT et la remplace par EXT. Si N'IMPORTE QUOI correspond, le groupe ext n'est pas capturé.

C'est le seul qui a fonctionné pour moi:

path='folder/other_folder/file.js'

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

>> file

Cela peut également être utilisé dans l'interpolation de chaînes, mais malheureusement, vous devez le définir baseau préalable.

Voici l'algorithme que j'ai utilisé pour trouver le nom et l'extension d'un fichier lorsque j'ai écrit un script Bash pour rendre les noms uniques en cas de conflit de noms par rapport à la casse.

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

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

FYI: Le programme complet de translittération et plus de cas de test peuvent être trouvés ici: https://www.dropbox.com/s/4c6m0f2e28a1vxf/avoid-clashes-code.zip?dl=0

En utilisant un fichier d'exemple /Users/Jonathan/Scripts/bash/MyScript.sh, ce code:

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

se traduira par ${ME}être MyScriptet ${MY_EXT}être .sh:

Scénario:

#!/bin/bash
set -e

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

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

Quelques tests:

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

D'après les réponses ci-dessus, le plus court oneliner pour imiter Python

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

en supposant que votre fichier a vraiment une extension, est

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