Trong Bash, cách đơn giản nhất để kiểm tra nếu một mảng chứa một giá trị nhất định là gì?

Chỉnh sửa : Với sự giúp đỡ từ các câu trả lời và các ý kiến, sau một số thử nghiệm, tôi đã đưa ra điều này:

function contains() {
    local n=$#
    local value=${!n}
    for ((i=1;i < $#;i++)) {
        if [ "${!i}" == "${value}" ]; then
            echo "y"
            return 0
        fi
    }
    echo "n"
    return 1
}

A=("one" "two" "three four")
if [ $(contains "${A[@]}" "one") == "y" ]; then
    echo "contains one"
fi
if [ $(contains "${A[@]}" "three") == "y" ]; then
    echo "contains three"
fi

Tôi không chắc đó có phải là giải pháp tốt nhất không, nhưng có vẻ như nó hoạt động.

Cách tiếp cận này có ưu điểm là không cần lặp lại tất cả các yếu tố (ít nhất là không rõ ràng). Nhưng vì array_to_string_internal()trong mảng.c vẫn lặp các phần tử mảng và ghép chúng thành một chuỗi, nên có lẽ nó không hiệu quả hơn các giải pháp lặp được đề xuất, nhưng nó dễ đọc hơn.

if [[ " ${array[@]} " =~ " ${value} " ]]; then
    # whatever you want to do when array contains value
fi

if [[ ! " ${array[@]} " =~ " ${value} " ]]; then
    # whatever you want to do when array doesn't contain value
fi

Lưu ý rằng trong trường hợp giá trị bạn đang tìm kiếm là một trong những từ trong thành phần mảng có khoảng trắng, nó sẽ cho kết quả dương tính giả. Ví dụ

array=("Jack Brown")
value="Jack"

Regex sẽ thấy "Jack" nằm trong mảng mặc dù không phải vậy. Vì vậy, bạn sẽ phải thay đổi IFSvà các ký tự phân cách trên regex của bạn nếu bạn vẫn muốn sử dụng giải pháp này, như thế này

IFS=$'\t'
array=("Jack Brown\tJack Smith")
unset IFS
value="Jack"

if [[ "\t${array[@]}\t" =~ "\t${value}\t" ]]; then
    echo "true"
else
    echo "false"
fi

Điều này sẽ in "sai".

Rõ ràng điều này cũng có thể được sử dụng như một tuyên bố thử nghiệm, cho phép nó được thể hiện dưới dạng một lớp lót

[[ " ${array[@]} " =~ " ${value} " ]] && echo "true" || echo "false"

Dưới đây là một chức năng nhỏ để đạt được điều này. Chuỗi tìm kiếm là đối số đầu tiên và phần còn lại là các thành phần mảng:

containsElement () {
  local e match="$1"
  shift
  for e; do [[ "$e" == "$match" ]] && return 0; done
  return 1
}

Một lần chạy thử chức năng đó có thể trông giống như:

$ array=("something to search for" "a string" "test2000")
$ containsElement "a string" "${array[@]}"
$ echo $?
0
$ containsElement "blaha" "${array[@]}"
$ echo $?
1

$ myarray=(one two three)
$ case "${myarray[@]}" in  *"two"*) echo "found" ;; esac
found

for i in "${array[@]}"
do
    if [ "$i" -eq "$yourValue" ] ; then
        echo "Found"
    fi
done

Đối với chuỗi:

for i in "${array[@]}"
do
    if [ "$i" == "$yourValue" ] ; then
        echo "Found"
    fi
done

Giải pháp một dòng

printf '%s\n' ${myarray[@]} | grep -P '^mypattern$'

Giải trình

Câu printflệnh in từng phần tử của mảng trên một dòng riêng biệt.

Câu greplệnh sử dụng các ký tự đặc biệt ^và $để tìm một dòng chứa chính xác mẫu được đưa ra là mypattern(không hơn, không kém).

Sử dụng

Để đưa điều này vào một if ... thentuyên bố:

if printf '%s\n' ${myarray[@]} | grep -q -P '^mypattern$'; then
    # ...
fi

Tôi đã thêm một -qcờ vào grepbiểu thức để nó không in trùng khớp; nó sẽ chỉ coi sự tồn tại của một trận đấu là "đúng".

Nếu bạn cần hiệu suất, bạn không muốn lặp lại toàn bộ mảng của mình mỗi khi bạn tìm kiếm.

