编辑：这个答案已经过时了。从 1.21 开始，Go 中现在有内置函数 min 和 max。请参阅 Jonas 的回答。

没有内置此功能。

如果您仅在一个包中需要此功能，则可以编写一个未导出的函数（例如 minIntSlice ）。

如果您需要在多个包中使用此功能，则可以创建一个包并将类似的功能放入其中。您应该考虑将此包设为内部包（ https://golang.org/s/go14internal ）。

关于如何改进代码的一些建议：

1. p5

2. p6

    for i, e := range v {     if i==0 || e < m {         m = e     } }

如果不给出值的索引，它将为您提供最小值 0，这可能不存在于给定的值中，因此您还必须对索引应用条件。

感谢您提供指向“内部”包的指针。我确实有类似的未导出的重复函数，而内部看起来是更好地维护这些函数的方法。

这个答案已经过时了。从 1.21 开始，Go 中现在有内置函数 min 和 max。请参阅 Jonas 的答案。

从 Go 开始， 1.21 现在有内置函数来获取 max 和 min ，以及一个新的 slices 包来实现切片的相同功能。

https://go.dev/ref/spec#Min_and_max

min(2, -5, 8, 1.2) // Result: -5
max(2, -5, 8, 1.2) // Result: 8

对于切片，请使用以下 slices 包： https://pkg.go.dev/slices

import "slices"

x := []float64{2, -5, 8, 1.2}
slices.Min(x) // Result: -5
slices.Max(x) // Result: 8

正如@kostya正确指出的那样，Golang中没有内置的最小值或最大值函数。

不过，我建议一个稍微不同的解决方案：

func MinMax(array []int) (int, int) {
    var max int = array[0]
    var min int = array[0]
    for _, value := range array {
        if max < value {
            max = value
        }
        if min > value {
            min = value
        }
    }
    return min, max
}

这样就解决了空切片的问题：出现运行时错误（ index out of range ）并且最大值是免费的。:-)

    min := s[0]
    for i :=1; i < len(s); i++ {
        if min > s[i] {
            min = s[i]
        }
    }

min > s[i]? min = s[i] : min

请不要只发布代码作为答案，还应解释您的代码的作用以及它如何解决问题。带有解释的答案通常更有帮助且质量更高，也更有可能吸引点赞。

如果你不关心输入数组

import . "sort"
func MinIntSlice(v []int){
    Ints(v)
    return z[0]
}

func MaxIntSlice(v []int){
    Ints(v)
    return z[len(v)-1]
}
// and MinMax version
func MinMax(v []int)(int,int){
    Ints(v)
    return z[0],z[len(v)-1]
}

此包 用于单独值或切片的 Min 实现 Max 和 go get 可以像这样使用：

import (
    "fmt"
    "<Full URL>/go-imath/ix" // Functions for int type
)
...
fmt.Println(ix.Min(100, 152)) // Output: 100
fmt.Println(ix.Mins(234, 55, 180)) // Output: 55
fmt.Println(ix.MinSlice([]int{2, 29, 8, -1})) // Output: -1

标准包中没有此类操作的函数。

但是， gonum 库 提供了函数 floats.Min(x) 和 floats.Max(x) （以及其他用于处理数值数据的有趣函数）。

用法：

package main

import (
    "fmt"
    "gonum.org/v1/gonum/floats"
)

func main() {
    x := []float64{1, 6, 9, -3, -5}
    minX := floats.Min(x)
    maxX := floats.Max(x)
    fmt.Printf("Min: %f, max %f\n", minX, maxX)
}

结果：

Min: -5.000000, max 9.000000

对于包含数百万个项目的巨大切片（例如 25 万像素的图像 []int ），你可以通过分块计算最小值/最大值来获得显著的性能提升：

func GetMinMax(data []int) (int, int) {
    minVal := data[0]
    maxVal := data[0]
    for i := range data {
        if data[i] < minVal {
            minVal = data[i]
        }

        if data[i] > maxVal {
            maxVal = data[i]
        }
    }

    return minVal, maxVal
}

func GetMinMaxConcurrent(data []int) (int, int) {
    numChan := make(chan int)

    numChunks := runtime.NumCPU()
    chunkSize := len(data) / numChunks

    // Process
    var wg sync.WaitGroup
    for i := 0; i < numChunks; i++ {
        wg.Add(1)
        go func(i, chunkSize int, numChan chan int) {
            startIndex := i * chunkSize
            endIndex := startIndex + chunkSize
            if endIndex > len(data) {
                endIndex = len(data)
            }

            minVal, maxVal := GetMinMax(data[startIndex:endIndex])
            numChan <- minVal
            numChan <- maxVal
            wg.Done()
        }(i, chunkSize, numChan)
    }

    // Collect results
    resultsChan := make(chan int)
    defer close(resultsChan)

    go func(numChan, resultsChan chan int) {
        arr := make([]int, 0)
        for num := range numChan {
            arr = append(arr, num)
        }
        minVal, maxVal := GetMinMax(arr)
        resultsChan <- minVal
        resultsChan <- maxVal
    }(numChan, resultsChan)

    wg.Wait()
    close(numChan) // needed so results routine can return

    return <-resultsChan, <-resultsChan
}

此代码不适用于小切片，仅当您的切片足够大以便能够从同时处理块中受益时才使用。

通过排序，它可以更短：

func MinIntSlice(v []int) int {
  sort.Ints(v)
  return v[0]
}

func MaxIntSlice(v []int) int {
  sort.Ints(v)
  return v[len(v)-1]
}

但不要忘记根据您的喜好对其进行修改以获得零长度切片。

仅仅为了挑选一些东西而改变底层切片是一个糟糕的想法。这可能会改变其他地方隐式排序的断言

排序是o（n log n）但最大值是线性时间o（n）算法，这个“代码更短”但算法更差。

是的，这远非最佳。但是当你需要在算法中间的某个地方对小切片进行最小/最大操作时，可以对其进行排序并取第一个/最后一个，而不是创建你永远不会再使用的单独函数。

使用@kostya的 答案

2. p1

   for i, e := range v {    if i==0 || e < m {        m = e    }}

如果不给出值的索引，它将给出最小值 0，这可能不存在于给定的值中