identify if present and remove specific argument from shell args

Question

I have to check if particular argument lets say 'java8' is present in my shell arguments to script and if it is present remove it . Also I want it to be stored in some other variable , but want it to be removed from my $*.

One option I Trie checking if arg is present using getopts but I dont know how to remove argument .

Please note - the position of arg to check 'java8' is not known I can be at any place

while getopts "f:" flag
do
     case $flag in
         f)
           echo $OPTARG
           ;;
     esac
done
echo $*
~

So basically when I invoke -

./test.sh arg1 arg2 -f java8 arg3

after execution of getopts block the remaining args will be

arg1 , arg2 , arg3

Answer 1

For any POSIX shell (without using a temporary array): Dropping any instance of -f followed by java8, or of -fjava8, from the list of positional parameters, while counting the number of such dropped options-with arguments in the variable found.

skip=0 found=0
for arg do
    case $1 in
        -f)
            if [ "$2" = java8 ]; then
                skip=2
                found=$(( found + 1 ))
            fi
            ;;
        -f*)
            if [ "$1" = -fjava8 ]; then
                skip=1
                found=$(( found + 1 ))
            fi
    esac

    if [ "$skip" -eq 0 ]; then
        set -- "$@" "$1"
    else
        skip=$(( skip - 1 ))
    fi
    shift
done

if [ "$skip" -eq 1 ]; then
    set -- "$@" -f
    found=$(( found - 1 ))
fi

printf 'Args: %s\n' "$*"
printf 'Found = %d\n' "$found"

The above loop iterates as often as the initial number of positional parameters.

If the first positional parameter is -f, the second positional parameter is tested to see whether it's java8. If the test is true, then we need to skip these two arguments, so the skip counter is set to 2. We also increment found to indicate that we've found one more instance of -f java8.

If the first positional parameter is -fjava8, then we need to skip this single argument, so the skip counter is set to 1. We also increment found to indicate that we've found one more instance of -fjava8 (the same as finding -f java8).

After the case statement, we don't do anything other than decrement the skip counter and shift off the first positional parameter if skip is non-zero. If skip is zero, we move the first positional parameter to the end of the list before calling shift, effectively allowing the arguments we keep to cycle back through the list while dropping the unwanted arguments.

Since we're using the list of positional parameters in a cyclic way, we would lose the last argument if it was -f and the first argument was java8. This is what the last if statement protects against.

Answer 2

Maybe something like this? I'm assuming you want to remove -f java8...

#!/bin/bash

while (( $# )); do
    if [[ $1 = "-f" ]] && [[ $2 = "java8" ]]; then
        shift 2
        continue
    fi

    args+=( "$1" )
    shift
done

echo "${args[*]}"

Example usage:

$ ./argtest.sh one two three
one two three
$ ./argtest.sh one two -f java8 three four
one two three four
$ ./argtest.sh -f java8 -f foo -f bar
-f foo -f bar