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

ახალი პროგრამის დაწერის პირველი სესია.

ამ შემთხვევაში, თქვენ უნდა შეხვიდეთ მთავარ მენიუში (F10), აირჩიოთ პუნქტი "ფაილი", დააჭირეთ "Enter", შემდეგ ქვემენიუში აირჩიეთ სიტყვა "ახალი", დააჭირეთ "Enter". ამ შემთხვევაში შედგენილ პროგრამას ავტომატურად მიენიჭება სახელწოდება "NONAME.PAS", რომელიც მონიშნული იქნება EDIT ფანჯრის ზედა მარჯვენა კუთხეში. პროგრამის სხვა სახელის მისაცემად, თქვენ უნდა აირჩიოთ ქვეპუნქტი „ჩაწერა“ მთავარი მენიუს „ფაილი“ პუნქტში და გამოსულ ფანჯარაში შეიყვანეთ სასურველი პროგრამის სახელი, მიუთითეთ დისკის სახელი და, საჭიროების შემთხვევაში. , დირექტორიას სახელი. ზემოაღნიშნულის დასრულების შემდეგ, თქვენ უნდა დააჭიროთ "Enter", რის შემდეგაც გაირკვევა EDIT ფანჯარა, მითითებული პროგრამის სახელი გამოჩნდება ფანჯრის ზედა მარჯვენა კუთხეში და კურსორი ციმციმებს ზედა მარცხენა კუთხეში და გიწვევთ შეიყვანეთ ახალი პროგრამის ტექსტი კლავიატურიდან.

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

პროგრამების ზოგადი სტრუქტურა პასკალში:

პროგრამის დასახელება პროგრამის აღწერა განყოფილება დასაწყისი განცხადების განყოფილება დასასრული.

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

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

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

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

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

პროგრამის პროგრამის სახელი;

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

ჩვენი პროგრამის მეორე ხაზი შეიცავს განყოფილებას მუდმივების განსაზღვრისთვის. მასში ჩამოთვლილია პროგრამაში გამოყენებული მუდმივები და მათი მნიშვნელობები. სიტყვა "CONST" ნიშნავს, რომ მას დაუყოვნებლივ მოჰყვება ერთი ან მეტი მუდმივის განმარტება. „მუდმივის განსაზღვრა“ ნიშნავს მისი სახელის და მნიშვნელობის მითითებას, რომელიც არ შეიცვლება პროგრამის განმავლობაში. მუდმივი განისაზღვრება შემდეგნაირად:

Const მუდმივი სახელი=მნიშვნელობა;

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

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

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

Var ცვლადის სახელი: ცვლადის ტიპი;

Turbo Pascal-ში ცვლადის სახელი უნდა იწყებოდეს ლათინური ასოებით, შედგებოდეს ლათინური ასოებისგან, რიცხვებისგან ან ხაზგასმით "_". სახელი უნდა შედგებოდეს არაუმეტეს 63 სიმბოლოსგან (შემდგენელი არ იღებს მეტს). თქვენ არ შეგიძლიათ გამოიყენოთ სივრცე ცვლადის სახელში.

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

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

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

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

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

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

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

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

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

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

სათაური

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

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

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

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

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

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

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

Შესვლა:

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

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

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

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

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

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

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

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

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

პროგრამა გამარჯობა_ბიჭი_გოგო; (curly ბრჭყალები გაძლევთ საშუალებას ჩაწეროთ კომენტარი კოდში) 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. მოდით გამოვყოთ პასკალის ორი თვისება:

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

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

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

ხშირად პასკალში პროგრამების დასაწერად იყენებენ Turbo Pascal-ს.

რატომ უნდა აირჩიონ დამწყებთათვის ეს ენა? შევეცადოთ გავერკვეთ. იმისათვის, რომ სრულად დაეუფლოთ რომელიმე პროგრამირების ენას, უნდა გქონდეთ შესაბამისი ლიტერატურა. ამიტომ ენების უმეტესობა მაშინვე ქრება, კერძოდ ლოგო. ის არ არის გავრცელებული რუსულენოვან ქვეყნებში, ამიტომ მასზე არ არსებობს სასწავლო წიგნები. ამ მომენტში ყველაზე ცნობილია Pascal, Java, Basic და C. მოდით განვიხილოთ თითოეული ცალკე. Java ძირითადად გამოიყენება ვებ პროგრამირებისთვის. C არის ერთ-ერთი ყველაზე გავრცელებული, მაგრამ ასევე ყველაზე რთული ენა (განსაკუთრებით დამწყებთათვის). იმისათვის, რომ საბოლოოდ ისწავლოთ მასში პროგრამების დაწერა, უმჯობესია ჯერ დაეუფლოთ Pascal-ს ან Basic-ს. ორივეს სწავლობენ სკოლებში (მასწავლებლის არჩევანით). მათი გავრცელების მიზეზი მდგომარეობს იმაში, რომ ამ ენებზე შეგიძლიათ დაწეროთ იგივე პროგრამა, როგორც C ან C++-ში, მაგრამ მისი ათვისება ბევრად უფრო ადვილია მისი კონსტრუქციის სიმარტივის გამო.

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

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

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

