არის ელემენტი ნაკრებში? ახალი მასალის სწავლა

kset ობიექტების კომპლექტები kset კომპლექტები არის კობჯექტის ობიექტების კოლექცია. kset კომპლექტი მოქმედებს როგორც საბაზისო კონტეინერის კლასი ისეთი ობიექტებისთვის, როგორიცაა "ყველა ბლოკის მოწყობილობა". kset კომპლექტები ძალიან ჰგავს ktypes-ს და ჩნდება კითხვა: „რა არის ორი განსხვავებული

ფედორენკო სერგეი

შესავალი

Delphi საშუალებას გაძლევთ განსაზღვროთ კომპლექტის ობიექტების ტიპი, რომელთა ელემენტებიც იგივე საბაზისო ტიპის მნიშვნელობებია. ბაზის ტიპი განსაზღვრავს ყველა ელემენტის ჩამონათვალს, რომელიც შეიძლება შეიცავდეს მოცემულ კომპლექტს. ნაკრებში შემავალი ელემენტების რაოდენობა შეიძლება განსხვავდებოდეს 0-დან 256-მდე (სიმრავლეს, რომელიც არ შეიცავს ელემენტებს, ეწოდება ცარიელი).

აღწერა

ნაკრების ტიპის აღწერა ასეთია:

ტიპი<имя типа>= კომპლექტი<базовый тип>;

აქ<имя типа>- იდენტიფიკატორი;<базовый тип>- ერთ-ერთი სკალარული ტიპი, გარდა რეალურისა. ბაზის ტიპი მითითებულია დიაპაზონით ან ჩამოთვლებით. სტანდარტული ტიპებიდან, ბაიტის, char და ლოგინის ტიპები შეიძლება მითითებული იყოს ნაკრების საბაზისო ტიპად. საბაზისო ტიპი შემოღებულია ან წინასწარი განმარტებით პროგრამის აღწერილობის განყოფილებაში, ან პირდაპირი განცხადების საშუალებით კომპლექტის ტიპის აღწერილობაში სიტყვების ნაკრების შემდეგ, მაგალითად:

აკრიფეთ ასო = "a" .. "z"; // შეზღუდული ტიპის ასოს აღწერა
ტიპი SL = ასოების ნაკრები; // მრავალჯერადი ტიპის SL-ის აღწერა საბაზისო ტიპის ასოებით

ტიპი SLR = კომპლექტი "a" .. "z"; // პირდაპირ ჩართეთ ბაზის ტიპის განმარტება "a .. "z" SLR მრავალჯერადი ტიპის განსაზღვრებაში

თუ პროგრამა იყენებს ცვლადებს, რომელთა მნიშვნელობები მითითებულია, მაშინ ეს ცვლადები აღწერილია ჩვეულებრივი გზით:

ტიპი intset = ბაიტის ნაკრები;
var m1, m2: intset; // ცვლადები აღწერილია მათი კუთვნილების ადრე განსაზღვრულ ტიპზე მითითებით
var m3: კომპლექტი 1..20; // ცვლადის ტიპის განმარტება პირდაპირ შედის მის აღწერაში

თქვენ შეგიძლიათ დააყენოთ კომპლექტის ტიპის ცვლადის მნიშვნელობა პროგრამაში მინიჭების ოპერატორის გამოყენებით, რომლის მარჯვენა მხარეს ნაკრების ელემენტები ჩამოთვლილია კვადრატულ ფრჩხილებში, გამოყოფილი მძიმეებით (ე.წ. ნაკრების კონსტრუქტორი). მრავალი ტიპის ცვლადის მნიშვნელობების მაგალითები:

ცარიელი ნაკრები;
- კომპლექტი, რომელიც შეიცავს ელემენტებს 1, 3, 5, 6, .. 12;
["a" .. "p", "u", "z"] - ნაკრები, რომელიც შედგება char ტიპის ჩამოთვლილი სიმბოლოებისგან.

ნაკრების ტიპის ელემენტები შეიძლება განისაზღვროს როგორც გამონათქვამები, მაგალითად: . გამონათქვამებს უნდა ჰქონდეს მნიშვნელობები რიგითი ტიპის მოცემული საბაზისო ნაკრებიდან. მრავალჯერადი ტიპის ცვლადის მნიშვნელობების დიაპაზონი არის ყველა შესაძლო ქვეჯგუფის ნაკრები, რომელიც ჩამოყალიბებულია საბაზისო ტიპის ელემენტებიდან.

