ფორმატირება

                                   Escape Sequences

Char სიმბოლო, რომელსაც უნიკალური სიმბოლოების გადმოცემის უნარი აქვს, წარმოდგენილი (\) ამ ნიშნით არის Escape Sequence. მათემათიკაში (\) მას დახრილობას ან სხვაობას ეძახიან.  დახრილობა არის ლიტერალი Char ტიპის რომელსაც აქვს უნარი უთხრას კომპიუტერს ან სოფტს შეასრულოს ესა თუ ის ფუნქცია, აგრეთვე მისი მეშვეობით ხდება უნიკალური კოდური სიტყვების გადმოცემა, დახრილობა არსებობს მხოლოდ ““ აპოსტროფებში, აპოსტროფების გარეთ ის არ ფუნქციონირებს, ის იყინებს რამოდენიმე სიმბოლოს (\t, \n, \b, \r, \f, \\, \’, \”, \\, \u……) რომელსაც პროგრამაში განვიხილავთ და ამავდროულად მათი მეშვეობით  დავწერთ უნიკალურ ბგერებს რომლის წარმომადგენლობაც იქნება ალფანუმერაციული.

 * \t - Tab. შუალედი

 * \n - new line.

 * \b - baclspace.

 * \r - carriage

 * \f - form feed

 * \'- single quote

 * \"- double quote

 * \\ - backslash კურსორი იწევს ერთი ნაბიჯით მარცხნივ, აბგდ\b იქნება აბგ

კომპილირების შემდგომ.

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

განვიხილოთ unicode System რა კავშირშია escape sequence-ან.  უნიკალური კოდური სისტემის გადმოცემა მხოლოდ escape sequence მეშვეობით ხდება, თუ გსურთ ჩინურად დაწეროთ ტექსტი, ან ნებისმიერ სხვა ენაზე თუ იეროგლიფზე მოგიწევთ ამ სისტემის გამოყენება, მათემატიკური სიმოლოები, ნიშნები, პენტაგრამები და სხვა უამრავი რამ რაც შექმნილა საუკუნეების მანძილზე მოქცეულია Char ტიპის გავლენის ქვეშ, კარგად რო მიხვდეთ რასთან გავქ საქმე, ძველ ქართულად დავწეროთ „გამარჯობა“. მაგალითი ფოტოზე.

ყველა კოდური სიტყვის შემდეგ, შუალედი \t

კომპილირების შემდგომ, შედეგი:

როგორ ხდება კომპილირება, რას ნიშნავს სტანდარტული ეკრანიზება, სტანდარტული შიგთავსი, გარე ინფორმაცია და შეცდომა, ალბათ ბევრჯერ გინახავთ რო ვიყენებთ System.out რომლის ძირითადი მოვალეობა არის მიიღოს და გამოიტანოს ეკრანზე კოდირების მიერ შესრულებული ოპერაციის შედეგი. ოპერაციული სისტემა ვალდებულია მოახდინოს დეფინირება სტანდარტული Input-Output მექანიზმის რომლის მოვალეობა არის ხელი შეუწყოს ურთიერთ კავშირს მექანიზმსა და მომხმარებელს შორის.  როცა პროგრამა იწყებს მუშაობას Source-code ასრულებს მოქმედებას მანამ სანამ პროგრამა გაიხსენაბ(ან დაიხურება), ამ გზით აპლიკაცია მზად არის წაიკითხოს და მიიღოს მომხმარებლის მიერ მოთხოვნილი ოპერაცია და შეასრულოს იგი. (System.in). შეინახოს ინფორმაცია და გამოიტანოს იგი ეკრანზე(System.out) და შეძლოს კომუნიკაცია პროგრამისთან რთულ სიტუაციებში(System.err), რომელსაც გამოაქვს ეკრანზე ერორ მესიჯი. რომელსაც სავარაუდოდ შემდგომ უმკლავდებით ან ვერ უმკლავდებით.

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

