Introduktion till Delphi XE5

Språket Delphi är inte skiftlägeskänsligt för nyckelord eller namn. Kompilatorn kontrollerar att konstanta värden får plats i variabeln de tilldelas till, men under körning kontrolleras inte överflöden.

Viktiga snabbtangenter:

• F5: Breakpoint
• F9: Kompilera och starta (Shift+Ctrl+F9 startar utan debugging)
• Ctrl+F9: Kompilera
• Ctrl+Shit+C: Implementera alla funktioner

Unit

En källkodsfil har filändelsen .pas och benämns som en unit (enhet). En enhet inleds med nyckelordet unit och avslutas med end. (inklusive punkten). Den minimala strukturen ser ut så här:

unit MinUnit;

interface

implementation

end.

I sektionen interface anges vilka andra enheter som enheten använder.

interface
uses
  MinAndraUnit;

Dessutom deklareras typer (nyckelordet type) och globala variabler i interface. Sektionen implementation används för att implementera funktioner.

Datatyper

Numeriska datatyper:

• Byte: 0 – 255
• ShortInt: -127 – 127
• Word: 16 bit osignerad (0 – 65535)
• SmallInt: 16 bit signerad (-32768 – 32767)
• LongWord (eller Cardinal): 32 bit osignerad
• LongInt (eller Integer): 32 bit signerad
• Int64: 64 bit signerad
• Currency: 50 tecken, fyra decimaler

Flyttal:

• Single: 7 tecken
• Double: 15 tecken
• Extended: 19 tecken

Konstanter skapas utan att någon datatyp behöver anges. Notera att = vid deklaration av konstanter. Följande exempel skapar en ShortInt (A), en SmallInt (B) och en Integer (C):

const
  A = 30;
  B = 300;
  C = 300000;

Text:

• Char (eller AnsiChar): Ett enkelt tecken
• WideChar: Ett internationellt tecken
• ShortString: Upp till 255 Char
• String (eller AnsiString): Fritt antal Char
• WideString: Fritt antal WideChar

Som strängavgränsare används apostrof (‘).

var
   s : string;
begin
   s := 'Conny Karlsson';
   writeln(copy(s, 1, 3)); //Första tecknet och tre framåt ger 'Con'
   insert('Helmer ', s, 7); //Infoga 'Helmer ' efter 'Conny '
   writeln(s); //'Conny Helmer Karlsson'
   //Byt ut Helmer till Holger.
   writeln(stringreplace(s, 'Helmer', 'Holger', [rfReplaceAll, rfIgnoreCase]));

Operatörer

Aritmetiska operatörer:

• + (addition eller strängkonkatenering)
• – (subtraktion)
• * (multiplikation)
• / (division)
• div (heltalsdivision)
• mod (modulus)

Logiska operatörer:

• and (logiskt och)
• or (logiskt eller)
• xor (logiskt exklusivt eller)
• not (enkel logiskt inte)

Jämförelseoperatörer:

• = (lika med)
• < och > (mindre än, större än)
• <= och >= (mindre än eller lika med, större än eller lika med)
• <> (inte lika med)

För tilldelning används := (kolon och lika med).

Typomvandling

För konvertering från tal till sträng används Str, CurrToStr, Format, IntToStr och IntToHex. Notera att Str tar en sträng som utparameter med resultatet istället för att ge resultatet i retur.

var
  i : Integer;
  s : String;
  c : Currency;
begin
  //Konvertera Integer till String med s som utparameter:
  i := 10;
  Str(i, s);
  //Konvertera Currentsy till String:
  c := 100;
  s := CurrToStr(c);

För att konvertera från sträng till tal används StrToInt, StrToIntDef (feltolerant konvertering) och StrToFloat.

var
  f : Extended;
  format : TFormatSettings;
begin
  //Konvertera String till Integer (undantagsfel vid misslyckad konvertering):
  writeln(StrToInt('500'));
  //Konvertera String till Integer (0 vid misslyckad konvertering):
  writeln(StrToIntDef('1000', 0));
  //Konvertera String till Extended (undantagsfel vid misslyckad konvertering):
  format := TFormatSettings.create;
  format.DecimalSeparator := ',';
  writeln(StrToFloat('100,5', format));

