Nástroje vývojára
Integrované vývojové prostredie (IDE) Lazarus sa hrdí tým, že je to prostredie pre Rýchly vývoj aplikácii (RAD). A myslím si, že právom. IDE ponúka vývojárovi mnoho nástrojov pre zrýchlenie práce so zdrojovým kódom, ktoré sú však málo známe.
Obsah článku
Nástroje IDE sú popísané aj v slovenskom preklade dokumentácie, napriek tomu chcem tieto nástroje popísať znova. Vzhľadom k tomu, že som tú stránku dokumentácie prekladal, dovolím si niektoré časti použiť doslovne.
Niektoré nástroje sú prístupné prostredníctvom kontextového menu, iné pomocou klávesovej skratky. Zväčša však obomi spôsobmi. V popise sa zamerám na ovládanie klávesovými skratkami, pretože predpokladám, že väčšina vývojárov píše kód na klávesnici a je preto málo efektívne neustále premiestňovanie ruky z klávesnice na myš a naopak.
Nástroje, ktoré ponúka IDE Lazarus vývojárovi na zjednodušenie i zrýchlenie práce možno rozdeliť do niekoľkých kategórií:
- nástroje presunu v kóde
- dokončovanie kódu
- refactoring
- šablóny
- publikovanie projektu
Zhrnutie klávesových skratiek
Názov | Klávesová skratka | |
---|---|---|
Hľadanie deklarácie | Declaration Jumping | Ctrl+Click alebo Alt+Up |
Prepínanie metód | Method Jumping | Ctrl+Shift+Up a Ctrl+Shift+Down |
Šablóny kódu | Code Templates | Ctrl+J |
Dokončovanie kódu | Code/Class Completion | Ctrl+Shift+C |
Dokončovanie identifikátorov | Identifier Completion | Ctrl+Medzerník |
Dokončovanie slov | Word Completion | Ctrl+W |
Pomoc s parametrami | Parameter Hints | Ctrl+Shift+Space |
Úplne na začiatok popíšem tri, asi najužitočnejšie nástroje, ktoré ponúka IDE.
Dokončovanie identifikátorov
V originále Identifier Completion, je naozaj užitočný nástroj. Keďže programovanie v Lazare nie je mojou prácou, ale len koníčkom, nenosím v hlave všetky možné aj nemožné mená vlastností, metód, procedúr či funkcií. Nepamätám si aj preto, lebo nemusím, napíšem niekoľko prvých písmen a potom stlačím Ctrl+Medzerník a v zozname, ktorý sa objaví, si nájdem to čo práve potrebujem. A nemusím napísať ani tých niekoľko znakov na začiatku. Predstavte si procedúru:
Dokončenie identifikátora
procedure TForm1.FormCreate(Sender: TObject);
begin
|
end;
Umiestnite v nej kurzor medzi begin
a end
a stlačte
Ctrl+Space. Nástroj IDE spracuje celý dosiahnuteľný kód a zobrazí
zoznam všetkých nájdených identifikátorov. Prvý krát to môže chvíľu
trvať, ale CodeTools si ukladajú výsledok do medzipamäte, takže
ďalšie hľadania sú rýchlejšie.
Niektoré identifikátory, ako napríklad Write
, ReadLn
, Low
,
SetLength
, a podobne sú zabudované v prekladači, a teda nie sú
definované nikde v zdrojovom kóde. Ak by dokončovanie identifikátorov
pracovalo len so zdrojovými kódmi, nenašlo by ich. Preto má funkcia
Dokončovanie identifikátorov veľa z takýchto slov tiež zabudovaných.
Dokončovanie identifikátorov nedokončuje kľúčové slová prekladača,
takže ho nemožno použiť na dokončenie proc na procedure
. Na
toto je určené Dokončovanie slov alebo Šablóny kódu.
Dokončovanie identifikátorov nezobrazuje tie identifikátory, ktoré sú
nekompatibilné a tiež rozpoznáva nekompletné vlastnosti a navrhne
predvolené mená:
property PropName: PropType read |;
Keď umiestnite kurzor za medzeru za kľúčovým slovom read a
stlačíte Ctrl+Medzerník pre dokončovanie identifikátorov, bude v
zozname ponúknutá len premenná FPropName
a procedúra
SetPropName
. Ak b bola v zozname ponúknutá len jedna možnosť, je
táto možnosť automaticky doplnená.
Pri vyhľadávaní vhodných kandidátov na doplnenie identifikátora berie do úvahy všetky znaky vľavo od kurzora a poskytuje v zozname len identifikátory, ktorá sa na dané znaky začínajú. Takto môžete začať dokončovanie identifikátorov aj v už existujúcom slove. Potom budú písmená vľavo od kurzora brané ako predpona:
Doplňovanie uprostred slova
procedure TForm1.FormCreate(Sender: TObject);
begin
Ca|ption
end;
V totmo prípade nástroj ponúkne v zozname len identifikátory, ktoré sa začínajú na Ca.
Klávesy v okne identifikátorov
Pri zobrazenom okne so zoznamom ponúkaných identifikátorov majú jednotlivé klávesy takúto funkciu:
- písmená/čísla: pridávajú znak do editora zdrojového kódu a aktuálnej predpony, čo zároveň aktualizuje zoznam,
- BackSpace: odstraňuje posledný znak z editora zdrojového kódu a aktuálnej predpony, čo zároveň aktualizuje zoznam,
- Enter: nahradzuje celé slovo na kurzore zvoleným identifikátorom a zatvára vyskakovacie okno,
- Shift+Enter: ako Enter, ale nahradzuje len predponu (ľavú časť) slova na kurzore,
- Hore/Dole: presúva výber,
- Esc: zatvára vyskakovacie okno bez zmeny,
- Tabulátor: dokončuje predponu na ďalšiu zhodu, ak napríklad aktuálna predpona je But a dokončovanie identifikátora zobrazuje len Button1 a Button1Click, potom stlačenie Tabulátora dokončí predponu na Button1.
Dokončovanie slov
Dokončovanie slov (Word Completion) dokončuje kľúčové slová prekladača, je vyvolané stlačením Ctrl+W a na dokončenie ponúka všetky slová všetkých aktuálne otvorených editorov. Inak pracuje presne ako Dokončovanie identifikátorov.
Pomoc s parametrami
Toto je môj ďalší problém. Keď sa už dopátram k menu funkcie, či procedúry, ako sa dostať k zoznamu jej parametrov? To je práve úloha pre Pomoc s parametrami (Parameter Hints). Po stlačení Ctrl+Shift+Medzerník ukazuje pomocné okno s deklaráciami parametrov aktuálneho zoznamu parametrov:
Canvas.FillRect(|);
Umiestnite kurzor do zátvoriek, stlačte skratku Ctrl+Shift+Medzerník
a objaví sa pomocné okno, ukazujúce parametre FillRect
. Ak je funkcia
preťažená, okno poskytuje zoznam parametrov podľa aktuálne zadaných údajov.
Skákanie v kóde
Určite ste sa stretli s tým, že ste potrebovali pozrieť na iné miesto v kóde. IDE poskytuje pre tento účel niekoľko praktických nástrojov.
Prepínanie metód
V anglickom origináli sa tento nástroj volá Method Jumping, čiže doslovný preklad by mohol znieť Metódové skákanie. Ale myslím, že prepínanie je výstižnejšie, pretože sa jedná o prepínanie medzi telom metódy a jej deklaráciou.
Na samotné prepínanie slúžia klávesové skratky Ctrl+Shift+ŠípkaHore,
respektíve Ctrl+Shit+ŠípkaDole. Skratku
využijete, ak sa nachádzate (kurzor) v tele metódy, teda medzi
kľúčovými slovami begin
a end
metódy. Stlačením
Ctrl+Shift+ŠípkaHore sa kurzor prenesie na jej deklaráciu. Ak sa
kurzor nachádza niekde v deklarácii procedúry, presuniete sa do jej
tela pomocou klávesovej skratky Ctrl+Shit+ŠípkaDole.
Tento nástroj IDE nie je obmedzený len metódy, ale pracuje aj s bežnými procedúrami a funkciami. Dôležité je uvedomiť si, že pri romro prepínaní je urobený skok na metódu s rovnakým názvom aj zoznamom parametrov.
V prípade, že nástroj Prepínanie metód nenájde deklaráciu (alebo telo) metódy s rovnakým názvom a rovnakou deklaráciou parametrov, skočí na metódu, ktorá je najpodobnejšia a kurzor umiestni na prvý rozdiel v mene alebo parametroch metódy. Takto môžete pomerne jednoducho identifikovať preklep v mene metódy, alebo zabudnuté zmeny v deklarácii parametrov.
Príklad rôznych parametrov
interface
procedure DoSomething(p: char); // deklarácia procedúry
implementation
procedure DoSomething(p: string); // telo procedúry
begin
// ...
end;
Preskočenie z deklarácie do tela umiestni kurzor na kľúčové slovo string, pretože v ňom je rozdiel. Túto vlastnosť môžete využiť na premenovanie metódy a/alebo zmenu jej parametrov.
Premenovaná metóda ‚DoSomething‘ na ‚MakeIt‘
interface
procedure MakeIt; // deklarácia procedúry
implementation
procedure DoSomething; // telo procedúry
begin
// ...
end;
Ak v tomto prípade urobíte prepnutie z deklarácie MakeIt
do jej
tela, bude IDE hľadať vhodné telo, ale keďže žiadne nenájde, začne
hľadať kandidátov. Premenovaná bola len jedna procedúra, tak existuje
len jedno telo bez deklarácie (DoSomething
), a tak kurzor skočí do
DoSomething
a IDE ho umiestni vpravo od DoSomething
. Teraz je
možné ľahko premenovať aj implementáciu procedúry. V prípade
premenovaných parametrov je funkcia obdobná.
Hľadanie deklarácie
V originálnom názve Find Declaration. Tento nástroj je určený pre rýchle vyhľadanie deklarácie identifikátora. Stačí, ak je kurzor kdekoľvek v mene identifikátora, stlačiť skratku Alt+Up` a kurzor skočí na deklaráciu daného identifikátora. Ak máte v ruke myš, môžete využiť skratku Ctrl+ĽavéTlačidlo.
Umiestnite kurzor na identifikátor a urobte Hľadanie deklarácie, tým bude nájdená deklarácia tohoto identifikátora, prípadne otvorený príslušný súbor a kurzor bude premiestnený na miesto deklarácie. Každé takéto hľadanie deklarácie nastavuje bod skoku. Tzn. po skoku na nájdenú deklaráciu môžete jednoducho skočiť naspäť pomocou kontextového menu
.Oproti Delphi má nástroj hlavný rozdiel v tom, že pracuje so zdrojovým kódom na základe pravidiel Pascalu, a nie s výsledkom prekladača. Prekladač potom vracia konečný typ identifikátora, len Hľadanie deklarácie prezerá zdrojové kódy a všetky kroky medzi získaním výsledného typu. Týmto spôsobom môžete stopovať každý identifikátor a nájsť každé predefinovanie, či preťaženie.
Napríklad, vlastnosť Visible
je najprv deklarovaná v TControl
(controls.pp
), potom je predefinovaná v TCustomForm
a nakoniec
predefinovaná aj v TForm
. Spustenie Hľadania deklarácie
vlastnosti Visible
vás najprv presunie na Visible
v TForm
,
potom možno spustiť hľadanie deklarácie znova a skočíte na Visible v
TCustomForm
a znova pre skočenie na Visible
v TControl
.
Vnorené súbory
V originále Include Files . Jedná sa o súbory vložené do zdrojového kódu pomocou direktív prekladača {$I filename} alebo {$INCLUDE filename}. Lazarus a FreePascal často používajú tento spôsob rozdelenia zdrojového kódu na redukciu nadbytočnosti a zlepšenie čitateľnosti, napríklad konštrukcií {$IFDEF} pri podpore rôznych platforiem.
Narozdiel od Delphi, IDE Lazarus plne podporuje vnorené súbory. Napríklad môžete skočiť z deklarácie metódy v súbore .pas do tela metódy vo vnorenom (include) súbore. Všetky nástroje kódu, považujú vnorené súbory za špeciálne hranice. Napríklad: keď dokončovanie kódu pridáva telo novej metódy za telom inej metódy, ponechá ich obe v rovnakom súbore. Týmto spôsobom môžete vložiť celú implementáciu triedy do include súborov, ako to robí LCL skoro pre všetky svoje ovládacie prvky.
Pri práci s vnorenými súbormi je však treba dávať pozor na jednu začiatočnícku chybu, a to ak najprv otvoríte vnorený súbor a skúsite prepínanie metód alebo hľadanie deklarácie, nemusí to fungovať. IDE totiž nevie (a ani nemá odkiaľ), do ktorej jednotky vnorený súbor patrí, preto je potebné najprv otvoriť jednotku.
Po zanalyzovaní jednotky, IDE v nej rozpozná direktívy include a bude pamätať vzťahy jednotlivých súborov. Tieto informácie si IDE ukladá pri skončení a pri uložení projektu, a keď nabudúce otvoríte vnorený súbor a urobíte do neho skok alebo hľadanie deklarácie, IDE interne otvorí jednotku a skoky budú fungovať.
Tento mechanizmus má aj svoje obmedzenia. Ak je vnorený súbor použitý dvomi, či viacerými jednotkami, potom jednotlivé skoky z deklarácie procedúry/metódy v tomto vnorenom súbore do tela závisia na poslednej akcii. Ak ste pracovali s jednou jednotkou, bude urobený skok do nej, ak s druho, potom do druhej. Ak pracujete s obomi, potom nastane zmätok.
Prejdi do direktívy include
Tento nástroj sa v origináli volá (Goto Include Directive). Tento príkaz, v menu Search, využijete vprípade, že sa nachádzate vo vnorenom súbore. Po jeho použití IDE urobí skok na miesto príkazu (direktívy) {$I filename}, pomocou ktorého je aktuálny súbor vnorený.
Záložky


Poznáte to, máte rozsiahly projekt, niečo v ňom upravujete, ale to neustále posúvanie sa o 20 riadkov, či o tri súbory vedľa… IDE ponúka riešenie, v súboroch zdrojového kódu si môžete definovať záložky, na ktoré potom môžete skákať pomocou klávesovej skratky alebo kontextového menu.
Záložku môžete vytvoriť pomocou klávesových skratiek Ctrl+Shift+Číslo a skočiť na už vytvorenú záložku pomocou skratky Ctrl+Číslo, pričom Číslo sú klávesy 0..9. Môžete využiť aj príkaz Nastaviť voľnú záložku. Tento príkaz priradí najnižšiu z voľných záložiek v mieste kurzora. Prístup k záložkam je aj prostredníctvom kontextového menu.
Všimnite si, že v kontextovom menu je pri každej nastavenej záložke zobrazené meno príslušného súboru spolu s číslom riadku a stĺpca. Takže skok na danú záložku prenesie kurzor na konkrétne miesto riadku.
Dokončovanie kódu
Nástroje dokončovania kódu využívam pomerne často, najmä dokončovanie identifikátorv, pretože si mená jednotlivých vlastností a metód jednoducho nepamätám. Zdá sa Vám to divné? Je to nakoniec jedno, hlavne, že sú tieto nástroje užitočné. A v skutku sa jedná o mocný nástroj, ktorý dokáže ušetriť veľa práce.
Dokončovanie tried
V originále nazvané Class Completion. Jedná sa o veľmi výkonnú
funkciu dokončovania kódu a jej funkcia je prostá. Stačí napísať
definíciu triedy, pridáte deklaráciu metód a vlastností, a
Dokončovanie kódu pridá telá metód, metódy prístupu k vlastnostiam
a súkromným premenným. A polovica práce je hotová. Nerozumiete? Všetko
si ukážeme na príklade. Vytvorte triedu TExample
:
Definícia triedy
TExample = class(TObject)
public
constructor Create;
destructor Destroy; override;
end;
Umiestnite kurzor niekde do tela definície triedy a stlačte skratku Ctrl+Shift+C. Dokončovanie tried vytvorí chýbajúce telá metód a presunie kurzor na prvé vytvorené telo, takže môžno rovno začať písať kód metódy:
Doplnené telá metód
{ TExample }
constructor TExample.Create;
begin
|
end;
destructor TExample.Destroy;
begin
inherited Destroy;
end;
Poznámka
Značka ‚|‘ nie je pridaná, len ukazuje umiestnenie kurzora.
Všimnite si, že Dokončovanie tried automaticky pridáva volanie
deštruktora základnej triedy (inherited Destroy
). Toto
automatické vloženie je urobené, ak pri deklarácii metódy v triede
použijete kľúčové slovo override
. Teraz pridajte ďalšiu metódu,
napríklad DoSomething
:
Deklarované procedúry
TExample = class(TObject)
public
constructor Create;
procedure DoSomething(i: integer);
destructor Destroy; override;
end;
Keď teraz použijeme Dokončovanie tried a bude pridané telo novej metódy:
Doplnené telo metódy
procedure TExample.DoSomething(i: integer);
begin
|
end;
Všimnite si, že nové telo metódy je vložené medzi telá metódy
Create
a Destroy
, teda presne na miesto ako je to v definícii.
Týmto sú telá metód uchovávané v rovnakom logickom poradí, ako v
deklarácii. Spôsob vkladania môžete definovať pomocou .
Dokončovanie vlastností
Ale týmto Dokončovanie tried ani zďaleka nekončí. Táto funkcia
dokáže aj dokončovať aj deklaráciu vlastností. Pre ukážku si do triedy
pridáme vlastnosť AnInteger
:
Pridaná vlastnosť
TExample = class(TObject)
public
constructor Create;
procedure DoSomething(i: integer);
destructor Destroy; override;
property AnInteger;
end;
Stlačíme Ctrl+Shift+C a Dokončovanie tried pridá metódu pre prístup k zápisu do vlastnosti a nejaký základný kód:
Doplnená obsluha vlastnosti
procedure TExample.SetAnInteger(const AValue: integer);
begin
|if FAnInteger=AValue thenexit;
FAnInteger:=AValue;
end;
A nie len to, Dokončovanie kódu pridalo deklaráciu čítania vlastnosti, a deklarácie súkromneho člena a metódy, ktoré slúžia na uchovávanie hodnoty a prístup k vlastnosti:
Doplnené súkromné členy
TExample = class(TObject)
private
FAnInteger: integer;
procedure SetAnInteger(const AValue: integer);
public
constructor Create;
procedure DoSomething(i: integer);
destructor Destroy; override;
property AnInteger: integerread FAnInteger write SetAnInteger;
end;
Vlastnosť bola rozšírená pridaním kľúčových slov Read
a Write
.
V triede je nová sekcia private
s premennou FAnInteger
a
metódou SetAnInteger
. Pridanie F na začiatok súkromného člena
triedy je bežnou notáciou Delphi, rovnako ako označenie prístupovej
metódy pomocou Set
. Ak nechcete používať túto notáciu, môžete to
zmeniť ponmocou .
Ďalšie možnosti doplňovania vlastností sú rovnako zaujímavé. Ak deklarujete vlastnosť takto:
property PropName: PropType read;
Dokončovanie triedy rozšíri deklaráciu na vlastnosť len na čítanie:
property PropName: PropType read FPropName;
Ak deklarujete vlastnosť takto:
property PropName: PropType write;
Dokončovanie triedy rozšíri deklaráciu na vlastnosť len na zápis:
property PropName: PropType write SetPropName;
Ak deklarujete vlastnosť s metódou read
:
property PropName: PropType read GetPropName;
Dokončovanie triedy nechá deklaráciu vlastnosti nezmenenú, ale
pridá deklaráciu funkcie GetPropName
:
function GetpropName: PropType;
Ak pri deklarácii vlastnosti použijete direktívu stored
:
property PropName: PropType stored;
Dokončovanie triedy túto deklaráciu rozšíri na:
property PropName: PropType read FPropName write SetPropName stored PropNameIsStored;
Pretože direktíva stored je používaná pre streamovanie čítania a
zápisu, sú do deklarácie pridané aj kľúčové slová read
a write
.
Dokončovanie procedúr
V pôvodnom názve Forward Procedure Completion, táto časť dokončovania
kódu dokončuje deklarácie procedúr pridaním tela chýbajúcich procedúr,
ktoré sú definované. Je vyvolané, ak je kurzor na pripravenej
definícii procedúry, pomocou klávesovej skratky Ctrl+Shift+C.
Tento nástroj nepracuje len s procedúrami definovanými v časti
interface
, ale aj s dopredne definovanými procedúrami, ktoré sú
definované pomocou kľúčového slova forward
.
Napríklad, pridajte novú procedúru do časti interface
:
procedure DoSomething;
Umiestníme kurzor na ňu a stlačíme Ctrl+Shift+C pre dokončovanie
kódu. V časti implementation
bude doplnené:
Doplnené telo procedúry
procedure DoSomething;
begin
|
end;
Telo novej procedúry je pridané pred metódy tried. Ak už sú v časti
interface
nejaké definície procedúr, IDE sa pokúsi zachovať ich
poradie, napríklad:
procedure Proc1;
procedure Proc2; // nová procedúra
procedure Proc3;
Ak telá Proc1
a Proc3
už existujú, potom bude telo Proc2
vložené medzi nich. Toto správanie môže byť zmené pomocou . Ak pri spustení dokončovanie
procedúr chýbajú telá viacerých procedúr:
procedure Proc1_Old; // telo existuje
procedure Proc2_New; // telo neexistuje
procedure Proc3_New; // "
procedure Proc4_New; // "
procedure Proc5_Old; // telo existuje
Dokončovanie kódu pridá všetky tri telá procedúr (Proc2_New
, Proc3_New
,
Proc4_New
).
Dokončovanie priradenia udalostí
V originále nazvané Event Assignment Completion . Dokončovanie
priradenia udalostí dokončuje jeden príkaz Udalosť :=
a pracuje
presne tak, ako pridávanie metód v Inšpektore objektov. Na
použitie dokončovania priradenia udalostí stačí umiestniť kurzor za
príkaz priradenia udalosti a stlačiť Ctrl+Shift+C. Napríklad v
metóde udalosti FormCreate
, pridajte riadok OnPaint :=
:
Písanie priradenia udalosti
procedure TForm1.Form1Create(Sender: TObject);
begin
OnPaint := |
end;
Potom stlačte Ctrl+Shift+C pre spustenie dokončovania kódu a príkaz priradenia udalosti bude doplnený takto:
OnPaint:=@Form1Paint;
Zároveň bude do triedy TForm1
pridaná nová metóda Form1Paint
.
Dôležité je aby ste kurzor umiestnili za operátor priradenia :=
.
Ak by ste ho umiestnili na identifikátor (tj. OnPaint
),
dokončovanie kódu spustí Dokončovanie lokálnych premenných, ale toto
dokončovanie zlyhá, pretože premenná OnPaint
už definovaná je.
Tip
Môžete definovať meno novej metódy aj sami, a to jej zadaním do priradenia, napríklad:
OnPaint := @ThePaintMethod;
Dokončovanie deklarácie premenných
V anglickom origináli sa tento nástroj volá Variable Declaration Completion. Dokončovanie deklarácie premenných pridáva definíciu lokálnej premennej, ktorá sa vyskytuje v príkaze priradenia. Dokončovanie deklarácie premenných spustíte, stlačením skratky Ctrl+Shift+C, keď je kurzor umiestnený na identifikátore v priradení. Predstavte si, že máte kód:
Pôvodný kód
type
TWhere = (Behind, Middle, InFront);
procedure TForm1.Form1Create(Sender: TObject);
var
a: array[TWhere]ofchar];
begin
for Where:=Low(a)toHigh(a)dowriteln(a[Where]);
end;
Umiestnite kurzor na identifikátor Where` v priradení začiatku
cyklu a stlačte skratku :kbd:`Ctrl+Shift+C` pre dokončenie kódu.
Výsledkom bude deklarácia premennej typu ``TWhere
:
Výsledok dokončovania
procedure TForm1.Form1Create(Sender: TObject);
var
a: array[TWhere]ofchar;
Where: TWhere;
begin
for Where:=Low(a)toHigh(a)dowriteln(a[Where]);
end;
Typ identifikátora je odhadovaný podľa pravej strany príkazu
priradenia. V tomto prípade je použitý typ podľa premennej a
.
Napríklad čísla sú identifikované ako Integer
.
Spätné dokončovanie triedy
Pôvodný názov tejto funkcie dokončovania kódu je Reversed Class Completion . Spätné dokončovanie triedy pridáva deklarácie súkromných metód pre aktuálne telo metódy. Je vyvolané, keď je kurzor v tele metódy, ktorá zatiaľ v triede deklarovaná nie je a je stlačená klávesová skratka Ctrl+Shift+C:
Nedeklarovaná metóda
procedure TForm1.DoSomething(Sender: TObject);
begin
|
end;
Metóda DoSomething
zatiaľ nie je v TForm1
deklarovaná, preto
stlačte Ctrl+Shift+C a medzi súkromné metódy triedy TForm1
bude
pridaná deklarácia metódy
Pridaná deklarácia
procedure DoSomething(Sender: TObject);
Na rozdiel od Delphi je táto funkcia dokončovania kódu vykonávaná vždy len jednym smerom, a to buď Z rozhrania triedy do jej implementácie alebo naopak z implementácie triedy do jej rozhrania. Delphi vždy vyvoláva oba smery, čo však už pri malom preklepe môže spôsobiť, že bude bez upozornenia vytvorená definícia novej metódy.
Komentáre a dokončovanie kódu
Pri použití funkcií dokončovania kódu sa IDE Lazarus pokúša zachovať komentáre tam, kde sú. Ak máte takýto kód:
Deklarácia s jednoriadkovým komentárom
FList: TList; // zoznam prvkov TComponent
FInt: integer;
Bude, pri vkladaní novej premennej medzi FList
a FInt
,
komentár ponechaný na riadku spolu s FList
. To platí i pre
viacriadkové komentáre:
Deklarácia s viacriadkovým komentárom
FList: TList; { zoznam prvkov TComponent
Toto je komentár na niekoľkých riadkoch, začínajúci
na riadku s FList, tak nástroj dokončenia kódu predpokladá,
že patrí k riadku s FList a nepreruší tento vzťah.
Kód bude vložený za komentár. }
FInt: integer;
Ak však komentár začína na ďalšom riadku:
Kombinácia jedno a viacriadkového komentára
FList: TList; // zoznam prvkov TComponent
{ Tento komentár patrí k nasledujúcemu riadku.
Nový kód je vložený pred tento komentár a
za komentár na riadku s FList. }
FInt: integer;
bude IDE predpokladať, že komentár patrí k nasledujúcemu riadku a novú premennú pridá pred viacriadkový komentár.
Refactoring
Otočenie priradenia
V originále Invert Assignments. Otočenie priradení pracuje s vybratými príkazmi Pascalu a obracia všetky priradenia z tohoto výberu. Tento nástroj je užitočný pre transformáciu „save“ kódu na „load“ a naopak.
Pôvodné priradenia
procedure DoSomething;
begin
AValueStudio := BValueStudio;
AValueAppartment := BValueAppartment;
AValueHouse := BValueHouse;
end;
Vyberte riadky s priradeniami (medzi begin
a end
) a vyvolajte
funkciu Otočenie priradenia, ktorá je dostupná cez kontextové menu
. Takto budú všetky priradenia
otočené a automaticky odsadené:
Výsledok otočenia
procedure DoSomething;
begin
BValueStudio := AValueStudio;
BValueAppartment := AValueAppartment;
BValueHouse := AValueHouse;
end;
Uzavrieť výber
Nástroj Uzavrieť výber môžete používať z kontextového menu
alebo ho nájdete v menu . Slúži na vloženie uzatvorených blokov kódu k už napísanému kódu. Na jeho použitie nejaký vyberte blok textu a vyvolajte nástroj. Zobrazí sa dialóg, v ktorom si môžete vybrať aký blok má byť vytvorený.
Napríklad v procedúre:
Pôvodný kód
procedure VytvoritObjekt();
var
lObjekt:TStringList;
begin
WriteLn;
end;
vyberte slovo writeln
, spusťte nástroj Uzavrieť výber a zvoľte,
povedzme, blok Try .. Except
. Procedúra bude doplnená takto:
Doplnený uzatvorený blok
procedure VytvoritObjekt();
var
lObjekt:TStringList;
begin
try
WriteLn;
except
|
end;
end;
Premenovať identifikátor

