Làm cách nào để tôi có thể biết được tên tệp có khớp với mẫu toàn cầu không?

Tôi muốn biết nếu một chuỗi $stringsẽ được khớp bởi một mẫu hình cầu $pattern. $stringcó thể hoặc không thể là tên của một tập tin hiện có. Tôi có thể làm cái này như thế nào?

Giả sử các định dạng sau cho chuỗi đầu vào của tôi:

string="/foo/bar"
pattern1="/foo/*"
pattern2="/foo/{bar,baz}"

Tôi muốn tìm một thành ngữ bash xác định nếu $stringcó thể được kết hợp bởi $pattern1, $pattern2hoặc bất kỳ mẫu glob tùy ý khác. Đây là những gì tôi đã cố gắng cho đến nay:

1. [[ "$string" = $pattern ]]

   Điều này gần như hoạt động, ngoại trừ $patternđược hiểu là một mẫu chuỗi và không phải là một mẫu toàn cầu.

2. [ "$string" = $pattern ]

   Vấn đề với cách tiếp cận này là $patternđược mở rộng và sau đó so sánh chuỗi được thực hiện giữa $stringvà mở rộng $pattern.

3. [[ "$(find $pattern -print0 -maxdepth 0 2>/dev/null)" =~ "$string" ]]

   Cái này hoạt động, nhưng chỉ khi $stringchứa một tập tin tồn tại.

4. [[ $string =~ $pattern ]]

   Điều này không hoạt động vì =~toán tử gây ra $patternđược hiểu là biểu thức chính quy mở rộng, không phải là mẫu hình cầu hoặc ký tự đại diện.

Không có giải pháp chung cho vấn đề này. Lý do là, trong bash, mở rộng dấu ngoặc (nghĩa là {pattern1,pattern2,...}mở rộng tên tệp (còn gọi là mẫu hình cầu) được coi là những thứ riêng biệt và được mở rộng trong các điều kiện khác nhau và tại các thời điểm khác nhau. Dưới đây là danh sách đầy đủ các mở rộng mà bash thực hiện:

• mở rộng cú đúp
• mở rộng dấu ngã
• mở rộng tham số và biến
• thay thế lệnh
• mở rộng số học
• chia từ
• mở rộng tên đường dẫn

Vì chúng tôi chỉ quan tâm đến một tập hợp con trong số này (có thể là niềng răng, dấu ngã và mở rộng tên đường dẫn), nên có thể sử dụng các mẫu và cơ chế nhất định để hạn chế mở rộng theo kiểu có thể kiểm soát được. Ví dụ:

#!/bin/bash
set -f

string=/foo/bar

for pattern in /foo/{*,foo*,bar*,**,**/*}; do
    [[ $string == $pattern ]] && echo "$pattern matches $string"
done

Chạy tập lệnh này tạo ra đầu ra sau:

/foo/* matches /foo/bar
/foo/bar* matches /foo/bar
/foo/** matches /foo/bar

Điều này hoạt động vì set -fvô hiệu hóa mở rộng tên đường dẫn, vì vậy chỉ có mở rộng dấu ngoặc và mở rộng dấu ngã xảy ra trong câu lệnh for pattern in /foo/{*,foo*,bar*,**,**/*}. Sau đó chúng ta có thể sử dụng thao tác kiểm tra [[ $string == $pattern ]]để kiểm tra chống lại việc mở rộng tên đường dẫn sau khi mở rộng dấu ngoặc đã được thực hiện.

Tôi không tin rằng đó {bar,baz} là mô hình toàn cầu vỏ (mặc dù chắc chắn /foo/ba[rz]là vậy) nhưng nếu bạn muốn biết liệu có $stringphù hợp hay $patternkhông:

case "$string" in 
($pattern) put your successful execution statement here;;
(*)        this is where your failure case should be   ;;
esac

Bạn có thể làm bao nhiêu tùy thích:

case "$string" in
($pattern1) do something;;
($pattern2) do differently;;
(*)         still no match;;
esac

Như Patrick đã chỉ ra rằng bạn cần một "kiểu khác" của mẫu:

[[ /foo/bar == /foo/@(bar|baz) ]]


string="/foo/bar"
pattern="/foo/@(bar|baz)"
[[ $string == $pattern ]]

Báo giá là không cần thiết ở đó.

Tôi sẽ sử dụng grep như vậy:

#!/bin/bash
string="/foo/bar"
pattern1="/foo/*"
pattern2="/foo/{bar,baz}"

if echo $string | grep -e "$pattern1" > /dev/null; then
    echo $string matches $pattern1
fi

if echo $string | grep -e "$pattern2" > /dev/null; then
    echo $string matches $pattern2
fi

Cung cấp đầu ra:

./test2.bsh 
/foo/bar matches /foo/*

trong zsh:

[[ $string = $~pattern ]] && print true