Trong trường hợp này, bạn có thể tạo một mảng kết hợp (bảng băm hoặc từ điển) đại diện cho một chỉ mục của mảng đó. Tức là nó ánh xạ từng phần tử mảng vào chỉ mục của nó trong mảng:

make_index () {
  local index_name=$1
  shift
  local -a value_array=("$@")
  local i
  # -A means associative array, -g means create a global variable:
  declare -g -A ${index_name}
  for i in "${!value_array[@]}"; do
    eval ${index_name}["${value_array[$i]}"]=$i
  done
}

Sau đó, bạn có thể sử dụng nó như thế này:

myarray=('a a' 'b b' 'c c')
make_index myarray_index "${myarray[@]}"

Và kiểm tra thành viên như vậy:

member="b b"
# the "|| echo NOT FOUND" below is needed if you're using "set -e"
test "${myarray_index[$member]}" && echo FOUND || echo NOT FOUND

Hoặc cũng:

if [ "${myarray_index[$member]}" ]; then 
  echo FOUND
fi

Lưu ý rằng giải pháp này thực hiện đúng ngay cả khi có khoảng trắng trong giá trị được kiểm tra hoặc trong các giá trị mảng.

Là một phần thưởng, bạn cũng có được chỉ số của giá trị trong mảng với:

echo "<< ${myarray_index[$member]} >> is the index of $member"

Tôi thường chỉ sử dụng:

inarray=$(echo ${haystack[@]} | grep -o "needle" | wc -w)

giá trị khác không cho thấy một trận đấu đã được tìm thấy.

Một lớp lót khác không có chức năng:

(for e in "${array[@]}"; do [[ "$e" == "searched_item" ]] && exit 0; done) && echo "found" || echo "not found"

Cảm ơn @Qwerty cho những người đứng đầu về không gian!

chức năng tương ứng:

find_in_array() {
  local word=$1
  shift
  for e in "$@"; do [[ "$e" == "$word" ]] && return 0; done
  return 1
}

thí dụ:

some_words=( these are some words )
find_in_array word "${some_words[@]}" || echo "expected missing! since words != word"

containsElement () { for e in "${@:2}"; do [[ "$e" = "$1" ]] && return 0; done; return 1; }

Bây giờ xử lý các mảng trống chính xác.

Đây là một đóng góp nhỏ:

array=(word "two words" words)  
search_string="two"  
match=$(echo "${array[@]:0}" | grep -o $search_string)  
[[ ! -z $match ]] && echo "found !"  

Lưu ý: cách này không phân biệt trường hợp "hai từ" nhưng điều này không bắt buộc trong câu hỏi.

Nếu bạn muốn thực hiện một thử nghiệm nhanh và bẩn để xem liệu nó có đáng lặp lại trên toàn bộ mảng để có một kết quả khớp chính xác hay không, Bash có thể coi các mảng như vô hướng. Kiểm tra một trận đấu trong vô hướng, nếu không thì bỏ qua vòng lặp sẽ tiết kiệm thời gian. Rõ ràng bạn có thể nhận được dương tính giả.

array=(word "two words" words)
if [[ ${array[@]} =~ words ]]
then
    echo "Checking"
    for element in "${array[@]}"
    do
        if [[ $element == "words" ]]
        then
            echo "Match"
        fi
    done
fi

Điều này sẽ xuất ra "Kiểm tra" và "Kết hợp". Với array=(word "two words" something)nó sẽ chỉ xuất "Kiểm tra". Với array=(word "two widgets" something)sẽ không có đầu ra.

Điều này làm việc cho tôi:

# traditional system call return values-- used in an `if`, this will be true when returning 0. Very Odd.
contains () {
    # odd syntax here for passing array parameters: http://stackoverflow.com/questions/8082947/how-to-pass-an-array-to-a-bash-function
    local list=$1[@]
    local elem=$2

    # echo "list" ${!list}
    # echo "elem" $elem

    for i in "${!list}"
    do
        # echo "Checking to see if" "$i" "is the same as" "${elem}"
        if [ "$i" == "${elem}" ] ; then
            # echo "$i" "was the same as" "${elem}"
            return 0
        fi
    done

    # echo "Could not find element"
    return 1
}

Cuộc gọi ví dụ:

arr=("abc" "xyz" "123")
if contains arr "abcx"; then
    echo "Yes"
else
    echo "No"
fi

a=(b c d)

