Golang replace array elements by array elements in string

In PHP we can do something like :

$result = str_replace($str,$array1,$array2);

Where $array1 and $array2 are array of elements, this makes php replace all array1 elements by array2 elements.
Is there any equivalent to this using the Golang? I have tried the same php approach but it did not work :

str := "hello world"
array1 :=  []string {"hello","world"}
array2 :=  []string {"foo","bar"}
r := strings.NewReplacer(array1,array2)
str = r.Replace(str)

I know I can do something like :

str := "hello world"
array1 :=  []string {"hello","world"}
array2 :=  []string {"foo","bar"}
r := strings.NewReplacer("hello","foo","world","bar")
str = r.Replace(str)

That would work but I need to use arrays directly because the arrays of replacements will be created dynamically.

I believe performance would be much better if you first zip both arrays in a single replacement array and then run just one replacer pass over the target string because strings.Replacer is fairly optimized for various cases and because the replacement algorithm would need to be run only once.

Something like this would do:

func zip(a1, a2 []string) []string {
	r := make([]string, 2*len(a1))
	for i, e := range a1 {
		r[i*2] = e
		r[i*2+1] = a2[i]
	}
	return r
}

func main() {
	str := "hello world"
	array1 := []string{"hello", "world"}
	array2 := []string{"foo", "bar"}
	str = strings.NewReplacer(zip(array1, array2)...).Replace(str)
	fmt.Println(str)
}

How about a map?

str := "Lorem Ipsum is simply dummy. Lorem Ipsum is text of the printing. Lorem Ipsum is typesetting industry.";

replace := map[string]string{
	"Lorem": "LoremReplaced",
	"Ipsum": "IpsumReplaced",
	"printing": "printingReplaced",
}

for s, r := range replace {
	str = strings.Replace(str, s, r, -1)
}

The solution I have found is the following :

str := "hello world"
array1 :=  []string {"hello","world"}
array2 :=  []string {"foo","bar"}

for i,toreplace := range array1{
	r := strings.NewReplacer(toreplace,array2[i])
	str = r.Replace(str)
}

fmt.Println(str)

A function can be created

func str_replace(str string, original []string, replacement []string) string {

	for i,toreplace := range original{
		r := strings.NewReplacer(toreplace,replacement[i])
		str = r.Replace(str)
	}

	return str
}

Usage :

str := "hello world"
array1 :=  []string {"hello","world"}
array2 :=  []string {"foo","bar"}
str = str_replace(str,array1,array2)
fmt.Println(str)

Any more elegant solution is more than welcome.