How to write a function that takes parameters and flags in arbitrary order?

Question

I am new to shell and I was trying to write a custom function that takes regular arguments, as well as parse any flags provided.

test_it() {
  flag1="false"
  flag2="false"

  while getopts "ab" opt; do
    case ${opt} in
    a) flag1="true" ;;
    b) flag2="true" ;;
    *) break ;;
    esac
  done
  echo $flag1 $flag2
  shift "$(($OPTIND - 1))"
  echo "Custom param: $1"
}

However, this function would only work as I wanted if I supply the custom param after the flags. If I were to supply the custom param before the flags, it doesn't parse the flags.

> test_it -ab foo
true true
Custom param: foo
> test_it foo -ab
false false
Custom param: foo
> test_it -a foo -b
true false
Custom param: foo

Is there a way in which I can make it so that the flags and params get parsed correctly regardless of order? In other words, it should echo true true for both flags in all three of these cases, since they were invoked at some point during the function call? This should be possible, as I have observed functions like rsync to behave that way.

Use a function name other than test -- you're overriding the builtin command. — glenn jackman
– glenn jackman, Commented Aug 29, 2022 at 22:00

ilkkachu · Accepted Answer · 2024-06-16 12:11:45Z

Yes: in a function, before calling while getopts, add

local OPTIND OPTARG

That will reset the "counter" to 0 each time.

Note also that while getopts will stop at the first non-option. If you want test foo -ab to work, you need to use getopt(1), in particular the enhanced version of getopt from util-linux or Busybox and available for Mac in brew under the name "gnu-getopt". (getopt example script)

test_it() {
    local tmp flag1=false flag2=false

    if getopt -T; [ "$?" -ne 4 ]; then
        echo "wrong version of 'getopt' installed, aborting..." >&2
        return 1
    fi 

    tmp=$(getopt -o 'ab' -n "$FUNCNAME" -- "$@")
    
    local rc=$?
    ((rc == 0)) || return $rc
    
    eval set -- "$tmp"
    
    while true; do
        case "$1" in
            '-a') flag1=true
                  shift
                  ;;
            '-b') flag2=true
                  shift
                  ;;
            '--') shift
                  break
                  ;;
            *)    echo Internal Error >&2
                  return 1
                  ;;
        esac
    done

    declare -p flag1 flag2
    echo "Remaining params:"
    printf "%s\n" "$@"
}

$ test_it foo -a bar -b
declare -- flag1="true"
declare -- flag2="true"
Remaining params:
foo
bar

$ test_it -a quz
declare -- flag1="true"
declare -- flag2="false"
Remaining params:
quz

$ test_it baz -b
declare -- flag1="false"
declare -- flag2="true"
Remaining params:
baz

$ test_it -c
test_it: invalid option -- c