ჩამოთვლისგან განსხვავებით, პირველზე, მეორეზე და ა.შ. ნაკრების ელემენტები, რადგან კომპლექტებისთვის შეკვეთის კონცეფციას აზრი არ აქვს. თუ ნაკრები შეიცავს მხოლოდ სამ ელემენტს, მაშინ შესაძლო კომბინაციების ჯამური რაოდენობაა 2 * 2 * 2 = 8. დაჯავშნულ სიტყვათა კომპლექტს შეუძლია განსაზღვროს ნაკრები 256-მდე ელემენტით, ე.ი. 1.1579208923731619542357098500869e+77 ვარიანტები. პრაქტიკაში, ასეთი რაოდენობის ვარიანტები არასდროს იქნება საჭირო. კერძოდ, დელფის დეველოპერები გვირჩევენ გამოიყენონ ნაკრები არაუმეტეს 16 ელემენტით.

ოპერაციების დაყენება

იგივე ოპერაციები შეიძლება შესრულდეს მრავალი ტიპის ცვლადებზე, როგორც ჩვეულებრივ კომპლექტებზე:

1. გაერთიანება (+);
2. კვეთა (*);
3. განსხვავება (-).

გარდა ამისა, გარკვეული ოპერაციები შემოწმების, ეკუთვნის თუ არა ელემენტი სიმრავლეს (in), კომპლექტების იდენტურობის შემოწმება (=), არაიდენტურობა, კომპლექტი (<>), კომპლექტების წევრობის (ბუდეს) განსაზღვრა (>= ან<=). Примеры:

1. = // შედეგი True
2. ["a" .. "z"] = ["a" .. "p"] // შედეგი მცდარია
3. <>// შედეგი True
4. ["ა", "ბ", "გ"]<= ["a" .. "z"] // Результат True
5. ["a" .. "k"] >= ["a" .. "z"] // შედეგი მცდარი
6. + // შედეგი
7. * // შედეგი
8. - // შედეგი

ფუნქციონირება საშუალებას გაძლევთ განსაზღვროთ, ეკუთვნის თუ არა ელემენტი კომპლექტს. პირველი ოპერანდი სიტყვის მარცხნივ არის ძირითადი ტიპის გამოხატულება. მეორე ოპერანდი სიტყვის მარჯვნივ უნდა იყოს მრავალი ტიპის, მაგალითად:

a in // შედეგი True
2 * 4 in // შედეგი True
"a" + "b" in ["ab", "cd", "ef"] // შედეგი True
5 in // შედეგი True
5 in // შედეგი მცდარი

in ოპერატორის გამოყენებისას, წევრობის შესამოწმებელი მნიშვნელობა და კვადრატულ ფრჩხილებში დაყენება არ საჭიროებს წინასწარ განსაზღვრას დეკლარაციების განყოფილებაში, თუ ისინი არ არის მითითებული, როგორც კონკრეტული მნიშვნელობები.

ინ ოპერატორი საშუალებას გაძლევთ ეფექტურად შეასრულოთ მდგომარეობის რთული ტესტები. მაგალითად, ნაცვლად:

(c >= "0") და (გ<= "9") or (c >= "ა") და (გ<="z");

უფრო ადვილია დაწერა:

c in ["0" .. "9", "a" .. "z"];

უფრო მეტიც, ეს უკანასკნელი დიზაინი, როგორც წესი, უფრო ეფექტური იქნება.

ოპერაციები (=) და (<>) საშუალებას გაძლევთ შეამოწმოთ ტოლია თუ არა ორი ნაკრები. ოპერატორების გამოყენებით (>=) და (<=) можно определить, является ли одно множество подмножеством другого. Пример:

= // შედეგი მცდარია
<= // Результат True

