ฉันต้องการรับชื่อไฟล์ (ไม่มีส่วนขยาย) และส่วนขยายแยกต่างหาก

ทางออกที่ดีที่สุดที่ฉันพบคือ:

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

สิ่งนี้ผิดเพราะใช้งานไม่ได้หากชื่อไฟล์มี.อักขระหลายตัว ถ้าสมมติว่าผมมีa.b.jsก็จะพิจารณาaและb.jsแทนและa.bjs

สามารถทำได้อย่างง่ายดายใน Python ด้วย

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

แต่ฉันไม่ต้องการที่จะไล่ล่าล่ามงูใหญ่สำหรับเรื่องนี้ถ้าเป็นไปได้

มีความคิดที่ดีกว่านี้ไหม?

ก่อนอื่นรับชื่อไฟล์โดยไม่มีพา ธ :

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

หรือคุณสามารถมุ่งเน้นไปที่ '/' สุดท้ายของเส้นทางแทนที่จะเป็น '.' ซึ่งควรทำงานแม้ว่าคุณจะมีนามสกุลไฟล์ที่ไม่แน่นอน:

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

คุณอาจต้องการตรวจสอบเอกสาร:

• บนเว็บที่ส่วน " การขยายพารามิเตอร์เชลล์ 3.5.3 "
• ใน bash manpage ที่ส่วนที่เรียกว่า "การขยายพารามิเตอร์"

~% 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 / ไฟล์:
    dir = "/ home / me /"
    base = "ไฟล์"
    ext = ""
/home/me/file.tar:
    dir = "/ home / me /"
    base = "ไฟล์"
    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 $1
cd $(basename $1 .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แทนที่"."อักขระตามด้วยจำนวน"."อักขระที่ไม่ใช่อักขระใด ๆจนถึงจุดสิ้นสุดของบรรทัดโดยที่ไม่มีสิ่งใด (เช่นจะลบทุกอย่างออกจากรอบชิงชนะเลิศ"."ไปยังจุดสิ้นสุดของบรรทัดรวม) นี่คือการทดแทนที่ไม่โลภโดยใช้กลอุบาย regex

คำสั่งสำหรับEXTENSIONแทนที่จำนวนอักขระใด ๆ ตามด้วย"."อักขระที่จุดเริ่มต้นของบรรทัดโดยไม่มีสิ่งใด (กล่าวคือจะลบทุกอย่างจากจุดเริ่มต้นของบรรทัดไปจนถึงจุดสุดท้ายรวมอยู่ด้วย) นี่เป็นการทดแทนโลภซึ่งเป็นการกระทำเริ่มต้น

เมลเลนเขียนความคิดเห็นในบล็อกโพสต์:

การใช้ Bash ${file%.*}จะต้องมีชื่อไฟล์โดยไม่มีนามสกุลและ${file##*.}เพื่อให้ได้นามสกุลเท่านั้น นั่นคือ,

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

ขาออก:

filename: thisfile
extension: txt

ไม่จำเป็นต้องรำคาญกับawkหรือsedหรือแม้กระทั่งperlสำหรับงานนี้ง่าย มี pure-Bash, - os.path.splitext()โซลูชันที่เข้ากันได้ซึ่งใช้การขยายพารามิเตอร์เท่านั้น

การดำเนินการอ้างอิง

เอกสารของos.path.splitext(path):

แยกพา ธ ชื่อพา ธ เป็นคู่(root, ext)เช่นนั้นroot + ext == pathและextจะว่างเปล่าหรือเริ่มต้นด้วยจุดและมีอย่างน้อยหนึ่งช่วงเวลา ช่วงเวลานำในชื่อฐานจะถูกละเว้น ผลตอบแทนsplitext('.cshrc')('.cshrc', '')

รหัสหลาม:

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

ผลการทดสอบ

การทดสอบทั้งหมดผ่าน

คุณสามารถใช้cutคำสั่งเพื่อลบสองนามสกุลสุดท้าย ( ".tar.gz"ส่วน):

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

ตามที่ระบุไว้โดย Clayton Hughes ในความคิดเห็นสิ่งนี้จะไม่ทำงานสำหรับตัวอย่างที่แท้จริงในคำถาม ดังนั้นทางเลือกที่ฉันเสนอให้ใช้sedกับนิพจน์ทั่วไปที่ขยายเพิ่มเช่นนี้

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

มันทำงานได้โดยการลบส่วนขยาย (ตัวเลขและตัวอักษร) สองตัวสุดท้ายโดยไม่มีเงื่อนไข

[อัปเดตอีกครั้งหลังจากความคิดเห็นจาก Anders Lindahl]

ต่อไปนี้เป็นคำแนะนำทางเลือกอื่น ๆ (โดยส่วนใหญ่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(/[^.]*[.]/, "", $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 '^[/]\|^~/'

กรณีการใช้งานทั้งหมดกำลังใช้เส้นทางแบบเต็มต้นฉบับเป็นอินพุตโดยไม่ขึ้นอยู่กับผลลัพธ์ระดับกลาง

คำตอบที่ได้รับการยอมรับทำงานได้ดีในแบบฉบับกรณีแต่ล้มเหลวในการขอบกรณีกล่าวคือ:

• สำหรับชื่อไฟล์ที่ไม่มีนามสกุล (เรียกว่าคำต่อท้ายในส่วนที่เหลือของคำตอบนี้) 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 "$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

รหัสทดสอบที่ฝึกใช้งานฟังก์ชั่น:

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

โซลูชันที่เล็กที่สุดและง่ายที่สุด (ในบรรทัดเดียว) คือ:

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

ฉันคิดว่าถ้าคุณต้องการชื่อไฟล์คุณสามารถลอง:

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"

และนั่นคือทั้งหมด = D

คุณสามารถบังคับให้ตัดเพื่อแสดงฟิลด์ทั้งหมดและฟิลด์ที่ตามมาเพิ่ม-ลงในหมายเลขฟิลด์

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

ดังนั้นหากไฟล์คือeth0.pcap.gzส่วนขยายจะเป็นpcap.gz

ด้วยตรรกะเดียวกันคุณสามารถดึงชื่อไฟล์โดยใช้ '-' โดยมีการตัดดังนี้:

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

วิธีนี้ใช้ได้แม้กับชื่อไฟล์ที่ไม่มีส่วนขยายใด ๆ

การรับรู้ไฟล์มายากล

นอกจากคำตอบที่ดีมากมายสำหรับคำถาม Stack Overflow ฉันต้องการเพิ่ม:

ภายใต้ 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 "$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##*[/.-]}
}

ฟังก์ชันนี้สามารถตั้งค่าตัวแปร Bash ที่สามารถใช้ได้ในภายหลัง:

(นี่เป็นแรงบันดาลใจจากคำตอบที่ถูกต้องของ @Petesh):

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

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

stuff.tar.gzตกลงดังนั้นถ้าผมเข้าใจถูกต้องปัญหาที่นี่คือวิธีการที่จะได้รับชื่อและนามสกุลเต็มรูปแบบของไฟล์ที่มีนามสกุลหลายเช่น

สิ่งนี้ใช้ได้กับฉัน:

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

สิ่งนี้จะให้คุณstuffเป็นชื่อไฟล์และ.tar.gzเป็นส่วนขยาย มันใช้งานได้กับจำนวนส่วนขยายใด ๆ รวมถึง 0 หวังว่านี่จะช่วยได้สำหรับทุกคนที่มีปัญหาเดียวกัน =)

ฉันใช้สคริปต์ต่อไปนี้

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

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

สิ่งนี้เหมาะสำหรับจุดและช่องว่างหลายจุดในชื่อไฟล์อย่างไรก็ตามหากไม่มีส่วนขยายก็จะส่งคืนชื่อไฟล์เอง ง่ายต่อการตรวจสอบว่า; เพียงทดสอบชื่อไฟล์และส่วนขยายที่เหมือนกัน

โดยปกติวิธีการนี้ใช้ไม่ได้กับไฟล์. tar.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

Caveats:แยกที่จุดสุดท้ายซึ่งทำงานได้ดีสำหรับชื่อไฟล์ที่มีจุดอยู่ในจุดนั้น แต่ไม่เหมาะสำหรับส่วนขยายที่มีจุดในจุดนั้น ดูตัวอย่างด้านล่าง

การใช้งาน:

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

เพียงใช้ ${parameter%word}

ในกรณีของคุณ:

${FILE%.*}

หากคุณต้องการที่จะทดสอบมันทำงานต่อไปนี้ทั้งหมดและเพียงแค่ลบส่วนขยาย:

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

การสร้างจากคำตอบของPeteshหากต้องการเพียงชื่อไฟล์ทั้งเส้นทางและส่วนขยายสามารถแยกเป็นบรรทัดเดียว

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

ส่วนใหญ่มาจาก @ 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
    [[ $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
}     

ตัวอย่างการใช้ ...

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>

คำตอบง่ายๆ:

หากต้องการขยายคำตอบของตัวแปร POSIXโปรดทราบว่าคุณสามารถทำรูปแบบที่น่าสนใจมากขึ้น ดังนั้นสำหรับรายละเอียดที่นี่คุณสามารถทำสิ่งนี้ได้:

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

ที่จะตัดการเกิดขึ้นครั้งสุดท้ายของ. tar <บางสิ่งบางอย่าง>

โดยทั่วไปหากคุณต้องการลบการเกิดขึ้นครั้งสุดท้ายของ <บางสิ่งบางอย่าง> <บางสิ่ง - อื่น ๆ >จากนั้น

${1.*.*}

ควรทำงานได้ดี

ลิงก์คำตอบข้างต้นดูเหมือนว่าจะตาย นี่คือคำอธิบายที่ดีของพวงของการจัดการสตริงที่คุณสามารถทำได้โดยตรงในการทุบตีจาก TLDP

หากคุณต้องการอนุญาตให้มีส่วนขยายที่ว่างเปล่านี่คือระยะทางสั้นที่สุดที่ฉันสามารถทำได้:

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

บรรทัดแรกอธิบาย: มันตรงกับ PATH.EXT หรืออะไรก็ได้และแทนที่ด้วย EXT หากมีสิ่งใดตรงกันกลุ่ม ext จะไม่ถูกจับ

นี่เป็นสิ่งเดียวที่ทำงานสำหรับฉัน:

path='folder/other_folder/file.js'

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

>> file

สามารถใช้ในการแก้ไขสตริงได้เช่นกัน แต่น่าเสียดายที่คุณต้องตั้งค่าbaseไว้ล่วงหน้า

นี่คืออัลกอริทึมที่ฉันใช้ในการค้นหาชื่อและนามสกุลของไฟล์เมื่อฉันเขียนสคริปต์ 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[@]}"
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

ใช้ไฟล์ตัวอย่าง/Users/Jonathan/Scripts/bash/MyScript.shรหัสนี้:

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

จะมีผลใน${ME}การเป็นMyScriptและ${MY_EXT}เป็น.sh:

สคริปต์:

#!/bin/bash
set -e

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

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

การทดสอบบางอย่าง:

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

จากคำตอบข้างต้นผู้แปลที่สั้นที่สุดถึงเลียนแบบ Python

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

สมมติว่าไฟล์ของคุณมีนามสกุลจริง ๆ คือ

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