Go Academy · Leçon

new() et quand utiliser les pointeurs

Allocation avec new et modèles courants de pointeurs

new() et quand utiliser les pointeurs est une leçon Go Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Go Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Go Academy comprend 4 leçons au total.

La fonction intégrée new()

new(T) alloue un T initialisé à zéro et retourne un *T. Pour les structures, cela équivaut à &T{} :

package main
import "fmt"

func main() {
    p := new(int)
    fmt.Println(*p)     // 0
    *p = 42
    fmt.Println(*p)     // 42

    type Point struct{ X, Y int }
    pt := new(Point)
    fmt.Println(*pt)    // {0 0}
}

new contre &T{}

Pour les structures, &T{} est plus idiomatique et permet d'initialiser les champs. new est rarement utilisé dans le Go moderne :

package main
import "fmt"

type Config struct{ Port int; Host string }

func main() {
    a := new(Config)          // zeroed
    b := &Config{Port: 8080}  // initialized
    fmt.Println(a, b)
}

Quand retourner un pointeur

Retournez un pointeur depuis un constructeur lorsque :

La structure contient un état et les appelants doivent partager la même instance
La structure possède des méthodes avec récepteur de pointeur (nécessaire pour satisfaire une interface)
La structure est grande et les copies seraient coûteuses

Quand retourner une valeur

Retournez une valeur lorsque :

Le type est petit (quelques champs)
Il s'agit d'une configuration immuable
Vous voulez indiquer clairement que les appelants obtiennent des copies indépendantes

Exemple : time.Time est retourné par valeur bien qu'il possède de nombreuses méthodes.

Pointeurs dans les tranches et les tables associatives

Stocker des pointeurs dans des collections permet de partager les modifications :

package main
import "fmt"

type User struct{ Name string; Score int }

func main() {
    users := []*User{{"Alice", 0}, {"Bob", 0}}
    users[0].Score = 100
    fmt.Println(users[0]) // &{Alice 100}
}

Pointeur vers un type primitif pour gérer l'absence

Un champ *int ou *string peut être nil pour signifier « non défini », ce qui est utile avec JSON et omitempty, ou pour les colonnes facultatives d'une base de données :

package main
import "fmt"

type Profile struct {
    Name string
    Age  *int // nil means not provided
}

func main() {
    p := Profile{Name: "Alice"}
    fmt.Println(p.Age == nil) // true
    age := 30
    p.Age = &age
    fmt.Println(*p.Age) // 30
}

Éviter la prolifération des pointeurs

Une utilisation excessive des pointeurs augmente la pression exercée sur le ramasse-miettes et réduit la localité du cache. Effectuez des mesures comparatives avant de remplacer des types valeur par des pointeurs uniquement pour des raisons de performances.

make contre new

make initialise les tranches, les tables associatives et les canaux (ils nécessitent une configuration interne). new alloue n'importe quel type initialisé à zéro et retourne un pointeur. Ces fonctions ont des rôles différents :

package main
import "fmt"

func main() {
    s := make([]int, 5)           // usable slice
    m := make(map[string]int)     // usable map
    p := new(int)                 // *int pointing to 0
    fmt.Println(s, m, *p)
}

Modèle de pointeur immuable

Retournez *T, mais documentez-le comme étant immuable ; les utilisateurs ne doivent pas le modifier. Ce modèle est courant pour les objets de configuration partagés entre plusieurs goroutines.

Résumé de la sécurité des pointeurs

Règles pour utiliser les pointeurs en toute sécurité :

Vérifiez toujours que la valeur n'est pas nil avant de la déréférencer
Ne stockez pas de pointeurs vers des variables de la pile plus longtemps que la durée de vie de la variable (l'analyse d'échappement de Go s'en charge)
Ne convertissez jamais un unsafe.Pointer, sauf en cas d'absolue nécessité
Laissez le compilateur gérer la pile et le tas

Vérification rapide

Que retourne new(int) ?

Récapitulatif : new et les pointeurs

Points essentiels :

new(T) retourne un *T initialisé à zéro ; il est rarement utilisé, préférez &T{}
Retournez des valeurs lorsque le type est petit ou immuable, et des pointeurs lorsqu'il contient un état ou est grand
Les champs de type *T permettent de représenter l'absence par nil
N'utilisez pas trop de pointeurs : le ramasse-miettes a un coût

Exercice pratique

Créez une structure Settings avec un champ *int pour MaxConnections. Écrivez une fonction qui accepte *Settings et définit une valeur par défaut uniquement lorsque le champ vaut nil.

Questions Fréquemment Posées

La leçon « new() et quand utiliser les pointeurs » est-elle gratuite ?

Oui — le texte complet de « new() et quand utiliser les pointeurs » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Go Academy, passe à CoddyKit PRO. Le cours Go Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « new() et quand utiliser les pointeurs » ?

Allocation avec new et modèles courants de pointeurs Tu pratiques Go Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Go Academy ?

Aucune expérience préalable n'est requise. Go Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « new() et quand utiliser les pointeurs » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Go Academy ?

Oui. Chaque leçon Go Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Go Academy