დელფი - რა არის ეს?

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

Windows ოპერაციული სისტემების ოჯახი ამჟამად ყველაზე პოპულარულია პერსონალური კომპიუტერის მომხმარებლებში და, ბუნებრივია, ვინც გეგმავს პროგრამირებას, ცდილობს დაწეროს პროგრამები, რომლებიც იმუშავებს ამ სისტემებზე.

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

კომპიუტერული ტექნოლოგიების სწრაფმა განვითარებამ და პროგრამული უზრუნველყოფის განვითარების ეფექტური ინსტრუმენტების საჭიროებამ განაპირობა პროგრამირების სისტემების გაჩენა, რომლებიც ორიენტირებულია ეგრეთ წოდებულ „სწრაფ განვითარებაზე“, რომელთა შორის შეიძლება გამოვყოთ ბორლანდი დელფიდა Microsoft Visual Basic. სწრაფი განვითარების სისტემების გულში (RAD სისტემები, აპლიკაციის სწრაფი განვითარება- სწრაფი აპლიკაციის განვითარების გარემო) არის ვიზუალური დიზაინისა და ღონისძიების პროგრამირების ტექნოლოგია, რომლის არსი იმაში მდგომარეობს, რომ განვითარების გარემო იღებს რუტინულ სამუშაოს უმეტეს ნაწილს, რის შედეგადაც პროგრამისტს უტოვებს დიალოგური ყუთების და ღონისძიების დამუშავების ფუნქციების შექმნას. პროგრამისტის პროდუქტიულობა RAD სისტემების გამოყენებისას ფანტასტიკურია!

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

ამჟამად, Delphi პაკეტის შემდეგი ვერსია ხელმისაწვდომი გახდა პროგრამისტებისთვის - Borland Delphi 7 Studio. წინა ვერსიების მსგავსად, Borland Delphi 7 Studio გაძლევთ საშუალებას შექმნათ მრავალფეროვანი პროგრამები: მარტივი ერთი ფანჯრის აპლიკაციებიდან დაწყებული, განაწილებული მონაცემთა ბაზების მართვის პროგრამებამდე. პაკეტი მოიცავს მრავალფეროვან კომუნალურ პროგრამას, რომელიც საშუალებას გაძლევთ იმუშაოთ მონაცემთა ბაზებთან, XML დოკუმენტებთან, შექმნათ დახმარების სისტემა და გადაჭრათ სხვა პრობლემები. მეშვიდე ვერსიის გამორჩეული თვისებაა .NET ტექნოლოგიის მხარდაჭერა.

Borland Delphi 7 Studioშეუძლია იმუშაოს ოპერაციულ სისტემებში Windows 98-დან Windows XP-მდე. თანამედროვე სტანდარტებით, პაკეტი არ აწესებს რაიმე განსაკუთრებულ მოთხოვნას კომპიუტერულ რესურსებზე: პროცესორი უნდა იყოს Pentium ან Celeron ტიპის, საათის სიხშირით მინიმუმ 166 MHz (რეკომენდებულია Pentium II 400 MHz), ოპერატიული მეხსიერება - 128 MB (256 MB). რეკომენდირებულია), საკმარისი რაოდენობის თავისუფალი ადგილი დისკზე (დაახლოებით 475 მბ საჭიროა Enterprise ვერსიის სრული ინსტალაციისთვის).

ამ წიგნის შესახებ

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

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

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

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

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

რა არის პროგრამირება

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

შედეგად, ჩვენ გვაქვს პირველი პირობა: პროგრამირების შესასწავლად გჭირდებათ რაიმე სახის პროგრამირების ენა. ჩვენს შემთხვევაში, ეს იქნება Object Pascal-ის უახლესი ვერსიები (14.0 ან 15.0).

გარდა ამისა, ვთქვათ, ვინც საკუთარ თავს პროგრამისტს უწოდებს, არა მხოლოდ დაარედაქტირა HTML კოდის რამდენიმე სტრიქონი, არამედ ნახა დელფი და მასში ფორმაც კი დახატა 2-3 ღილაკით და ტექსტური ველით. ეს პროგრამისტია? დიდი ალბათობით არც. ფაქტია, რომ ვიზუალური გარსის ქვეშ, ფაქტობრივად, იმალება ძალიან რთული მექანიზმი, რომელიც უზრუნველყოფს კონტროლის (იგივე ღილაკების) ურთიერთქმედებას მომხმარებელთან და ოპერაციულ სისტემასთან - ერთის მხრივ, და საშუალებას გაძლევთ შეასრულოთ თითქმის ნებისმიერი გამოთვლითი მოქმედება. - მეორეზე. ამ ყველაფერთან ერთად თქვენ უნდა შეგეძლოთ გააკეთოთ მთავარი - შექმენით პროგრამის ქცევის ალგორითმები - იქნება ეს მისი რეაქცია კონკრეტული ღილაკის დაჭერაზე, თუ რთული მათემატიკური განტოლების ამოხსნის ფუნქციის შექმნა.

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

რა არის დელფი

