Bonjour, je suis ton petit "GO Language" mignon

Cette rubrique interprète de manière exhaustive les connaissances pertinentes dans le domaine du logiciel, avec un biais vers un contenu technique approfondi. Elle couvre principalement les langages de programmation, l'architecture système, les frameworks open source, la gestion technique, etc. . Il est divisé en plusieurs sujets, chaque sujet contient plusieurs articles.

Cet article est le premier article de la rubrique et le premier article de la série sur le langage GO. Aujourd'hui, je souhaite vous donner mon impression générale du langage GO sous tous ses aspects. Les articles suivants présenteront en profondeur chaque fonctionnalité. et compétences en programmation.

Introduction

Historiquement, les auteurs du langage Go sont Robert Griesemer, Rob Pike et Ken Thompson. Parmi eux, Ken Thompson est connu des programmeurs pour ses énormes contributions au développement des langages UNIX et C. . Familier. Quels logiciels sont écrits en Go jusqu'à présent ? Le logiciel de conteneur Docker, les logiciels de base ETCD et Kubernetes, les logiciels de base de données TiDB et InfluxDB, le système de messagerie NSQ et le composant de mise en cache GroupCache.

On peut constater que dans presque tous les domaines des logiciels d'infrastructure, de nouveaux logiciels écrits en langage Go ont émergé, et la part de marché de ces logiciels continue d'augmenter. En plus d'être un langage pour les logiciels d'infrastructure, le langage Go offre de plus en plus d'opportunités en tant que langage universel côté serveur. Certaines tendances de développement ressortent également de la popularité des frameworks Web du langage Go tels que Beego et Gorilla.

Exemple de programme

Jetons un coup d'œil au style de codage de GO à travers un exemple de programme simple :

1. Package main

2. importer "fmt"

3. func main(){

4. fmt.Println("hello,world");

5. }

Comment exécuter le code ci-dessus Le langage GO est un langage compilé, et la chaîne d'outils GO convertit les fichiers sources du programme en instructions natives liées à la machine (binaire), l'outil le plus basique est la commande run, qui peut compiler et lier un ou plusieurs fichiers source GO (avec .go comme suffixe), et commencer à exécuter le fichier exécutable généré après la liaison. regardez l'opération réelle :

1.$go run helloworld.go

Imprimer : hello,world

La compilation, la liaison et l'exécution ci-dessus ne font qu'un -time task , ce qui signifie que la prochaine fois que vous exécuterez la commande go run, tous les processus internes seront refaits. Nous pouvons générer un programme binaire via la commande go build, puis l'appeler arbitrairement, comme indiqué ci-dessous :

1. $go build helloworld.go

2. $./helloworld

3. hello,world

Ici, nous avons mentionné le langage compilé, qu'est-ce que le langage compilé Si le langage compilé est le programme écrit ? doit être reconnu par la machine. Il doit passer par deux étapes : la compilation et la liaison consistent à compiler le code source en code machine, et la liaison consiste à concaténer le code machine de chaque module et la bibliothèque dépendante pour générer un exécutable. déposer.

Jetons un coup d'œil aux avantages et aux inconvénients des langages compilés. En raison de l'existence du processus de pré-compilation, le code peut être optimisé et ne devra être compilé qu'une seule fois. il peut être indépendant de l'environnement du langage Run, l'inconvénient est que l'intégralité du module modifié doit être compilé.

Par rapport aux langages compilés, les langages interprétés ne traduiront que ligne par ligne lors de l'exécution du programme. Alors qu'est-ce que la liaison ? Pour être précis, la liaison et le chargement, c'est-à-dire effectuer ces deux étapes après la compilation, afin que le programme puisse s'exécuter en mémoire. La liaison est effectuée via un connecteur, qui relie plusieurs fichiers cibles en un fichier cible complet, chargeable et exécutable. L'ensemble du processus comprend la résolution des symboles (association des symboles d'application dans le fichier cible à deux étapes de définition correspondantes). définitions avec emplacements mémoire.

Convention de dénomination

