Извлечь имя файла и расширение в Bash
Я хочу, чтобы получить имя файла (без расширения) и расширение отдельно.
лучшее решение я нашел до сих пор:
NAME=`echo "$FILE" | cut -d'.' -f1`
EXTENSION=`echo "$FILE" | cut -d'.' -f2`
это неправильно, потому что он не работает, если имя файла содержит несколько .
символы. Если, скажем, у меня есть a.b.js
, он будет рассматривать a
и b.js
, вместо a.b
и js
.
это можно легко сделать в Python с
file, ext = os.path.splitext(path)
но я бы предпочел не запускать Python переводчик только для этого, если возможно.
идеи получше?
30 ответов
во-первых, получить имя файла без пути:
filename=$(basename -- "$fullfile")
extension="${filename##*.}"
filename="${filename%.*}"
кроме того, вы можете сосредоточиться на последнем " / "пути вместо". который должен работать даже если у вас есть непредсказуемо расширениями:
filename="${fullfile##*/}"
~% FILE="example.tar.gz"
~% echo "${FILE%%.*}"
example
~% echo "${FILE%.*}"
example.tar
~% echo "${FILE#*.}"
tar.gz
~% echo "${FILE##*.}"
gz
дополнительные сведения см. В разделе расширение параметров оболочки в руководстве Bash.
обычно вы уже знаете расширение, поэтому вы можете использовать:
basename filename .extension
например:
basename /path/to/dir/filename.txt .txt
и мы получаем
filename
вы можете использовать магию переменных POSIX:
bash-3.2$ FILENAME=somefile.tar.gz
bash-3.2$ echo ${FILENAME%%.*}
somefile
bash-3.2$ echo ${FILENAME%.*}
somefile.tar
в этом есть оговорка, если ваше имя файла было в форме ./somefile.tar.gz
затем echo ${FILENAME%%.*}
жадно удалил бы самую длинную спичку в .
и у вас будет пустая строка.
(вы можете обойти это с помощью временной переменной:
FULL_FILENAME=$FILENAME
FILENAME=${FULL_FILENAME##*/}
echo ${FILENAME%%.*}
)
этой сайт больше объясняет.
${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
это не работает, если файл не имеет расширения или имени файла. Вот что я использую; он использует только встроенные имена и обрабатывает больше (но не все) патологические имена файлов.
#!/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
и вот некоторые тестовые примеры:
$ 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 = ""
можно использовать basename
.
пример:
$ basename foo-bar.tar.gz .tar.gz
foo-bar
вам нужно предоставить basename с расширением, которое должно быть удалено, однако, если вы всегда выполняете tar
С -z
тогда вы знаете, что расширение будет .tar.gz
.
это должно делать то, что вы хотите:
tar -zxvf
cd $(basename .tar.gz)
pax> echo a.b.js | sed 's/\.[^.]*$//'
a.b
pax> echo a.b.js | sed 's/^.*\.//'
js
отлично работает, поэтому вы можете просто использовать:
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
команды, кстати, работают следующим образом.
команда NAME
заменяет a "."
символ, за которым следует любое число"."
символы до конца строки, без ничего (т. е. он удаляет все из final "."
до конца строки включительно). Это в основном не жадная подстановка с использованием обмана regex.
команда EXTENSION
заменители a любое количество символов, за которыми следует "."
символ в начале строки, без ничего (т. е. он удаляет все от начала строки до конечной точки, включительно). Это жадная подстановка, которая является действием по умолчанию.
Меллен пишет в комментарии к сообщению в блоге:
используя Bash, есть также ${file%.*}
получить имя файла без расширения и ${file##*.}
чтобы получить расширение в одиночку. То есть,
file="thisfile.txt"
echo "filename: ${file%.*}"
echo "extension: ${file##*.}"
выходы:
filename: thisfile
extension: txt
можно использовать cut
команда для удаления последних двух расширений (".tar.gz"
часть):
$ echo "foo.tar.gz" | cut -d'.' --complement -f2-
foo
как отметил Клейтон Хьюз в комментарии, это не будет работать на конкретном примере в вопросе. Поэтому в качестве альтернативы я предлагаю использовать sed
с расширенными регулярными выражениями, например:
$ echo "mpc-1.0.1.tar.gz" | sed -r 's/\.[[:alnum:]]+\.[[:alnum:]]+$//'
mpc-1.0.1
он работает, удаляя последние два (альфа-числовые) расширения безоговорочно.
[Обновлено снова после комментария от Андерса Линдаля]
нет необходимости беспокоиться с awk
или sed
или даже perl
для этой простой задачи. Есть чистый-Баш,os.path.splitext()
-совместимое решение, которое использует только разложений параметра.
Эталонной Реализации
документация os.path.splitext(path)
:
разделить путь пути на пару
(root, ext)
такое, чтоroot + ext == path
и ext пусто или начинается с точки и содержит не более одного периода. Ведущие периоды базовое имя игнорируется;splitext('.cshrc')
возвращает('.cshrc', '')
.
Python-кода:
root, ext = os.path.splitext(path)
Реализация Bash
почитание ведущих периодов
root="${path%.*}"
ext="${path#"$root"}"
игнорирование ведущих периодов
root="${path#.}";root="${path%"$root"}${root%.*}"
ext="${path#"$root"}"
тесты
вот тестовые примеры для игнорирование ведущих периодов реализация, которая должна соответствовать ссылочной реализации Python на каждом входе.
|---------------|-----------|-------|
|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' |
|---------------|-----------|-------|
вот некоторые альтернативные предложения (в основном в awk
), включая некоторые расширенные варианты использования, такие как извлечение номеров версий для пакетов программного обеспечения.
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(/[^.]*[.]/, "", )} 1'
# Extension (last-2): 'tar.gz'
echo "$f" | awk -F'[.]' '{print $(NF-1)"."$NF}'
# Basename : 'file'
echo "$f" | awk '{gsub(/.*[/]|[.].*/, "", )} 1'
# Basename-extended : 'file.1.0.1.tar'
echo "$f" | awk '{gsub(/.*[/]|[.]{1}[^.]+$/, "", )} 1'
# Path : '/path/to/complex/'
echo "$f" | awk '{match(, /.*[/]/, a); print a[0]}'
# or
echo "$f" | grep -Eo '.*[/]'
# Folder (containing the file) : 'complex'
echo "$f" | awk -F'/' '{=""; 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'[/.]' '{=""; print }'
# Is absolute : True (exit-code : 0)
# Return true if it is an absolute path (starting with '/' or '~/'
echo "$f" | grep -q '^[/]\|^~/'
все варианты использования, используя исходный полный путь в качестве входных данных, вне зависимости от промежуточных результатов.
[Пересмотрено с однострочного до общего bash функции поведение сейчас соответствует dirname
и basename
служебные программы; обоснование добавил.]
на принято отвечать работает в типичный делам, а не в edge делам, а именно:
- для имен файлов без расширения (называется суффикс в остальной части этот ответ),
extension=${filename##*.}
возвращает входное имя файла, а не пустая строка. -
extension=${filename##*.}
не включает начальное.
, противоречит Конвенции.- слепо знаком
.
не будет работать для имен без суффикса.
- слепо знаком
-
filename="${filename%.*}"
будет пустая строка, если имя входного файла начинается с.
и не содержит никаких новых.
символы (например,.bash_profile
) - противоречит Конвенции.
---------
таким образом, сложность робастное разрешение которое покрывает все случаи края требует функции - см. его определение ниже; это может возвратить все компоненты контура.
пример вызова:
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 "")
_sp_basename=$(basename "")
# 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 ]] && printf -v "" "$_sp_dirname"
[[ -n ]] && printf -v "" "$_sp_basename"
[[ -n ]] && printf -v "" "$_sp_basename_root"
[[ -n ]] && printf -v "" "$_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
тестовый код, который выполняет функции:
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
ожидаемый результат - обратите внимание на граничные случаи:
- имя файла без суффикса
- имя файла, начиная с
.
(не считается началом суффикс) - входной путь, заканчивающийся в
/
(символы/
игнорируется) - входной путь, который является только имя файла (
.
возвращается как родительский путь) - имя файла, которое имеет больше, чем
.
-маркер с префиксом (суффиксом считается только последний):
----- /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
Я думаю, что если вам просто нужно имя файла, вы можете попробовать это:
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"
и это все =д.
наименьшее и самое простое решение (в одной строке):
$ file=/blaabla/bla/blah/foo.txt
echo $(basename ${file%.*})
foo
вы можете заставить вырезать отображать все поля и последующие, добавляя -
в поле Номер.
NAME=`basename "$FILE"`
EXTENSION=`echo "$NAME" | cut -d'.' -f2-`
Итак, если файл eth0.pcap.gz
, расширение будет pcap.gz
используя ту же логику, вы также можете получить имя файла, используя ' - ' с cut следующим образом:
NAME=`basename "$FILE" | cut -d'.' -f-1`
это работает даже для имен файлов, которые не имеют расширения.
Итак, если я правильно понимаю, проблема здесь заключается в том, как получить имя и расширение файла, который имеет несколько расширений, например, stuff.tar.gz
.
это работает для меня:
fullfile="stuff.tar.gz"
fileExt=${fullfile#*.}
fileName=${fullfile%*.$fileExt}
это даст вам stuff
С и .tar.gz
как расширение. Это работает для любого количества расширений, включая 0. Надеюсь, это поможет для тех, кто имеет ту же проблему =)
файл Magic признание
В дополнение к много хороших ответов на этот вопрос переполнения стека, я хотел бы добавить:
под Linux и другими unixen, есть магия команда с именем file
, которые делают обнаружение типа файла путем анализа некоторых первых байтов файла. Это очень старый инструмент, изначально используемый для серверов печати (если не создан для... Я не уверен в этом).
file myfile.txt
myfile.txt: UTF-8 Unicode text
file -b --mime-type myfile.txt
text/plain
расширения стандартов можно найти в /etc/mime.types
(на мой Debian рабочий стол GNU/Linux. См.man file
и man mime.types
. Возможно, вам нужно установить file
утилиты и mime-support
пакеты):
grep $( file -b --mime-type myfile.txt ) </etc/mime.types
text/plain asc txt text pot brf srt
вы можете создать Баш функция для определения правильного расширения. Есть небольшой (не идеальный) образец:
file2ext() {
local _mimetype=$(file -Lb --mime-type "") _line _basemimetype
case ${_mimetype##*[/.-]} in
gzip | bzip2 | xz | z )
_mimetype=${_mimetype##*[/.-]}
_mimetype=${_mimetype//ip}
_basemimetype=$(file -zLb --mime-type "")
;;
stream )
_mimetype=($(file -Lb ""))
[ "${_mimetype[1]}" = "compressed" ] &&
_basemimetype=$(file -b --mime-type - < <(
${_mimetype,,} -d <"")) ||
_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} "%s.%s" ${_basemimetype##*[/.-]} ${_mimetype##*[/.-]} ||
printf ${2+-v} "%s" ${_basemimetype##*[/.-]}
}
эта функция может установить переменную Bash, которая может быть использована позже:
(это вдохновлено правильным ответом @Petesh):
filename=$(basename "$fullfile")
filename="${filename%.*}"
file2ext "$fullfile" extension
echo "$fullfile -> $filename . $extension"
$ F = "text file.test.txt"
$ echo ${F/*./}
txt
это обслуживает несколько точек и пробелов в имени файла, однако, если нет расширения, оно возвращает само имя файла. Легко проверить; просто проверьте, что имя файла и расширение одинаковы.
естественно, этот метод не работает .смола.файлы gz. Однако это можно было бы решить в двухэтапном процессе. Если расширение gz, то проверьте еще раз, чтобы увидеть, есть ли также расширение tar.
как извлечь имя файла и расширение в рыбное:
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
предостережения: разбивается на последнюю точку, которая хорошо работает для имен файлов с точками в них, но не хорошо для расширений с точками в них. См. пример ниже.
использование:
$ 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.
вероятно, есть лучшие способы сделать это. Не стесняйтесь редактировать мой ответ, чтобы улучшить его.
Если есть ограниченный набор расширения, с которыми вы будете иметь дело, и вы знаете их все, попробуйте следующее:
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
Это не имейте предостережение в качестве первого примера, но вам нужно обрабатывать каждый случай, чтобы он мог быть более утомительным в зависимости от того, сколько расширений вы можете ожидать.
здесь код на awk. Это можно сделать проще. Но я не хорош в AWK.
filename$ ls
abc.a.txt a.b.c.txt pp-kk.txt
filename$ find . -type f | awk -F/ '{print }' | rev | awk -F"." '{="";print}' | rev | awk 'gsub(" ",".") ,sub(".$", "")'
abc.a
a.b.c
pp-kk
filename$ find . -type f | awk -F/ '{print }' | awk -F"." '{print $NF}'
txt
txt
txt
простой ответ:
для расширения на переменные POSIX ответ обратите внимание, что вы можете сделать более интересные узоры. Поэтому для случая, подробно описанного здесь, вы можете просто сделать это:
tar -zxvf
cd ${1%.tar.*}
это отрежет последнее вхождение .смола..
в целом, если вы хотите удалить последнее вхождение .. тогда
${1.*.*}
должно работать нормально.
ссылка вышеуказанный ответ кажется мертвым. вот отличное объяснение связки манипуляций со строками, которые вы можете сделать непосредственно в Bash, из TLDP.
здание Petesh ответ, если требуется только имя файла, и путь, и расширение могут быть разделены в одной строке,
filename=$(basename ${fullname%.*})
просто использовать ${parameter%word}
в вашем случае:
${FILE%.*}
Если вы хотите проверить его, все следующие работы, и просто удалите расширение:
FILE=abc.xyz; echo ${FILE%.*};
FILE=123.abc.xyz; echo ${FILE%.*};
FILE=abc; echo ${FILE%.*};
основанный в значительной степени от @mklement0 отлично, и битком набитый случайными, полезными bashisms - а также другие ответы на этот / другие вопросы / "этот чертов интернет"... Я завернул все это в немного, чуть более понятное, многоразовое функции для моего (или вашего) .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
[[ =~ ^(.*/)?(.+)?$ ]] && { # regex parse the path
dir=${BASH_REMATCH[1]}
file=${BASH_REMATCH[2]}
ext=$([[ $file = *.* ]] && printf %s ${file##*.} || printf '')
# edge cases for extesionless files and files like ".nesh_profile.coffee"
[[ $file == $ext ]] && fnr=$file && ext='' || fnr=${file:0:$((${#file}-${#ext}))}
case "" in
dir) echo "${dir%/*}"; ;;
name) echo "${fnr%.*}"; ;;
fullname) echo "${fnr%.*}.$ext"; ;;
ext) echo "$ext"; ;;
esac
}
IFS=$SAVEIFS
}
использование образцы...
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>
из ответов выше, самый короткий oneliner для имитации Python в
file, ext = os.path.splitext(path)
предполагая, что ваш файл действительно имеет расширение, это
EXT="${PATH##*.}"; FILE=$(basename "$PATH" .$EXT)
Если вы также хотите разрешить пустой расширения, это самое короткое, что я мог придумать:
echo 'hello.txt' | sed -r 's/.+\.(.+)|.*//' # EXTENSION
echo 'hello.txt' | sed -r 's/(.+)\..+|(.*)//' # FILENAME
1-я строка объяснена: она соответствует пути.EXT или что-то еще и заменяет его EXT. Если что-то было сопоставлено, группа ext не захвачена.
чтобы сделать dir более полезным (в случае, если в качестве ввода указан локальный файл без пути), я сделал следующее:
# Substring from 0 thru pos of filename
dir="${fullpath:0:${#fullpath} - ${#filename}}"
if [[ -z "$dir" ]]; then
dir="./"
fi
Это позволяет вам сделать что-то полезное, например, добавить суффикс к базовому имени входного файла как:
outfile=${dir}${base}_suffix.${ext}
testcase: foo.bar
dir: "./"
base: "foo"
ext: "bar"
outfile: "./foo_suffix.bar"
testcase: /home/me/foo.bar
dir: "/home/me/"
base: "foo"
ext: "bar"
outfile: "/home/me/foo_suffix.bar"
можно использовать
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 | rev
echo "filename" | sed 's/^/./' | rev | cut -d. -f2- | rev | cut -c2-
echo "filename" | sed 's/^/./' | rev | cut -d. -f1 | rev
echo "filename.tar.gz" | sed 's/^/./' | rev | cut -d. -f2- | rev | cut -c2-
echo "filename.tar.gz" | sed 's/^/./' | rev | cut -d. -f1 | rev
вот алгоритм, который я использовал для поиска имени и расширения файла, когда я написал сценарий 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 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
тестовый запуск.
$ 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: полная программа транслитерации и больше тестовых примеров можно найти здесь: https://www.dropbox.com/s/4c6m0f2e28a1vxf/avoid-clashes-code.zip?dl=0