კომპილატორში ინფორმაციის გამოტანა ხდება System.out.print(); და System.out.println(); - ის მეშვეობით. ახსნა განმარტებას არ დავიწყებ, ერთი ნახვითაც ჩანს რო პრიმიტიულია. Print-ს უბრალოდ გამოაქვს ინფორმაცია კომპილატორზე, println-ს გამოაქვს ინფორმაცია ახალ ველზე, მაგრამ არსებობს საკმაოდ ძლიერი მეთოდი რომელსაც იგივე მოვალეობა აქვს რაც მაღლა ხსენებულ 2 მეთოდს, System.out.printf(); რომელსაც შეუძლია რამოდენიმე არგუმენტის ერთდროულად მიღება და ფორმატირება. მას აქვს უნარი მიიღოს და გაითავისოს სიმბოლოები რომლებიც ცნობილია Format Specification-ის სახელით, სადაც მოთავსებულია String, Int, Float ტიპების ფორმატირებისთვის განკუთვნილი სიმბოლოები. მათი მეშვეობით ხდება კომპილირება და დიდი ინფორმაციის ეკრანზე გამოტანა მცირე ვიზუალით.

რას აკეთებს printf() მეთოდი. მას გააჩნია ლიტერალები, რომლებიც ასრულებენ გარკვეულ ოპერაციებს, პროგრამისტები ამ ლიტერალებს ინდექსებს ეძახიან, მისი გამოხატულება არის % ნიშანი, როგორც სხვა დანარჩენი ლიტერალები ისიც არ მუშაობს „“ აპოსტროფების გარეთ, თუ გვსურს ინფორმაციის გადაცემა String Format ოპერაციის გამოყენებით მოგვიწევს გათვალისწინება რო String-ის ლიტერალი არის აპოსტროფი და ფორმატირების ლიტერალი არის % ნიშანი, შესაბამისას ნებისმიერი ინფორმაცია რომელსაც ფორმატირებით გადავცემთ გამოიყურება შემდეგნაირად. „%d“. ამ შემთხვევაში D არის Integer-ის გამოხატულება ფორმატირების გზით. ყველა ტიპს, დროს, კალენდარს, სისტემებს, აქვს საკუთარი გამოხტულება ფორმატირების გზით, ყველას რა თქმა უნდა ვერ განვიხილავთ, რადგან უზარმაზარი ინფორმაციაა, ამიტომ განვიხილოთ ბირთვი, რისი გამოყენებაც ხშირად მოგვიწევს. მთავარი რაც უნდა გვახსოვდეს printf() მეთოდს შეუძლია უამრავი არგუმენტის მიღება და შემდგომ მისი ფორმატირება, ის არის შესანიშნავი მეთოდი, რომელიც საშუალებას გვაძლევს ჩვენი სურვილის და მიხედვით გამოვიტანოთ შედეგი ფორმატირებული გზით ეკრანზე, მას სამი ძირითადი ოპერაცია გააჩნია, 1. Printf()- მეთოდი. 2, (“%d”)- Strinf Formating. 3, (56)- არგუმენტი. ერთად ეს სამი ოპერაცია გამოიყურება შემდეგნაირად. System.out.printf(“%d”, 56); სადაც %d ამოწმებს ვმუშაობთ თუ არა ინტეგერთან, გადამოწმების შემდგომ კი ეკრანზე გამოიტანს ინტეგერ ღირებულება 56-ს.  მსგავსად იტეგერისა, ის მუშაობს, %b, %c, %s, %f, %e, %g, %o, %x, %h,  %a %tB, %n, %%, თანმიმდევრულა, Boolean, Char, String, Format, scientific notation(თუ არ იცით რას ნიშნავს, ეს არის მეცნიერული გზა დიდ ციფრებთან სამუშაოდ და მისი ძირითადი დანიშნულებაა გამოხატოს ნულები, X არის 9 ნული, ჯავაში გამოიყენება e და ა.შ) ოქტალ, ჰექსადეციმალ,  ჰეშკოდი,  კალენდარი, ახალი ველი და პროცენტი,

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

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

კომპილირების შემფგომ:

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

                                       [Argument_index1][Flags][width][.precision]

[Argument_index] - ლიტერალი $

[.precision] - ლიტერალი . (წერტილი აზრს არ ასრულებს, ის ლიტერალია)

მისი მეშვეობით ვაშორებთ დამატებით ნულებს ციფრს ან ვამატებთ ნულებს,

[width] - მისი ლიტერალია ციფრები, ციფრების საშუალებით პროგრამას ვეუბნებით რამდენი უჯრის გამოყენება გვსურს.  სტანდარტულად კომპილატორი იყენებს 6 უჯრას წერტილის შემდგომ. 2.2 ფორმატირების შემდგომ დაამატებს 6 ნულს, ეგ ნულები რო გაქრეს საკამრისია [.precision]  ოპერაცია გამოვიყენოთ.