if printf '%s\0' "${a[@]}" | grep -Fqxz c
then
  echo 'array “a” contains value “c”'
fi

Nếu bạn thích, bạn có thể sử dụng các tùy chọn dài tương đương:

--fixed-strings --quiet --line-regexp --null-data

Mượn từ câu trả lời của Dennis Williamson , giải pháp sau đây kết hợp các mảng, trích dẫn an toàn vỏ và các biểu thức chính quy để tránh sự cần thiết: lặp qua các vòng lặp; sử dụng đường ống hoặc các quy trình phụ khác; hoặc sử dụng các tiện ích không bash.

declare -a array=('hello, stack' one 'two words' words last)
printf -v array_str -- ',,%q' "${array[@]}"

if [[ "${array_str},," =~ ,,words,, ]]
then
   echo 'Matches'
else
   echo "Doesn't match"
fi

Đoạn mã trên hoạt động bằng cách sử dụng các biểu thức chính quy Bash để khớp với phiên bản được xâu chuỗi của nội dung mảng. Có sáu bước quan trọng để đảm bảo rằng kết hợp biểu thức chính quy không thể bị đánh lừa bởi các kết hợp giá trị thông minh trong mảng:

1. Xây dựng chuỗi so sánh bằng cách sử dụng printftrích dẫn shell dựng sẵn của Bash , %q. Trích dẫn Shell sẽ đảm bảo rằng các ký tự đặc biệt trở nên "an toàn với vỏ" bằng cách thoát khỏi dấu gạch chéo ngược \.
2. Chọn một ký tự đặc biệt để phục vụ như là một dấu phân cách giá trị. Dấu phân cách ĐÃ là một trong những ký tự đặc biệt sẽ được thoát khi sử dụng %q; đó là cách duy nhất để đảm bảo rằng các giá trị trong mảng không thể được xây dựng theo những cách thông minh để đánh lừa biểu thức khớp thông thường. Tôi chọn dấu phẩy ,vì ký tự đó là an toàn nhất khi bị đánh cắp hoặc sử dụng sai theo cách không mong muốn.
3. Kết hợp tất cả các thành phần mảng thành một chuỗi, sử dụng hai thể hiện của ký tự đặc biệt để đóng vai trò là dấu phân cách. Sử dụng dấu phẩy làm ví dụ, tôi đã sử dụng ,,%qlàm đối số printf. Điều này rất quan trọng vì hai trường hợp của ký tự đặc biệt chỉ có thể xuất hiện cạnh nhau khi chúng xuất hiện dưới dạng dấu phân cách; tất cả các trường hợp khác của nhân vật đặc biệt sẽ được thoát.
4. Nối hai trường hợp dấu của dấu phân cách vào chuỗi, để cho phép khớp với phần tử cuối cùng của mảng. Như vậy, thay vì so sánh với ${array_str}, so sánh với ${array_str},,.
5. Nếu chuỗi mục tiêu bạn đang tìm kiếm được cung cấp bởi một biến người dùng, bạn phải thoát tất cả các trường hợp của ký tự đặc biệt bằng dấu gạch chéo ngược. Mặt khác, kết hợp biểu thức chính quy trở nên dễ bị lừa bởi các phần tử mảng được tạo khéo léo.
6. Thực hiện một biểu thức chính quy Bash khớp với chuỗi.

Một bổ sung nhỏ cho câu trả lời của @ ghostdog74 về việc sử dụng caselogic để kiểm tra mảng đó có chứa giá trị cụ thể không:

myarray=(one two three)
word=two
case "${myarray[@]}" in  ("$word "*|*" $word "*|*" $word") echo "found" ;; esac

Hoặc với extglobtùy chọn được bật, bạn có thể làm như thế này:

myarray=(one two three)
word=two
shopt -s extglob
case "${myarray[@]}" in ?(*" ")"$word"?(" "*)) echo "found" ;; esac

Ngoài ra chúng ta có thể làm điều đó với iftuyên bố:

myarray=(one two three)
word=two
if [[ $(printf "_[%s]_" "${myarray[@]}") =~ .*_\[$word\]_.* ]]; then echo "found"; fi

được :

array=("something to search for" "a string" "test2000")
elem="a string"

sau đó kiểm tra đơn giản về:

if c=$'\x1E' && p="${c}${elem} ${c}" && [[ ! "${array[@]/#/${c}} ${c}" =~ $p ]]; then
  echo "$elem exists in array"
fi

Ở đâu

c is element separator
p is regex pattern

