I like Bash, but it isn’t well suited for some tasks. For fun I sometimes ignore that. Occasionally people seem to find this useful.

In that spirit, here is my implementation of the popular Luhn / mod10 algorithm used in credit card, IMEI, and other number sequences.

download [luhn.zip]

To maximize the enjoyment I’ve optimized the script a little bit in two ways:

1) Normally every other digit of the sequence to be computed is multiplied by 2. If that result is greater than 9, then 9 is subtracted. There are only 10 single digits in base-10, so it seemed reasonable to precompute these values. This saves not only the multiplication step, but also the conditional branch (on greater/less than 9), and the occasional subtraction operation (when values were greater than 9).

2) I prepend a 0 to the submitted sequence if there are an uneven number of digits in the sequence. The leading 0 doesn’t affect the end result, but being assured of having pairs of digits available in the while loop of our luhn_checksum() function saves us from needing to keep track of which digits should be added directly and which should be handled as described in optimization #1 above.

If for some reason you are actually using this script, you probably will be most interested in luhn_checkdigit() and luhn_test().

Here is an example of how this can be used:

Convert a decimal value into the binary representation and vice versa in Bash using only built-ins. If you know a better way, please let me know. To ensure a properly formatted expression for the arithmetic expansion in bin2dec, the dec2bin function prefixes zeros as needed to pad to a character count evenly divisible by 8.

Examples:

Perhaps not the most efficient way, but at least for small numbers it appears to be quicker than opening a subshell.

Occasionally I find myself wanting to removing leading and/or trailing occurrences of a character or string from a larger string in bash. A couple common uses are removing quotes, or stripping an unknown number of spaces leading into the data of interest. This can be done pretty easily with other methods such as awk or sed, but with the disadvantage of requiring external commands. This a pure bash implementation using only shell built-ins. It might be better to rewrite this with $BASH_REMATCH, but this is what I currently have.

#!/bin/bash



trim () {

    str="$1"

    match="$2"

    # trim spaces by default

    if [ -z "$match" ]; then

        match=" "

    fi

    # trim leading

    while [ "${str:0:${#match}}" == "$match" ];

    do

        str="${str:${#match}:${#str}}"

    done

    # trim tailing

    while [ "${str:$((${#str}-${#match}))}" == "$match" ];

    do

        str="${str:0:$((${#str} - ${#match}))}" 

    done

    echo "$str"

}



#Remove leading and trailing spaces

example="    Hello     "

echo "`trim  "$example" " "`"



#The second parameter is optional when removing spaces

example="    Hello     "

echo "`trim  "$example"`"





#Remove leading and trailing occurences of "word"

example="wordHelloword"

echo "`trim  "$example" "word"`"

One approach would be to encode everything, but the approach I took was to just encode things I thought might be problematic to pass over the query string.

URL (a.k.a percent) encoding of a string in bash: