IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)

Vous êtes nouveau sur Developpez.com ? Créez votre compte ou connectez-vous afin de pouvoir participer !

Vous devez avoir un compte Developpez.com et être connecté pour pouvoir participer aux discussions.

Vous n'avez pas encore de compte Developpez.com ? Créez-en un en quelques instants, c'est entièrement gratuit !

Si vous disposez déjà d'un compte et qu'il est bien activé, connectez-vous à l'aide du formulaire ci-dessous.

Identifiez-vous
Identifiant
Mot de passe
Mot de passe oublié ?
Créer un compte

L'inscription est gratuite et ne vous prendra que quelques instants !

Je m'inscris !

La version 1.26 de Go, le langage de programmation développé par Google, est disponible avec des modifications du langage, un nouveau ramasse-miettes, des performances améliorées et bien plus encore

Le , par Anthony

653PARTAGES

5  0 
Go 1.26 est désormais disponible. La dernière version du langage de programmation développé par Google introduit deux modifications de la syntaxe du langage : une simplification de la fonction intégrée « new », qui permet désormais à son opérande d'être une expression, et la possibilité pour les types génériques de se référencer à eux-mêmes dans les listes de paramètres de type. Cette mise à jour active également par défaut le ramasse-miettes Green Tea (GC), plus performant, et apporte d'autres améliorations en termes de performances.

Go est un langage de programmation généraliste de haut niveau, statiquement typé et compilé. Il est connu pour la simplicité de sa syntaxe et l'efficacité du développement qu'il permet grâce à l'inclusion d'une grande bibliothèque standard répondant à de nombreux besoins pour les projets courants. Il a été conçu chez Google en 2007 par Robert Griesemer, Rob Pike et Ken Thompson, puis annoncé publiquement en novembre 2009. Sa syntaxe est similaire à celle du C, mais il dispose également d'un ramasse-miettes, d'un typage structurel et d'une concurrence de type CSP.


Go 1.26 introduit plusieurs améliorations majeures du langage et du runtime pour les développeurs. La nouvelle fonction intégrée est désormais plus flexible, car elle accepte des expressions pour les opérandes, ce qui simplifie la spécification des valeurs initiales des variables. Cela est particulièrement utile lors du remplissage de champs facultatifs dans les workflows de sérialisation, tels que ceux utilisant encoding/json ou les tampons de protocole qui utilisent souvent des pointeurs.

Par ailleurs, Go 1.26 permet désormais aux types génériques de se référencer eux-mêmes dans les listes de paramètres de type, ce qui ouvre la voie à des modèles d'abstraction de type plus avancés. Les développeurs bénéficient d'une assistance supplémentaire grâce à la commande go fix entièrement remaniée, qui regroupe désormais les modernizers de Go afin d'automatiser les mises à jour des bases de code, d'appliquer des idiomes modernes et de faciliter les migrations d'API à l'aide d'une suite de fixers et d'un inlineur au niveau de la source.

En termes de performances, le ramasse-miettes Green Tea est désormais activé par défaut, poursuivant ainsi les améliorations apportées en matière d'optimisation et de stabilité lors des expérimentations précédentes. L'efficacité d'exécution est améliorée grâce à une réduction d'environ 30 % de la surcharge des appels cgo. Pour une sécurité renforcée, les plateformes 64 bits bénéficient désormais d'une randomisation de l'adresse de base du tas au démarrage, ce qui rend plus difficile l'exploitation des bogues de mémoire dans cgo.

À la suite de ces changements, Go 1.26 lance également un profil expérimental de fuite de goroutines et apporte d'autres mises à jour au compilateur, au linker, aux routines bootstrap et à la bibliothèque standard.

Modifications du langage

Go 1.26 introduit deux améliorations significatives à la syntaxe du langage et au système de types.

Tout d'abord, la nouvelle fonction intégrée, qui crée une nouvelle variable, permet désormais à son opérande d'être une expression, spécifiant la valeur initiale de la variable.

Un exemple simple de ce changement signifie qu'un code tel que celui-ci :

Code Go : Sélectionner tout
1
2
x := int64(300)
ptr := &x
Peut être simplifié comme suit :

Code Go : Sélectionner tout
ptr := new(int64(300))
Cette fonctionnalité est particulièrement utile lorsque vous travaillez avec des paquets de sérialisation tels que encoding/json ou les tampons de protocole qui utilisent un pointeur pour représenter une valeur facultative, car elle permet de remplir un champ facultatif dans une expression simple, par exemple :

Code Go : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import "encoding/json"
 