შენიშვნები:
1. ცარიელი სიმრავლე არის ნებისმიერი სხვა სიმრავლის ქვესიმრავლე, მიუხედავად მისი ელემენტების ძირითადი ტიპისა.
2. ოპერანდთა კომპლექტებს შეიძლება ჰქონდეთ განსხვავებული ბაზის ტიპები. მაგალითად A სიმრავლეების მქონე: კომპლექტი 1 .. 99 და B: კომპლექტი 100 .. 150, A+B გაერთიანების შედეგად შეგვიძლია მივიღოთ ახალი სიმრავლე ბაზის ტიპის 1 .. 150-ით.
3. აუცილებელია განვასხვავოთ სიმრავლის კონსტრუქტორი და X რიგობითი ტიპის სეგმენტი.. Y. X > Y-სთვის პირველ შემთხვევაში ვსაუბრობთ ცარიელ სიმრავლეზე, ხოლო მეორეში შემდგენელი წარმოქმნის შეცდომას. მაგალითი:

["a", "b"] = ["b" .. "a"] // შედეგი მცდარი

ქვესიმრავლის შემოწმებისას, ტესტი ტარდება "ნაკლებად ან ტოლზე" და არა მხოლოდ ტესტირება საკუთარი ქვესიმრავლისთვის, ანუ "ტოლების" გარეშე. ოპერაციები (<) и (>) არ არის გათვალისწინებული, ამიტომ, საჭიროების შემთხვევაში, A და B კომპლექტების სათანადო ქვეჯგუფის შემოწმება შეიძლება განხორციელდეს შემდეგნაირად:

(ა<= B) and (A >= B) ან (A >= B) და (A<>ბ)

მოქმედებების სწორი თანმიმდევრობის დასაზუსტებლად მხედველობაში უნდა იქნას მიღებული სიმრავლეების მოქმედებების უპირატესობის (პრიორიტეტის) მიღებული რიგი: კვეთას (*) აქვს ისეთივე პრიორიტეტი, როგორც გამრავლებისა და გაყოფის არითმეტიკული მოქმედებები; გაერთიანება (+) და სხვაობა (-) იკავებს შემდეგ ქვედა პრიორიტეტულ დონეს, შეკრებისა და გამოკლების არითმეტიკული ოპერაციების მსგავსი; ყველაზე დაბალ დონეზე არის მითითებული შედარების ოპერაციები (=,<>, <=, >=) და შეამოწმეთ, ეკუთვნის თუ არა ელემენტი სიმრავლეს (in). იგივე პრიორიტეტის ოპერაციები შესრულებულია მარცხნიდან მარჯვნივ. ფრჩხილები გამოიყენება მოქმედებების თანმიმდევრობის შესაცვლელად.

ნაკრების გამოყენება

ყველაზე ეფექტურად, ნაკრები შეიძლება გამოყენებულ იქნას if განცხადებების ჩასანაცვლებლად, მაგალითად, იმის შესამოწმებლად, არის თუ არა გარკვეული პასუხი დაშვებულ სიაში. შემდეგი პროგრამა სიმბოლოების სტრიქონის შეყვანისთვის, რომელიც შეიცავს ლათინურ ასოებს, რიცხვებს და სივრცეებს, შეყვანილი სიმბოლოების სისწორის კონტროლით, შეიძლება იყოს კომპლექტების გამოყენების მაგალითი:

პროგრამა Project1;

($APPTYPE CONSOLE)

ვარ
str:string;
L: ბაიტი;
t: ლოგიკური;

დელფში, პროგრამისტებს ძალიან ხშირად უწევთ საქმე კომპლექტებთან, რომლებიც არსებითად არის იმავე ტიპის მნიშვნელობების კრებულები. თითოეულ კომპლექტს აქვს მნიშვნელობების საკუთარი დიაპაზონი, რომელიც შედგება ყველა შესაძლო ქვესიმრავლისგან, რომელიც მოიცავს მის ელემენტებს.

თუ ანალოგს გამოვხატავთ მათემატიკური ტერმინით, მაშინ პროგრამირებისას კომპლექტის კონცეფციას რამდენიმე მახასიათებელი აქვს. მაგალითად, ის სასრულია, ანუ სიმრავლე არ შეიძლება შეიცავდეს ელემენტთა უსასრულო რაოდენობას. სიმრავლის კუთვნილი ობიექტების საერთო რაოდენობა მერყეობს 0-დან 256-მდე. თუ ნაკრები არ ეკუთვნის ერთ ელემენტს, მაშინ მას ცარიელი ეწოდება.

აღსანიშნავია ის ფაქტი, რომ Delphi კომპლექტებში არ შეიძლება გამოყენებულ იქნას რაიმე ელემენტის (სიმბოლოები, რიცხვები) შესანახად. მას შეუძლია მხოლოდ უპასუხოს კითხვას, ეკუთვნის თუ არა გარკვეული ელემენტი მოცემულ კომპლექტს.

