Un regard sur Passer par les yeux d'un développeur .NET. Semaine # 1

Bonjour à tous!

Je m'appelle Lex et je suis l'hôte de la chaîne YouTube " IT Beard ". Et je suis un associé de 6 ans. Récemment, j'avais envie d'aller au-delà de ma technologie de base (C # /. NET), et de comprendre l'essence du paradoxe Blob . J'ai fermement décidé de m'essayer dans une autre langue, et le choix s'est fait par hasard sur Go.

Afin d'acquérir des connaissances de manière structurée, je me suis inscrit à un cours de mail.ru, que vous pouvez trouver ici: https://www.coursera.org/learn/golang-webservices-1 . En fait, ce que j'ai appris de la première semaine de formation dans ce cours sera discuté plus loin. C'est parti!


Je vais commencer par une petite intro sur la langue. Go était déjà développé à l'époque des processeurs multicœurs (2007-2009), donc tout est très bien ici avec la parallélisation du travail sur les cœurs. De plus, la langue fonctionne très bien avec les demandes concurrentielles (simultanées). En général, une recherche pour toutes sortes de services Web et de systèmes Web chargés. Exactement ce dont j'ai besoin, car j'ai développé des API Web (API Web) ces dernières années.

Commencer

Pour travailler avec la langue, il suffit d'installer le progiciel «Go tools» de 118 Mo et vous pouvez commencer à coder.

Les scripts ont l' extension * .go et sont exécutés par la commande go sur la ligne de commande (je suis un adhérent de la ligne de commande Windows). La commande gofmt place tous les espaces d'indentation et crée des bonbons à partir du fichier (embellisseur de code hors de la boîte). Comme dans mon sous-réseau préféré, dans Go, l'exécution du programme commence par la méthode principale .
Une fonctionnalité intéressante a immédiatement attiré mon attention - vous ne pouvez pas mettre de point-virgule à la fin de la ligne :)

