使用for循环：

elements = []string{"abc", "def", "fgi", "adi"}
elementMap := make(map[string]string)
for i := 0; i < len(elements); i +=2 {
    elementMap[elements[i]] = elements[i+1]
}

runnable example on the playground
标准库没有执行此操作的函数。

目前还没有办法用perl的方式来实现，你只需要迭代切片，并把切片元素放在map中，比如作为map的键：

func main() {
    var elements []string
    var elementMap map[string]string
    elements = []string{"abc", "def", "fgi", "adi"}

    // initialize map
    elementMap = make(map[string]string)

    // put slice values into map
    for _, s := range elements {  
        elementMap[s] = s
        // or just keys, without values: elementMap[s] = ""
    }

    // print map
    for k := range elementMap {
        fmt.Println(k)
    }
}

根据您要执行的操作，您必须记住一件事：map键是唯一的，因此如果切片包含重复的字符串，您可能需要使用map[string]int：

func main() {
    var elements []string
    var elementMap map[string]int
    elements = []string{"abc", "def", "fgi", "adi", "fgi", "adi"}

    // initialize map
    elementMap = make(map[string]int)

    // increment map's value for every key from slice
    for _, s := range elements {  
        elementMap[s]++
    }

    // print map
    for k, v := range elementMap {
        fmt.Println(k, v)
    }
}

您可以随时将该功能 Package 在一个函数中：

func sliceToStrMap(elements []string) map[string]string {
    elementMap := make(map[string]string)
    for _, s := range elements {
        elementMap[s] = s
    }
    return elementMap
}

func sliceToIntMap(elements []string) map[string]int {
    elementMap := make(map[string]int)
    for _, s := range elements {
        elementMap[s]++
    }
    return elementMap
}

如果要找一个函数库，你可以使用go-funk。这段代码在Go语言中可能性能不高，而且在我们有泛型之前也不习惯。

var elements = []string{"abc", "def", "fgi", "adi"}

elementsMap := funk.Map(
    funk.Chunk(elements, 2),
    func(x []string) (string, string) { // Slice to Map
        return x[0], x[1]
    },
)

fmt.Println(elementsMap) // map[abc:def fgi:adi]

https://play.golang.org/p/-t-33z4aKM_j

尝试范围

elements := []string{"abc", "def", "fgi", "adi"}
    elementMap := make(map[int]string)
    for i, data := range elements  {
             elementMap[i] = data
        }

fmt.Println(elementMap ) // map[0:abc 1:def 2:fgi 3:adi]

https://play.golang.org/p/h6uZn5obLKg

对于泛型：

func Map[T any, V comparable](src []T, key func(T) V) map[V]T {
    var result = make(map[V]T)
    for _, v := range src {
        result[key(v)] = v
    }
    return result
}

我只是稍微改变了ngotd的方法，以保留引用。

func Map[T any, V comparable](src []T, key func(T) V) map[V]*T {
    var result = make(map[V]T)
    for idx := range src {
        el := &src[idx]
        result[key(el)] = el
    }
    return result
}

这是与一些滑动窗口问题相同的解决方案，回答了具有多于一个Map键的多结果切片：

func zipSlices[T any, V comparable](src []T, size int, keyf func(idx int) V) []map[V]T {

    var results = []map[V]T{}
    total := len(src)
    if total < size {
        return results 
    }
    for idx := 0; idx <= total; idx += size {
        var j int
        var newOne = make(map[V]T)
        for {
            if j >= size {
                j = 0  
                break
            } 

            if idx+j >= total {
                break
            }
            newOne[keyf(j)] = src[idx+j]
            j += 1
        }

        if len(result) > 0 {
            results = append(results , newOne)
        }
    }
    return results 
}