Delphi (limbaj de programare)

Versiunea actuală a paginii nu a fost încă examinată de colaboratori experimentați și poate diferi semnificativ de versiunea revizuită la 8 ianuarie 2020; verificările necesită 103 editări .
Delphi
Clasa de limba imperativ , structurat , orientat pe obiecte , orientat pe componente , la nivel înalt
Aparut in 1986  ( 1986 )
Autor Anders Hejlsberg
Extensie de fișier .pas, .dpr, .dpk, .pp, .dproj, .dfm, .fmx, .bpl
Eliberare Delphi 11.1 Alexandria [1]  (15 martie 2022 ) ( 15.03.2022 )
Tip sistem static , puternic
Implementări majore Borland/Inprise/Codegear/Embarcadero Delphi ; Borland Kylix ; pascal liber
A fost influențat Obiect Pascal , C++
influențat C# , Java [1]
Site-ul web embarcadero.com/ru/produ…
Platformă x86, x64, ARM
OS Windows , macOS , iOS , Android , Linux

Delphi (Delphi, pronunțat /ˈdɘlˌfi:/ [2] ) este un limbaj de programare la nivel înalt , imperativ, structurat , orientat pe obiecte , cu tipărire statică puternică a variabilelor. Domeniul principal de utilizare este scrierea de aplicații software.

Acest limbaj de programare este un dialect al limbajului Object Pascal . Obiectul Pascal sa referit inițial la un limbaj ușor diferit care a fost dezvoltat la Apple în 1986 de grupul lui Larry Tesler [3] . Cu toate acestea, începând cu Delphi 7 [4] , lucrările lui Borland au început să folosească numele Delphi pentru a se referi la limbajul cunoscut anterior ca Object Pascal .

Platformă țintă

Inițial, mediul de dezvoltare Delphi a fost destinat exclusiv dezvoltării aplicațiilor Microsoft Windows , apoi a fost implementată o variantă pentru platformele Linux (marca Kylix ), cu toate acestea, după lansarea Kylix 3 în 2002, dezvoltarea sa a fost întreruptă și suportul pentru Microsoft . În curând a fost anunțat .NET , care, la rândul său, a fost întrerupt odată cu lansarea Delphi 2007.

În prezent, împreună cu suportul pentru dezvoltarea de programe pe 32 și 64 de biți pentru Windows, este posibil să se creeze aplicații pentru Apple macOS (începând cu Embarcadero Delphi XE2), iOS (inclusiv un simulator, începând cu XE4 folosind propriul compilator), Google Android (începând cu Delphi XE5) [5] , precum și Linux Server x64 (începând cu versiunea 10.2 Tokyo).

O implementare independentă, terță parte, a mediului de dezvoltare de către proiectul Lazarus ( Free Pascal , atunci când este compilat în modul de compatibilitate Delphi) îi permite să fie utilizat pentru a construi aplicații Delphi pentru platforme precum Linux , macOS și Windows CE .

Au existat, de asemenea, încercări de a folosi limbajul în proiecte GNU (de ex. Notepad GNU ) și de a scrie un compilator pentru GCC ( GNU Pascal ).

Folosit pentru a scrie servicii de internet IIS.

Filosofie și diferențe față de limbajele de programare aplicate populare

La crearea limbajului (și aici diferența calitativă față de limbajul C), sarcina nu a fost să asigure performanța maximă a codului executabil sau concizia codului sursă pentru a salva RAM. Inițial, limbajul s-a concentrat pe armonie și lizibilitate ridicată, deoarece era destinat să predea disciplina programarii. Această zveltețe inițială mai târziu, atât pe măsură ce hardware-ul a crescut, cât și ca urmare a apariției de noi paradigme, a făcut mai ușoară extinderea limbajului cu noi constructe.

Astfel, complexitatea obiectului C++, în comparație cu C, a crescut foarte semnificativ și a făcut dificilă studierea lui ca prim limbaj de programare, ceea ce nu se poate spune despre Object Pascal în comparație cu Pascal.

