ใน Bash วิธีที่ง่ายที่สุดในการทดสอบว่าอาร์เรย์มีค่าที่แน่นอนคืออะไร

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

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

ฉันไม่แน่ใจว่ามันเป็นทางออกที่ดีที่สุด แต่ดูเหมือนว่าจะทำงาน

วิธีการนี้มีข้อได้เปรียบที่ไม่จำเป็นต้องวนซ้ำองค์ประกอบทั้งหมด (อย่างน้อยก็ไม่ชัดเจน) แต่เนื่องจากarray_to_string_internal()ในarray.cยังคงวนลูปมากกว่าองค์ประกอบของอาร์เรย์และเชื่อมต่อพวกมันเข้ากับสตริงมันอาจจะไม่ได้มีประสิทธิภาพมากกว่าโซลูชั่นลูปที่เสนอ แต่มันอ่านได้มากกว่า

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

โปรดทราบว่าในกรณีที่ค่าที่คุณค้นหาเป็นหนึ่งในคำในองค์ประกอบอาร์เรย์ที่มีช่องว่างมันจะให้ผลบวกเท็จ ตัวอย่างเช่น

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

regex จะเห็น "Jack" ว่ากำลังอยู่ในอาร์เรย์แม้ว่าจะไม่ใช่ ดังนั้นคุณจะต้องเปลี่ยนIFSและตัวคั่นใน regex ของคุณหากคุณยังต้องการใช้วิธีนี้เช่นนี้

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

สิ่งนี้จะพิมพ์ "false"

เห็นได้ชัดว่าสิ่งนี้สามารถใช้เป็นคำแถลงการทดสอบได้ด้วยทำให้สามารถแสดงเป็นซับในได้

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

ด้านล่างเป็นฟังก์ชั่นเล็ก ๆ สำหรับการบรรลุเป้าหมายนี้ สตริงการค้นหาเป็นอาร์กิวเมนต์แรกและส่วนที่เหลือเป็นองค์ประกอบอาร์เรย์:

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

การทดสอบการทำงานของฟังก์ชันนั้นอาจมีลักษณะดังนี้:

$ 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

สำหรับสตริง:

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

โซลูชันเดียว

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

คำอธิบาย

printfคำสั่งพิมพ์องค์ประกอบของอาร์เรย์แต่ละบรรทัดที่แยกต่างหาก

grepคำสั่งใช้ตัวอักษรพิเศษ^และ$เพื่อหาบรรทัดที่มีว่ารูปแบบให้เป็นmypattern(ไม่มากไม่น้อยกว่า)

การใช้

ในการใส่if ... thenคำสั่งลงในข้อความ:

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

ฉันเพิ่มการ-qตั้งค่าสถานะลงในgrepนิพจน์เพื่อไม่ให้พิมพ์ออกมาตรงกัน มันจะรักษาการมีอยู่ของการแข่งขันว่า "เป็นจริง"

หากคุณต้องการประสิทธิภาพคุณไม่ต้องการวนลูปทั้งหมดของคุณทุกครั้งที่ค้นหา

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

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
}

จากนั้นคุณสามารถใช้สิ่งนี้:

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

และทดสอบการเป็นสมาชิกเช่น:

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

หรือยัง:

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

ขอให้สังเกตว่าการแก้ปัญหานี้ทำสิ่งที่ถูกต้องแม้ว่าจะมีช่องว่างในค่าที่ทดสอบหรือในค่าอาร์เรย์

ในฐานะโบนัสคุณจะได้รับดัชนีของค่าภายในอาร์เรย์ด้วย:

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

ฉันมักจะใช้:

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

ค่าที่ไม่ใช่ศูนย์หมายถึงพบคู่ที่ตรงกัน

อีกหนึ่งซับโดยไม่มีฟังก์ชั่น:

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

ขอบคุณ @Qwerty สำหรับหัวขึ้นเกี่ยวกับช่องว่าง!

ฟังก์ชั่นที่เกี่ยวข้อง:

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

ตัวอย่าง:

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

ตอนนี้จัดการกับอาร์เรย์ที่ว่างเปล่าอย่างถูกต้อง

นี่คือผลงานเล็ก ๆ :

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

หมายเหตุ: วิธีนี้จะไม่แยกความแตกต่างของคำว่า "สองคำ" แต่ไม่จำเป็นต้องใช้ในคำถาม

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

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

สิ่งนี้จะส่งออก "กำลังตรวจสอบ" และ "จับคู่" ด้วยarray=(word "two words" something)มันจะออกเฉพาะ "การตรวจสอบ" ด้วยarray=(word "two widgets" something)จะไม่มีการส่งออก

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

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

ตัวอย่างการโทร:

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

