我会完全照你做的做，做一些调整来纠正错别字

import (
    "fmt"
    "strconv"
    "strings"
)

func main() {
    list := []int{1,2,3}

    var list2 []string
    for _, x := range list {
        list2 = append(list2, strconv.Itoa(x * 2))  // note the = instead of :=
    }

    str := strings.Join(list2, ", ")
    fmt.Println(str)
}

这是一个老问题，但在我的谷歌搜索中是最热门的，我发现了一些信息，我相信这些信息对OP和其他任何来到这里寻找同样东西的人都有帮助。
有一种更短的方法，尽管你必须自己编写map函数。
在go中，func是一个类型，它允许你编写一个函数，该函数接受主题切片和一个函数作为输入，并迭代该切片，应用该函数。
请参见Go by Example页面底部附近的Map函数：https://gobyexample.com/collection-functions
我把它放在这里供参考：

func Map(vs []string, f func(string) string) []string {
    vsm := make([]string, len(vs))
    for i, v := range vs {
        vsm[i] = f(v)
    }
    return vsm
}

你可以这样称呼它：

fmt.Println(Map(strs, strings.ToUpper))

所以，是的：您正在寻找的更短的方法是存在的，尽管它没有内置到语言本身中。

既然泛型已经在1.18中引入，我已经创建了一个包含Map和Filter方法的小型实用程序包：）
https://pkg.go.dev/github.com/sa-/slicefunk
使用示例

package main

import (
    "fmt"

    sf "github.com/sa-/slicefunk"
)

func main() {
    original := []int{1, 2, 3, 4, 5}
    newArray := sf.Map(original, func(item int) int { return item + 1 })
    newArray = sf.Map(newArray, func(item int) int { return item * 3 })
    newArray = sf.Filter(newArray, func(item int) bool { return item%2 == 0 })
    fmt.Println(newArray)
}

使用go1.18+，你可以编写一个更简洁的通用Map函数：

func Map[T, V any](ts []T, fn func(T) V) []V {
    result := make([]V, len(ts))
    for i, t := range ts {
        result[i] = fn(t)
    }
    return result
}

用法，例如：

input := []int{4, 5, 3}
outputInts := Map(input, func(item int) int { return item + 1 })
outputStrings := Map(input, func(item int) string { return fmt.Sprintf("Item:%d", item) })

找到了定义通用Map数组函数的方法

func Map(t interface{}, f func(interface{}) interface{} ) []interface{} {
    switch reflect.TypeOf(t).Kind() {
    case reflect.Slice:
        s := reflect.ValueOf(t)
        arr := make([]interface{}, s.Len())
        for i := 0; i < s.Len(); i++ {
            arr[i] = f(s.Index(i).Interface())
        }
        return arr
    }
    return nil
}

origin := []int{4,5,3}
newArray := Map(origin, func(item interface{}) interface{} { return item.(int) + 1})

您可以使用lo's Map来快速地将函数应用到所有元素。例如，要乘以2并转换为字符串，您可以用途：

l := lo.Map[int, string]([]int{1, 2, 3, 4}, func(x int, _ int) string { return strconv.Itoa(x * 2) })

然后，您可以转换回逗号分隔的字符串，如下所示：strings.Join(l, ",")