იმისათვის, რომ გაიგოთ, როგორ მუშაობს ეს ენა, თქვენ უნდა დაწეროთ პატარა „დავალება“. ვთქვათ, თქვენ უნდა შექმნათ პროგრამა, რომელიც დაამატებს ორ რიცხვს: Q+W=E. რა უნდა გაკეთდეს მის შესაქმნელად?

ასო E იმოქმედებს როგორც ცვლადი (მათემატიკაში - x). აუცილებლად მიუთითეთ სახელი (არაუმეტეს 250 სიმბოლო). ის შეიძლება შედგებოდეს:

• ასოები (A..Z);
• რიცხვები 0-დან 9-მდე. მაგრამ გახსოვდეთ, რომ სახელი არ უნდა იწყებოდეს რიცხვით;
• სიმბოლო "_".

სათაური არ უნდა შეიცავდეს:

• რუსული ასოები;
• სასვენი ნიშნები;
• სპეციალისტი. სიმბოლოები, როგორიცაა ჰეში "#", პროცენტი "%", დოლარი "$", ტილდი "~" და ა.შ.

სწორი სახელის მაგალითი იქნება "red_velvet4", "exo" ან "shi_nee". ასევე უნდა გვახსოვდეს, რომ პასკალი არ არის რეგისტრირებული, ამიტომ ცვლადები სახელად "btob" და "BtoB" განიხილება, როგორც ერთი. როგორ ხდება უჯრედების „დაწყება“ და დასახელება პროგრამირების გარემოში, ქვემოთ იქნება ნათელი. ამ პროცესის შემდეგ საჭიროა ცვლადის ტიპის დადგენა. ეს აუცილებელია იმისათვის, რომ პროგრამამ შედეგი სწორად აჩვენოს ეკრანზე ან დაბეჭდოს იგი ქაღალდზე. მაგალითად, თუ ორი რიცხვი დაემატება, მაშინ მითითებულია რიცხვითი ტიპი, ხოლო თუ გამოსახულია მისალმება, მაშინ მითითებულია სტრიქონის ტიპი. ორი რიცხვის ჩვეულებრივი მიმატებისთვის შესაფერისია ტიპი მთელი რიცხვი („რიცხვი“).

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

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

პროგრამა shi_nee;

Var Q, W, E: მთელი რიცხვი;

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

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

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

ენის სინტაქსი

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

იმისათვის, რომ მივანიჭოთ უჯრედს მისი მნიშვნელობა, მაგალითად, E=15, თქვენ უნდა მოათავსოთ ორწერტილი ტოლობის ნიშნის წინ:

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

ტესტირება

Turbo Pascal-ის გაშვების შემდეგ, თქვენ უნდა დაბეჭდოთ პროგრამა, სწორად მოაწყოთ საჭირო სიმბოლოები და დააყენოთ სასურველი ხაზის რიგი. პროგრამის გაშვება შესაძლებელია Ctrl+F9 კლავიშების მეშვეობით ან გამოყენებით. თუ ყველაფერი სწორად არის შეყვანილი, ეკრანი ოდნავ ციმციმდება. თუ შეცდომაა, პროგრამა შეჩერდება და კურსორი განთავსდება იმ ხაზზე, სადაც ის არსებობს. ამ შემთხვევაში, თავად შეცდომის აღწერა გამოჩნდება "გამომავალი" სტრიქონში, მაგალითად, შეცდომა 85: ";" განდევნილი. ეს ხაზი მიუთითებს, რომ მძიმით სადღაც აკლია. თუმცა, თქვენ ჯერ არ უნდა მიაქციოთ ყურადღება ასეთ პრობლემებს, თქვენ უნდა გაიგოთ სტრუქტურა პასკალის მაგალითების გამოყენებით.