หากคุณต้องการคุณสามารถใช้ตัวเลือกยาวที่เทียบเท่าได้:

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

การยืมตัวจากคำตอบของเดนนิสวิลเลียมสันคำตอบต่อไปนี้ได้รวมเอาอาร์เรย์การอ้างถึงเชลล์ที่ปลอดภัยและการแสดงออกปกติเพื่อหลีกเลี่ยงความต้องการ: วนซ้ำวนซ้ำ; ใช้ท่อหรือกระบวนการย่อยอื่น ๆ หรือใช้ยูทิลิตีแบบ non-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

โค้ดด้านบนใช้งานได้โดยใช้นิพจน์ทั่วไปของ Bash เพื่อจับคู่กับเนื้อหาอาร์เรย์ มีหกขั้นตอนสำคัญเพื่อให้แน่ใจว่าการจับคู่นิพจน์ทั่วไปไม่สามารถถูกหลอกได้ด้วยการรวมค่าที่ฉลาดภายในอาเรย์:

1. สร้างสตริงเปรียบเทียบโดยใช้ทุบตีในตัวของprintfเปลือก %qquoting, การอ้างถึงเชลล์จะทำให้แน่ใจว่าอักขระพิเศษกลายเป็น "เชลล์ปลอดภัย" ด้วยการถูกใช้เครื่องหมายแบ็กสแลช\ด้วยการหนีไปกับทับขวา
2. เลือกอักขระพิเศษเพื่อใช้เป็นตัวคั่นค่า คั่นจะต้องมีหนึ่งในตัวละครพิเศษที่จะกลายเป็นหนีเมื่อใช้%q; นั่นเป็นวิธีเดียวที่จะรับประกันได้ว่าค่าภายในอาร์เรย์ไม่สามารถสร้างขึ้นด้วยวิธีที่ชาญฉลาดเพื่อหลอกจับคู่นิพจน์ทั่วไป ฉันเลือกจุลภาค,เพราะตัวละครนั้นปลอดภัยที่สุดเมื่อประเมินหรือนำไปใช้ในทางที่ผิดโดยไม่คาดคิด
3. รวมองค์ประกอบอาร์เรย์ทั้งหมดไว้ในสตริงเดียวโดยใช้สองอินสแตนซ์ของอักขระพิเศษเพื่อใช้เป็นตัวคั่น การใช้เครื่องหมายจุลภาคเป็นตัวอย่างที่ผมใช้เป็นอาร์กิวเมนต์ไป,,%q printfสิ่งนี้มีความสำคัญเนื่องจากอักขระพิเศษสองตัวสามารถปรากฏขึ้นติดกันได้เมื่อปรากฏเป็นตัวคั่นเท่านั้น อินสแตนซ์อื่น ๆ ทั้งหมดของอักขระพิเศษจะถูกหลีกเลี่ยง
4. ผนวกสองอินสแตนซ์ต่อท้ายของตัวคั่นไปยังสตริงเพื่อให้ตรงกับองค์ประกอบสุดท้ายของอาร์เรย์ ดังนั้นแทนที่จะเปรียบเทียบกับการเปรียบเทียบกับ${array_str}${array_str},,
5. หากสตริงเป้าหมายที่คุณกำลังค้นหาจัดหาให้โดยตัวแปรผู้ใช้คุณต้องหลีกเลี่ยงอินสแตนซ์ทั้งหมดของอักขระพิเศษด้วยแบ็กสแลช มิฉะนั้นการจับคู่นิพจน์ทั่วไปจะเสี่ยงต่อการถูกหลอกโดยองค์ประกอบอาเรย์ที่สร้างขึ้นอย่างชาญฉลาด
6. ทำการนิพจน์ปกติของ Bash จับคู่กับสตริง

คำตอบเล็ก ๆ ของ @ ghostdog74 เกี่ยวกับการใช้caseตรรกะเพื่อตรวจสอบว่าอาร์เรย์มีค่าเฉพาะ:

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

หรือextglobเปิดใช้ตัวเลือกคุณสามารถทำสิ่งนี้ได้:

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

นอกจากนี้เราสามารถทำได้ด้วย ifคำสั่ง:

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

ให้:

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

จากนั้นตรวจสอบอย่างง่ายของ:

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

ที่ไหน

c is element separator
p is regex pattern

(เหตุผลในการกำหนด p แยกต่างหากแทนที่จะใช้นิพจน์ภายใน [[]] โดยตรงคือเพื่อรักษาความเข้ากันได้สำหรับ bash 4)

รวมไม่กี่ของความคิดที่นำเสนอนี้คุณสามารถทำให้สง่างามถ้างบโดยไม่ต้องลูปที่ไม่ตรงกับคำที่แน่นอน

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

