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

有关更多详细信息，请参阅Bash手册中的壳参数展开。

首先，获取不带路径的文件名：

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

或者，您可以专注于路径的最后一个'/'而不是'.'，即使您有不可预测的文件扩展名，它也应该有效：

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

您可能需要查看留档：

• 在网络上的“3.5.3外壳参数扩展”部分
• 在bash手册中名为“参数扩展”的部分

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

工作正常，所以你可以使用：

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

顺便说一句，这些命令的工作方式如下。

NAME的命令替换一个"."字符，后跟任意数量的非"."字符，直到行尾，没有任何内容（即，它删除了从最后的"."到行尾的所有内容，包括在内）。这基本上是使用正则表达式技巧的非贪婪替换。

EXTENSION的命令在行首替换任意数量的字符，后跟一个"."字符，没有任何内容（即，它删除了从行首到最后一个点的所有内容，包括在内）。这是一个贪婪的替换，是默认操作。

如果文件没有扩展名或没有文件名，这似乎不起作用。这是我正在使用的；它只使用内置并处理更多（但不是全部）病态文件名。

#!/bin/bashfor fullpath in "$@"dofilename="${fullpath##*/}"                      # Strip longest match of */ from startdir="${fullpath:0:${#fullpath} - ${#filename}}" # Substring from 0 thru pos of filenamebase="${filename%.[^.]*}"                       # Strip shortest match of . plus at least one non-dot char from endext="${filename:${#base} + 1}"                  # Substring from len of base thru endif [[ -z "$base" && -n "$ext" ]]; then          # If we have an extension and no base, it's really the basebase=".$ext"ext=""fi
echo -e "$fullpath:\n\tdir  = \"$dir\"\n\tbase = \"$base\"\n\text  = \"$ext\""done

以下是一些测试用例：

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

简单地使用${parameter%word}

在您的案例中：

${FILE%.*}

如果你想测试它，所有以下工作，只需删除扩展：

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

Mellen在一篇博客文章的评论中写道：

使用Bash，还有${file%.*}可以在没有扩展名的情况下获取文件名，${file##*.}可以单独获取扩展名。也就是说，

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

产出：

filename: thisfileextension: txt

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

这迎合了文件名中的多个点和空格，但是如果没有扩展名，它会返回文件名本身。不过很容易检查；只需测试文件名和扩展名是否相同。

当然，这种方法不适用于.tar.gz文件。但是，这可以在两步过程中处理。如果扩展名是gz，则再次检查是否还有tar扩展名。

您还可以使用for循环和tr从路径中提取文件名…

for x in `echo $path | tr "/" " "`; do filename=$x; done

tr用空格替换路径中的所有“//”分隔符，从而形成一个字符串列表，for循环扫描它们，将最后一个留在filename变量中。

因此，涵盖所有边缘情况的强大解决方案的复杂性要求函数-请参阅下面的定义；它可以返回路径的所有组件。

示例调用：

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

请注意，输入路径后的参数是自由选择的，位置变量名字。
要跳过那些不感兴趣的变量，请指定_（使用丢弃变量$_）或''；例如，要仅提取文件名根和扩展名，请使用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[@]}"; doecho ----- "$p"parentpath= fname= fnameroot= suffix=splitPath "$p" parentpath fname fnameroot suffixfor n in parentpath fname fnameroot suffix; doecho "$n=${!n}"donedone

执行该函数的测试代码：

test_paths=('/etc/bash.bashrc''/usr/bin/grep''/Users/jdoe/.bash_profile''/Library/Application Support/''readme.new.txt')
for p in "${test_paths[@]}"; doecho ----- "$p"parentpath= fname= fnameroot= suffix=splitPath "$p" parentpath fname fnameroot suffixfor n in parentpath fname fnameroot suffix; doecho "$n=${!n}"donedone

预期输出-注意边缘情况：

• 没有后缀的文件名
• 以.开头的文件名（没有被认为是后缀的开头）
• 以/结尾的输入路径（尾随/被忽略）
• 仅为文件名的输入路径（.作为父路径返回）
• 具有超过.前缀标记的文件名（只有最后一个被认为是后缀）：

----- /etc/bash.bashrcparentpath=/etcfname=bash.bashrcfnameroot=bashsuffix=.bashrc----- /usr/bin/grepparentpath=/usr/binfname=grepfnameroot=grepsuffix=----- /Users/jdoe/.bash_profileparentpath=/Users/jdoefname=.bash_profilefnameroot=.bash_profilesuffix=----- /Library/Application Support/parentpath=/Libraryfname=Application Supportfnameroot=Application Supportsuffix=----- readme.new.txtparentpath=.fname=readme.new.txtfnameroot=readme.newsuffix=.txt

主要基于@mclement0的优秀，充满随机，有用的巴什主义-以及对这个/其他问题/“那个该死的互联网”的其他答案……我把它全部包装成一点，稍微更容易理解，可重用函数为我的（或你的）.bash_profile负责（我认为）应该是dirname/basename/你有什么的更强大版本。

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 pathdir=${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" indir) echo      "${dir%/*}"; ;;name) echo      "${fnr%.*}"; ;;fullname) echo "${fnr%.*}.$ext"; ;;ext) echo           "$ext"; ;;esac}IFS=$SAVEIFS}

使用示例…

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

从上面的答案来看，模仿Python的最短oneliner

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

假设您的文件确实有扩展名，是

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

我使用以下脚本

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

如何提取<强>鱼中的文件名和扩展名：

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

注意事项：在最后一个点上拆分，这适用于带有点的文件名，但不适用于带有点的扩展名。参见下面的示例。

用法：

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

可能有更好的方法来做到这一点。请随意编辑我的答案以改进它。

如果您要处理的扩展集有限，并且您知道所有这些扩展，请尝试以下操作：

switch $filecase *.tarecho (basename $file .tar) tarcase *.tar.bz2echo (basename $file .tar.bz2) tar.bz2case *.tar.gzecho (basename $file .tar.gz) tar.gz# and so onend

作为第一个示例，没有确实有警告，但您必须处理每个案例，因此根据您可以期望的扩展数量，它可能会更乏味。

您可以使用

sed 's/^/./' | rev | cut -d. -f2- | rev | cut -c2-

获取文件名和

sed 's/^/./' | rev | cut -d. -f1  | rev

获得扩展。

测试用例：

echo "filename.gz"     | sed 's/^/./' | rev | cut -d. -f2- | rev | cut -c2-echo "filename.gz"     | sed 's/^/./' | rev | cut -d. -f1  | revecho "filename"        | sed 's/^/./' | rev | cut -d. -f2- | rev | cut -c2-echo "filename"        | sed 's/^/./' | rev | cut -d. -f1  | revecho "filename.tar.gz" | sed 's/^/./' | rev | cut -d. -f2- | rev | cut -c2-echo "filename.tar.gz" | sed 's/^/./' | rev | cut -d. -f1  | rev

一个简单的答案：

要扩展POSIX变量答案，请注意你可以做更多有趣的模式。所以对于这里详述的案例，你可以简单地这样做：

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

这将切断最后一次出现的. tar.<某物>。

更一般地说，如果您想删除最后出现的.<某物>.<其他东西>，那么

${1.*.*}

应该工作得很好。

上面答案的链接似乎已经死了。这里有一个很好的解释，你可以直接在Bash中进行字符串操作，来自TLDP。

一个简单的bash单行程序。我用它从pwd中的所有文件中删除了第一扩展名

for each in `ls -1 *.rst`doa=$(echo $each | wc -c)echo $each | cut -c -$(( $a-5 )) >> blognamesdone

它能做什么？

1）ls -1 *.rst将在新行（try）中列出标准输出上的所有文件。

2）echo $each | wc -c计算每个文件名中的字符数。

3）echo $each | cut -c -$(( $a-5 ))最多选择最后4个字符，即.rst。

这是我在编写Bash脚本时用于查找文件名称和扩展名的算法，以便在名称与大小写冲突时使名称唯一。

#! /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[@]}"doecho "theFileName=${theFileName}"
# Get the proposed name by chopping off the extensionname="${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

测试运行。

$ config/Name\&Extension.bashScript config/Name&Extension.bash finding name and extension pairs.
theFileName=.Montrealname=.Montrealextension=theFileName=.Rome.txtname=.Romeextension=.txttheFileName=Loundon.txtname=Loundonextension=.txttheFileName=Parisname=Parisextension=theFileName=San Diego.txtname=San Diegoextension=.txttheFileName=San Francisconame=San Franciscoextension=$

仅供参考：完整的音译程序和更多的测试用例可以在这里找到：https://www.dropbox.com/s/4c6m0f2e28a1vxf/avoid-clashes-code.zip?dl=0

以下是一些替代建议（主要在awk中），包括一些高级用例，例如提取软件包的版本号。

请注意，如果输入略有不同，其中一些可能会失败，因此任何使用这些的人都应该验证他们的预期输入，并在需要时调整regex表达式。

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]}'# orecho "$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 '^[/]\|^~/' 

所有用例都使用原始完整路径作为输入，而不依赖于中间结果。

从Petesh构建答案，如果只需要文件名，路径和扩展都可以在一行中剥离，

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

这是一个sed解决方案，可以提取各种形式的路径组件，并且可以处理大多数边缘情况：

## Enter the input path and field separator character, for example:## (separatorChar must not be present in inputPath)
inputPath="/path/to/Foo.bar"separatorChar=":"
## sed extracts the path components and assigns them to output variables
oldIFS="$IFS"IFS="$separatorChar"read dirPathWithSlash dirPath fileNameWithExt fileName fileExtWithDot fileExt <<<"$(sed -En 's/^[[:space:]]+//s/[[:space:]]+$//t l1:l1s/^([^/]|$)//ts/[/]+$//t l2:l2s/^$/filesystem\/\filesystem/pths/^(.*)([/])([^/]+)$/\1\2\\1\\3/pgt l3:l3s/^.*[/]([^/]+)([.])([a-zA-Z0-9]+)$/\1\\2\3\\3/pts/^.*[/](.+)$/\1/p' <<<"$inputPath" | tr "\n" "$separatorChar")"IFS="$oldIFS"
## Results (all use separatorChar=":")
## inputPath        = /path/to/Foo.bar## dirPathWithSlash = /path/to/## dirPath          = /path/to## fileNameWithExt  = Foo.bar## fileName         = Foo## fileExtWithDot   = .bar## fileExt          = bar
## inputPath        = /path/to/Foobar## dirPathWithSlash = /path/to/## dirPath          = /path/to## fileNameWithExt  = Foobar## fileName         = Foobar## fileExtWithDot   =## fileExt          =
## inputPath        = /path/to/...bar## dirPathWithSlash = /path/to/## dirPath          = /path/to## fileNameWithExt  = ...bar## fileName         = ..## fileExtWithDot   = .bar## fileExt          = bar
## inputPath        = /path/to/..bar## dirPathWithSlash = /path/to/## dirPath          = /path/to## fileNameWithExt  = ..bar## fileName         = .## fileExtWithDot   = .bar## fileExt          = bar
## inputPath        = /path/to/.bar## dirPathWithSlash = /path/to/## dirPath          = /path/to## fileNameWithExt  = .bar## fileName         = .bar## fileExtWithDot   =## fileExt          =
## inputPath        = /path/to/...## dirPathWithSlash = /path/to/## dirPath          = /path/to## fileNameWithExt  = ...## fileName         = ...## fileExtWithDot   =## fileExt          =
## inputPath        = /path/to/Foo.## dirPathWithSlash = /path/to/## dirPath          = /path/to## fileNameWithExt  = Foo.## fileName         = Foo.## fileExtWithDot   =## fileExt          =
## inputPath        = / (the root directory)## dirPathWithSlash = filesystem/## dirPath          = filesystem## fileNameWithExt  =## fileName         =## fileExtWithDot   =## fileExt          =
## inputPath        =  (invalid because empty)## dirPathWithSlash =## dirPath          =## fileNameWithExt  =## fileName         =## fileExtWithDot   =## fileExt          =
## inputPath        = Foo/bar (invalid because doesn't start with a forward slash)## dirPathWithSlash =## dirPath          =## fileNameWithExt  =## fileName         =## fileExtWithDot   =## fileExt          =

以下是它的工作原理：

#0解析输入路径并按顺序在单独的行上打印以下路径组件：

• 带有尾随斜杠字符的目录路径
• 不带尾随斜杠字符的目录路径
• 带扩展名的文件名
• 不带扩展名的文件名
• 带前导点字符的文件扩展名
• 不带前导点字符的文件扩展名

#0将#1输出转换为上述路径组件的分隔符分隔字符串。

#0使用分隔符作为字段分隔符（IFS="$separatorChar"），并将每个路径组件分配给其各自的变量。

以下是#0构造的工作原理：

• #0和#1去掉任何前导和/或尾随空格字符
• #0和#1为下一个s函数刷新t函数
• #0和#1测试无效的输入路径（不以正斜杠开头的路径），在这种情况下，它将所有输出行留空并退出sed命令
• #0去掉任何拖尾斜杠
• #0和#1为下一个s函数刷新t函数
• #0和#1测试输入路径由根目录//组成的特殊情况，在这种情况下，它为斜线路径描述和diPath输出行打印文件系统/和文件系统，将所有其他输出行留空，并退出ed命令
• #0将输入路径保存在保持空间中
• #0打印斜线路径描述、diPath和外部文件名输出行
• #0从保持空间中检索输入路径
• #0和#1为下一个s函数刷新t函数