Niekedy v priebehu písania kódu zistíte, že ste pre premennú zvolili nesprávny identifikátor. Ak máte premennú použitú veľa krát, pravdepodobne sa s tým zmierite, lebo prepisovanie by bolo príliš pracné. Ale IDE ponúka pomoc aj v tomto prípade a premenuje všetky výskyty identifikátora, takže kedykoľvek v priebehu písania kódu môžete identifikátor jednoducho zmeniť tak, aby čo najlepšie vyhovoval vyšej potrebe.
Umiestnite kurzor na identifikátor a vyvolajte tento nástroj z kontextového menu
, objaví sa dialóg, v ktorom môžete nastaviť rozsah hľadania a nové meno identifikátora. Premenovanie je robené s týmito podmienkami:- premenované budú všetky výskyty indentifikátora, ktoré momentálne používajú túto deklaráciu, čiže deklarácie s rovnakým menom premenované nebudú,
- pred premenovaním je vykonaná kontrola mena, čiže nástroj neumožní vytvoriť duplicitný identifikátor,
- premenovanie indentifikátorov je robené v súbore zdrojového kódu, preto si úpravy najprv uložte; premenovanie v novom, ešte neuloženom, súbore skončí chybou,
- premenovanie pracuje len so zdrojovými kódmi Pascalu, nepremenúva súbory ani neupravuje súbory lfm/ lrs či lazdoc.
Nájdi odkazy na identifikátor
V prípade, že potebujete zistiť, kde všade je v kóde použitý identifikátor, stačí ak umiestnite kurzor na identifikátor a z kontextového menu
. Nástroj zobrazí dialógové okno, podobné tomu na premenovanie identifikátora, v ktorom si môžete zvoliť rozsah hľadania a potom zobrazí výsledky hľadania v okne hľadaní:
Oddeliť procedúru
Nástroj Oddeliť procedúru (Extract Procedure) pomáha pri tvorbe štruktúrovaného kódu tak, že umožňuje vystrihne vybratú časť kódu a vytvorí z nej novú procedúru alebo metódu.

