Quel est le but du mot-clé var?

Mise à jour: Il y a deux questions liées ici, en fait: 1. Pourquoi dois-je déclarer des variables du tout? 2. A quoi sert “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 ci-dessous:

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 où le type du côté droit d’une expression est soit inconnu du programmeur, soit extrêmement verbeux. Considérer:

 SomeGeneric> thing = new SomeGeneric>(); 

Verbeux et sujet aux erreurs, non? Alors maintenant, ils vous ont laissé faire ceci:

 var thing = new SomeGeneric>(); 

En réduisant la duplication des informations, les erreurs sont éliminées. Notez qu’il n’y a pas que des fautes de frappe, ici: il est possible que le type de l’expression de gauche soit mal compris, de sorte que le compilateur puisse lancer de manière silencieuse de gauche à droite, rvalue. Cela est encore plus important lorsque les types renvoyés par la valeur peuvent être inconnus ou anonymes.

Sans le mot-clé var, il devient possible de créer accidentellement une nouvelle variable lorsque vous avez réellement l’intention d’utiliser une variable existante. par exemple

 name = "fred"; ... Name = "barney"; // whoops! we meant to reuse name 

Je comprends le besoin de var et ça sert très bien. N’avoir aucun mot-clé et définir des variables à la volée sans aucun type est effrayant. Vous blessez le prochain qui doit maintenir votre code ou vous-même si vous devez retravailler le code que vous n’avez pas touché depuis plus d’un an. Je ne suis pas sûr que ce soit une porte qui devrait être ouverte en C # et j’espère que ce n’est pas le cas, car la var est déjà à l’origine de problèmes de lisibilité lorsqu’elle n’est pas utilisée.

Presque tous les exemples de .net 3.5 que je vois récemment ont toutes les variables définies avec var.

Le raisonnement que je fais est que cela sacrifie vraiment la lisibilité pour sauver des frappes de touche quand 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, c’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 object int, decimal, float, weight, quoi? Je dois encore perdre du temps à le regarder … J’ai besoin de la béquille intellisense pour sauver ma journée de ma programmation. Peut-être inclure le type de retour dans le nom de la fonction. Bonne idée, maintenant, utiliser var nous a sauvé rien, sauf faire toutes mes fonctions ont de vrais noms longs.

Je pense que les gens utilisent de plus en plus la var, ce qui conduit à une programmation paresseuse qui rend la lecture du code plus difficile. Chaque fois que vous tapez le mot-clé var, vous devriez avoir une bonne raison pour laquelle vous l’utilisez au lieu d’être explicite.

C’est un peu subjectif, mais je pense que concevoir C # 3.0 pour avoir le mot-clé “var” pour les variables implicitement typées au lieu de ne pas utiliser de mot-clé rend le code plus lisible. Par exemple, le premier bloc de code ci-dessous est plus lisible que le second:

Évidente lorsque la variable est déclarée:

 var myVariable = SomeCodeToSetVariableHere; myVariable = SomeOtherCodeTOSetVariable; 

Pas évidente où la variable est déclarée:

 myVariable = SomeCodeToSetVariableHere; myVariable = SomeOtherCodeTOSetVariable; 

Ce sont des exemples simplistes. Je pense que vous pouvez voir où cela se passe. Dans des situations complexes, il peut être intéressant de pouvoir trouver 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 utilisable partout où vous vous attendez à voir un élément du type impliqué dans l’affectation. L’obligation d’introduire des noms dans le compilateur comme cela permet au compilateur de rejeter les choses pour lesquelles il n’a pas été explicitement indiqué et, par conséquent, de détecter certains types d’erreurs au moment de la compilation afin qu’elles ne soient pas explosées à 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 son autorisation est que tout ce qui se trouve sur le côté gauche de n’importe quelle assignation où le nom n’existait pas auparavant dans une déclaration de variable devient une véritable faute de frappe. Si plus tard dans le programme vous affectez quelque chose d’autre à anon et que vous référencez encore la nouvelle valeur, mais que la déclaration du milieu a une faute de frappe, vous avez un problème qui n’apparaîtra pas avant l’exécution.

Votre réponse est que Boo le fait, donc ça doit aller ou du moins possible. Mais c’est un hareng rouge. Nous parlons de C #, pas de Boo. L’un des objectives de C # est d’avoir un langage où le compilateur peut détecter autant d’erreurs que possible. Boo veut le faire aussi, mais il veut aussi ressembler davantage à Python. Il sacrifie donc une partie (pas toutes) de la sécurité à la compilation de C # en échange d’une syntaxe de type python.

disclaimer: mes exemples sont Java car c’est ce que je sais, mais les concepts doivent être identiques.

J’ai voté pour la réponse que j’estime 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 ça parfois un peu irritant de taper:

 DataOutputStream ds=new DataOutputStream(); 

Semble redondant, mais honnêtement, il n’ya rien de vraiment grave. Cela ne vous prend pas plus de temps pour taper deux fois, et c’est extrêmement utile. Ce qui prend du temps, c’est quand vous avez des questions – quand vous n’êtes pas sûr de savoir comment utiliser une API. Si cela vous dérange vraiment de taper ce type de déclaration deux fois, alors pourquoi perdez-vous votre temps ici? Depuis que vous avez commencé à lire ceci, vous pourriez avoir saisi 30 ou 40 déclarations, ce qui est suffisant pour chaque déclaration dont vous aurez besoin pour les deux prochaines semaines.

Je suppose que je dis que même si je comprends le stress émotionnel que la répétition peut causer, la cohérence, la clarté et la capacité de fabriquer des outils plus intelligents en valent la peine.

Encore une chose, la plupart du temps, le code ne devrait pas être comme mon exemple ci-dessus. Ce que vous devriez faire c’est ceci:

 DataOutput ds=new DataOutputStream(); 

Cela cache 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 dans votre classe. Plus tard, si vous souhaitez remplacer ds par un autre type de stream de sortie, il vous suffira de modifier cette seule ligne. Si vous utilisiez les fonctionnalités non disponibles pour DataOutput en les convertissant en DataOutputStream, l’éditeur les trouvera facilement et vous le fera savoir.

Je crois que var (et plusieurs autres nouveaux mots-clés) ont été ajoutés spécifiquement pour supporter 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 dans Linq.

var est extrêmement utile pour Linq. En fait, selon un auteur expert, ” sans” var “, LINQ devient trop pénible à utiliser. ”

Pour les types anonymes, qui supportent entre autres LINQ.

http://www.blackwasp.co.uk/CSharpAnonTypes.aspx