Cách ngắn nhất để trích xuất 3 ký tự cuối cùng của tên tệp cơ sở (trừ hậu tố)

Tôi đang cố gắng đặt một biến trong tập lệnh sh thành 3 ký tự cuối cùng của tên cơ sở của tệp (theo tên cơ sở tôi có nghĩa là không có đường dẫn và không có hậu tố). Tôi đã thành công trong việc này, nhưng vì tò mò, tôi tự hỏi liệu tôi có thể sử dụng một lệnh ngắn hơn, ngắn hơn không. Ban đầu tôi có một lớp lót với awk, nhưng nó khá dài. Hiện tại tôi có tập lệnh hai dòng này (giả sử tên tệp hoàn chỉnh nằm trong $1):

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

Vì vậy, ví dụ, "/path/to/somefile.txt" đầu ra "ile" trong $lastpart.

Tôi có thể bằng cách nào đó kết hợp basenamevà bit để tách hậu tố thành một lệnh duy nhất không, và có cách nào để gửi nó đến tail(hoặc một cái gì khác tôi có thể sử dụng) mà không cần sử dụng đường ống không? Hậu tố không rõ vì vậy tôi không thể đặt nó làm tham số basename.

Mục tiêu chính thực sự không phải là quá ngắn để có thể càng ngắn càng tốt, càng nhanh càng dễ đọc. Bối cảnh thực tế của tất cả những điều này là câu hỏi này trên Superuser , nơi tôi đang cố gắng đưa ra một câu trả lời khá đơn giản.

Đó là một công việc điển hình cho expr :

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

Nếu bạn biết tên tệp của mình có định dạng mong đợi (chứa một và chỉ một dấu chấm và ít nhất 3 ký tự trước dấu chấm), điều đó có thể được đơn giản hóa thành:

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

Lưu ý rằng trạng thái thoát sẽ khác không nếu không có kết quả khớp, nhưng cũng có thể nếu phần khớp là một số giải quyết thành 0. (như cho a000.txthoặc a-00.txt)

Với zsh:

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

( :tcho đuôi (tên cơ sở), :rcho phần còn lại (đã loại bỏ phần mở rộng)).

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

###OUTPUT###

456

Điều đó đầu tiên loại bỏ ba ký tự cuối cùng $varsau đó xóa khỏi $varkết quả của việc loại bỏ đó - trả về ba ký tự cuối cùng của $var. Dưới đây là một số ví dụ cụ thể hơn nhằm mục đích chứng minh làm thế nào bạn có thể làm một việc như vậy:

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

Bạn không cần phải truyền bá tất cả những điều này qua rất nhiều lệnh. Bạn có thể nén cái này:

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

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

Kết hợp $IFSvới setcác tham số shell ting cũng có thể là một phương tiện phân tích cú pháp và khoan thông qua các biến shell rất hiệu quả:

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

Điều đó sẽ giúp bạn có được chỉ có ba nhân vật ngay trước giai đoạn đầu sau khi cuối cùng /trong $path. Nếu bạn muốn lấy chỉ có ba chữ cái đầu tiên ngay trước cuối cùng .trong $path (ví dụ, nếu có một khả năng nhiều hơn một .trong filename) :

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

Trong cả hai trường hợp, bạn có thể làm:

newvar=$(IFS...)

Và ...

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

... sẽ in những gì sau .

Nếu bạn không phiền khi sử dụng chương trình bên ngoài, bạn có thể làm:

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

Nếu có một \nký tự ewline trong tên tệp (không áp dụng cho các giải pháp shell gốc - tất cả chúng đều xử lý điều đó) :

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

Nếu bạn có thể sử dụng perl:

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

sed làm việc cho điều này:

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

Hoặc là

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

Nếu bạn sedkhông hỗ trợ -r, chỉ cần thay thế các trường hợp ()với \(và \), và sau đó -rlà không cần thiết.

Nếu perl có sẵn, tôi thấy nó có thể dễ đọc hơn các giải pháp khác, đặc biệt vì ngôn ngữ regex của nó có tính biểu cảm hơn và nó có công cụ /xsửa đổi, cho phép viết regex rõ ràng hơn:

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

Điều này in không có gì nếu không có kết quả khớp như vậy (nếu tên cơ sở không có phần mở rộng hoặc nếu gốc trước phần mở rộng quá ngắn). Tùy thuộc vào yêu cầu của bạn, bạn có thể điều chỉnh regex. Regex này thi hành các ràng buộc:

1. Nó khớp với 3 ký tự trước phần mở rộng cuối cùng (phần sau và bao gồm dấu chấm cuối cùng). 3 ký tự này có thể chứa một dấu chấm.
2. Phần mở rộng có thể để trống (ngoại trừ dấu chấm).
3. Phần phù hợp và phần mở rộng phải là một phần của tên cơ sở (phần sau dấu gạch chéo cuối cùng).

Sử dụng điều này trong thay thế lệnh có các vấn đề bình thường với việc loại bỏ quá nhiều dòng mới, một vấn đề cũng ảnh hưởng đến câu trả lời của Stéphane. Nó có thể được xử lý trong cả hai trường hợp, nhưng ở đây dễ dàng hơn một chút:

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

Tôi nghĩ hàm bash này, pathStr (), sẽ làm những gì bạn đang tìm kiếm.

Nó không yêu cầu awk, sed, grep, perl hoặc expr. Nó chỉ sử dụng các nội dung bash nên khá nhanh.

Tôi cũng đã bao gồm các hàm argsNumber và isOption phụ thuộc nhưng các chức năng của chúng có thể dễ dàng được tích hợp vào pathStr.

Hàm phụ thuộc ifHelpShow không được bao gồm vì nó có nhiều phụ thuộc để xuất văn bản trợ giúp trên dòng lệnh đầu cuối hoặc vào hộp thoại GUI qua YAD . Các văn bản trợ giúp được chuyển đến nó được bao gồm cho tài liệu. Tư vấn nếu bạn muốn ifHelpShow và những người phụ thuộc của nó.

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
}

TÀI NGUYÊN

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