ახლა ჩვენ ვიცით, რომ პროგრამირება არის ალგორითმების შედგენა, პლუს პროგრამირების ენის გამოყენება. მაგრამ თუ ენა, რომელსაც ჩვენ ვსწავლობთ არის Object Pascal, მაშინ რა არის Delphi? პასუხი არის: Delphi არის RAD, ან სწრაფი აპლიკაციის განვითარება - სწრაფი აპლიკაციის განვითარების გარემო. სხვა სიტყვებით რომ ვთქვათ, Delphi მოიცავს არა მხოლოდ Object Pascal ენასთან მუშაობის ყველა ინსტრუმენტს (განსაკუთრებით მას შემდეგ, რაც 2005 წლის ვერსიიდან დაწყებული, Delphi-ს აქვს მხარდაჭერა სხვა პროგრამირების ენებისთვის, განსაკუთრებით C#), არამედ უამრავ დამატებით ინსტრუმენტს, რომელიც შექმნილია სიჩქარისთვის. მაქსიმალურად გააუმჯობესოს პროცესი და გაამარტივოს პროგრამების შექმნა. ეს ხელსაწყოები მოიცავს, პირველ რიგში, ვიზუალური ფორმის რედაქტორს, რომლის დახმარებით თქვენ შეგიძლიათ შექმნათ სრულფასოვანი პროგრამა რამდენიმე წუთში და ზედმეტი ძალისხმევის გარეშე, ისევე როგორც პროგრამის განვითარების ვიზუალური კომპონენტის სხვა კომპონენტები.

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

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

დელფი და სხვები

რა თქმა უნდა, Delphi არ არის ერთადერთი სწრაფი აპლიკაციის განვითარების გარემო. არსებობს სხვა RAD-ები, რომლებიც თანაბრად სასარგებლოა ვიზუალური პროგრამის შემუშავებისთვის, როგორიცაა Visual Basic. მაგრამ BASIC ცნობილია, როგორც არა ყველაზე ძლიერი და მოსახერხებელი პროგრამირების ენა; გარდა ამისა, მასზე დაწერილი პროგრამები ხასიათდება შედარებით დაბალი შესრულებით.

ამავდროულად, არის პროგრამირების ენები, რომლებიც არანაკლებ ძლიერია ვიდრე Object Pascal და აქვთ საკუთარი RAD - პირველ რიგში, ეს არის C++ ენა ისეთი ცნობილი განვითარების ინსტრუმენტებთან ერთად, როგორიცაა Visual C++ და C++ Builder. თუმცა, C++ სწავლის სიმარტივის თვალსაზრისით დადებითად არ ადარებს Object Pascal-ს. გარდა ამისა, C++-ში პროგრამების შექმნა და გამართვა შედარებით ნელია, თუმცა მზა პროგრამები მუშაობს ისევე სწრაფად, როგორც დელფის გამოყენებით შექმნილი პროგრამები.

ᲨᲔᲜᲘᲨᲕᲜᲐ
გაითვალისწინეთ, რომ 1995 წელს გამოჩენის დროს, დელფი იყო მართლაც უნიკალური გარემო, რომელიც აერთიანებდა ვიზუალურ პროგრამირებას ოპტიმიზატორ კომპილატორთან და მონაცემთა ბაზებთან მუშაობის ინსტრუმენტებთან.

შედეგად, ჩვენ ვიღებთ თითქმის იდეალურ პროდუქტს პროგრამის სწრაფი განვითარებისთვის: ერთის მხრივ, Visual Basic-თან შედარებული სიმარტივე და მოხერხებულობა, ხოლო მეორეს მხრივ, C++-ისთვის დამახასიათებელი სიმძლავრე, სიჩქარე და მოქნილობა.

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

პროცედურული პროგრამირება და ალგორითმები

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

მოდით შევხედოთ უმარტივეს ალგორითმს - თამაშისთვის "გამოიცანი რიცხვი". მისი მოქმედების ლოგიკა იმაში მდგომარეობს, რომ თქვენ უნდა შეამოწმოთ რიცხვი მეტია თუ ნაკლები ფარულზე, და თუ ასეა, გამოაჩენთ შესაბამის მინიშნებას, ხოლო თუ ის არც დიდია და არც ნაკლები (ე.ი. ემთხვევა) მაშინ თამაში მთავრდება. . ასეთი ალგორითმის ბლოკ-სქემა შედგება 2 ტოტისაგან (ნახ. 1.1).

ბრინჯი. 1.1. მარტივი ალგორითმის ნაკადის სქემა

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

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

ბრინჯი. 1.2. პროგრამის კონტროლის სქემა

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

კონკრეტული ალგორითმის სპეციფიკური განხორციელება დამოკიდებულია გამოყენებული პროგრამირების ენაზე, ასევე პროგრამის შემქმნელის პრეფერენციებზე, რადგან, როგორც წესი, ერთი და იგივე კონსტრუქციის გადაჭრა შესაძლებელია რამდენიმე განსხვავებული მეთოდის გამოყენებით. მაგალითად, თქვენ შეგიძლიათ გამოიყენოთ როგორც მარყუჟები, ასევე უპირობო ნახტომის განცხადებები ბლოკ დიაგრამაზე მითითებულ წერტილზე დასაბრუნებლად. კარგად, თავად ბლოკები შეიძლება განთავსდეს ცალკეულ პროცედურებში და ეწოდოს ქვეპროგრამებს. ერთადერთი საერთო მახასიათებელია ჩანგალზე პასუხისმგებელი პირობითი ოპერატორი - თითქმის ყველა ენაზე და არც პასკალია გამონაკლისი, მას IF ჰქვია. თუმცა დრო მაინც გვექნება Object Pascal-ის ოპერატორების გასაცნობად.

ობიექტზე ორიენტირებული პროგრამირების შესახებ

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

ᲨᲔᲜᲘᲨᲕᲜᲐ
ტერმინი "ობიექტი" პროგრამირებაში გაგებულია, როგორც მონაცემთა გარკვეული რთული ტიპი, რომელსაც შეიძლება დაერთოს ამ ტიპის უნიკალური თვისებები და OOP-ის შემთხვევაში, ასევე მეთოდები.

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

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

Object Pascal-ში ყველა კლასი წარმოიქმნება ერთი წინაპრისგან - TObject კლასიდან, რომელიც ახორციელებს მოქმედებებს ყველა კლასისთვის საერთო ობიექტზე, როგორიცაა შექმნა და წაშლა.

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

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

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

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

ვიზუალური პროგრამირება და დელფი

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

ბრინჯი. 1.3. კლასიკური და ვიზუალური მიდგომები ინტერფეისის შესაქმნელად

ის ფაქტი, რომ Delphi არის ვიზუალური განვითარების გარემო, თავის კვალს ტოვებს პროგრამირების ენაზე. კერძოდ, ის უზრუნველყოფს სპეციალურ საშუალებებს, რათა კლასების გარკვეული თვისებები ხელმისაწვდომი იყოს უკვე პროგრამის შემუშავების ეტაპზე და არა მხოლოდ გაშვების დროს. მაგრამ ამ ბრწყინვალების ყველაზე მნიშვნელოვანი ნაწილი არის კლასის ბიბლიოთეკა - VCL (Visual Component Library). ეს არის VCL, რომელიც მალავს Windows-ის შიდა ნაწილების ყველა უხეში კიდეებს და საშუალებას გაძლევთ მარტივად შექმნათ აპლიკაციები გაჭიანურებულ ომში ჩართვის გარეშე სისტემური შეტყობინებების, გამოძახებების, სახელურებისა და მაჩვენებლების დამუშავებით.

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

ვიზუალურ კომპონენტებს დეტალურად განვიხილავთ ამ წიგნის მე-3 ნაწილში.

დელფის ვერსიები და მათი განსხვავებები

შესავალი ნაწილის ბოლოს განვიხილავთ განსხვავებებს Delphi-ს ვერსიებს შორის, პარალელურად შევისწავლით ამ შესანიშნავი განვითარების გარემოს განვითარების ისტორიას.

დელფი 1. გამოშვებული Windows 95-ის გამოჩენამდე ცოტა ხნით ადრე, Delphi 1.0 იყო Windows (3.1) აპლიკაციის განვითარების პირველი ინსტრუმენტი, რომელიც აერთიანებდა ოპტიმიზაციის შემდგენელს, ვიზუალური განვითარების გარემოს და მონაცემთა ბაზის მძლავრ ინსტრუმენტებს. ეს იყო ნამდვილი რეინკარნაცია პასკალური ენისთვის - ის გახდა ობიექტი პასკალი.

დელფი 2. Delphi-ის მე-2 ვერსია, რომელიც გამოვიდა ერთი წლის შემდეგ, სთავაზობდა იგივეს, მაგრამ Windows-ის 32-ბიტიან ვერსიებს (95/NT), კვლავ გახდა პირველი ინსტრუმენტი, რომელიც აერთიანებს 32-ბიტიან კომპილატორს, მონაცემთა ბაზებთან მუშაობის ინსტრუმენტებს და ვიზუალს. განვითარების გარემო, რომელიც მხარს უჭერს OLE-ს (და განახლებული Delphi 2.01 - და ActiveX-ის გამოშვების შემდეგ). შეიცვალა ენაც, გახდა 32-ბიტიანი.

დელფი 3. Delphi-ის შემდგომმა გაუმჯობესებამ ყველა მიმართულებით განაპირობა მე-3 ვერსიის გამოშვება, რომელსაც გააჩნდა აპლიკაციების შექმნის ინსტრუმენტების გაფართოებული ნაკრები COM და ActiveX-ის მხარდაჭერის წყალობით. ამ ვერსიაში პირველად აქცენტი გაკეთდა ინტერნეტისთვის აპლიკაციების შექმნის შესაძლებლობაზე და გაჩნდა მონაცემთა დაუბეჭდავი ტიპი - ვარიანტი.

დელფი 4. განვითარების კიდევ ერთი მნიშვნელოვანი ეტაპი. ამ ვერსიაში ბევრი ახალი და სასარგებლო რამ დაინერგა აპლიკაციის განვითარების გასამარტივებლად, მათ შორის ახალი გარემო დინამიური მინიშნებებით და ა.შ. გაუმჯობესდა კომპონენტებთან მუშაობის მოდელი (VCL) და შესაძლებელი გახდა ისეთი ტექნოლოგიების სწრაფად გამოყენება, როგორიცაა MIDAS, DCOM და CORBA. ამ ვერსიაში ასევე გაუმჯობესდა Object Pascal ენა: გამოჩნდა თანამედროვე OOP-ისთვის დამახასიათებელი ახალი ფუნქციები, დაინერგა მონაცემთა ახალი ტიპები, მათ შორის 64-ბიტიანი.

დელფი 5. იმდენი ცვლილება იყო დელფი 4-ში, რომ, სამწუხაროდ, იყო შემაშფოთებელი შეცდომები და შეცდომები. შედეგი იყო 3 განახლების პაკეტის გამოშვება (ჩვენმა მეკობრეებმა ისინი გაყიდეს Delphi 4.1, 4.2 და 4.3-ის საფარქვეშ). მაგრამ Delphi 5 უნდა ჩაითვალოს ყველაზე სრულყოფილ და სწორ განახლების პაკეტად - ამ ვერსიაში ყველაფერი, რაც დაიწყო Delphi 4-ში, განხორციელდა.

დელფი 6. მეექვსე ვერსიის გამოშვებით, Borland-მა გამოაცხადა ახალი, კროს-პლატფორმული ეპოქა Delphi-ში, ერთდროულად გამოუშვა Delphi-ის ვერსია Linux-ისთვის (Kylix 1.0). ახლა, აპლიკაციის შექმნისას, შეგიძლიათ აირჩიოთ მისი ტიპი - Windows-ისთვის ან უნივერსალური. შესაბამისად, VCL ბიბლიოთეკას დაემატა CLX ბიბლიოთეკა, რომელიც თავსებადია როგორც Windows-თან, ასევე Linux-თან. გარდა ამისა, მე -6 ვერსიაში, "მშობლიური" და არა უცხოური ActiveX, საბოლოოდ გამოჩნდა ინტერნეტთან მუშაობის კომპონენტები და ორივე ვერსიაში ერთდროულად - როგორც VCL, ასევე CLX. ამ ვერსიით დაწყებული, თავად Object Pascal პროგრამირების ენას ოფიციალურად უწოდებენ Delphi.

დელფი 7. Delphi 6-ის შემდგომი განვითარება, გაუმჯობესებული CLX ბიბლიოთეკა და Linux OS-ის განვითარების გარემოს ახალი შესაბამისი ვერსია - Kylix 3. ამავე დროს, Delphi 7-დან დაწყებული, Borland დაინტერესდა სხვა პლატფორმასთან - Microsoft-თან თავსებადობის საკითხით. NET, რომლისთვისაც განხორციელდა გარკვეული ცვლილებები, როგორც VCL-ში, ასევე ენაში (და, შესაბამისად, შემდგენელში).

დელფი 8. დელფის პირველი ვერსია, რომელიც ორიენტირებულია Microsoft.NET პლატფორმასთან მუშაობაზე. ამ ვერსიაში, დეველოპერებმა აიღეს გარემოს ინტერფეისის შეცვლის რისკი, რაც მსგავსი გახადა Microsoft-ის პროდუქტების, Borland-ის ახალი ძირითადი აქციონერის. შესაბამისად, Kylix-ის მხარდაჭერა შეწყდა.

დელფი 2005 წ. Delphi 8-ის გამოშვებიდან ერთ წელზე ნაკლები ხნის შემდეგ გამოჩნდა ახალი ვერსია, რომელმაც სწრაფად დაუბრუნა კლასიკური IDE სტილში მუშაობის შესაძლებლობა Windows-ისთვის აპლიკაციების შემუშავებისას. ამავდროულად, Delphi 2005, სპეციალურად NET პლატფორმისთვის აპლიკაციების შემუშავების შემთხვევაში, საშუალებას გაძლევთ იმუშაოთ არა მხოლოდ Delphi ენაზე, არამედ C#-ითაც. ამავდროულად, ისეთი ინოვაციები, როგორიცაა for...in ოპერატორი და ჩაშენებული პროცედურები და ფუნქციები დაინერგა თავად დელფის ენაში.

დელფი 2006 წ. Borland-ის მიერ გამოშვებული Delphi-ის უახლესი ვერსია. ასევე გამოვიდა მსუბუქი ვერსია - ტურბო დელფი. შემდეგ დაიწყო მოგზაურობა სხვა დეველოპერებთან.

დელფი 2007 წ. ვერსია გამოშვებული CodeGear-ის მიერ. დამატებულია მხარდაჭერა Aero ინტერფეისისთვის Windows Vista-სთვის.

დელფი 2009 წ. Embarcodero-ს მიერ გამოშვებული ვერსია. Unicode მხარდაჭერა განხორციელდა VCL-ში და RTL-ში, ზარები Windows API-ის ყველა ფუნქციაზე შეიცვალა Unicode-ის ანალოგებით, დამატებულია ზოგადი ტიპები და ანონიმური მეთოდები.

დელფი 2010 წელი. Windows 7-ის მხარდაჭერა, შეხების და ჟესტების კომპონენტები და dbExpress კომპონენტები უკვე ოფიციალურად უჭერენ მხარს Firebird-ს.

Delphi XE (დელფი 2011). დამატებულია ღრუბლოვანი გამოთვლის მხარდაჭერა.

დელფი ჩვეულებრივ ასოცირდება აპლიკაციის განვითარების გარემოსთან, რომელიც დაფუძნებულია ბორლანდის მიერ შემუშავებულ Object Pascal ენაზე. ეს ენა არის Turbo Pascal-ის მემკვიდრე ობიექტზე ორიენტირებული გაფართოებებით, რომელიც თავის მხრივ თავის ისტორიას ატარებს „სუფთა“ პასკალამდე, რომელიც შეიქმნა ნიკლაუს ვირტის მიერ 1970 წელს.

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

ფონი

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

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

Windows-ის მოსვლასთან ერთად გაჩნდა საჭიროება ამ პლატფორმისთვის პროგრამული უზრუნველყოფის განვითარების გარემოს შექმნა. ყველაზე პოპულარული გადაწყვეტა პერსონალური Windows კომპიუტერებისთვის 80-იან და 90-იანი წლების დასაწყისში იყო Turbo Pascal შემდგენელი და IDE Borland-ისგან. ჩაშენებული შემდგენელი უზრუნველყოფდა კომპილაციის მაღალ სიჩქარეს და კოდის მაღალ ხარისხს (აქედან გამომდინარე Turbo პრეფიქსი). Turbo Pascal გარემო ასევე უზრუნველყოფდა კოდის გამართვას და შეიცავდა მაგალითების მდიდარ კომპლექტს. ყველა ამ თვისებამ საშუალება მისცა Turbo Pascal გამხდარიყო პასკალის ენის სტანდარტი გარკვეული დროით.

დროის გამოწვევა

Windows-ში გრაფიკულმა ინტერფეისმა საკმაოდ სწრაფად დაიწყო განვითარება და Turbo Pascal IDE კვლავ იყენებდა DOS-ის მსგავს ინტერფეისს. თანდათან მაიკროსოფტმა გააცნობიერა, რომ მათ სჭირდებოდათ პროგრამირების „ვიზუალიზაციის“კენ გადასვლა.

მარტივი პროგრამის შესაქმნელად, დეველოპერებს უნდა დაეწერათ კოდის რამდენიმე გვერდი: დაწერეთ კოდის დიდი ბლოკები მენიუებისთვის და ფანჯრებისთვის, შრიფტები, მეხსიერების გასუფთავება, ღილაკების „დახაზვა“ და ა.შ. თუმცა, Windows GUI-ის უპირატესობები საკმაოდ ძლიერი იყო, ამიტომ საჭირო იყო ოპერაციული სისტემის განვითარების მხარდაჭერა. მაიკროსოფტმა გააცნობიერა, რომ აუცილებელი იყო როგორმე გაეადვილებინა დეველოპერებისთვის ცხოვრება. ამიტომ, 90-იან წლებში კომპანიამ წამოიწყო რამდენიმე პარალელური პროექტი Windows-ისთვის ახალი პროგრამირების ენისა და განვითარების გარემოს შესაქმნელად. პირველი ნიშანი იყო Visual Basic.

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

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

„სახელი დელფი შემოგვთავაზა დენი თორპმა სესიის დროს. ჩვენ გვინდოდა, რომ სისტემის სახელი ასახავდეს პროდუქტის უნიკალურ შესაძლებლობებს მონაცემთა ბაზებთან მუშაობისთვის და Delphi შესანიშნავად ეხმიანება ისეთ დამსახურებულ სახელს ამ სფეროში, როგორიცაა Oracle, ყოველ შემთხვევაში მათთვის, ვისთვისაც კომბინაცია „Delphic Oracle“ ნიშნავს რაღაცას. თქვა დელფის სისტემის განვითარების კვლევითი ჯგუფის ხელმძღვანელმა ჩაკ იაზდჟევსკიმ.

Borland Delphi რუსეთში 1993 წლის ბოლოს გამოჩნდა და მაშინვე დიდი პოპულარობა მოიპოვა.

ძირითადი ვერსიები

ვერსია 1 განკუთვნილი იყო 16-ბიტიანი Win16 პლატფორმის განვითარებისთვის. მეორე ვერსიიდან დაწყებული, განხორციელდა პროგრამის შედგენის შესაძლებლობა 32-ბიტიანი Win32 პლატფორმისთვის.

დელფი 1

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

დელფი 3

Delphi-ის მე-6 ვერსიასთან ერთად გამოვიდა Kylix-ის გარემო, მასთან თავსებადი ენასა და ბიბლიოთეკებში, რომელიც განკუთვნილია ლინუქსის ოპერაციული სისტემისთვის პროგრამების შედგენისთვის.

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

2006 წელს Delphi-ში შესაძლებელი გახდა აპლიკაციების დაწერა .NET-ისთვის სტანდარტული .NET კლასის ბიბლიოთეკის გამოყენებით, VCL .NET-ისთვის. გარემომ ასევე შესაძლებელი გახადა .NET აპლიკაციების C#-ში და Win32 აპლიკაციების C++-ში ჩაწერა. Delphi 2006-მა ასევე დანერგა MDA (Model Driven Architecture) ტექნოლოგია ECO (Enterprise Core Objects) 3.0 ვერსიის გამოყენებით.

რისთვისაც იბრძოდნენ

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

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

შესაძლებელი გახდა ActiveX კომპონენტების შექმნა Microsoft IDL-ის გამოყენების გარეშე, ვებ სერვერის შესაძლებლობების გაფართოება (სერვერის მხარის სკრიპტები), HTML, XML ან ASP-ის შესახებ თითქმის არაფრის ცოდნის გარეშე.

ახლა უკვე შესაძლებელია განაწილებული აპლიკაციების შექმნა COM და CORBA, ინტერნეტისა და ინტრანეტის აპლიკაციების საფუძველზე Borland DataBase Engine, ODBC დრაივერების ან Microsoft ADO მონაცემების წვდომისთვის.

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

ცვლილებები

ყოველწლიურად გამოდიოდა დელფის ახალი ვერსია, მაგრამ მეხუთე შემდეგ თითქოს რაღაც მოხდა... მოგვიანებით გაირკვა, რომ Delphi-ის ახალ ვერსიაზე მუშაობის პარალელურად მუშავდებოდა დელფის მსგავსი პროგრამირების ენა Linux-ისთვის. . ახალ პროდუქტს Kylix ჰქვია. Delphi-მ დიდი გავლენა მოახდინა C# ენის კონცეფციის შექმნაზე .NET პლატფორმისთვის. მისი მრავალი ელემენტი და კონცეპტუალური გადაწყვეტა იყო ჩართული C#-ში. ერთ-ერთი მიზეზი არის ანდერს ჰეილსბერგის, Delphi-ის ერთ-ერთი წამყვანი დეველოპერი შპს Borland-ისგან გადასვლა. Microsoft Corp.

2006 წლის მარტში Borland-მა გადაწყვიტა შეეწყვიტა ინტეგრირებული განვითარების გარემოს შემდგომი განვითარება JBuilder, Delphi და C++Builder ამ ტერიტორიის არამომგებიანობის გამო. იგეგმებოდა კომპანიის IDE სექტორის გაყიდვა. თავისუფალი პროგრამული უზრუნველყოფის მხარდამჭერთა ჯგუფმა მოაწყო ფონდის შეგროვება, რათა შეიძინონ უფლებები განვითარების გარემოზე და შემდგენელზე Borland-ისგან. თუმცა, იმავე წლის ნოემბერში, გადაწყდა, რომ უარი ეთქვათ IDE ბიზნესის გაყიდვაზე.

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

2007 წლის მარტში CodeGear-მა მომხმარებლები გაახარა Delphi 2007-ის განახლებული ხაზით Win32 პროდუქტებისთვის და სრულიად ახალი პროდუქტის გამოშვებით, Delphi 2007 PHP-სთვის.

2008 წლის 25 აგვისტოს Embarcadero-მ, CodeGear-ის ახალმა მფლობელმა, გამოაქვეყნა პრესრელიზი Delphi-ზე Win32 2009-ისთვის. ამ ვერსიამ მრავალი ინოვაცია შემოიტანა ენის დონეზე:

ნაგულისხმევად, სრული Unicode მხარდაჭერა ენის ყველა ნაწილში, VCL და RTL;
ზარების ჩანაცვლება ყველა Windows API ფუნქციის Unicode ანალოგებით (ანუ MessageBox უწოდებს MessageBoxW-ს და არა MessageBoxA-ს).
განზოგადებული ტიპები, ასევე ცნობილია როგორც გენერიკა.
ანონიმური მეთოდები.
ახალი $POINTERMATH შემდგენელი დირექტივა.
Exit ფუნქციას ახლა შეუძლია მიიღოს პარამეტრები ფუნქციის ტიპის მიხედვით.

Delphi XE2 ვერსიაში (2011) დაემატა Win64 კომპილატორი და ჯვარედინი კომპილაცია Apple ოპერაციული სისტემებისთვის (MacOS X, iOS).

ვსევოლოდ ლეონოვმა, რუსი დელფის ევანგელისტი Embarcadero Technologies-დან, თავის ინტერვიუში შემდეგი ვერსიის შესახებ ისაუბრა:

Delphi XE3 არის ახალი თაობის სწრაფი განვითარების ინსტრუმენტების გაგრძელება Delphi ოჯახისგან. შეგახსენებთ, რომ 2011 წელს Delphi XE2 გამოვიდა FireMonkey პლატფორმით, რომელიც VCL ვიზუალური კომპონენტის ბიბლიოთეკის ალტერნატივაა.

ის ძალიან ჰგავს VCL-ს მისი გამოყენების მეთოდებითა და კომპონენტებით (ღილაკები, ეტიკეტები, შეყვანის ველები, მენიუები და ა.შ.), მაგრამ აქვს სხვა ოპერაციულ სისტემაში პორტირების შესაძლებლობა. FireMonkey არის ჯვარედინი პლატფორმა. FireMonkey-ით შექმნილ აპლიკაციებს შეუძლია შედგეს როგორც Windows, ასევე Mac OS-ში. თითქმის ერთი ან ორი „დაწკაპუნებით“ ჩვენ შეგვიძლია აღვადგინოთ პროექტი სრულიად განსხვავებული ოპერაციული სისტემისთვის. თითქმის ყველა დემო პროექტს, რომელიც მოყვება Delphi-ს FireMonkey პლატფორმაზე, აქვს ორი ვერსია: ერთი Windows-ისთვის და ერთი Mac OS-ისთვის. და ამისათვის თქვენ არ გჭირდებათ ცვლილებების შეტანა აპლიკაციის წყაროს კოდში

2013 წელს გამოშვებული Delphi XE5 ვერსია უზრუნველყოფდა ARM/Android პლატფორმაზე მოწყობილობებისთვის აპლიკაციების ჯვარედინი კომპილაციას.

Delphi 10.1 berlin გამოვიდა 2016 წლის აპრილში. ინოვაციები:

• Object Pascal შემდგენელი და ხელსაწყოების ნაკრები 64-ბიტიანი iOS-ისთვის;
• უნივერსალური iOS აპლიკაციების მხარდაჭერა (აპლიკაციის პაკეტში 32-ბიტიანი და 64-ბიტიანი ორობითი ფაილების ჩათვლით);
• FireUI გადახედვა მობილურ პლატფორმებზე;
• გადახედვა სხვადასხვა მოწყობილობებზე;
• გაფართოებული შესაძლებლობები Unified Interface Designer-ში სტილებთან მუშაობისთვის, მათ შორის უნივერსალური სტილები და Windows სტილის მორგება;
• FireUI Device Manager საშუალებას გაძლევთ შეცვალოთ ხელმისაწვდომი მოწყობილობების სპეციფიკაციები და დაამატოთ ახალი მოწყობილობები;
• Memo, ListView, Calendar, Switch კონტროლი iOS პლატფორმისთვის;
• MapView კომპონენტი მობილური პლატფორმებისთვის (iOS და Android), რომელიც მხარს უჭერს სპეციალიზებულ ინტერაქტიული რუქების ბიბლიოთეკებს თითოეული პლატფორმისთვის (შემუშავებული Apple-ისა და Google-ის მიერ, შესაბამისად).

არც ცოცხალი და არც მკვდარი

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

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

ვსევოლოდ ლეონოვი ეთანხმება ამას:

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

ფუნდამენტური პროგრამირების კურსები მთელმა ფაკულტეტმა „გაფრინდა“. და Turbo Pascal-ის არსებობამ დაბალი შესვლის ბარიერით, შემდეგ კი დელფის გარემომ, რომელიც საშუალებას გაძლევთ ჩაერთოთ თვითგანათლებით ამ სიტყვის კარგი გაგებით, შეძლეს გაჯერებულიყო IT ინდუსტრია საკმარისად კომპეტენტური დეველოპერებით, ასევე აპლიკაციის პროგრამული უზრუნველყოფის შექმნის ქვეყნის მასშტაბით საინჟინრო დონის გაზრდა.

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

ახალი გმირი ღია წყაროდან

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

FreePascal-ის საფუძველზე შეიქმნა უფასო მრავალპლატფორმული IDE Lazarus, რომელიც საშუალებას გაძლევთ იმუშაოთ დელფის პროექტებთან. იგი ეფუძნება ვიზუალური კომპონენტების ლაზარეს კომპონენტ ბიბლიოთეკას (LCL).

დეკლარირებული მხარდაჭერილი პლატფორმების სია:

Windows: 98, 2k, XP, Vista, 7, 32 და 64 ბიტიანი;
FreeBSD/Linux: gtk 2.8 და qt4.5, 32 და 64bit;
Mac OS X: 10.4, LCL 32bit მხოლოდ, არასამთავრობო LCL შეიძლება იყოს 64bit.

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

ასე რომ, ამ სტატიაში ვისაუბრებთ იმაზე, თუ როგორ უნდა განვსაზღვროთ Windows ოპერაციული სისტემის ბიტიურობა Delphi-ში პროგრამირებისას. ეს აუცილებელია იმისათვის, რომ, მაგალითად, აირჩიოთ დრაივერის ერთი ან სხვა ვერსია - x86 (32 ბიტი) ან x64 (64 ბიტი).

მაშ ასე, დავიწყოთ.

მოდით შევქმნათ ახალი პროექტი და დავამატოთ Label კომპონენტი ფორმაში.

შემდეგ გადავდივართ წყაროს კოდის რედაქტორში და var ცვლადების მქონე განყოფილებაში დავამატებთ razr string ცვლადი (string data type, e.e. string).

var Form1: TForm1;

razr: სიმებიანი;

ამის შემდეგ, ორჯერ დააწკაპუნეთ ფორმაზე, დააკოპირეთ და ჩასვით მასში შემდეგი კოდი (მთავარი ფორმის TForm1.FormCreate შექმნის პროცედურაში), ფრაზებს შორის იწყება და დასასრული; (ანუ პროცედურის დასაწყისი და დასასრული).

(Get Environment Variable ფუნქციის გამოყენებით ჩვენ ვკითხულობთ ProgramFiles(X86) ცვლადის მნიშვნელობას

თუ სისტემა 32-ბიტიანია, მაშინ მას ექნება ცარიელი მნიშვნელობა

თუ 64-ბიტიანი, მაშინ მას ექნება ცოდნა C:Program Files(x86)

ანუ საქაღალდე, რომელშიც დაინსტალირებულია პროგრამების 32-ბიტიანი ვერსიები)

razr:= GetEnvironmentVariable("ProgramFiles(x86)");

label1.Caption:= razr;

თუ (razr = "") მაშინ

დაიწყოს

label1.Font.Color:=clRed; (ცვლის წარწერის ფერს, შეგიძლიათ აირჩიოთ ნებისმიერი თქვენი გემოვნებით, მაგალითად clGreen - მწვანე)

label1.Caption:= "თქვენ გაქვთ x86"; (ლეიბლის სახელის ნაცვლად labl1 შეგიძლიათ დაწეროთ სხვა რამ, მაგალითად metka)

სხვა

დაიწყოს

label1.Font.Color:=clBlue; (ცვლის წარწერის ფერს, შეგიძლიათ აირჩიოთ ნებისმიერი თქვენი გემოვნებით, მაგალითად clGreen - მწვანე)

label1.Caption:= "თქვენ გაქვთ x64";

დასასრული;

როგორ მუშაობს პროგრამა?

Get Environment Variable ფუნქცია კითხულობს გარემოს ცვლადის მნიშვნელობას Windows-ში ProgramFiles (X86).

თუ სისტემა 32-ბიტიანია, მაშინ მას ექნება ცარიელი მნიშვნელობა.

თუ ის 64-ბიტიანია, მაშინ მას ექნება ცოდნა C:Program Files(x86), ანუ ეს არის საქაღალდე, რომელშიც დაინსტალირებულია პროგრამების 32-ბიტიანი ვერსიები.

სინამდვილეში, ეს ყველაფერია.

აი რა დამემართა.

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

კომენტარები ()

wdfm 90

პროგრამა კარგად მუშაობს Windows 7 x64-ზე, შეგიძლიათ გამოიყენოთ იგი

ედვარდ 300

ვინც დაიწყებს ოფტოპიკს + უცენზურო ენას 1 დღით აეკრძალება! ეს არ ეხება ადმინისტრატორებს.
.php?board=18.0

ტყუილად არ შემიქმნია ეს ფორუმი!

ედვარდ 300

შესავალი

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

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

დელფის ძირითადი ცნებები და განმარტებები

დელფის პროგრამის მასივი ვიზუალური

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

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

ფორმის ფანჯარა, მისი სათაური FORM1, წარმოადგენს შაბლონს, განლაგებას პროგრამის ერთ-ერთი ობიექტის შემუშავებაში.

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

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

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

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

მოვლენა არის ის, რაც ხდება თქვენ მიერ შექმნილი აპლიკაციის მუშაობის დროს. Delphi-ში თითოეულ მოვლენას აქვს სახელი, მაგალითად, მაუსის დაწკაპუნება არის OnClick მოვლენა, ორმაგი დაწკაპუნება არის OnDblClick მოვლენა.

პროექტი არის ფაილების ერთობლიობა (პროგრამული ერთეულები - მოდულები), რომელთა გამოყენებით შემდგენელი ქმნის შესრულებადი პროგრამის ფაილს. პროექტის ერთ-ერთი ფაილი, რომელსაც ეწოდება პროექტის ფაილი და გაფართოებით dpr, შეიცავს პროექტის ზოგად აღწერას. პროექტის ფაილი არის აპლიკაციის მთავარი მოდული, რომელიც გენერირებულია Delphi-ის მიერ. გარდა ძირითადი მოდულისა, პროექტი მოიცავს ერთ ან მეტ მოდულს (Units). პროექტის მოდულის ფაილები (ერთეული) შეიცავს პროცედურების ტექსტებს, ფუნქციებს, ტიპების აღწერილობას, ასევე ყველა ინფორმაციას შესრულებადი პროგრამის შესაქმნელად და აქვს pas გაფართოება. პროცედურა არის ოპერატორების ჯგუფი პროგრამირების ენაზე, რომელიც საშუალებას გაძლევთ შეასრულოთ კონკრეტული მოქმედებები (პრობლემის გადაჭრა). ასეა თუ ისე, ყველა შესრულებადი კოდი, რომელიც თქვენ შეადგინეთ ინიციალიზაციისთვის, აუცილებლად მოთავსებულია რაიმე პროცედურაში.

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

unitModuleName;

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

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

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

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

(აქ არის მოდულის პროცედურების და ფუნქციების აღწერა)

(მოდულის ცვლადის ინიციალიზაციის განყოფილების ინსტრუქციები განთავსებულია აქ)

ამრიგად, ინტერფეისის განყოფილება ეუბნება შემდგენელს, მოდულის რომელი ნაწილია ხელმისაწვდომი სხვა პროგრამის მოდულებისთვის. განხორციელების განყოფილება იწყება დირექტივით ($R*.DFM), რომელიც ეუბნება შემდგენელს გამოიყენოს ფორმის აღწერა შესრულებადი ფაილის გენერირებისას. ფორმის აღწერა განთავსებულია ფაილში dfm გაფართოებით, რომლის სახელი ემთხვევა მოდულის სახელს. დირექტივას ($R*.DFM) მოჰყვება მოვლენის დამუშავების პროცედურები ფორმისა და მისი კომპონენტებისთვის. პროგრამისტს ასევე შეუძლია აქ განათავსოს შემუშავებული პროცედურები და ფუნქციები. თუ ინიციალიზაციის განყოფილება არ შეიცავს ინსტრუქციას, მაშინ სიტყვა დასაწყისი არ არის მითითებული.