Bonjour à tous! Aujourd'hui, nous partageons la dernière partie de la traduction de l'article «Ce qui est et ce qui n'est pas dans Go. Nous vous rappelons que dans la
première partie, nous avons parlé des éléments qui sont dans Go, aujourd'hui nous parlerons de ce qui n'est pas dans Go.
La traduction de ce matériel a été préparée en prévision du début d'un nouveau flux au cours de développeur de Golang .
Go a été créé avec un regard en arrière, et son package de base est vraiment bien composé: il a un garbage collection, des packages, des fonctions de première classe, une portée lexicale, une interface d'appel système et des lignes immuables, dont le texte est généralement encodé en UTF-8. Mais il a relativement peu de fonctionnalités et ne devrait pas augmenter leur nombre. Par exemple, il n'a aucune conversion numérique implicite, aucun constructeur ou destructeur, aucune surcharge d'opérateur, aucune valeur de paramètre par défaut, aucun héritage, aucun générique, aucune exception, aucune macro, aucune annotation de fonction et aucun stockage de flux local.
Articles non trouvés dans Go
Conversion de nombre implicite
En programmation, la conversion de type implique de changer le type de données d'un objet en un autre. La conversion implicite signifie que cette modification est effectuée automatiquement par l'interpréteur ou le compilateur. Par exemple, affecter une valeur int à une variable à laquelle une valeur à virgule flottante a été affectée précédemment. Cette conversion n'est pas disponible dans Go. Lorsqu'un type n'est pas mentionné lors de la déclaration d'une variable, un type approprié lui est affecté, par exemple, int, float, string, etc., en fonction de la syntaxe du littéral. Dans l'exemple ci-dessous, Go générera une erreur car il trouvera deux types de données différents et ne pourra pas travailler avec eux. Cela se produit car le compilateur Go convertit implicitement
int en
float64 .
a := 1.0
Constructeurs et destructeurs
La tâche des concepteurs est le traitement primaire et l'initialisation de l'objet, et le destructeur est de détruire l'objet après sa durée de vie et sa mémoire libre. Contrairement à d'autres paradigmes orientés objet, il n'y a pas de classes dans Go. Par conséquent, le concept de constructeurs et de destructeurs n'existe pas non plus.
Surcharge de l'opérateur
La surcharge des opérateurs est la manière dont les opérateurs peuvent effectuer des opérations définies par l'utilisateur. Les opérateurs se comportent en fonction des arguments passés. Par exemple, en C ++
+ opérateur peut être utilisé pour combiner des chaînes, ainsi que pour ajouter deux entiers. La valeur «+» peut également être définie par l'utilisateur et modifiée en fonction des besoins du programme. En JavaScript, une opération de type
'1' + 1 entraînera la sortie de la chaîne
"11" raison de la priorité plus élevée des lignes. De telles définitions ne sont pas autorisées dans Go, les opérateurs fonctionnent strictement et n'effectuent des opérations qu'avec certains types d'arguments de données.
Valeurs par défaut
Go n'autorise pas les valeurs par défaut dans les prototypes de fonction ou lorsque les fonctions sont surchargées. La spécification du langage Go est exceptionnellement petite et spécifiquement prise en charge pour simplifier l'analyse. Contrairement à d'autres langues, où vous pouvez transmettre des valeurs par défaut / paramètres facultatifs à une fonction, dans Go, vous ne pouvez vérifier que si une valeur a été transmise. Une approche différente des valeurs par défaut dans Go serait quelque chose comme ceci.
func Concat1(a string, b int) string { if a == "" { a = "default-a" } if b == 0 { b = 5 } return fmt.Sprintf("%s%d", a, b) }
Héritage
Parce que Go ne suit pas la hiérarchie familière des classes de programmation orientée objet, les structures de Go ne sont pas héritées les unes des autres. En général, l'héritage est une procédure dans les langages POO dans laquelle une classe hérite des propriétés et de la méthode de classe de ses parents. L'héritage peut aller profondément dans plusieurs niveaux. Cependant, dans Go, une structure peut être compilée simplement en fournissant un pointeur ou en l'intégrant dans des structures collaboratives. Un exemple de composition sur Go est donné ci-dessous. Le remplacement des classes peut être une interface dans Go. Les interfaces existent dans d'autres langues, mais les interfaces Go sont implicitement satisfaites.
type TokenType uint16 type Token struct { Type TokenType Data string } type IntegerConstant struct { Token *Token Value uint64 }
Programmation générale
La programmation générique est une forme dans laquelle nous connectons des modèles connus sous le nom de génériques, qui ne sont pas vraiment le vrai code source, mais sont compilés par le compilateur pour les convertir en code source. Essayons de comprendre les modèles d'une manière simple. Considérez les modèles de programmation comme un formulaire. Nous créons un formulaire dans lequel les détails importants du modèle sont laissés en blanc et doivent être remplis plus tard lors de la compilation. Ensuite, lorsque nous devons créer quelque chose à partir de ce modèle, nous spécifions simplement les détails, par exemple, le type.
template<typename T> class MyContainer {
L'extrait ci-dessus est écrit en C ++. Le modèle n'est pas fourni avec un type, mais il est fourni lorsque le MyContainer est initialisé. Nous pouvons également spécifier d'autres types, tels que
float ,
double , etc., selon nos besoins. Les modèles généralisés sont utiles lors de l'exécution d'algorithmes sur un ensemble de données de plusieurs types.
Exceptions
Une exception indique une condition raisonnable que l'application peut vouloir intercepter. Grâce à des exceptions, nous pouvons résoudre des situations dans lesquelles le programme peut ne pas fonctionner. Une exception vérifiée n'entraîne pas un arrêt complet de l'exécution; elle peut être interceptée et traitée. Go n'a pas d'exceptions, il n'a que des erreurs comme les interfaces et les erreurs intégrées. La principale différence entre les erreurs et les exceptions est qu'elles indiquent un problème grave et doivent être résolues immédiatement, de sorte que la programmation Go devient plus stricte. Les erreurs dans Go doivent être vérifiées explicitement à mesure qu'elles se produisent.
Macros
Les macros sont des macro-commandes. Il s'agit d'un moyen de minimiser les tâches de programmation répétitives en définissant une sortie prédéfinie pour un ensemble donné d'entrées. Par exemple, si nous voulons obtenir le carré d'un nombre en C, nous pouvons simplement écrire
x * x , où
x est une variable, mais nous pouvons également définir une macro qui renvoie le carré d'un nombre chaque fois que nous en avons besoin. Les macros ne sont pas des fonctions. Les macros ne sont pas disponibles dans Go.
#define square(x) ((x) * (x)) int main() { int four = square(2);
Annotations de fonction
Les annotations sont un moyen d'associer des métadonnées à des paramètres de fonction. En Python, les annotations sont prises en charge syntaxiquement et sont complètement facultatives. Regardons un petit exemple pour décrire les annotations en Python.
def foo(a: int, b: 'description', c: float) -> float: print(a+b+c) foo(1, 3, 2)
Dans le code ci-dessus, les paramètres
a ,
b et
c annotés avec certaines métadonnées.
a et
c annotés
c types
int et
float , tandis que
b fourni avec une description de chaîne.
foo une sortie spécifique, malgré le type d'arguments mentionnés dans les annotations.
Stockage de flux local
Le stockage de flux local est une méthode de programmation informatique qui utilise une mémoire statique ou globale localisée dans un flux. Il s'agit d'une zone statique où les données sont copiées pour chaque flux du programme. Lorsque plusieurs flux utilisent les mêmes données statiques pour la même tâche, ils peuvent les copier à partir du stockage de flux local plutôt que de les stocker seuls.
Conclusion
Go s'est concentré sur la simplicité et l'élégance. Il a une syntaxe rapide, petite et simple. Contrairement à d'autres langages POO, il a moins de concepts qui devraient être déposés dans la tête. Les créateurs de Go ont choisi la simplicité du langage sans ajouter de complexité multiplicative aux parties adjacentes du langage. Par conséquent, Go n'a pas de fonctionnalités qui rendent l'analyseur plus lent et plus grand. La simplicité est la clé d'un bon logiciel.
REMARQUE Les extraits de code de cet article sont copiés à partir de divers articles sur Internet.
C’est tout.
Lire la première partie