Differences between revisions 11 and 12
Revision 11 as of 2011-04-01 17:40:35
Size: 5724
Editor: GreyCat
Comment: |
Revision 12 as of 2011-04-02 04:49:13
Size: 5781
Editor: sn18
Comment: printf %q quotes | character
Deletions are marked like this. Additions are marked like this.
Line 23: Line 23:
Line 28: Line 28:
Line 31: Line 31:
Line 33: Line 33:
   then     then
Line 45: Line 45:
Line 54: Line 54:
Line 58: Line 58:
Line 111: Line 111:
You can also use extended glob with printf to search for a word in an array.  You can also use extended glob with printf to search for a word in an array.
Line 124: Line 124:
   . ''printf %q quotes a | character too, so it probably should not'' --sn18
Line 128: Line 129:
   # Is 'foo' one of the positional parameters?     # Is 'foo' one of the positional parameters?
Line 140: Line 141:

I want to check to see whether a word is in a list (or an element is a member of a set).

If your real question was How do I check whether one of my parameters was -v? then please see FAQ #35 instead. Otherwise, read on....

First of all, let's get the terminology straight. Bash has no notion of "lists" or "sets" or any such. Bash has strings and arrays. Strings are a "list" of characters, arrays are a "list" of strings.

NOTE: In the general case, a string cannot possibly contain a list of other strings because there is no reliable way to tell where each substring begins and ends.

Given a traditional array, the only proper way to do this is to loop over all elements in your array and check them for the element you are looking for. Say what we are looking for is in bar and our list is in the array foo:

  •    # Bash
       for element in "${foo[@]}"; do
          [[ $element = $bar ]] && echo "Found $bar."

If you need to perform this several times in your script, you might want to extract the logic into a function:

  •    # Bash
       isIn() {
           local pattern="$1" element
           for element
               [[ $element = $pattern ]] && return 0
           return 1
       if isIn "jacob" "${names[@]}"
           echo "Jacob is on the list."

Or, if you want your function to return the index at which the element was found:

  •    # Bash 3.0 or higher
       indexOf() {
           local pattern=$1
           local index list
           for index in "${!list[@]}"
               [[ ${list[index]} = $pattern ]] && {
                   echo $index
                   return 0
           echo -1
           return 1
       if index=$(indexOf "jacob" "${names[@]}")
           echo "Jacob is the ${index}th on the list."
           echo "Jacob is not on the list."

If your "list" is contained in a string, and for some half-witted reason you choose not to heed the warnings above, you can use the following code to search through "words" in a string. (The only real excuse for this would be that you're stuck in Bourne shell, which has no arrays.)

  •    # Bourne
       set -f
       for element in $foo; do
          if test x"$element" = x"$bar"; then
             echo "Found $bar."
       set +f

Here, a "word" is defined as any substring that is delimited by whitespace (or more specifically, the characters currently in IFS). The set -f prevents glob expansion of the words in the list. Turning glob expansions back on (set +f) is optional.

If you're working in bash 4 or ksh93, you have access to associative arrays. These will allow you to restructure the problem -- instead of making a list of words that are allowed, you can make an associative array whose keys are the words you want to allow. Their values could be meaningful, or not -- depending on the nature of the problem.

  •    # Bash 4
       declare -A good
       for word in "goodword1" "goodword2" ...; do
       # Check whether $foo is allowed:
       if ((${good[$foo]})); then ...

Here's a hack that you shouldn't use, but which is presented for the sake of completeness:

  •    # Bash
       if [[ " $foo " = *" $bar "* ]]; then
          echo "Found $bar."

(The problem here is that is assumes space can be used as a delimiter between words. Your elements might contain spaces, which would break this!)

That same hack, for Bourne shells:

  •    # Bourne
       case " $foo " in
          *" $bar "*) echo "Found $bar.";;

You can also use extended glob with printf to search for a word in an array. I haven't tested it enough, so it might break in some cases --sn18

  •    # Bash
       shopt -s extglob
       #convert array to glob
       printf -v glob '%q|' "${array[@]}"
       [[ $word = @($glob) ]] && echo "Found $word"
  • It will break when an array element contains a | character. Hence, I moved it down here with the other hacks that work in a similar fashion and have a similar limitation. -- GreyCat

    • printf %q quotes a | character too, so it probably should not --sn18

GNU's grep has a \b feature which allegedly matches the edges of words. Using that, one may attempt to replicate the shorter approach used above, but it is fraught with peril:

  •    # Is 'foo' one of the positional parameters?
       egrep '\bfoo\b' <<<"$@" >/dev/null && echo yes
       # This is where it fails: is '-v' one of the positional parameters?
       egrep '\b-v\b' <<<"$@" >/dev/null && echo yes
       # Unfortunately, \b sees "v" as a separate word.
       # Nobody knows what the hell it's doing with the "-".
       # Is "someword" in the array 'array'?
       egrep '\bsomeword\b' <<<"${array[@]}"
       # Obviously, you can't use this if someword is '-v'!

Since this "feature" of GNU grep is both non-portable and poorly defined, we recommend not using it. It is simply mentioned here for the sake of completeness.

Bulk comparison

This method tries to compare the desired string to the entire contents of the array. It can potentially be very efficient, but it depends on a delimiter that must not be in the sought value or the array. Here we use $'\a', the BEL character, because it's extremely uncommon.

  •    # usage: if has "element" list of words; then ...; fi
       has() {
         local IFS=$'\a' t="$1"
         [[ $'\a'"$*"$'\a' == *$'\a'$t$'\a'* ]]


BashFAQ/046 (last edited 2019-05-20 20:45:14 by GreyCat)