(Lý do chỉ định p riêng, thay vì sử dụng biểu thức trực tiếp bên trong [[]] là để duy trì khả năng tương thích cho bash 4)

Kết hợp một vài trong số các ý tưởng được trình bày ở đây, bạn có thể tạo ra một sự thanh lịch nếu thống kê mà không có vòng lặp nào khớp từ chính xác .

$find="myword"
$array=(value1 value2 myword)
if [[ ! -z $(printf '%s\n' "${array[@]}" | grep -w $find) ]]; then
  echo "Array contains myword";
fi

Điều này sẽ không kích hoạt trên wordhoặc val, chỉ toàn bộ từ phù hợp. Nó sẽ phá vỡ nếu mỗi giá trị mảng chứa nhiều từ.

Tôi thường viết các loại tiện ích này để hoạt động theo tên của biến, thay vì giá trị biến, chủ yếu vì bash không thể chuyển các biến bằng tham chiếu.

Đây là phiên bản hoạt động với tên của mảng:

function array_contains # array value
{
    [[ -n "$1" && -n "$2" ]] || {
        echo "usage: array_contains <array> <value>"
        echo "Returns 0 if array contains value, 1 otherwise"
        return 2
    }

    eval 'local values=("${'$1'[@]}")'

    local element
    for element in "${values[@]}"; do
        [[ "$element" == "$2" ]] && return 0
    done
    return 1
}

Với điều này, ví dụ câu hỏi trở thành:

array_contains A "one" && echo "contains one"

Vân vân.

Sử dụng grepvàprintf

Định dạng từng thành viên mảng trên một dòng mới, sau đó greplà các dòng.

if printf '%s\n' "${array[@]}" | grep -x -q "search string"; then echo true; else echo false; fi

$ array=("word", "two words")
$ if printf '%s\n' "${array[@]}" | grep -x -q "two words"; then echo true; else echo false; fi
true

Lưu ý rằng điều này không có vấn đề với dấu phân cách và không gian.

Kiểm tra một dòng không có 'grep' và vòng lặp

if ( dlm=$'\x1F' ; IFS="$dlm" ; [[ "$dlm${array[*]}$dlm" == *"$dlm${item}$dlm"* ]] ) ; then
  echo "array contains '$item'"
else
  echo "array does not contain '$item'"
fi

Cách tiếp cận này không sử dụng các tiện ích bên ngoài như grepvòng lặp.

Điều gì xảy ra ở đây, là:

• chúng tôi sử dụng một trình so khớp chuỗi ký tự đại diện để tìm mục của chúng tôi trong mảng được nối thành một chuỗi;
• chúng tôi cắt bỏ các kết quả dương tính giả có thể bằng cách đặt mục tìm kiếm của chúng tôi giữa một cặp dấu phân cách;
• chúng tôi sử dụng một ký tự không thể in là dấu phân cách, để ở bên an toàn;
• chúng tôi cũng đạt được dấu phân cách của chúng tôi được sử dụng để nối mảng bằng cách thay thế tạm thời IFSgiá trị biến;
• chúng tôi IFStạm thời thay thế giá trị này bằng cách đánh giá biểu thức điều kiện của chúng tôi trong một vỏ con (bên trong một cặp dấu ngoặc đơn)

Sử dụng mở rộng tham số:

$ {tham số: + word} Nếu tham số là null hoặc unset, không có gì được thay thế, nếu không thì việc mở rộng từ được thay thế.

declare -A myarray
myarray[hello]="world"

for i in hello goodbye 123
do
  if [ ${myarray[$i]:+_} ]
  then
    echo ${!myarray[$i]} ${myarray[$i]} 
  else
    printf "there is no %s\n" $i
  fi
done

Sau khi trả lời, tôi đọc một câu trả lời khác mà tôi đặc biệt thích, nhưng nó thật thiếu sót và bị đánh giá thấp. Tôi đã lấy cảm hứng và đây là hai cách tiếp cận mới mà tôi thấy khả thi.

array=("word" "two words") # let's look for "two words"

sử dụng grepvà printf:

(printf '%s\n' "${array[@]}" | grep -x -q "two words") && <run_your_if_found_command_here>

sử dụng for:

(for e in "${array[@]}"; do [[ "$e" == "two words" ]] && exit 0; done; exit 1) && <run_your_if_found_command_here>

Để có kết quả không phải là thêm || <run_your_if_notfound_command_here>