สิ่งนี้จะไม่ทำให้เกิดขึ้นwordหรือvalคำที่ตรงกันทั้งหมดเท่านั้น มันจะแตกถ้าแต่ละค่าอาร์เรย์มีหลายคำ

ฉันมักจะเขียนโปรแกรมอรรถประโยชน์เหล่านี้เพื่อใช้งานในชื่อของตัวแปรมากกว่าค่าตัวแปรหลักเพราะ bash ไม่สามารถส่งผ่านตัวแปรได้โดยการอ้างอิง

นี่คือเวอร์ชันที่ทำงานกับชื่อของอาร์เรย์:

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
}

ด้วยสิ่งนี้ตัวอย่างของคำถามจะกลายเป็น:

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

เป็นต้น

การใช้ grepและprintf

จัดรูปแบบสมาชิกอาเรย์แต่ละตัวในบรรทัดใหม่จากนั้นgrepตามด้วยบรรทัด

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

โปรดทราบว่าสิ่งนี้ไม่มีปัญหากับ delimeter และช่องว่าง

การตรวจสอบหนึ่งบรรทัดโดยไม่มี 'grep' และลูป

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

วิธีการนี้ไม่ใช้โปรแกรมอรรถประโยชน์ภายนอกเช่นgrepหรือลูป

เกิดอะไรขึ้นที่นี่คือ:

• เราใช้ตัวจับคู่สตริงย่อยเพื่อค้นหารายการของเราในอาร์เรย์ที่ต่อกันเป็นสตริง
• เราตัดค่าบวกที่เป็นเท็จที่เป็นไปได้ออกโดยใส่รายการค้นหาของเราระหว่างตัวคั่นคู่
• เราใช้อักขระที่ไม่สามารถพิมพ์ได้เป็นตัวคั่นเพื่อให้อยู่ในด้านที่ปลอดภัย
• เราบรรลุตัวคั่นของเราที่ถูกใช้สำหรับการต่อข้อมูลอาร์เรย์ด้วยเช่นกันโดยการแทนที่ IFSค่าตัวแปร
• เราทำการIFSเปลี่ยนค่านี้ชั่วคราวโดยการประเมินนิพจน์เงื่อนไขของเราใน sub-shell (ภายในวงเล็บหนึ่งคู่)

ใช้การขยายพารามิเตอร์:

$ {พารามิเตอร์: + word} หากพารามิเตอร์เป็นโมฆะหรือไม่มีการตั้งค่าจะไม่มีการแทนที่สิ่งใดมิฉะนั้นการขยายตัวของคำจะถูกแทนที่

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

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

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

ใช้grepและprintf:

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

ใช้for:

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

เพื่อไม่ให้เพิ่มผลลัพธ์ || <run_your_if_notfound_command_here>

นี่คือสิ่งที่ฉันทำ

ฉันไม่ควรใช้ bash สำหรับลูปถ้าฉันสามารถหลีกเลี่ยงได้เนื่องจากต้องใช้เวลาในการรัน หากสิ่งที่ต้องห่วงให้มันเป็นสิ่งที่เขียนในภาษาระดับต่ำกว่าสคริปต์เปลือก

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

สิ่งนี้ทำงานได้โดยการสร้างอาเรย์แบบเชื่อมโยงชั่วคราว_arrซึ่งมีดัชนีมาจากค่าของอาเรย์อินพุต (โปรดทราบว่าอาร์เรย์ที่เชื่อมโยงมีอยู่ใน bash 4 ขึ้นไปดังนั้นฟังก์ชันนี้จะไม่ทำงานใน bash รุ่นก่อนหน้านี้) เราตั้งค่า$IFSให้หลีกเลี่ยงการแยกคำในช่องว่าง

ฟังก์ชั่นนี้ไม่มีการวนprintfซ้ำอย่างชัดเจนแม้ว่าจะใช้ขั้นตอนการทุบตีภายในอินพุตอาร์เรย์เพื่อเติมข้อมูล รูปแบบ printf ใช้%qเพื่อให้แน่ใจว่าข้อมูลอินพุตจะถูกหลบหนีเพื่อให้สามารถใช้เป็นคีย์อาร์เรย์ได้อย่างปลอดภัย

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

โปรดทราบว่าทุกสิ่งที่ฟังก์ชั่นนี้ใช้นั้นมีอยู่ในตัวเพื่อทุบตีดังนั้นจึงไม่มีท่อภายนอกลากคุณลงแม้ในการขยายคำสั่ง

และถ้าคุณไม่ชอบการใช้eval... ดีคุณมีอิสระที่จะใช้วิธีการอื่น :-)

ฉันใช้เทคนิคนิพจน์ทั่วไปที่แนะนำแล้ว:

values=(foo bar)
requestedValue=bar

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

