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);
