Quel type de préfixe utilisez-vous pour les variables membres?

Je n'utilise aucun préfixe. Si je risque de mélanger les variables locales ou les paramètres de la méthode avec les membres de la classe , alors la méthode ou la classe est trop longue et profite de diviser .

cela (sans doute) non seulement rend le code plus lisible et quelque peu" couramment", mais le plus important encourage des classes et des méthodes bien structurées . En fin de compte, il se résume donc à un tout autre question que le préfixe ou pas de préfixe de problème pour.

mise à JOUR: eh bien, le goût et les préférences de changement, n'est-ce pas.. J'utilise maintenant le trait de soulignement comme préfixe pour les variables membres, car il s'est avéré utile pour reconnaître les variables locales et les variables membres à long terme. Surtout les nouveaux membres de l'équipe ont parfois des moments difficiles quand les deux ne sont pas facilement reconnaissables.

néant. J'ai l'habitude d'utiliser un trait de soulignement, mais a parlé d'elle sur un projet où les autres n'aiment pas, et n'ont pas manqué. Un IDE décent ou une mémoire décente vous dira ce qu'est une variable membre et ce qui ne l'est pas. Un des développeurs de notre projet insiste pour mettre " ceci."devant chaque membre variable, et nous l'amusons quand nous travaillons sur des domaines de code qui sont nominalement "son".

souligné seulement.

dans mon cas, je l'utilise parce que c'est ce que dit le document sur les normes de codage à mon lieu de travail. Cependant, je ne vois pas l'intérêt d'ajouter m_ ou quelque chose d'horrible hongrois au début de la variable. Le 'underscore only' minimaliste le garde lisible.

il est plus important d'être cohérent que quoi que ce soit, alors choisissez quelque chose sur lequel vous et vos coéquipiers pouvez être d'accord et vous y tenir. Et si la langue dans laquelle vous codez a une convention, vous devriez essayer de vous y tenir. Rien n'est plus déroutant qu'une base de code qui suit une règle de préfixe de façon incohérente.