Go est un autre langage (avec python, c #, php, js, ts et autres), qui est pratique pour travailler avec VSCode. VSCode lui-même fournit absolument tous les packages et dépendances nécessaires lors de l'écriture du code. Lors de l'enregistrement de l'IDE, veuillez exécuter gofmt pour vous et rendre le code encore plus beau.

Variables

Tout est familier ici: il existe de nombreux types différents, il existe des valeurs par défaut. D'inhabituel pour un donateur, le mot-clé var signifie que la variable ira plus loin, et le type de la variable peut être déclaré ou pas déjà après le nom de la variable. Exceptionnellement.

En général, il existe de nombreuses façons de déclarer et d'initialiser des variables. Vous pouvez même affecter des valeurs à plusieurs variables, séparées par des virgules, sur la même ligne. Et en passant, il n'y a pas de transtypages implicites.

Et Go a également un opérateur " : = ", qui vous permet de déclarer et d'initialiser immédiatement de nouvelles variables (et presque toujours uniquement de nouvelles). Salut Pascal;)

Vue d'enregistrement:

perem1, perem2 := 2, 3 

soit crée deux nouvelles variables, soit en crée une, et la seconde affecte simplement une nouvelle valeur. Cela signifie que si les deux variables existent déjà, cela ne fonctionnera pas et vous obtiendrez une erreur, disent-ils utiliser l'affectation habituelle. Opérateur : = doit créer quelque chose :)

Il y a aussi un faux drôle - le caractère de soulignement "_". Cela signifie l'absence d'une variable, quelque chose comme ça :) (dans les objets tranchants, comme il s'est avéré, c'est aussi: https://docs.microsoft.com/en-us/dotnet/csharp/discards )



Moment amusant avec des chaînes: le décompte standard de la longueur de chaîne d'une chaîne len (str) compte les octets , et en UTF8 un caractère peut peser plus. Pour compter les caractères appelés runes , vous devez utiliser la méthode utf8.RuneCountInString (str) du package «utf8». Et, et pourtant - nous ne changeons pas les lignes (comme dans votre préféré).

Constantes

Les constantes peuvent être déclarées par lots. Les constantes ont un type intéressant, ou quelque chose comme ça - iota . Je l'appellerai Jopta. Jopta vous permet de faire certaines constantes sur la base d'autres, quelque chose comme un itérateur pour les constantes (quelque chose qui rappelle le rendement d'un sous-réseau).

Et pourtant, les constantes ne peuvent pas être saisies. Pour de telles constantes, le compilateur décide de quel type elles sont au bon moment. Idéalement, ce qui est déjà là.

Pointeurs

Oui oui Il y a des indications ici, mais cela ne semble pas très effrayant. Ils disent qu'ils ne sont pas numérotés, et vous ne pouvez pas obtenir le prochain pointeur en ajoutant un pair au pointeur. Ici, c'est un peu comme une variable qui stocke un lien vers une autre variable (jusqu'à présent, je l'ai en quelque sorte compris).

Le pointeur est spécifié via un esperant ou la nouvelle méthode (type) (pour obtenir un pointeur vers un type, pas une variable):



Si vous accédez directement au pointeur, le lien change. Et si par l'opérateur " * ", alors la valeur de la variable qui se trouve derrière le pointeur (vers lequel il pointe) change. En général, ce n'est pas encore très clair, mais alors, disent-ils, ce sera plus clair.

Tableaux

La taille du tableau fait partie du type de données! Ainsi, les tableaux de différentes dimensions sont en fait différents types de données et ne sont pas compatibles.



Mais que faut-il pour les tableaux s'ils sont si secs et immuables (ils ne peuvent pas être modifiés pendant l'exécution). Par conséquent, nous avons proposé de telles tranches (tranches) basées sur des tableaux.



Une tranche a une longueur et une capacité . Cela m'a rappelé un peu le type de données nvarchar de SQL. C'est-à-dire vous pouvez allouer de l'espace mémoire (allocation de mémoire) à vos baies, mais y mettre des baies de n'importe quelle longueur (jusqu'à la capacité). Bref, la chose est intéressante, il faut s'y habituer. Pour une utilisation pratique des tranches, il existe toutes sortes de méthodes telles que make (), append (), len (), cap () et, bien sûr, d'autres. À partir d'une tranche (tranche), vous pouvez obtenir légèrement une sous-tranche (tranche de tranche). Et en passant, append () étend la capacité de la tranche.

Si la sous-tranche est égale à la tranche, alors en fait, ils se réfèreront à un morceau de mémoire. Et en conséquence, un changement de la valeur dans une tranche entraînera un changement dans la deuxième tranche. Mais si l'un d'eux est développé via append () , un nouveau morceau de mémoire sera alloué.
Bref, tout est sérieux avec la mémoire :)

Carte, table de hachage, tableau associatif

Tout cela est le même. Allez sur des tables de hachage pour des recherches de clés rapides. Initialisé comme suit:



Vous pouvez créer des sous-tables (Map Map), etc. (n'importe quel niveau d'imbrication, un peu comme). Il existe une valeur par défaut qui renvoie des clés inexistantes. Il est tiré du type de clé (pour bool, puis false). Pour savoir si une variable est retournée par défaut, c'est-à-dire que la clé est manquante - utilisez la clé pour l'existence de la clé (chose intéressante):

Structures de contrôle

Il y a un if-else. Un peu plus intéressant que dans les objets tranchants, car vous pouvez utiliser les conditions d'initialisation pour if.

Il y a un swith-case. Les pauses n'ont pas besoin d'être définies, et c'est une différence. Inversion de la logique) Si vous souhaitez également vérifier la condition suivante, vous devez écrire fallthrough .

Il y a pour. Et tout cela avec des cycles.



Avec tranche itérative plus ludique (opérateur de plage):



Et même par carte de hachage, vous pouvez itérer (bien que la séquence soit souvent différente, car la carte n'est pas directionnelle):



Pour le type, la plage de chaînes itère sur les runes, pas sur les octets.

Les fonctions

Déclaré via le mot clé func . De plus, l'inversion de la logique est à nouveau comparée au sous-réseau - les paramètres d'entrée sont indiqués en premier, puis le type de la valeur de retour (vous pouvez immédiatement le nommer).

Les fonctions peuvent renvoyer plusieurs résultats , tout comme les tuples dans un sous - réseau .

Les valeurs nommées renvoyées par la fonction sont initialisées par défaut avec des valeurs par défaut pour le type.

Et pourtant, vous pouvez créer des fonctions variables qui ont un nombre illimité de paramètres d'entrée du même type (comme param dans le sous-réseau). Et puis un type spécifique de tranche vient à l'entrée de la fonction.

Les fonctions peuvent avoir des noms ou être sans nom - anonymes . Et ils peuvent être appelés, peuvent être affectés à des variables. Cela ressemble à JavaScript. Vous pouvez même créer des types basés sur des fonctions! Les fonctions peuvent être passées comme paramètres (lire les délégués du sous-réseau)

Il y a même une fermeture (uuuh, effrayante)! Vous pouvez atteindre les variables de la fonction en dehors de celle-ci (lire, dans la fonction parent). Ce sont les tartes.

Vous pouvez déclarer l' exécution différée des fonctions . Grâce au mot clé defer, cela se fait. C'est-à-dire les fonctions différées sont exécutées à la fin de la fonction dans laquelle elles sont déclarées, dans l'ordre inverse de la déclaration de ces fonctions différées. Ici. De plus, l'initialisation des arguments des fonctions différées se produit lorsque le bloc de report est déclaré . C'est important, surtout si une autre fonction est prise comme argument - elle sera exécutée beaucoup plus tôt que prévu!

PANIQUE! Go a une telle fonction - panic () . C’est comme la remise en jeu, mais pire. Cette fonction arrête l'exécution du programme. Mais cette même panique peut être traitée par report, car elle est exécutée de n'importe quelle façon à la fin de la fonction, même après une panique. Et pourtant - panique, ce n'est pas un essai. C'est pire!

Structures (quasi-objets)

Le go n'est pas tout à fait un langage de paradigme OOP. Mais il y a des choses comme les structures . Si vous êtes du monde du sous-réseau, vous savez que nous avons également des structures - ce sont des mappages d'objets qui peuvent être stockés sur la pile (types de valeurs). Dans Go, la structure est en quelque sorte le seul moyen de faire quelque chose comme un objet. Je ne peux pas encore parler des types de valeur, mais la nature de l'interaction avec les structures est très similaire à celle détaillée.

Chaque structure est essentiellement un type distinct et peut avoir un ensemble de propriétés de types spécifiques (y compris le type d'une autre structure ou type de fonction):



De plus, un certain mécanisme d'héritage direct des objets du sous-réseau est vu ici. Dans l'image ci-dessus, la structure de compte est imbriquée avec la structure de personne . Cela signifie que tous les champs de Personne seront disponibles dans une variable de type Compte . Si les noms de propriété coïncident (dans l'exemple ci-dessus Id, Name ), il n'y aura pas de conflit, mais la valeur d'un champ supérieur sera prise:

Les méthodes

Oui, il n'y a pas seulement la similitude des objets, mais aussi des méthodes. Presque OOP :) Une méthode est une fonction liée à un type spécifique (par exemple, à une structure). Une méthode diffère d'une fonction dans une déclaration: après le mot clé func , entre parenthèses, vous devez spécifier le type auquel appartient cette méthode et le rôle de passer une variable de ce type. Quel est le rôle? Si vous mettez un astérisque devant le type, la variable sera transmise par référence (rappelez-vous les pointeurs, elle était là aussi), et en conséquence, à l'intérieur de la méthode, nous travaillerons avec un type spécifique, et non une copie de celui-ci.



D'après l'image ci-dessus, nous pouvons conclure que UpdateName n'a pas de sens, car il modifie la copie de la structure et non l'original. Et cette copie ne revient pas. Alors que SetName va changer la structure d'origine (grâce à l'astérisque et en passant par référence).

Les méthodes dans les structures sont héritées (et selon les règles d'héritage de propriété), c'est-à-dire la structure parente a accès à toutes les méthodes imbriquées dans ses structures.

D'autres types peuvent avoir des méthodes, pas seulement des structures. Cela peut ressembler à des méthodes d'extension de sous-réseau, mais non. Les méthodes dans Go ne peuvent être créées que pour les types locaux, c'est-à-dire types qui sont déclarés dans ce package (à propos des packages un peu plus loin).

Packages, portée, espaces de noms

Je viens de réaliser que Go n'a pas NEIMSPACE! Généralement! Je m'en suis rendu compte quand, après la compilation, une erreur est sortie, ils disent que dans un dossier j'ai deux fichiers avec la méthode principale. Il s'avère qu'au stade de la compilation, tout, depuis papa, semble être collé ensemble dans une seule toile! Un dossier est en fait un espace de noms. C'est tellement magique, camarades :)

Voici, en passant, ce que dit le dock:



Remarque pour vous-même: fumez un quai
Et voici un autre petit article dans le sujet: https://www.callicoder.com/golang-packages/#the-main-package-and-main-function

Ainsi, disent-ils, la structure de dossier de base ressemble à:

bin - binaires compilés
pkg - fichiers d'objets temporaires
src - sources

Les packages font référence au nom du dossier dans lequel se trouvent les fichiers de packages. Oui, un package peut contenir de nombreux fichiers importés les uns dans les autres.

Autre règle intéressante: les fonctions, propriétés, variables et constantes commençant par une majuscule peuvent être utilisées en dehors du package , c'est-à-dire être importé . Tout avec une petite lettre est utilisé uniquement à l'intérieur du colis. Un analogue des modificateurs d'accès du sous-réseau.

Le mot-clé d' importation fonctionne dans un fichier, pas dans un package.

Interfaces

Les interfaces ici sont intéressantes. Nous n'avons pas besoin d'hériter des interfaces de nos structures. Il suffit que la structure, qui vient comme paramètre d'entrée d'une certaine méthode qui prend un type d'interface, implémente les méthodes de cette interface. Et il n'y a aucun problème. C'est-à-dire les méthodes d'interface ne doivent pas nécessairement être implémentées par la structure. Mais la structure doit contenir l'implémentation de toutes les méthodes requises dans une fonction particulière, où le type d'interface est utilisé comme paramètre d'entrée.

Il s'avère que, contrairement à Go, l'interface est une caractéristique de la fonction dans laquelle elle est utilisée, et non une caractéristique d'une structure spécifique (objet).

Si c'est encore plus simple, alors la logique est la suivante: vous n'avez pas besoin d'être capable de charlatan pour être un canard. Si vous savez charlatan, alors vous êtes probablement un canard :)

Et au fait, si votre structure implémente toutes les méthodes d'une interface, alors cette structure peut être affectée comme valeurs de la variable de l'interface implémentée . Quelque chose comme ça :)

Type boîtier de commutateur

Go a un boîtier de commutation spécial qui peut fonctionner en fonction du type entrant. Chose cool:



Soit dit en passant, voici comment vous pouvez convertir un type en un autre (par exemple, un type d'interface en un type de structure afin d'obtenir des champs de structure qui ne sont pas accessibles depuis l'interface):



ok - signe booléen que la conversion a réussi. Nous avons déjà rencontré les signes :)

L'interface vide est la bête du monde de Go. Cela peut prendre n'importe quel type. Quelque chose comme dynamique ou Object in. Par exemple, il est utilisé dans fmt.Println () et des fonctions similaires qui utilisent une interface vide dans l'implémentation.

Les interfaces peuvent être intégrées les unes aux autres, et ainsi faire la composition des interfaces (ce qui est dit dans la lettre I (ségrégation des interfaces) des principes SOLID )

Les tests

Dans Go, toutes les fonctions de test commencent par le mot Test et l'entrée du test du module de test est acceptée. Les fichiers sont nommés par le nom du fichier de test + mot _test ( main_test.go - teste le fichier main.go ). De plus, les tests et les fichiers de test sont dans un seul paquet!

Épilogue

C’est tout! Merci de votre attention et je suis prêt à discuter des problèmes dans les commentaires. Je vous retrouve dans les notes suivantes de mes cours!

PS Vous pouvez regarder toutes mes promenades de code sur cette semaine de formation sur github