Tento nástroj je užitočný na rozdelenie veľkých procedúr alebo na jednoduché vytvorenie novej procedúry z nejakého kódu. Ako príklad si zoberme jednoduchú procedúru s jedniným príkazom:
Základný príklad
procedure DoSomething;
begin
Writeln;
end;
Vyberte riadok s príkazom WriteLn;
a z kontextového menu vyberte
. Vyskočí dialógové
okno, v ktorom môžete zvoliť typ a meno novej procedúry, ktorá má byť
vytvorená. Zvoľte napríklad: Procedúra s menom NewProc a
nástroj vytvorí kód:
Nová procedúra
procedure NewProc;
begin
Writeln;
end;
procedure DoSomething;
begin
NewProc;
end;
V príklade vidno, že bola vytvorená nová procedúra s menom NewProc
a do jej tela bol vložený výber, ktorý bol v pôvodnej procedúre
nahradený volaním novej procedúry. Ak by ste zvolili podprocedúru,
bude vytvorená lokálna procedúra:
Nová podprocedúra
procedure DoSomething;
procedure NewProc;
begin
Writeln;
end;
begin
NewProc;
end;
Lokálne premenné a parametre:
Nástroj Oddeliť procedúru hľadá použité premenné a automaticky vytvára zoznam parametrov a lokálnych premenných, napríklad:
Ukážka s premennými
procedure DoSomething(var Erni, Bert: Integer);
var
i: Integer; // Komentár
begin
Erni:=Erni+Bert;
for i:=Erni to5dobegin
// nejaký kód
end;
end;
Vyberte celú slučku For a nechajte vytvoriť novú procedúru
NewProc
. Lokálna premenná i
je použitá len vo výbere, tak bude
presunutá do novej procedúry. Premenná Erni
je však použitá aj vo
zvyšku kódu, tak sa z nej stane parameter:
Presunutie premenej
procedure NewProc(const Erni: Integer);
var
i: Integer; // Komentár
begin
for i:=Erni to 5 do begin
// nejaký kód
end;
end;
procedure DoSomething(var Erni, Bert: Integer);
begin
Erni:=Erni+Bert;
NewProc(Erni);
end;
Všimnite si, že premenná i
je presunutá do procedúry NewProc
vrátane komentára.
Šablóny kódu a Publikovať projekt
Šablóny kódu
Šablóny kódu (Code Templates) je šikovný nástroj, ktorý môže pri písaní kódu ušetriť mnoho práce a času tým, že stačí do kódu napísať len prednastavený identifikátor šablóny, použiť klávesúvú skratku Ctrl+J a nástroj tento identifikátor nahradí kódom šablóny. Lazarus už s inštaláciou prichádza s množstvom pripravených šablón, ktoré sú prístupné v menu

