У 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"

Регекс побачить "Джек" як масив, хоча його немає. Таким чином, вам доведеться змінити IFSі розділові символи на вашому регексе, якщо ви хочете все-таки використовувати це рішення, як це

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

Запозичуючи Dennis Williamson «s відповідь , такі рішення об'єднує в собі масиви, оболонки-безпечне цитування, і регулярні вирази , щоб уникнути необхідності: ітерація петель; використання труб або інших підпроцесів; або за допомогою не-утиліти.

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. Побудувати рядок порівняння за допомогою Bash вбудованих в printfоболонці-цитували, %q. Цитування оболонок гарантуватиме, що спеціальні символи стануть "захищеними від оболонок", уникнувши зворотним нахилом \.
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

Зауважте, що це не має проблем із деліметрами та пробілами.

Однорядкова перевірка без '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заміщення значення тимчасовим, оцінюючи наше умовне вираження в підколонці (всередині пари в дужках)

Використання розширення параметрів:

$ {параметр: + слово} Якщо параметр є нульовим або не встановленим, нічого не замінено, інакше розширення слова замінено.

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

У мене був випадок, що мені довелося перевірити, чи міститься ідентифікатор у списку ідентифікаторів, генерованих іншим скриптом / командою. Для мене працювали наступні:

# 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 за списком ідентифікаторів, і мені довелося пізніше перевірити, чи є мій ідентифікатор у цьому списку, і це працювало найкраще для мене. Він не буде працювати для створених вручну масивів типу, LIST=("1" "2" "4")але для виводу сценарію, розділеного новим рядком.

PS .: не змогли прокоментувати відповідь, оскільки я відносно новий ...

Наступний код перевіряє, чи є задане значення в масиві, і повертає його нульове зміщення:

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/ Я думаю, що це досить розумно.

EDIT: Можливо, ви могли просто зробити:

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/}ним. Ці дві заміни працюють у bash, але обидві одночасно працюють ${arr[@]/#%pattern/}лише в zsh.

Якщо модифікований масив дорівнює оригіналу, він не містить елемента.

Редагувати:

Цей працює в bash:

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

Після підстановки вона порівнює довжину обох масивів. Обов`язково, якщо масив містить елемент, заміна повністю видалить його, а кількість буде різною.