დელფის კომპლექტი

მაგალითად:

ტიპი<имя типа>= კომპლექტი<базовый тип>;
ამ შემთხვევაში<имя типа>მოქმედებს როგორც იდენტიფიკატორი. ა<базовый тип>არის ერთ-ერთი სკალარული ტიპი, იგი მითითებულია ჩამოთვლით ან კონკრეტული დიაპაზონით. სტანდარტულ ტიპებს შორის, char, byte, boolean შეიძლება გამოყენებულ იქნას, როგორც ძირითადი ტიპი. თქვენ შეგიძლიათ დააყენოთ ტიპი როგორც პროგრამის აღწერაში, ასევე უშუალოდ მითითებული აღწერილობაში.

მაგალითად: პირველი ვარიანტი.

ტიპი abc = "c" .. "q"; // ტიპის აღწერა abc type FG = კომპლექტი abc; // მრავალჯერადი ტიპის FG-ის აღწერა ბაზის ტიპის abc
მეორე ვარიანტი.

ტიპი FGH = კომპლექტი "c" .. "q"; // პირდაპირ ჩართეთ საბაზისო ტიპის განმარტება "c' .. "q" FGH მრავალჯერადი ტიპის განსაზღვრებაში
დელფში კომპლექტების განხილვისას, აღსანიშნავია, რომ შეკვეთაზე ლაპარაკს აზრი არ აქვს. მაგალითად, თუ გარკვეული ნაკრები მოიცავს მხოლოდ სამ ობიექტს, მაშინ სხვადასხვა ვარიაციების საერთო რაოდენობა იქნება რვა.

ნაკრების განსაზღვრის შემდეგ, მასზე შეიძლება შესრულდეს სხვადასხვა ოპერაციები. დელფში კომპლექტები შეიძლება გაერთიანდეს და გადაიკვეთოს. გარდა ამისა, ხელმისაწვდომია ოპერაციები, როგორიცაა განსხვავება და IN.

დელფში კომპლექტების შედარებისას აზრი არ აქვს ელემენტების თანმიმდევრობას ყურადღებას. ორი კომპლექტი ტოლი იქნება, თუ ისინი შეიცავს ერთსა და იმავე ელემენტებს.

დელფში შეგიძლიათ გამოიყენოთ წევრობის ოპერაციები. ერთი ნაკრები ეკუთვნის მეორეს, თუ მისი ყველა ელემენტი შედის მეორე კომპლექტში.

მაგალითად, A >= B არის True, თუ B სიმრავლის ყველა ელემენტი ასევე არის A სიმრავლეში.

იმის გასარკვევად. მიეკუთვნება თუ არა კონკრეტული ელემენტი კომპლექტს, გამოიყენება IN ოპერატორი. ამ ოპერაციის გამოყენებით, თქვენ შეგიძლიათ შეასრულოთ წევრობის პირობების საკმაოდ რთული ტესტები ძალიან ეფექტურად.

ყოველივე ზემოთქმულის გარდა, ქ Delphi კომპლექტები შეიძლება გაერთიანდეს ერთში. შედეგად, მიიღება მესამე ნაკრები, რომელიც მოიცავს ელემენტებს როგორც A-დან, ასევე B-დან.

კომპლექტების გამოყენება კონკრეტული პროგრამის განხორციელებაში პროგრამისტებს საშუალებას აძლევს მნიშვნელოვნად გააუმჯობესონ ალგორითმის სიცხადე, გაამარტივონ if განცხადება და ასევე დაზოგონ გარკვეული დრო. სეტების გამოყენება Delphi-ში ძალიან მარტივია, განსაკუთრებით თუ შევადარებთ Linux-ის ადმინისტრაციას.

რაიმე სერიოზული პროგრამის შექმნისას თქვენ არ შეგიძლიათ დამატებითი, უფრო რთული მონაცემთა ტიპების გარეშე, ვიდრე რიცხვები და სტრიქონები. IN დელფიპროგრამისტს შეუძლია საკუთარი მიზნებისთვის მონაცემთა ტიპების შექმნა. პროგრამაში მონაცემთა ახალი ტიპის დასანერგად (აღწერისთვის), გამოიყენეთ ოპერატორი საკვანძო სიტყვით ტიპი:
ტიპი type_name = ტიპის_აღწერილობა ;

