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

გამარჯობა, ძვირფასო მკითხველებო! დღეს ჩვენ ვისაუბრებთ პროგრამირების სისტემაზე, რომელშიც "ჯადოსნობა" მოხდება. ჩვენთან ერთად თქვენ უკვე მოაგვარეთ 70-ზე მეტი (!) პრობლემა და ახლა დადგა დრო, რომ გადახვიდეთ PascalABC.Net-თან ურთიერთქმედების ახალ დონეზე.

მოკლე წინასიტყვაობა.

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

იმისათვის, რომ დააინსტალიროთ PascalABC.NET, უნდა გადახვიდეთ ვებსაიტზე.

ყველა კონვენცია შესრულებულია და ჩვენ ვიწყებთ!

PascalABC.NET-ის საწყისი დაყენება.

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

ჯერ გადავიდეთ Tools -> Settings.

გამოჩნდება მსგავსი ფანჯარა.

გახსენით "რედაქტორი" ჩანართი.

შეამოწმეთ ყუთები და აირჩიეთ შრიფტი.

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

გადადით "შემდგენელის ოფციები".

მოხსენით ველი "EXE ფაილის წაშლა" გვერდით.

რატომ ვტოვებთ EXE ფაილს? ეს არის კონსოლის აპლიკაციის ფაილი, რომლითაც თქვენ ან თქვენს მეგობარს შეგიძლიათ გაუშვათ პროგრამა CP-ის გახსნის გარეშე.

გახსენით Intellisense.

შეამოწმეთ ყუთები, როგორც ნაჩვენებია ეკრანის სურათზე.

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

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

პროგრამის აკრეფის გასაადვილებლად, PascalABC.NET გთავაზობთ ტექსტის შაბლონებს ( ფრაგმენტები). შაბლონის გამოსაძახებლად, აკრიფეთ რამდენიმე სპეციალური სიმბოლო და დააჭირეთ კლავიშებს Shift + სივრცე.

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

| ნიშნავს კურსორის პოზიციას შაბლონის ჩასმის შემდეგ

დასაწყისი | დასასრული;

დასაწყისი | დასასრული.

პროგრამა ; დაწყება | დასასრული.

კიდევ ერთი ახალი უნარი! ახლა თქვენ არ დაგავიწყდებათ ცვლადის ტიპი.

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

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

// პროგრამის დაწყება. var i: მთელი რიცხვი; მე:= 3; i += 1; (i = 4 ) i *= 2; ( i = 8 ) // პროგრამის დასასრული.

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

მიღებული ცოდნის გამოყენებით გადავჭრათ მნიშვნელობების გაცვლის პრობლემა.

პროგრამის გაცვლა; var x, y: რეალური; start write ("შეიყვანეთ x, y: "); readln(x, y); var tmp: რეალური:= x; //შეიყვანეთ ახალი ცვლადი და დაუყოვნებლივ შეიყვანეთ მისი მნიშვნელობა. x:= y; y:= tmp; writeln(x," ", y); დასასრული.

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

პროგრამის მაგალითი; var n:= 2; // მთელი ცვლადი x:= 3.14; // რეალური ტიპის ცვლადი begin var c:= "q"; // სიმბოლოს ტიპის ცვლადი var s:= "Pascal"; // სტრიქონის ტიპის ცვლადი var b:= True; // ლოგიკური ტიპის ცვლადი var r:= x; // იგივე ტიპის ცვლადი, როგორც x ბოლო.

ყველა!

გამოიწერეთ ჩვენი ვებ-გვერდი და არ დაგავიწყდეთ ღილაკებზე დაჭერა!

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

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

პასკალ ABC გაკვეთილები

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

ჩვენ ვითვისებთ რედაქტორის ინტერფეისს და ვწერთ კოდის პირველ ხაზებს.

ჩვენ ვსწავლობთ რიცხვებთან მუშაობის ლოგიკას და ვამუშავებთ ტაიმერს.

ჩვენ ვსწავლობთ, თუ როგორ ადგენს პროგრამირების ენა წყაროს კოდს.

ჩვენ ვიყენებთ პასკალს სკოლის მოსწავლე ანას პრობლემის გადასაჭრელად.