Typer

Typer deklareras i interface-sektionen i en enhet. De inleds med type följt av namn och supertyp, och avslutas med end; (notera avslutande semikolon). Detta exempel visar två typer:

type
  MinTyp = class(TObject)
  end;

type
  MinAndraTyp = class(TObject)
  end;

Supertypen TObject behöver inte anges, eftersom den antas gälla. Deklarationerna delas upp efter synlighet. Följande exempel utrustar typen Employee med två privata medlemsvariabler.

type
  Employee = class
private
  //Privata variabler
  _firstName : string;
  _lastName : string;
  end;

Förutom synlighetsnivån private finns nivåerna protected, public och published. Nivån private anger att medlemmen är lokal för objektet, protected innebär att typer som ärver från typen har tillgång till medlemmen, public innebär att alla andra objekt i samma projekt har tillgång till medlemmen, och published innebär att medlemmen dessutom är tillgänglig för object inspectorn i utvecklingsmiljön.

Funktioner

Funktioner deklareras med nyckelordet function, följt av funktionens namn, parameterlista och returtyp enligt följande:

function Namn(parameter: typ; parameter: typ) : returtyp;

Om funktionen saknar retur, används istället nyckelordet procedure.

procedure Namn(parameter: typ; parameter: typ)

Parenteserna efter namnet är inte nödvändiga om funktionen eller proceduren inte tar några parametrar. Detta exempel visar funktionen getName:

type
  Employee = class
  private
    //Privata variabler
    _firstName : string;
    _lastName : string;
    function getName : string;
  end;

Implementationerna sker i sektionen implementation. Man använder typnamn.funktionsnamn för att ange vilken funktion som implementeras. Implementationen avgränsas med begin och end; (semikolon). Det är inte obligatoriskt att skicka tillbaka ett värde, trots att man deklarerat en returtyp. För att skicka tillbaka ett värde görs en tilldelning till result.

function Employee.getName: string;
begin
  result :=  (_firstName + ' ' + _lastName);
end;

Däremot är det inte tillåtet att läsa oinitierade strängar. Ett sätt att utrusta _firstName och _lastName med värden är att implementera en konstruktor. Dessa ska enligt standarden heta create, och kan överlagras för att erbjuda flera sätt att initiera objekten.

public
  constructor create; overload;
  constructor create(firstName: string; lastName: string); overload;

Konstruktorn måste anropas uttryckligen.

e := Employee.create;

Properties

Properties är inte lika mångsidiga som i många andra språk. I Delphi anger man endast vilken medlemsvariabel som påverkas vid tilldelning till en property, och vilken som påverkas av avläsning. Syntaxen för en property är:

property namn : typ read uttryck write uttryck;

För att skapa en read only property utelämnas write uttryck, och för att skapa en read only property utelämnas write uttryck. Exempel:

type
  Point = class
  private
    _x : integer;
    _y : integer;
  public
    property x : integer read _x write _x;
    property y : integer read _y write _y;
  end;

Ett exempel

Följande exempel visar deklarationen av en klass (sektionen interface) som representerar en person. Klassen innehåller privata variabler, en privat funktion, två konstruktorer, två read/write properties samt en read only property som använder en funktion som uttryck.

type
  Employee = class
  private
    //Privata variabler
    _firstName : string;
    _lastName : string;
    function getName : string;
  public
    constructor create; overload;
    constructor create(firstName: string; lastName: string); overload;
    property firstName : string read _firstName write _firstName;
    property lastName : string read _lastName write _lastName;
    property name : string read getName;
  end;

Så här ser implementationerna ut (sektionen implementation):

constructor Employee.create;
begin
  _firstName := '';
  _lastName := '';
end;

constructor Employee.create(firstName, lastName: string);
begin
  _firstName := firstName;
  _lastName := lastName;
end;

function Employee.getName: string;
  begin
  result :=  (_firstName + ' ' + _lastName);
end;

Här följer ett exempel:

var
  e : Employee;
begin
  e := Employee.create('Sven', 'Svensson');
  writeln(e.name);