Korn Shell（ksh88）函数内重复错误处理代码的简化方案咨询

Great question! Let's start by fixing a subtle bug in your original code first: after assigning ret=$?, the $? variable gets overwritten with the exit code of the assignment itself (which is almost always 0). So your if [[ $? -ne 0 ]] check will never trigger unless the assignment fails, which is extremely unlikely. The correct check should be against the ret variable directly: if [[ $ret -ne 0 ]].

Now, for simplifying this repetitive error handling in ksh88 (where you can't use the command || handler syntax you mentioned), here are two solid approaches:

1. Encapsulate Error Checking in a Helper Function #

First, create a reusable helper function that handles the exit code check and error message. Since ksh88 doesn't let a subfunction force its parent to return directly, we'll have the helper return the exit code, then check it in your main function:

# Helper function to check exit codes and print errors
function _check_error {
    typeset cmd_name="$1"
    typeset exit_code=$?  # Grab exit code of the last command run

    if [[ $exit_code -ne 0 ]]; then
        # Strip leading underscore from the function name for cleaner output
        echo "${cmd_name#_} produced an error: $exit_code"
        return $exit_code
    fi
    return 0
}

# Your simplified main function
function _myFunc {
    _myFirstSubFunc "TEST"
    _check_error "_myFirstSubFunc"
    if [[ $? -ne 0 ]]; then
        return $?
    fi

    _mySecondSubFunc "TEST"
    _check_error "_mySecondSubFunc"
    if [[ $? -ne 0 ]]; then
        return $?
    fi

    return 0
}

This cuts down on repetition by moving all the error logic into _check_error, so you only need two lines per subfunction call instead of four.

2. Go Further: Encapsulate Both Execution and Error Checking #

For even more brevity, create a helper that runs the subfunction and handles the error check in one step. This combines the subfunction call and error handling into a single command:

# Helper to run a function and handle errors automatically
function _run_and_verify {
    typeset func_name="$1"
    shift  # Shift to get the arguments for the subfunction

    # Execute the target subfunction with its arguments
    "$func_name" "$@"
    typeset exit_code=$?

    if [[ $exit_code -ne 0 ]]; then
        echo "${func_name#_} produced an error: $exit_code"
        return $exit_code
    fi
    return 0
}

# Even more simplified main function
function _myFunc {
    _run_and_verify _myFirstSubFunc "TEST"
    if [[ $? -ne 0 ]]; then
        return $?
    fi

    _run_and_verify _mySecondSubFunc "TEST"
    if [[ $? -ne 0 ]]; then
        return $?
    fi

    return 0
}

This way, you don't have to manually call the subfunction and then the error checker—_run_and_verify does both for you.

Why Traps/Aliases Didn't Work #

Traps are designed to handle signals or script-wide exit events, not per-command error checking in a function. Aliases, on the other hand, are expanded before command execution and don't play nicely with capturing exit codes or controlling function flow in ksh88, which is why those approaches didn't work for your use case.

Both of the above solutions work within ksh88's limitations, keep your code DRY, and ensure your function exits early with the correct error code without terminating the entire process.

内容的提问来源于stack exchange，提问作者zedd