วิธีที่สั้นที่สุดในการแยก 3 ชื่อสุดท้ายของชื่อไฟล์ฐาน (ลบด้วยคำต่อท้าย)

ฉันพยายามตั้งค่าตัวแปรในสคริปต์ sh เป็น 3 ตัวอักษรสุดท้ายของชื่อฐานของไฟล์ (โดยชื่อฐานฉันหมายถึงไม่มีเส้นทางและไม่มีคำต่อท้าย) ฉันประสบความสำเร็จในการทำสิ่งนี้ แต่ด้วยความอยากรู้อยากเห็นอย่างหมดจดฉันสงสัยว่ามีคำสั่งสั้นเพียงคำเดียวที่ฉันสามารถใช้ได้ เดิมทีฉันมีซับในด้วยawkแต่มันค่อนข้างยาว ขณะนี้ฉันมีสคริปต์สองบรรทัดนี้ (สมมติว่ามีชื่อไฟล์ที่สมบูรณ์อยู่$1):

filebase=`basename "$1"`
lastpart=`echo -n ${filebase%.*} | tail -c3`

ดังนั้นสำหรับตัวอย่างเช่น"/path/to/somefile.txt"จบลงด้วย"ile"$lastpartใน

ฉันสามารถรวมbasenameและบิตเพื่อตัดส่วนต่อท้ายเป็นคำสั่งเดียวได้หรือไม่และมีวิธีส่งไปยังtail(หรืออย่างอื่นที่ฉันสามารถใช้ได้) โดยไม่ต้องใช้ไพพ์หรือไม่? ไม่รู้จักคำต่อท้ายดังนั้นฉันไม่สามารถยึดเป็นพารามิเตอร์basenameได้

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

นั่นเป็นงานทั่วไปสำหรับexpr:

$ file=/path/to/abcdef.txt
$ expr "/$file" : '.*\([^/.]\{3\}\)\.[^/.]*$'
def

หากคุณรู้ว่าชื่อไฟล์ของคุณมีรูปแบบที่คาดหวัง (มีจุดหนึ่งจุดและมีเพียงหนึ่งจุดและอย่างน้อย 3 ตัวอักษรก่อนจุด) ซึ่งสามารถทำให้ง่ายขึ้นเพื่อ:

expr "/$file" : '.*\(.\{3\}\)\.'

โปรดทราบว่าสถานะการออกจะไม่เป็นศูนย์หากไม่มีการจับคู่ แต่ยังหากส่วนที่จับคู่เป็นตัวเลขที่เปลี่ยนเป็น 0 (เช่นสำหรับa000.txtหรือa-00.txt)

ด้วยzsh:

file=/path/to/abcdef.txt
lastpart=${${file:t:r}[-3,-1]}

( :tสำหรับหาง (basename) :rสำหรับส่วนที่เหลือ (ที่มีนามสกุลออก))

var=123456
echo "${var#"${var%???}"}"

###OUTPUT###

456

ที่เอาครั้งแรกในช่วงสามตัวละครจาก$varนั้นเอามาจาก$varผลของการกำจัดว่า - $varซึ่งผลตอบแทนที่ผ่านมาสามตัวละคร นี่คือตัวอย่างบางส่วนที่มีจุดมุ่งหมายเพื่อแสดงให้เห็นถึงวิธีที่คุณอาจทำสิ่งนั้นโดยเฉพาะ:

touch file.txt
path=${PWD}/file.txt
echo "$path"

/tmp/file.txt

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

file
txt
file.txt
/tmp/file.txt

คุณไม่ต้องกระจายสิ่งเหล่านี้ทั้งหมดผ่านคำสั่งมากมาย คุณสามารถกระชับสิ่งนี้:

{
    base=${path##*/} exten= 
    printf %s\\n "${base%.*}" "${exten:=${base#"${base%???}"}}" "$base" "$path"
    echo "$exten"
}

file 
txt 
file.txt 
/tmp/file.txt
txt

การรวม$IFSกับsetพารามิเตอร์ ting shell สามารถเป็นวิธีการแยกวิเคราะห์และเจาะผ่านตัวแปรเชลล์ที่มีประสิทธิภาพมาก:

(IFS=. ; set -f; set -- ${path##*/}; printf %s "${1#"${1%???}"}")

ที่คุณจะได้รับเพียงตัวละครทั้งสามทันทีก่อนช่วงแรกต่อไปนี้ที่ผ่านมาใน/ $pathหากคุณต้องการที่จะดึงเฉพาะอักขระสามตัวแรกทันทีก่อนที่สุดท้าย.ใน$path (เช่นถ้ามีความเป็นไปได้มากกว่าหนึ่ง.ในชื่อไฟล์) :

(IFS=.; set -f; set -- ${path##*/}; ${3+shift $(($#-2))}; printf %s "${1#"${1%???}"}")

ในทั้งสองกรณีคุณสามารถทำได้:

newvar=$(IFS...)

และ...

(IFS...;printf %s "$2")

... จะพิมพ์สิ่งที่ตามมา .

หากคุณไม่รังเกียจการใช้โปรแกรมภายนอกคุณสามารถทำได้:

printf %s "${path##*/}" | sed 's/.*\(...\)\..*/\1/'

หากมีโอกาสของ\nอักขระ ewline ในชื่อไฟล์(ไม่สามารถใช้กับโซลูชันเชลล์เนทีฟ - มันจะจัดการกับสิ่งนั้นอยู่ดี) :

printf %s "${path##*/}" | sed 'H;$!d;g;s/.*\(...\)\..*/\1/'

หากคุณสามารถใช้perl:

lastpart=$(
    perl -e 'print substr((split(/\.[^.]*$/,shift))[0], -3, 3)
            ' -- "$(basename -- "$1")"
)

sed ใช้งานได้สำหรับสิ่งนี้:

[user@host ~]$ echo one.two.txt | sed -r 's|(.*)\..*$|\1|;s|.*(...)$|\1|'
two

หรือ

[user@host ~]$ sed -r 's|(.*)\..*$|\1|;s|.*(...)$|\1|' <<<one.two.txt
two

ถ้าคุณsedไม่สนับสนุน-rเพียงแทนที่อินสแตนซ์ของ()ด้วย\(และ\)จากนั้น-rไม่จำเป็นต้อง

ถ้า perl พร้อมใช้งานฉันพบว่าสามารถอ่านได้มากกว่าโซลูชันอื่น ๆ โดยเฉพาะเนื่องจากภาษา regex นั้นมีความชัดเจนและมี/xตัวแก้ไขซึ่งอนุญาตให้เขียน regex ที่ชัดเจนกว่า:

perl -e 'print $1 if shift =~ m{ ( [^/]{3} ) [.] [^./]* \z }x' -- "$file"

สิ่งนี้จะพิมพ์อะไรถ้าไม่มีการจับคู่ดังกล่าว (ถ้าชื่อฐานไม่มีส่วนขยายหรือถ้ารากก่อนส่วนขยายสั้นเกินไป) คุณสามารถปรับ regex ได้ทั้งนี้ขึ้นอยู่กับความต้องการของคุณ regex นี้บังคับใช้ข้อ จำกัด :

1. มันตรงกับ 3 ตัวอักษรก่อนที่จะขยายสุดท้าย (ส่วนหลังและรวมถึงจุดสุดท้าย) อักขระ 3 ตัวเหล่านี้สามารถมีจุดได้
2. ส่วนขยายสามารถว่างเปล่า (ยกเว้นจุด)
3. ส่วนที่ตรงกันและส่วนขยายจะต้องเป็นส่วนหนึ่งของชื่อฐาน (ส่วนหลังสแลชสุดท้าย)

การใช้สิ่งนี้ในการทดแทนคำสั่งมีปัญหาปกติในการลบบรรทัดใหม่ที่ต่อท้ายมากเกินไปซึ่งเป็นปัญหาที่ส่งผลต่อคำตอบของStéphane สามารถจัดการได้ทั้งสองกรณี แต่ง่ายกว่าเล็กน้อยที่นี่:

lastpart=$(
  perl -e 'print "$1x" if shift =~ m{ ( [^/]{3} ) [.] [^./]* \z }x' -- "$file"
)
lastpart=${lastpart%x}  # allow for possible trailing newline

Python2.7

$ echo /path/to/somefile.txt | python -c "import sys, os; print '.'.join(os.path.basename(sys.stdin.read()).split('.')[:-1])[-3:]"
ile

$ echo file.one.two.three | python -c "import sys, os; print '.'.join(os.path.basename(sys.stdin.read()).split('.')[:-1])[-3:]"
two

ฉันคิดว่าฟังก์ชั่นทุบตีนี้ pathStr () จะทำสิ่งที่คุณกำลังมองหา

ไม่ต้องการ awk, sed, grep, perl หรือ expr ใช้ bash builtins เท่านั้นดังนั้นมันจึงค่อนข้างเร็ว

ฉันยังได้รวมฟังก์ชัน argsNumber และ isOption ที่พึ่งพาได้ด้วย

ifHelpShow ฟังก์ชั่นขึ้นอยู่ไม่ได้รวมในขณะที่มันมี subdependencies มากมายสำหรับการแสดงผลข้อความช่วยเหลือทั้งใน commandline ขั้วหรือกล่องโต้ตอบ GUI ผ่านYad ข้อความช่วยเหลือที่ส่งไปยังเอกสารนี้จะรวมอยู่ในเอกสาร ให้คำแนะนำหากคุณต้องการความช่วยเหลือหากแสดงและผู้ติดตาม

function  pathStr () {
  ifHelpShow "$1" 'pathStr --OPTION FILENAME
    Given FILENAME, pathStr echos the segment chosen by --OPTION of the
    "absolute-logical" pathname. Only one segment can be retrieved at a time and
    only the FILENAME string is parsed. The filesystem is never accessed, except
    to get the current directory in order to build an absolute path from a relative
    path. Thus, this function may be used on a FILENAME that does not yet exist.
    Path characteristics:
        File paths are "absolute" or "relative", and "logical" or "physical".
        If current directory is "/root", then for "bashtool" in the "sbin" subdirectory ...
            Absolute path:  /root/sbin/bashtool
            Relative path:  sbin/bashtool
        If "/root/sbin" is a symlink to "/initrd/mnt/dev_save/share/sbin", then ...
            Logical  path:  /root/sbin/bashtool
            Physical path:  /initrd/mnt/dev_save/share/sbin/bashtool
                (aka: the "canonical" path)
    Options:
        --path  Absolute-logical path including filename with extension(s)
                  ~/sbin/file.name.ext:     /root/sbin/file.name.ext
        --dir   Absolute-logical path of directory containing FILENAME (which can be a directory).
                  ~/sbin/file.name.ext:     /root/sbin
        --file  Filename only, including extension(s).
                  ~/sbin/file.name.ext:     file.name.ext
        --base  Filename only, up to last dot(.).
                  ~/sbin/file.name.ext:     file.name
        --ext   Filename after last dot(.).
                  ~/sbin/file.name.ext:     ext
    Todo:
        Optimize by using a regex to match --options so getting argument only done once.
    Revised:
        20131231  docsalvage'  && return
  #
  local _option="$1"
  local _optarg="$2"
  local _cwd="$(pwd)"
  local _fullpath=
  local _tmp1=
  local _tmp2=
  #
  # validate there are 2 args and first is an --option
  [[ $(argsNumber "$@") != 2 ]]                        && return 1
  ! isOption "$@"                                      && return 1
  #
  # determine full path of _optarg given
  if [[ ${_optarg:0:1} == "/" ]]
  then
    _fullpath="$_optarg"
  else
    _fullpath="$_cwd/$_optarg"
  fi
  #
  case "$_option" in
   --path)  echo "$_fullpath"                            ; return 0;;
    --dir)  echo "${_fullpath%/*}"                       ; return 0;;
   --file)  echo "${_fullpath##*/}"                      ; return 0;;
   --base)  _tmp1="${_fullpath##*/}"; echo "${_tmp1%.*}" ; return 0;;
    --ext)  _tmp1="${_fullpath##*/}";
            _tmp2="${_tmp1##*.}";
            [[ "$_tmp2" != "$_tmp1" ]]  && { echo "$_tmp2"; }
            return 0;;
  esac
  return 1
}

function argsNumber () {
  ifHelpShow "$1" 'argsNumber "$@"
  Echos number of arguments.
  Wrapper for "$#" or "${#@}" which are equivalent.
  Verified by testing on bash 4.1.0(1):
      20140627 docsalvage
  Replaces:
      argsCount
  Revised:
      20140627 docsalvage'  && return
  #
  echo "$#"
  return 0
}

function isOption () {
  # isOption "$@"
  # Return true (0) if argument has 1 or more leading hyphens.
  # Example:
  #     isOption "$@"  && ...
  # Note:
  #   Cannot use ifHelpShow() here since cannot distinguish 'isOption --help'
  #   from 'isOption "$@"' where first argument in "$@" is '--help'
  # Revised:
  #     20140117 docsalvage
  # 
  # support both short and long options
  [[ "${1:0:1}" == "-" ]]  && return 0
  return 1
}

ทรัพยากร

• http://tldp.org/LDP/abs/html/arrays.html
• /programming/23207168/a-semantics-for-bash-scripts/23208014#23208014