Existe-t-il une meilleure alternative pour les paramètres variadiques de Golang ?

Les meilleures alternatives aux fonctions variadiques sont : Utiliser des tranches comme arguments Utiliser des structures comme arguments Utiliser le currying de fonctions

De meilleures alternatives aux fonctions variadiques dans Go

Les arguments variadiques dans Go Les fonctions permettent de transmettre n'importe quel nombre de paramètres via le ... syntaxe. Bien que cela soit pratique dans certains cas, cela a également ses limites, notamment : ... 语法允许传递任意数量的参数。虽然这在某些情况下很方便，但也有其局限性，包括：

• 类型不安全： 可变参数函数的参数没有明确的类型，这可能会导致类型检查器无法检测到错误。
• 效率低下： 可变参数函数内部通常使用切片，这会带来额外的内存分配和复制开销。

替代方案

有几种替代方案可以替代可变参数函数：

1. 使用切片作为参数：

func max(numbers []int) int {
    if len(numbers) == 0 {
        return 0
    }

    max := numbers[0]
    for _, n := range numbers {
        if n > max {
            max = n
        }
    }
    return max
}

2. 使用 structs 作为参数：

type Stats struct {
    Mean float64
    Median float64
    Mode float64
}

func calcStats(nums []float64) Stats {
    // ... 计算统计数据并填充 `Stats` struct
    return Stats{
        Mean: mean,
        Median: median,
        Mode: mode,
    }
}

3. 使用函数柯里化：

柯里化将一个多参数函数转换为一个一系列单参数函数的过程。例如，我们可以对 max

• Type non sécurisé :

  Les paramètres d'une fonction variadique n'ont pas de type explicite, ce qui peut entraîner l'échec du vérificateur de type. détecté.

• Inefficacité : Les tranches sont généralement utilisées dans des fonctions variadiques, ce qui entraînera une allocation de mémoire supplémentaire et une surcharge de copie.

Alternatives

Il existe plusieurs alternatives aux fonctions variadiques : 🎜🎜🎜1 Utiliser des tranches comme paramètres : 🎜🎜

func maxCurried(ns ...int) int {
    return func(n int) int {
        if n > ns[0] {
            ns[0] = n
        }
        return ns[0]
    }
}

🎜🎜2. Utiliser des structures comme paramètres : 🎜 🎜

package main

import (
    "fmt"
    "time"
)

func maxVarargs(nums ...int) int {
    if len(nums) == 0 {
        return 0
    }

    max := nums[0]
    for _, n := range nums {
        if n > max {
            max = n
        }
    }
    return max
}

func maxSlice(nums []int) int {
    if len(nums) == 0 {
        return 0
    }

    max := nums[0]
    for _, n := range nums {
        if n > max {
            max = n
        }
    }
    return max
}

func main() {
    // 产生一个包含 100 万个随机整数的切片
    nums := make([]int, 1000000)
    for i := range nums {
        nums[i] = rand.Int()
    }

    // 使用可变参数函数计算最大值
    start := time.Now()
    maxVarargs(nums...)
    elapsedVarargs := time.Since(start)

    // 使用切片函数计算最大值
    start = time.Now()
    maxSlice(nums)
    elapsedSlice := time.Since(start)

    fmt.Println("MaxVarargs execution time:", elapsedVarargs)
    fmt.Println("MaxSlice execution time:", elapsedSlice)
}

🎜🎜3. .Utiliser le currying de fonctions : 🎜🎜🎜Le currying est le processus de conversion d'une fonction multi-paramètres en une série de fonctions à paramètre unique. Par exemple, nous pouvons curry la fonction max : 🎜rrreee🎜🎜Cas pratique🎜🎜🎜Supposons que nous ayons une fonction qui doit calculer la valeur maximale d'une série d'entiers. Comparons en utilisant des paramètres variables Efficacité. de fonctions et de fonctions slice : 🎜rrreee🎜Exécutez ce programme et nous verrons que les fonctions slice sont nettement plus rapides que les fonctions variadiques. 🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!