Quoi de neuf dans Go Version 1.18

Le langage de programmation Go a beaucoup évolué depuis sa première publication en 2009. Go 1.18 était une version très attendue en raison de sa prise en charge des génériques et de nombreuses autres mises à jour importantes.

Go a publié la version 1.18 en mars 2022. Voici la liste des changements les plus importants.

Prise en charge des génériques

La programmation générique vous permet d'écrire des fonctions qui peuvent accepter et renvoyer des types plus flexibles.

Avant la prise en charge des génériques, vous deviez déclarer explicitement les types de paramètres et les types de retour. La forme la plus simple des génériques vous permet de spécifier des paramètres non typés :

fonctionImprimer n'importe quoi[T tout](choseJ) {
fmt.Println(chose)
}

Mais les génériques offrent bien plus de pouvoir que cela. Vous pouvez déclarer presque n'importe quelle combinaison et granularité de type pour les paramètres. Par exemple, vous pouvez utiliser le contraintes package pour écrire une fonction qui opère sur n'importe quelle valeur que vous pouvez commander. Cela inclut int, floats et strings. Voici un exemple qui illustre la syntaxe :

importer "golang.org/x/exp/constraints"
fonctionMax[T contraintes. Commandé](saisir[]J) (maximumJ) {
 pour _, v := plage d'entrée {
 si v > maximum {
 max = v
 }
 }
retourner maximum
}

Notez que cette fonction utilise le type générique, contraintes. Commandé, pour déclarer son paramètre et son type de retour.

Les génériques offrent une incertitude et une flexibilité dans le code. La proposition de génériques et les modifications sont rétrocompatibles.

Test de fuzz

Le fuzzing est un technique de test logiciel qui valide un programme avec des données erronées, inattendues ou imprévisibles.

Le essai introduit le fuzzing en 1.18, donc pour définir un fuzz, vous devez l'importer depuis la bibliothèque standard :

importer "essai"

Après avoir importé le essai package, vous pouvez passer un identifiant de type *essai. F à la fonction de test.

fonctiontestFunc(f *test. F) {
// votre code 
}

Le fuzzing génère des paramètres d'entrée pour tester le code. Le résultat du fuzzing est imprévisible car les entrées ne sont pas définies par l'utilisateur. Le fuzzing devrait vous aider à écrire de meilleurs tests de code et à détecter des bogues dont vous ignoriez l'existence.

Prise en charge de l'espace de travail Go

Les espaces de travail sont des répertoires de code source similaire qui constituent un projet ou une unité plus grande. Les espaces de travail facilitent la gestion et le débogage du code en regroupant le code similaire en fonction des fonctionnalités.

Classiquement, vous subdivisez les projets Go en code source (src) et les fichiers exécutables (poubelle). La chaîne d'outils Go construit le code source du premier dans des exécutables du second. Les espaces de travail Go permettent aux développeurs de travailler avec plusieurs espaces de travail en utilisant des modules Go avec un module principal particulier.

La commande pour créer des espaces de travail est :

$ aller travailler <commande>

Utilisez le travail commande avec des sous-commandes comme :

• initialiser → crée un espace de travail dans le répertoire spécifié.
• utiliser → ajoute un nouveau module à go.work, le fichier d'espace de travail go.
• Éditer → édite le fichier d'espace de travail go.
• synchroniser → synchronise les dépendances de la liste de compilation avec les modules de l'espace de travail.

L'inclusion d'espaces de travail à emporter augmenterait la productivité comme prévu dans le développement du langage.

Amélioration des performances

Aller la version 1.18 prend désormais en charge ARM64 Apple M1 et PowerPC 64 bits dans la convention d'appel ABI. Cela se traduit par un gain de plus de 10% des performances du processeur pour les utilisateurs de ces appareils.

Les variables déclarées et inutilisées dans les fonctions sont désormais enregistrées comme des erreurs lors de la compilation du programme.

Le allez construire commande, ainsi que d'autres commandes connexes, prend en charge la -asan flag, qui prend en charge l'interopérabilité avec C/C++. Cela aidera les développeurs Go à utiliser les programmes Go avec les programmes C et C++.

Autres mises à jour importantes

Le va chercher La commande n'installe plus les packages en mode compatible avec les modules, ce qui est un grand changement par rapport au moment où vous j'ai commencé avec Go. Le allez installer la commande remplace avoir pour ajuster les dépendances des modules entre les espaces de travail.

Étant donné que le vérificateur de type gère désormais les génériques, les messages d'erreur peuvent être consignés différemment que dans les versions précédentes.

Le temps de compilation des programmes peut être plus lent dans la version 1.18. Mais cela n'affectera pas le temps d'exécution une fois que Go aura compilé votre programme.

Vous pouvez trouver tous les détails de toutes les dernières modifications dans les notes de version pour Aller 1.18.

Go 1.18 a plusieurs ajouts divers

Avec Go 1.18, vous pouvez désormais écrire du code générique, tester efficacement à l'aide du fuzzing et basculer entre les modules Go à l'aide d'espaces de travail. Vous pouvez même écrire du code qui fonctionne en conjonction avec des programmes C et C++.

Golang vaut-il la peine d'être appris aujourd'hui ?

Lire la suite

A propos de l'auteur