ჩვენ ვაპროგრამებთ რეალურ ვირტუალურ მუსიკის სინთეზატორს.

ჩვენ ვითვისებთ რთულ მათემატიკურ ფუნქციებს და ვქმნით სრულფასოვან საინჟინრო კალკულატორს.

ჩვენ ვქმნით "სწორ" სატელეფონო წიგნს მონაცემთა ბაზის საფუძველზე.

გაკვეთილი 1 - პირველი პროგრამა
გაკვეთილი 2 - მარტივი რიცხვები
გაკვეთილი 3 - შემდგენელები (ნაწილი 1)
გაკვეთილი 3 - შემდგენელები (ნაწილი 2)
გაკვეთილი 4 - სასკოლო პრობლემის გადაჭრა
გაკვეთილი 5 - ფორტეპიანოს დამზადება
გაკვეთილი 6 - გაფართოებული კალკულატორი (ნაწილი 1)
გაკვეთილი 6 - გაფართოებული კალკულატორი (ნაწილი 2)
გაკვეთილი 7 - მოსახერხებელი სატელეფონო წიგნი (ნაწილი 1)
გაკვეთილი 7 - მოსახერხებელი სატელეფონო წიგნი (ნაწილი 2)
გაკვეთილი 7 - მოსახერხებელი სატელეფონო წიგნი (ნაწილი 3)
გაკვეთილი 7 - მოსახერხებელი სატელეფონო წიგნი (ნაწილი 4)
გაკვეთილი 8 - გრაფიკასთან მუშაობა. ნაწილაკების სისტემა (ნაწილი 1)
გაკვეთილი 8 - გრაფიკასთან მუშაობა. ნაწილაკების სისტემა (ნაწილი 2)
გაკვეთილი 8 - გრაფიკასთან მუშაობა. ნაწილაკების სისტემა (ნაწილი 3)
გაკვეთილი 8 - გრაფიკასთან მუშაობა. ნაწილაკების სისტემა (ნაწილი 4)

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

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

1. სამუშაოსთვის მზადება

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

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

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

2. დაწყება

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

დიდი და პატარა ლათინური ასოები: A...Z, a...z;
ციფრები: 0...9;
სპეციალური სიმბოლოები: + - * / =< >.,:; ' # () ( ) და მათი კომბინაციები: ">=" "

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

პროგრამის სტრუქტურა ასე გამოიყურება:

პროგრამა "პროგრამის სახელი"; - პროგრამის სათაური;
(შენიშვნა: ხაზის ბოლოს არის მძიმით, არა ყველა, მაგრამ უმეტესობა)
გამოყენება (ბიბლიოთეკის სახელი); აქ შედის ბიბლიოთეკები, რომლებიც უზრუნველყოფენ დამატებით შესაძლებლობებს პროგრამების შექმნისას;
ლეიბლი (ეტიკეტის სახელი); აქ, საჭიროების შემთხვევაში, იწერება ეტიკეტები, რომლებიც საშუალებას გაძლევთ გადახვიდეთ პროგრამის სხვადასხვა ადგილებში (დაწვრილებით მათ შესახებ მოგვიანებით);
Const აქ მივუთითებთ მუდმივი მნიშვნელობის მქონე ცვლადებს, მაგალითად, p=3.14;
Var აქ ჩამოვთვლით ყველა ცვლადებს, რომლებიც გამოყოფილია მძიმეებით, შემდეგ კი მივუთითებთ მონაცემთა ტიპს (მაგალითი: Var: K, L, M: მთელი რიცხვი; N, O: რეალური; (თუ არსებობს რამდენიმე ტიპი));
დასაწყისი (აქ მძიმით არ არის)
შემდეგ მოდის პროგრამის მთავარი ბლოკი;
დასასრული. – პროგრამის დასასრული („დასრულების“ შემდეგ საჭიროა წერტილი, თუ ეს არ არის პროგრამის დასასრული და არა ოპერატორის ფრჩხილები).

3. პირველი პროგრამების შექმნა