[Flags] - ლიტერალები + 0  # ( ,  -

[Argument_index] მაგალითი:

სკრინზე ხედავთ ფორმატირების განსხვავებულ მაგალითებს, პირველ მაგალითში ვახდენთ არგუმენტების თანმიმდევრულად გამოტანას ეკრანზე, გვაქ სტრინგი, რომლის ფორმატირებული ლიტერალია %s, ვახდენთ კომპილაციას და ლოგიკურად ეკრანზე უნდა მივიღოთ, 102030. მეორე მაგალითზე ვიყენებთ [Argument_index] ლიტერალს სადაც პროგრამს ვეუბნებით რო გვჭირდება მხოლოდ პირველი არგუმენტი ეკრანზე, შესაბამისად %1$s ვწერთ, სადაც 1 არგუმენტის ნომერია და $ არგუმენტის ლიტერალი, პირველი არგუმენტი არის 10, სამჯერ განმეორების შემდეგ ეკრანზე უნდა გამოვიდეს 101010, მესამე მაგალითზე გონების დაძაბვა მოგიწევთ, როგორ ფიქრობთ რა შედეგი გვექნება ეკრანზე? როცა ერთი არგუმენტირებული და 2 სტანდარტული ოპერაცია გვაქ ერთ მეთოდში?

%2$s გვაძლევს მეორე არგუმენტს, 20-ს, შემდეგ კი ათვლა იწყება ახლიდან რადგან სტანდარტული ფორმატირება იწყება, შესაბამისად ეკრანზე გამოვა 201020.  კომპილირების შემდგომ ნახეთ შედეგი:

[.precision] საშუალებით კომპილატორს ვეუბნებით რამდენი უჯრის გამოყენება გვსურს სასვენი ნიშნის შემდგომ, მაგალითად თუ გვაქ ციფრი 25,2345678 და ეკრანზე გვსურს მხოლოდ 25-ის ხილვა, მაშინ ვწერთ %.0f სადაც სასვენი ნიშანი პროგრამას ეუბნება რო ნიშნის შემდგომ გვინდა 0 ციფრის გამოყენება , ანუ დანარჩენი 7 ციფრის გაქრობა, ეკრანზე გამოვა 25. მაგალითზე უკეთ მიხვდებით

გვაქ 4 ველი ფორმატირების, სადაც პირველ ველზე ვამბობთ რო სასვენი ნიშნის შემდგომ არ გვუსრს ციფრების ქონა, .0 აქრობს ყველა დანარჩენ ციფრს, ეკრანზე გამოდის 25. მეორე ველზე, .1 გამოაქვს 25,2. მესამე ველზე 25,23. მაგრამ რას გამოიტანს მეოთხე ველზე? სავარაუდოდ 25,234 ხო? გაგიკვირდებათ მაგრამ ბოლო ველის შედეგი არის 25,235 და არა 4. ეს იმიტომ რო ამ ოპერაციას აქვს ციფრების დამრგვალების უნარი, როდესაც უახლოვდება გრუპირების ზღვარს იწყებს დამრგვალებას და ყველა შემდეგ ციფრს ამრგვალებს, რო გაგვეგრძელებინა, .4 შედეგი ეკრანზე იქნებოდა 25,2346. კომპილირების შემდგომ.

[width] მისი მოვალეობა არის უჯრების კონტროლი ციფრების მეშვეობით, რამდენ ციფრსაც მიუთითებთ არგუმენტს იმდენ უჯრას გამოიყენებს, მაგალითისთვის, %10d, 897.სადაც 897 გამოვა 10 უჯრაში, მაგრამ ერთადერთი პრობლემა არის ის რომ ციფრები იქნება მარჯვენა კუთხეში უჯრის, ნახეთ მაგალითზე:

ორი ველი გვაქ, სადაც ერთზე 10 უჯრის დაშორება მიუთითეთ და მეორეზე 100 უჯრის დაშორება, . კომპილირების შემდგომ 

10 უჯრა

100 უჯრა.

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

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

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

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