Les noms des fonctions, constantes, variables, types, instructions, étiquettes et packages dans le langage GO ont des règles de dénomination relativement uniformes. Le nom commence par une lettre ou un trait de soulignement. , suivi de Il peut s'agir de n'importe quel nombre de caractères, de chiffres ou de traits de soulignement. Notez que le langage GO est sensible à la casse et que les mots-clés ne peuvent pas être utilisés comme noms. Lorsqu'ils rencontrent des noms composés de mots, les programmeurs GO utilisent généralement le style "camel case".

En parlant de cela, jetons un coup d'œil à la convention de dénomination de Java. En prenant $ comme exemple, le site officiel d'Oracle recommande de ne pas utiliser $ ou _ pour démarrer les noms de variables, et il est recommandé de ne pas utiliser du tout le caractère « $ » dans la dénomination. Le texte original est « La convention, cependant, est. pour toujours commencer vos noms de variables par une lettre, et non par '$' ou '_'". Concernant cet article, Tencent partage le même point de vue. Baidu estime que bien que les noms de classe puissent prendre en charge l'utilisation du symbole « $ », il n'est utilisé que dans la génération du système (comme les classes anonymes, les classes proxy) et l'encodage ne peut pas être utilisé.

Ce type de problème a été soulevé par de nombreuses personnes sur StackOverFlow. L'opinion dominante est que vous n'avez pas besoin de prêter trop d'attention, vous devez seulement faire attention à l'existence du code d'origine "_". . S'il existe, conservez-le. S'il n'existe pas, essayez de le conserver. Quelqu'un a également suggéré que la raison pour laquelle "_" ne devrait pas être utilisé autant que possible est que les écrans à basse résolution rendent difficile à l'œil nu la distinction entre "_" (un souligné) et "__" (deux soulignés).

Personnellement, je pense que cela peut être dû aux normes de codage du langage C. Parce qu'en langage C, les noms de macros, les noms de variables et les noms de fonctions internes dans les fichiers d'en-tête du système commencent par _, donc lorsque vous #incluez les fichiers d'en-tête du système, les noms de ces fichiers sont définis s'ils correspondent aux noms que vous utilisez. Les conflits peuvent provoquer divers phénomènes étranges. Sur la base de diverses informations, il est recommandé de ne pas utiliser "_", "$" ou d'espaces comme début du nom, afin de ne pas être difficile à lire ou provoquer des problèmes étranges.

Pour les noms de classe, la suggestion donnée par l'expert Java russe Yegor Bugayenko est d'essayer d'utiliser l'abstraction des entités dans la vie réelle. Si le nom de la classe se termine par "-er", ce n'est pas recommandé. méthode de dénomination. Il a souligné qu'il existe une exception à cet article, à savoir les classes d'outils, telles que StringUtils, FileUtils et IOUtils. Pour les noms d'interface, n'utilisez pas IRecord, IfaceEmployee, RedcordInterface, mais utilisez plutôt un nom d'entité du monde réel.

Bien sûr, tout ce qui précède est destiné à Java et n'a rien à voir avec GO. Le langage GO est plus influencé par le langage C.

Aperçu des variables

Le langage GO comprend quatre méthodes de déclaration principales : variable (var), constante (const), type (type) et fonction (func). Parlons de quelques sentiments liés aux variables :

1. La déclaration var crée une variable d'un type spécifique, puis lui attache un nom et définit sa valeur initiale. Chaque déclaration a une forme commune : nom var. type = expression. Encore une chose, le langage Go autorise les chaînes vides et ne signalera pas d'erreur de pointeur nul.

2. Vous pouvez utiliser name:=expression pour déclarer des variables. Remarque : = signifie déclaration et = signifie affectation.

Si la durée de vie d'une variable est var x int, l'expression &x (adresse de x) obtient un pointeur vers une variable entière, et son type est un pointeur entier (*int). Si la valeur s'appelle p, on peut dire que p pointe vers x, ou que p contient l'adresse de x. La variable pointée par p s'écrit *p. L'expression *p obtient la valeur d'une variable (dans ce cas, un entier). Comme *p représente un scalaire, elle peut également apparaître sur le côté gauche de l'opérateur d'affectation et est utilisée pour mettre à jour la valeur de la variable.

1. x:=1

2. p:=&x//p est un pointeur entier, pointant vers x

3. fmt.Println(*p)//Sortie "1"

