Просмотр кода страницы Delphi (язык программирования)

{{Значения|Delphi}}
{{о|языке программирования|интегрированной среде разработки|Delphi (среда разработки)|об2=1}}
{{Карточка языка программирования
| name = Delphi
| логотип =
| paradigm = [[Императивное программирование|императивный]], [[Структурное программирование|структурированный]], [[Объектно-ориентированное программирование|объектно-ориентированный]], [[Компонентно-ориентированное программирование|компонентно-ориентированный]], [[Высокоуровневый язык программирования|высокоуровневый]]
| typing = [[статическая типизация|статическая]], [[сильная типизация|сильная]]
| implementations = Borland/Inprise/Codegear/Embarcadero [[Delphi (среда разработки)|Delphi]]; Borland [[Kylix]]; [[FreePascal]]
| dialects =
| year =
| designer = [[Хейлсберг, Андерс|Андерс Хейлсберг]]
| latest_release_version = 13.0 Florence
| latest_release_date = {{start date and age|2025|09|10}}
| influenced_by = [[Object Pascal]], [[C++]]
| influenced = [[C Sharp|C#]], [[Java]][https://web.archive.org/web/20120627043929/http://java.sun.com/docs/white/delegates.html]
| operating_system = [[Microsoft Windows]]
| license =
| website = https://www.embarcadero.com/ru/products/delphi
| платформа = x86, x64, ARM
| операционная система = [[Windows]], [[Linux]], [[Android]], [[macOS]], [[iOS]]
| extension = .pas, .dpr, .dpk, .pp, .dproj, .dfm, .fmx, .bpl
}}
'''Delphi''' (Де́лфи, произносится {{IPA|/ˈdɘlˌfi:/}}<ref>В [[Великобритания|Великобритании]] доминирует произношение «дел-фи́»: {{cite web
 |url         = http://cougar.eb.com/sound/gg/ggdelp02.wav
 |title       = вариант произношения, характерный для Великобритании
 |work        = Merriam-Webster Online Dictionary
 |publisher   = Merriam-Webster
 |lang        = en
 |access-date  = 2008-10-01
 |archive-url  = https://www.webcitation.org/616XNHJAJ?url=http://cougar.eb.com/sound/gg/ggdelp02.wav
 |archive-date = 2011-08-21
 |url-status     = dead
}}, а в [[США]] — «де́л-фай»: {{cite web
 |url         = http://cougar.eb.com/sound/gg/ggdelp01.wav
 |title       = вариант произношения, характерный для США
 |work        = Merriam-Webster Online Dictionary
 |publisher   = Merriam-Webster
 |lang        = en
 |access-date  = 2008-10-01
 |archive-url  = https://www.webcitation.org/616XNiHf4?url=http://cougar.eb.com/sound/gg/ggdelp01.wav
 |archive-date = 2011-08-21
 |url-status     = dead
}}</ref>) — [[Императивное программирование|императивный,]] [[Структурное программирование|структурированный]], [[Объектно-ориентированное программирование|объектно-ориентированный]], [[Высокоуровневый язык программирования|высокоуровневый]] [[язык программирования]] со [[Сильная и слабая типизация|строгой]] [[Статическая типизация|статической типизацией]] переменных. Основная область использования — написание прикладного программного обеспечения.

Этот язык программирования является [[Диалект (программирование)|диалектом]] языка [[Object Pascal]]. Изначально язык Object Pascal относился к несколько другому языку, который был разработан в фирме [[Apple]] в 1986 году группой [[Ларри Теслер]]а<ref>{{cite web |url=https://archive.org/stream/Mac_History_Pascal_DTC/Mac_History_Pascal_DTC_djvu.txt|title=Apple Lisa Computer: History of Apple and Pascal|author=David T. Craig}}</ref>. Однако, начиная с Delphi 7<ref>[http://docs.codegear.com/docs/radstudio/radstudio2007/RS2007_helpupdates/HUpdate4/EN/html/devcommon/overview_xml.html Delphi Language Overview]{{Недоступная ссылка|date=2018-01|bot=InternetArchiveBot }}</ref>, в официальных документах компании [[Borland]] название Delphi стало использоваться для обозначения языка, ранее известного как [[Object Pascal]].

== Целевая платформа ==
Изначально среда разработки Delphi была предназначена исключительно для разработки приложений Microsoft [[Windows]], затем был реализован вариант для платформ [[Linux]] (под торговой маркой [[Kylix]]), однако после выпуска в 2002 году Kylix 3 его разработка была прекращена, и вскоре было объявлено о поддержке [[Microsoft .NET]], которая, в свою очередь, была прекращена с выходом Delphi 2007. 

В настоящее время, наряду с поддержкой разработки 32 и 64-разрядных программ для Windows, реализована возможность создавать приложения для [[Apple]] [[macOS]] (начиная с Embarcadero Delphi XE2), [[iOS]] (включая симулятор, начиная с XE4 посредством собственного компилятора), [[Google (компания)|Google]] [[Android]] (начиная с Delphi XE5)<ref>непосредственно исполняемые на [[ARM (архитектура)|ARM]]-процессоре)</ref>, а также [[Linux]] Server x64 (начиная с версии 10.2 Tokyo).

Независимая, сторонняя реализация среды разработки проектом [[Lazarus]] ([[Free Pascal]], в случае компиляции в режиме совместимости с Delphi) позволяет использовать его для создания приложений на Delphi для таких платформ, как [[Linux]], [[macOS]] и [[Windows CE]].

Также предпринимались попытки использования языка в проектах [[GNU]] (например, [[Notepad GNU]]) и написания компилятора для [[GCC]] ([[GNU Pascal]]).

Используется для написания интернет сервисов IIS.

== Философия и отличия от популярных прикладных языков программирования ==
При создании языка (и здесь качественное отличие от [[Си (язык программирования)|языка C]]) не ставилось задачи обеспечить максимальную производительность исполняемого кода или лаконичность исходного кода для экономии оперативной памяти. Изначально язык ставил во главу угла стройность и высокую читаемость, поскольку был предназначен для обучения дисциплине программирования. Эта изначальная стройность в дальнейшем, как по мере роста аппаратных мощностей, так и в результате появления новых парадигм, упростила расширение языка новыми конструкциями.

Так, сложность объектного [[C++]], по сравнению с Си, выросла весьма существенно и затруднила его изучение в качестве первого языка программирования, чего нельзя сказать об [[Object Pascal]] относительно [[Паскаль (язык программирования)|Pascal]].

Ниже перечислены некоторые отличия синтаксических конструкций Delphi от семейства C-подобных языков (C/C++/[[Java]]/[[C Sharp|C#]]):
* В Delphi формальное начало любой программы чётко отличается от других участков кода и должно располагаться в определённом, единственном в рамках проекта, исходном файле с расширением <code>dpr</code> (тогда как другие файлы исходных текстов программы имеют расширение pas).
<source lang="delphi" line="1">program Project32;

{$APPTYPE CONSOLE}

{$R *.res}

uses
  System.SysUtils;

begin
  try
    { TODO -oUser -cConsole Main: Insert code here }
  except
    on E: Exception do
      Writeln(E.ClassName, ': ', E.Message);
  end;
end.</source>
: В С-подобных языках программирования в качестве входа обычно используется глобальная функция или статический метод с именем <code>main</code> и определённым списком параметров, причём такая функция может быть расположена в любом из файлов исходного текста проекта.
* В Delphi идентификаторы типов, переменных, а равно и ключевые слова читаются ''независимо'' от регистра: например, идентификатор <code>SomeVar</code> полностью эквивалентен <code>somevar</code>. Регистро-зависимые идентификаторы в начале компьютерной эпохи ускоряли процесс компиляции, и кроме того, позволяли использовать очень короткие имена, порой отличающиеся лишь регистром. И хотя к настоящему времени обе эти практики — использование нескольких идентификаторов, различающихся лишь регистром, равно как и чрезмерная их лаконичность, — осуждены и не рекомендованы к применению, практически все унаследованные от [[Си (язык программирования)|С]] языки ([[C++]], [[Java]], [[C Sharp|C#]]) являются ''регистро-зависимыми'', что, с одной стороны, требует достаточно большой внимательности к объявлению и использованию идентификаторов, а с другой — принуждает писать более строгий код, когда каждая переменная имеет чётко определённое имя (вариации регистра могут вызвать путаницу и ошибки).

* В Delphi в исходных файлах <code>.pas</code> (которые, как правило, и содержат основное тело программы) на уровне языковых средств введено строгое разделение на [[Интерфейс (объектно-ориентированное программирование)|интерфейсный]] раздел и раздел реализации. В интерфейсной части содержатся лишь объявления типов и методов, тогда как код реализации в интерфейсной части не допускается на уровне компиляции. Подобное разделение свойственно также языкам C, C++ или [[Rust (язык программирования)|Rust]], где в рамках культуры и парадигмы программирования вводится разделение на заголовочные и собственно файлы реализации, но подобное разделение не обеспечивается на уровне языка или компилятора. В C# же или Java такое разделение утрачено вовсе — реализация метода, как правило, следует сразу же после его объявления. Инкапсуляция обеспечивается лишь принадлежностью метода к той или иной области видимости. Для просмотра одной только интерфейсной части модуля исходного кода используются специальные средства.

* В Delphi метод или функция чётко определяются зарезервированными для этого ключевыми словами <code>procedure</code> или <code>function</code>, тогда как в C-подобных языках различие обуславливается типом возвращаемого значения: <source lang="delphi" line="1">
//Delphi
procedure DoSomething (aParam: Integer); //не возвращает значения
function Calculate (aParam1, aParam2: Integer): Integer; //возвращает целочисленный результат
</source><source lang="csharp" line="1">
//C#
void DoSomething(int aParam); // не возвращает значения
{
// code
}
int Calculate(int aParam1, aParam2); // возвращает целочисленный результат
{
// code
}
</source>
: Тем сложнее в C, C++ и С# выглядят такие конструкции, как объявление типа «[[Указатель (тип данных)|указатель]] на метод»: <source lang="cpp" line="1">
//C++: объявление типа pCalc, указателя на функцию-член, принимающую два целочисленных параметра и возвращающую целочисленный результат
typedef int (TSomeClass::*pCalc)(int, int);
</source>
: В вышеуказанном примере объявление типа отличается от объявления переменной ключевым словом <code>typedef</code>. Имя типа, <code>pCalc</code>, указывается в середине выражения, в скобках. <source lang="csharp" line="1">
//C#: объявление типа pCalc, указателя на функцию-член, принимающую два целочисленных параметра и возвращающую целочисленный результат
public delegate int pCalc(int aParam1, int aParam2);
</source>
: В вышеуказанном примере объявление типа отличается от объявления переменной специальным ключевым словом <code>delegate</code>, имя типа указывается в середине выражения. <source lang="delphi" line="1">
//Delphi
type pCalc = function(aParam1, aParam2: Integer): Integer of object;
</source>
: В вышеуказанном примере объявление типа отличается от объявления переменной специальным ключевым словом <code>type</code>, применением знака равенства (в случае переменной используется двоеточие), имя типа идёт сразу после ключевого слова.

* В Delphi начало и конец [[Область видимости|программного блока]] выделяются ключевыми словами <code>begin</code> и <code>end</code>, тогда как в C-подобных языках программирования для этих целей используются фигурные скобки. Таким образом, возможно, в Delphi достигается лучшая читаемость кода для лиц с ослабленным зрением. С другой стороны, фигурные скобки могут быть более интуитивными при визуальном восприятии, выполняя функцию [[Пиктограмма|пиктограммы]]. <source lang="csharp" line="1">
//C#
if (bVal) {
//код, состоящий из нескольких инструкций
}
if (bVal2) /* код, состоящий из одной инструкции */;
</source>
: В вышеуказанном примере фигурные скобки обозначают составную инструкцию, то есть блок инструкций. Поскольку в команде [[Оператор ветвления|ветвления]] для одной инструкции допускается выражение без ''фигурных'' скобок, то для условного выражения ''круглые'' скобки ''обязательны''. В сложных условных выражениях количество вложенных скобочных конструкций может быть велико. <source lang="delphi" line="1">
//Delphi
if bVal then begin
// код, состоящий из нескольких инструкций
end;
if bVal2 then (* код, состоящий из одной инструкции *);
</source>
: В Delphi условное выражение всегда отделяется от следующей инструкции ключевым словом <code>then</code>, что избавляет от необходимости заключать условие в круглые скобки.
* В C-подобных языках в целях подобного отделения условное выражение [[Цикл (программирование)|цикла]] заключается в круглые скобки: <source lang="csharp" line="1">
while (condition) { // цикл с "предусловием"
// тело цикла
};
do {
// тело другого цикла
} while (condition2); // конец цикла с "постусловием", тело выполняется хотя бы однажды
</source>
: В Delphi циклы с [[Цикл (программирование)#Цикл с предусловием|предусловием]] и [[Цикл (программирование)#Цикл с постусловием|постусловием]] различаются сильнее: ''конец'' цикла с постусловием труднее принять за ''начало'' цикла с предусловием. Но порой такое различие может вызвать путаницу (необходимо помнить, что в цикле <code>until</code> указывается условие ''выхода''). <source lang="delphi" line="1">
while condition do begin//условием продолжения цикла является истинность выражения, следующего за словом while, как C/C#
//тело цикла
end;
repeat//начало цикла с постусловием
//тело цикла
until not condition2;//истинность выражения, следующего за словом until - это условие ВЫХОДА из цикла, в отличие от C/C#
</source>
* В Delphi операция присвоения значения переменной обозначается при помощи двоеточия со знаком равенства, <code>:=</code>, что является заимствованием из математической нотации. Знак равенства без двоеточия — это оператор проверки равенства, возвращающий [[Логическое выражение|булево значение]]. Напротив, в C-подобных языках оператором присваивания является одинарный знак равенства, а оператором проверки равенства — двойной, <code>==</code>. В силу того, что в этих языках программирования присваивание является лишь выражением, возвращающим значение переменной слева, не так уж редки следующие неочевидные для новичка ошибки: <source lang="c++" line="1">
// C++
int iVal = 12;
while (iVal = 1) {
// по замыслу программиста, данное тело цикла не должно выполняться, если на входе iVal имеет значение, отличное от единицы
// однако, в результате ошибочной замены знака == на одиночный =, iVal будет присвоено значение 1, а цикл окажется бесконечным
}
</source>
: В Delphi подобная ошибка невозможна хотя бы уже потому, что присваивание в этом языке — операция, не возвращающая значения.
* В Delphi [[объектно-ориентированное программирование]] хоть и поощряется, однако не является единственно возможным. Так, допустимо (в отличие от [[C Sharp|C#]]) объявление и использование глобальных или статических функций и переменных.
: Язык C# принудительно объектен, а глобальные, без привязки к классу, функции запрещены. Типы, передающиеся в функции по значению, наподобие структур <code>struct</code>, унаследованы от общего типа C#, несмотря на то, что сами по себе они не могут быть унаследованы (то есть, наследование структур в C# запрещено). Вместе с тем, экземпляры классов C# являются неявно-ссылочными типами, как и в Delphi.

: Поскольку системные вызовы в [[Windows]] (как, впрочем, и в [[POSIX|POSIX-системах]] наподобие [[Linux]], [[MacOS|Mac OS]]) формально необъектны, взаимодействие C#-кода с ними затруднено даже без учёта разной парадигмы управления временем жизни переменных в памяти. Delphi не имеет подобных ограничений. Несмотря на такую акцентированную на объектность парадигму, в C# отсутствует понятие [[Виртуальный метод|виртуального конструктора]], то есть создания экземпляра класса, точный тип которого на этапе компиляции неизвестен, а известен лишь базовый класс этого экземпляра. Отчасти, этот недостаток может быть скомпенсирован посредством [[Интерфейс (объектно-ориентированное программирование)|интерфейсов]] или [[Рефлексия (программирование)|рефлексией]], однако подобные решения не являются стандартными для языка.<source lang="delphi" line="1">
type
  TAnimal = class abstract
  protected
    FPersonalName: string;
  public
    constructor Create(const PersonalName: string); virtual; abstract;
    function GetSpecieName: string; virtual; abstract; // возвращает биологический вид животного
    property Name: string read FPersonalName;
  end;

  TAnimalClass = class of TAnimal; // метакласс, могущий ссылаться на любой класс, унаследованный от TAnimal

  ...

function CreateAnAnimal(const FactAnimalClass: TAnimalClass; const Name: string): TAnimal;
begin
  Result := FactAnimalClass.Create(Name); // функция не знает, животное какого именно вида будет создано, хотя "кличка" известна. Конкретная реализация вида скрыта.
end;
</source>
: Кроме того, в отличие от C# и [[C++]], где вызов конструктора базового класса непременно осуществляется ещё до входа в тело конструктора унаследованного класса, в Delphi этот вызов делается явно. Таким образом, его можно отложить или вовсе опустить в специальных целях. Очевидно, в отличие от C#, возможен контроль над [[Обработка исключений|исключениями]] в базовых конструкторах.
* Для наиболее гибкой и эффективной реализации объектно-ориентированного подхода в Delphi введены два механизма [[Полиморфизм (информатика)|полиморфного]] вызова: классический виртуальный, а также ''динамический''. Если в случае классического виртуального вызова адреса всех [[Виртуальный метод|виртуальных функций]] будут содержаться в [[Таблица виртуальных методов|таблице виртуальных методов]] каждого класса, то в случае с динамическим вызовом указатель на метод существует лишь в таблице того класса, в котором он был задан или перекрыт. Таким образом, для динамического вызова из класса D метода класса A, переопределённого в B, потребуется выполнить поиск в таблицах методов классов D, A и B. Подобная оптимизация имеет своей целью уменьшение размера статической памяти, занимаемой под таблицы методов. Экономия может быть существенна для длинных иерархий классов с очень большим количеством виртуальных методов. В C-подобных языках динамические полиморфные вызовы не применяются.

* В отличие от C#, язык Delphi допускает создание (инициализацию) экземпляра класса, содержащего [[Абстрактный метод|абстрактные]] (не имеющие реализации) методы. Чтобы исключить возможность создания экземпляра класса, не достаточно объявить в нём абстрактные методы. Необходимо использовать в описании класса ключевое слово <code>abstract</code>. Таким образом, в настоящее время классы, имеющие абстрактные методы (в отличие от ранних реализаций Delphi), не считаются абстрактными. При помощи механизма виртуальных функций код базового класса, имеющего абстрактные методы, определяет на этапе выполнения, перекрыт ли в фактическом экземпляре класса конкретный абстрактный метод, и в зависимости от этого или вызывает перекрытый метод, или создаёт исключение <code>EAbstractError</code>. Также Delphi допускает перекрытие любого ''конкретного'' виртуального метода базового класса ''абстрактным'' в классе-потомке:

: <source lang="delphi" line="1">
type
TMyBase = class(TObject)
  function A: integer; virtual; // метод A имеет реализованное тело в разделе implementation
end;

TMyDerived = class(TMyBase)
  function A: integer; override; abstract; // метод перекрыт как абстрактный, тела не имеет,
// и при этом перекрывает (скрывает) реализованный в базовом классе
end;

procedure Test;
var m: TMyBase;
begin
  m := TMyDerived.Create; // мы создали класс с абстрактным методом
  m.A; // вызов A полиморфный, и мы получаем исключение типа EAbstractError, пытаясь выполнить абстрактный метод
end;
</source>
* В отличие от [[C++]], язык C# обладает унаследованной от Delphi концепцией свойств класса — псевдополей, которые в ряде случаев могут более интуитивно, по сравнению с методами, отражать, а также изменять состояние объекта. <source lang="csharp" line="1">
public class Date{//данный пример взят с [http://msdn.microsoft.com/en-us/library/w86s7x04.aspx msdn]
    private int month = 7;  // Backing store

    public int Month{
        get{ return month; }
        set{
            if ((value > 0) && (value < 13)) {
                month = value;
            }
        }//set
    }//prop
}//class
</source>

: Аналогичный исходный текст на языке Delphi может выглядеть следующим образом: <source lang="delphi" line="1">
type
  TDate = class
  private
    FMonth : Integer;
  protected
    procedure SetMonth(const Value: Integer); // реализация в разделе implementation
  public
    property Month: Integer read FMonth write SetMonth;
  end;
</source>
: Если в Delphi возможна привязка свойства к значению поля, то в C# они всегда снабжаются методами доступа с использованием скобок составной команды (кроме автоматических свойств). Методы эти, в отличие от Delphi, не могут быть объявлены виртуальными, равно как не могут быть вызваны непосредственно. Метод доступа в C# всегда относится к одному, и только к одному свойству, тогда как для Delphi это утверждение, вообще говоря, неверно. Более того, один и тот же метод может быть использован для реализации доступа к существенно различным свойствам:<source lang="delphi" line="1">
type
  TRectangle = class
  private
    FCoordinates: array[0..3] of Longint;
    function GetCoordinate(Index: Integer): Longint;
    procedure SetCoordinate(Index: Integer; Value: Longint);
  public
    property Left: Longint index 0 read GetCoordinate write SetCoordinate;
    property Top: Longint index 1 read GetCoordinate write SetCoordinate;
    property Right: Longint index 2 read GetCoordinate write SetCoordinate;
    property Bottom: Longint index 3 read GetCoordinate write SetCoordinate;

    property Coordinates[Index: Integer]: Longint read GetCoordinate write SetCoordinate;
  end;
</source>

: Как Delphi, так и C# допускают использование индексируемых свойств (индексаторов), в этом случае синтаксис доступа к такому свойству аналогичен доступу к элементу массива. Однако, если в Delphi число индексируемых свойств, равно как и число индексаторов, может быть произвольным, в C# индексатор применим лишь к специальному свойству по умолчанию. Кроме того, в Delphi свойство по умолчанию не только может быть индексируемым, также оно может быть перегружено по типу индексатора: <source lang="delphi" line="1">
TMyObject = class
protected
  function getStr(Name: string): string; virtual;
  function getStrByIx(Index: Integer): string; virtual;
  function getBy2Indicies(X, Y: Integer): string; virtual;
public
  property Value[Name: string]: string  read getStr; default;
  property Value[Index: Integer]: string read getStrByIx; default;
  property Value[X, Y: Integer]: string read getBy2Indicies; default; //количество
end;
</source>
* Языки [[Java]] и C# были изначально спроектированы для создания программ, работающих в управляемой среде, где управлением временем жизни объектов занимается эта среда, поэтому ручное управление памятью не допускается. Удобство и безопасность этого подхода отрицательно влияют на производительность.
{{Начало скрытого блока|Заголовок =Преимущества и недостатки сборки мусора|Выравнивание_заголовка=left|Фон_заголовка=Azure}}
Платформы .NET и Java значительно упростили разработку программ за счёт введения «сборщика мусора», который разрешает программисту не заботиться о высвобождении памяти, занимаемой объектами, которые вышли из области видимости работающего кода программы. Это, с ''одной'' стороны, значительно уменьшило проблему так называемых «утечек памяти» (когда уже ненужные, — и недостижимые по причине утраты адреса данные занимают оперативную память), но, с ''другой'' стороны, потребовало от платформы реализовать сложный и ресурсоёмкий алгоритм «сборки мусора» — который традиционно реализован как нахождение достижимых объектов и высвобождение остальных. На практике, чтобы выполнить ''исчерпывающий'' анализ достижимости объектов, сборщик мусора в некоторые моменты времени приостанавливает работу программы (всех её потоков), что приводит к кратковременной потере отзывчивости. Частота и длительность таких остановок напрямую зависит от объёма доступной оперативной памяти (пока есть свободная память, сборщик мусора старается не проводить блокирующий анализ), а также от числа задействованных в программе объектов (таким образом, лучше иметь несколько «больших» объектов, чем много — маленьких).

Ситуация ухудшается по мере роста количества задействованных в программе потоков — ведь исчерпывающий анализ достижимости требует полного останова. Таким образом, явная выгода — решение проблемы «утечек памяти» и, в целом, автоматическое управление временем жизни объектов — породила ''неявную'' проблему масштабирования и «провалов» производительности. Эта проблема малозаметна в простых программах, но по мере роста сложности и объёма кодовой базы становится всё более острой — то есть на финальном этапе разработки. Сложные программные комплексы, как правило, имеют привязку к реальному времени, так и требования к отзывчивости.
{{цитата|автор=[https://habrahabr.ru/post/188580 Drew Crawford — Почему веб-приложения на мобильных платформах работают медленно ]|Точнее, когда у сборщика мусора есть в 5 раз больше памяти, чем требуется, его производительность совпадает или слегка превосходит прямое управление памятью. Однако, производительность сборщика мусора быстро деградирует, когда ему требуется работать с небольшими хипами. С 3<!-- -мя --> размерами требуемой памяти он, в среднем, работает на 17 % медленнее, а с двумя размерами — на 70 % медленнее. Также сборщик мусора более подвержен пейджингу, если память дефрагментирована. В подобных условиях, все протестированные нами сборщики мусора работают на порядок медленнее прямого управления памятью.}}
{{Конец скрытого блока}}

Попытки снизить издержки сборки мусора могут привести к существенному искажению стиля программирования<ref>{{YouTube|mB4TKsIz5Sk|Дмитрий Иванов — Сказки о преждевременной оптимизации|start=2140}}</ref><ref>{{YouTube|Q-7y1u9kZV0|Роман Елизаров — Миллионы котировок в секунду на чистой Java|start=3539}}</ref>. В Delphi не существует автоматического управления памятью: (в ''классических'' компиляторах языка) экземпляры классов создаются и удаляются вручную, тогда как для некоторых типов — интерфейсов, строк и динамических массивов — задействован механизм подсчёта ссылок. Ни один из этих подходов, вообще говоря, не гарантирует отсутствия [[Утечка памяти|утечек памяти]], но, с другой стороны, проблема отзывчивости неактуальна, временные издержки управления памяти малы, и, что важнее, очевидны. Также, при отсутствии утечек общий объём задействованной оперативной памяти существенно меньше, чем у аналогичных приложений, полагающихся на сборщик мусора.

== История языка ==
Object Pascal — результат развития языка [[Турбо Паскаль]], который, в свою очередь, развился из языка [[Паскаль (язык программирования)|Паскаль]]. Паскаль был полностью [[процедурный язык программирования|процедурным языком]], Турбо Паскаль, начиная с версии 5.5, добавил в Паскаль объектно-ориентированные свойства, а в Object Pascal — динамическую идентификацию типа данных с возможностью доступа к метаданным классов (то есть к описанию классов и их членов) в компилируемом коде, также называемую [[Интроспекция (программирование)|интроспекцией]] — данная технология получила обозначение [[RTTI]]. Так как все классы наследуют функции базового класса TObject, то любой указатель на объект можно преобразовать к нему, после чего воспользоваться методом ClassType и функцией TypeInfo, которые и обеспечат интроспекцию.

Также отличительным свойством Object Pascal от C++ является то, что объекты по умолчанию располагаются в динамической памяти. Однако можно переопределить виртуальные методы NewInstance и FreeInstance класса TObject. Таким образом, абсолютно любой класс может осуществить «желание» «где хочу — там и буду лежать». Соответственно организуется и «многокучность».

Object Pascal (Delphi) является результатом функционального расширения Turbo Pascal<ref>Об этом говорят обозначения версий компилятора. Так, в Delphi 7 компилятор имеет номер версии 15.0 (последняя версия Borland Pascal / Turbo Pascal обозначалась 7.0, в Delphi 1 компилятор имеет версию 8.0, в Delphi 2 — 9.0 и т. д. Номер версии 11.0 носит компилятор Pascal, входивший в состав среды [[C++ Builder]]).</ref>.

Многие элементы и концептуальные решения Delphi вошли в состав С#. Одной из причин называют переход [[Хейлсберг, Андерс|Андерса Хейлсберга]], одного из ведущих разработчиков Дельфи, из компании Borland Ltd. в Microsoft Corp.
* Версия 8 способна генерировать [[байт-код]] исключительно для платформы .NET. Это первая среда, ориентированная на разработку многоязычных приложений (лишь для платформы .NET);
* Последующие версии (обозначаемые годами выхода, а не порядковыми номерами, как это было ранее) могут создавать как приложения Win32, так и байт-код для платформы .NET.

[[Delphi for .NET]] — [[Интегрированная среда разработки|среда разработки]] Delphi, а также язык Delphi (Object Pascal), ориентированные на разработку приложений для .NET.

Первая версия полноценной среды разработки Delphi для .NET — Delphi 8. Она позволяла писать приложения только для .NET. Delphi 2006 поддерживает технологию MDA с помощью ECO (Enterprise Core Objects) версии 3.0.

В марте 2006 года компания Borland приняла решение о прекращении дальнейшего совершенствования интегрированных сред разработки [[JBuilder]], Delphi и C++ Builder по причине убыточности этого направления. Планировалась продажа IDE-сектора компании. Группа сторонников [[свободное программное обеспечение|свободного программного обеспечения]] организовала сбор средств для покупки у Borland прав на среду разработки и компилятор<ref>[http://opendelphi.org Default Parallels Plesk Panel Page] {{webarchive|url=https://web.archive.org/web/20061205015430/http://opendelphi.org/ |date=2006-12-05 }}</ref>.

Однако в ноябре того же года было принято решение отказаться от продажи IDE-бизнеса. Тем не менее разработкой IDE продуктов теперь будет заниматься новая компания — CodeGear, которая будет финансово полностью подконтрольна Borland.

В августе 2006 года Borland выпустил облегчённую версию RAD Studio под именем Turbo: [[Turbo Delphi]] (для Win32 и .NET), Turbo C#, Turbo C++.

В марте 2008 года было объявлено о прекращении развития этой линейки продуктов.

В марте 2007 года CodeGear порадовала пользователей обновлённой линейкой продуктов Delphi 2007 for Win32 и выходом совершенно нового продукта Delphi 2007 for PHP.

В июне 2007 года CodeGear представила свои планы, то есть опубликовала так называемый «roadmap»<ref>{{Cite web |url=http://dn.codegear.com/article/36620 |title=Delphi and C++Builder Roadmap |access-date=2007-07-18 |archive-date=2007-10-10 |archive-url=https://web.archive.org/web/20071010010158/http://dn.codegear.com/article/36620 |url-status=dead }}</ref>.

[[Файл:Embarcadero RAD Studio 2010.png|200px|thumb|Embarcadero RAD Studio 2010]]
25 августа 2008 года компания Embarcadero, новый хозяин CodeGear, опубликовала пресс-релиз на Delphi for Win32 2009<ref>{{Cite web |url=http://www.codegear.com/article/38512 |title=Database Tools and Developer Software {{!}} Embarcadero Technologies |access-date=2008-08-25 |archive-date=2008-08-29 |archive-url=https://web.archive.org/web/20080829190209/http://www.codegear.com/article/38512 |url-status=dead }}</ref>. Версия привнесла множество нововведений в язык, как то<ref>[http://www.codegear.com/products/delphi/win32/whats-new/ Delphi from Embarcadero | RAD Application Development Software] {{webarchive|url=https://web.archive.org/web/20080710075609/http://www.codegear.com/products/delphi/win32/whats-new/ |date=2008-07-10 }}</ref>:

* По умолчанию полная поддержка [[Юникод]]а во всех частях языка, VCL и RTL; замена обращений ко всем функциям Windows API на юникодные аналоги (то есть MessageBox вызывает MessageBoxW, а не MessageBoxA).
* [[Обобщённое программирование|Обобщённые типы]], они же '''generics'''.
* [[Анонимная функция|Анонимные методы]].
* Новая директива компилятора $POINTERMATH [ON|OFF].
* Функция Exit теперь может принимать параметры в соответствии с типом функции.

Вышедшая в 2011 году версия Delphi XE2 добавила компилятор [[Win64]] и кросс-компиляцию для операционных систем фирмы [[Apple]] (MacOS X, iOS).

Вышедшая в 2013 году версия Delphi XE5 обеспечила кросс-компиляцию приложений для устройств на платформе ARM/Android.

== Компиляторы ==
* [[Embarcadero Delphi]] (ранее наз. CodeGear Delphi и Borland Delphi) — вероятно, наиболее известный компилятор, который является последователем [[Borland Pascal]] и [[Turbo Pascal]]. Используется [[Windows API#Versions|Win16]] (Delphi 1), [[Windows API#Versions|Win32]] (Delphi 2 и позже), [[Windows API#Versions|Win64]] (Delphi 16 (XE2) и позже), а также [[.NET Framework|.NET 1.x, 2.0]] (Delphi 8, Delphi 2005-Delphi 2007). Поддержка .NET впоследствии выделена в отдельный продукт, известный как (несовместимый с Delphi) [[Oxygene (язык программирования)|Oxygene]].
* [[Free Pascal]] (FPC) — [[Свободное программное обеспечение|свободный]] компилятор [[Object Pascal]], который поддерживает различные диалекты Паскаля, включая [[Turbo Pascal]] (с некоторыми оговорками), Delphi и собственные диалекты. На текущий момент FPC может генерировать код для [[x86]], [[x86-64]], [[PowerPC]], [[SPARC]] и процессоров [[ARM (архитектура)|ARM]], а также для различных операционных систем, в том числе для [[Microsoft Windows]], [[Linux]], [[FreeBSD]], [[Mac OS]]. Существует несколько сред разработки программного обеспечения для FPC (одна из самых известных представителей — [[Lazarus]]).
* [[GNU Pascal]] (отдельно разработанная версия из [[GCC]]). Не ставит целью продолжение серии диалектов Delphi как составляющей Паскаля, но тем не менее содержит режим совместимости с Borland Pascal, и очень медленно приспосабливает компоненты языка Delphi. Не подходит для компиляции больших проектов, содержащих код Delphi, но его поддерживает большинство операционных систем и архитектур.
* [[Oxygene (язык программирования)|Oxygene]] (ранее известен как ''Chrome'') — компилятор ограниченно совместимого с Delphi языка, который интегрирован в [[Microsoft Visual Studio]]. Также доступен в виде компилятора с вольной командной строкой [[Common Language Infrastructure|CLI]]. Использует .NET и моноплатформы. Прежде продавался под маркой [[Embarcadero Delphi]] Prism.
* [[MIDletPascal]] — язык программирования с Delphi-подобным синтаксисом и одноимённый компилятор, который преобразует исходный код в компактный и быстрый [[байт-код Java]].
* [[PocketStudio]] — основанная на Паскале [[Интегрированная среда разработки|IDE]] для [[Palm OS]].
* [[Virtual Pascal]] — Бесплатный компилятор и текстовая IDE для Win32, OS/2 и Linux. На тот момент очень быстрый и весьма совместимый (частично поддерживаются конструкции Delphi 5). Внешне очень похож на текстовую среду Borland Pascal 7, хотя отсутствует совместимая с ним графика, например. Однако разработка окончилась в 2004 году, а исходники открыты не были. С тех пор FPC ушёл намного вперёд и в целом для программирования лучше он. Тем не менее VP остаётся очень неплохим вариантом быстрой замены ещё более устаревших версий Borland Pascal для школы/института, учитывая родную работу в Win32 без проблем с русскими кодировками.

== Синтаксис языка ==

=== Система типов ===
[[Система типов]] в Delphi [[строгая типизация|строгая]], [[статическая типизация|статическая]].
{{Начало скрытого блока|Заголовок =Краткий перечень поддерживаемых типов|Выравнивание_заголовка=left|Фон_заголовка=Azure}}
Поддерживаются следующие [[тип данных|типы данных]]:
* целочисленные, знаковые, и беззнаковые: Byte, Shortint, Word, Smallint, Cardinal,Integer, UInt64, Int64
* типы-перечисления, задаваемые пользователем
* вещественные типы Single, Double, Extended (только x86-32, на Win64 Extended = Double), унаследованный тип Real48, работающий в режиме целочисленной эмуляции. Тип <code>Currency</code> вещественное фиксированной точности.
* строки. Тип <code>string</code> — автоматический распределяемый в памяти, с подсчётом ссылок и парадигмой Copy-On-Write. В поздних версиях Delphi символы двухбайтные, Unicode-совместимые. AnsiString — аналогичная реализация для строк с шириной символа в один байт. Такие строки содержат в служебном поле информацию о кодировке. В Windows компиляторах с ранних версий существует тип <code>WideString</code>, полностью совместимый типу <code>BSTR</code> в [[Component Object Model]]. Также допускается использование строк с фиксированной длиной, не превышающей 255 однобайтных символов. Допускается использование примитивных строковых типов, в стиле языка C: <code>PChar</code> и <code>PWideChar</code>
* массивы. Одномерные, многомерные фиксированной длины, а также подобные им динамические, с подсчётом ссылок.
* множества, состоящие из элементов типа-перечисления. Максимальный размер такого перечисления — 256 элементов.
* [[Запись (тип данных)|Записи]]. Структурный (value) тип без поддержки наследования. Начиная с Delphi 2006 добавлена поддержка инкапсуляции, методов, свойств. Перегрузка операторов. Начиная с Delphi 10.3 Rio добавлена возможность создавать для записи конструкторы.
* Классы и обобщённые классы (generics). Неявно-ссылочный тип. Поддержка инкапсуляции, наследования, полиморфизма, в том числе виртуальных конструкторов, атрибутов, обобщённых параметров для класса и отдельных методов, а также диспетчеризации методов по индексу. Класс может реализовать один или несколько интерфейсов, в том числе опосредованно, делегируя реализацию интерфейса свойству или полю. Множественное наследование не поддерживается.
* Указатели на функции и методы, а также указатели на анонимные функции.
* Типы-[[метакласс]]ы, содержащие указатель на тип объекта (но не сам объект). В основном введены для реализации виртуальных конструкторов и автоматической сериализации.
* интерфейсы. COM-совместимые (в Windows-компиляторе), унаследованные от одного предка. Множественное наследование не поддерживается.
* Диспинтерфейсы, для работы с интерфейсами IDispatch в режиме позднего связывания.
* {{iw|Вариантный тип данных|Вариантные типы|en|Variant type}} <code>Variant</code> и <code>OleVariant</code> — тип с динамической типизацией.
* Старые объекты, поддерживаемые для совместимости с Turbo Pascal. В отличие от экземпляра класса, объект может быть размещён в стеке, или статически. .
{{Конец скрытого блока}}

=== [[Оператор (программирование)|Операторы]] ===
Список операторов через пробел: <code>:= </code><code>+ — * / div mod </code><code>not and or with xor </code><code>shl shr </code><code>^ = <> </code><code>>= <= < > </code><code>@ in is as</code>
{{Начало скрытого блока|Заголовок =Краткий перечень операторов|Выравнивание_заголовка=left|Фон_заголовка=Azure}}
* Арифметические: <code>+</code> <code>—</code> <code>*</code> <code>/</code> <code>div</code> <code>mod</code> Сложение, вычитание, умножение, деление(дающее вещественный результат), целочисленное деление, выделение остатка.
По типу возвращаемого значения ''различаются'' операторы целочисленного деления (<code>div</code> и <code>mod</code>) и оператор <code>/</code>. Последний, применяемый как к целочисленным, так и к вещественным операндам, всегда в результате даёт вещественный тип.
Оператор сложения <code>+</code> используется также для конкатенации строк (когда используются встроенные строковые типы).
* [[Битовые операции|Бинарные]]/логические: <code>not</code> <code>and</code> <code>or</code> <code>xor</code> Инверсия(отрицание), «И», «ИЛИ», Исключающее «ИЛИ». Тип операции (бинарная или логическая) зависит от типа первого операнда.
К битовым операторам целочисленных типов относятся также <code>shl</code>, <code>shr</code> — операторы сдвига, соответствующие по смыслу одноимённым командам процессоров Intel x86.

* Порядковые операторы(операторы сравнения)<code>=</code> <code><></code> <code>></code> <code><</code> <code>>=</code> <code><=</code> — равенства, неравенства(соответствует оператору <code>!=</code> в C-подобных языках), больше, меньше, не меньше, не больше — применяются ко всем порядковым и вещественным типам и возвращают значение типа <code>boolean</code>
* К операторам множества относятся <code>+</code> <code>-</code> <code>*</code> <code>in</code> — сложение, вычитание, пересечение множеств, а также оператор теста вхождения, которые используются для манипуляций со встроенным типом множества. Первые три возвращают тип множества, последний — булевый тип.
{{Начало скрытого блока|Заголовок =Пример использования оператора in|Выравнивание_заголовка=left|Фон_заголовка=Azure}}
<source lang="delphi">
type
  TDayOfWeek = (Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday); //задаётся тип перечислений
  TDays = set of TDayOfWeek; //задаётся тип множества
var
  day: TDayOfWeek;
  days: TDays;
  isMyDay: Boolean;
begin
 days := [Sunday, Tuesday, Saturday];
 day := Monday;
 isMyDay := day in days; // оператор in возвращает булевое значение, принимая первым операндом значение типа "элемент множества", а вторым — значение типа "множество"
end;
</source>
{{Конец скрытого блока}}
* Операторы приведения типов — <code>()</code> <code>as</code> <code>is</code> — безусловное приведение, безопасное приведение объектных и интерфейсных типов, а также оператор теста принадлежности к типу(возвращает булевое значение). Безусловное(небезопасное) приведение используется в функциональном стиле(слева пишется идентификатор типа, справа в скобках приводимое к нему выражение) и применяется к порядковым, вещественным, структурным, ссылочным, строковым типам. При этом для ссылочных(включая неявно-ссылочные) типов '''не''' происходит действительного приведения, а лишь новая интерпретация тех же данных.
Операторы <code>as</code> и <code>is</code> применяются к типам, допускающим полиморфное поведение — экземплярам класса и интерфейсам. Первый приводит безопасное(в смысле невозможности неверной интерпретации) приведение типа, а второй тестирует поддержку экземпляром класса или интерфейсом некоторого класса или интерфейса. Нужно помнить, что в отличие от языка C# неудавшееся приведение типа оператором <code>as</code> возбуждает исключение.
* Ссылочные операторы <code>^</code> <code>@</code> — используются для работы с указателями.
Оператор <code>^</code> разыменовывает указатель. Оператор <code>@</code> выполняет обратное действие, возвращая адрес переменной. Поддерживается простые операции сложения и вычитания над типизированными указателями, с учётом размера типов, на которые они указывают (''умная'' арифметика указателей).
* Оператор присваивания <code>:=</code>. В Delphi оператор присваивания, образует не выражение, а операцию, таким образом, не допускается «нанизывание» присваиваний.
{{Конец скрытого блока}}

=== [[Класс (программирование)|Классы]] ===
В языке Object Pascal классы — это специальные типы данных, используемые для описания объектов. Соответственно объект, имеющий тип какого-либо класса, является экземпляром (instance) этого класса или переменной этого типа.

Класс представляет собой особый тип, имеющий в своём составе такие элементы, как поля, свойства и методы. Поля класса аналогичны полям записи и служат для хранения информации об объекте. ''Методами'' называются процедуры и функции, предназначенные как правило для обработки полей. ''Свойства'' занимают промежуточное положение между полями и методами.

== Объектно-ориентированные особенности языка ==

=== [[Инкапсуляция (программирование)|Инкапсуляция]] ===
Объединение и скрытие объектных данных, а также обрабатывающих их методов, внутри конкретного класса от пользователя называется инкапсуляцией.

=== [[Наследование (программирование)|Наследование]] ===
При создании новых типов объектов способность получить все свойства и методы от своих предков называют наследованием. Такие типы объектов наследуют после своего создания все поля, свойства, события, методы и прочее от своих предков. Наследование часто избавляет разработчиков от рутинной работы и позволяет, не мешкая, приступить к разработке чего-то нового. В отличие от C++, в Delphi не допускается множественное наследование. В Delphi есть возможность добавить методы в класс или запись, с помощью так называемого помощника класса или помощника записи (class helper или record helper), который, не являясь потомком от модифицируемого класса или записи, может добавлять в них дополнительные методы. Примером может служить объявленная в модуле System.SysUtils запись-помощник TStringHelper.

=== [[Полиморфизм (информатика)|Полиморфизм]] ===
Delphi реализует классическую модель полиморфизма, принятую в ''прикладных'' языках программирования, когда методы базового класса, а также ссылочные переменные типа базового класса,— способны манипулировать экземплярами классов-потомков на основе контракта, заданного в базовом классе. Контрактом в этом случае выступает объявление абстрактных методов в базовом классе.

== Примеры ==

=== Структура программы ===
Каждая написанная программа на языке Delphi состоит из заголовка программы (program NewApplication;), поля используемых модулей Uses (к примеру, Uses Windows, Messages, SysUtils и т. д.), который может не входить в саму структуру, а также блоков описания и исполнения (начинаются составным оператором begin и заканчиваются end.).

<source lang="delphi" line="1">
program Project1;                     // Заголовок программы, с её именем «Project1»

uses
  Forms,
  Unit1 in 'Unit1.pas' {Form1};       // модули, которые подключены к проекту и используются программой

{$R *.res}

begin
  Application.Initialize;                // Инициализация приложения
  Application.CreateForm(TForm1, Form1); // Создание формы/окна
  Application.Run;                       // Запуск и исполнение
end.
</source>

=== Пример № 1 ===
Вывод сообщения «Hello, world!» в консольном приложении Delphi
<source lang="delphi" line="1">
program Helloworld;          //название программы
{$APPTYPE CONSOLE}           //директива компилятору о создании консольного приложения
begin
  writeln('Hello, world!');    //вывод сообщения Hello, world!
  readln;                    //ожидание нажатия клавиши пользователем
end.                         //конец программы
</source>

=== Пример № 2 ===
Вывод сообщения «Hello, world!» в 32-разрядном GUI приложении Delphi
<source lang="delphi" line="1">
...

procedure TForm1.Button1Click(Sender: TObject); //Обработчик события OnClick, генерируемый автоматически
begin
  ShowMessage('Hello, world!');                  //вывод сообщения Hello, world!
end;                                           //конец процедуры

...
</source>

=== Пример № 3 ===
Динамическое создание списка строк и запись его в файл.
<source lang="delphi" line="1">
// Обработчик события, происходящего при создании формы MainForm
procedure TMainForm.FormCreate(Sender: TObject);
var
  // Объявление переменной типа TStrings (список строк).
  Strings: TStrings;
begin
  // Создание (выделение памяти и заполнение её начальными значениями) объекта типа TStringList.
  // TStringList - это потомок TStrings, реализующий его абстрактные методы с целью хранения строк в памяти.
  Strings := TStringList.Create;
  try
    // Добавление строки.
    Strings.Add('Добавляемая строка.');
    // Сохранение всех строк в файл.
    Strings.SaveToFile('C:\Strings.txt');
  finally
    // Освобождение памяти объекта и очистка ссылки на неё для предотвращения непреднамеренного обращения к не выделенной памяти.
    FreeAndNil(Strings);
  end;
end;
</source>

== Расширения файлов ==
* <code>.pas</code> — исходный код модуля (pascal)
* <code>.dpr</code> — исходный код проекта (pascal)
* <code>.dproj</code> — исходный код проекта (xml)
* <code>.dproj.local</code> — исходный код проекта (xml)
* <code>.dfm</code> — исходный код формы
* <code>.dpk</code> — исходный код проекта пакета
* <code>.bpl</code> — скомпилированный пакет
* <code>.dcu</code> — скомпилированный модуль
* <code>.exe</code> — скомпилированное приложение
* <code>.res</code> — ресурсы
* <code>.dsk</code> — привязки к файлам
* <code>.identcache</code> — кэшированные привязки к файлам

== Известное программное обеспечение, созданное на Delphi ==
Среди многих распространённых программных продуктов, написанных на Delphi:<ref>[http://delphi.wikia.com/wiki/Good_Quality_Applications_Built_With_Delphi Good Quality Applications Built With Delphi — Delphi Programming] {{Wayback|url=http://delphi.wikia.com/wiki/Good_Quality_Applications_Built_With_Delphi |date=20110630150937 }}{{ref|en}}{{неавторитетный источник|31|05|2015}}</ref>:
* Продукция Embarcadero: [[Embarcadero Delphi]], Embarcadero [[C++ Builder]], Borland [[JBuilder]] 1 и 2 версии.
* Администрирование и разработка баз данных: [[MySQL Tools]], [[IBExpert]], Open Server.
* Инженерное программное обеспечение: [[Altium Designer]], [[SprutCAM]].
* Файловые менеджеры: [[Total Commander]], [[Frigate]], [[ViewFD]], [[FreeCommander]].
* Просмотрщики графики: [[FastStone Image Viewer]], [[FuturixImager]], [[drComRead]].
* Редакторы графики: [[IcoFX]].
* Видео- и аудиопроигрыватели: [[Light Alloy]], [[The KMPlayer]], [[AIMP]], [[X-Amp]], [[Nata Player]].
* Программы мгновенного обмена сообщениями: [[QIP 2012]], [[R&Q]], [[The Bat!]], [[PopTray]], [[FeedDemon]], [[MyChat]], [[Skype]] (до покупки [[Microsoft]]).
* Клиенты файлообменных сетей: [[Shareman]], Ares Galaxy.
* Создание музыки: [[FL Studio]], [[Guitar Pro]] (до версии 6.0).
* Разработка программного обеспечения: [[Dev-C++]], [[DUnit]], [[Game Maker]], [[Inno Setup]], [[PyScripter]], PE Explorer.
* Редакторы ресурсов: [[Resource Hacker]], [[Resource Tuner]].
* Веб-разработка: [[Macromedia HomeSite]], PHPEdit.
* Текстовые редакторы: [[BirEdit]], [[Notepad GNU]], [[Bred]] (до версии Bred 3), [[PSPad]].
* Учёт и налогообложение: [[Меркурий-ERP]], «[[Бюджет 21 (программный продукт)|Бюджет 21]]», «[[Парус (программный продукт)|Парус]]», [[AVARDA]] (до версии 6.x включительно), [[R-Keeper|r_keeper]], Traider Alpha.
* Система электронной очереди «[[МАКСИМА (система электронной очереди)|МАКСИМА]]»<ref>{{Cite web|url=http://mtg-biz.ru/solutions/more/3665/|title=Система электронной очереди "МАКСИМА"|publisher=mtg-biz.ru|access-date=2017-01-05|archive-date=2017-01-06|archive-url=https://web.archive.org/web/20170106010944/http://mtg-biz.ru/solutions/more/3665/|url-status=live}}</ref>.
* Программы хранения и обработки медицинских изображений Makhaon Worsktation<ref>{{Cite web |url=http://www.makhaon.com/index.php?lng=ru&p=products |title=Makhaon Worsktation |access-date=2015-10-01 |archive-date=2015-10-02 |archive-url=https://web.archive.org/web/20151002223822/http://www.makhaon.com/index.php?lng=ru&p=products |url-status=live }}</ref>, Makhaon Storage<ref>{{Cite web |url=http://www.makhaon.com/index.php?lng=ru&p=products |title=Makhaon Storage |access-date=2015-10-01 |archive-date=2015-10-02 |archive-url=https://web.archive.org/web/20151002223822/http://www.makhaon.com/index.php?lng=ru&p=products |url-status=live }}</ref>
* Программы для создания [[Мультипликация (технология)|анимаций]]: Pivot Stickfigure Animator.
* Программы для [[Сжатие данных|сжатия данных]]: [[ALZip]], [[PowerArchiver]], [[IZArc]].
* Нахождение и уничтожение шпионского ПО и вредоносных программ: [[Spybot — Search & Destroy]].
* Компьютерные игры: [[Age of Wonders]], «[[Космические рейнджеры]]», [[Космические рейнджеры HD: Революция]], [[Venom. Codename: Outbreak]], [[Space Empires V]], «[[Правда о девятой роте]]».
* Лаунчер портативных программ: [[PortableApps]].
* Дефрагментация диска: [[SmartDefrag]].
* Различные системные утилиты: [[TreeSize]].
* Терминал для работы с COM-портом: TerminalTMB.

== Критика ==
{{Орисс в разделе|дата=2021-04-05}}

=== Критика языка на ранних этапах развития ===
История критики Pascal восходит к 1981 году и работе Брайана Кернигана<ref>{{cite web | url=http://www.lysator.liu.se/c/bwk-on-pascal.html | title=Why Pascal is Not My Favorite Programming Language | access-date=2016-05-23 | archive-date=2009-04-28 | archive-url=https://web.archive.org/web/20090428163341/https://www.princeton.edu/~mike/unixhistory | url-status=live }}</ref>, аргументы которой в основном устарели по мере развития языка.

=== Нововведения для компиляции на мобильные платформы ===
Некоторые изменения языка, осуществлённые компанией Embarcadero (разработчиком языка) в так называемых NextGen-компиляторах языка Delphi, намеренно ''нарушили'' совместимость с накопленной базой исходного кода. Эти изменения были отрицательно восприняты широким кругом опытных Delphi-разработчиков, поскольку, хотя и приближали язык к парадигме языков .NET, но ''сломали'' традицию высокой обратной совместимости и существенно затруднили перенос имеющегося исходного кода в программное обеспечение для мобильных платформ.
Указанные ниже изменения поставили под сомнение самую парадигму мультиплатформенной разработки на базе единого исходного кода, рекламируемую Embarcadero.
* введение индексации строк по нулевой базе
Со времён Pascal исторически сложилось, что встроенный строковый тип индексировался с базой в единицу: «нулевой» элемент строки возвращал длину строки. По мере введения новых («длинных» и «юникодных») строковых типов данный порядок индексации сохранялся, обеспечивая почти бесшовный перенос кодовой базы на обновлённые версии языка. Однако со введением nextgen-компиляции парадигма изменилась: в новых компиляторах строки стали индексироваться по нулевой базе, как и в семействе С-подобных языков (C++, C#, Java), при этом в «классических» компиляторах для Windows и Mac OS парадигма единичной индексации была сохранена.
* введение безальтернативного механизма подсчёта ссылок для экземпляров классов
Исторически классы и их экземпляры являются неявно-ссылочными структурными типами. Тем не менее, управление временем жизни экземпляра класса изначально выполнялось вручную — посредством явного вызова конструктора и деструктора (либо метода <code>Free()</code>), и такая особенность сохраняется (по состоянию на 2018 год) в ''классических'' версиях компиляторов. [[Подсчёт ссылок]] работал лишь для классов, реализующих интерфейсы, и притом, в том только случае, когда манипуляции с такими классами производились посредством переменных интерфейсного типа.

До версии 10.4 компиляторы для мобильных платформ ввели подсчёт ссылок для всех экземпляров классов, тем самым в корне изменив парадигму управлением временем жизни объектов, поскольку «ручное» управление практически (за исключением некоторых весьма продвинутых техник) несовместимо с новой парадигмой.

С версии 10.4 введен единый механизм управления памятью<ref>{{Cite web|lang=ru|url=https://www.embarcadero.com/ru/products/rad-studio/whats-new-in-10-4-sydney|title=Что нового в RAD Studio 10.4|website=Embarcadero Website|access-date=2020-09-15|archive-date=2020-06-03|archive-url=https://web.archive.org/web/20200603101033/https://www.embarcadero.com/ru/products/rad-studio/whats-new-in-10-4-sydney|url-status=dead}}</ref>, когда для мобильных, настольных и серверных используется классическая реализация управления памятью объектов. ARC-модель управления памятью model осталась для управления строками и ссылками на тип интерфейса на всех платформах.

=== Медленная эволюция языковых средств ===
Многие разработчики рассматривают консервативность Delphi как достоинство, которое обеспечивает высокую переносимость кода, а также упрощает понимание языка начинающими программистами.

Однако в настоящее время ситуация такова, что ''новые'' технологии, парадигмы и даже языки программирования появляются (и набирают популярность) едва ли не каждый год. Развитие же языковых средств ''не всегда'' влечёт за собой отказ от обратной совместимости.

Ярким примером такого подхода является
{{Начало скрытого блока|Заголовок =''запоздалое'' введение в язык объявления локальных переменных внутри блока|Выравнивание_заголовка=left|Фон_заголовка=Azure}}
[[Файл:QC Inline.png|thumb|upright=1.2|right|Обсуждение на Embarcadero Quality Portal]]
До версии компилятора 33.0 (Delphi 10.3 Rio) объявление локальной переменной должно было ''предшествовать'' первой инструкции кода функции, причём инициализация локальных (стековых) переменных в месте объявления не допускается. Невозможен был также и вывод типа.

Для сравнения, объявление локальной переменной в любом месте функции поддерживалось в языке Си изначально, и было унаследовано практически всеми языками, которые придерживались Си-подобного стиля — C++, C#, Java и др.

Введение этого языкового средства в Delphi обсуждалось давно, но в то время не встретило понимания разработчиков языка.
{{Конец скрытого блока}}

== Примечания ==
{{примечания}}

== Литература ==
* {{книга
|автор = Нил Дж. Рубенкинг.
|заглавие = Язык программирования Delphi для «чайников». Введение в Borland Delphi 2006
|ссылка = https://archive.org/details/delphi3fordummie0000rube
|оригинал = Delphi for Dummies
|место = М. |издательство = [[Диалектика (издательство)|Диалектика]]
|год = 2007
|страниц = 336
|isbn = 0-7645-0179-8
}}
* {{книга
|автор = Хавьер Пашеку.
|заглавие = Программирование в Borland Delphi 2006 для профессионалов
|оригинал = Delphi for .NET Developer’s Guide
|место = М. |издательство = [[Вильямс (издательство)|Вильямс]]
|год = 2006
|страниц = 944
|isbn = 0-672-32443-X
}}
* {{книга
|автор = А. Н. Вальвачев, К. А. Сурков, Д. А. Сурков, Ю. М. Четырько.
|заглавие = Программирование на языке Delphi. Учебное пособие
|ссылка = http://www.rsdn.ru/?article/Delphi/Delphi_7_00.xml
|год = 2005
}}

== Ссылки ==
{{Навигация|Тема=Delphi|Викиучебник=Delphi}}
* [https://www.embarcadero.com/ru/products/delphi Домашняя страница среды программирования Delphi] на сайте [[Embarcadero Technologies]]

{{Pascal}}

[[Категория:Delphi]]