სადაც name ჩამოვწიეთ 6 უჯრით მარცხნივ, და bruce ჩავწიეთ 6 უჯრით მარჯვნივ ჯამში მოვახდინეთ 12 უჯრის კონტროლი, ალბათ გაგიჩდებოდათ კითხვა რა მოხდება თუ უჯრა მოთხოვნილ რაოდენობაზე მცირეა? მაგალითად გვაქ ციფრი 121212 და მოვითხოვეთ 5 უჯრა ან 4 უჯრა, როგორ დაიტევს 4 უჯრა 6 ციფრს? ძალიან მარტივად, ავტომატურად შექმნის უჯრას ჯავა თქვენთვის. რათა არ მოხდეს პროგრამის გაჩერება.

ჩვენი შემდეგი ლიტერალი არის + ნიშანი.

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

ჩვენი შემდეგი flag არის 0. ის უბრალოდ ახდენს ციფრებზე ნულის დამატებას მარცხენა მხრიდან, მაგალითად თუ გვაქ ციფრი 111 და გვინდა ეკრნაზე გამოვიტანოთ 0111, უბრალოდ უნდა დავწეროთ %0d რაც 0 დაემატება 111-ს,  ნუ წარმოიდგინეთ ახლა როგორ შეიძლება მსგავსი რამ რეალურად მოხდეს?. რა თქმა უნდა მსგავსი რამ რეალურად შეუძლებელია მოხდეს და გეტყვით რატომ, როდესაც ციფრზე რომელიც ეკრანზე გამოდის სტანდარტულად მარცხენა კუთხეში, გვინდა დამატება ციფრის მას არ აქვს ადგილი ციფრი დაიმატოს, 111-ში მარცხენა 1 არის უკიდურესი პირველი ციფრი რის შემდგომაც არაფერია, შესაბამისად 0 ადგილი აღარ არის, მაშინ ჩდება კითხვა, თუ ვერ გამოვიყენებ რათ მინდა ეგეთი ფუნქცია? მე თუ დამიჯერებთ არც არაფერში გჭირდებათ მაგრამ უნდა ვიცოდეთ, თუ გვინდა ციფრების მარცხენა მხარეს 0-ის დამატება ან რამოდენიმე 0-ის, მაშინ უნდა ვიმუშაოთ ერთ ნულზე მეტ ნულებთან. მაგალითი სკრინზე.

კომპილირების შემდგომ:

სადაც მესამე ველი კარგად გვიჩვენებს თუ რომელია პირველი ციფრი 111-ში.

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

მაგალითი სკრინზე:

კომპილირების შემდგომ:

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

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

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

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

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

სადაც ჰექსადეციმალი ახდენს 111-ის კონვერტირებას და ეკრნაზე გამოტანას, პირველ მაგალითზე პატარა ბგერებით, მეორე მაგალითზე დიდი ბგერებით. ჰექსის პრეფიქსია 0x, ბინარის ob, ამისთვის არის საჭირო # ლიტერალი რო ეკრანზე მოვახერხოთ სისტემური ციფრის გამოტანა სრულად. კომპილირების შემდგომ

რაოდენ მოცულობითია printf() მეთოდი ხედავთ. სავარაუდოდ რაღაცეებიც გამოგვრჩა, მაგრამ როდესაც მუშაობთ დიდ პროგრამებთან დაგჭირდებათ, გამოსადეგია. ჩვენი შემდეგი გაჩერება არის err() მეთოდზე, 

System.err.println() ძირითად მოვალეობებში შედის,  მოახდინოს ერორ მესიჯის გამოტანა ეკრანზე რათა პროგრამისტმა მოახერხოს მისი დამუშავება, მას აქვს დამატებითი ფუნქცია, გარდა გამოტანისა შეუძლია ერორ მესიჯის შენახვაც, თუ შექმნით ფაილს რომელსაც გამოიყენებთ შეცდომების შესანახად. მაგალითად ეკლიპსში თუ წერთ ერორ მესიჯი გამოდის წითელი ბგერებით რათა გამორჩეული იყოს და შესამჩნევი. როგორც ესეთი განსაკუთრებული არაფერია და მაგალითზე არ განვიხილავთ, ყველა მაღლა ჩამოთვილი მეთოდი მოქცეულია ერთი დიდი პაკეტის გავლენის ქვეშ, რომელსაც JAVA.IO ქვია. Java input-outpu stream, რომელიც თავის მხრივ ერთ-ერთი უძლიერესი ხელსაწყოა ფაილებთან სამუშაოდ. 

რაიმე სახის კითხვა თუ გაგიჩდათ მომწერეთ მაილზე.