pour c++, il y a une autre raison de préférer m_ à _ outre le fait que _ préfixe parfois des mots-clés de compilateur. La variable M signifie "membre". Ce vous donne également la capacité de désambiguer entre les locaux et les autres classes de variables, s_ pour static et g_ pour global (mais bien sûr n'utilisez pas globals).

quant aux commentaires que l'IDE prendra toujours soin de vous, est-ce que l'IDE est vraiment la seule façon dont vous regardez votre code? Votre outil diff a-t-il le même niveau de qualité pour l'hilighting syntaxique que votre IDE? Qu'en est-il de votre outil d'historique de révision du contrôle des sources? Est-ce que vous ne trouvez jamais un fichier source ligne de commande? Les IDE modernes sont des outils d'efficacité fantastiques, mais le code devrait être facile à lire quel que soit le contexte dans lequel vous le lisez.

je préfère utiliser le mot-clé this . Cela signifie this.data ou this->data au lieu d'un nom dépendant de la communauté.

parce que:

• avec de nos jours IDEs taper this. popups intellinsense
• c'est évident pour tout le monde sans savoir nom défini

préfixer des variables avec des lettres pour dénoter leur type est périmé avec de bonnes IDEs et me rappelle de ce article de Joël

en utilisant C#, je suis passé du préfixe "m_" à juste un underscore , puisque "m_" est un héritage de C++ .

les directives officielles de Microsoft vous indique de ne pas utiliser de préfixes, et à utiliser camel-case sur les membres privés et pascal-case sur les membres publics . Le problème est que cela entre en conflit avec une autre directive de la même source, qui stipule que vous devez rendre tous les codes compatibles avec toutes les langues utilisées dans .NET . Par exemple, VB.NET ça ne fait pas de différence entre les douilles.

donc juste un trait de soulignement pour moi. Cela rend également facile d'accéder à travers IntelliSense, et le code externe appelant seulement les membres du public n'ont pas à voir les underscores visuellement désordonnés.

mise à Jour: je ne pense pas que le C# "."- le préfixe aide le " moi."en VB, qui verrez encore "Moi.âge "le même que" moi.Âge."

nous utilisons m_ puis une notation Simonyi légèrement modifiée, comme Rob le dit dans une réponse précédente. Ainsi, le préfixe semble utile et m_ n'est pas trop intrusif et facilement recherché.

pourquoi la notation? Et pourquoi ne pas simplement suivre (pour .NET) les recommandations de notation de Microsoft qui reposent sur le boîtier des noms?

dernière question en premier lieu: VB.NET est indifférent à casing. Il en va de même des bases de données et (surtout) des AD. Quand J' je dois garder le customerID et le CustomerID (in, say, C#), ça me fait mal au cerveau. Si l'enveloppe est une forme de notation, mais pas très efficace.

la notation du préfixe a une valeur à plusieurs égards:

1. augmente la compréhension humaine du code sans utiliser L'IDE. Comme dans la révision de code -- ce que je trouve toujours le plus facile à faire sur papier au départ.
2. avez-vous déjà écrit T-SQL ou d'autres procs RDBMS stockés? Utilisation de la notation du préfixe les noms de colonne de base de données est vraiment utile, en particulier pour ceux d'entre nous qui aiment utiliser des éditeurs de texte pour ce genre de choses.

peut-être en bref, préfixer comme une forme de notation est utile parce qu'il ya encore des environnements de développement où les smart IDEs ne sont pas disponibles. Pensez à L'IDE (un outil logiciel) comme nous permettant quelques raccourcis (comme le typage intellisense), mais ne comprenant pas tout l'environnement de développement.

un IDE est un Environnement de Développement intégré de la même manière qu'une voiture est un Réseau de Transport: seulement une partie d'un système plus vaste. Je ne veux pas suivre une convention "voiture" comme rester sur les routes balisées, quand parfois, il est plus rapide juste de marcher à travers un terrain vague. Se fier à L'IDE pour suivre la dactylographie variable serait comme avoir besoin du GPS de la voiture pour marcher à travers le terrain vacant. Mieux vaut avoir la connaissance (aussi étrange que cela puisse être d'avoir "m_intCustomerID") sous une forme portable que de revenir à la voiture pour chaque petit changement de cap.

cela dit, la convention m_ ou la" présente " convention sont toutes deux lisibles. Nous aimons m_ parce qu'il est facilement recherché et permet toujours à la variable de dactylographier de le suivre. On convient qu'un simple soulignement est utilisé par un trop grand nombre d'autres activités du code-cadre.

Cela dépend vraiment de la langue. Je suis un gars de C++, et préfixer tout avec underscore est un peu délicat. La langue réserve des choses qui commencent par un underscore pour la mise en œuvre dans certains cas (selon la portée). Il y a aussi un traitement spécial pour les underscores doubles, ou underscores suivis d'une majuscule. Donc je dis juste d'éviter ce gâchis et de simplement choisir un autre préfixe. "m" est ok IMO. 'm_' est un peu beaucoup, mais pas terrible non plus. Une question de goût, vraiment.

mais attention à ces _leadingUnderscores. Vous serez surpris du nombre de Compilateurs et de bibliothèques internes qui sont ainsi nommés, et il y a certainement de la place pour les accidents et les confusions si vous n'êtes pas extrêmement prudent. Suffit de dire non.

cela dépend du cadre que j'utilise! Si j'écris du code MFC, j'utilise m_ et la notation hongroise. Pour d'autres choses (qui ont tendance à être STL/Boost) alors j'ajoute un suffixe de soulignement à toutes les variables membres et je ne m'occupe pas de la notation hongroise.

classe MFC

