Analyse de l'efficacité du passage des paramètres de fonction dans Golang

Le passage des paramètres de la fonction Golang a deux méthodes : le passage de valeur et le passage de référence. Le passage par valeur crée une copie du paramètre, qui est sûre mais coûteuse ; le passage par référence transmet le pointeur de paramètre, ce qui est bon marché mais comporte le risque de modifier la valeur d'origine et de problèmes de concurrence.

Analyse de l'efficacité du passage des paramètres de fonction dans Golang

Le passage des paramètres de fonction joue un rôle important dans les performances du programme, en particulier pour les grandes structures de données ou les objets complexes. Golang propose deux méthodes pour transmettre des paramètres de fonction : la transmission de valeurs et la transmission de références.

Passage par valeur

Le passage par valeur crée une copie de la valeur du paramètre et la transmet à la fonction. Il s'agit d'une méthode de transmission sûre car les modifications apportées aux paramètres à l'intérieur de la fonction n'affectent pas les valeurs d'origine de l'appelant. Cependant, si les paramètres transmis sont des structures de données volumineuses ou des objets complexes, une surcharge de mémoire et un temps de copie supplémentaires seront nécessaires.

func foo(x int) {
    x++ // 修改 x 的副本，不会影响调用者原始值
}

Pass by reference

Pass by référence transmet le pointeur vers le paramètre, pas la valeur elle-même. Cela peut réduire considérablement la surcharge de mémoire et le temps de copie, en particulier lors de la transmission de structures de données volumineuses ou d'objets complexes. Cependant, le passage par référence présente les inconvénients suivants :

1. Modification des paramètres : La modification du pointeur de paramètre à l'intérieur de la fonction affectera la valeur d'origine de l'appelant.
2. Problèmes de concurrence : Si le paramètre est une ressource partagée, le passage par référence peut entraîner des problèmes de concurrence.

func foo(x *int) {
    *x++ // 修改原始值，因为传递的是指针
}

Un cas pratique

Ce qui suit est un cas pratique comparant les performances du passage par valeur et du passage par référence :

package main

import (
    "fmt"
    "time"
)

type LargeStruct struct {
    Data []byte
}

func main() {

    // 创建一个大型结构
    largeStruct := &LargeStruct{Data: make([]byte, 1000000)}

    // 使用值传递
    start := time.Now()
    for i := 0; i < 100000; i++ {
        foo(largeStruct)
    }
    elapsed1 := time.Since(start)

    // 使用引用传递
    start = time.Now()
    for i := 0; i < 100000; i++ {
        fooPtr(largeStruct)
    }
    elapsed2 := time.Since(start)

    fmt.Println("值传递耗时：", elapsed1)
    fmt.Println("引用传递耗时：", elapsed2)
}

func foo(largeStruct LargeStruct) {}

func fooPtr(largeStruct *LargeStruct) {}

Dans ce cas, le passage par valeur est beaucoup plus lent que le passage par référence, car le foo La fonction est copiée à chaque fois qu'elle est appelée dans sa totalité.

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!