สิ่งที่เกิดขึ้นที่นี่คือคุณกำลังขยายค่าทั้งหมดที่สนับสนุนเป็นคำและเตรียมสตริงเฉพาะ "X-" ในกรณีนี้ให้กับแต่ละรายการและทำแบบเดียวกันกับค่าที่ร้องขอ ถ้าอันนี้มีอยู่ในอาเรย์จริงๆแล้วสตริงที่ได้จะตรงกับโทเค็นที่เกิดขึ้นมากที่สุดหรือไม่มีเลยในทางตรงกันข้าม ในกรณีหลัง | | ผู้ให้บริการทริกเกอร์และคุณรู้ว่าคุณกำลังจัดการกับค่าที่ไม่สนับสนุน ก่อนหน้านี้ทั้งหมดค่าที่ร้องขอจะถูกตัดออกจากช่องว่างนำหน้าและต่อท้ายทั้งหมดผ่านการจัดการสตริงสตริงมาตรฐาน

มันสะอาดและสง่างามฉันเชื่อว่าแม้ว่าฉันจะไม่แน่ใจว่ามันมีประสิทธิภาพมากแค่ไหนหากค่าที่คุณสนับสนุนมีขนาดใหญ่เป็นพิเศษ

นี่คือปัญหาของฉัน นี่คือเวอร์ชั่นย่อ:

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

และรุ่นยาวซึ่งฉันคิดว่าเป็นเรื่องง่ายในสายตา

# 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$"
}

ตัวอย่าง:

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

ฉันมีกรณีที่ฉันต้องตรวจสอบว่ามี ID อยู่ในรายการ ID ที่สร้างโดยสคริปต์ / คำสั่งอื่น สำหรับฉันทำงานต่อไปนี้:

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

คุณสามารถย่อให้สั้นลงได้เช่นกัน:

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

ในกรณีของฉันฉันใช้ jq เพื่อกรอง JSON สำหรับรายการ ID และต้องตรวจสอบภายหลังว่า ID ของฉันอยู่ในรายการนี้หรือไม่และนี่ใช้งานได้ดีที่สุดสำหรับฉัน จะไม่ทำงานสำหรับอาร์เรย์ที่สร้างขึ้นด้วยตัวเองLIST=("1" "2" "4")แต่ใช้กับเอาต์พุตสคริปต์ที่แยกบรรทัดใหม่

ป.ล. : ไม่สามารถแสดงความคิดเห็นคำตอบเพราะฉันค่อนข้างใหม่ ...

รหัสต่อไปนี้จะตรวจสอบว่าค่าที่กำหนดอยู่ในอาร์เรย์และส่งกลับค่าออฟเซ็ตที่เป็นศูนย์หรือไม่:

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

การแข่งขันเสร็จสิ้นในค่าที่สมบูรณ์ดังนั้นการตั้งค่า VALUE = "สาม" จะไม่ตรงกัน

นี่อาจเป็นสิ่งที่ควรตรวจสอบหากคุณไม่ต้องการทำซ้ำ:

#!/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

ตัวอย่างดัดแปลงมาจาก: http://www.thegeekstuff.com/2010/06/bash-array-tutorial/ ฉันคิดว่ามันค่อนข้างฉลาด

แก้ไข: คุณอาจทำเพียง:

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

แต่หลังใช้งานได้เฉพาะถ้าอาร์เรย์มีค่าที่ไม่ซ้ำกัน การค้นหา 1 ใน "143" จะให้ผลบวกเป็นบวก

สายไปหน่อย แต่คุณสามารถใช้สิ่งนี้:

#!/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

ฉันมากับอันนี้ซึ่งทำงานได้เฉพาะใน zsh แต่ฉันคิดว่าวิธีการทั่วไปดี

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

คุณจะออกรูปแบบของคุณจากแต่ละองค์ประกอบเท่านั้นถ้ามันเริ่มต้น${arr[@]/#pattern/}หรือสิ้นสุด${arr[@]/%pattern/}กับมัน การแทนที่ทั้งสองนี้ทำงานในการทุบตี แต่ทั้งสองอย่างในเวลาเดียวกัน${arr[@]/#%pattern/}ใช้ได้เฉพาะใน zsh

ถ้าอาเรย์ที่ถูกแก้ไขนั้นมีค่าเท่ากับของแท้แสดงว่ามันไม่มีองค์ประกอบ

แก้ไข:

อันนี้ใช้ได้ในทุบตี:

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

หลังจากการทดแทนมันจะเปรียบเทียบความยาวของอาร์เรย์ทั้งสอง Obly ถ้า array มีองค์ประกอบการแทนที่จะถูกลบอย่างสมบูรณ์และจำนวนจะแตกต่างกัน