老实说，这个很简单，我就这样写出来：

package main

import "fmt"

func main() {

    s := []int{5, 2, 6, 3, 1, 4}

    for i, j := 0, len(s)-1; i < j; i, j = i+1, j-1 {
        s[i], s[j] = s[j], s[i]
    }

    fmt.Println(s)
}

http://play.golang.org/p/vkJg_D1yUb

（其他答案很好地解释了sort. Interface以及如何使用它；所以我不会重复。）

通常，要对整数数组进行排序，您可以将它们包装在IntSlice中，该IntSlice定义了方法Len、小和Swap。sort. Sort依次使用这些方法。sort.Reverse所做的是它采用定义Len、小和Swap的现有类型，但它用一个始终与底层小相反的新方法替换了小方法：

type reverse struct {
    // This embedded Interface permits Reverse to use the methods of
    // another Interface implementation.
    Interface
}

// Less returns the opposite of the embedded implementation's Less method.
func (r reverse) Less(i, j int) bool {
    return r.Interface.Less(j, i)
}

// Reverse returns the reverse order for data.
func Reverse(data Interface) Interface {
    return &reverse{data}
}

因此，当您编写sort. Reverse（sort.IntSlice（s））时，发生的事情是您正在获得这个新的、“修改”的IntSlice它的小方法被替换。因此，如果您在其上调用sort.Sort，它调用小，它将按降序排序。

我迟到了两年，但只是为了好玩和兴趣，我想贡献一个“古怪”的解决方案。

假设任务真的是反转列表，那么对于原始性能来说，bgp的解决方案可能是无与伦比的。它通过前后交换数组项来简单有效地完成工作，这种操作在数组和切片的随机访问结构中是有效的。

在函数式编程语言中，惯用的方法通常会涉及递归。这在Go中看起来有点奇怪，并且会有糟糕的性能。也就是说，这是一个递归数组反转函数（在一个小测试程序中）：

package main

import (
    "fmt"
)

func main() {
    myInts := []int{ 8, 6, 7, 5, 3, 0, 9 }
    fmt.Printf("Ints %v reversed: %v\n", myInts, reverseInts(myInts))
}

func reverseInts(input []int) []int {
    if len(input) == 0 {
        return input
    }
    return append(reverseInts(input[1:]), input[0]) 
}

输出：

Ints [8 6 7 5 3 0 9] reversed: [9 0 3 5 7 6 8]

同样，这是为了好玩而不是生产。它不仅很慢，而且如果列表太大，它会溢出堆栈。我刚刚测试过，它会反转100万int的列表，但在1000万崩溃。