Na obrázku si môžete všimnúť v hornej časti okna preddefinované šablóny. Každá začína nastavenou skratkou a pokračuje krátkym popisom šablóny. Každú šablónu si môžete upraviť, zmazať alebo si môžete pridať vlastnú. Obsah zvolenej šablóny je zobrazený v spodnom okne. Znak rúry (|) v tele šablóny udáva pozíciu kurzora, po použití šablóny teda miesto kde môžete hneď pokračovať v písaní.
Každej šablóne je možné priradiť makro a nastaviť možnosti automatického dokončovania.
Samozrejme, môže byť problém zapamätať si také množstvo šablón, preto ak ponecháte kurzor na prázdnom znaku (medzere, nie na identifikátore) a stlačíte skratku Ctrl+J, IDE Vám ponúkne zoznam dostupných šablón. Pomocou kurzorových kláves alebo napísania niekoľkých počiatočných znakov vyberte príslušný identifikátor a stlačením klávesy Enter vytvorte zvolenú šablónu. Stlačenie klávesy Esc zatvorí zoznam.
Použitie nástroja Šablóny kódu si môžte predstaviť na príklade, v
ktorom vytvoríte definíciu triedy. Na túto operáciu je pripravená
šablóna s identifikátorom classf
, preto na začiatok riadku napíšte
tento identifikátor, kurzor ponechajte vpravo za f a stlačte
Ctrl+J. Identifikátor classf
bude nahradený pripravenou
šablónou kódu:
Kód zo šablóny
T = class(T)
private
public
constructor Create;
destructor Destroy; override;
end;
a kurzor bude umiestnený za T, aby ste mohli priamo zadať meno triedy, ale už nemuseli písať dohodnuté T na začiatku mena.
Publikovať projekt

Nástroj (Publish Project) pomáha s publikovaním zdrojového kódu projektu je dostupný z menu
. Načo je takýto nástroj potrebný? Predstavte si situáciu, keď chcete niekomu (napríklad do svn) poslať len zdrojové kódy projektu a nastavenia prekladača pre svoj kód. Lenže bežný adresár projektu obsahuje množstvo informácií a súborov, z ktorých väčšinu publikovať netreba:- súbor .lpi obsahuje informácie o relácii (napr. pozíciu záložiek zatvorených jednotiek),
- súbory .ppu, .o, a .exe tiež nie sú potrebné k zdrojovému kódu,
- a podobne …
Práve príkaz Publikuj projekt vyexportuje adresár do nového umiestnenia, v ktorom vytvorí súbor .lpi len so základnými informáciami a prekopíruje zdrojové kódy, so všetkých podadresárov. V ponúknutom dialógu môžete nastaviť filter pre zahrnutie/vynechanie súborov, či pre kompresiu výstupu do jediného archívu.