Următoarele sunt câteva dintre diferențele dintre constructele de sintaxă Delphi și familia de limbaje asemănătoare C (C/C++/Java/C#):

programul Project32 ; {$APPTYPE CONSOLE} {$R *.res} folosește System . Sysutils ; start try { TODO -oUser -cConsole Main: Insert code here } except on E : Exception do Writeln ( E . ClassName , ': ' , E . Message ) ; sfârşitul ; sfârşitul . În limbajele de programare asemănătoare C, o funcție globală sau o metodă statică cu un nume mainși o anumită listă de parametri este de obicei folosită ca intrare, iar o astfel de funcție poate fi localizată în oricare dintre fișierele sursă ale proiectului.
  • În Delphi, identificatorii pentru tipuri, variabile și cuvinte cheie sunt citiți fără a ține seama de majuscule și minuscule : de exemplu, un identificator SomeVareste complet echivalent cu somevar. Identificatorii sensibili la majuscule la începutul erei computerelor au accelerat procesul de compilare și au permis, de asemenea, utilizarea numelor foarte scurte, uneori diferind doar în cazul majusculelor.
Și deși până acum ambele practici - utilizarea mai multor identificatori care diferă numai în caz, precum și concizia lor excesivă, sunt condamnate și nu sunt recomandate pentru utilizare, aproape toate limbile derivă din C - C + +, Java, C # - sunt sensibile la majuscule , ceea ce, pe de o parte, necesită destul de multă grijă în declararea și utilizarea identificatorilor, iar pe de altă parte, vă obligă să scrieți un cod mai strict atunci când fiecare variabilă are un nume bine definit (variațiile de caz pot provoca confuzii și erori).
  • În Delphi, în fișierele sursă .pas (care, de regulă, conțin corpul principal al programului), la nivel de limbă este introdusă o împărțire strictă în secțiunea de interfață și secțiunea de implementare. Partea de interfață conține doar declarații de tip și metodă, în timp ce codul de implementare din partea de interfață nu este permis la nivel de compilare. O separare similară este, de asemenea, caracteristică limbajelor C/C++, unde, în cadrul paradigmei de cultură și programare, o separare este introdusă în antet și fișierele de implementare efective, dar o astfel de separare nu este furnizată la limbaj sau compilator. nivel.
În C# și Java, această separare este complet pierdută - implementarea unei metode, de regulă, urmează imediat după declararea acesteia. Încapsularea este asigurată numai prin apartenența metodei la unul sau altul. Instrumente speciale sunt folosite pentru a vizualiza doar partea interfață a modulului de cod sursă.
  • În Delphi, o metodă sau o funcție este clar definită de cuvintele cheie rezervate proceduresau function, în timp ce în limbajele asemănătoare C, distincția se face printr-un cuvânt cheie care specifică tipul valorii returnate:// Procedura Delphi DoSomething ( aParam : Integer ) ; //nu returnează o funcție de valoare Calculate ( aParam1 , aParam2 : Integer ) : Integer ; // returnează un rezultat întreg //C# void DoSomething ( int aParam ); // nu returnează o valoare { // cod } int Calculați ( int aParam1 , aParam2 ); // returnează un rezultat întreg { // cod }
Mai dificile în C#/C++ sunt construcții precum declararea tipului „pointer to method”://C++: declarație de tip pCalc, un pointer către o funcție membru care preia doi parametri întregi și returnează un rezultat întreg typedef int ( TSomeClass ::* pCalc )( int , int ); În exemplul de mai sus, declarația de tip diferă de declarația variabilă cu cuvântul cheie typedef, numele tipului, pCalc, este specificat în mijlocul expresiei, între paranteze.//C#: declarație de tip pCalc, un pointer către o funcție membru care ia doi parametri întregi și returnează un rezultat întreg delegat public int pCalc ( int aParam1 , int aParam2 ); În exemplul de mai sus, declarația de tip diferă de declarația variabilă cu un cuvânt cheie special delegate, numele tipului fiind specificat în mijlocul expresiei.//Delphi tip pCalc = function ( aParam1 , aParam2 : Integer ) : Integer al obiectului ; În exemplul de mai sus, declarația de tip diferă de declarația unei variabile cu un cuvânt cheie special type, utilizarea unui semn egal (în cazul unei variabile se utilizează două puncte), numele tipului vine imediat după cuvântul cheie.
  • În Delphi, începutul și sfârșitul unui bloc de program sunt marcate cu cuvintele cheie beginși end, în timp ce în limbajele de programare asemănătoare C sunt folosite acolade în acest scop: {}. Astfel, poate că Delphi realizează o mai bună lizibilitate a codului pentru persoanele cu deficiențe de vedere. Pe de altă parte, bretele pot fi mai intuitive din punct de vedere vizual, servind drept pictogramă .//C# if ( bVal ) { // cod format din mai multe instrucțiuni } if ( bVal2 ) /* cod format dintr-o instrucțiune */ ;
În exemplul de mai sus, acolade denotă o declarație compusă, adică un bloc de instrucțiuni. Deoarece o expresie fără acolade este permisă într-o comandă de ramură pentru o singură instrucțiune, parantezele sunt necesare pentru o expresie condiționată . În expresiile condiționale complexe, numărul de paranteze imbricate poate fi mare.//Delphi if bVal then begin // sfârşitul codului cu mai multe instrucţiuni ; dacă bVal2 atunci (* cod de instrucțiune unic *) ; În Delphi, expresia condiționată este întotdeauna separată de instrucțiunea următoare prin cuvântul cheie then, ceea ce elimină necesitatea de a include condiția între paranteze.
  • În limbajele asemănătoare C, pentru această separare, condiționalul buclei este inclus în paranteze:while ( condiție ) { // buclă cu „precondiție” // corp buclă }; do { // corpul altei bucle } while ( condiția2 ); // sfârșitul buclei cu o „postcondiție”, corpul este executat cel puțin o dată
În Delphi, buclele cu o precondiție și o postcondiție diferă mai mult: sfârșitul unei bucle cu o postcondiție este mai greu de confundat cu începutul unei bucle cu o precondiție. Dar uneori o astfel de distincție poate provoca confuzie (trebuie amintit că condiția de ieșireuntil este specificată în buclă ). condiția while do begin //condiția pentru continuarea buclei este adevărul expresiei care urmează cuvântului while, ca C/C# //loop body end ; repetare //începutul buclei cu postcondiție //corpul buclei până la nu condiția2 ; //adevărul expresiei care urmează cuvântului până este condiția pentru EXIT din buclă, spre deosebire de C/C#
  • În Delphi, operația de atribuire a unei valori unei variabile este notă cu două puncte cu semnul egal, :=, care este împrumutat din notația matematică. Un semn egal fără două puncte este un operator de test de egalitate care returnează o valoare booleană. În schimb, în ​​limbajele asemănătoare C, operatorul de atribuire este un singur semn egal, iar operatorul de test de egalitate este un semn dublu, ==. Datorită faptului că în aceste limbaje de programare atribuirea este doar o expresie care returnează valoarea variabilei din stânga, următoarele greșeli care nu sunt evidente pentru un începător nu sunt atât de rare:// C++ int iVal = 12 ; în timp ce ( iVal = 1 ) { // conform intenției programatorului, acest corp de buclă nu trebuie executat dacă iVal are o altă valoare decât una la intrare // totuși, ca urmare a unei înlocuiri eronate a semnului == cu un singur =, iVal va fi a atribuit valoarea 1, iar bucla va fi infinită }
În Delphi, o astfel de eroare este imposibilă, fie și doar pentru că atribuirea în această limbă este o operație care nu returnează o valoare.
  • În Delphi, programarea orientată pe obiecte și pe obiecte, deși încurajată, nu este singura posibilă. Deci, este permis (spre deosebire de C#) să declarați și să utilizați funcții și variabile globale sau statice.
Limbajul C# este forțat să fie obiect. Funcțiile globale, fără referire la o clasă, sunt interzise. Tipurile de valoare, cum ar fi structs struct, sunt moștenite de la tipul generic C#, chiar dacă ele însele nu pot fi moștenite (adică moștenirea struct nu este permisă în C#). Cu toate acestea, instanțele de clase C# sunt tipuri de referință implicite, la fel ca în Delphi. Deoarece apelurile de sistem în Windows (ca, într-adevăr, în sistemele POSIX, cum ar fi Linux, Mac OS) sunt formal non-obiect, interacțiunea codului C # cu acestea este dificilă chiar și fără a ține cont de paradigma diferită de gestionare a duratei de viață a variabilelor în memorie. . Delphi nu are astfel de restricții. În ciuda acestei paradigme centrate pe obiect, C# îi lipsește conceptul de constructor virtual, adică crearea unei instanțe a unei clase al cărei tip exact nu este cunoscut la momentul compilării, dar este cunoscută doar clasa de bază a acelei instanțe. Parțial, acest dezavantaj poate fi compensat prin utilizarea interfețelor sau reflectării, dar astfel de soluții nu sunt standard pentru limbaj.tip TAnimal = clasa abstract protejat FPersonalName : string ; constructor public Create ( const PersonalName : string ) ; virtual ; abstract ; funcția GetSpecieName : șir ; virtual ; abstract ; // returnează specia biologică a proprietății animalului Nume : șir citit FPersonalName ; sfârşitul ; TAnimalClass = clasa TAnimal ; _ // metaclasă care se poate referi la orice clasă care moștenește de la TAnimal ... funcția CreateAnAnimal ( const FactAnimalClass : TAnimalClass ; const Nume : șir ) : TAnimal ; începe Rezultatul := FactAnimalClass . Creați ( Nume ) ; // funcția nu știe ce fel de animal va fi creat, deși „porecla” este cunoscută. Implementarea concretă a vederii este ascunsă. sfârşitul ; În plus, spre deosebire de C# și C++, unde apelul la constructorul clasei de bază se face neapărat înainte de a intra în corpul constructorului de clasă moștenit, în Delphi acest apel se face în mod explicit. Astfel, poate fi amânat sau omis în întregime în scopuri speciale. Evident, spre deosebire de C#, este posibil să se controleze excepțiile în constructorii de bază.
  • Pentru implementarea cât mai flexibilă și eficientă a abordării orientate pe obiecte, Delphi a introdus două mecanisme de apel polimorfe: virtual clasic și dinamic : dacă în cazul unui apel virtual clasic adresele tuturor funcțiilor virtuale vor fi conținute în tabelul metodelor virtuale. a fiecărei clase, atunci în cazul unui apel dinamic un pointer către o metodă există doar în tabelul clasei în care a fost definit sau suprascris.
Astfel, pentru a apela dinamic din clasa D o metodă din clasa A redefinită în B, va fi necesară căutarea în tabelele de metode ale claselor D, A și B. Această optimizare are ca scop reducerea dimensiunii memoriei statice ocupate de tabelele de metode. Economiile pot fi semnificative pentru ierarhiile de clasă lungă cu un număr foarte mare de metode virtuale. În limbajele asemănătoare C, apelurile polimorfe dinamice nu sunt folosite.
  • Spre deosebire de C#, limbajul Delphi permite crearea (inițializarea) unei instanțe a unei clase care conține metode abstracte (fără implementare). Pentru a exclude posibilitatea de a crea o instanță a unei clase, nu este suficient să declarați metode abstracte în ea. Cuvântul cheie abstract trebuie utilizat în declarația clasei. Astfel, în prezent, clasele care au metode abstracte (spre deosebire de implementările timpurii Delphi) nu sunt considerate abstracte. Folosind mecanismul funcției virtuale, codul unei clase de bază care are metode abstracte determină în timpul execuției dacă o anumită metodă abstractă este suprascrisă în instanța reală a clasei și, în funcție de aceasta, fie apelează metoda suprascrisă, fie aruncă o excepție EAbstractError.
Delphi permite, de asemenea, ca orice metodă virtuală concretă a unei clase de bază să fie înlocuită de una abstractă într-o clasă descendentă:tip TMyBase = clasă ( TObject ) funcţie A : întreg ; virtual ; // metoda A are un corp implementat în secțiunea finală a implementării ; TMyDerived = clasă ( TMyBase ) funcţia A : întreg ; suprascrie ; abstract ; // metoda este suprascrisă ca abstractă, nu are corp, // și în același timp o suprascrie (ascunde) pe cea implementată în clasa de bază end ; Procedura Test ; var m : TMyBase ; începe m := TMyDerived . a crea ; // am creat o clasă cu o metodă abstractă m . A ; // apelul la A este polimorf și obținem un EAbstractError când încercăm să executăm metoda abstractă end ;
  • Spre deosebire de C++, limbajul C# are conceptul de proprietăți de clasă moștenit de la Delphi: pseudo-câmpuri, care, în unele cazuri, pot reflecta și, de asemenea, modifica starea unui obiect mai intuitiv, comparativ cu metodele.public class Date { //acest exemplu este preluat de la [http://msdn.microsoft.com/en-us/library/w86s7x04.aspx msdn] private int luna = 7 ; // magazin de suport public int Luna { get { return luna ; } set { if (( valoare > 0 ) && ( valoare < 13 )) { luna = valoare ; } } //set } //prop } //clasă
Un cod sursă similar în Delphi ar putea arăta astfel:tip TDate = clasă privată FMonth : Integer ; procedura protejata SetMonth ( const Value : Integer ) ; // implementare in sectiunea de implementare proprietate publica Luna : Integer read FMonth write SetMonth ; sfârşitul ; Înainte de a trece la o comparație a implementării limbajului a proprietăților, observăm că o comparație a acestor două exemple arată clar că limbajul C # provoacă, în primul rând, abuzul de bretele (ceea ce nu este atât de înfricoșător, având în vedere concizia lor. scris) și, în al doilea rând, specificatorii de acces obligatoriu la heap pentru fiecare membru al clasei; în Delphi (ca și în C++), odată ce un specificator este declarat, acesta se aplică tuturor membrilor următori. De asemenea, dacă în Delphi este posibil să legați o proprietate la o valoare de câmp, atunci în C# acestea sunt întotdeauna prevăzute cu metode accesorii folosind paranteze de comandă compuse (cu excepția proprietăților automate). Aceste metode, spre deosebire de Delphi, nu pot fi declarate virtuale și nici nu pot fi apelate direct. Un accesoriu în C# se referă întotdeauna la una și o singură proprietate, în timp ce în Delphi această afirmație nu este în general adevărată. Mai mult, aceeași metodă poate fi folosită pentru a implementa accesul la proprietăți semnificativ diferite:tip TRectunghi = clasa private FCoordonate : matrice [ 0 .. 3 ] din Longint ; function GetCoordinate ( Index : Integer ) : Longint ; procedura SetCoordinate ( Index : Integer ; Valoare : Longint ) ; proprietate publică Stânga : index Longint 0 citire GetCoordinate scrie SetCoordinate ; proprietate Top : Longint index 1 citește GetCoordinate scrie SetCoordinate ; Dreptul de proprietate : indexul Longint 2 citește GetCoordinate scrie SetCoordinate ; proprietate Bottom : Longint index 3 citește GetCoordinate scrie SetCoordinate ; proprietate Coordonate [ Index : Integer ] : Longint read GetCoordinate scrie SetCoordinate ; sfârşitul ; Atât Delphi, cât și C# permit utilizarea proprietăților indexate: în acest caz, sintaxa pentru accesarea unei astfel de proprietăți este similară cu accesarea unui element de matrice. Totuși, în timp ce în Delphi numărul de proprietăți indexate, precum și numărul de indexare, pot fi arbitrare, în C# indexerul se aplică doar unei proprietăți implicite speciale. De asemenea, în Delphi, nu numai că o proprietate implicită poate fi indexabilă, ci poate fi și supraîncărcată de un tip de indexator:TMyObject = funcție protejată de clasă getStr ( Nume : șir ) : șir ; virtual ; function getStrByIx ( Index : Integer ) : sir ; virtual ; funcția getBy2Indicies ( X , Y : Integer ) : șir ; virtual ; proprietate publică Valoare [ Nume : șir ] : șir citire getStr ; implicit ; proprietate Valoare [ Index : Integer ] : șir citit getStrByIx ; implicit ; proprietate Valoare [ X , Y : Integer ] : șir citit getBy2Indicies ; implicit ; //număr sfârşit ;
  • Limbajele Java și C# au fost concepute inițial pentru a scrie programe care rulează într-un mediu gestionat în care mediul gestionează durata de viață a obiectelor: deci gestionarea manuală a memoriei nu este permisă. Comoditatea și securitatea acestei abordări au un impact negativ asupra performanței.
Avantajele și dezavantajele colectării gunoiului

Platformele .NET și Java au simplificat foarte mult dezvoltarea programelor prin introducerea unui „colector de gunoi”, care permite programatorului să nu-și facă griji cu privire la eliberarea memoriei ocupate de obiectele care au ieșit din sfera de aplicare a codului programului care rulează. Acest lucru, pe de o parte, a redus semnificativ problema așa-numitelor „scurgeri de memorie” (atunci când datele care sunt deja inutile și inaccesibile din cauza pierderii adresei ocupă RAM), dar, pe de altă parte, a necesitat platformă pentru a implementa un algoritm complex și intensiv de „colectare a gunoiului” – care este implementat în mod tradițional pentru a găsi obiecte accesibile și a elibera restul. În practică, pentru a efectua o analiză exhaustivă a accesibilității obiectelor, colectorul de gunoi la un moment dat suspendă programul (toate firele sale), ceea ce duce la o pierdere pe termen scurt a capacității de răspuns. Frecvența și durata unor astfel de opriri depind direct de cantitatea de RAM disponibilă (atâta timp cât există memorie liberă, colectorul de gunoi încearcă să nu efectueze analize de blocare), precum și de numărul de obiecte implicate în program (astfel, este mai bine să ai câteva obiecte „mari” decât multe – mici).

Situația se înrăutățește pe măsură ce numărul de fire implicate în program crește, deoarece o analiză exhaustivă a accesibilității necesită o oprire completă. Astfel, beneficiul evident – ​​rezolvarea problemei „scurgerii de memorie” și, în general, gestionarea automată a duratei de viață a obiectelor – a dat naștere implicită a problemei de scalare și „eșecuri” de performanță. Această problemă este subtilă în programele simple, dar pe măsură ce complexitatea și dimensiunea bazei de cod crește, devine din ce în ce mai acută - adică în stadiul final de dezvoltare. Sistemele software complexe, de regulă, au cerințe de referință și de reacție în timp real.

Mai exact, atunci când colectorul de gunoi are de 5 ori mai multă memorie decât are nevoie, performanța sa este egală sau puțin mai bună decât gestionarea directă a memoriei. Cu toate acestea, performanța colectorului de gunoi se degradează rapid atunci când trebuie să lucreze cu șolduri mici. Cu 3 dimensiuni de memorie necesară, este în medie cu 17% mai lentă, iar cu 2 dimensiuni este cu 70% mai lentă. De asemenea, colectorul de gunoi este mai predispus la paginare dacă memoria este defragmentată. În astfel de condiții, toți colectorii de gunoi pe care i-am testat sunt cu un ordin de mărime mai lenți decât gestionarea directă a memoriei.Drew Crawford - De ce aplicațiile web mobile sunt lente

Încercările de reducere a suprasolicitarii colectării gunoiului pot duce la o distorsiune semnificativă a stilului de programare [6] [7] .

Nu există o gestionare automată a memoriei în Delphi: (în compilatoarele de limbaj clasice ) instanțele de clasă sunt create și șterse manual, în timp ce pentru unele tipuri - interfețe, șiruri și matrice dinamice, este folosit mecanismul de numărare a referințelor. Niciuna dintre aceste abordări, în general, nu garantează absența scurgerilor de memorie, dar, pe de altă parte, problema receptivității nu este relevantă, timpul de gestiune a memoriei este mic și, mai important, evident. De asemenea, în absența scurgerilor, cantitatea totală de RAM utilizată este semnificativ mai mică decât aplicațiile similare care se bazează pe colectorul de gunoi.

Istoria limbii

Obiectul Pascal este rezultatul dezvoltării limbajului Turbo Pascal , care, la rândul său, s-a dezvoltat din limbajul Pascal . Pascal a fost un limbaj complet procedural , Turbo Pascal, începând cu versiunea 5.5, a adăugat proprietăți orientate pe obiect la Pascal și identificarea dinamică a tipului de date la Object Pascal cu posibilitatea de a accesa metadatele clasei (adică de a descrie clasele și membrii acestora) în cod compilat, numit și introspecție  - această tehnologie a fost denumită RTTI . Deoarece toate clasele moștenesc funcțiile clasei de bază TObject, orice pointer către un obiect poate fi convertit în acesta, după care se pot folosi metoda ClassType și funcția TypeInfo, care vor oferi introspecție.

De asemenea, o proprietate distinctivă a Object Pascal din C++ este că obiectele sunt localizate implicit în memoria dinamică. Cu toate acestea, puteți suprascrie metodele virtuale NewInstance și FreeInstance ale clasei TObject. Astfel, absolut orice clasă poate îndeplini „dorința” „unde vreau – acolo voi minți”. În consecință, „multi-heaping” este organizat.

Obiectul Pascal (Delphi) este rezultatul unei extensii funcționale a Turbo Pascal [8] .

Delphi a avut un impact uriaș asupra conceptului de limbaj C# pentru platforma .NET . Multe dintre elementele și soluțiile sale conceptuale au fost încorporate în C#. Unul dintre motive este transferul lui Anders Hejlsberg , unul dintre principalii dezvoltatori ai Delphi, de la Borland Ltd. la Microsoft Corp.

  • Versiunea 8 este capabilă să genereze bytecode exclusiv pentru platforma .NET. Acesta este primul mediu axat pe dezvoltarea de aplicații multilingve (doar pentru platforma .NET);
  • Versiunile ulterioare (indicate prin anul de lansare, mai degrabă decât numerele de serie, așa cum a fost cazul anterior) pot crea atât aplicații Win32, cât și bytecode pentru platforma .NET.

Delphi pentru .NET  este un mediu de dezvoltare Delphi , precum și limbajul Delphi (Object Pascal), axat pe dezvoltarea de aplicații pentru .NET.

Prima versiune a unui mediu de dezvoltare Delphi cu drepturi depline pentru .NET a fost Delphi 8. A permis scrierea de aplicații numai pentru .NET. Delphi 2006 acceptă tehnologia MDA cu ECO (Enterprise Core Objects) versiunea 3.0.

În martie 2006, Borland a decis să oprească îmbunătățirea ulterioară a mediilor de dezvoltare integrate JBuilder , Delphi și C++ Builder din cauza nerentabilității acestei direcții. S-a planificat vânzarea sectorului IDE al companiei. Un grup de susținători de software liber a organizat o strângere de fonduri pentru a cumpăra drepturile asupra mediului de dezvoltare și compilator de la Borland [9] .

Totuși, în noiembrie același an, s-a luat decizia de a nu vinde afacerea IDE. Cu toate acestea, dezvoltarea produselor IDE va ​​fi acum gestionată de o nouă companie - CodeGear, care va fi complet controlată financiar de Borland.

În august 2006, Borland a lansat o versiune ușoară a RAD Studio numită Turbo: Turbo Delphi (pentru Win32 și .NET), Turbo C#, Turbo C++.

În martie 2008, a fost anunțat sfârșitul dezvoltării acestei linii de produse.

În martie 2007, CodeGear a mulțumit utilizatorilor cu o linie actualizată de Delphi 2007 pentru produse Win32 și lansarea unui produs complet nou Delphi 2007 pentru PHP.

În iunie 2007, CodeGear și-a prezentat planurile de viitor, adică a publicat așa-numita foaie de parcurs [10] .

Pe 25 august 2008, Embarcadero, noul proprietar al CodeGear, a publicat un comunicat de presă despre Delphi pentru Win32 2009 [11] . Versiunea a adus multe inovații limbajului, cum ar fi [12] :

  • În mod implicit, suport complet Unicode în toate părțile limbii, VCL și RTL; înlocuirea apelurilor către toate funcțiile API Windows cu omologi Unicode (adică MessageBox apelează MessageBoxW, nu MessageBoxA).
  • Tipuri generice , sunt și generice .
  • Metode anonime .
  • Nouă directivă de compilator $POINTERMATH [ON|OFF].
  • Funcția Exit poate accepta acum parametri în funcție de tipul funcției.

Lansat în 2011, Delphi XE2 a adăugat un compilator Win64 și o compilare încrucișată pentru sistemele de operare Apple (MacOS X, iOS).

Lansat în 2013, Delphi XE5 a oferit o compilare încrucișată a aplicațiilor pentru dispozitive ARM/Android.

Compilatoare

  • Embarcadero Delphi (fostul CodeGear Delphi și Borland Delphi) este probabil cel mai cunoscut compilator care este succesorul lui Borland Pascal și Turbo Pascal . Folosit de Win16 (Delphi 1), Win32 (Delphi 2 și versiuni ulterioare), Win64 (Delphi 16 (XE2) și versiuni ulterioare) și .NET 1.x, 2.0 (Delphi 8, Delphi 2005-Delphi 2007). Suportul .NET a fost ulterior transformat într-un produs separat cunoscut sub numele de Oxygen (incompatibil cu Delphi ) .
  • Free Pascal (FPC) este un compilator Object Pascal gratuit care acceptă diverse dialecte Pascal, inclusiv Turbo Pascal (cu unele avertismente), Delphi și dialecte native. În prezent, FPC poate genera cod pentru procesoarele x86 , x86-64 , PowerPC , SPARC și ARM , precum și pentru diferite sisteme de operare, inclusiv Microsoft Windows , Linux , FreeBSD , Mac OS . Există mai multe medii de dezvoltare software pentru FPC (unul dintre cei mai cunoscuți reprezentanți este Lazarus ).
  • GNU Pascal (o versiune dezvoltată separat de GCC ). Nu își propune să continue seria dialectelor Delphi ca parte a Pascal, dar conține totuși modul de compatibilitate Borland Pascal și este foarte lent în a se adapta componentelor limbajului Delphi. Nu este potrivit pentru compilarea proiectelor mari care conțin cod Delphi, dar majoritatea sistemelor de operare și arhitecturii îl acceptă.
  • Oxygene (cunoscut anterior ca Chrome ) este un compilator limitat de limbi compatibile cu Delphi care este integrat în Microsoft Visual Studio . Disponibil și ca compilator gratuit de linie de comandă CLI . Utilizează .NET și monoplatforme. Vândut anterior sub marca Embarcadero Delphi Prism.
  • MIDletPascal  este un limbaj de programare cu o sintaxă asemănătoare Delphi și un compilator cu același nume care convertește codul sursă în bytecode Java compact și rapid .
  • PocketStudio este un IDE  bazat pe Pascal pentru Palm OS .
  • Virtual Pascal  - compilator gratuit și IDE text pentru Win32, OS/2 și Linux. La acel moment, foarte rapid și foarte compatibil (construcțiile Delphi 5 sunt parțial acceptate). În exterior, este foarte asemănător cu mediul de text Borland Pascal 7, deși nu există nicio grafică compatibilă cu acesta, de exemplu. Cu toate acestea, dezvoltarea sa încheiat în 2004, iar codul sursă nu era deschis. De atunci, FPC a mers mult mai departe și este în general mai bun pentru programare. Cu toate acestea, VP rămâne o opțiune foarte bună pentru o înlocuire rapidă pentru versiunile și mai învechite de Borland Pascal pentru școală / institut, având în vedere munca nativă în Win32 fără probleme cu codificările rusești.

Sintaxa limbii

Sistemul de tipuri

Sistemul de tipuri din Delphi este strict , static .

O listă scurtă de tipuri acceptate

Sunt acceptate următoarele tipuri de date :

  • întreg, semnat și nesemnat: Byte, Shortint, Word, Smallint, Cardinal, Integer, UInt64, Int64
  • tipuri de enumerare definite de utilizator
  • tipuri reale Single, Double, Extended (doar x86-32, pe Win64 Extended = Double), de tip Real48 moștenit, lucrând în modul de emulare întreg. Tipul Currencyeste fix cu precizie reală.
  • linii. Tipul string este alocat automat în memorie, cu numărarea referințelor și paradigma Copy-On-Write. În versiunile ulterioare ale Delphi, caracterele sunt pe doi octeți, compatibile cu Unicode. AnsiString este o implementare similară pentru șiruri de caractere cu lățimea caracterelor de un octet. Astfel de șiruri conțin informații despre codificare în câmpul de servicii. Compilatoarele Windows din versiunile anterioare au un tip WideStringcare este pe deplin compatibil cu tipul BSTRdin Component Object Model . De asemenea, este permisă utilizarea șirurilor de caractere cu o lungime fixă ​​care nu depășește 255 de caractere pe un singur octet. Sunt permise tipuri de șiruri primitive, C: stil PCharșiPWideChar
  • matrice. Lungime fixă ​​unidimensională, multidimensională, precum și dinamică similară, cu numărare de referință.
  • mulţimi formate din elemente de tip enumerare. Dimensiunea maximă a unei astfel de enumerari este de 256 de elemente.
  • Intrări . Tip structural (valoare) fără suport de moștenire. Începând cu Delphi 2006, a fost adăugat suport pentru încapsulare, metode și proprietăți. Supraîncărcarea operatorului. Începând cu Delphi 10.3 Rio, a fost adăugată capacitatea de a crea constructori pentru scriere.
  • Clase și clase generice (generice). Un tip de referință implicit. Suport pentru încapsulare, moștenire, polimorfism, inclusiv constructori virtuali, atribute, parametri generici pentru o clasă și metode individuale și trimiterea metodei prin index. O clasă poate implementa una sau mai multe interfețe, inclusiv indirect prin delegarea implementării unei interfețe către o proprietate sau un câmp. Moștenirea multiplă nu este acceptată.
  • Indicatori către funcții și metode, precum și indicatori către funcții anonime.
  • Tipurile sunt metaclase care conțin un pointer către tipul unui obiect (dar nu și obiectul în sine). Introdus în principal pentru a implementa constructori virtuali și serializare automată.
  • interfețe. Compatibil cu COM (pe compilatorul Windows), moștenit de la același strămoș. Moștenirea multiplă nu este acceptată.
  • Dispinterfaces, pentru lucrul cu interfețele IDispatch în modul de legare târziu.
  • Tipuri de variante Variant șiOleVariant — tip cu tastare dinamică.
  • Obiecte vechi întreținute pentru compatibilitate cu Turbo Pascal. Spre deosebire de o instanță a unei clase, un obiect poate fi alocat pe stivă sau static. .

Operatori

Lista operatorilor separați printr-un spațiu::= + — * / div mod not and or with xor shl shr ^ = <> >= <= < > @ in is as

Lista scurtă de operatori
  • Aritmetică: + — * / div modadunarea, scăderea, înmulțirea, împărțirea (care dă un rezultat real), împărțirea întregului, extragerea restului.

Tipul de returnare distinge între operatorii de diviziune întregi ( divși mod) și operatorul /. Acesta din urmă, aplicat atât la operanzi întregi, cât și la operanzi reali, are ca rezultat întotdeauna un tip real. Operatorul de adăugare +este folosit și pentru concatenarea șirurilor (când sunt utilizate tipurile de șiruri încorporate).

  • Binar /logic: not and or xorinversare (negație), „ȘI”, „SAU”, „SAU” exclusiv. Tipul operației (binară sau logică) depinde de tipul primului operand.

Operatorii de biți de tipuri întregi includ și operatorii shl, shr - shift, corespunzând în sensul comenzilor cu același nume ale procesoarelor Intel x86.

  • Operatori ordinali (operatori de comparație) = <> > < >= <= — egalități, inegalități (corespunde operatorului !=în limbaje asemănătoare C), mai mare decât, mai mic decât, nu mai puțin, nu mai mult — se aplică tuturor tipurilor ordinale și reale și returnează o valoare de tipboolean
  • Operatorii de set includ + - * in adunarea, scăderea, intersecția setului și operatorul de testare a apariției, care sunt utilizați pentru a manipula tipul de set încorporat. Primele trei returnează tipul setului, ultimul returnează tipul boolean.
Un exemplu de utilizare a operatorului in tip TDayOfWeek = ( Luni , Marți , Miercuri , Joi , Vineri , Sâmbătă , Duminică ) ; //set enum type TDays = set de TDayOfWeek ; //Tipul setului este setat var day : TDayOfWeek ; zile : TDays ; isMyDay : Boolean ; zilele de început := [ duminică , marți , sâmbătă ] ; zi := luni ; isMyDay := zi în zile ; // operatorul in returnează o valoare booleană, luând ca prim operand o valoare de tip „set element”, iar ca al doilea operand o valoare de tip „set” end ;
  • Operatori de turnare de tip () as is - turnare necondiționată, turnare sigură a tipurilor de obiecte și interfețe și operator de testare a apartenenței tip (returnează o valoare booleană). Turnarea necondiționată (nesigură) este folosită într-un stil funcțional (identificatorul de tip este scris în stânga, expresia turnată la acesta este scrisă între paranteze în dreapta) și se aplică tipurilor ordinal, real, de structură, referință, șir. În același timp, pentru tipurile de referință (inclusiv implicit de referință) , nu există nicio distribuție reală, ci doar o nouă interpretare a acelorași date.

Operatorii asși isse aplică tipurilor care permit comportamentul polimorf - instanțe de clasă și interfețe. Primul are ca rezultat o conversie de tip sigur (în sensul imposibilității interpretării greșite), iar cel de-al doilea testează suportul de către o instanță a unei clase sau interfețe a unei clase sau interfețe. Amintiți-vă că, spre deosebire de C#, o distribuție nereușită de către un operator asaruncă o excepție.

  • Operatori de referință ^ @ - utilizați pentru a lucra cu pointeri.

Operatorul ^dereferențează indicatorul. Operatorul @face invers, returnând adresa variabilei. Operațiile simple de adunare și scădere sunt acceptate pe pointerii tipați, având în vedere dimensiunea tipurilor către care indică ( aritmetică inteligentă a indicatorului).

  • Operator de atribuire :=. În Delphi, operatorul de atribuire nu formează o expresie, ci o operație, deci nu este permisă „înșirarea” asignărilor.

Clasele

În Object Pascal, clasele sunt tipuri speciale de date folosite pentru a descrie obiecte. În consecință, un obiect care are tipul unei clase este o instanță a acestei clase sau o variabilă de acest tip.

O clasă este un tip special care are elemente precum câmpuri, proprietăți și metode. Câmpurile de clasă sunt similare câmpurilor de înregistrare și sunt folosite pentru a stoca informații despre un obiect. Metodele sunt proceduri și funcții care sunt de obicei utilizate pentru procesarea câmpurilor. Proprietățile sunt intermediare între câmpuri și metode.

Caracteristicile orientate pe obiecte ale limbajului

Încapsulare

Combinarea și ascunderea datelor obiectului, precum și a metodelor care le procesează, în interiorul unei clase concrete de la utilizator se numește încapsulare.

Moștenire

Atunci când se creează obiecte noi, capacitatea de a obține toate proprietățile și metodele de la strămoșii lor se numește moștenire. Astfel de obiecte moștenesc după crearea lor toate câmpurile, proprietățile, evenimentele, metodele etc. de la strămoșii lor. Moștenirea salvează adesea dezvoltatorii de munca de rutină și le permite să înceapă rapid să dezvolte ceva nou. Spre deosebire de C++, Delphi nu permite moștenirea multiplă. În Delphi, este posibil să se adauge metode la o clasă sau înregistrare folosind așa-numitul class helper sau record helper (clas helper sau record helper), care, nefiind un descendent al clasei sau înregistrării care se modifică, poate adăuga metode suplimentare. lor. Un exemplu este intrarea de ajutor TStringHelper declarată în modulul System.SysUtils.

Polimorfism

Delphi implementează modelul clasic de polimorfism adoptat în limbajele de programare aplicate , atunci când metodele clasei de bază, precum și variabilele de referință de tipul clasei de bază, sunt capabile să manipuleze instanțe ale claselor descendente pe baza contractului specificat în clasa de bază. Contractul în acest caz este declararea metodelor abstracte în clasa de bază.

Exemple

Structura programului

Fiecare program scris în limbajul Delphi constă dintr-un antet de program (program NewApplication;), un câmp de module utilizate Utilizări (de exemplu, Uses Windows, Messages, SysUtils etc.), care este posibil să nu fie incluse în structura în sine, ca precum și blocuri de descriere și execuții (începe cu un operator compus începe și se termină cu final.).

program Project1 ; // Antetul programului, cu numele „Proiect1” folosește Forms , Unit1 în 'Unit1.pas' {Form1} ; // module care sunt conectate la proiect și utilizate de program {$R *.res} începe aplicația . Inițializați ; // Inițializați aplicația Aplicație . CreateForm ( TForm1 , Form1 ) ; // Creați formular/fereastră Aplicație . alerga ; // Lansați și executați end .

Exemplul #1

Afișarea mesajului „Bună, lume!” în aplicația de consolă Delphi

programul Helloworld ; //numele programului {$APPTYPE CONSOLE} //directivă către compilator pentru a crea o aplicație de consolă începe writeln ( 'Bună, lume!' ) ; //mesaj de ieșire Salut, lume! readln ; //așteptați ca utilizatorul să apese o tastă finală . // sfârşitul programului

Exemplul #2

Afișarea mesajului „Bună, lume!” într-o aplicație GUI Delphi pe 32 de biți

... procedura TForm1 . Button1Click ( Expeditor : TObject ) ; //Managerul de evenimente OnClick generat automat începe ShowMessage ( 'Bună, lume!' ) ; //mesaj de ieșire Salut, lume! sfârşitul ; //sfârșitul procedurii ...

Exemplul #3

Crearea dinamică a unei liste de șiruri și scrierea acesteia într-un fișier.

// Handler pentru evenimentul care apare la crearea formularului procedura MainForm TMainForm . FormCreate ( Expeditor : TObject ) ; var // Declararea unei variabile de tip TStrings (lista de șiruri). Șiruri de caractere : TStrings ; begin // Crearea (alocarea memoriei și completarea acesteia cu valori inițiale) a unui obiect de tip TStringList. // TStringList este un descendent al TStrings care implementează metodele sale abstracte pentru a stoca șiruri de caractere în memorie. Șiruri := TStringList . a crea ; try // Adăugarea unui șir. Coarde . Adăugați ( „Linie de adăugat.” ) ; // Salvați toate liniile într-un fișier. Coarde . SaveToFile ( 'C:\Strings.txt' ) ; în final // Dealocați memoria obiectului și ștergeți referința acestuia pentru a preveni accesul neintenționat la memoria nealocată. FreeAndNil ( șiruri ) ; sfârşitul ; sfârşitul ;

Extensii de fișiere

  • .pas - codul sursă al modulului (pascal)
  • .dpr - codul sursă al proiectului (pascal)
  • .dproj - codul sursă al proiectului (xml)
  • .dproj.local - codul sursă al proiectului (xml)
  • .dfm - formează codul sursă
  • .dpk - codul sursă al proiectului pachetului
  • .bpl - pachet compilat
  • .dcu - modul compilat
  • .exe - aplicație compilată
  • .res - resurse
  • .dsk - link-uri la fișiere
  • .identcache - asocieri de fișiere stocate în cache

Software-ul Delphi remarcabil

Printre numeroasele produse software comune scrise în Delphi, se poate găsi [13] :

Critica

Critica limbii în stadiile incipiente ale dezvoltării

Istoria criticii lui Pascal datează din 1981 și lucrările lui Brian Kernighan [15] , ale cărui argumente au devenit în mare parte învechite pe măsură ce limbajul a evoluat.

Inovații pentru compilare pe platformele mobile

Unele modificări de limbaj implementate de Embarcadero (dezvoltatorul de limbă) în așa-numitele compilatoare Delphi NextGen au rupt intenționat compatibilitatea cu baza de cod sursă acumulată. Aceste modificări au fost primite negativ de o gamă largă de dezvoltatori Delphi cu experiență, deoarece, deși au adus limbajul mai aproape de paradigma limbajului .NET, au spart tradiția compatibilității cu versiuni inverse ridicate și au făcut mult mai dificilă portarea codului sursă existent la software. pentru platformele mobile. Următoarele modificări au provocat însăși paradigma dezvoltării multiplatformă, sursă unică, promovată de Embarcadero.

  • introducerea indexării în bază zero a șirurilor

De la Pascal, tipul de șir încorporat a fost istoric indexat cu o bază de unu: elementul „null” al șirului a returnat lungimea șirului. Pe măsură ce au fost introduse noi tipuri de șiruri („lung” și „unicode”), această ordine de indexare a fost menținută, oferind o portabilitate aproape perfectă a bazei de cod la versiuni actualizate ale limbii. Cu toate acestea, odată cu introducerea compilației nextgen, paradigma s-a schimbat: în compilatoarele noi, șirurile au început să fie indexate la bază zero, ca în familia limbajelor asemănătoare C (C ++, C #, Java), în timp ce în compilatoarele „clasice” pentru Windows și Mac OS, paradigma indexării unice a fost salvată.

  • introducerea unui mecanism non-alternativ de numărare a referințelor pentru instanțe de clasă

Din punct de vedere istoric, clasele și instanțele lor sunt tipuri de structuri cu referință implicită. Cu toate acestea, gestionarea duratei de viață a unei instanțe de clasă a fost inițial făcută manual - prin apelarea explicită a constructorului și a destructorului (sau a metodei Free()), iar această caracteristică este păstrată (din 2018) în versiunile clasice ale compilatoarelor. Numărarea referințelor a funcționat doar pentru clasele care implementează interfețe și, în plus, doar în cazul în care astfel de clase au fost manipulate prin variabile de tipul interfeței.

Înainte de versiunea 10.4, compilatoarele pentru platformele mobile au introdus numărarea referințelor pentru toate instanțele claselor, schimbând astfel fundamental paradigma managementului duratei de viață a obiectelor, deoarece managementul „manual” este practic (cu excepția unor tehnici foarte avansate) incompatibil cu noua paradigmă.

Începând cu versiunea 10.4, a fost introdus un mecanism unificat de gestionare a memoriei [16] , când implementarea clasică a managementului memoriei obiect este utilizată pentru mobil, desktop și server. Modelul modelului de management al memoriei ARC a rămas pentru gestionarea șirurilor și a referințelor tip interfață pe toate platformele.

Evoluția lentă a limbajului înseamnă

Mulți dezvoltatori văd conservatorismul lui Delphi ca pe o virtute care face codul extrem de portabil și, de asemenea, face limbajul mai ușor de înțeles pentru programatorii începători.

Cu toate acestea, în prezent, situația este astfel încât noile tehnologii, paradigme și chiar limbaje de programare apar (și câștigă popularitate) aproape în fiecare an. Dezvoltarea instrumentelor lingvistice nu implică întotdeauna respingerea compatibilității cu retrocompatibilitatea.

Un prim exemplu al acestei abordări este

o introducere întârziată în limbajul declarării variabilelor locale în interiorul unui bloc

Înainte de versiunea compilatorului 33.0 (Delphi 10.3 Rio), declararea unei variabile locale trebuia să preceadă prima instrucțiune a codului funcției, iar inițializarea variabilelor locale (stive) la site-ul declarației nu este permisă. Inferența tipului a fost, de asemenea, imposibilă.

Prin comparație, declararea unei variabile locale oriunde într-o funcție a fost acceptată nativ în C și a fost moștenită de aproape toate limbile care au aderat la stilul C-like - C++, C#, Java etc.

Introducerea acestei caracteristici de limbaj în Delphi a fost discutată mult timp, dar la acel moment nu a întâlnit înțelegerea dezvoltatorilor de limbaj.

În același timp, declararea variabilelor locale în interiorul unui bloc, cu excepția operațiunilor în buclă For, poate duce la complicarea lizibilității codului proiectelor mari.

Note

  1. ↑ Anunț de disponibilitate RAD Studio 11.1 Alexandria . Arhivat din original pe 20 aprilie 2022. Preluat la 12 aprilie 2022.
  2. ↑ pronunția „del-phi” domină în Marea Britanie: o variantă de pronunție caracteristică Regatului Unit  (engleză)  (link inaccesibil) . Dicţionar online Merriam-Webster . Merriam Webster. Consultat la 1 octombrie 2008. Arhivat din original pe 21 august 2011. , iar în SUA  - „del-fi”: o variantă a pronunției caracteristică Statelor Unite  (engleză)  (link inaccesibil) . Dicţionar online Merriam-Webster . Merriam Webster. Consultat la 1 octombrie 2008. Arhivat din original pe 21 august 2011.
  3. ↑ David T. Craig. Apple Lisa Computer: Istoria Apple și Pascal .
  4. ↑ Prezentare generală a limbii Delphi  (link în jos)
  5. ↑ executat direct pe procesorul ARM )
  6. ↑ Dmitry Ivanov - Povești despre optimizarea prematură pe YouTube , începând cu ora 35:40
  7. ↑ Roman Elizarov - Milioane de citate pe secundă în Java pur pe YouTube , începând cu ora 58:59
  8. ↑ Acest lucru este indicat de desemnările versiunii compilatorului. Deci, în Delphi 7, compilatorul are un număr de versiune de 15.0 (cea mai recentă versiune de Borland Pascal / Turbo Pascal a fost desemnată 7.0, în Delphi 1 compilatorul are versiunea 8.0, în Delphi 2 - 9.0 etc. Numărul de versiune 11.0 este compilatorul Pascal, care făcea parte din mediul C++ Builder ).
  9. ↑ Pagina implicită Parallels Plesk Panel Arhivată 5 decembrie 2006.
  10. ↑ Foaia de parcurs Delphi și C++Builder (link în jos) . Consultat la 18 iulie 2007. Arhivat din original la 10 octombrie 2007. 
  11. ↑ Instrumente pentru baze de date și software pentru dezvoltatori | Embarcadero Technologies (link indisponibil) . Data accesului: 25 august 2008. Arhivat din original la 29 august 2008. 
  12. ↑ Delphi din Embarcadero | Arhivat din original pe 10 iulie 2008. Software de dezvoltare a aplicațiilor RAD
  13. ↑ Aplicații de bună calitate construite cu Delphi - Programare Delphi Arhivat 30 iunie 2011 la Wayback Machine 
  14. ↑ Sistem electronic de coadă MAXIMA . mtg-biz.ru. Data accesului: 5 ianuarie 2017. Arhivat din original pe 6 ianuarie 2017.
  15. ↑ De ce Pascal nu este limbajul meu de programare preferat . Data accesului: 23 mai 2016. Arhivat din original la 28 aprilie 2009.
  16. ↑ Ce este nou în RAD Studio 10.4 Sydney - RAD Studio - Produse .features-tabs ul.nav.nav-tabs Ce este nou în RAD Studio 10.4 RAD Studio 10.4 oferă suport Windows nativ de înaltă performanță îmbunătățit semnificativ, productivitate crescută cu  fulgerător)  ? . Site-ul Embarcadero . Preluat la 15 septembrie 2020. Arhivat din original la 16 septembrie 2020.

Literatură

Link -uri

 Pascal
Dialectele
Compilatoare
Comercial
Gratuit
Neacceptat
IDE
Persoane
 Limbaje de programare