TypeDeffinition1;
	TypeDeffinition2;
	...

	TypeName=TypeDeclaration;

Пример:

type
	Float=Real; // тип Float эквивалентен уже существующему типу Real
	TIntegerArray=array[0..9] of Integer; // массив для 10-ти значений типа Integer
	TSemaphoreColor=(scRed, scYellow, scGreen); {перечислимый тип который может содержать
	одно из трех значений scRed, scYellow, scGreen}

Объявление пользовательских типов данных будет подробно рассмотрено в дальнейших главах. Здесь оно приведено только для общего представления о том что такое типы данных.

Данные, которыми манипулирует программа, хранятся в переменных. Каждая переменная принадлежит к одному из типов данных. По другому говорят что "такая-то переменная является переменной такого-то типа" или "такая-то переменная имеет тип такой-то". Указание типа данных для переменной является важным свойством языка. Указание типа данных определяет правила по которым переменная может быть использована, способы ее использования и допустимый набор действий которые могут быть произведены над данными хранящимися в этой переменной. Самое главное, то что задание типа данных для переменной информирует компилятор о том какие "правила игры" нужно принять во время работы с этой переменной. Таким образом компилятор имеет возможность проанализировать корректность операций производимых над переменными и сообщить программисту о ошибках, буде тот в своем программном коде нарушает правила игры.

Переменные имеют также имена или по другому идентификаторы. По имени переменной компилятор (да и программист тоже :-) отличают одну переменную от другой.

Над переменными возможно производить две фундаментальных операции - присвоить переменной какое-нибудь значение и использовать значение присвоенное переменной для каких-нибудь целей.

Попробуем объяснить концепцию переменных на пальцах

Допустим у нас имеется числовое значение 25 которое представляет собой количество денег которые должен нам наш знакомый. Нам надо сохранить его (не знакомого, а сколько денег он нам должен) а потом воспользоваться им. Мы берем коробку на которой написано "Долг", пишем на бумажке число 25 и бросаем его в коробку. А в голове запоминаем что размер долга знакомого хранится в коробке с надписью "Долг". Впоследствии встретившись с нашим знакомым в темном переулке мы быстренько ищем у себя в кармане коробку с надписью "Долг", открываем ее, выуживаем бумажку и радостно сообщаем ему: "Слышь-ты, гони бабло... цельных... м-м-м-м... 25 рублей". Видя нашу зверскую рожу знакомый в ужасе сообщает нам что в наличности у него с собой только 15 рублей и он готов отдать нам их, а остаток будет попозже. "Без проблем", - говорим мы ибо 15 рублей нам и не хватало на бутылочку "Сибирская корона - Рубиновое". Забираем у него деньги, старую бумажку выбрасываем, на новой пишем 10 (результат от 25-15) и кладем в коробку "Долг".

Хорошо. У нас есть бутылка пива и мы хотели бы ее сохранить некоторое время (например, пока не дойдем до ближайшей шашлычной). Попытка затолкать бутылку пива в такую-же коробку в которой у нас хранилась заметка о долге ни к чему не приведет. Бутылка не влезет. Тогда мы пихаем бутылку в полиэтиленовый пакет с надписью "Christian_Dior" и счастливо прем в шашлычную к месту распития и разъетия.

В чем мораль сей басни, спросите вы? А вот в чем. Бумажки с надписями и бутылка пива - это значения переменных. Емкости для хранения (коробка и пакет) - это сами переменные, места где хранятся значения (данные). Надписи на коробке и пакете - идентификаторы переменных по которым мы отличали их от других коробок распиханых по карманам и пакетов болтающихся за спиной. Разница размеров между пакетам и коробкой - типы переменных, в коробку мы можем класть только маленькие бумажки, а в пакет только бутылки с пивом.

Когда мы положили бумажку с надписью в коробку мы выполнили операцию присваивания. Присвоили переменной "Долг" значение 25. Когда мы смотрели бумажку для сообщения размера долга, мы использовали значение находящееся в переменной "Долг". Когда мы положили другую бумажку в коробку, мы присвоили перменной "Долг" новое значение - 10, как результат выражения 25-15. С пивом и пакетом то-же самое.

Переменные объявляются в секции объявления переменных, которая начинается с ключевого слова var. Формат объявления переменных:

var
	VariableDeffinitionList

	VariableList1:VariableDatatype1;
	VariableList2:VariableDatatype2;
	...
	VariableListN:VariableDatatypeN;

	VariableIdent1,VariableIdent2,...,VariableIdentN:VariableDataType;

