Tôi muốn lấy tên tệp (không có phần mở rộng) và phần mở rộng riêng.

Giải pháp tốt nhất tôi tìm thấy cho đến nay là:

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

Điều này là sai vì nó không hoạt động nếu tên tệp chứa nhiều .ký tự. Nếu, giả sử, tôi có a.b.js, nó sẽ xem xét avà b.js, thay vì a.bvà js.

Nó có thể dễ dàng thực hiện trong Python với

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

nhưng tôi không muốn kích hoạt trình thông dịch Python chỉ vì điều này, nếu có thể.

Còn ý tưởng nào hay hơn không?

Đầu tiên, lấy tên tệp mà không có đường dẫn:

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

Ngoài ra, bạn có thể tập trung vào '/' cuối cùng của đường dẫn thay vì '.' sẽ hoạt động ngay cả khi bạn có phần mở rộng tệp không thể đoán trước:

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

Bạn có thể muốn kiểm tra tài liệu:

• Trên trang web tại phần " 3.5.3 Mở rộng tham số Shell "
• Trong trang bash tại phần có tên "Mở rộng tham số"

~% FILE="example.tar.gz"

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

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

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

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

Để biết thêm chi tiết, xem phần mở rộng tham số shell trong hướng dẫn Bash.

Thông thường bạn đã biết tiện ích mở rộng, vì vậy bạn có thể muốn sử dụng:

basename filename .extension

ví dụ:

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

và chúng tôi nhận được

filename

Bạn có thể sử dụng phép thuật mở rộng tham số POSIX:

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

Có một lưu ý rằng nếu tên tệp của bạn có dạng ./somefile.tar.gzthì echo ${FILENAME%%.*}sẽ tham lam loại bỏ kết quả khớp dài nhất với .và bạn sẽ có chuỗi trống.

(Bạn có thể làm việc xung quanh đó với một biến tạm thời:

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

)

Trang web này giải thích thêm.

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

Điều đó dường như không hoạt động nếu tệp không có phần mở rộng hoặc không có tên tệp. Đây là những gì tôi đang sử dụng; nó chỉ sử dụng các nội trang và xử lý nhiều hơn (nhưng không phải tất cả) tên tệp bệnh lý.

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

Và đây là một số thử nghiệm:

$ 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 / nhà / tôi / ...
/:
    thư mục = "/"
    cơ sở = ""
    máy lẻ = ""
/ nhà / tôi /:
    dir = "/ nhà / tôi /"
    cơ sở = ""
    máy lẻ = ""
/ nhà / tôi / tập tin:
    dir = "/ nhà / tôi /"
    cơ sở = "tập tin"
    máy lẻ = ""
/home/me/file.tar:
    dir = "/ nhà / tôi /"
    cơ sở = "tập tin"
    ext = "hắc ín"
/home/me/file.tar.gz:
    dir = "/ nhà / tôi /"
    cơ sở = "file.tar"
    ext = "gz"
/home/me/.hidden:
    dir = "/ nhà / tôi /"
    cơ sở = ".hidden"
    máy lẻ = ""
/home/me/.hidden.tar:
    dir = "/ nhà / tôi /"
    cơ sở = ".hidden"
    ext = "hắc ín"
/ nhà / tôi / ..:
    dir = "/ nhà / tôi /"
    cơ sở = ".."
    máy lẻ = ""
.:
    thư mục = ""
    cơ sở = "."
    máy lẻ = ""

Bạn có thể sử dụng basename.

Thí dụ:

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

Bạn cần cung cấp basename với phần mở rộng đó sẽ được gỡ bỏ, tuy nhiên nếu bạn luôn được thực hiện tarvới -zsau đó bạn biết phần mở rộng sẽ .tar.gz.

Điều này sẽ làm những gì bạn muốn:

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

hoạt động tốt, vì vậy bạn chỉ có thể sử dụng:

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

Các lệnh, nhân tiện, làm việc như sau.

Lệnh NAMEthay thế một "."ký tự theo sau bởi bất kỳ số lượng "."ký tự không nào cho đến cuối dòng, không có gì (nghĩa là, nó loại bỏ mọi thứ từ cuối cùng "."đến cuối dòng, bao gồm). Đây về cơ bản là một sự thay thế không tham lam bằng cách sử dụng thủ thuật regex.

