Le go est-il une langue interprétée ?

go est un langage interprété. Go (également connu sous le nom de Golang) est un langage de programmation concurrent, compilé et fortement typé, doté de capacités de récupération de place développées par Google. Les avantages du langage go : courbe d'apprentissage facile, haute efficacité de développement et de fonctionnement, bibliothèque standard puissante, formatage du code source défini au niveau du langage, etc.

L'environnement d'exploitation de ce tutoriel : système Windows 10, GO 1.18, ordinateur thinkpad t480.

Go (également connu sous le nom de Golang) est un langage compilé statiquement fortement typé développé par Robert Griesemer, Rob Pike et Ken Thompson de Google.

La syntaxe de Go est proche du langage C, mais la déclaration des variables est différente. Go prend en charge le ramassage des ordures. Le modèle parallèle de Go est basé sur le processus séquentiel de communication (CSP) de Tony Hall. D'autres langages qui adoptent un modèle similaire incluent Occam et Limbo, mais il possède également des fonctionnalités des opérations Pi, telles que la transmission par canal. La prise en charge des plugins est ouverte dans la version 1.8, ce qui signifie que certaines fonctions peuvent désormais être chargées dynamiquement depuis Go.

Par rapport à C++, Go n'inclut pas de fonctions telles que l'énumération, la gestion des exceptions, l'héritage, les génériques, les assertions, les fonctions virtuelles, etc., mais il ajoute le type de tranche, la concurrence, les tuyaux, le garbage collection, le niveau de langage. prise en charge de fonctionnalités telles que les interfaces. La version Go 2.0 prendra en charge les génériques, mais a une attitude négative envers l'existence d'assertions et défend également le fait qu'elle ne fournit pas d'héritage de type.

Contrairement à Java, Go possède des tableaux associatifs intégrés (également appelés hachages ou dictionnaires), tout comme les types de chaînes.

Avantages du langage Go

Go est facile à apprendre

C'est vrai : si Si vous connaissez un langage de programmation, vous pouvez maîtriser la plupart de la syntaxe de Go en étudiant "Go Language Journey" pendant quelques heures et écrire votre premier vrai programme en quelques jours. Lisez et comprenez la programmation Go pratique, parcourez la documentation du package, jouez avec des boîtes à outils Web comme Gorilla ou Go Kit, et vous serez un très bon développeur Go.

C'est parce que l'objectif principal de Go est la simplicité. Quand j’ai commencé à apprendre Go, cela m’a rappelé ma première découverte de Java : un langage simple et une bibliothèque standard riche mais pas pléthorique. Comparé à l’environnement Java actuel, apprendre Go est une expérience rafraîchissante. En raison de la simplicité de Go, les programmes Go sont très lisibles, bien que la gestion des erreurs ajoute quelques maux de tête (plus d'informations ci-dessous).

La simplicité du langage Go peut être une erreur. Pour citer Rob Pike, la simplicité est à la fois complexe et nous verrons qu'il y a de nombreux pièges qui nous attendent derrière la simplicité qui nous fera violer le principe DRY (Don't Repeat Yourself).

Programmation simultanée simple basée sur des goroutines et des canaux

Les goroutines sont probablement la meilleure fonctionnalité de Go. Ce sont des threads informatiques légers, distincts des threads du système d’exploitation.

Lorsqu'un programme Go effectue une opération qui semble bloquer les E/S, le runtime Go suspend en fait la goroutine et la reprend lorsqu'un événement indique qu'un résultat est disponible. Pendant ce temps, d’autres goroutines sont programmées pour être exécutées. Par conséquent, dans le modèle de programmation synchrone, nous bénéficions des avantages d’évolutivité de la programmation asynchrone.

Les goroutines sont également légères : leurs piles augmentent et diminuent en fonction de la demande, ce qui signifie qu'avoir des centaines, voire des milliers de goroutines ne pose aucun problème.