უთვალავიტიპი არის მონაცემთა ტიპი, რომლის მნიშვნელობების დიაპაზონი უბრალოდ იდენტიფიკატორების ნაკრებია. ეს შეიძლება გამოყენებულ იქნას იმ შემთხვევებში, როდესაც თქვენ უნდა აღწეროთ მონაცემთა ტიპი, რომლის მნიშვნელობები უფრო ნათლად არის წარმოდგენილი არა ციფრებით, არამედ სიტყვებით. ჩამოთვლილი ტიპი იწერება, როგორც იდენტიფიკატორების თანმიმდევრობა, ჩამოთვლილი ფრჩხილებში - ამ ტიპის მნიშვნელობები, რომლებიც ჩამოთვლილია მძიმეებით. ამ შემთხვევაში, ტიპის პირველი ელემენტები უმცროსად ითვლება შემდეგთან შედარებით. მაგალითად, ტიპი, რომელიც აღწერს საფეხბურთო გუნდების სახელებს, შეიძლება ჩამოყალიბდეს ასე:

ტიპი FootballTeam = (სპარტაკი, დინამო, ცსკა, ტორპედო, ლოკომოტივი);
ვარ MyTeam: FootballTeam;
დაიწყება
MyTeam:=სპარტაკი;
დასასრული;

ზოგადად, ჩამოთვლილი ტიპები ნიშნავს ყველა ტიპს, რისთვისაც შეიძლება განისაზღვროს მნიშვნელობების თანმიმდევრობა და მათი უპირატესობა. ეს მოიცავს:

• ყველა მთელი ტიპი, რომლებისთვისაც ყოველთვის შესაძლებელია N რიცხვის შემდეგ რიცხვის მითითება;
• სიმბოლოების ტიპები (Char): სიმბოლოს "a" ყოველთვის მოსდევს "b", "0" ყოველთვის მოჰყვება "1" და ა.შ.;
• ლოგიკური ტიპები - ლოგიკური ტიპი ასევე არის enum ტიპი: ტიპილოგიკური = (მცდარი, მართალია);

• მასივები
• ჩანაწერები
• კომპლექტი

ტიპიმასივის_ტიპის_სახელი = მასივი[დიაპაზონი] დანელემენტის_ტიპი;

დიაპაზონიგანსაზღვრავს მასივის ქვედა და ზედა საზღვრებს და, შესაბამისად, მასში არსებული ელემენტების რაოდენობას. მასივზე წვდომისას, ინდექსი უნდა იყოს ამ დიაპაზონში. მთელი რიცხვის ტიპის ასი ელემენტის მასივი აღწერილია შემდეგნაირად:

ტიპი TMyArray = მასივი დანმთელი რიცხვი;

ახლა ჩვენ შეგვიძლია აღვწეროთ TMyArray ტიპის ცვლადები:

ვარ A, B: TMyArray;

ტიპების მინიჭების ნაცვლად, შეგიძლიათ მკაფიოდ გამოაცხადოთ ცვლადები მასივებად:

ვარ A, B: მასივი დანმთელი რიცხვი;

მასივის ელემენტზე წვდომისთვის, თქვენ უნდა მიუთითოთ მასივის სახელი და ელემენტის ინდექსი კვადრატულ ფრჩხილებში. ინდექსი შეიძლება იყოს რიცხვი, იდენტიფიკატორი ან გამოხატულება, რომლის მნიშვნელობა უნდა მოხვდეს მასივის აღწერისას მითითებულ დიაპაზონში:

ვარ N: მთელი რიცხვი;
დაიწყება
N:= 65;
A := 101;
A[N] := 165;
A := 200;
B:= A;
დასასრული;

ზოგჯერ საჭიროა გაარკვიეთ მასივის ზედა ან ქვედა ზღვარი. ამისათვის გამოიყენება ჩაშენებული ფუნქციები:

მაღალი ()- დააბრუნებს რიცხვს, რომელიც არის მასივის ზედა ზღვარი;
დაბალი ()- დააბრუნებს რიცხვს, რომელიც არის მასივის ქვედა ზღვარი.

თქვენ უნდა ჩადოთ ფრჩხილებში მასივი, რომლის საზღვრებიც გსურთ გაიგოთ.