Lệnh EXTENSIONthay thế một số lượng ký tự bất kỳ được theo sau bởi một "."ký tự ở đầu dòng, không có gì (nghĩa là, nó loại bỏ mọi thứ từ đầu dòng đến dấu chấm cuối cùng, bao gồm). Đây là một sự thay thế tham lam là hành động mặc định.

Mellen viết trong một bình luận trên một bài đăng trên blog:

Sử dụng Bash, cũng ${file%.*}có được tên tệp mà không có phần mở rộng và ${file##*.}chỉ có phần mở rộng. Đó là,

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

Đầu ra:

filename: thisfile
extension: txt

Không cần phải bận tâm với awkhoặc sedhoặc thậm chí perlcho nhiệm vụ đơn giản này. Có một os.path.splitext()giải pháp tương thích thuần Bash, chỉ sử dụng các mở rộng tham số.

Thực hiện tham khảo

Tài liệu về os.path.splitext(path):

Chia đường dẫn tên đường dẫn thành một cặp (root, ext)sao cho root + ext == pathvà ext trống hoặc bắt đầu bằng một dấu chấm và chứa nhiều nhất một khoảng thời gian. Các giai đoạn hàng đầu trên tên cơ sở được bỏ qua; splitext('.cshrc')trả lại ('.cshrc', '').

Mã Python:

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

Thực hiện Bash

Tôn vinh thời kỳ hàng đầu

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

Bỏ qua các giai đoạn hàng đầu

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

Xét nghiệm

Dưới đây là các trường hợp thử nghiệm để thực hiện Bỏ qua các giai đoạn hàng đầu , phù hợp với triển khai tham chiếu Python trên mỗi đầu vào.

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

Kết quả kiểm tra

Tất cả các bài kiểm tra đã qua.

Bạn có thể sử dụng cutlệnh để xóa hai phần mở rộng cuối cùng ( ".tar.gz"phần):

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

Theo ghi nhận của Clayton Hughes trong một bình luận, điều này sẽ không hoạt động cho ví dụ thực tế trong câu hỏi. Vì vậy, như một cách thay thế tôi đề xuất sử dụng sedvới các biểu thức chính quy mở rộng, như thế này:

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

Nó hoạt động bằng cách loại bỏ hai phần mở rộng (số alpha) cuối cùng một cách vô điều kiện.

[Cập nhật lại sau khi nhận xét từ Anders Lindahl]

Dưới đây là một số đề xuất thay thế (chủ yếu là trong awk), bao gồm một số trường hợp sử dụng nâng cao, như trích xuất số phiên bản cho các gói phần mềm.

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

Tất cả các trường hợp sử dụng đang sử dụng đường dẫn đầy đủ ban đầu làm đầu vào, mà không phụ thuộc vào kết quả trung gian.

Các câu trả lời được chấp nhận hoạt động tốt trong điển hình trường hợp , nhưng thất bại trong cạnh trường hợp , cụ thể là:

• Đối với tên tệp không có phần mở rộng (được gọi là hậu tố trong phần còn lại của câu trả lời này), extension=${filename##*.}trả về tên tệp đầu vào thay vì một chuỗi trống.
• extension=${filename##*.}không bao gồm ban đầu ., trái với quy ước.
  • Chuẩn bị mù quáng .sẽ không hoạt động cho tên tệp mà không có hậu tố.
• filename="${filename%.*}"sẽ là chuỗi rỗng, nếu tên tệp đầu vào bắt đầu bằng .và không chứa thêm .ký tự nào (ví dụ .bash_profile:) trái với quy ước.

---------

Do đó, sự phức tạp của một giải pháp mạnh mẽ bao gồm tất cả các trường hợp cạnh yêu cầu một hàm - xem định nghĩa của nó bên dưới; nó có thể trả về tất cả các thành phần của một đường dẫn .

Cuộc gọi ví dụ:

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

Lưu ý rằng các đối số sau đường dẫn đầu vào được tự do chọn, tên biến vị trí .
Để bỏ qua các biến không quan tâm đến trước các biến đó, chỉ định _(sử dụng biến ném đi $_) hoặc ''; ví dụ, để trích xuất tên tập tin gốc và phần mở rộng, sử dụng 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

Mã kiểm tra thực hiện chức năng:

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

Đầu ra dự kiến ​​- lưu ý các trường hợp cạnh:

• một tên tệp không có hậu tố
• một tên tệp bắt đầu bằng .( không được coi là bắt đầu của hậu tố)
• một đường dẫn đầu vào kết thúc bằng /(trailing /bị bỏ qua)
• một đường dẫn đầu vào chỉ là một tên tệp ( .được trả về làm đường dẫn cha)
• một tên tệp có nhiều hơn .mã thông báo -prefixed (chỉ cuối cùng được coi là hậu tố):

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

Giải pháp nhỏ nhất và đơn giản nhất (trong một dòng) là:

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

Tôi nghĩ rằng nếu bạn chỉ cần tên của tệp, bạn có thể thử điều này:

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"

Và đó là tất cả = D.

Bạn có thể buộc cắt để hiển thị tất cả các trường và những trường tiếp theo thêm -vào số trường.

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

Vì vậy, nếu FILE là eth0.pcap.gz, EXTENSION sẽ làpcap.gz

Sử dụng cùng logic, bạn cũng có thể tìm nạp tên tệp bằng cách sử dụng '-' với cách cắt như sau:

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

Điều này hoạt động ngay cả đối với tên tệp không có bất kỳ phần mở rộng.

Nhận dạng tập tin ma thuật

Ngoài rất nhiều câu trả lời hay cho câu hỏi Stack Overflow này, tôi muốn thêm vào:

Trong Linux và unixen khác, có một lệnh ma thuật được đặt tên file, đó là phát hiện filetype bằng cách phân tích một số byte đầu tiên của tệp. Đây là một công cụ rất cũ, ban đầu được sử dụng cho các máy chủ in (nếu không được tạo cho ... Tôi không chắc về điều đó).

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

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

Các phần mở rộng tiêu chuẩn có thể được tìm thấy trong /etc/mime.types(trên máy tính để bàn Debian GNU / Linux của tôi . Xem man filevà man mime.types. Có lẽ bạn phải cài đặt filetiện ích và mime-supportgói):

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

Bạn có thể tạo một bashchức năng xác định mở rộng đúng. Có một mẫu nhỏ (không hoàn hảo):

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

Hàm này có thể đặt biến Bash có thể được sử dụng sau:

(Điều này được lấy cảm hứng từ câu trả lời đúng @Petesh):

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

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

Ok, nếu tôi hiểu chính xác, vấn đề ở đây là làm thế nào để có được tên và phần mở rộng đầy đủ của một tệp có nhiều phần mở rộng, ví dụ : stuff.tar.gz.

Điều này làm việc cho tôi:

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

Điều này sẽ cung cấp cho bạn stuffnhư tên tệp và .tar.gznhư phần mở rộng. Nó hoạt động cho bất kỳ số lượng tiện ích mở rộng nào, bao gồm 0. Hy vọng điều này sẽ giúp cho bất kỳ ai có cùng vấn đề =)

Tôi sử dụng đoạn script sau

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

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

Điều này phục vụ cho nhiều dấu chấm và khoảng trắng trong một tên tệp, tuy nhiên nếu không có phần mở rộng thì nó sẽ trả về tên tệp đó. Dễ dàng kiểm tra mặc dù; chỉ cần kiểm tra tên tệp và phần mở rộng là như nhau.

Đương nhiên phương pháp này không hoạt động đối với các tệp .tar.gz. Tuy nhiên, điều đó có thể được xử lý trong một quá trình hai bước. Nếu phần mở rộng là gz thì hãy kiểm tra lại xem có phần mở rộng tar không.

Cách trích xuất tên tệp và phần mở rộng trong cá :

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

Hãy cẩn thận: Chia tách trên dấu chấm cuối cùng, hoạt động tốt cho tên tệp có dấu chấm trong đó, nhưng không tốt cho phần mở rộng có dấu chấm trong đó. Xem ví dụ dưới đây.

Sử dụng:

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

Có lẽ có nhiều cách tốt hơn để làm điều này. Hãy chỉnh sửa câu trả lời của tôi để cải thiện nó.

Nếu có một bộ tiện ích mở rộng giới hạn mà bạn sẽ xử lý và bạn biết tất cả các tiện ích mở rộng, hãy thử điều này:

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

Điều này không có sự cảnh báo như ví dụ đầu tiên, nhưng bạn phải xử lý mọi trường hợp để nó có thể tẻ nhạt hơn tùy thuộc vào số lượng tiện ích mở rộng bạn có thể mong đợi.

Đây là mã với AWK . Nó có thể được thực hiện đơn giản hơn. Nhưng tôi không giỏi trong 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

Đơn giản chỉ cần sử dụng ${parameter%word}

Trong trường hợp của bạn:

${FILE%.*}

Nếu bạn muốn kiểm tra nó, tất cả các công việc sau đây và chỉ cần xóa tiện ích mở rộng:

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

Xây dựng từ câu trả lời của Petesh , nếu chỉ cần tên tệp, cả đường dẫn và phần mở rộng có thể bị tước trong một dòng,

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

Dựa chủ yếu vào sự xuất sắc của @ mkuity0, và đầy ắp những bashism ngẫu nhiên, hữu ích - cũng như những câu trả lời khác cho câu hỏi này / những câu hỏi khác / "cái internet chết tiệt đó" ... Tôi gói gọn lại một chút, dễ hiểu hơn một chút, chức năng có thể sử dụng lại cho tôi (hoặc của bạn) .bash_profile, người quan tâm đến những gì (tôi cho là) ​​sẽ là phiên bản mạnh mẽ hơn của dirname/ basename/ những gì có bạn ..

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
}     

Ví dụ sử dụng ...

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>

Một câu trả lời đơn giản:

Để mở rộng câu trả lời cho các biến POSIX , lưu ý rằng bạn có thể thực hiện các mẫu thú vị hơn. Vì vậy, đối với trường hợp chi tiết ở đây, bạn chỉ cần làm điều này:

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

Điều đó sẽ cắt đứt sự xuất hiện cuối cùng của .tar. <cái gì đó> .

Tổng quát hơn, nếu bạn muốn loại bỏ sự xuất hiện cuối cùng của. <cái gì đó> . <cái gì đó khác> sau đó

${1.*.*}

nên làm việc tốt

Liên kết câu trả lời trên dường như đã chết. Đây là một lời giải thích tuyệt vời về một loạt các thao tác chuỗi mà bạn có thể thực hiện trực tiếp trong Bash, từ TLDP .

Nếu bạn cũng muốn cho phép các tiện ích mở rộng trống , đây là lần ngắn nhất tôi có thể nghĩ ra:

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

Dòng thứ 1 giải thích: Nó khớp với PATH.EXT hoặc BẤT CỨ NÀO và thay thế nó bằng EXT. Nếu MỌI THỨ đã được khớp, nhóm ext sẽ không bị bắt.

Đây là người duy nhất làm việc cho tôi:

path='folder/other_folder/file.js'

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

>> file

Điều này cũng có thể được sử dụng trong nội suy chuỗi, nhưng thật không may, bạn phải đặt basetrước.

Đây là thuật toán tôi đã sử dụng để tìm tên và phần mở rộng của tệp khi tôi viết tập lệnh Bash để làm cho tên duy nhất khi tên xung đột với vỏ.

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

Việc chạy thử.

$ 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: Chương trình chuyển ngữ hoàn chỉnh và nhiều trường hợp kiểm tra có thể được tìm thấy ở đây: https://www.dropbox.com/s/4c6m0f2e28a1vxf/avoid-clashes-code.zip?dl=0

Sử dụng tệp ví dụ /Users/Jonathan/Scripts/bash/MyScript.sh, mã này:

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

sẽ cho kết quả ${ME}là MyScriptvà ${MY_EXT}là .sh:

Kịch bản:

#!/bin/bash
set -e

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

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

Một số xét nghiệm:

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

Từ các câu trả lời ở trên, oneliner ngắn nhất để bắt chước Python

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

giả sử tập tin của bạn thực sự có một phần mở rộng, là

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