type Person struct {
    Name string   `json:"name"`
    Age  *int     `json:"age"` // age if known; nil otherwise
}
 
func personJSON(name string, born time.Time) ([]byte, error) {
    return json.Marshal(Person{
        Name: name,
        Age:  new(yearsSince(born)),
    })
}
 
func yearsSince(t time.Time) int {
    return int(time.Since(t).Hours() / (365.25 * 24)) // approximately
}
Deuxièmement, la restriction selon laquelle un type générique ne peut pas faire référence à lui-même dans sa liste de paramètres de type a été supprimée. Il est désormais possible de spécifier des contraintes de type qui font référence au type générique contraint. Ce changement simplifie la mise en œuvre de structures de données et d'interfaces complexes.

Par exemple, un type générique Adder peut exiger d'être instancié avec un type qui lui est similaire :

Code Go : Sélectionner tout
1
2
3
4
5
6
7
type Adder[A Adder[A]] interface {
    Add(A) A
}
 
func algo[A Adder[A]](x, y A) A {
    return x.Add(y)
}
Auparavant, l'autoréférence à Adder dans la première ligne n'était pas autorisée. Outre le fait de rendre les contraintes de type plus puissantes, cette modification simplifie également très légèrement les règles de spécification pour les paramètres de type.

Améliorations apportées aux outils

Commande Go

La vénérable commande go fix a été entièrement remaniée et héberge désormais les modernisateurs de Go. Elle offre désormais un moyen fiable et instantané de mettre à jour les bases de code Go vers les dernières expressions idiomatiques et API de bibliothèque centrale. La suite initiale de moderniseurs comprend des dizaines de correcteurs permettant d'utiliser les fonctionnalités modernes du langage et de la bibliothèque Go, ainsi que l'analyseur inline au niveau source qui permet aux utilisateurs d'automatiser leurs propres migrations d'API à l'aide des directives inline //go:fix. Ces correcteurs ne devraient pas modifier le comportement de votre programme.

La commande go fix réécrite s'appuie sur le même framework d'analyse Go que go vet. Cela signifie que les mêmes analyseurs qui fournissent des diagnostics dans go vet peuvent être utilisés pour suggérer et appliquer des corrections dans go fix. Les correcteurs historiques de la commande go fix, qui étaient tous obsolètes, ont été supprimés.

go mod init utilise désormais par défaut une version inférieure de Go dans les nouveaux fichiers go.mod. L'exécution de go mod init à l'aide d'une chaîne d'outils de version 1.N.X créera un fichier go.mod spécifiant la version Go go 1.(N-1).0. Les versions préliminaires de 1.N créeront des fichiers go.mod spécifiant go 1.(N-2).0. Par exemple, les versions candidates de Go 1.26 créeront des fichiers go.mod avec go 1.24.0, et Go 1.26 et ses versions mineures créeront des fichiers go.mod avec go 1.25.0. Cela vise à encourager la création de modules compatibles avec les versions actuellement prises en charge de Go. Pour un contrôle supplémentaire de la version de Go dans les nouveaux modules, go mod init peut être suivi de go get go@version.

cmd/doc et go tool doc ont été supprimés. go doc peut être utilisé en remplacement de go tool doc : il accepte les mêmes flags et arguments et se comporte de la même manière.

Pprof

L'interface utilisateur Web de l'outil pprof, activée avec le drapeau -http, affiche désormais par défaut le graphique en flammes. L'ancien graphique est disponible dans le menu « Affichage -> Graphique » ou via /ui/graph.

Améliorations des performances

Le compilateur peut désormais allouer la mémoire de sauvegarde pour les tranches sur la pile dans davantage de situations, ce qui améliore les performances.

Nouveau ramasse-miettes

Le ramasse-miettes Green Tea, précédemment disponible à titre expérimental dans Go 1.25, est désormais activé par défaut.

La conception de ce ramasse-miettes améliore les performances du marquage et du balayage des...
La fin de cet article est réservée aux abonnés. Soutenez le Club Developpez.com en prenant un abonnement pour que nous puissions continuer à vous proposer des publications.

Une erreur dans cette actualité ? Signalez-nous-la !

Avatar de dolanor
Membre habitué https://www.developpez.com
Le 13/02/2026 à 13:34
Bien content de cette version.

Des retours que j'ai vu, les gains sur CGO et le garbage collection sont assez sympatiques !

Faudrait que je teste sur la démo du moteur 3D g3n.

Et je suis trop content qu'ils réinvestissent sur go fix, un outil tellement sous côté
2  0