$ test_it baz --ab
test_it: unrecognized option `--ab'

Just a reminder that not all versions of getopt support arguments with whitespace in them, the getopt -o invocation and the use of eval set ... with the output. The util-linux version is the main one that does support them, but it looks like Busybox's version also does (including the -T option to test that support). The more traditional ones are meant for args=$(getopt...); set -- $args without eval (and without quotes), and that has some rather obvious failings. — ilkkachu
– ilkkachu, Commented Aug 29, 2022 at 22:07
And I see the macos tag on the question now. The default /usr/bin/getopt on the mac is an old version: I'd recommend installing Homebrew, and then install the bash and gnu-getopt packages. — glenn jackman
– glenn jackman, Commented Aug 29, 2022 at 22:13
@glennjackman hi glenn, thanks for the answer. I am currently figuring out how to get gnu-getopt working, and will try out your answer once I am able to do so. — Donald Zhu
– Donald Zhu, Commented Aug 29, 2022 at 22:20

Kim Dongryeong · Accepted Answer · 2024-06-16 11:20:56Z

-1

This is a script that can accept -ab or -ba as well.

It's written for Zsh. For Bash,

shebang should be replaced with #!/bin/bash
"args[1]: ${args[1]}" should be replaced with "args[0]: ${args[0]}"

The code starts from here:

#!/bin/zsh


fct_test() {
    local flag_a=false
    local flag_b=false
 
    local args=()
    while (( $# )); do
        case $1 in
            -a) flag_a=true ;;
            -b) flag_b=true ;;
            -ab|-ba) 
                flag_a=true
                flag_b=true ;;
            -*)
                echo >&2 "Invalid option: $1"
                return 1
                ;;
            *) args+=("$1") ;;
        esac
        shift
    done
 
 
    # Check if exactly one command is provided
    if [ ${#args[@]} -ne 1 ]; then
        echo >&2 "Usage: fct_test <command> -[a|b] or fct_test -[a|b] <command>"
        return 1  # Return 1 to indicate an error
    fi
 
    echo "flag_a: $flag_a"
    echo "flag_b: $flag_b"
    echo "args[1]: ${args[1]}"
}
echo "TEST 1"
fct_test -a "arg1"
echo

echo "TEST 2"
fct_test "arg1" -ba
echo

echo "TEST 3"
fct_test -a "arg1" -b
echo

echo "TEST 4"
fct_test "arg1"
echo

echo "TEST 5"
fct_test -x "arg1"
echo

echo "TEST 6"
fct_test "arg1" "arg2"
echo

The result:

% ./function_param_test.sh
TEST 1
flag_a: true
flag_b: false
args[1]: arg1

TEST 2
flag_a: true
flag_b: true
args[1]: arg1

TEST 3
flag_a: true
flag_b: true
args[1]: arg1

TEST 4
flag_a: false
flag_b: false
args[1]: arg1

TEST 5
Invalid option: -x

TEST 6
Usage: fct_test <command> -[a|b] or fct_test -[a|b] <command>

edited Jun 16, 2024 at 11:20

answered Jun 16, 2024 at 11:18

Kim Dongryeong

11 bronze badge

This looks like you're just reimplementing getopt manually, which might not be a good idea. For example, the -ab|-ba branch in the case statement works here, in the simple case of two options, but consider what happens if you add just a third one? You'll need manually add the -ac|-ca and -bc|-cb branches plus another explicitly listing all six permutations of -abc. Imagine adding the fourth option. And that's even without mixing in options that take arguments, or the -- separator, etc.

ilkkachu
– ilkkachu

2024-06-16 12:20:11 +00:00
Commented Jun 16, 2024 at 12:20
If you're going to do that, either do it properly or just reduce the accepted syntax to something that's easier to parse. If you want to support stacked options, you only need substring access, which is possible in Bash, ksh and zsh. And on the other hand, dropping support for them makes the parsing much easier. Or, you know, just use the existing implementations.

ilkkachu
– ilkkachu

2024-06-16 12:23:15 +00:00
Commented Jun 16, 2024 at 12:23
@ilkkachu Hi! Thanks for your comment and insight! You are absolutely right and true that my script is not expandable/scalable! But I simply rewrote the OP's script as a working one for the OP's usage. ;) And what do you mean with the substring access? Like -a*)?

Kim Dongryeong
– Kim Dongryeong

2024-06-17 12:36:51 +00:00
Commented Jun 17, 2024 at 12:36
I mean that implementing processing of stacked options sanely requires looking at the individual characters of an argument, not just the whole string. You can get e.g. the first char of $1 with ${1:0:1}, and you can loop over the chars with something like for (( i = 0; i < ${#1}; i++)), check each char individually and set the appropriate flags.

ilkkachu
– ilkkachu

2024-06-18 09:41:03 +00:00
Commented Jun 18, 2024 at 9:41

Add a comment |

Stack Exchange Network

How to write a function that takes parameters and flags in arbitrary order?

2 Answers 2

You must log in to answer this question.

Hot Network Questions

How to write a function that takes parameters and flags in arbitrary order?

2 Answers 2

You must log in to answer this question.

Related

Hot Network Questions