class CFoo  
{  
private:  
    int m_nAge;  
    CString m_strAddress;  
public:  
    int GetAge() const { return m_nAge; }  
    void SetAge(int n) { m_nAge = n; }  
    CString GetAddress() const { return m_strAddress;  
    void SetAddress(LPCTSTR lpsz) { m_strAddress = lpsz; }  
};

classe STL

class foo  
{  
private:  
    int age_;  
    std::string address_;  
public:  
    int age() const { return age_; }  
    void age(int a) { age_ = a; }  
    std::string address() const { return address_; }  
    void address(const std::string& str) { address_ = str; }  
};

Maintenant, cela peut sembler un peu Impair - deux styles différents - mais cela fonctionne pour moi, et écrire beaucoup de code MFC qui n'utilise pas le même style que MFC lui-même semble juste laid.

si la langue supporte le ce ou me mot-clé, alors n'utilisez aucun préfixe et utilisez à la place ledit mot-clé.

je préfixe variables de membre avec un " m " et les paramètres (dans la fonction) avec 'p'. So code ressemblera à:

class SomeClass {
    private int mCount;
    ...
    private void SomeFunction(string pVarName) {...}
}

je trouve que cela vous indique rapidement la portée de base de n'importe quelle variable - si aucun préfixe, alors c'est un local. En outre, lorsque vous lisez une fonction, vous n'avez pas besoin de penser à ce qui est passé dans et ce qui est juste une variable locale.

la Plupart du temps, j'utilise python. Python exige que vous utilisiez self.foo afin d'accéder à l'attribut " foo de l'instance de la classe en cours. De cette façon, le problème de la confusion des variables locales, des paramètres et des attributs de l'instance sur laquelle vous travaillez est résolu.

En général, j'aime cette approche, même si je n'aime pas être forcé de le faire. Ainsi, ma façon idéale de faire les choses est de ne pas le faire et d'utiliser une certaine forme d'accès d'attribut sur ceci ou soi-même afin de récupérer les variables membres. Comme ça, je n'aurai pas à encombrer les noms avec des méta-données.

un seul _ utilisé uniquement comme indicateur visuel. (C#)

• aide à grouper les membres avec intellisense.
• plus facile à repérer les variables membres lors de la lecture du code.
• plus difficiles à cacher une variable membre à une définition locale.

_ au lieu de this.

j'utilise _ aussi au lieu de this. parce que c'est juste plus court ( 4 moins de caractères) et c'est un bon indicateur des variables membres. De plus, en utilisant ce préfixe, Vous pouvez éviter les conflits de noms. Exemple:

public class Person {
  private String _name;

  public Person(String name) {
    _name = name;
  }
}

Comparez avec ceci:

public class Person {
  private String name;

  public Person(String name) {
    this.name = name;
  }
}

je trouve le premier exemple plus court et plus clair.

ça dépend dans quelle langue vous travaillez.

dans C# vous pouvez faire référence à n'importe quel membre en utilisant le préfixe 'this', par exemple 'this.val', ce qui signifie qu'aucun préfixe n'est nécessaire. VB a une capacité similaire avec "Me".

dans les langues où il y a une notation intégrée pour indiquer l'accès d'un membre, Je ne vois pas l'intérêt d'utiliser un préfixe. Dans d'autres langues, je suppose qu'il est logique d'utiliser quelle que soit la convention communément acceptée est pour cela langue.

notez que l'un des avantages d'utiliser une notation intégrée est que vous pouvez également l'utiliser lorsque vous accédez à des propriétés et méthodes sur la classe sans compromettre vos conventions de nommage pour celles-ci (ce qui est particulièrement important lorsque vous accédez à des membres non privés). La raison principale de l'utilisation de tout type d'indicateur est un indicateur qui vous causent des effets secondaires possibles de la classe, alors c'est une bonne idée de l'avoir lors de l'utilisation d'autres membres, indépendamment de savoir si ils sont un champ/propriété/méthode/etc.

une autre astuce est Convention d'appellation :

toutes les variables membres sont nommées comme d'habitude, sans préfixe (ou ' ceci."est-ce qu'il est habituel de le faire dans le projet)

mais ils seront facilement différenciés de la variable locale parce que dans mon projet, ces variables locales sont toujours nommées:

• un quelque Chose: représente un objet.
• certains ManyThings: liste des objets.
• est AState ou a quelque chose: pour l'état booléen.

toute variable qui ne commence pas par "A", "some" ou "is/has" est une variable membre.

depuis VB.NET n'est pas sensible à la casse, Je préfixe mes variables membres avec un underscore et un camel case le reste du nom. Je capitalise les noms de propriétés.

Dim _valueName As Integer

Public Property ValueName() As Integer

je suis avec les gens qui n'utilisent pas de préfixes.

IDEs sont si bons de nos jours, il est facile de trouver l'information sur une variable à un coup d'oeil de la coloration de la syntaxe, mouse-over tooltips et la navigation facile à sa définition.

c'est en plus de ce que vous pouvez obtenir à partir du contexte de la variable et des conventions de nommage (comme lowerCamelCase pour les variables locales et les champs privés, UpperCamelCase pour les propriétés et les méthodes etc) et des choses comme "hasXXXX" et" isXX " pour booléens.

Je n'ai pas utilisé de préfixes depuis des années, mais j'avais l'habitude d'être un "Ceci."préfixe monstre mais je suis parti que si absolument nécessaire (merci, Resharper).

je suis weirdo et je préfixe les variables membres avec les initiales du nom de classe (qui est Camel-cased).

TGpHttpRequest = class(TOmniWorker)
strict private
  hrHttpClient  : THttpCli;
  hrPageContents: string;
  hrPassword    : string;
  hrPostData    : string;

la plupart des gens de Delphi utilisent juste F.

TGpHttpRequest = class(TOmniWorker)
strict private
  FHttpClient  : THttpCli;
  FPageContents: string;
  FPassword    : string;
  FPostData    : string;

j'utilise camel case et underscore comme beaucoup ici. J'utilise le underscore parce que je travaille avec C# et je me suis habitué à éviter le mot-clé 'ceci' dans mes constructeurs. Je camel case méthode-scoped variantes de sorte que le underscore me rappelle quelle portée je travaille avec à l'époque. Sinon, je ne pense pas que cela importe tant que vous n'essayez pas d'ajouter des informations inutiles qui sont déjà évidentes dans le code.

j'ai utilisé M_ perfix en C++ mais en C# je préfère utiliser camel case pour le champ et pascal case pour sa propriété.

private int fooBar;
public int FooBar
{
  get { return fooBar; }
  set { fooBar = value; }
}

j'aime m_ mais tant que la convention est utilisée dans la base de code est utilisé, je suis cool avec elle.

votre mul_ example se dirige vers la notation hongroise des applications de Charles Simonyi.

je préfère garder les choses simples et c'est pourquoi j'aime utiliser m_ comme préfixe.

cela rend beaucoup plus facile de voir où vous devez aller voir l'original de la déclaration.

Aucun si ce n'est pas nécessaire, soulignement simple sinon. S'applique à python.

j'ai tendance à utiliser m_ en C++, mais ça ne me dérangerait pas de le laisser en Java ou C#. Et il dépend de la norme de codage. Pour le code d'héritage qui a un mélange de underscore et m_, Je refactoriserais le code à une norme (étant donné une taille de code raisonnable)

j'utilise @.

:D j/k -- mais si elle ne sorte de dépendent de la langue. S'il y a getters/setters, je mets habituellement un _ devant la variable private member et le getter/setter aura le même nom sans le _. Sinon, j'ai l'habitude de ne pas utiliser toute la.

S'il est vraiment nécessaire de préfixer des variables membres, je préférerais certainement m_ à un simple underscore. Je trouve un underscore en lui-même réduit la lisibilité, et peut être confondu avec des mots réservés C++.

cependant, je doute que les variables membres nécessitent une notation spéciale. Même en ignorant l'AIDE IDE, il n'est pas évident pourquoi il y aurait confusion entre ce qui est une variable locale et ce qui est une variable membre.

pour mes propres projets j'utilise _ comme postfix (comme Martin York l'a noté ci-dessus, _ comme préfixe est le serveur de réserve par la norme C/C++ pour les implémentations de Compilateurs) et je travaille sur Symbian projects .

en Java, une convention commune est de préfacer les variables membres avec "my" andusecamelcase pour le reste du nom variable.