Q:

go array initialization containing a string literal

I'm trying to initialize a byte array as a mix of numbers and a string.   I've managed to do it using a pair of appends, or by splitting the string into individual chars, but for the sake of readability is there a way to do it as a single initializer containing a string? 
// method 1, with two appends
a := []byte{1, 2}
a = append(a, []byte("foo")...);
a = append(a, 3, 4);

// method 2, splitting the string into chars
b := []byte{1, 2, 'f', 'o', 'o', 3, 4)

A:

What you did in your first attempt in 3 lines is probably more readable that any one-liners:
(You can try all the examples on the Go Playground.) 
// Doing one-by-one:
a := []byte{1, 2}
a = append(a, []byte("foo")...)
a = append(a, 3, 4)
fmt. Println(a)

// Using individual chars:
a = []byte{1, 2, 'f', 'o', 'o', 3, 4}
fmt. Println(a)

// Using a single string literal:
a = []byte("\x01\x02foo\x03\x04")
fmt. Println(a)

// Using several "nested" appends:
a = append(append([]byte{1, 2}, []byte("foo")...), 3, 4)
fmt. Println(a)

Except if you create a helper function:
func concat(s ...[]byte) []byte {
    var res []byte
    for _, v := range s {
        res = append(res, v...)
    }
    return res
}

And then using it:
// With a utility function:
a = concat([]byte{1, 2}, []byte("foo"), []byte{3, 4})
fmt. Println(a)

// With a utility function, formatted differently:
a = concat(
    []byte{1, 2},
    []byte("foo"),
    []byte{3, 4},
)
fmt. Println(a)

You could also do it using a single keyed composite literal and a single copy() call to "insert" the string:
// With keyed literal and copy:
a = []byte{1, 2, 5: 3, 4}
copy(a[2:], "foo")
fmt. Println(a)

Still I don't think it's more readable or worth it. 

Concat optimization
As per comments left below, @EliasVanOotegem benchmarked the solution above (using append on an empty slice) and compared it to summing the total capacity of the byte slice required and allocating that memory in one go.  The latter turns out to be slightly more efficiend (~20%), so I'll include that version below:
func concat(s ...[]byte) []byte {
    c := 0
    for _, v := range s {
        c += len(v)
    }
    res := make([]byte, 0, c) // allocate everything
    for _, v := range s {
        res = append(res, v...)
    }
    return res
}

I personally would use the following optimized version which does not require slice header assignments as it uses the builtin copy():
func concat(s ...[]byte) []byte {
    size := 0
    for _, v := range s {
        size += len(v)
    }
    res, i := make([]byte, size), 0
    for _, v := range s {
        i += copy(res[i:], v)
    }
    return res
}