Đây là của tôi về điều này.

Tôi thà không sử dụng bash cho vòng lặp nếu tôi có thể tránh nó, vì điều đó cần có thời gian để chạy. Nếu một cái gì đó phải lặp, hãy để nó là một cái gì đó được viết bằng ngôn ngữ cấp thấp hơn so với tập lệnh shell.

function array_contains { # arrayname value
  local -A _arr=()
  local IFS=
  eval _arr=( $(eval printf '[%q]="1"\ ' "\${$1[@]}") )
  return $(( 1 - 0${_arr[$2]} ))
}

Điều này hoạt động bằng cách tạo ra một mảng kết hợp tạm thời _arr, có chỉ số được lấy từ các giá trị của mảng đầu vào. (Lưu ý rằng mảng kết hợp có sẵn trong bash 4 trở lên, vì vậy chức năng này sẽ không hoạt động trong các phiên bản trước của bash.) Chúng tôi đặt $IFSđể tránh chia tách từ trên khoảng trắng.

Hàm này không chứa các vòng lặp rõ ràng, mặc dù các bước bash bên trong thông qua mảng đầu vào để điền vào printf. Định dạng printf sử dụng %qđể đảm bảo rằng dữ liệu đầu vào được thoát để chúng có thể được sử dụng một cách an toàn làm khóa mảng.

$ a=("one two" three four)
$ array_contains a three && echo BOOYA
BOOYA
$ array_contains a two && echo FAIL
$

Lưu ý rằng mọi thứ mà chức năng này sử dụng là tích hợp để bash, do đó không có đường ống bên ngoài nào kéo bạn xuống, ngay cả trong việc mở rộng lệnh.

Và nếu bạn không thích sử dụng eval... tốt, bạn có thể sử dụng một cách tiếp cận khác. :-)

Phiên bản của tôi về kỹ thuật biểu thức chính quy đã được đề xuất:

values=(foo bar)
requestedValue=bar