რა უნდა ისწავლო პირველ რიგში?

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

ერთგანზომილებიანი მასივები

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

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

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

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

Var a: მასივი char;

i:=5-დან 40-მდე წაკითხვა (ch[i]);

i:=5-დან 40-მდე ჩაწერეთ (ch[i]:3);

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

ორგანზომილებიანი მასივები

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

ასეთი მონაცემები პასკალის ენაზე (მაგალითები შეგიძლიათ იხილოთ ქვემოთ) აღწერილია ორი გზით: „ტიპის მასივი“ ან „ტიპის მასივი“.

ცვლადები b და f მუდმივებია. ამის ნაცვლად შეგიძლიათ რიცხვების ჩასმაც (როგორც ერთგანზომილებიან მასივებში), მაგრამ ასეთ პრობლემებში უმჯობესია არ ივარჯიშოთ ეს. ეს იმიტომ ხდება, რომ პროგრამირების ენა განსაზღვრავს პირველ მუდმივობას, როგორც რიგების რაოდენობას, ხოლო მეორეს, როგორც მოცემული მასივის სვეტების რაოდენობას.

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

Const b=24; f=13;

ტიპი cherry=რეალის მასივი;

გარკვეულწილად ადვილია მასივის აღწერა ცვლადების განყოფილების მეშვეობით (დამწყებთათვის):

Const b=24; f=13;

Var n: უძრავის მასივი;

ორივე ვარიანტი იქნება სწორი;

გახსენით მასივები

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

Seulgi1: მასივი char;

Yeri: უძრავის მასივი;

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

გრაფიკა პასკალში

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

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

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

როგორც წესი, გრაფიკული მონაცემების აღწერისას, ეს პროცედურა გამოიყენება:

InitGraph(var driver, choke: real; Path: string);

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

მოდით შევხედოთ პროგრამის მარტივ მაგალითს Pascal ABC.NET-ში. თავიდან ვფიქრობდი უფრო რთული მაგალითის მოყვანას, მაგრამ მივხვდი, რომ ამის ახსნას ძალიან დიდი დრო დასჭირდებოდა, ამიტომ ჩვენ გადავხედავთ სტანდარტულ მაგალითს "Hello World!".

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

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

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

ასეთი კოდის ერთადერთი შეზღუდვა (ერთ სტრიქონში) არის სივრცეების არსებობა ბრძანებებს შორის (ამ მაგალითში, სივრცე start და writeln-ს შორის) და სივრცე ახალ ხაზსა და ";"-ით დასრულებულ ხაზს შორის. არ არის საჭირო. ანუ, ვთქვათ შემდეგი კოდი:

პროგრამა pascal;დაიწყება წერა ("Pascal ABC.NET"); დასასრული.

ასევე, პასკალი უგულებელყოფს განსხვავებას მცირე და დიდ ასოებს შორის (მომავალში, თუ თქვენ გამოაცხადებთ ცვლადს a, მაშინ ასევე შეგიძლიათ მოიხსენიოთ როგორც A), როგორც ზოგიერთ პროგრამირების ენაში (მაგრამ ეს ასე არ არის ALL-ში. !). ანუ კოდი

პროგრამა პასკალი; BEGIN WRITELN ("Pascal ABC.NET"); ᲓᲐᲡᲐᲡᲠᲣᲚᲘ.

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

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

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

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

პროგრამა პასკალი; const my_text="Pascal ABC.NET"; წერის დაწყება (ჩემი_ტექსტი); დასასრული.

