Quel est le point du mot clé var?
https://stackoverflow.com/questions/209199
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianQuestion
Le mot clé var supprime la nécessité d'un code explicite. J'ai tapé la déclaration et j'ai lu avec intérêt la discussion SO du moment où il pourrait être approprié.
J'ai aussi lu (mais je ne l'ai pas utilisé) Boo qui semble prendre les choses à la légère aller plus loin en rendant facultatif la déclaration d'une variable locale . Avec Boo, le type et la déclaration peuvent être impliqués.
Ce qui me conduit à me demander pourquoi les concepteurs du langage C # se sont donné la peine d'inclure un mot clé var?
Mise à jour : oui, var prend en charge les types anonymes, mais les types anonymes ne nécessitent pas en eux-mêmes le mot clé var ...
var anon = new { Name = "Terry", Age = 34 };
versus
anon = new { Name = "Terry", Age = 34 };
La solution
Mise à jour: Deux questions connexes se posent ici. En fait: 1. Pourquoi dois-je déclarer des variables? 2. Quelle est l'utilisation de "var"? dans un langage qui vous fait déclarer des variables?
Les réponses à (1) sont nombreuses et peuvent être trouvées ailleurs pour cette question. Ma réponse à (2) est la suivante:
Comme d'autres commentateurs l'ont dit, LINQ l'utilise pour ses types anonymes. Cependant, LINQ est en réalité une instance d'un problème plus général dans lequel le type du membre de droite d'une expression est inconnu du programmeur ou extrêmement détaillé. Considérez:
SomeGeneric<VeryLongTypename<NestedTypename>> thing = new
SomeGeneric<VeryLongTypename<NestedTypename>>();
Verbeux et sujet aux erreurs, non? Alors maintenant, ils vous laissent faire ceci:
var thing = new SomeGeneric<VeryLongTypename<NestedTypename>>();
En réduisant la duplication d'informations, les erreurs sont éliminées. Notez qu’il n’ya pas que des erreurs de frappe, ici: il est possible que le type de l’expression de gauche soit mal typé de telle sorte que le compilateur puisse effectuer un casting silencieux de gauche à droite, mais le casting perd en fait une propriété du rvalue. Ceci est encore plus important lorsque les types renvoyés par la valeur rvalue peuvent être inconnus ou anonymes.
Autres conseils
Sans le mot-clé var, il devient possible de créer accidentellement une nouvelle variable alors que vous aviez réellement l'intention d'utiliser une variable déjà existante. par exemple
name = "fred";
...
Name = "barney"; // whoops! we meant to reuse name
Je comprends la nécessité de var et cela l’est très utile. Ne pas avoir de mot clé et simplement définir des variables à la volée sans aucun type est effrayant. Vous blessez le prochain gars qui doit maintenir votre code ou vous-même si vous devez retravailler le code que vous n'avez pas utilisé depuis plus d'un an. Je ne suis pas sûr qu’il s’agisse d’une porte qui devrait être ouverte en C # et j’espère que ce n’est pas le cas car var pose déjà des problèmes de lisibilité lorsqu’il est utilisé de manière excessive, ce qui n’est pas nécessaire.
Presque tous les exemples .net 3.5 que je vois actuellement ont toutes les variables définies avec var.
L’argument que je fais est que cela sacrifie vraiment la lisibilité au profit de la sauvegarde des frappes au clavier lorsqu’il est trop utilisé. Par exemple:
// What myVar is, is obvious
SomeObject myVar = new SomeObject();
// What myVar is, is obvious here as well
var myVar = new SomeObject();
Le problème que je vois est que les gens l’utilisent partout ... par exemple:
// WTF is var without really knowing what GetData() returns?
// Now the var shortcut is making me look somewhere else when this should
// just be readable!
var myVar = GetData();
// If the developer would have just done it explicitly it would actually
// be easily readable.
SomeObject myVar = GetData();
Donc, le prochain argument sera, il suffit de nommer la fonction mieux ...
var weight = GetExactWeightOfTheBrownYakInKilograms();
Je ne sais toujours pas ce qui revient. Est-ce un objet int, decimal, float, weight, quoi? Je dois encore perdre du temps à le regarder… j'ai besoin de la béquille intellisense pour sauver la journée de ma programmation paresseuse. Peut-être inclure le type de retour dans le nom de la fonction. Bonne idée, maintenant, utiliser var ne nous a rien épargné, sauf que toutes mes fonctions portent de vrais noms.
Je pense que les gens utilisent tout simplement plus de var et que cela conduit à une programmation paresseuse qui, à son tour, rend le code plus difficile à lire. Chaque fois que vous tapez le mot clé var, vous devez avoir une bonne raison de l’utiliser au lieu d’être explicite.
C’est un peu subjectif, mais je pense que la conception de C # 3.0 doit avoir le "var". mot clé pour les variables implicitement typées au lieu de aucun mot clé rend le code plus lisible. Par exemple, le premier bloc de code ci-dessous est plus lisible que le second:
Évident où la variable est déclarée:
var myVariable = SomeCodeToSetVariableHere;
myVariable = SomeOtherCodeTOSetVariable;
Pas évident où la variable est déclarée:
myVariable = SomeCodeToSetVariableHere;
myVariable = SomeOtherCodeTOSetVariable;
Ce sont des exemples simplistes. Je pense que vous pouvez voir où cela va. Dans des situations complexes, il peut être intéressant de pouvoir localiser l'endroit où une variable est réellement définie.
Dans votre question, var ajoute de la valeur au code en indiquant au compilateur que le mot anon est désormais autorisé à être utilisé partout où vous vous attendez à voir un élément du type impliqué dans l'affectation. Le fait d'introduire des noms dans le compilateur comme ceci permet au compilateur de rejeter les éléments qui ne lui ont pas été explicitement expliqués sont autorisés, et donc de détecter certains types d'erreurs lors de la compilation afin qu'elles ne s'enflamment pas à l'exécution.
Par exemple, dans la section mise à jour de votre question, vous avez posé des questions sur cet extrait de code:
anon = new { Name = "Terry", Age = 34 };
Le problème avec cette possibilité est qu’il transforme tout ce qui se trouve à gauche de toute affectation dont le nom n’existait pas auparavant dans une déclaration de variable, même s’il s’agit vraiment d’une faute de frappe. Si, plus tard dans le programme, vous affectez autre chose à anon, puis encore plus en référence à la nouvelle valeur, mais si la déclaration du milieu avait une faute de frappe, vous rencontrez un problème qui ne se présentera pas avant l'exécution.
Votre réponse est que Boo le fait, donc ça doit être correct ou au moins possible. Mais c'est un hareng rouge. Nous parlons de C #, pas de Boo. L’un des objectifs de C # est d’avoir un langage dans lequel le compilateur peut intercepter autant d’erreurs que possible. Boo veut faire cela aussi, mais il veut aussi ressembler davantage à Python. Donc, cela sacrifie certaines (pas toutes) la sécurité à la compilation de C # en échange d'une syntaxe semblable à celle de python.
disclaimer: mes exemples sont en Java car c'est ce que je sais, mais les concepts doivent être identiques.
J'ai voté en faveur de la réponse qui me semble critique (il est trop facile de créer accidentellement une nouvelle variable).
bill=5;
bi11=bill+5
Quelle est la valeur de la facture?
Cela dit, je trouve parfois un peu irritant de taper:
DataOutputStream ds=new DataOutputStream();
Cela semble redondant, mais honnêtement, il n’ya rien de mal à cela. Il ne vous faut pas plus longtemps pour le taper deux fois, et c'est extrêmement utile. Ce qui prend du temps, c’est lorsque vous avez des questions, lorsque vous ne savez pas exactement comment utiliser certaines API. Si cela vous dérange vraiment de taper deux fois cette déclaration de type, alors pourquoi perdez-vous votre temps ici? Depuis que vous avez commencé à lire ceci, vous auriez pu taper 30 ou 40 déclarations, assez pour chaque déclaration dont vous aurez besoin pour les deux prochaines semaines.
Je suppose que je dis que bien que je comprenne le stress émotionnel que se répéter peut causer, la cohérence, la clarté et la capacité de créer des outils plus intelligents en valent la peine.
Une dernière chose, la plupart du temps, le code ne devrait pas ressembler à mon exemple ci-dessus. Voici ce que vous devriez faire:
DataOutput ds=new DataOutputStream();
Cela masque immédiatement le fait que vous utilisez une classe concrète dans un modèle. Ce modèle devrait pouvoir effectuer toutes les opérations dont vous avez besoin sur votre classe. Plus tard, si vous voulez remplacer ds par un autre type de flux de sortie, il vous suffit de changer cette ligne pour résoudre le problème. Si vous utilisiez les fonctionnalités non disponibles pour DataOutput en les transmettant à DataOutputStream, l'éditeur le comprendra facilement et vous le fera savoir.
Pour les types anonymes, qui supportent entre autres LINQ.
Je pense que var (et plusieurs autres nouveaux mots clés) ont été ajoutés spécifiquement pour prendre en charge Linq.
var est le mot clé utilisé pour créer un type anonyme - voir http: / /msdn.microsoft.com/en-us/library/bb397696.aspx
Les types anonymes peuvent être utilisés ailleurs que Linq.
var est excessivement utile pour Linq. En fait, selon un auteur expert, Sans 'var', LINQ devient trop pénible à utiliser. "