requestedValue=${requestedValue##[[:space:]]}
requestedValue=${requestedValue%%[[:space:]]}
[[ "${values[@]/#/X-}" =~ "X-${requestedValue}" ]] || echo "Unsupported value"

Điều xảy ra ở đây là bạn đang mở rộng toàn bộ mảng các giá trị được hỗ trợ thành các từ và thêm vào một chuỗi cụ thể, "X-" trong trường hợp này, cho từng chuỗi và thực hiện tương tự với giá trị được yêu cầu. Nếu cái này thực sự được chứa trong mảng, thì chuỗi kết quả sẽ khớp với một trong số các mã thông báo kết quả, hoặc không có gì ngược lại. Trong trường hợp sau, | | toán tử kích hoạt và bạn biết bạn đang xử lý một giá trị không được hỗ trợ. Trước đó, tất cả các giá trị được yêu cầu sẽ bị tước bỏ tất cả các khoảng trắng hàng đầu và dấu kiểm thông qua thao tác chuỗi vỏ tiêu chuẩn.

Nó sạch sẽ và thanh lịch, tôi tin, mặc dù tôi không chắc chắn về hiệu suất của nó nếu mảng giá trị được hỗ trợ của bạn đặc biệt lớn.

Đây là nhận của tôi về vấn đề này. Đây là phiên bản ngắn:

function arrayContains() {
        local haystack=${!1}
        local needle="$2"
        printf "%s\n" ${haystack[@]} | grep -q "^$needle$"
}

Và phiên bản dài, mà tôi nghĩ là dễ nhìn hơn nhiều.

# With added utility function.
function arrayToLines() {
        local array=${!1}
        printf "%s\n" ${array[@]}
}

function arrayContains() {
        local haystack=${!1}
        local needle="$2"
        arrayToLines haystack[@] | grep -q "^$needle$"
}

Ví dụ:

test_arr=("hello" "world")
arrayContains test_arr[@] hello; # True
arrayContains test_arr[@] world; # True
arrayContains test_arr[@] "hello world"; # False
arrayContains test_arr[@] "hell"; # False
arrayContains test_arr[@] ""; # False

Tôi đã có trường hợp tôi phải kiểm tra xem ID có được chứa trong danh sách ID được tạo bởi tập lệnh / lệnh khác không. Đối với tôi làm việc như sau:

# the ID I was looking for
ID=1

# somehow generated list of IDs
LIST=$( <some script that generates lines with IDs> )
# list is curiously concatenated with a single space character
LIST=" $LIST "

# grep for exact match, boundaries are marked as space
# would therefore not reliably work for values containing a space
# return the count with "-c"
ISIN=$(echo $LIST | grep -F " $ID " -c)

# do your check (e. g. 0 for nothing found, everything greater than 0 means found)
if [ ISIN -eq 0 ]; then
    echo "not found"
fi
# etc.

Bạn cũng có thể rút ngắn / nén nó như thế này:

if [ $(echo " $( <script call> ) " | grep -F " $ID " -c) -eq 0 ]; then
    echo "not found"
fi

Trong trường hợp của tôi, tôi đã chạy jq để lọc một số JSON cho danh sách ID và sau đó phải kiểm tra xem ID của tôi có trong danh sách này không và điều này hoạt động tốt nhất với tôi. Nó sẽ không hoạt động cho các mảng được tạo thủ công của loại LIST=("1" "2" "4")nhưng với đầu ra tập lệnh được phân tách dòng mới.

PS.: Không thể bình luận một câu trả lời vì tôi còn khá mới ...

Đoạn mã sau kiểm tra xem một giá trị đã cho có trong mảng không và trả về giá trị bù dựa trên zero của nó:

A=("one" "two" "three four")
VALUE="two"

if [[ "$(declare -p A)" =~ '['([0-9]+)']="'$VALUE'"' ]];then
  echo "Found $VALUE at offset ${BASH_REMATCH[1]}"
else
  echo "Couldn't find $VALUE"
fi

Trận đấu được thực hiện trên các giá trị hoàn chỉnh, do đó, đặt VALUE = "ba" sẽ không khớp.

Điều này có thể đáng để điều tra nếu bạn không muốn lặp lại:

#!/bin/bash
myarray=("one" "two" "three");
wanted="two"
if `echo ${myarray[@]/"$wanted"/"WAS_FOUND"} | grep -q "WAS_FOUND" ` ; then
 echo "Value was found"
fi
exit

Đoạn trích được chuyển thể từ: http : //www.thegeek ware.com/2010/06/bash-array-tutorial/ Tôi nghĩ rằng nó khá thông minh.

EDIT: Bạn có thể chỉ cần làm:

if `echo ${myarray[@]} | grep -q "$wanted"` ; then
echo "Value was found"
fi

Nhưng cái sau chỉ hoạt động nếu mảng chứa các giá trị duy nhất. Tìm kiếm 1 trong "143" sẽ cho kết quả sai, methinks.

Hơi muộn, nhưng bạn có thể sử dụng điều này:

#!/bin/bash
# isPicture.sh

FILE=$1
FNAME=$(basename "$FILE") # Filename, without directory
EXT="${FNAME##*.}" # Extension

FORMATS=(jpeg JPEG jpg JPG png PNG gif GIF svg SVG tiff TIFF)

NOEXT=( ${FORMATS[@]/$EXT} ) # Formats without the extension of the input file

# If it is a valid extension, then it should be removed from ${NOEXT},
#+making the lengths inequal.
if ! [ ${#NOEXT[@]} != ${#FORMATS[@]} ]; then
    echo "The extension '"$EXT"' is not a valid image extension."
    exit
fi

Tôi đã đưa ra cái này, hóa ra chỉ hoạt động trong zsh, nhưng tôi nghĩ cách tiếp cận chung là tốt.

arr=( "hello world" "find me" "what?" )
if [[ "${arr[@]/#%find me/}" != "${arr[@]}" ]]; then
    echo "found!"
else
    echo "not found!"
fi

Bạn lấy ra mẫu của bạn từ mỗi phần tử chỉ khi nó bắt đầu ${arr[@]/#pattern/}hoặc kết thúc ${arr[@]/%pattern/}với nó. Hai sự thay thế này hoạt động trong bash, nhưng cả hai cùng một lúc${arr[@]/#%pattern/} chỉ hoạt động trong zsh.

Nếu mảng được sửa đổi bằng với bản gốc, thì nó không chứa phần tử.

Biên tập:

Cái này hoạt động trong bash:

 function contains () {
        local arr=(${@:2})
        local el=$1
        local marr=(${arr[@]/#$el/})
        [[ "${#arr[@]}" != "${#marr[@]}" ]]
    }

Sau khi thay thế, nó so sánh độ dài của cả hai mảng. Obly nếu mảng chứa phần tử thay thế sẽ xóa hoàn toàn nó, và số lượng sẽ khác nhau.