4. *p=2//Équivalent à x=2

5. fmt.Println(x)//Output "2"

Notez que par rapport au NULL de Java, GO signifie que la valeur zéro du type pointeur est nulle.

3. Utilisez la nouvelle fonction intégrée pour créer une variable. L'expression new(T) crée une variable de type T sans nom, l'initialise à une valeur zéro de type T et renvoie son adresse (type d'adresse). est *T) . Il n'y a aucune différence entre les variables créées à l'aide de nouvelles et les variables locales ordinaires dont les adresses sont prises, sauf qu'il n'est pas nécessaire d'introduire (ou de déclarer) un nom virtuel et qu'elles peuvent être utilisées directement dans des expressions via new(T).

1. func newInt() *int{

2. return new(int)

3. }
   

est équivalent à :

1. func newInt() *int{

2. var dummy int

3. retour &dummy

4. }

outil gofmt

GO langage De nombreux outils sont fournis, comme gofmt, qui peuvent formater le code. Voyons comment il est implémenté.

Gofmt lira le programme et le formatera, comme la commande gofmt filename, qui imprimera le code formaté. Jetons un coup d'œil à un exemple de programme (nom du programme demo.go) :

Après avoir exécuté gofmt demo.go, le code de sortie est le suivant :

Garbage Collection

Pour les garbage collector de langage de haut niveau, comment savoir si une variable doit être recyclée L'idée de base est chaque variable au niveau du package et les variables locales ? de chaque fonction en cours d'exécution, peut être utilisée comme source pour tracer le chemin des variables, qui peut être trouvé via des pointeurs et d'autres moyens de référence. Si le chemin de la variable n'existe pas, alors le scalaire devient inaccessible et n'affecte donc aucun autre calcul.

Étant donné que la durée de vie d'une variable est déterminée par son accessibilité, une variable locale peut continuer à exister au-delà d'une itération de la boucle qui la contient.

L'objectif de conception du garbage collector dans le langage GO est qu'un collecteur non bloquant réalise le recyclage en 10 millisecondes (notez que selon les expériences, cette affirmation ne peut être faite que lorsque le GC en a suffisamment. le temps CPU ne peut être établi que dans certaines circonstances). Du point de vue du principe de conception, le recycleur Go est un recycleur simultané tricolore, marquant et transparent. Son idée de conception a été proposée par Dijkstra en 1978, et son objectif est d'être cohérent avec les propriétés du matériel moderne et moderne. Les besoins en matière de faible latence correspondent parfaitement.

Résumé

Pour résumer, chaque nouvelle langue apparaît pour une raison, d'une manière générale il y a deux raisons principales :

1. Des scénarios complexes ou des problèmes spécifiques sont apparus qui ne peuvent pas être résolus par les langages traditionnels actuels

2.

Je pense qu'à l'exception des Bell Labs, qui feront quelque chose complètement par sentiments personnels, aucune entreprise ne présentera de nouvelles technologies avec désinvolture, sans issue. Comme l'a dit Rob Pike, « la complexité augmente de manière multiplicative ». Afin de résoudre un certain problème, rendre progressivement une certaine partie du système plus complexe ajoute inévitablement de la complexité à d'autres parties.

Avec la pression constante d'ajouter des fonctionnalités, des options et des configurations du système, et de le publier rapidement, la simplicité est souvent négligée. Parvenir à la simplicité nécessite de condenser l’essence de l’idée au début du projet et de développer des lignes directrices plus spécifiques tout au long de la vie du projet pour discerner quels changements sont bons et lesquels sont mauvais ou fatals.

Tant que vous travaillez suffisamment dur, de bons changements peuvent atteindre vos objectifs sans compromettre ce que Fred Brooks a appelé « l'intégrité conceptuelle » de la conception logicielle. Les mauvais changements ne permettent pas cela, et les changements fatals sacrifient la simplicité au profit de la commodité. Mais ce n’est que grâce à la simplicité de conception qu’un système peut rester stable, sécurisé et cohérent au fur et à mesure de sa croissance. Le langage Go inclut non seulement le langage lui-même, ses outils et ses bibliothèques standards, mais entretient également une culture comportementale d’une extrême simplicité.