Implicite vs getters / setters explicites dans AS3, qui à utiliser et pourquoi?

Question

Depuis l'avènement de AS3 je travaille comme ceci:

private var loggy:String;

public function getLoggy ():String
{
  return loggy;
}

public function setLoggy ( loggy:String ):void
{
  // checking to make sure loggy's new value is kosher etc...
  this.loggy = loggy;
}

et ont évité de travailler comme ceci:

private var _loggy:String;

public function get loggy ():String
{
  return _loggy;
}

public function set loggy ( loggy:String ):void
{
  // checking to make sure loggy's new value is kosher etc...
  _loggy = loggy;
}

Je l'ai évité d'utiliser getters / setters implicites de AS3 en partie pour que je puisse commencer à taper « get .. » et l'assistant de contenu va me donner une liste de tous mes getters, et de même pour mes setters. Je n'aime aussi underscores dans mon code qui me éteint la route implicite.

Une autre raison est que je préfère la sensation de ceci:

whateverObject.setLoggy( "loggy's awesome new value!" );

à ceci:

whateverObject.loggy = "loggy's awesome new value!";

Je sens que l'ancien reflète mieux ce qui se passe réellement dans le code. Je fais appel des fonctions, pas la définition des valeurs directement.

Après l'installation de Flash Builder et le grand nouveau plugin SourceMate ( ce qui permet d'obtenir quelques-unes des caractéristiques utiles qui FDT est célèbre en FB) j'ai réalisé que lorsque j'utiliser la fonction « générer accesseurs » de SourceMate il définit automatiquement mon code à l'aide de la route implicite:

private var _loggy:String;

public function get loggy ():String
{
  return _loggy;
}

public function set loggy ( loggy:String ):void
{
  // do whatever is needed to check to make sure loggy is an acceptable value
  _loggy = loggy;
}

Je figure que ces gens SourceMate doivent savoir ce qu'ils font ou qu'ils ne seraient pas en train d'écrire des plugins d'amélioration du flux de travail pour le codage en AS3, alors maintenant je me demande mes voies.

Alors ma question est la suivante: quelqu'un peut me donner une bonne raison pour laquelle je devrais donner mon explicite g / s façons, commencer à utiliser la technique implicite, et embrasser ces petits _underscores puants pour mes vars privés? Ou dos me dans mes raisons pour faire les choses comme ce que je fais?

Answer 1

Pour être honnête, je pense que cela est un peu comme indenter ou style corset - où l'importance / serviabilité correspondant à votre style à tout ce que vous travaillez avec codeBase éclipses un avantage « inhérent » à une ou l'autre approche. Cela dit cependant, que de ces auriez-vous maintenir plutôt dans un moteur physique?

// with getters
body.position.y += body.velocity.y * dt;

// without
body.getPosition().setY( body.getPosition().getY() + body.getVelocity.getY() * dt );

Un autre avantage pour les getters / setters est que vous pouvez toujours faire des propriétés simples variables publiques d'abord, et les factoriser dans getters / setters plus tard si nécessaire, sans changer le code externe. Vous ne devez pas accesseurs construire pour chaque variable de manière préemptive; vous pouvez attendre jusqu'à ce que vous vous décidiez besoin.

Answer 2

Je peux penser à quelques raisons du haut de ma tête.

1. get Implicite / set offre une meilleure / plus facile fonctionnalité des données de liaison. Il est plus facile de câbler les événements et les crises dans le « modèle Flex » beaucoup plus agréable.
2. Il rend votre ASDoc généré beaucoup plus concis.
3. Il est, je crois, la seule façon d'obtenir une propriété dans l'inspecteur des propriétés pour les composants personnalisés lorsque vous travaillez en mode design.

Gardez à l'esprit que si tout ce que vous faites est get / set droite, il n'y a pas beaucoup perdu en qu'exposer un public var et sans passer par le getter / setter avec la tenue var (_variable). Vous pouvez toujours changer un get implicite / set plus tard sans changer les classes interface externe.

Answer 3

Je ne me getters implicites parce que si durcisse refactoring et la lisibilité du code. Il est généralement pas très facile à repérer si l'affectation est au champ public ou est la méthode accesseur. Donc, si vous voulez suivre un bug que vous pourriez tomber dans la chasse méchant.