J'avais une vulnérabilité goroutine dans mon ancienne application : ces goroutines attendaient la fermeture d'un canal avant de terminer, et le canal ne se fermait jamais (un problème de blocage courant). Ce processus consomme 90 % du processeur sans raison, et la vérification des expvars montre 600 000 goroutines inactives. Je suppose que le planificateur de goroutines monopolise le processeur !

Bien sûr, les systèmes d'acteurs comme Akka peuvent facilement gérer des millions d'acteurs, en partie parce que les acteurs n'ont pas de piles, mais ils sont loin d'être aussi simples que des goroutines pour écrire des applications de requêtes/réponses massivement simultanées (c'est-à-dire http Apis).

Les canaux sont un moyen pour les goroutines de communiquer : ils fournissent un modèle de programmation pratique pour envoyer et recevoir des données entre goroutines sans avoir à s'appuyer sur de fragiles primitives de synchronisation de bas niveau. les chaînes ont leur propre ensemble de modèles d’utilisation.

Cependant, les canaux doivent être soigneusement examinés, car des canaux mal dimensionnés (qui ne sont pas mis en mémoire tampon par défaut) peuvent provoquer des blocages. Nous verrons également ci-dessous que l'utilisation de canaux n'empêche pas les conditions de concurrence en raison de son manque d'immuabilité.

Bibliothèque standard riche

La bibliothèque standard de Go est très riche, notamment pour tout ce qui touche au protocole réseau ou au développement d'API : client et serveur http, chiffrement, formats d'archives, compression , envoi d'e-mails et plus encore. Il existe même un analyseur HTML et un moteur de modèles assez puissant pour générer du texte et du HTML, qui filtre automatiquement les attaques XSS (telles que celles utilisées dans Hugo).

Les différentes API sont généralement simples et faciles à comprendre. Ils semblent parfois trop simplistes : cela est en partie dû au fait que le modèle de programmation goroutine signifie que nous ne devons nous soucier que des opérations « apparemment synchrones ». C'est aussi parce que certaines fonctions générales peuvent également remplacer de nombreuses fonctions spécialisées, comme je l'ai découvert récemment à propos des calculs de temps.

Go a des performances supérieures

Go compile vers un exécutable local. De nombreux utilisateurs de Go viennent de Python, Ruby ou Node.js. Pour eux, il s’agit d’une expérience passionnante car ils constatent une augmentation considérable du nombre de requêtes simultanées que le serveur peut gérer. C'est en fait tout à fait normal lorsque vous utilisez un langage interprété qui n'est pas concurrent (Node.js) ou qui dispose d'un verrou d'interpréteur global. Combiné à la simplicité du langage, cela explique pourquoi Go est passionnant.

Cependant, par rapport à Java, dans les tests de performances brutes, l'image n'est pas si claire. Là où Go bat Java, c'est dans l'utilisation de la mémoire et la récupération de place.

Le garbage collector de Go est conçu pour donner la priorité à la latence et éviter les temps d'arrêt, ce qui est particulièrement important dans les serveurs. Cela peut entraîner des coûts de processeur plus élevés, mais dans une architecture évolutive horizontalement, ce problème est facilement résolu en ajoutant davantage de machines. N'oubliez pas que Go a été conçu par Google et qu'ils ne manquent jamais de ressources.

Le garbage collector (GC) de Go a moins à faire que Java : une tranche est une structure de tableau contigu, pas un tableau de pointeurs comme Java. De même, les cartes Go utilisent également de petits tableaux comme compartiments pour atteindre le même objectif. Cela signifie moins de travail pour le garbage collector et une meilleure localisation du cache CPU.

Go a également un avantage sur Java dans les utilitaires de ligne de commande : en tant qu'exécutable natif, les programmes Go n'ont pas de surcharge de démarrage, alors que Java nécessite d'abord que le bytecode soit chargé et compilé.

Définition au niveau linguistique du formatage du code source

Certains des débats les plus houleux de ma carrière ont eu lieu sur la définition du format du code dans les équipes. Go résout ce problème en définissant un format canonique pour le code. L'outil gofmt reformatera votre code et n'aura aucune option.

Qu'on le veuille ou non, gofmt définit comment formater le code, résolvant ainsi ce problème une fois pour toutes.

Cadre de test standardisé

Go fournit un bon cadre de test dans sa bibliothèque standard. Il prend en charge les tests parallèles, l'analyse comparative et comprend de nombreux utilitaires permettant de tester facilement les clients et les serveurs du réseau.

Les programmes Go sont faciles à utiliser

Devoir installer un seul fichier exécutable est un rêve pour les ingénieurs d'exploitation par rapport à Python, Ruby ou Node.js. À mesure que Docker est de plus en plus utilisé, ce problème devient de moins en moins important, mais les exécutables autonomes signifient également de petites images Docker.

Go dispose également de fonctionnalités d'observabilité intégrées, permettant de publier des statuts et des métriques internes à l'aide du package expvar, et de faciliter l'ajout de nouveau contenu. Mais soyez prudent car ils sont automatiquement exposés dans le gestionnaire de requêtes http par défaut et ne sont pas protégés. Java a quelque chose de similaire à JMX, mais c'est beaucoup plus complexe.

Instruction Defer pour éviter d'oublier de nettoyer

Le but de l'instruction defer est similaire à celui de Java finalement : exécuter du code de nettoyage à la fin de la fonction actuelle, quelle que soit la façon dont cette fonction se termine. Ce qui est intéressant avec le defer, c'est qu'il n'a aucun lien avec le bloc de code et peut apparaître à tout moment. Cela maintient le code de nettoyage aussi proche que possible du code qui doit être nettoyé :

file, err := os.Open(fileName)
if err != nil {
    return
}
defer file.Close()
// 用文件资源的时候，我们再也不需要考虑何时关闭它

Bien sûr, les ressources d'essai de Java sont moins verbeuses, et Rust déclare automatiquement la ressource lorsque son propriétaire est supprimé, mais depuis Go vous oblige à connaître explicitement le nettoyage des ressources, il est donc bon de le rapprocher de l'allocation des ressources.

Nouveaux types

J'aime les types parce qu'il y a certaines choses qui m'ennuient et me font peur, par exemple nous traitons les identifiants d'objets persistants partout comme des chaînes ou des types longs qui passent. Nous codons généralement le type d'identifiant dans le nom du paramètre, mais cela crée des bugs subtils lorsqu'une fonction a plusieurs identifiants comme paramètres et que certains appels ne correspondent pas à l'ordre des paramètres.

Go prend en charge de première classe les nouveaux types, c'est-à-dire que le type est un type existant et qu'il reçoit une identité indépendante différente du type d'origine. Contrairement à l’empaquetage, les nouveaux types n’ont aucune surcharge d’exécution. Cela permet au compilateur de détecter ce genre d'erreur :

type UserId string // <-- new type
type ProductId string
func AddProduct(userId UserId, productId ProductId) {}
func main() {
    userId := UserId("some-user-id")
    productId := ProductId("some-product-id")
    // 正确的顺序： 没有问题
    AddProduct(userId, productId)
    // 错误的顺序：将会编译错误 
    AddProduct(productId, userId)
    // 编译错误：
    // AddProduct 不能用 productId(type ProductId) 作为 type UserId的参数
    // Addproduct 不能用 userId(type UserId) 作为type ProfuctId 的参数 
}

Malheureusement, le manque de génériques rend le travail avec de nouveaux types fastidieux, car l'écriture de code réutilisable pour eux nécessite la conversion des valeurs des types primitifs.

Pour plus de connaissances sur la programmation, veuillez visiter : Vidéo de programmation ! !

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!