გამოხატულება ბ:= ანიშნავს, რომ მასივის თითოეული ელემენტი ბიგივე მასივის ინდექსის მქონე ელემენტის ტოლი იქნება ა. ასეთი მინიჭება შესაძლებელია მხოლოდ იმ შემთხვევაში, თუ ორივე მასივი გამოცხადებულია დასახელებული ტიპის მიხედვით, ან ჩამოთვლილია იმავე სიაში. და იმ შემთხვევაში:

ვარ A: მასივი დანსიმებიანი;
B: მასივი დანსიმებიანი;

მისი გამოყენება შეუძლებელია (მაგრამ ელემენტარული დავალება B := A; და ა.შ. შესაძლებელია).

მასივებს შეიძლება ჰქონდეს მრავალი განზომილება, გამოყოფილი მძიმეებით. მაგალითად, ცხრილი ოთხი სვეტით და სამი მწკრივით:

ტიპი MyTable = მთელი რიცხვის მასივი;
ვარ X: MyTable;
Y: მთელი რიცხვი;
დაიწყება
Y:=X;
დასასრული;

ახლა დავალების ოპერაციის შედეგად ითანაბარი იქნება 7 .
მრავალგანზომილებიანი, მაგალითად, ორგანზომილებიანი მასივი შეიძლება აღწერილი იყოს, როგორც მასივების მასივი:

ტიპი TMyArray = მასივი მასივის დანმთელი რიცხვი;

შედეგი იქნება წინა მაგალითის მსგავსი.
მრავალგანზომილებიანი მასივის თითოეულ განზომილებას შეიძლება ჰქონდეს თავისი ტიპი და არა აუცილებლად მთელი რიცხვი.
გარდა ზემოაღნიშნულისა, ე.წ სტატიკურიმასივები, რომლებშიც ელემენტების რაოდენობა მუდმივია, in დელფიშეიძლება გამოყენებულ იქნას დინამიურიმასივები, ელემენტების რაოდენობა, რომლებშიც შეიძლება შეიცვალოს პროგრამის მოთხოვნებიდან გამომდინარე. ეს საშუალებას გაძლევთ დაზოგოთ კომპიუტერული რესურსები, თუმცა ასეთ მასივებთან მუშაობა გაცილებით ნელია. დინამიური მასივები აღწერილია სტატიკურის მსგავსად, მაგრამ ინდექსის დიაპაზონის მითითების გარეშე:

ტიპი TDinArray = მასივიმთელი რიცხვი;
ვარ A: TDinArray;

შექმნის შემდეგ დინამიურ მასივში არ არის ელემენტები. საჭირო ზომა დაყენებულია პროგრამაში სპეციალური პროცედურის გამოყენებით SetLength. ასი ელემენტისგან შემდგარი მასივი:

დაიწყება
SetLength(A, 100);
დასასრული;

დინამიური მასივის ქვედა ზღვარი ყოველთვის ნულია. ამიტომ მასივის ინდექსი აშეიძლება განსხვავდებოდეს 0 რომ 99 .
მრავალგანზომილებიანიდინამიური მასივები აღწერილია ზუსტად ისე მასივების მასივები. მაგალითად, ორგანზომილებიანი:

ტიპი T3DinArray = მასივიმთელი რიცხვი;
ვარ A: T3DinArray;

პროგრამა ჯერ ადგენს ზომას პირველი განზომილების გასწვრივ (სვეტების რაოდენობა):

დინამიურ მასივზე გამოყოფილი მეხსიერების გასათავისუფლებლად, თქვენ უნდა მიანიჭოთ მასივს მნიშვნელობა, როგორც მთელი რიცხვი. ნული:
A: = ნული;
საკვანძო სიტყვა ნულიდელფში ნიშნავს არანაირ ღირებულებას.