აქ, აღწერის განყოფილებაში, მე შევქმენი ცვლადი მუდმივი მნიშვნელობით (მუდმივი) სიტყვის "const" გამოყენებით, რასაც მოჰყვება ერთი ან მეტი მუდმივის აღწერა. პროგრამირების ენაზე მუდმივის აღწერის შემდეგ, შეგიძლიათ გამოიყენოთ მისი მნიშვნელობა სადმე (პროგრამის ფარგლებში), მაგრამ ვერ შეძლებთ მისი მნიშვნელობის შეცვლას. ზოგიერთ შემთხვევაში ეს ძალიან მოსახერხებელია. მაგალითად, Pi-ს მნიშვნელობა უდრის 3.14-ს... ცხადია, მისი გამოყენება ძალიან მოსახერხებელია ნებისმიერი გეომეტრიული ფორმულის გამოთვლისას. და ეს მნიშვნელობა იგივე უნდა იყოს გარე ფაქტორების მიუხედავად (ქვეყანა, სადაც ცხოვრობთ; წელიწადის დრო; დღის დრო...). ამ მუდმივის მნიშვნელობის შეცვლით, თქვენ მიიღებთ არასწორ მნიშვნელობებს გეომეტრიულ ფორმულებში. და ეს არასწორია. სწორედ ამიტომ გამოიგონეს მუდმივები პროგრამირების ენებში. ისინი უნდა იყოს აღწერილი აღწერილობის განყოფილებაში და გამოყენებული იყოს თქვენს კოდში. ამ შემთხვევაში, მზა პროგრამის აწყობისას, ყველგან ამ მუდმივის სახელის ნაცვლად მისი მნიშვნელობა შეიცვლება. შეიძლება ფიქრობთ, რომ სისულელეა ყველგან მოცემული მუდმივის სახელის დაწერა, თუ ის მაინც შეიცვლება მისი მნიშვნელობით. უფრო ადვილი არ არის მისი მნიშვნელობის დაუყოვნებლივ დაწერა?

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

Const Mytext="მე მიყვარს Pascal ABC.NET ენა და ამიტომ ვქმნი საიტს, სადაც შეგიძლიათ ისწავლოთ ეს ენა";

და სადაც საჭიროა, უფრო მოსახერხებელია ამ მუდმივი "მიტექსტის" სახელის დაწერა, ვიდრე ამ გრძელი წინადადების.

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

Var f:text; მე: მთელი რიცხვი; start assign(f, "data.bat"); გადატვირთვა (f); წაკითხვა (f,i); i:=(i*10 - 125)*(-1); დახურვა (f); assign(f, "data.bat"); გადაწერა (f); ჩაწერე(f,i); დახურვა (f); დასასრული.

სავარაუდოდ, თქვენ ამ კოდში თითქმის არაფერი გესმით (არ მინდოდა ამ მაგალითის მოყვანა, მაგრამ უფრო მეტი სიცხადისთვის გადავწყვიტე მიმეცემა). თქვენ არ გჭირდებათ ახლა ამ კოდში ჩაღრმავება (რადგან მე ის შემთხვევით დავწერე). ეს კოდი ხსნის "data.bat" ფაილს, კითხულობს მნიშვნელობას მისგან, გარდაქმნის ამ მნიშვნელობას და აბრუნებს ახალ მნიშვნელობას ამ ფაილში. მაგრამ ეს არ არის მთავარი. ამ კოდში შეგიძლიათ იხილოთ სტრიქონები "assign(f, "data.bat");" ამ მაგალითში არის 2 ხაზი. თუ ფაილის სახელი მოულოდნელად შეიცვლება, მოგვიწევს ამ ორი ხაზის გადაწერა. წარმოიდგინეთ ათასობით ასეთი სტრიქონი რომ იყოს. ყველა მათგანი ხელახლა უნდა დაიწეროს. სწორედ ამ მიზეზით შემოიღეს ცვლადები და მუდმივები.

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

Const my_text="Pascal ABC.NET";

მუდმივი სახელია "my_text" და მისი მნიშვნელობა არის "Pascal ABC.NET". შეიძლება გქონდეთ განცდა, რომ მუდმივებს მხოლოდ სიმებიანი მნიშვნელობების მინიჭება შეუძლიათ, მაგრამ ეს ასე არ არის:

Const my_Pi=3.1428;

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

ჩვენს მაგალითში განცხადებების განყოფილება შეიცავს მხოლოდ ერთ განცხადებას, "writeln("Pascal ABC.NET");". ბრძანება "writeln" არის ქვეპროგრამა (მათ ცოტა მოგვიანებით გავიცნობთ), რომელიც აჩვენებს ყველაფერს, რაც მის ფრჩხილებშია (ჩვენს შემთხვევაში, პროგრამა აჩვენებს "Pascal ABC.NET").

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

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

პასკალის პროგრამირების ენაში ნებისმიერ პროგრამას აქვს სამი კომპონენტი: 1) header; 2) აღწერილობების განყოფილება; 3) პროგრამის ძირითადი ნაწილი.