თქვენ ახლა გაეცანით პროგრამის ძირითად სტრუქტურას. აღსანიშნავია, რომ ზემოაღნიშნული სექციებიდან მხოლოდ „Var“, „Begin“ და „End“ არის სავალდებულო, ხოლო დანარჩენის გამოყენება შესაძლებელია დავალების შესრულებისას საჭიროების შემთხვევაში.

გახსენით თქვენი შემდგენლის ფანჯარა და შეიყვანეთ შემდეგი სტრიქონები:

პროგრამა Programma1;
დაიწყოს
დასასრული.

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

პროგრამა Programma1;
დაიწყოს
ჩაწერეთ ("პასკალი");
დასასრული.

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

3.1. ოპერატორები წერენ, წერენ, კითხულობენ, კითხულობენ

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

პროგრამა Programma1;
var A: მთელი რიცხვი;
დაიწყოს
writeln("A="); წაკითხვა (A); (შეიყვანეთ მნიშვნელობა და „მიამაგრეთ“ ის ცვლად A-ს)
დაწერე); (გამოიტანეთ A ცვლადის მნიშვნელობა)
დასასრული.

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

პროგრამა Programma1;
var A: მთელი რიცხვი;
დაიწყოს
readln(A);
write("A=", A); (ხაზი ასე გამოიყურება: "A = "შეყვანილი მნიშვნელობა A" ")
დასასრული.

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

3.2. მონაცემთა ტიპები პასკალში

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

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

მთელი რიცხვის მონაცემთა ტიპები (მთლიანი რიცხვებისთვის):
- ბაიტი
ამ ტიპის მნიშვნელობების შენახვის მოცულობა არის 1 ბაიტი. ამ ტიპის მნიშვნელობების დიაპაზონი არის 0-დან 255-მდე.
- სიტყვა
ამ ტიპის მნიშვნელობები უკვე იკავებს მეხსიერების 2 ბაიტს, ხოლო მნიშვნელობების დიაპაზონი უკვე უფრო დიდია: 0-დან 65535-მდე.
- მთელი რიცხვი (ჩვენთვის უკვე ნაცნობი)
მნიშვნელობები ასევე იკავებს მეხსიერების 2 ბაიტს, დიაპაზონი იგივე ზომისაა, მაგრამ ასევე შეიცავს უარყოფით რიცხვებს: -32786...32787.
- ლონგინტი
მეხსიერების რაოდენობა, რომელიც დაკავებულია ტიპის მნიშვნელობით არის 4 ბაიტი. მნიშვნელობების დიაპაზონი სრულად შეესაბამება მონაცემთა ტიპის სახელს: -2147483648-დან 2147483647-მდე
-მოკლეInt
ტიპის მნიშვნელობა მოიხმარს მეხსიერების 1 ბაიტს, დიაპაზონი შედარებით მცირეა: -128…127.

მონაცემთა რეალური ტიპები (წილადი ნაწილის მქონე რიცხვებისთვის):
- რეალური
დაკავებულია ტიპის მნიშვნელობით – 6 ბაიტი. მნიშვნელოვანი ფიგურების რაოდენობაა 11-12. (მნიშვნელოვანი ფიგურები ზუსტი ფიგურებია, ანუ არ არის მომრგვალებული). ტიპის მნიშვნელობის დიაპაზონი: 2.9*10-39-დან 1.7*1038-მდე.
-Ორმაგი
ტიპის მნიშვნელობის ზომაა 8 ბაიტი. მნიშვნელოვანი ფიგურების რაოდენობაა 15-16. დიაპაზონი: 5.0*10324…1.7*10308.
- გაგრძელდა
იკავებს 10 ბაიტს. მნიშვნელოვანი ფიგურების რაოდენობაა 19-20. დიაპაზონი: 3.4*10-4932…1.1*104932.
გარდა ამისა, არსებობს ასევე სიმბოლოს მონაცემთა ტიპი (char) და თუნდაც ლოგიკური მონაცემთა ტიპი (ლოგიკური), რომლის ცვლადებს შეუძლიათ მიიღონ მხოლოდ მნიშვნელობები "true" ან "false".

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

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

