Approach 1: Reading in awk

Since the array elements can contain any character but the null byte (\0) we have to delimit them by \0. This is done with printf. For simplicity we assume that the array has at least one entry.

Due to the \0 we can no longer pass the string to awk as an argument but have to use (or emulate) a file instead. We then read that file in awk using \0 as the record separator RS (may require GNU awk).

awk 'BEGIN {RS="\0"} {a[n++]=$0; next}' <(printf %s\\0 "${a[@]}")

This reliably constructs the awk array a from the bash array a. The length of a is stored in n.

This approach is ugly when you actually want to use it. There is no simple step-by-step instruction on how to incorporate this approach into your existing awk script. Normally, your awk script would read another file afterwards, therefore you have to change the record separator RS after the array file was read. This can be done with NR>FNR. However, if your awk script already reads multiple files and relies on something like NR==FNR things get complicated.

Approach 2: Generating awk Code with bash

Instead of parsing the array in awk we hard-code the array by generating awk code. This code will be injected at the beginning of an existing awk script and initialize the array. This approach also supports sparse arrays and associative arrays and should work with all awk versions, not only GNU.

For the code generation we have to correctly quote all strings. For example, the code generator echo "a[0]=${a[0]}" would fail if ${a[0]} was " resulting in the code a[1]=""". POSIX awk supports octal escape sequences (\012) which can encode all bytes. We simply encoding everything. That way we cannot forget any special symbols (even though the generated code is a bit inefficient).

octString() {
    printf %s "$*" | od -bvAn | tr ' ' '\\' | tr -d '\n'
}
arrayToAwk() {
    printf 'BEGIN{'
    n=0
    for key in "${!a[@]}"; do
        printf 'a["%s"]="%s";' "$(octString "$key")" "$(octString "${a[$key]}")"
        ((n++))
    done
    echo "n=$n}"
}

The function arrayToAwk converts the bash array a (can be sparse or associative) into a BEGIN block. After inserting the generated code block at the begging of your existing awk program you can use the awk array a anywhere inside awk without having to adapt anything (assuming that the variable names a and n were unused before). n is the size of the awk array a.

For awk commands of the form awk ... 'program' ... use

awk ... "$(arrayToAwk)"'program' ...

For big arrays this might result in the error Argument list too long. You can circumvent this problem using a program file:

awk ... -f <(arrayToAwk; echo 'program') ...

For awk commands of the form awk ... -f progfile ... use

awk ... -f <(arrayToAwk; cat progfile) ...

I'd like to point out that this can be extremely simple if you do not mind using ARGV and deleting all the non-file arguments. One way:

>cat awk_script.sh
#!/bin/awk -f

BEGIN{
    i=1
    while(ARGV[i] != "--" && i < ARGC) {
        print ARGV[i]
        delete ARGV[i]
        i++
    }
    if(i < ARGC)
        delete ARGV[i]
} {
    print "File 1 contains at 1",$1
}

Then run it with:

>./awk_script.sh "${a[@]}" -- file1
AB
 C  D
E
F       G
¼ẞ�

File 1 contains at 1 a

Obviously I'm missing some symbols.

Note while I like this method it assumes -- is not in the array, as pointed out by Oguz Ismail. They give a great alternate solution of having the first argument the length of your list.

This can be a one liner to where you have

awk 'BEGIN{... get and delete first arguments ...}{process files}END{if wanted} "${a[@]}" file1 file2...

but will become unreadable very quickly.