ගොනු නාමය (දිගුවකින් තොරව) සහ දිගුව වෙන වෙනම ලබා ගැනීමට මට අවශ්‍යය.

මම මෙතෙක් සොයාගත් හොඳම විසඳුම නම්:

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

මෙය වැරදියි, මන්ද ගොනුවේ නමේ .අක්ෂර කිහිපයක් තිබේ නම් එය ක්‍රියා නොකරයි . මා සතුව තිබේ නම් a.b.js, එය සලකා බලනු ඇති aඅතර b.js, ඒ වෙනුවට a.bසහ js.

එය පහසුවෙන් පයිතන් සමඟ කළ හැකිය

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

නමුත් මම කැමතියි හැකි නම් මේ සඳහා පයිතන් පරිවර්තකයෙකුට වෙඩි නොතබන්න.

වඩා හොඳ අදහස් තිබේද?

පළමුව, මාර්ගය නොමැතිව ගොනු නාමය ලබා ගන්න:

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

විකල්පයක් ලෙස, ඔබට '' වෙනුවට මාර්ගයේ අවසාන '/' වෙත අවධානය යොමු කළ හැකිය. ඔබට අනපේක්ෂිත ගොනු දිගු තිබුණත් එය ක්‍රියාත්මක විය යුතුය:

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

ඔබට ප්‍රලේඛනය පරීක්ෂා කිරීමට අවශ්‍ය විය හැකිය:

• වෙබයේ " 3.5.3 ෂෙල් පරාමිති පුළුල් කිරීම "
• "පරාමිති පුළුල් කිරීම" යනුවෙන් හැඳින්වෙන කොටසේ ඇති බැෂ් මෑන්පේජ් හි

~% 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 = "ගොනුව"
    ext = ""
/home/me/file.tar:
    dir = "/ home / me /"
    base = "ගොනුව"
    ext = "තාර"
/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 = "තාර"
/ home / me / ..:
    dir = "/ home / me /"
    base = ".."
    ext = ""
.:
    dir = ""
    base = "."
    ext = ""

ඔබට භාවිතා කළ හැකිය basename.

උදාහරණයක්:

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

ඉවත් කළ යුතු දිගුව සමඟ ඔබට මූලික නම ලබා දිය යුතුය, කෙසේ වෙතත් ඔබ සැමවිටම ක්‍රියාත්මක 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ආදේශ කිරීම සඳහා වන විධානය , කිසිවක් නොමැතිව (එනම්, එය අවසන් සිට පේළියේ අවසානය දක්වා සියල්ල ඉවත් කරයි ). මෙය මූලික වශයෙන් රිජෙක්ස් උපක්‍රම භාවිතා කරමින් කෑදර නොවන ආදේශකයකි."."".""."

පේළියේ ආරම්භයේ දී EXTENSIONඅක්ෂරයකින් පසුව ඕනෑම අක්ෂර සංඛ්‍යාවක් ආදේශ කිරීම සඳහා වන විධානය ".", කිසිවක් නොමැතිව (එනම්, එය රේඛාවේ ආරම්භයේ සිට අවසාන තිත දක්වා සියල්ල ඉවත් කරයි). මෙය ගිජු ආදේශනයකි.

බ්ලොග් සටහනක් ගැන අදහස් දක්වමින් මෙලන් මෙසේ ලියයි:

Bash භාවිතා කරමින්, ${file%.*}දිගුවකින් තොරව ගොනු නාමය ${file##*.}ලබා ගැනීමට සහ දිගුව තනිවම ලබා ගැනීමටද ඇත. එනම්,

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

නිමැවුම්:

filename: thisfile
extension: txt

කරදර වෙන්න අවශ්ය නෑ awkහෝ sedපවා perlමෙම සරල කාර්යය සඳහා. os.path.splitext()පරාමිති පුළුල් කිරීම් පමණක් භාවිතා කරන පිරිසිදු-බෑෂ්, අනුකූල විසඳුමක් ඇත.

යොමු ක්‍රියාත්මක කිරීම

ප්‍රලේඛනය os.path.splitext(path):

යුගලයක් බවට pathname මාර්ගය බෙදී (root, ext), එවන් root + ext == path, සහ ඔබ මෙතෙක් හිස් හෝ කාලය ආරම්භ වීමත් සමග බොහෝ එක් කාල දී අඩංගු වේ. මූලික නාමයේ ප්‍රමුඛ කාල පරිච්ඡේද නොසලකා හරිනු ලැබේ; splitext('.cshrc')ප්‍රතිලාභ ('.cshrc', '').

පයිතන් කේතය:

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

බෑෂ් ක්‍රියාත්මක කිරීම

ප්‍රමුඛ කාල පරිච්ඡේදයන්ට ගරු කිරීම

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

ප්‍රමුඛ කාල පරිච්ඡේද නොසලකා හැරීම

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

පරීක්ෂණ

ප්‍රමුඛ ආවර්තයන් නොසලකා හැරීම සඳහා වන පරීක්ෂණ අවස්ථා මෙන්න , එය සෑම ආදානයකම පයිතන් යොමු ක්‍රියාත්මක කිරීමට අනුරූප වේ.

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

සටහනක ක්ලේටන් හියුස් සඳහන් කළ පරිදි, මෙය ප්‍රශ්නයේ සත්‍ය උදාහරණය සඳහා ක්‍රියා නොකරනු ඇත. එබැවින් විකල්පයක් ලෙස මම යෝජනා කරන්නේ මේ ආකාරයට sedදීර් regular නිත්‍ය ප්‍රකාශන භාවිතා කිරීමට ය :

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

එය ක්‍රියාත්මක වන්නේ අවසාන (ඇල්ෆා-සංඛ්‍යාත්මක) දිගු දෙක කොන්දේසි විරහිතව ඉවත් කිරීමෙනි.

[ඇන්ඩර්ස් ලින්ඩාල්ගේ අදහස් දැක්වීමෙන් පසුව නැවත යාවත්කාලීන කරන ලදි]

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"

ඒ සියල්ල = ඩී.

සියලුම ක්ෂේත්‍ර පෙන්වීමට ඔබට කප්පාදුව බල කළ හැකි අතර පසුව ඒවා -ක්ෂේත්‍ර අංකයට එකතු වේ.

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

එබැවින් FILE නම් eth0.pcap.gz, ව්‍යාප්තිය වනු ඇතpcap.gz

එකම තර්කනය භාවිතා කරමින්, ඔබට පහත පරිදි කප්පාදුවෙන් '-' භාවිතා කර ගොනු නාමය ලබා ගත හැකිය:

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

කිසිදු දිගුවක් නොමැති ගොනු නාම සඳහා පවා මෙය ක්‍රියා කරයි.

මැජික් ගොනු හඳුනාගැනීම

මෙම සිරස් පිටාර ගැලීමේ ප්‍රශ්නයට හොඳ පිළිතුරු රාශියකට අමතරව මම එකතු කිරීමට කැමතියි:

ලිනක්ස් සහ වෙනත් යුනික්සෙන් යටතේ, මැජික් විධානයක් නම් කර ඇත file, එය ගොනුවේ පළමු බයිට් කිහිපයක් විශ්ලේෂණය කිරීමෙන් ගොනු ටයිප් හඳුනාගැනීම සිදු කරයි. මෙය ඉතා පැරණි මෙවලමක් වන අතර මුලික වශයෙන් මුද්‍රණ සේවාදායකයන් සඳහා භාවිතා වේ (නිර්මාණය කර නොමැති නම් ... මට ඒ ගැන විශ්වාස නැත).

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

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

ප්‍රමිති දිගු සොයා ගත හැකිය /etc/mime.types(මගේ ඩේබියන් ග්නූ / ලිනක්ස් ඩෙස්ක්ටොප් එකේ. බලන්න 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

ඔබට a නිර්මාණය කළ හැකිය bashනිවැරදි දිගුව තීරණය කිරීමේ කාර්යය. කුඩා (පරිපූර්ණ නොවේ) නියැදියක් ඇත:

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 නම් තාර දිගුවක් ද තිබේදැයි බැලීමට නැවත පරීක්ෂා කරන්න.

මාළු වල ගොනු නාමය සහ දිගුව උකහා ගන්නේ කෙසේද :

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%.*};

බොහෝ දුරට @ mklement0 හි විශිෂ්, හා අහඹු, ප්‍රයෝජනවත් බැෂිම් වලින් පිරී ඇත - මෙන්ම මෙම / වෙනත් ප්‍රශ්න වලට පිළිතුරු / "එම අන්තර්ජාලය" ... මම ඒ සියල්ල මඳක් ඔතා, තරමක් තේරුම්ගත හැකි, මගේ (හෝ ඔබගේ) නැවත භාවිතා කළ හැකි කාර්යය.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>

පීටෙෂ් පිළිතුරෙන් ගොඩනැගීම , ගොනු නාමය පමණක් අවශ්‍ය නම්, මාර්ගය සහ දිගුව යන දෙකම තනි පේළියකින් ඉවත් කළ හැකිය,

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

සරල පිළිතුරක්:

POSIX විචල්ය පිළිතුරු පුළුල් කිරීම සඳහා , ඔබට වඩාත් රසවත් රටා කළ හැකි බව සලකන්න. එබැවින් මෙහි විස්තර කර ඇති නඩුව සඳහා, ඔබට මෙය කළ හැකිය:

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

එය .tar හි අවසාන සිදුවීම කපා දමනු ඇත. <something> .

වඩාත් සාමාන්‍යයෙන්, ඔබට අවසාන සිදුවීම ඉවත් කිරීමට අවශ්‍ය නම්. <something> . <something-else> එවිට

${1.*.*}

හොඳින් වැඩ කළ යුතුයි.

ඉහත පිළිතුර සබැඳිය මිය ගොස් ඇති බව පෙනේ. ටීඑල්ඩීපී වෙතින් ඔබට කෙලින්ම බාෂ් හි කළ හැකි නූල් හැසිරවීමේ පොකුරක් පිළිබඳ විශිෂ්ට පැහැදිලි කිරීමක් මෙන්න .

ඔබටත් හිස් දිගුවන්ට ඉඩ දීමට අවශ්‍ය නම්, මට ඉදිරිපත් කළ හැකි කෙටිම කාලය මෙයයි:

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

1 වන පේළිය පැහැදිලි කර ඇත: එය PATH.EXT හෝ ANYTHING සමඟ ගැලපෙන අතර එය EXT සමඟ ප්‍රතිස්ථාපනය කරයි. කිසිවක් ගැලපෙන්නේ නම්, අමතර කණ්ඩායම අල්ලා නොගනී.

මා වෙනුවෙන් වැඩ කළ එකම එක මෙයයි:

path='folder/other_folder/file.js'

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

>> file

මෙය නූල් අන්තර් මැදිහත්වීමේදීද භාවිතා කළ හැකිය, නමුත් අවාසනාවකට ඔබ baseකලින් සැකසිය යුතුය.

ආවරණයක් සම්බන්ධයෙන් නම් ගැටෙන විට නම් අද්විතීය කිරීමට නම් මම බාෂ් ස්ක්‍රිප්ට් එකක් ලියන විට ගොනුවක නම සහ දිගුව සොයා ගැනීම සඳහා භාවිතා කළ ඇල්ගොරිතම මෙන්න.

#! /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}පැවැත්මේ ප්‍රති result ලය වනු ඇත .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

ඉහත පිළිතුරු වලින්, පයිතන් අනුකරණය කිරීමට කෙටිම ඔනලයිනර් ය

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

ඔබේ ගොනුවට දිගුවක් තිබේ යැයි උපකල්පනය කිරීම

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