✎ 1) სათაური არის სიტყვა პროგრამა, რასაც მოსდევს პროგრამის სახელწოდება ლათინურად და ბოლოში მძიმით. სახელი არ შეიძლება დაიწყოს რიცხვით, არ უნდა ემთხვეოდეს რეზერვებულ სიტყვებს (დაწყება, დასასრული, მთელი რიცხვი და ა.შ.) ან ცვლადის სახელებს აღწერილობების განყოფილებიდან (იხ. ქვემოთ) და ნებისმიერი სიმბოლოს გამოყენებას ('@', '%'. , '&' და ა.შ.), ხაზგასმის გარდა. მიზანშეწონილია სახელის მიცემა ისეთი მნიშვნელობით, რომელიც ასახავს თავად პროგრამის არსს. მაგრამ თქვენ არ გჭირდებათ სათაურის დაწერა.

✎ 2) აღწერილობების განყოფილება – ვინაიდან პირველ რიგში განვიხილავთ უმარტივეს ამოცანებს, მეორე ნაწილი შეიცავს ან მუდმივების ან ცვლადების აღწერას (იხილეთ სტატიის შესავალი პასკალის მე-4 და მე-5 პუნქტები).

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

ამრიგად, ზოგადად, პასკალის პროგრამა ასე გამოიყურება:

უმარტივესი ამოცანების ამოხსნისას პირველ რიგში შემოვიფარგლებით მთელი რიცხვებით. სანამ პროგრამირებას დავიწყებთ, პასკალში ციფრებზე უმარტივეს 4 ოპერაციას მივუთითებთ: „+“ - დამატება, „-“ - გამოკლება, „*“ - გამრავლება, „/“ - გაყოფა. როგორც ხედავთ, პროგრამირებასა და მათემატიკაში, ელემენტარული მოქმედებები რიცხვებზე იგივენაირად აღინიშნება. მოვაგვაროთ შემდეგი პრობლემა:

დავალება.მიეცით მთელი რიცხვები A და B იპოვეთ მათი ჯამი.

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

1 პროგრამაჯამი; (პროგრამას ჰქვია Summa)

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

ასე რომ, მიეცით A და B რიცხვების მნიშვნელობები, ტოლი, მაგალითად, 23 და 76, შესაბამისად. ვინაიდან წინასწარ ვიცით მნიშვნელობები, A და B მსგავსი იქნება კონსტდა S იქნება აღწერილი როგორც ვარ. იმის გათვალისწინებით, რომ მუდმივების აღწერა წინ უსწრებს ცვლადების აღწერას, აღწერილობის განყოფილება ამ შემთხვევაში იქნება შემდეგი:

ამრიგად, პროგრამის ძირითადი ნაწილი შედგება S ჯამის გამოთვლისა და ეკრანზე გამოტანისგან. პასკალში, A და B ჯამის გამოსათვლელად, უბრალოდ არ შეგიძლიათ დაწეროთ S = A + B; ასეთი აღნიშვნა შესაძლებელია, თუ თქვენ უნდა შეამოწმოთ არის თუ არა რიცხვი S ჯამის A + B. A იმისათვის, რომ ჩაწეროთ A + B ჯამის მნიშვნელობა S ცვლადში, თქვენ უნდა "მივანიჭოთ" ამ ჯამის მნიშვნელობა S ცვლადს., ე.ი. ჩაწერეთ ჯამი A + B კომპიუტერის მეხსიერების იმ ადგილას, რომელიც გამოყოფილია S ცვლადისთვის. ეს ჰგავს ერთი რიცხვის მნიშვნელობის „გადატანას“ მეორის მნიშვნელობაში. დავალება ასე იწერება:

შედეგის გამოსატანად გამოიყენეთ ჩაწერის გამომავალი ოპერატორი ეკრანზე კომენტარით:

write("23 და 76 რიცხვების ჯამი არის: S = ", S);

ჩვენი 1) პროგრამის სათაურის, 2) აღწერილობის განყოფილების და 3) პროგრამის სხეულის კომბინაციით, ჩვენ ვიღებთ პატარა კოდს, რომელიც შეიძლება დაკოპირდეს PascalABC.Net-ში ან Pascal-ის სხვა ვერსიაში:

ამ პროგრამის შესრულების შემდეგ ეკრანზე დავინახავთ:

23 და 76 რიცხვების ჯამი არის: S = 99

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

ამ შემთხვევაში, შედეგი ეკრანზე იქნება ასეთი:

23 და 76 რიცხვების ჯამი არის 99

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

შემდეგ გვერდზე ვისაუბრებთ პროცენტებზე. იმავდროულად, თუ World of Warcraft-ის ფანი ხართ, მაშინ ეს დაგეხმარებათ