ჩვენ უკვე ვისწავლეთ პროგრამაში მონაცემების შეყვანა, ახლა ვცადოთ ვისწავლოთ მისი დამუშავება. პირველი და ყველაზე მნიშვნელოვანი რაც დაგვჭირდება ამ საკითხში არის დავალების ოპერატორი. ის ასე გამოიხატება: “:=”, და გამოიყენება ცვლადისთვის მნიშვნელობის მინიჭებისთვის. მაგალითები: A:=1,5; B:=2+A. ახლა, როდესაც ჩვენ ვიცნობთ დავალების ოპერატორს, შეგვიძლია გადავხედოთ პასკალის მათემატიკურ ოპერაციებს:

დამატება (+);
გამოკლება (-);
გამრავლება (*);
განყოფილება(/);
მთელი დაყოფა (div) – აბრუნებს გაყოფის მთელ ნაწილს (მაგალითი: 10 div 3 = 3);
გაყოფის დარჩენილი ნაწილი (მოდ) – აბრუნებს მხოლოდ გაყოფის ნარჩენს (მაგალითი: 5 mod 2 = 1);

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

Abs(x) – აბრუნებს x-ის მოდულს;
sin(x) – x კუთხის სინუსი (რადანებში);
cos(x) – x კუთხის კოსინუსი (რადანებში);
int(x) – აბრუნებს x-ის მთელ ნაწილს;
random(number) – შემთხვევითი რიცხვი 0-დან მოცემულ ერთამდე;
sqr(x) – კვადრატი x;
sqrt(x) – x-ის კვადრატული ფესვი;
inc(x) – x-ის გაზრდა 1-ით;
dec(x) – x-ის შემცირება 1-ით.

პირობები

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

თუ (პირობა 1) მაშინ (მოქმედება 1 - მთავარი) სხვა (მოქმედება 2 - ალტერნატივა)
(თუ - თუ, მაშინ - მაშინ, სხვა - სხვაგვარად)

პირობების აგებისას გამოიყენეთ ლოგიკური ოპერაციები და არა, ან, xor:

და არის ოპერანდი, რომელიც აერთიანებს რამდენიმე პირობას ერთში. მოქმედება შესრულდება მხოლოდ იმ შემთხვევაში, თუ ყველა ჩამოთვლილი პირობა შეესაბამება სიმართლეს.
პროგრამის პირობები;
var a: მთელი რიცხვი;
დაიწყოს
readln(a);
თუ (2*2=4) და (3+2=5) მაშინ a:=a+1 სხვა a:=a-1;
დაწერე);
დასასრული.

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

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

პროგრამის პირობები;
var b: მთელი რიცხვი;
დაიწყოს
readln(b);
თუ არა 5=4 მაშინ b:=b+1 სხვა b:=b-1;
ჩაწერე(ბ);
დასასრული.

პირობა 5=4 მცდარია, ამიტომ შესრულდება პირველი მოქმედება.

ან (ან) არის ლოგიკური ოპერატორი მრავალნაწილიანი პირობისთვის. მთავარი მოქმედება შესრულდება, თუ ერთი პირობა მაინც შეესაბამება სიმართლეს.
პროგრამის პირობები;
var d: მთელი რიცხვი;
დაიწყოს
readln(d);
თუ (5=4+1) ან (5=4) მაშინ d:=d+1 სხვა d:=d-1;
ჩაწერე(დ);
დასასრული.

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

Xor - ამ ოპერატორით, ძირითადი მოქმედება შესრულებულია, თუ მხოლოდ ერთი პირობაა ჭეშმარიტი. თუ ერთზე მეტი პირობა არის ჭეშმარიტი, ან არცერთი მათგანი არ არის ჭეშმარიტი, შესრულდება ალტერნატიული მოქმედება.

პროგრამის პირობები;
var n: მთელი რიცხვი;
დაიწყოს
readln(n);
თუ (6=4) xor (3=5-2) მაშინ n:=n+1 სხვა n:=n-1;
ჩაწერე(n);
დასასრული.

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

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

3.4. პროგრამის მართვის პროცედურები და ფუნქციები

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