Пример:

var
	A,A1:Integer;
	B:String;
	C,D:Real;

var
	C:Real;
	A:Integer;
	B:String;
	A1:Integer;
	D:Real;

Иногда нам требуется использовать в тексте программы фиксированные значения, т.е. значения которые не должны изменяться в процессе выполнения программы. Например в программе расчета давления машины на грунт это может быть количество колес автомобиля - 4. Предположим везде в расчетах мы будем использовать это число - 4. Но что будет если нам предложат переделать программу чтобы она считала давление на грунт БТР-а, у которого этих колес 8 штук? Идея просматривать код и заменять везде 4 на 8 - не самая лучшая. Гораздо удобнее и правильнее определить константу и назначить ей нужное значение, а потом использовать вместо значения эту константу. Компилятор сам подставит значение константы в тех местах где она была использована. Таким образом нам достаточно лишь будет исправить значение константы с 4 на 8 а потом перекомпилировать программу.

Константы подразделяются на два вида - истинные (true constants) и типизированные (typed). Истинные константы - собственно и есть константы в чистом виде. Типизированные константы - константы которые могут содержать типизированные значения. Например можно объявить массив-константу или запись-константу.

Главное и наиболее полезное свойство констант, это то что они неизменны на протяжении всего времени выполнения программы. Программа в которой производится попытка изменить значение константы просто не скомпилируется.

Константы, так-же как переменные и типы данных, объявляются в своей секции объявления констант которая начинается с зарезервированного слова const. Объявление констант имеет следующий формат:

const
	ConstantDeffinitionList

	ConstantDeffinition1
	ConstantDeffinition2
	...
	ConstantDeffinitionN

	ConstantIdent=ConstantExpression;

	ConstantIdent:DataType=ConstantExpression;

Пример объявления констант:

const
	A=10;
	B='Linux must die';
	E:Real=2.71;
	C=A+5;
	D:array[0..4] of Integer=(5, A, 1, C, 123);

Итак, вернемся к нашим баранам и посчитаем распределение давления колес на поверхность для какого-нибудь транспортного средства. Хотя мы знаем что вес обычно распределяется неравномерно, но будем для простоты считать что это не так и давление каждого колеса на поверхность одинаковое.

{$APPTYPE CONSOLE}
program WheelPressure;  // название программы
        // секция объявлений
type    // секция объявления типов
    // объявили тип данных Float который совпадает с встроенным типом Real
	Float=Real;
const        // секция объявления констант
	WheelCount=4;   // WheelCount - количество колес
	VehicleMass:Float=1.8;   // VehicleMass - масса транспортного средства
var     // секция объявления переменных
	WheelPressure:Float;   // WheelPressure - давление одного колеса
begin  // начало тела программы
    // присваиваем переменной WheelPressure частное от деления VehicleMass на WheelCount
	WheelPressure:=VehicleMass/WheelCount;
	// печатаем пояснение и значение переменной WheelPressure
	WriteLn('Pressure caused by one wheel is ', WheelPressure);
end.  // конец тела программы

NB! Обратите внимание на комментарий вначале текста программы {$APPTYPE CONSOLE}. Это специальный комментарий для компилятора Delphi инструктирующий его что он должен создавать консольную программу.

Для чего все это сделано, скажете вы, когда можно было просто написать:

{$APPTYPE CONSOLE}
program WheelPressure;
var
	WheelPressure:Float;
begin
	WheelPressure:=1.8/4;
	WriteLn('Pressure caused by one wheel is ', WheelPressure);
end.

{$APPTYPE CONSOLE}
program WheelPressure;
begin
	WriteLn('Pressure caused by one wheel is ', 1.8/4);
end.

А вот зачем. Представьте себе что наша программа состоит не из пары десятков строк а из пары десятков тысяч строк (обычное дело для реального мира) и, скажем, "количество колес", используется в двадцати местах, рассеянных по этой программе. Предположим условия задачи изменятся и нам придется делать расчет не для 4-ех колесного транспортного устройства, а для 8-ми колесного. Куда проще завести константу и использовать ее во всех расчетах, а при необходимости сменить вместо того чтобы искать все места в программе где используется "количество колес" и менять его с 4 на 8.

То-же самое относится к типу данных Float. Если вдруг нам понадобится увеличить точность расчетов то мы просто переменим объявление типа данных Float и объявим его равным типу данных Double вместо Real. Тип данных Double позволяет сохранить больше значащих цифр при вычислениях. Таким образом исправив программу только в одном месте мы повысим точность вычислений по всей программе.