პოსტებიძალიან მნიშვნელოვანი და მოსახერხებელი ინსტრუმენტი. სპეციალური ტექნოლოგიების გამოყენების გარეშეც კი შეგიძლიათ გამოიყენოთ იგი საკუთარის შესაქმნელად მონაცემთა ბაზები. ჩანაწერები არის მონაცემთა სტრუქტურა, რომლის თითოეულ ელემენტს აქვს საკუთარი სახელი და მონაცემთა ტიპი. ჩანაწერის ელემენტს სხვაგვარად უწოდებენ ველი. შესვლის აღწერა ასე გამოიყურება:
ტიპიჩანაწერის_ტიპის_სახელი = ჩანაწერი
ველი_სახელი: ველი_ტიპი;
. . .
ველი_სახელი: ველი_ტიპი;
დასასრული;
ველების სახელები, რომლებსაც აქვთ იგივე ტიპი, შეიძლება, როგორც ცვლადის აღწერილობის შემთხვევაში, მიეთითოს ერთ სტრიქონზე, გამოყოფილი მძიმეებით. ჩანაწერის ველზე მითითებისთვის ჯერ მიუთითეთ ჩანაწერის სახელი, შემდეგ წერტილი, შემდეგ ველის სახელი. მაგალითად, საწარმოს პერსონალის შესახებ მონაცემები შეიძლება ორგანიზებული იყოს ამ ტიპის ჩანაწერის გამოყენებით:

ტიპი TPers = ჩანაწერი
Fam, Name, Par: სიმებიანი;
წელი: მთელი რიცხვი;
Dep: სიმებიანი;
დასასრული;
ვარპირები: TPers;
დაიწყება
სპარს . ფამ:="ივანოვი";
სპარს . სახელი: "ივანე";
სპარს . პარ:"ივანოვიჩი";
სპარს . წელი:=1966;
სპარს . Dep:="სახელოსნო No1";
დასასრული;

ახლა რჩება მხოლოდ ამ მონაცემების ფაილში ჩაწერა, მისი ტიპი ადრე გამოცხადებული TPers, და მონაცემთა ბაზამზადაა. ფაილით დელფიასევე ასოცირდება ცვლადი სახელწოდებით ფაილის ცვლადი, რომელიც აღწერილია ასე:
VFile : ფაილიფაილის_ტიპი;
ტიპი შეიძლება იყოს დელფის ნებისმიერი შეზღუდული ტიპი. თუმცა, ტიპი დაუშვებელია სიმებიანი, რადგან ის იძლევა ცვლადი ზომის 2 გბ-მდე. ის უნდა იყოს შეზღუდული: სტრიქონი[N], სადაც N არის სიმბოლოების რაოდენობა. ტიპი TPersწინა მაგალითიდან უნდა იყოს აღწერილი, მაგალითად, ასე:

ტიპი TPers = ჩანაწერი
Fam, Name, Par: სიმებიანი;
წელი: მთელი რიცხვი;
Dep: სიმებიანი;
დასასრული;

ახლა ამ ტიპის ცვლადი იკავებს მკაცრად განსაზღვრულ ადგილს მეხსიერებაში და შეიძლება ჩაიწეროს ფაილში. როგორ გავაკეთოთ ეს აღწერილია მე-2 ნაწილიგაკვეთილი No7.

ბევრიარის ელემენტების ჯგუფი, გაერთიანებული ერთი სახელით და რომელთანაც სხვა რაოდენობების შედარება შესაძლებელია იმის დასადგენად, ეკუთვნის თუ არა ისინი ამ კომპლექტს. ელემენტების რაოდენობა ერთ კომპლექტში არ შეიძლება აღემატებოდეს 256-ს. ნაკრები აღწერილია შემდეგნაირად:

ტიპინაკრები_სახელი = კომპლექტიმითითებული_მნიშვნელობის_დიაპაზონი;

დიაპაზონად შეიძლება განისაზღვროს ნებისმიერი ტიპი, რომელშიც ელემენტების რაოდენობა არ აღემატება 256-ს. მაგალითად:

ტიპი TMySet = კომპლექტი 0 .. 255;
ტიპი TMySet = კომპლექტიბაიტი;

კომპლექტის სპეციფიკური მნიშვნელობები მითითებულია პროგრამაში კვადრატულ ფრჩხილებში ჩასმული ელემენტების სიის გამოყენებით. დიაპაზონის გამოყენება ასევე შეიძლება:

ვარ MySet: TMySet;
დაიწყება
MySet:=;
დასასრული;

იმის შესამოწმებლად არის თუ არა მნიშვნელობა სიმრავლის ელემენტი, გამოიყენეთ ოპერატორი inკომბინაციაში პირობითიოპერატორი:

ვარგასაღები: ჩარ;
Str: სიმებიანი;