პროგრამის მარკა;
ეტიკეტი 1,2;
var A, B: მთელი რიცხვი;
დაიწყოს
readln(A);
2: თუ A=5, მაშინ მივიღე 1; (2: - მოქმედება შესაბამის ეტიკეტზე გადასვლის შემდეგ,)
A:=A+1; (გადადით - გადადით ეტიკეტზე)
goto 2;
1: დაწერე (A);
დასასრული.

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

დაყოვნება (დრო) – შეაჩერეთ პროგრამა დაგვიანებით, ბრჭყალებში დრო მითითებულია მილიწამებში.
Readkey – აჩერებს პროგრამას კლავიშის დაჭერამდე, ფუნქციის მნიშვნელობა არის დაჭერილი კლავიშის კოდი.
გასვლა - პროცედურის ადრეული დასრულება.
გასათვალისწინებელია, რომ დაგვიანებისთვის, წაკითხვის ღილაკისთვის და მუშაობაში გასასვლელად, თქვენ უნდა დააკავშიროთ crt მოდული (გამოიყენებს crt-ს).

ასევე ნახეთ ვიდეო: პასკალი ნულიდან - პირველი პროგრამა.

4. დასკვნა

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

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

რაოდენობების სახეები

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

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

რიცხვითი, თავის მხრივ, იყოფა ორ ტიპად.

მე მაშინვე ვაძლევ ამ ტიპის აღნიშვნას პასკალში

პერსონაჟები ასევე იყოფა ორ ტიპად.

რაოდენობების მეორე კლასიფიკაცია.
მუდმივი - მნიშვნელობა უცვლელია. ცვლადი - მნიშვნელობა შეიძლება შეიცვალოს პროგრამის გაშვებისას. ცვლადები იდენტიფიცირებულია სიმბოლური სახელებით, რომლებსაც იდენტიფიკატორები ეწოდება. როგორ მივანიჭოთ მნიშვნელობა ცვლადს? დავალების ბრძანების გამოყენებით! დავალების ბრძანება პასკალში: < переменная >:= < выражение >

პირველი პროგრამა პასკალში

პროგრამის სტრუქტურა პასკალში

სათაური

პროგრამა< имя переменной >;

ცვლადების და მუდმივების გამოცხადება

კონსტ<Символическое имя> = <выражение>;
ვარ<Однотипные переменные> : <тип>;

ოპერატორების განყოფილება

დაწყება
<оператор 1>;
<оператор 2>;
…
დასასრული.

შეყვანა და გამომავალი პასკალში

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

Შესვლა:

წაკითხვა (ცვლადი)
readln (ცვლადი)

და გამომავალისთვის:

ჩაწერა (ტექსტი "ში")
writeln (ტექსტი "ში")

„რა განსხვავებაა წაკითხვასა და წაკითხვას, წერასა და ჩაწერას შორის?“: ისევ გაგიკვირდებათ. პასუხი მარტივია. თუ დაამატებთ „ln“-ს (რაც ნიშნავს Line-ს), კურსორი გადადის შემდეგ სტრიქონზე.

გამარჯობა, სამყარო პასკალში

ახლა თქვენ მზად ხართ დაწეროთ თქვენი პირველი პროგრამა.

პროგრამა Hello_World; (ხუჭუჭა ციტატები საშუალებას გაძლევთ ჩაწეროთ კომენტარი კოდზე) Begin Write("Hello, World!"); Დასასრული.

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

პრობლემა 1. საჭიროა მომხმარებლის სახელის მოთხოვნა და შემდეგ "Hi,<имя>!» ამ პრობლემის გადასაჭრელად, ჩვენ გვჭირდება სტრიქონის მონაცემთა ტიპი - string.

პროგრამა გამარჯობა_ბიჭი_გოგო; (curly quotes გაძლევთ საშუალებას ჩაწეროთ კომენტარი კოდში) var name: string; (ჩვენ ვაცხადებთ, რომ სახელი არის ახალი ცვლადი) Begin Write("Enter your name:"); (რადგან ჩვენ ვიყენებთ ჩაწერას, კურსორი ციმციმდება ორწერტილის შემდეგ) Read(name); (ჩვენ ვკითხულობთ ყველაფერს, რაც მომხმარებელმა შეიყვანა) Write("გამარჯობა", სახელი,"!"); (გთხოვთ გაითვალისწინოთ! ცვლადი გამოყოფილია ბრჭყალებისგან COMMA-ით End. !}

