I have a script running on Linux that accepts some parameters.
I would like to do something like:
if [[ $CONDITION == "true" ]]; then
script param1 --param2
else
script param1
fi
I would like to avoid the forking path of the if.
Is there a more optimal way to pass the second parameter?
The most expansible and robust way would probably be to use an array to hold the optional parameter(s):
params=()
if [[ $CONDITION == true ]]; then
params+=(--param2)
fi
script param1 "${params[@]}"
Or in shorthand:
[[ $CONDITION == true ]] && params+=(--param2)
script param1 "${params[@]}"
That avoids repeating the constant part of the command and you can put more than one argument in the array, even the whole command.
Note that it's important to do this with an array: if you replace the array with a regular variable (params="--param2"; script param1 $params) you'll either have to expand the variable unquoted, with all the problems that brings, or expand it quoted, in which case you'll pass an empty string as argument if the variable is empty.
In a simple case like this, the "alternate value" expansion can also be used:
cond=x
p2="--param2"
script param1 ${cond:+"$p2"}
Here, if cond is nonempty (regardless of if it's cond=false or cond=0 instead of cond=true), the value of p2 is expanded. This may be seen as less ugly than arrays, but be careful with the placement of the quotes.
See also:
--, and not the unary -- operator
-- operator only exists in the shell within arithmetic expansions, and there aren't any here. I can't think of any special meaning for the dash in the shell outside of them, either.
par="x y"; printf ":%s\n" a b ${par+"$par"} It should expand par as another argument after b, if par is set (i.e. unset par; printf ":%s\n" a b ${par+"$par"} there would not be an empty argument after b). Or you could have ${cond:+"$par"} to expand par if cond is non-empty.
set -o nounset when the params variable is empty ? I'm getting "unbound variable" errors. EDIT : use "${params[@]-}" with a dash at the end prevents the problem
A versatile way to do this is to set the arguments in an array. The most basic array is the list of positional parameters defined with set. You can build the list of parameters in sequence.
set -- param1
if [[ $CONDITION == "true" ]]; then
set -- "$@" --param2
fi
command "$@"
Which could be reduced to:
set -- param1
[[ $CONDITION == "true" ]] && set -- "$@" --param2
command "$@"
If the list of positional parameters needs to be preserved, then either:
Use a function:
callcommand(){ set -- param1
[[ $CONDITION == "true" ]] && set -- "$@" --param2
command "$@"
}
callcommand
Or use some other array variable:
paramArray=()
paramArray+=(param1)
[[ $CONDITION == "true" ]] && paramArray+=( "--param2" )
command "${paramArray[@]}"
param1 is already a parameter. Does this change the parameter array of the script?
param1 is not an argument of the script code above, it become a parameter of the command called. Yes, the positional parameters are changed (as they are used). See some alternatives in the edited answer.
PARAMS+=" param1"
if [[ $CONDITION == "true" ]]; then
PARAMS+=" --param2"
fi
script ${PARAMS}
if? In the script itself? In another script that calls the target script? Are these options (--param2) or arguments (param1)? Please edit your question and give us more details.trueis a shell builtin that returns a success exit status. If you useCONDITION=falsewhen CONDITION is not true, then you could write:if "$CONDITION"; then echo yes; fior"$CONDITION" && echo yestrueis not the same as"true"right?"echo" "foo"with no difficulty because the shell will remove the quotes before executing the command.valid=falseif someCondition; then valid=true; fi;if ! $valid; then echo Invalid; exit 1; fi