A vor Variablen

[Bladefire]

Hallo,

hin und wieder treffe ich ein A vor Variablen in verschiedenen funktionen an. Ich würde gerne wissen was das heißt. Bzw. unter welchen Stichwort ich es googlen kann.

Lg Simon

[Namenloser]

Das A steht für „argument“. Ist einfach eine Konvention, die von manchen verwendet wird, genau wie das T für „type“ bei Klassen oder das F für „field“ bei Feldern.

[Aphton]

Ich glaube, dass es seinen Ursprung hier hat (Bsp zur Verdeutlichung)

Delphi-Quellcode:

type
  TPerson = class
  private
    Age: Integer
  public
    procedure setAge(AAge: Integer);
  end;

procedure TPerson.setAge(AAge: Integer):
begin
  Age := AAge;
end;

Bei dieser Zuweisung kann man kein Age := Age machen, da die Sichtbarkeit von innen nach außen hin aufgelöst wird (Funktionsparameter -> Klassenfelder -> Globale Variablen -> ...)

Ich find das aber eher unschön; da gibts auch eine einfache Lösung dafür:

Delphi-Quellcode:

procedure TPerson.setAge(Age: IntegeR);
begin
  Self.Age := Age;
end

[RWarnecke]

Namenloser ist da eher schon auf dem richtigen Pfad. Ich habe auch ein Fremdprojekt, welches ich übernommen habe. Da wurde auch alle Variablen so deklariert. Die Buchstaben können auch die Art der Variable ausdrücken, wie zum Beispiel Integer, String u.s.w.

Edit:
Ich glaube so etwas in der richtig suchst Du oder ? Link

[himitsu]

Zitat von RWarnecke:

Die Buchstaben können auch die Art der Variable ausdrücken, wie zum Beispiel Integer, String u.s.w.

Joar, wobei ich diese Art eher schlecht finde.

Es gibt mehrere Gründe für einen Prefix oder Suffix.
- Kennzeichnung der Quelle (Position)
- Kennzeichnung des Typs
- wer weiß was sonst noch

Aber so kann man es auch bei den Enums betrachten, was nun schöner ist.
- Prefix als Gruppierung/Kennzeichnung des Enum-Typs
- oder ohne Prefix und dafür mit Namespace


Bei Parametern lass' ich die Prefixe aber auch lieber weg, denn so heißen die Property genauso wie die zugehörigen Parameter.

[Sir Rufo]

Wenn man eine gewisse Namens-Konvention einhält, dann weiß man auf einen Blick, wo die Variablen herkommt, bzw. wo die hingehört:

Delphi-Quellcode:

// Typen fangen mit T an
TFoo = class
private
    // privates Klassen-Feld: hier gibt es nix definiertes, ich nehme dafür einen _
  class var
    _Value : string;
private
  // Felder einer Klasse beginnen mit einem F
  FValue : string;
  function GetValue : string;
public
  // Eine Eigenschaft wird so benannt, wie sie genannt wird ohne Prefix
  property Value : string read GetValue write FValue;

  // Argumente von Methoden beginnen mit einem A
  function GetSomething( const AValue : string ) : string;
end;

function TFoo.GetValue : string;
begin
  Result := '*' + FValue + '*';
end;    

function TFoo.GetSomething( const AValue : string ) : string;
var
  // Hier gibt es keine allgemein gültige Konvention
  // Meine Lokalen Variablen beginnen mit einem L 
  LValue : string;
begin

  LValue { Lokale Variable } := 
    Value   { Eigenschaft }  + 
    AValue  { Argument der Methode } + 
    FValue  { Feld der Klasse } + 
    _Value  { Klassen-Variable };

  Result := LValue;
end;