დავალება 2.თქვენ უნდა გაარკვიოთ რამდენი წლისაა მომხმარებელი და შემდეგ აჩვენოთ „თქვენ<возраст>წლები“.ცხადია, ამ პრობლემის გადასაჭრელად ჩვენ გვჭირდება მონაცემთა მთელი ტიპი - მთელი.

პროგრამა რამდენი წლის ხარ; var წლები: მთელი რიცხვი; (გამოაცხადე წელი ახალი ცვლადია) Begin Writeln("რამდენი წლის ხარ?"); (რადგან ჩვენ ვიყენებთ writeln-ს, კარტა ციმციმდება წარწერის ქვეშ) წაკითხული (წლები); (ჩვენ ვკითხულობთ ყველაფერს, რაც მომხმარებელმა შეიყვანა) Write("თქვენ ხართ ", წლის," წლის."); Დასასრული.

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

P.S. მოდით გამოვყოთ პასკალის ორი თვისება:

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

P.P.S. მსოფლიოში სამი ყველაზე პოპულარული ოპერაციული სისტემაა: Linux, Mac OS და Windows. რა მოხდება, თუ Windows არ გაქვთ? რომელი კომპილერი ავირჩიო მაშინ? ამაზე ვისაუბრებთ გაკვეთილზე N.

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

ალგორითმული ენა: ძირითადი ცნებები

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

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

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

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

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

პასკალური ენა

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

26 ლათინური კაპიტალი და ;
ხაზგასმა;
ათი ციფრი;
შემზღუდველები;
ოპერაციის ნიშნები;
სპეციფიკატორები;
სისტემური რეზერვირებული (მომსახურების) სიტყვები.

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

დაწყებითი ენის სტრუქტურები

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

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

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

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

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

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

ალგორითმული ენის სინტაქსი

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

მძიმით (;) არის პირობითი სიგნალი, რომელიც მიუთითებს მიმდინარე ხაზის დასასრულს და ახალზე გადასვლის აუცილებლობას. მაგრამ გამონაკლისი შეიძლება იყოს სერვისის ბრძანებები: const, var, start და სხვა.

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

ცვლადისთვის კონკრეტული მნიშვნელობის მინიჭებისთვის, თქვენ უნდა მოათავსოთ ორწერტილი ტოლობის ნიშნის წინ. მაგალითად, გსურთ დააყენოთ n=13, მაგრამ კოდში ის ასე გამოიყურება n:=13.

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

კლასიკური პასკალის ოპერატორები

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

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

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

დავალების ოპერატორი

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

რთული ოპერატორები

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

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

პროგრამირების ენის პირობითი ოპერატორი

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

სტრუქტურულად ასე გამოიყურება:

თუ<условие>მაშინ<оператор1>სხვა<оператор2>.

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

პროგრამის კოდის სტრუქტურა

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

სათაური ჩვეულებრივ შეიცავს კოდის სახელს. მაგალითად, პროგრამა MyFirst.

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

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

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

მუდმივების ნაადრევი აღწერა საშუალებას გაძლევთ დაწეროთ მათი სახელები მოგვიანებით კოდში რიცხვითი ან ანბანური მნიშვნელობების ნაცვლად.

გამოყენებული ცვლადების აღწერის განყოფილებაში უნდა მიუთითოთ ყველა ტიპი, რომელიც გამოყენებული იქნება: "var c,a,r: მთელი რიცხვი; k,l, m: char; h1,h2: ლოგიკური;".

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

კოდის ტექსტი უნდა დასრულდეს წერტილით.

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

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

მოდით, აპლიკაციამ გამოაჩინოს ფრაზა "ეს ჩემი პირველი პროგრამაა!"

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

დაწყება
Writeln (ეს ჩემი პირველი პროგრამაა!");
Დასასრული.

ეს ასე მარტივია!

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

ვიმედოვნებთ, რომ თქვენთვის სასარგებლო აღმოჩნდა.