გადმოწერა


ძირითადი კონცეფციები



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

მახასიათებლები

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

შესაძლებლობები

  • MySQL, PostgreSQL, MSSQL, SQLite, Oracle მონაცემთა ბაზების მხარდაჭერა.
  • როგორც ჩვეულებრივი (მაგ: /index.php?cat=10&subcat=2&id=41 ) ასევე ადამიანისათვის გასაგები (რუს: ЧПУ - человекопонятный URL, ინგლ: friendly URL, მაგ: /product/phone/Samsung/) URL მისამართების მხარდაჭერა.
  • ფრეიმვორკი შეიცავს ისეთ ბიბლიოთეკებს, რომლების გამოიყენება ფაილებთან სამუშაოდ, ელ_ფოსტის გასაგზავნად, ფორმების ვალიდაციისათვის, სესიების მხარდასაჭერად, გამოსახულებებთან სამუშაოდ და ა.შ

ინსტალაცია

CI-ს ინსტალაცია საკმაოდ მარტივია
  • გადმოვწეროთ CI შემდეგი მისამართიდან : CodeIgniter
  • გავხსნათ დაარქივებული ფაილი.
  • ავტვირთოთ არქივში არსებული ყველა ფაილი სერვერზე
  • ატვირთვის შემდეგ გავხსნათ ჩვენი სერვერის URL მისამართი, მაგ: http://localhost/codeigniter
ამ მისამართზე შესვლის შემდეგ უნდა დავინახოთ შემდეგი სურათი



CodeIgniter - აპლიკაციის არქიტექტურა



  • როგორც ვხედავთ, როგორც კი CI მიიღებს რაიმე მოთხოვნას, მოთხოვნა მიემართება index.php გვერდისკენ.
  • მეორე ბიჯზე Routing ანუ მარშრუტიზატორი წყვეტს საით გაგზავნოს მოთხოვნა ბიჯი-3-სკენ თუ ბიჯი-4-სკენ უსაფრთხოების გადასამოწმებლად.
  • თუ მოთხოვნა უკვე მოხვედრილია კეშირების პროცესში, მაშინ მარშრუტიზატორი მოთხოვნას გაგზავნის ბიჯი-3-სკენ და პასუხი დაუბრუნდება მომხმარებელს.
  • თუ მოთხოვნა არ არის დამუშავებული, მაშინ მარშრუტიზატორი მას გაგზავნის ბიჯი-4-სკენ უსაფრთხოების გადასამოწმებლად.
  • მანამ მოთხოვნა გადაეცემა ძირითად კონტროლერს ანუ Application Controller-ს, გამოგზავნილ მოთხოვნაში შემავალი ინფორმაცია უკვე გადამოწმებულია უსაფრთხოების თვალსაზრისით, ძირითადი კონტროლერი ანუ Application Controller მოითხოვს ყველა აუცილებელ მოდელს, ბიბლიოთეკას, დამხმარეს, პლაგინს სკრიპტს და გადასცემს მათ წარმოდგენას ანუ View-ს.
  • წარმოდგენა ანუ View შექმნის საჭირო ინფორმაციის შემცველ გვერდს და ჩართავს მას კეშირების პროცესში, შემდეგ დაბრუნდება საბოლოო შედეგი და გვერდი მზად იქნება ახალი მოთხოვნის მისაღებად

CodeIgniter - დირექტორიების სტრუქტურა

ქვემოთ მოყვანილ სურათზე ასახულია CI დირექტორიების სტრუქტურა



CI დირექტორიების სტრუქტურა იყოფა სამ საქაღალდედ
  • Application
  • System
  • User_guide

Application

დასახელებიდანაც ჩანს, რომ ეს საქაღალდე შეიცავს ჩვენი აპლიკაციის მთლიან კოდს, ესაა საქაღალდე სადაც ვქმნით პროექტს, საქაღალდე შეიცავს შემდეგ ქვე-საქაღალდეებს
  • Cache − ეს საქაღალდე შეიცავს ჩვენი პროექტის ყველა კეშირებულ გვერდს, კეშირებული გვერდების მეშვეობით აპლიკაცია ხდება უფრო სწრაფი.
  • Config − ეს საქაღალდე შეიცავს კონფიგურაციულ ფაილებს, config.php ფაილში პროგრამისტს შეიძლია განსაზღვროს სხვადასხვა კონფიგურაციული პარამეტრები. database.php ფაილში კი შესაძლებელია მონაცემთა ბაზის პარამეტრების მითიტება.
  • Controllers − ეს საქაღალდე შეიცავს აპლიკაციის კონტროლერებს, ეს არის აპლიკაციის ძირითადი ნაწილი.
  • Core − ეს საქაღალდე შეიცავს აპლიკაციის ძირითად კლასს.
  • Helpers − ამ საქაღალდეში შეიძლება მოთავსდეს აპლიკაციის დამხმარე კლასები.
  • Hooks − ამ საქაღალდეში განთავსებული ფაილები საშუალებას გვაძლევენ სხვაგვარად დავგეგმოთ ფრეიმვორკში მიმდინარე შიდა სამუშაოები ძირითადი ფაილების შეუცვლელად.
  • Language − ეს საქაღალდე შეიცავს ენასთან დაკავშირებულ ფაილებს.
  • Libraries − ეს საქაღალდე შეიცავს აპლიკაციისათვის შექმნილი ბიბლიოთეკების ფაილებს.
  • Logs − ეს საქაღალდე შეიცავს სისტემის მუშობის ამსახველ ფაილებს.
  • Models − აქ განთავსდება მონაცემთა ბაზასთან დაკავშირებული ფაილები.
  • Third_party − ამ საქაღალდეში შეიძლება მოვათავსოთ აპლიკაციისათვის საჭირო სხვადასხვა პლაგინები.
  • Views − აქ მოთავსდება აპლიკაციის HTML ფაილები.

System

ეს საქაღალდე შეიცავს CI-ს ძირითად კოდებს, ბიბლიოთეკებს, დამხმარეებს და სხვა ფაილებს, რომლებიც გვეხმარებიან კოდის წერა გავხადოთ უფრო ადვილი.
  • Core − ეს საქაღალდე შეიცავს CI-ს ძირითად კლასს. არავითარ შემთხვევაში არ შეიძლება ამ საქაღალდეში რაიმეს შეცვლა ჩვენთვის საჭირო ფაილები მოთავსებულია application საქაღალდეში.
  • Database − საქაღალდე შეიცავს მონაცემთა ბაზის ძირითად დრაივერსა და მის სხვა ხელსაწყოებს.
  • Fonts − საქაღალდე შეიცავს ფონტებთან დაკავშირებულ ინფორმაციებს.
  • Helpers − საქაღალდე შეიჩავს სტანდარტულ CI დამხმარეებს (თარიღი, cookie და URL დამხმარეები).
  • Language − საქაღალდე შეიცავს ენასთან დაკავშირებულ ფაილებს.
  • Libraries − საქაღალდე შეიჩავს სტანდარტულ CI ბიბლიოთეკებს (ელ_ფოსტა, კალენდარი, ფაილების ატვირთვა და ა.შ ). შეგვიძლია შევქმნათ საკუთარი ბიბლკიოთეკებიც, მაგრამ ისინი უნდა შევინახოთ application/libraries საქაღალდეში რათა განვაცალკევოთ CI სტანდარტული ბიბლიოთეკებისაგან.

User_guide

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

გარდა ზემოთ ჩამოთვლილი საქაღალდეებისა ძირ დირექტორიაში არის ერთი მნიშვნელოვანი ფაილი index.php, აქ შეგვიძლია განვსაზღროთ ან შევცვალოთ აპლიკაციის სამუშაო გარემო და შეცდომათა გამოტანის სისტემა, აგრეთვე სისტემისა და აპლიკაციის საქაღალდეთა სახელები. რეკომენდებულია არ შევცვალოთ ამ საქაღალდეში განსაზღვრული პარამეტრები თუ ზუსტად არ ვიცით რას ვაკეთებთ.
2. რა არის MVC ?
MVC (Model–View–Controller ანუ მოდელი-წარმოდგენა-კონტროლერი) - არის კომპიუტერულ ინჟინერიაში გავრცელებული, კოდირების შაბლონი, მეთოდი, იდეა, რომელიც საშუალებას იძლევა განცალკევდეს ვებ-აპლიკაციის ლოგიკა და მისი წარმოდგენა ანუ ის ნაწილი რომელსაც მომხმარებელი ხედავს ბრაუზერში.



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

წარმოდგენა

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



კონტროლერი

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



მოდელი

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



მუშაობის კლასიკური სქემა

მომხმარებელმა გააკეთა მოთხოვნა საიტზე, მოთხოვნა გადაეცა საიტზე შესვლის ერთადერთ წერტილს (index.php, frontController), ამ წერტილში მოსულ მოთხოვნას ამუშავებს მარშრუტიზაციის კომპონენტი (Router), ერთგვარი გზამკვლევი მოთხოვნისათვის, როუტერმა უნდა განსაზღვროს თუ რომელმა კონტროლერმა უნდა დაამუშავოს მოთხოვნა



ვთქვათ ეს კონტროლერია NewsController, ეს კონტროლერი მოთხოვნიდან ღებულობს ინფორმაციას თუ რა სახის სიახლეების ნახვა უნდა მომხმარებელს, შემდეგ მიმართავს მოდელს საჭირო ინფორმაციის მისაღებად, პასუხის მიღების შემდეგ კონტროლერი იყენებს საჭირო წარმოდგენას პასუხის ბრაუზერში გამოსატანად, ასე იკვრება მთლიანი წრე.
3. CI - URL მისამართები
ნაგულისხმეობის პრინციპით CI-ში განსაზღვრულია საძიებო სისტემებისა და ადამიანის თვალისათვის ადვილად აღქმადი URL მისამართები. სტანდარტული URL მისამართების ჩაწერის სტანდარტული "მოთხოვნის ტექსტი" (მაგ: example.com?page=view&content=1...) ტიპის ნაცვლად CI იყენებს სეგმენტურ მიდგომას example.com/news/article/my_article

URL მისამართის სეგმენტები

საბაზისო URL მისამართს აქვს შემდეგი სახე example.com/class/function/ID URL მისამართის სეგმენტები, Model-View-Controller პრინციპის მიხედვით განსაზღვრავენ:
  1. პირველი სეგმენტი განსაზღვრავს კონტროლერის კლასს რომლის გამოძახებაც უნდა მოხდეს.
  2. მეორე სეგმენტი განსაზღვრავს კლასის მეთოდს რომელიც უნდა შესრულდეს
  3. მესამე და შემდეგი სეგმენტები განსაზღვრავენ ID-ს და სხვა ცვლადებს, რომლებიც უნდა გადაეცეს კონტროლერს.

URL მისამართიდან index.php ტექსტის წაშლა

ნაგულისმეობის პრინციპით URL მისამართებში შეტანილია index.php დასახელება example.com/index.php/news/article/my_article URL-დან მისი წაშლა შესაძლებელია .htaccess ფაილის მეშვეობით RewriteEngine On
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteRule ^(.*)$ index.php/$1 [L]
მოყვანილ მაგალითში ნებისმიერი HTTP მოთხოვნა, რომელიც განსხვავდება არსებული დირექტორიების ან ფაილების მოთხოვნისაგან, აღიქმნება index.php ფაილის მოთხოვნად.

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

"მოთხოვნის სტრიქონი" ტიპის URL მისამართები

შეიძლება მოხდეს რომ დაგვჭირდეს არა სეგმენტური URL მისამართები, არამედ შემდეგი სახის index.php?c=products&m=view&id=345 თუ გავხსნით application/config.php ფაილს დავინახავთ შემდეგ ჩანაწერებს $config['enable_query_strings'] = FALSE;
$config['controller_trigger'] = 'c';
$config['function_trigger'] = 'm';
თუ $config მასივის 'enable_query_strings' გასაღების მნიშვნელობად მივუთითებთ TRUE-ს, მაშინ შესძლებელი იქნება გავხსნათ შემდეგი ტიპის URL მისამართები index.php?c=controller&m=method
4. CI - კონტროლერები
კონტროლერი - ეს არის უბრალო ფაილი სადაც აღწერილია კლასი. როგორც მისი დასახელებიდან ჩანს, იგი მართავს მთლიან აპლიკაციას URI მისამართების დახმარებით. განვიხილოთ URL მისამართი example.com/index.php/blog/ ამ მისამართზე შესვლისას CI შეეცდება მოძებნოს კონტროლერი Blog.php და ჩატვირთოს იგი. როდესაც კონტროლერის დასახელება დაემთხვევა URI-ის პირველ სეგმენტს, მოხდება ამ კონტროლერის ჩატვირთვა.

კონტროლერის შექმნა

შევიდეთ application/controllers საქაღალდეში. აქ დაგვხვდება ორი ფაილი index.html და Welcome.php, ეს ფაილები მოყვება CI-ს. გავაკეთოთ ახალი ფაილი "Blog.php” და ჩავწეროთ შემდეგი კოდი
<?php
class Blog extends CI_Controller{
  public function index(){
    echo "Hello Georgia";
  }
}
?>
          
Blog კლასი არის CI-ში ჩაშენებული კლასის CI_Controller-ის მემკვიდრე კლასი. ფაილს უნდა დავარქვათ აუცილებლად Blog.php "B" დიდი ასოთი, აგრეთვე დიდი ასოთი უნდა დაიწყოს კონტროლერის კლასის დასახელებაც.

კონტროლერის გამოძახება

ამ კონტროლერის გამოძახება შესაძლებელია თუ შევალთ შემდეგ მისამართზე http://www.your-domain.com/index.php/blog ბრაუზერში უნდა გამოჩნდეს ტექსტი "Hello Georgia" ; )

კონტროლერის მეთოდები

განვაახლოთ ზემოთ აღწერილი კლასი და დავამატოთ მას მეთოდი “framework”
<?php
class Blog extends CI_Controller {

  public function index(){
    echo "Hello Georgia";
  }

  public function framework() {
     echo "This is CodeIgniter !";
  }

}
?>
          
ამ კონტროლერის გაშვება შეიძლება სამნაირად
  • http://www.your-domain.com/index.php/blog
  • http://www.your-domain.com/index.php/blog/index
  • http://www.your-domain.com/index.php/blog/framework
პირველ მისამართზე შესვლის შემდეგ ბრაუზერში გამოჩნდება ტექსტი "Hello Georgia" , როგორც ვხედავთ ვიხილეთ index მეთოდის მიერ გამოტანილი შედეგი, თუმცაღა URL-ში არ მიგვითითებია მეთოდის დასახელება, ჩვენ გამოვიყენეთ მხოლოდ კონტროლერის სახელი, ამგვარ სიტუაციებში CI ნაგულისმეობის პრინციპით იძახებს კონტროლერის index მეთოდს.

მარტივი ასახსნელია რომ მეორე შემთხვევაშიც იგივე შედეგს ვიხილავთ ბრაუზერში. რაც შეეხება მესამე URL-ს, მასზე შესვლის შემდეგ ბრაუზერში გამოვა ტექსტი "This is CodeIgniter !" , ეს კი არის framework მეთოდის შედეგი, რადგან კონტროლერის დასახელების შემდეგ სწორედ ამ მეთოდის სახელია მითითებული URL-ში.

URL მისამართის მეორე სეგმენტი განსაზღვრავს თუ კონტროლერის რომელი მეთოდის გამოძახება უნდა მოხდეს.

უნდა გვახსოვდეს

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

URL სეგმენტების მეთოდებში გამოყენება

თუ URL მისამართი შეიცავს ორ სეგმენტზე მეტს მაშინ საჭიროა ამ სეგმენტთა დასახელებების გამოყენება მეთოდების პარამეტრებად. example.com/index.php/products/shoes/sandals/123 მეთოდს უნდა გადაეცეს URI-ის 3 და 4 სეგმენტები (“sandals” და “123”):
<?php
  class Products extends CI_Controller {

          public function shoes($sandals, $id){
                  echo $sandals;
                  echo $id;
          }
  }
          

ნაგულისმევი კონტროლერის განსაზღვრა

შეიძლება მოხდეს ისე, რომ URL მისამართი არ შეიცავდეს კონტროლერის დასახელებას, მაგალითად იმ შემთხვბევაში თუ ჩვენი საიტის URL-ის მხოლოდ ფუძეს ავკრებთ http://www.your-domain.com ამ შემთხვევისათვის CI-მ წინასწარ უნდა იცოდეს თუ რომელი კონტროლერი ჩატვირთოს ნაგულისმევობის პრინციპით. ამისათვის უნდა გავხსნათ ფაილი application/config/routes.php და მივუთითოთ $route['default_controller'] = 'blog'; სადაც 'blog' არის იმ კონტროლერის სახელი, რომელიც გვსურს, რომ ჩაიტვირთოს გვერდზე შესვლისას.

Private მეთოდები

შესაძლებელია დაგვჭირდეს საჯარო ხელმისაწვდომობისაგან დაცული მეთოდების შექმნა. ამისათვის მეთოდი უნდა აღვწეროთ როგორც private ან protected და ის არ მოხდება URL მოთხოვნაში.
private function _utility(){
        // some code
}
          
ამ მეთოდს ვერ დავუკავშირდებით URL მისამართით example.com/index.php/blog/_utility/

კლასების კონსტრუქტორები

თუ კონტროლერში ვაპირებთ კონსტრუქტორის გამოყენებას, მასში აუცილებლად უნდა მოვათავსოთ შემდეგი კოდი parent::__construct(); ამ ჩანაწერის გამოყენების მიზეზი არის ის, რომ ჩვენს ლოკალურ კონსტრუქტორში მოხდეს მშობელი კლასის კონსტრუქტორის თავიდან განსაზღვრა
<?php
  class Blog extends CI_Controller {

          public function __construct(){
                  parent::__construct();
                  // Your own constructor code
          }
  }
          
კონსტრუქტორების გამოყენება ეფექტურია მაშინ, როდესაც გვინდა რომ ნაგულისმეობის პრინციპით განვსაზღროთ რაიმე მნიშვნელობები ან შევასრულოთ კონკრეტული ოპერაცია კლასის ეგზემპლიარის შექმნისას. კონსტრუქტორები არ აბრუნებენ შედეგს, მაგრამ შეუძლიათ ქმედების შესრულება ნაგულისმეობის პრინციპით.
5. CI - წარმოდგენები
წარმოდგენა არის ვებ-გვერდი ან ვებ-გვერდის ფრაგმენტი (ქუდი, გვერდითი განყოფილება, ძირი და ა.შ). წარმოდგენა შეიძლება ჩადგმული იყოს სხვა წარმოდგენაში (მაგ: საიტის ქუდი და ძირი ძირითადი გვერდის წარმოდგენაში). წარმოდგენის გამოძახება დაუყოვნებლივ არ ხდება, მას იძახებს კონტროლერი, გავიხსენოთ რომ MVC მიდგომაში კონტროლერი მუშაობს როგორც პროექტ-მენეჯერი :)) და ის წყვეტს თუ რომელი წარმოდგენა უნდა ჩაიტვირთოს.

წარმოდგენის შექმნა

წარმოდგენები მოთავსებულია application/views საქაღალდეში, მასში შევქმნათ ფაილი blogview.php შემდეგი კოდით
<html>
<head>
        <title>My Blog</title>
</head>
<body>
        <h1>Welcome to my Blog!</h1>
</body>
</html>
          

წარმოდგენის გამოძახება

წარმოდგენის გამოძახების სინტაქსი შემდეგია $this->load->view('დასახელება'); სადაც "დასახელება" არის საჭირო წარმოდგენის შესაბამისი ფაილის დასახელება რომელიც მოთავსებულია application/views დირექტორიაში, თუ სხვა დირექტორიაში მოთავსებული ფაილის გამოძახება გვსურს სინტაქსი ასეთია $this->load->view('დირექტორია/დასახელება'); .php გაფართოების მითითება აუცილებელი არ არის თუ არ ვიყენებთ სხვა რაიმეს გარდა .php-ისა.

ახლა გავხსნათ ჩვენს მიერ შექმნილი Blog.php კონტროლერი და ჩავწეროთ შემდეგი კოდი

<?php
  class Blog extends CI_Controller {

          public function index(){
                  $this->load->view('blogview');
          }
  }
          
index() მეთოდი იძახებს view() მეთოდს და აწვდის მას არგუმენტად “blogview”-ს რადგან ჩვენ გვჭირდება application/views/blogview.php წარმოდგენის გამოძახება. თუ ახლა შევალთ შემდეგ მისამართზე example.com/index.php/blog/ ბრაუზერში ვიხილავთ blogview.php ფაილში აღწერილი კოდის შესაბამის შიგთავსს.

რამოდენიმე წარმოდგენის ჩატვირთვა ერთდროულად

თუ ერთ კონტროლერში რამოდენიმე წარმოდგენას ჩავტვირთავთ ბრაუზერში გამოვა ერთიანი შედეგი ამ გაერთიანებისა.
<?php

  class Page extends CI_Controller {

          public function index()
          {
                  $data['page_title'] = 'Your title';
                  $this->load->view('header');
                  $this->load->view('menu');
                  $this->load->view('content', $data);
                  $this->load->view('footer');
          }

  }
          

დინამიური ინფორმაციის შეტანა წარმოდგენაში

კონტროლერიდან წარმოდგენაში დინამიური ინფორმაციის გაგზავნა შესაძლებელია მასივის ან ობიექტის მეშვეობით. ამ მასივის ან ობიექტის დასახელება მეორე პარამეტრად უნდა მიეთითოს $this->load->view(); მეთოდს. მასივის შემთხვევაში
$data = array(
        'title' => 'My Title',
        'heading' => 'My Heading',
        'message' => 'My Message'
);

$this->load->view('blogview', $data);
          
ობიექტის შემთხვევაში
$data = new Someclass(); 
$this->load->view('blogview', $data);
გავაკეთოთ ეს ჩვენს Blog.php კონტროლერში
<?php
  class Blog extends CI_Controller {

          public function index()
          {
                  $data['title'] = "My Real Title";
                  $data['heading'] = "My Real Heading";

                  $this->load->view('blogview', $data);
          }
  }
          
წარმოდგენაში ანუ blogview.php ფაილში კი ამ ინფორმაციის გამოტანა მოხდება ასე
<html>
<head>
        <title><?php echo $title;?></title>
</head>
<body>
        <h1><?php echo $heading;?></h1>
</body>
</html>
          

ციკლის გამოყენება წარმოდგენაში

მასივი, რომლის მეშვეობითაც წარმოდგენაში ინფორმაციას ვაგზავნით, შეიძლება შეიცავდეს არა მარტო მარტივ ცვლადებს, ის შეიძლება შეიცავდეს სხვა მასივსაც
<?php
  class Blog extends CI_Controller {

          public function index()
          {
                  $data['todo_list'] = array('Clean House', 'Call Mom', 'Run Errands');

                  $data['title'] = "My Real Title";
                  $data['heading'] = "My Real Heading";

                  $this->load->view('blogview', $data);
          }
  }
          
წარმოდგენაში ამ ინფორმაციის გამოყენება მოხდება შემდეგნაირად
<html>
<head>
        <title><?php echo $title;?></title>
</head>
<body>
        <h1><?php echo $heading;?></h1>

        <h3>My Todo List</h3>

        <ul>
        <?php foreach ($todo_list as $item):?>

                <li><?php echo $item;?></li>

        <?php endforeach;?>
        </ul>

</body>
</html>
          
6. CI - მოდელები
მოდელი არის PHP კლასი რომელიც შექმნილია მონაცემთა ბაზასთან სამუშაოდ. კლასი შეიძლება შეიცავდეს მეთოდებს, რომლებიც მბ-ში წაშლიან, ჩაამატებენ, დაარედაქტირებენ ჩანაწერებს.
class Blog_model extends CI_Model {

        public $title;
        public $content;
        public $date;

        public function get_last_ten_entries() {
                $query = $this->db->get('entries', 10);
                return $query->result();
        }

        public function insert_entry() {
                $this->title    = $_POST['title']; // please read the below note
                $this->content  = $_POST['content'];
                $this->date     = time();

                $this->db->insert('entries', $this);
        }

        public function update_entry() {
                $this->title    = $_POST['title'];
                $this->content  = $_POST['content'];
                $this->date     = time();

                $this->db->update('entries', $this, array('id' => $_POST['id']));
        }

}
          

მოდელის ანატომია

მოდელები განთავსებილია application/models საქაღალდეში. მოდელის საბაზისო პროტოტიპი არის შემდეგი
class Model_name extends CI_Model {

        public function __construct() {
                parent::__construct();
                // Your own constructor code
        }

}
          
Model_name არის კლასის დასახელება, რომელიც უნდა იწყებოდეს დიდი ასოთი, კლასი უნდა იყოს CI-ს კლასის CI_Model-ის მემკვიდრე.

მოდელის ჩატვირთვა

მოდელის გამოძახება შესაძლებელია კონტროლერის მეთოდებში შემდეგი სინტაქსის მიხედვით $this->load->model('model_name'); მოდელის ჩატვირთვის შემდეგ შესაძლებელია მისი თვისებების გამოძახება $this->model_name->method(); კონკრეტული მაგალითი
class Blog_controller extends CI_Controller {

        public function blog(){

          // ჩავტვირთეთ მოდელი
          $this->load->model('blog');

          /*
           წარმოდგენისათვის გადასაცემ მასივს მივაბით მოდელის ფუნქცია,
           მაგალითად ბოლო 10 ჩანაწერის ამოღების ფუნქცია
          */
          $data['query'] = $this->blog->get_last_ten_entries();

          // ჩავტვირთეთ წარმოდგენა და მივამაგრეთ ინფორმაცია
          $this->load->view('blog', $data);
        }
}
          

ავტომატურად ჩამტვირთავი მოდელები

ხშირია შემთხვევები, როდესაც საჭირო ხდება რომ რომელიმე მოდელის კლასი ავტომატურტად გაეშვეს, ჩაიტვირთოს. ამისათვის უნდა გავხსნათ application/config/autoload.php ფაილი და შესაბამისი მოდელები შევიტანოთ $autoload['model'] მასივში $autoload['model'] = array(); ამ მასივში მითითებული მოდელები ჩატვირთული იქნება აპლიკაციის ინიციალიზაციიდან მის გამორთვამდე.
7. CI - დამხმარე ფუნქციები
დამხმარე ფუნქციები, როგორც მათი დასახელებიდან ჩანს, გვეხმარებიან ამოცანათა გადაჭრაში. დამხმარე ფაილის უკან მოიაზრება დამხმარე ფუნქციების ნაკრები. არსებობს URL დამხმარეები, რომლებიც გვეხმარებიან ბმულების შექმნაში, არსებობს ფორმის დამხმარეები, რომლებიც გვეხმარებიან ფორმის ელემენტების შექმნაში და ა.შ. CI-ს დამხმარე ფუნქციები არ არის ჩაწერილი ოოპ სტილში, ეს ფუნქციები ჩაწერილია მარტივი პროცედურული სტილის კოდებით. ყოველი დამხმარე ფუნქცია ასრულებს, სხვა ფუნქციებისაგან დამოუკიდებელ, კონკრეტულ დავალებას.

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

დამხმარეები მოთავსებულია system/helpers ან application/helpers საქაღალდეში, CI ჯერ ამოწმებს application/helpers საქაღალდეს. თუ ეს საქაღალდე არ შეიცავს საჭირო დამხმარეს მაშინ მოწმდება system/helpers დირექტორია.

დამხმარე ფუნქციის ჩატვირთვა

ფუნქციის ჩატვირთვის სინტაქსი ასეთია $this->load->helper('name'); სადაც name არის დამხმარე ფუნქციის შესაბამისი ფაილის დასახელება .php გაფართოებისა და "helper" ნაწილის გარეშე. მაგალითად თუ გვინდა ჩავტვირთოთ URL მისამართების შექმნის დამხმარე ფაილი, რომლის დასახელებაცაა url_helper.php, ვიქცევით ასე $this->load->helper('url'); დამხმარეს ჩატვირთვა შესაძლებელია ნებისმიერ ადგილას კონტროლერში (ან წარმოდგენაში, თუმცა ეს კარგი პრაქტიკა არ არის), ბუნებრივია ჩატვირთვა უნდა მოხდეს დამხმარეს გამოყენებამდე. დამხმარე შეიძლება ჩაიტვირთოს კონტროლერის კონსტრუქტორი მეთოდის დახმარებით და ამის შემდეგ მასთან წვდომა შეგვეძლება კონტროლერის ყველა მეთოდიდან. შესაძლებელია რამოდენიმე დამხმარეს ერთდროულად ჩატვირთვაც $this->load->helper(array('helper1', 'helper2', 'helper3')); თუ გვსურს, რომ რომელიმე დამხმარე ავტომატურად ჩაიტვირთოს ამისათვის application/config/autoload.php ფაილში არსებულ შესაბამის მასივში უნდა შევიტანოთ ამ დამხმარეს დასახელება.

დამხმარეს გამოყენება

მას შემდეგ რაც ჩაიტვირთება დამხმარე, რომელიც შეიცავს საჭირო ფუნქციას, მისი გამოძახება შეგვიძლია ისევე როგორც გამოვიძახებდით სტანდარტულ PHP ფუნქციას. მაგალითად ჩვენს რომელიმე წარმოდგენაში, anchor() ფუნქციის მეშვეობით ბმულის გასაკეთებლად, ვიქცევით ასე <?php echo anchor('blog/comments', 'Click Here');?> სადაც “Click Here” არის ბმულის დასახელება, “blog/comments” კი არის კონტროლერის/მეთოდის URL რომელთან დაკავშირებაც გვინდა.

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

ჩვენი საკუთარი დამხმარეების შექმნა შესაძლებელია application/helpers/ საქაღალდეში. სახელად კი უნდა დავარქვათ უკვევ არსებული ანუ CI-ში ჩაშენებული დამხმარეს სახელი წინსართ MY_-სთან ერთად. ამ წინსართის შეცვლა შესაძლებელია application/config/config.php ფაილში თუ არსებული დამხმარეს მხოლოდ განვრობა გვსურს ამისათვის შექმნილ ფაილში უნდა დავამატოთ შესაბამისი ფუნქციები, ხოლო თუ უკვე მითითებული ფუნქციის გადაკეთება გვსურს მაშინ ახალ დამხმარეში უნდა შევქმნათ იგივე სახელის მქონე საკუთარი ფუნქცია და ის გადაფარავს ძველს.

დამხმარეების უპირატესობა

იმისათვის რათა კარგად გავიგოთ თუ რა უპირატესობა აქვს დამხმარე ფუნქციებს და თუ რატომაა მათი გამოყენება კომფორტული, მოვიყვანოთ კონკრეტული მაგალითი. დავუშვათ გვაქვს ასეთი ამოცანა: მოცემულია ტექსი და გვსურს დავაბრუნოთ ამ ტექსტის პირველი ოთხი სიტყვისაგან შემდგარი სტრიქონი. ჩვეულებრივი PHP კოდით ამ ამოცანის გადაჭრის ერთ-ერთი ვარიანტია შემდეგი: $str = "This is a Codeigniter tutorial";
$array = array_slice(explode(" ",$str),0,4);
echo $new = implode(" ",$array); // This is a Codeigniter
ახლა ვნახოთ თუ როგორ შეიძლება იგივე ამოცანის გადაჭრა ტექსტური დამხმარეს შესაბამისი ფუნქციის მეშვეობით $str = "This is a Codeigniter tutorial";
echo $new = word_limiter($str, 4); // This is a Codeigniter
8. CI - ბიბლიოთეკები
ყველა ხელმისაწვდომი ბიბლიოთეკა მოთავსებულია system/libraries საქაღალდეში, ბიბლიოთეკის კლასის გამოსაყენებლად კონტროლერში უნდა მოვახდინოთ ამ კლასის ინიციალიზაცია შემდეგი სინტაქსის მიხედვით $this->load->library('class_name'); სადაც ‘class_name’ არის საჭირო კასის დასახელება, მაგალითად ჩავტვირთოს ფორმის ვალიდაციის კლასი $this->load->library('form_validation'); შესაძლებელია რამოდენიმე ბიბლიოთეკის ერთდროულად ჩატვირთვაც $this->load->library(array('email', 'table'));

ბიბლიოთეკების შექმნა

ბიბლიოთეკის შექმნისას შესაძლებელია მოვიქცეთ შემდეგნაირად
  • შესაძლებელია შექვქმნათ ახალი ბიბლიოთეკა.
  • შესაძლებელია განვავრცოთ უკვე არსებული ბიბლიოთეკა
  • შესძლებელია ჩავანაცვლოთ არსებული ბიბლიოთეკა ახლით.
ბიბლიოთეკები უნდა მოვათავსოთ b>system/libraries საქაღალდეში. CI სწორედ აქ მოძებნის მათ, მას შემდეგ რაც ბიბლიოთეკების ინიციალიზაციას მოვახდენთ.

სახელის დარქმევის წესები

  • ბიბლიოთეკის ფაილის დასახელება უნდა დაიწყოს დიდი ასოთი, მაგ: Myclass.php
  • კლასის სახელი უნდა დაიწყოს დიდი ასოთი, მაგ: Myclass.
  • ფაილისა და კლასის დასახელებები უნდა ემთხვბეოდეს ერთმანეთს.

კლასის ფაილი

კლასის ძირითადი სტრუქტურა შემდეგნაირია
<?php
  defined('BASEPATH') OR exit('No direct script access allowed');

  class Someclass {

          public function some_method()
          {
          }
  }
          

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

კონტროლერში კლასის ინიციალიზაცია ხდება შემდგენაირად $this->load->library('someclass'); ამის შემდეგ უკვე შესაძლებელია კლასის რომელიმე მეთოდის გამოძახება $this->someclass->some_method();

პარამეტრების გადაცემა კლასის ინიციალიზაციისას

ბიბლიოთეკის ჩატვირთვისას შესაძლებელია მეორე პარამეტრის მეშვეობით მივუთითოთ დამატებითი ინფორმაცია, რომელიც გამოყენებულ იქნება კლასში
            $params = array('type' => 'large', 'color' => 'red'); 
$this->load->library('someclass', $params);
ამის შემდეგ უნდა შევქმნათ კლასის კონსტრუქტორი
<?php defined('BASEPATH') OR exit('No direct script access allowed');

  class Someclass {

          public function __construct($params)
          {
                  // Do something with $params
          }
  }
          

ბიბლიოთეკების კლასები

როგორც ვთქვით, ბიბლიოთეკების კლასები მოთავსებულია system/libraries საქაღალდეში, ყველა კლასს აქვს კონკრეტული ფუნქციონალიტეტი რომელიც ამარტივებს პროექტის წარმოების პროცესს
N ბიბლიოთეკის კლასი & აღწერა
2

Caching Class

This class will cache the pages, to quickly access the page speed.

3

Calendaring Class

Using this class, you can dynamically create calendars.

4

Shopping Cart Class

Using this class, you can add or remove item from Shopping Cart. The items are saved in session and will remain active until the user is browsing the site.

5

Config Class

Configuration preferences can be retrieved, using this class. This class is initialized automatically.

6

Email Class

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

7

Encryption Class

This class provides two-way data encryption functionality.

8

File Uploading Class

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

9

Form Validation Class

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

10

FTP Class

This class provides various FTP related functions like transferring files to remove server, moving, renaming or deleting files on server.

11

Image Manipulation Class

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

12

Input Class

This class pre-processes the input data for security reason.

13

Language Class

This class is used for internationalization.

14

Loader Class

This class loads elements like View files, Drivers, Helpers, Models etc.

15

Migrations Class

This class provides functionalities related to database migrations.

16

Output Class

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

17

Pagination Class

This class adds pagination functionalities to web page.

18

Template Parser Class

The Template Parser Class can perform simple text substitution for pseudo-variables contained within your view files. It can parse simple variables or variable tag pairs.

19

Security Class

This class contains security related functions like XSS Filtering, CSRF etc.

20

Session Library

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

21

HTML Table

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

22

Trackback Class

The Trackback Class provides functions that enable you to send and receive Trackback data.

23

Typography Class

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

24

Unit Testing Class

This class provides functionalities to unit test your application and generate the result.

25

URI Class

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

26

User Agent Class

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

27

XML-RPC and XML-RPC Server Classes

CodeIgniter’s XML-RPC classes permit you to send requests to another server, or set up your own XML-RPC server to receive requests.

28

Zip Encoding Class

ეს კლასი გამოიყენება მონაცემთა zip არქივების შესაქმნელად.

9. CI - URL მარშრუტიზაცია
როგორც ადრე აღვნიშნეთ CI-ს აქვს ადამიანისათვის გასაგები URL მისამართების მხარდაჭერა (რუს: ЧПУ - человекопонятный URL, ინგლ: friendly URL, მაგ: /product/phone/Samsung/), როგორც წესი მჭიდრო კავშირი და ერთი-ერთში მსგავსებაა URL ჩანაწერსა და მისი შესაბამისი კონტროლერების კლასებისა და მეთოდების დასახელებებს შორის. სტანდარტული URI სეგმენტების შაბლონი ასეთია your-domain.com/class/function/id/
  • პირველი სეგმენტი - განსაზღვრავს კონტროლერის კლასის დასახელებას რომელიც უნდა გაეშვას.
  • მეორე სეგმენტი - განსაზღვრავს კლასის მეთოდს, ფუნქციას რომლის გამოძახებაც უნდა მოხდეს.
  • მესამე და კიდევ დამატებითი სეგმენტები განსაზღვრავენ ID-ს და სხვა ცვლადებს, რომლებიც უნდა გადაეცეს კონტროლერს.
არის შემთხვევები, როდესაც საჭიროა მარშრუტიზაციის ამ მექანიზმის შეცვლა, CI საშუალებას გვაძლევს განვსაზღვროთ მარშრუტიზაციის საკუთარი წესები. მაგალითად გვსურს შემდეგნაირი URL მისამართების გამოყენება example.com/product/1/
example.com/product/2/
example.com/product/3/
example.com/product/4/
ამ მისამართების მეორე სეგმენტებში კლასის მეთოდის ნაცვლად გამოყენებულია ID პარამეტრები. ამ შემთხვევაში საჭიროა მარშრუტიზაციის ახალი წესების განსაზღვრა.

სამომხმარებლო მარშრუტები

არსებობს კონკრეტული ფაილი რომელშიც შესაძლებელია საკუთარი მარშრუტების განსაზღვრა, ეს ფაილია - application/config/routes.php. ფაილში აღწერილია მასივი სახელად $route რომელშიც შესაძლებელია მარშრუტიზაციის საკუთარი წესების შეტანა, ამ მასივის გასაღები/მნიშველობა წყვილებიდან გასაღები გასაღები წყვეტს თუ რისი მარშრუტიზაციაა საჭირო, მნიშვნელობა კი წყვეტს თუ საით უნდა მიიმართოს მარშრუტი, მარშრუტის განსაზღვრა შესაძლებელია ჩანაცვლების სიმბოლოებით (wildcards) ან რეგულარული გამოსახულებებით. მაგრამ უნდა გავითვალისწინოთ, რომ ჩვენს მიერ შედგენილი მარშრუტიზაციის წესები უნდა აღიწეროს CI-ს რეზერვირებული წესების შემდეგ.

ჩანაცვლების სიმბოლოები (wildcards)

შესაძლებელია ორი სახის ჩანაცვლების სიმბოლოების გამოყენება
  • (:num) - აღიქვამს მხოლოდ რიცხვების შემცველ სეგმენტს.
  • (:any) - აღიქვამას სხვადასხვა სიმბოლოების შემცველ სეგმენტს.
ჩანაცვლების სიმბოლოების შემცველი მარშრუტი შეიძლება გამოიყურებოდეს შემდეგნაირად $route['product/:num'] = 'catalog/product_lookup'; ანუ თუ URL მისამართის პირველ სეგმენტში მოიძებნება სიტყვა "product", ხოლო მეორე სეგმენტში კი რიცხვი, მაშინ ჩაიტვირთება კლასი "catalog" და მეთოდი "product_lookup".

მაგალითები

$route['journals'] = 'blogs'; URL მისამართი რომელიც პირველ სეგმენტში შეიცავს სიტყვას - “journals” გადამისამართდება “blogs” კლასისკენ. $route['blog/joe'] = 'blogs/users/34'; URL მისამართი რომელიც შეიცავს blog/joe სეგმენტებს გადამისამართდება “blogs” კლასისა და მისი “users” მეთოდისაკენ. ID პარამეტრის მნიშვნელობა კი იქნება “34”.

რეგულარული გამოსახულებები

$route მასივის გასაღებად შესაძლებელია რეგულარული გამოსახულებების გამოყენებაც, თუ URI დაემთხვევა რეგულარულ გამოსახულებას მაშინ მარშრუტი წარემართება $route მასივის ამ გასაღების შესაბამის მნიშვნელობაში მითითებული მისამართისკენ. $route['products/([a-z]+)/(\d+)'] = '$1/id_$2'; ამ მაგალითის მიხედვით თუ URL მისამართს ექნება დაახლოებით ამგვარი სახე - "products/shoes/123", გამოძახებულ იქნება კლასი “shirts” და მეთოდი “id_123”.

რეზერვირებული მარშრუტები

CI-ში არის სამი რეზერვირებული მარშრუტი
N მარშრუტის აღწერა
1

$route['default_controller']

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

2

$route['404_override']

ეს მარშრუტი განსაზღვრავს თუ რომელი კონტროლერის კლასი უნდა ჩაიტვირთოს თუ მოთხოვნილი კონტროლერი ვერ მოიძებნენა, ამ მარშრუტში განსაზღრული კლასი გადაფარავს 404 შეცდომის შეტყობინების გვერდს. ეს გავლენას არ მოახდენს show_404() ფუნქციის მუშაობაზე, რომელიც გააგრძელებს ნაგულისხმეობის პრინციპით ფაილის ჩატვირთვას application/views/errors/error_404.php.

3

$route['translate_uri_dashes']

როგორც ლოგიკური მნიშვნელობიდან ჩანს ეს მარშრუტი არ არის, ეს თვისება საშუალებას გვაძლევს URL-ის სეგმენტებში არსებული ტირეები: "-", ავტომატურად შეიცვალოს ქვედა ტირეებით "_", ამის გაკეთება აუცილებელია რადგან ტირე არ ითვლება კლასის ან მეთოდის სახელში დასაშვებ სიმბოლოდ, და მისი URL-ში მოხვედრა გამოიწვევს Fatal ტიპის შეცდომას.

10. CI - ალტერნატიული PHP სინტაქსი
შესაძლებელია მოხდეს ისე, რომ წარმოდგენის ფაილში დაგვჭირდეს PHP კოდის გამოყენება. იმისათვის რათა წარმოდგენის ფაილში გჰამოვიყენოთ PHP კოდის მინიმალური რაოდენობა და კოდის ბლოკების იდენტიფიკაციაც მარტივი იყოს, რეკომენდებულია PHP-S ალტერნატიული სინტაქსის გამოყენება.

ალტერნატიული ECHO

როგორც წესი, echo ოპერატორით ცვლადის გამოტანის სინტაქსი შემდეგნაირია <?php echo $variable; ?> ალტერნატიული სინტაქსი კი ასეთი <?=$variable?>

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

საკონტროლო სტრუქტურების (if, for, foreach და while) ჩაწერის ალტერნატიული ვარიანტი მოვიყვანოთ foreach ციკლის მაგალითზე
<ul>

<?php foreach ($todo as $item): ?>

        <li><?=$item?></li>

<?php endforeach; ?>

</ul>
          
შევნიშნოთ, რომ არ ხდება ფიგურული ფრჩხილების გამოყენება, დამხურავი ფიგურული ფრჩხილი ჩანაცვლებულია endforeach-ით. შესაბამისად სხვა საკონტროლო სტრუქტურების დამხურავი ელემენტებია endif, endfor, endforeach და endwhile.

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

<?php if ($username === 'sally'): ?>

        <h3>Hi Sally</h3>

<?php elseif ($username === 'joe'): ?>

        <h3>Hi Joe</h3>

<?php else: ?>

        <h3>Hi unknown user</h3>

<?php endif; ?>          
11. CI - უსაფრთხოება

URL უსაფრთხოება

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

შეცდომების გამოტანა

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

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

საუკეთესო პრაქტიკა

მანამ სანამ დავთანხმდებით, რომ ესა თუ ის ინფორმაცია გადაეცეს აპლიკაციას (მაგ: POST მეთოდით ფორმიდან გამოგზავნილი ინფორმაცია) სასურველია ამ ინფორმაციამ გაიაროს შემდეგი საფეხურები
  1. ვალიდაცია (სწორია თუ არა ტიპი, სიგრძე, ზომა და ა.შ)
  2. ფილტრი (ხომ არ შეიცავს არასასურველ სიმბოლოებს და ა.შ)
  3. გასუფთავება (თუ შეიცავს არასასურველ სიმბოლოებს წაიშაოლოს ეს სიმბოლოები)

ფორმის ელემენტებიდან აკრეფილი ინფორმაციის ვალიდაცია

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

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

უსაფრთხოების კიდევ ერთი კარგი პრაქტიკაა, რომ ჩვენი index.php ფაილი და სხვა ძირითადი ფაილები (მაგ .js, css და ა.შ) დავტოვოთ პროექტის ძირითად საქაღალდეში (ხშირ შემთხვევაში მას ჰქვია htdocs/”). ეს ის ფაილებია, რომელთა მიღებაც დაგვჭირდება ინტერნეტიდან.

არ არის სასურველი მომხმარებელს მიეცეს შესაძლებლობა ნახოს ისეთი ფაილები და საქაღალდეები რომლების ნახვაც არ არის საჭირო და აუცილებელი.

ასეთი ფაილების და საქაღალდეების დასამალად შესაძლებელია .htaccess ფაილის გამოყენებაც.

12. CI - PHP კოდის სტილი

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

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

არასწორია

somelibrary.php
someLibrary.php
SOMELIBRARY.php
Some_Library.php

Application_config.php
Application_Config.php
applicationConfig.php

სწორია

Somelibrary.php
Some_library.php

applicationconfig.php
application_config.php
გარდა ამისა, კლასის ფაილების დასახელებები უნდა დაემთხვეს თავად კლასის დასახელებებს, მაგალითად თუ გვაქვს კლასი "Myclass", მის შესაბამის ფაილს უნდა დავარქვათ "Myclass.php".

კლასთა და ფაილთა დასახელებები

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

არასწორია

class superclass
class SuperClass

სწორია

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

არასწორია

function fileproperties() // არ აღწერს მეთოდის შინაარს და აკლია სიტყვათა გამომყოფი
function fileProperties() // არ აღწერს მეთოდის შინაარს და ჩაწერილია აქლემისებური სტილით
function getfileproperties() // უკეთესია ! მაგრამ აკლია სიტყვათა გამომყოფი
function getFileProperties() // ჩაწერილია აქლემისებური სტილით
function get_the_file_properties_from_the_file() // სიტყვაგრძელია

სწორია

/*
   აღწერს მეთოდის შინაარს,
   მითითებულია გამომყოფი,
   ჩაწერილია პატარა ასოებით
*/
function get_file_properties()

ცვლადთა დასახელებები

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

არასწორია

$j = 'foo'; // ერთასოიანი დასახელება for() ციკლის გარეთ
$Str // შეიცავს დიდ ასოებს
$bufferedText // იყენებს აქლემისებურ სტილს, შესაძლებელია უფრო მოკლედ ჩაწერაც
$groupid // რამოდენიმე სიტყვა გამყოფის გარეშე
$name_of_last_city_used // გრძელი დასახელება

სწორია

for ($j = 0; $j < 10; $j++)
$str
$buffer
$group_id
$last_city

კომენტარები კოდში

კომენტარები კოდში, ეხმარება არა მარტო ნაკლებად გამოცდილ პროგრამისტს, არამედ შესაძლებელია ჩვენთვისაც ძალიან მნიშვნელოვანი აღმოჩნდეს რამოდენიმე თვის შემდეგ საკუთარი კოდის ნახვისას. "DocBlock" სტილის კომენტარების გამოყენება მიზანშეწონილია კლასების, მეთოდების და თვისებების აღწერისას.
/**
 * Super Class
 *
 * @package     Package Name
 * @subpackage  Subpackage
 * @category    Category
 * @author      Author Name
 * @link        http://example.com
*/
class Super_class {
          
ერთხაზიანი კომენტარების გამოყენებისას სასურველია კომენტარის ბლოკებს შორის დავამატოთ გამოტოვებული ხაზები
// break up the string by newlines
$parts = explode("\n", $str);

// A longer comment that needs to give greater detail on what is
// occurring and why can use multiple single-line comments.  Try to
// keep the width reasonable, around 70 characters is the easiest to
// read.  Don't hesitate to link to permanent external resources
// that may provide greater detail:
//
// http://example.com/information_about_something/in_particular/

$parts = $this->foo($parts);
          

კონსტანტები

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

არასწორია

myConstant // არ არის ჩაწერილი დიდი ასოებით
N // ჩაწერილია ერთი ასოთი
S_C_VER // არ აღწერს შინაარსს, დანიშნულებას

სწორია

MY_CONSTANT
NEWLINE
SUPER_CLASS_VERSION

TRUE, FALSE და NULL

TRUE, FALSE და NULL სიტყვა გასაღებები ყოველთვის უნდა ჩაიწეროს დიდი ასოებით.

არასწორია

if ($foo == true)
$bar = false;
function foo($bar = null)

სწორია

if ($foo == TRUE)
$bar = FALSE;
function foo($bar = NULL)

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

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

არასწორია

if ($foo || $bar)
if ($foo AND $bar)
if (!$foo)
if (! is_array($foo))

სწორია

if ($foo OR $bar)
if ($foo && $bar) // recommended
if ( ! $foo)
if ( ! is_array($foo))

დასაბრუნებელი მნიშვნელობების ტოლობები

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

არასწორია

// თუ 'foo' გვხვდება სტრიქონის დასაწყისში, strpos დააბრუნებს 0-ს,
// ლოგიკური პირობის მნიშვნელობა შეფასდება როგორც TRUE
if (strpos($str, 'foo') == FALSE)

სწორია

if (strpos($str, 'foo') === FALSE)

არასწორია

function build_string($str = ""){
        if ($str == "") // მაგრამ რა მოხდება თუ FALSE ან 0 გადაიცემა არგუმენტად ?
        {

        }
}
          

წორია

function build_string($str = ""){
        if ($str === "")
        {

        }
}
          

ბრჭყალები და ფრჩხილები

როგორც წესი ბრჭყალებისა და ფრჩხილების ირგვლივ გამოტოვებული ადგილების დატოვება არ არის საჭირო, გამონაკლისია PHP-ს სტრუქტურული მმართველების (do-while, elseif, for, foreach, if, switch, while) ჩაწერა, რომლებიც არგუმენტებს იღებენ მრგვალი ფრჩხილების საშუალებით, და ამ ფრჩხილებში ადგილის გამოტოვება უფრო ადვილად წასაკითხს ხდის კოდს.

არასწორია

$arr[ $foo ] = 'foo';

წორია

$arr[$foo] = 'foo'; // მასივის გასაღების ირგვლივ არაა საჭირო ადგილების გამოტოვება

არასწორია

function foo ( $bar ){

}
          

წორია

function foo($bar){

}
          

არასწორია

foreach( $query->result() as $row )

წორია

foreach ($query->result() as $row)

ერთი ჩანაწერი ერთ ხაზზე

არასწორია

$foo = 'this'; $bar = 'that'; $bat = str_replace($foo, $bar, $bag);

წორია

$foo = 'this';
$bar = 'that';
$bat = str_replace($foo, $bar, $bag);

სტრიქონები

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

არასწორია

"My String" // არ გვაქვს ცვლადი სტრიქონში
"My string $foo" // ცვლადი არ ზის ფიგურულ ბრჩხილებში
'SELECT foo FROM bar WHERE baz = \'bag\''

წორია

'My String'
"My string {$foo}"
"SELECT foo FROM bar WHERE baz = 'bag'"

SQL მოთხოვნები

SQL სიტყვა გასაღებები ყოველთვის იწერება დიდი ასოებით : SELECT, INSERT, UPDATE, WHERE, AS, JOIN, ON, IN და ა.შ. თუ მოთხოვნის ტექსტი საკმაოდ გრძელია სასურველია მისი ფრაგმენტები განვათავსოთ ახალ ხაზებზე.

არასწორია

// სიტყვა გასაღებები პატარა ასოებითაა ჩაწერილი
// და მოთხოვნაც გრძელია ერთ ხაზზე ჩასაწერად
$query = $this->db->query("select foo  as raboof, foobaz from exp_pre_email_addresses
...where foo != 'oof' and baz != 'zab' order by foobaz limit 5, 100");
          

წორია

$query = $this->db->query("SELECT foo AS raboof, foobaz
                                FROM exp_pre_email_addresses
                                WHERE foo != 'oof'
                                AND baz != 'zab'
                                ORDER BY foobaz
                                LIMIT 5, 100");
          
13. CI - კონფიგურაცია
application/config საქაღალდე შეიცავს ფაილებს რომლებშიც უნდა განვსაზღვროთ ჩვენი საიტის ძირითადი კონფიგურაციული პარამეტრები.

საბაზისო URL მისამართის განსაზღვრა

საბაზისო URL მისამართის განსაზღვრა შესაძლებელია application/config/config.php ფაილში, საბაზისო URL არის ჩვენი CI პროექტის ძირის მისამართი http://example.com/ თუ საბაზისო URL მითითებული არ არის CI შეეცდება გამოიცნოს პროტოკოლი, დომეინი და გზა ჩვენს აპლიკაციამდე, ასეა თუ ისე ეს პარამეტრი ყოველთვის უნდა განცსაზღვროთ, განსაკუთრებით მაშინ როცა პროექტი უკვე გაშვებულია სამუშაო გარემოში. საბაზისო URL-ის განსაზღვრა შესაძლებელია $config მასივში base_url გასაღების მეშვეობით $config['base_url'] = 'http://your-domain.com';

მონაცემთა ბაზის კონფიგურაცია

მონაცემთა ბაზის კონფიგურაციაზე ვისაუბრებთ "CI - მონაცემთა ბაზასთან მუშაობა" განყოფილების მე-2-ე თავში.

ავტომატური ჩატვირთვის კონფიგურაცია

ავტომატური ჩატვირთვის კონფიგურაციული პარამეტრების განსაზღვრა ხდება ფაილში application/config/autoload.php. ეს ფაილი განსაზღვრავს რომელი სისტემები უნდა ჩაიტვირთოს ავტომატურად, იმისათვის რათა სტრუქტურა მასიმალურად გამარტივდეს, ნაგულისმეობის პრინციპით ხდება აბსოლიტურად მინიმალური რესურსების ჩატვირთვა.
  • Libraries - ეს არის ბიბლიოთეკების სია რომლებიც ავტომატურად ჩაიტვირთება CI-ს მიერ. ამისათვის ეს ბიბლიოთეკები უნდა მოთავსდეს მასივში, მაგალითად ჩავტვირთოთ database, email და session ბიბლიოთეკები
$autoload['libraries'] = array('database', 'email', 'session');
  • Helper files - ეს არის დამხმარე ფაილების სია რომლებიც ავტომატურად ჩაიტვირთება CI-ს მიერ. ამისათვის ამ ფაილთა დასახელებები უნდა მოთავსდეს მასივში, მაგალითად ჩავტვირთოთ URL და file დამხმარე ფაილები.
$autoload['helper'] = array('url', 'file');
  • Language files - ეს არის ენის ფაილების სია რომლებიც ავტომატურად ჩაიტვირთება CI-ს მიერ. ამისათვის ამ ენათა დასახელებები უნდა მოთავსდეს მასივში
$autoload['language'] = array('lang1', 'lang2');


CI - დამხმარეები



1. CI - მასივის დამხმარე
მასივთან მუშაობისას გამოსაყენებელი დამხმარე ფუნქციების შემცველი ფაილის ჩატვირთვა ხდება შემდეგნაირად $this->load->helper('array');

ხელმისაწვდომი ფუნქციები

element()

სინტაქსი ასეთია element($item, $array[, $default = NULL])
  • $item - ელემენტი რომლის ამოღებაც გვსურს მასივიდან
  • $array - შესაბამისი მასივი
  • $default - რა დაბრუნდეს თუ ვერ მოიძებნება საჭირო პასუხი
ფუნქცია ადგენს აქვს თუ არა მასივს ესა თუ ის ინდექსი ან მითითებულია თუ არა რომელიმე ინდექსის მნიშვნელობა. თუ მასივის გასაღების მნიშვნელობა არ არის მითითებულიფუნქცია, ფუნქცია აბრუნებს NULL-ს ან იმ მნიშვნელობას რასაც მესამე პარამეტრად მივუთითებთ.
$array = array(
        'color' => 'red',
        'shape' => 'round',
        'size'  => ''
);

echo element('color', $array); // დაბრუნდება "red"
echo element('size', $array, 'foobar'); // დაბრუნდება "foobar"
            

elements()

elements ფუნქციაც მუშაობს element ფუნქციის ანალოგიურად, უბრალოდ მისი დახმარებით შესაძლებელია რამოდენიმე ელემენტის ერთდროულად ამოღება.
$array = array(
        'color' => 'red',
        'shape' => 'round',
        'radius' => '10',
        'diameter' => '20'
);

$my_shape = elements(array('color', 'shape', 'height'), $array);
            
შედეგი იქნება
array(
        'color' => 'red',
        'shape' => 'round',
        'height' => NULL
);
            
შეგვიძლია მესამე პარამეტრის გადაცემაც $my_shape = elements(array('color', 'shape', 'height'), $array, 'foobar'); შედეგი
array(
        'color'         => 'red',
        'shape'         => 'round',
        'height'        => 'foobar'
);
            
elements ფუნქციის გამოყენება ეფექტურია როდესაც რომელიმე მოდელს ინფორმაცია ეგზავნება $_POST მასივით.
  $this->load->model('post_model');
  $this->post_model->update(
          elements(array('id', 'title', 'content'), $_POST)
  );
            
ეს ჩანაწერი არ აძლევს მომხმარებელს საშუალებას გააგზავნოს ისეთი ინფორმაცია რომელიც არ უნდა შევიდეს ცხრილში, ანუ ამ შემთხვევაში ცხრილში განახლდება მხოლოდ id, title და content ველები.

random_element()

ფუნქცია გამოიყენება მასივიდან შემთხვევითი ელემენტის ამოსაღებად. random_element($array)
$quotes = array(
        "თბილისი",
        "ქუთაისი",
        "მცხეთა",
        "ბათუმი",
        "ცხინვალი",
        "სოხუმი"
);

echo random_element($quotes);
            
2. CI - ელ_ფოსტის დამხმარე
ელ_ფოსტის დამხმარე მოიცავს ფუნქციებს, რომლებიც გვეხმარებიან ელ_ფოსტასთან მუშაობისას, ჩატვირთვა ხდება შემდეგნაირად $this->load->helper('email');

valid_email()

ამოწმებს არის თუ არა კორექტული ელ_ფოსტა პარამეტრად გადაცემული სტრიქონი. აბრუნებს TRUE/FALSE მნიშვნელობებს.
if (valid_email('email@somesite.com')){
        echo 'email is valid';
}
else{
        echo 'email is not valid';
}
          

send_email()

send_email($recipient, $subject, $message) ფუნქცია აბრუნებს TRUE/FALSE მნიშვნელობებს იმისდამიხედვით გაიგზავნა თუ არა ელ_ფოსტა.
3. CI - ფაილების დამხმარე
ჩატვირთვა ხდება შემდეგნაირად $this->load->helper('file');

file_get_contents()

აბრუნებს ფაილის შიგთავსს ან FALSE-ს წარუმატებლობის შემთხვევაში, სინტაქსი ასეთია $string = file_get_contents('./path/to/file.php'); ფაილამდე გზა აღიქმება და უნდა ჩაიწეროს ძირითადი ფაილის index.php-სთან მიმართებაში და არა კონტროლერებთან ან წარმოდგენებთან მიმართებაში, CI იყენებს index.php ფაილს იყენებს როგორც მთავარ კონტროლერს და ამიტომ ბილიკები (pats) იწერება მასთან მიმართებაში.

delete_files()

შლის ყველა ფაილს მითითებულ საქაღალდეში სინტაქსი ასეთია delete_files($path[, $del_dir = FALSE[, $htdocs = FALSE]]) $path პარამეტრი განსაზღვრავს თავად საქაღალდეს, $del_dir პარამეტრი არის ლოგიკური ტიპის TRUE/FALSE და განსაზღვრავს წაიშალოს თუ არა დირექტორიაში არსებული სხვა დირექტორიებიც, $del_dir პარამეტრიც არის ლოგიკური ტიპის TRUE/FALSE და განსაზღვრავს წაიშალოს თუ არა დირექტორიაში არსებული .htaccess და index page ფაილები. მთლიანობაში ფუნქცია აბრუნებს TRUE/FALSE მნიშვნელობებს წარმატებიდან გამომდინარე delete_files('./path/to/directory/');

get_file_info()

აბრუნებს ინფორმაციას მითიტებული ფაილის შესახებ (სახელი, გზა ფაილამდე, ზომა განახლების თარიღი). $file = 'somefile.png';
echo get_file_info($file);
4. CI - ფორმების დამხმარე
ჩატვირთვის სინტაქსი $this->load->helper('form');

form_open()

ფუნქცია აბრუნებს HTML ფორმის გამხსნელ ტეგს. ფუნქციის სინტაქსი ასეთია form_open([$action = ''[, $attributes = ''[, $hidden = array()]]]) $action პარამეტრი განსაზღვრავს ფორმის action ატრიბუტს, ანუ გვერდს სადაც უნდა გაიგზავნოს ინფორმაცია ფორმიდან, $attributes პარამეტრი განსაზღვრავს HTML ატრიბუტებს, $hidden ატრიბუტი განსაზღვრავს დამალულ ველებს. echo form_open('email/send'); ეს ჩანაწერი შექმნის ფორმის გამხსნელ ტეგს და ტოლფასია შემდეგი ჩანაწერისა <form method="post" accept-charset="utf-8" action="http://example.com/index.php/email/send">

ატრიბუტების დამატება

ფორმის ატრიბუტების დასამატებლად, form_open() ფუნქციას მეორე პარამეტრად უნდა გადავცეთ ასოციაციური მასივი, რომელშიც თავმოყრილი იქნება ატრიბუტი/მნიშვნელობა წყვილები. $attributes = array('class' => 'email', 'id' => 'myform');
echo form_open('email/send', $attributes);
ამ ჩანაწერის ალტერნატიული ვარიანტი ატრიბუტების სტრიქონის სახით აღწერაა echo form_open('email/send', 'class="email" id="myform"'); ორივე შემთხვევაში მივიღებთ შედეგს <form method="post" accept-charset="utf-8" action="http://example.com/index.php/email/send" class="email" id="myform">

დამალული ველები

დამალული ველების დასამატებლად, form_open() ფუნქციას მესამე პარამეტრად უნდა გადავცეთ ასოციაციური მასივი $hidden = array('username' => 'Joe', 'member_id' => '234');
echo form_open('email/send', '', $hidden);
შედეგი იქნება
<form method="post" accept-charset="utf-8" action="http://example.com/index.php/email/send">
    <input type="hidden" name="username" value="Joe" />
    <input type="hidden" name="member_id" value="234" />
          

form_open_multipart()

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

form_input()

საშუალებას გვაძლევს შევქმნათ ჩვეულებრივი ტექსტური ტიპის შესაყვანი ველი. სინტაქსი ასეთია form_input([$data = ''[, $value = ''[, $extra = '']]]) $data პარამეტრი განსაზღვრავს ატრიბუტების მასივს, $value პარამეტრი განსაზღვრავს ველის "value" მნიშვნელობას, $extra ატრიბუტი განსაზღვრავს ექსტრა-ატრიბუტების მასივს. შევქმნათ ტექსტის შესაყვანი სტანდარტული ველი, მას გადავცეთ "name" და "value" ატრიბუტები echo form_input('username', 'johndoe'); ან შესაძლებელია ატრიბუტების ასოიციაციურ მასივში თავმოყრა და ამ მასივის form_input() ფუნქციის პარამეტრად მითითება
$data = array(
        'name'          => 'username',
        'id'            => 'username',
        'value'         => 'johndoe',
        'maxlength'     => '100',
        'size'          => '50',
        'style'         => 'width:50%'
);

echo form_input($data);

/*
შედეგი:

<input type="text" name="username" value="johndoe" id="username" maxlength="100" size="50" style="width:50%"  />
*/
          
თუ გვსურს, რომ ფორმა შეიცავდეს დამატებით ინფორმაციას, მაგალითად Javascript-ს, ეს ინფორმაცია შეგვიძლია გადავცეთ სტრიქონის სახით მესამე პარამეტრად $js = 'onClick="some_function()"';
echo form_input('username', 'johndoe', $js);
ან $js = array('onClick' => 'some_function();');
echo form_input('username', 'johndoe', $js);

form_password()

ფუნქცია არის form_input() ფუნქციის ანალოგიური, უბრალოდ ქმნის “password” ტიპის ველებს.

form_upload()

ფუნქცია არის form_input() ფუნქციის ანალოგიური, უბრალოდ ქმნის “file” ტიპის ველებს.

form_textarea()

ფუნქცია არის form_input() ფუნქციის ანალოგიური, უბრალოდ ქმნის “textarea” ელემენტს, მივაქციოთ ყურადღება იმას რომ, ზედა მაგალითში მოყვანილი "maxlength" და "size" ატრიბუტების ნაცვლად უნდა მივუთითოთ, "rows" და "cols".

form_dropdown()

ფუნქცია გამოიყენება HTML <select> ელემენტის შესაქმნელად, სინტაქსი ასეთია form_dropdown([$name = ''[, $options = array()[, $selected = array()[, $extra = '']]]]) პირველი განსაზღვრავს ელემენტის სახელს, მეორე პარამეტრი არის მასივი, რომელშიც შეტანილია <option> ელემენტების დასახელებები და მნიშვნელობები, მესამე პარამეტრი კი განსაზღვრავს თუ რომელი <option> ელემენტის ამორჩევა უნდა მოხდეს ავტომატურად
$options = array(
        'small'         => 'Small Shirt',
        'med'           => 'Medium Shirt',
        'large'         => 'Large Shirt',
        'xlarge'        => 'Extra Large Shirt',
);

$shirts_on_sale = array('small', 'large');
echo form_dropdown('shirts', $options, 'large');

/*
        შედეგი :

        <select name="shirts">
                <option value="small">Small Shirt</option>
                <option value="med">Medium  Shirt</option>
                <option value="large" selected="selected">Large Shirt</option>
                <option value="xlarge">Extra Large Shirt</option>
        </select>
*/
          

form_checkbox()

საშუალებას გვაძლევს შევქმნათ "checkbox" ტიპის ღილაკი, სინტაქსი ასეთია form_checkbox([$data = ''[, $value = ''[, $checked = FALSE[, $extra = '']]]]) $data პარამეტრი განსაზღვრავს ატრიბუტების მასივს, $value ატრიბუტი განსაზღვრავს ელემენტის მნიშვნელობას, $checked ატრიბუტი არის ლოგიკური ტიპის და განსაზღვრავს ავტომატურად მოინიშნოს თუ არა ღილაკი, $extra ატრიბუტი განსაზღვრავს დამატებით ინფორმაციას echo form_checkbox('newsletter', 'accept', TRUE);
// შედეგი : <input type="checkbox" name="newsletter" value="accept" checked="checked" />
$data = array(
        'name'          => 'newsletter',
        'id'            => 'newsletter',
        'value'         => 'accept',
        'checked'       => TRUE,
        'style'         => 'margin:10px'
);

echo form_checkbox($data);
// შედეგი: <input type="checkbox" name="newsletter" id="newsletter" value="accept" checked="checked" style="margin:10px" />
          
თუ გვსურს, რომ ელემენტი შეიცავდეს დამატებით ინფორმაციას, მაგალითად Javascript-ს, ეს ინფორმაცია შეგვიძლია გადავცეთ სტრიქონის სახით მესამე პარამეტრად $js = 'onClick="some_function()"';
echo form_checkbox('newsletter', 'accept', TRUE, $js);
შესაძლებელია ამ ინფორმაციის მასივში მოქცევაც $js = array('onClick' => 'some_function();');
echo form_checkbox('newsletter', 'accept', TRUE, $js);

form_radio()

ფუნქცია იდენტურია წინა ფუნქციისა, უბრალოდ ქმნის "radio" ტიპის ღილაკს.

form_label()

ფუნქციის საშუალებით იქმნება <label> ელემენტი, სინტაქსი ასეთია form_label([$label_text = ''[, $id = ''[, $attributes = array()]]]) $label_text პარამეტრი განსაზღვრავს ელემენტის ტექსტს, $id პარამეტრი განსაზღვრავს თუ რომელი ელემენტისათვის ვქმნით <label> ელემენტს, $attributes პარამეტრი განსაზღვრავს HTML ატრიბუტებს. echo form_label('What is your Name', 'username');
// შედეგი : <label for="username">What is your Name</label>
$attributes = array(
        'class' => 'mycustomclass',
        'style' => 'color: #000;'
);

echo form_label('What is your Name', 'username', $attributes);
// შედეგი :  <abel for="username" class="mycustomclass" style="color: #000;">What is your Name</label>
          

form_submit()

ფუნქციის საშუალებით იქმნება სტანდარტული "submit" ტიპის ღილაკი, სინტაქსი ასეთია form_submit([$data = ''[, $value = ''[, $extra = '']]]) $data პარამეტრი განსაზღვრავს ღილაკის სახელს, $value პარამეტრი მის ტექსტს, $extra პარამეტრი დამატებით ინფორმაციას. echo form_submit('mysubmit', 'Submit Post!');
// შედეგი : <input type="submit" name="mysubmit" value="Submit Post!" />
დამატებითი ინფორმაციის, მაგალითად JavaScript-ის მიბმის მაგალითები უკვე ვნახეთ.

form_reset()

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

form_button()

ფუნქციის საშუალებით იქმნება სტანდარტული "submit" ტიპის ღილაკი, სინტაქსი ასეთია form_button([$data = ''[, $content = ''[, $extra = '']]]) $data პარამეტრი განსაზღვრავს ღილაკის სახელს, $value პარამეტრი მის ტექსტს, $extra პარამეტრი დამატებით ინფორმაციას. echo form_button('name','content');
// შედეგი : <button name="name" type="button">Content</button>
$data = array(
        'name'          => 'button',
        'id'            => 'button',
        'value'         => 'true',
        'type'          => 'reset',
        'content'       => 'Reset'
);

echo form_button($data);
// შედეგი : <button name="button" id="button" value="true" type="reset">Reset</button>
          
დამატებითი ინფორმაციის, მაგალითად JavaScript-ის მიბმის მაგალითები უკვე ვნახეთ.

form_close()

ფუნქცია ქმნის ფორმის დამხურავ ტეგს. form_close([$extra = '']) $extra პარამეტრად შეგვიძლია მივუთითოთ იმ ელემენტების კოდი, რომელიც გვინდა რომ ფორმის შემდეგ შეიქმნას. $string = '</div></div>'; echo form_close($string); // შედეგი : </form> </div></div>
5. CI - HTML დამხმარე
დამხმარეს ჩატვირთვა ხდება შემდეგნაირად $this->load->helper('html');

heading()

ფუნქციის საშუალებით იქმნება h1-h6 HTML სათაურები, სინტაქსი შემდეგნაირია heading([$data = ''[, $h = '1'[, $attributes = '']]]) $data პარამეტრი განსაზღვრავს სათაურის ტექსტს, $h პარამეტრი განსაზღვრავს თუ რა ზომის უნდა იყოს სათაური (1-6), $attributes განსაზღვრავს HTML ატრიბუტებს. echo heading('Welcome!', 3, 'class="pink"');
echo heading('How are you?', 4, array('id' => 'question', 'class' => 'green'));
შედეგი <h3 class="pink">Welcome!<h3>
<h4 id="question" class="green">How are you?</h4>

img()

ფუნქცია ქმნის HTML <img /> ტეგს, სინტაქსი ასეთია img([$src = ''[, $index_page = FALSE[, $attributes = '']]]) $src ატრიბუტი განსაზღვრავს სურათის წყაროს, $attributes ატრიბუტი განსაზღვრავს HTML ატრიბუტებს echo img('images/picture.jpg'); // შედეგი : <img src="http://site.com/images/picture.jpg" />
$image_properties = array(
        'src'   => 'images/picture.jpg',
        'alt'   => 'alt text',
        'class' => 'post_images',
        'width' => '200',
        'height'=> '200',
        'title' => 'title text',
        'rel'   => 'lightbox'
);

img($image_properties);
// შედეგი :<img src="http://site.com/index.php/images/picture.jpg" alt="alt text" class="post_images" width="200" height="200" title="title text" rel="lightbox" />
          

ul()

ქმნის HTML <ul> ელემენტს, სინტაქსი ასეთია ul($list[, $attributes = ''])
$list = array(
        'red',
        'blue',
        'green',
        'yellow'
);

$attributes = array(
        'class' => 'boldlist',
        'id'    => 'mylist'
);

echo ul($list, $attributes);
          
შედეგი იქნება <ul class="boldlist" id="mylist"> <li>red</li> <li>blue</li> <li>green</li> <li>yellow</li> </ul> ანალოგიურად მუშაობს ol() ფუნქციაც.

meta()

ფუნქცია გვეხმარება მეტა-ტეგების ფორმირებაში, სინტაქსი ასეთია meta([$name = ''[, $content = ''[, $type = 'name'[, $newline = "n"]]]])
            echo meta('description', 'My Great site');
// შედეგი :  <meta name="description" content="My Great Site" />

echo meta('Content-type', 'text/html; charset=utf-8', 'equiv');
// Note the third parameter.  Can be "equiv" or "name"
// შედეგი :  <meta http-equiv="Content-type" content="text/html; charset=utf-8" />

echo meta(array('name' => 'robots', 'content' => 'no-cache'));
// შედეგი :  <meta name="robots" content="no-cache" />

$meta = array(
        array(
                'name' => 'robots',
                'content' => 'no-cache'
        ),
        array(
                'name' => 'description',
                'content' => 'My Great Site'
        ),
        array(
                'name' => 'keywords',
                'content' => 'love, passion, intrigue, deception'
        ),
        array(
                'name' => 'robots',
                'content' => 'no-cache'
        ),
        array(
                'name' => 'Content-type',
                'content' => 'text/html; charset=utf-8', 'type' => 'equiv'
        )
);

echo meta($meta);
// შედეგი :
// <meta name="robots" content="no-cache" />
// <meta name="description" content="My Great Site" />
// <meta name="keywords" content="love, passion, intrigue, deception" />
// <meta name="robots" content="no-cache" />
// <meta http-equiv="Content-type" content="text/html; charset=utf-8" />
          

br()

ფუნქცია გვეხმარება HTML <br /> ტეგის შექმნაში, სინტაქსი ასეთია br([$count = 1]) $count პარამეტრი განსაზღვრავს თუ რამდენი ცალი <br /> ელემენტი უნდა შეიქმნას echo br(3); // <br /><br /><br /> ანალოგიურად მუშაობს nbs() ფუნქციაც.
6. CI - URL დამხმარე
დამხმარეს ჩატვირთვა ხდება შემდეგნაირად $this->load->helper('url');

anchor()

ფუნქცია ქმნის სტანდარტულ HTML ბმულს საიტიას URL მისამართზე დაყრდნობით, სინტაქსი ასეთია anchor($uri = '', $title = '', $attributes = '') $uri პარამეტრი განსაზღვრავს ბმულის URL მისამართს, $title ატრიბუტი განსაზღვრავს ბმულის "title" ატრიბუტს, $attributes განსაზღვრავს დამატებით ატრიბუტებს.
echo anchor('news/local/123', 'My News', 'title="News title"');
// Prints: <a href="http://example.com/index.php/news/local/123" title="News title">My News</a>

echo anchor('news/local/123', 'My News', array('title' => 'The best news!'));
// Prints: <a href="http://example.com/index.php/news/local/123" title="The best news!">My News</a>

echo anchor('', 'Click here');
// Prints: <a href="http://example.com">Click Here</a>
          

site_url()

აბრუნებს ვებ-გვერდის URL მისამართს. ფუნქციას სეგმენტები შეიძლება გადაეცეს სტრიქონის ან მასივის სახით, სტრიქონის სახით სეგმენტთა გადაცემა შესაძლებელია შემდეგნაირად echo site_url('news/local/123');
// დაბრუნდება დაახლოებით შემდეგნაირი URL: http://example.com/index.php/news/local/123
მასივის სახით სეგმენტთა გადაცემა შესაძლებელია შემდეგნაირად $segments = array('news', 'local', '123');
echo site_url($segments);

url_title()

ფუნქციას არგუმენტად გადაეცემა სტრიქონი და ამ სტრიქონისაგან ქმნის ადამიანისათვის ადვილად წასაკითხ URL მისამართს. ფუნქციის გამოყენება ხელსაყრელია მაგალითად მაშინ თუ ჩანაწერების სათაურების URL მისამართებში გამოყენება გვსურს $title = "What's wrong with CSS?";
$url_title = url_title($title);
// შედეგი: Whats-wrong-with-CSS
ფუნქციას შეიძლება გადეცეს მეორე პარამეტრიც, რომელიც განსაზღვრავს სიტყვათა გამყოფს, ნაგულისმეობის პრინციპით ეს გამყოფი არის ტირე. გამყოფის დასაშვები მნიშვნელობები კი არის ტირე და ქვედა ტირე, თუ ქვედა ტირის მითითება გვსურს ვიქცევით ასე $title = "What's wrong with CSS?";
$url_title = url_title($title, 'underscore');
// შედეგი: Whats_wrong_with_CSS
შესაძლებელია მესამე პარამეტრის გადაცემაც, რომელიც განსაზღვრავს გამოყენებულ იქნას თუ არა დიდი ასოები URL მისამართში. ნაგულისმეობის პრინციპით დიდი ასოები არ გამოიყენება. ამ პარამეტრმა შეიძლება მიიღოს TRUE/FALSE მნიშვნელობები. $title = "What's wrong with CSS?";
$url_title = url_title($title, 'underscore', TRUE);
// შედეგი: whats_wrong_with_css

redirect()

ფუნქცია ახდენს მითითებულ URL მისამართზე გადამისამართებას. თუ საიტის მთლიან URL-ს მივუთითებთ გადამისამართება მაინც მოხდება მაგრამ შესაძლებელია URL-ის მხოლოდ სეგმენტების მითითებაც, ფუნქცია ამ სეგმენტებისა და სისტემის კონფიგურაციაში განსაზღვრული ძირითადი URL მისამართისაგან შექმნის გადასამისამართებელ ბმულს.
if ($logged_in == FALSE)
{
        redirect('/login/form/');
}

// with 301 redirect
redirect('/article/13', 'location', 301);
          
7. CI - ტექსტური დამხმარე
ამ დამხმარეში აღწერილი ფუნქციები გამოიყენება ტექსტებთან სამუშაოდ, დამხმარეს ჩატვირთვა ხდება შემდეგნაირად $this->load->helper('text');

word_limiter()

ფუნქცია ტექსტიდან იღებს მითითებული რაოდენობის სიტყვას და აბრუნებს ამ სიტყვებისაგან შემდგარ სტრიქონს. ტექსტი და სიტყვათა რაოდენობა უნდა გადაეცეს პარამეტრებად $string = "Here is a nice text string consisting of eleven words.";
$string = word_limiter($string, 4);
// დაბრუნდება : Here is a nice

character_limiter()

ფუნქცია ტექსტიდან იღებს მითითებული რაოდენობის სიმბოლოს და აბრუნებს ამ სიმბოლოებისაგან შემდგარ სტრიქონს. ტექსტი და სიმბოლოთა რაოდენობა უნდა გადაეცეს პარამეტრებად, აგრეთვე უნდა აღინიშნოს, რომ ფუნქცია არ ახდენს სიტყვათა გაწყვეტას, ამიტომ შესაძლებელია დაბრუნებულ შედეგში იმაზე მეტი ან ნაკლები სიმბოლო შევიდეს ვიდრე ჩვენ მივუთითებთ. $string = "Here is a nice text string consisting of eleven words.";
$string = character_limiter($string, 20);
// შედეგი : Here is a nice text string


CI - ბიბლიოთეკები



1. CI - upload კლასი

პროცესი

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

ასატვირთი ფორმის შექმნა

application/views/ დირექტორიაში შექვქმნათ ფაილი upload_form.php შემდეგი კოდით
<html>
<head>
<title>Upload Form</title>
</head>
<body>

<?php echo $error;?>

<?php echo form_open_multipart('upload/do_upload');?>

<input type="file" name="userfile" size="20" />

<br /><br />

<input type="submit" value="upload" />

</form>

</body>
</html>
          

საშედეგო გვერდი

application/views/ დირექტორიაში შექვქმნათ ფაილი upload_success.php შემდეგი კოდით
<html>
<head>
<title>Upload Form</title>
</head>
<body>

<h3>Your file was successfully uploaded!</h3>

<ul>
<?php foreach ($upload_data as $item => $value):?>
<li><?php echo $item;?>: <?php echo $value;?></li>
<?php endforeach; ?>
</ul>

<p><?php echo anchor('upload', 'Upload Another File!'); ?></p>

</body>
</html>
          

კონტროლერი

application/controllers დირექტორიაში შექვქმნათ ფაილი Upload.php შემდეგი კოდით
<?php

class Upload extends CI_Controller {

        public function __construct()
        {
                parent::__construct();
                $this->load->helper(array('form', 'url'));
        }

        public function index()
        {
                $this->load->view('upload_form', array('error' => ' ' ));
        }

        public function do_upload()
        {
                $config['upload_path']          = './uploads/';
                $config['allowed_types']        = 'gif|jpg|png';
                $config['max_size']             = 100;
                $config['max_width']            = 1024;
                $config['max_height']           = 768;

                $this->load->library('upload', $config);

                if ( ! $this->upload->do_upload('userfile'))
                {
                        $error = array('error' => $this->upload->display_errors());

                        $this->load->view('upload_form', $error);
                }
                else
                {
                        $data = array('upload_data' => $this->upload->data());

                        $this->load->view('upload_success', $data);
                }
        }
}
?>
          

ასატვირთი დირექტორია

ახლა საჭიროა საქაღალდე სადაც შეინახება ატვირთული ფაილები. CI-ს ძირ საქაღალდეში შევქმნათ საქაღალდე uploads.

ვცადოთ ! ; )

ამისათვის უნდა შევიდეთ შემდეგ მისამართზე xample.com/index.php/upload/
2. CI - form_validation კლასი
ვალიდაციის კლასის აღწერამდე ჩმოვაყალიბოთ სცენარი, რომლის მიხედვითაც მოხდება ფორმის ვალიდაცია
  1. შეიქმნა ფორმა
  2. შეივსო ფორმა და გაიგზავნა
  3. თუ გაგზავნილ ინფორმაციაში მოხვდა რაიმე არასწორი ინფორმაცია ან არ შევავსეთ აუცილებლად შესავსები ველი, ფორმა უნდა გამოისახოს შეყვანილ ინფორმაციასთან ერთად და აგრეთვე გამოჩნდეს შეტყობინება მომხდარი შეცდომის შესახებ.
  4. ეს პროცესი გაგრძელდება მანამ სანამ არ აიკრიფება კორექტული და სწორი ინფორმაცია.
ამ პროცესების პარალელურად სერვერული მხარის კოდმა უნდა გააკეთოს შემდეგი რამ
  1. შეამოწმოს შეივსო თუ არა აუცილებელი ველები.
  2. შეამოწმოს სწორი ტიპისაა თუ არა აკრეფილი ინფორმაცია, მაგალითად აიკრიფა თუ არა კორექტული ელ_ფოსტა, ან ტელეფონის ნომერი შედგება თუ არა მხოლოდ ციფრებისაგან და ა.შ
  3. აკრეფილი ინფორმაცია გაიწმინდოს არასასურველი სიმბოლოებისაგან
  4. მოხდეს ინფორმაციის დაფორმატება თუ ეს საჭიროა (მაგალითად თუ აკრეფილ ტექსტში შესულია HTML ელემენტები)
  5. გამზადდეს ინფორმაცია მბ-ში შესატანად
ფორმის ვალიდაციისათვის გვჭირდება სამი რამ
  1. წარმოდგენის ფაილი სადაც შეიქმნება თავად ფორმა.
  2. წარმოდგენის ფაილი შედეგის გამოსატანად.
  3. კონტროლერის ფაილი რომელიც დაამუშავებს ინფორმაციას.

ფორმა

application/views/ საქაღალდეში შევქმნათ ფაილი myform.php შემდეგი კოდით
<html>
<head>
<title>My Form</title>
</head>
<body>

<?php echo validation_errors(); ?>

<?php echo form_open('form'); ?>

<h5>Username</h5>
<input type="text" name="username" value="" size="50" />

<h5>Password</h5>
<input type="text" name="password" value="" size="50" />

<h5>Password Confirm</h5>
<input type="text" name="passconf" value="" size="50" />

<h5>Email Address</h5>
<input type="text" name="email" value="" size="50" />

<div><input type="submit" value="Submit" /></div>

</form>

</body>
</html>
          

საშედეგო გვერდი

application/views/ საქაღალდეში შევქმნათ ფაილი formsuccess.php შემდეგი კოდით
<html>
<head>
<title>My Form</title>
</head>
<body>

<h3>Your form was successfully submitted!</h3>

<p><?php echo anchor('form', 'Try it again!'); ?></p>

</body>
</html>
          

კონტროლერი

application/controllers/ საქაღალდეში შევქმნათ ფაილი Form.php შემდეგი კოდით
<?php

class Form extends CI_Controller {

        public function index()
        {
                $this->load->helper(array('form', 'url'));

                $this->load->library('form_validation');

                if ($this->form_validation->run() == FALSE)
                {
                        $this->load->view('myform');
                }
                else
                {
                        $this->load->view('formsuccess');
                }
        }
}
          

ვცადოთ ! ; )

ამისათვის უნდა შევიდეთ შემდეგ მისამართზე example.com/index.php/form/ მაგრამ ვალიდაცია ჯერ არ დასრულებულა, თუ ახლა ფორმას გავაგზავნით გვერდი უბრალოდ დარეფრეშდება, რადგანაც ჯერ არ მიგვითითებია ვალიდაციის წესები, წესების განსაზღვრის გარეშე კი ვალიდაციის კლასი ყოველთვის დაავრუნებს FALSE მნიშვნელობას, run() მეთოდი TRUE მნიშვნელობას აბრუნებს მხოლოდ მაშინ, თუ ვალიდაციის კანონების გათვალისწინების შემდეგ არ დაფიქსირდება არანაირი შეცდომა.

გავაკეთოთ რამოდენიმე შენიშვნა ზემოთ აღწერილი ფაილების შესახებ, myform.php ფაილში აღწერილი ფორმა არის ჩვეულებრივი ვებ-ფორმა რამოდენიმე თავისებურებით

  1. იგი იყენებს ფორმის დამხმარე კლასს, ფორმის გამხსნელი ტეგის შესაქმნელად, ტექნიკური თვალსაზრისით ეს აუცილებელი არ არის, ამ ტეგის გახსნა HTML-ის დახმარებითაც შეიძლება, თუმცა დამხმარეს გამოყენების უპირატესობა იმაშია, რომ იგი ახდენს ფორმის "action" ატრიბუტისათვის გადასაცემ URL მისამართს, კონფიგურაციულ ფაილში მითითებულიURL-ზე დაყრდნობით. ეს კი აპლიკაციას უფრო მოქნილს ხდის იმ შემთხვევისათვის თუ შეიცვლება აპლიკაციის URL მისამართები.
  2. ამავე ფაილში შევამჩნევთ შემდეგი ფუნქციის გამოძახებას <?php echo validation_errors(); ?> ეს ფუნქცია დააბრუნებს შეტყობინებას ვალიდაციისას დაფიქსირებული შეცდომის შესახებ, ხოლო თუ შეცდომა არ მოხდება მაშინ დააბრუნებს ცარიელ სტრიქონს.
Form.php კონტროლერს აქვს ერთი მეთოდი index(), ეს მეთოდი ახდენს ვალიდაციის კლასის ინიციალიზაციას და ტვირთავს ფორმისა და URL-ების დამხმარე კლასებს, აგრეთვე მისი მეშვეობით ხდება ვალიდაციის პროცესის გაშვება, იმისდამიხედვით წარმატებით დასრულდება თუ არა ვალიდაცია მეთოდი ჩატვირთავს ან ისევ ფორმას, ან შედეგის გვერდს.

ვალიდაციის კანონების განსაზღვრა

CI საშუალებას გვაძლევს განვსაზღვროთ ვალიდაციის იმდენი წესი რამდენიც საჭიროა ველების რაოდენობიდან გამომდინარე, ვალიდაციის წესების მისათითებლად უნდა გამოვიყენოთ set_rules() მეთოდი. $this->form_validation->set_rules(); ამ მეთოდ უნდა გადაეცეს სამი პარამეტრი
  1. ველის სახელი
  2. ადამიანისათვის გასაგები ველის სახელი რომელსაც კოდი გამოიყენებს შედეგების წარმოდგენისას, მაგალითად თუ ველს ჰქვია "user", ადამიანისათვის გასაგებ სახელად შეიძლება მივუთითოთ “Username”.
  3. ვალიდაციის წესი
  4. (ნებაყოფლობითი) გადაეცეს ველის ვალიდაციის წესის შესაბამისი შეტყობინება შეცდომის დაფიქსირებისას.
$this->form_validation->set_rules('username', 'Username', 'required');
$this->form_validation->set_rules('password', 'Password', 'required');
$this->form_validation->set_rules('passconf', 'Password Confirmation', 'required');
$this->form_validation->set_rules('email', 'Email', 'required');
ჩავამატოთ ეს კოდი კონტროლერში, ვალიდაციის ინიციალიზაციის შემდეგ
<?php

class Form extends CI_Controller {

        public function index()
        {
                $this->load->helper(array('form', 'url'));

                $this->load->library('form_validation');

                $this->form_validation->set_rules('username', 'Username', 'required');
                $this->form_validation->set_rules('password', 'Password', 'required',
                        array('required' => 'You must provide a %s.')
                );
                $this->form_validation->set_rules('passconf', 'Password Confirmation', 'required');
                $this->form_validation->set_rules('email', 'Email', 'required');

                if ($this->form_validation->run() == FALSE)
                {
                        $this->load->view('myform');
                }
                else
                {
                        $this->load->view('formsuccess');
                }
        }
}
          
თუ ახლა გავაგზავნით ფორმას უკვე შედეგსაც ვიხილავთ, ცარიელი ველების გაგზავნისას ვიხილავთ შესაბამისი შეცდომების შეტყობინებას, ხოლო თუ ველებს შევავსებთ - წარმატების გვერდს. თუმცა ერთი ხარვეზი კიდევ ფიქსირდება: შეცდომის დაფიქსირებისას ფორმა აღარ ივსება ავტომატურად, ანუ თუ შევიყბანეთ სამი ველის მნიშვნელობა და არ შევიყვანეთ მეოთხესი, შეცდომის შეტყობინება კი გამოდის მაგრამ სწორად შეყვანილი ინფორმაციაც იკარგება. ამ პრობლემას ქვემოთ მოვაგვარებთ.

ვალიდაციის კანონების განსაზღვრა მასივის მეშვეობით

$config = array(
        array(
                'field' => 'username',
                'label' => 'Username',
                'rules' => 'required'
        ),
        array(
                'field' => 'password',
                'label' => 'Password',
                'rules' => 'required',
                'errors' => array(
                        'required' => 'You must provide a %s.',
                ),
        ),
        array(
                'field' => 'passconf',
                'label' => 'Password Confirmation',
                'rules' => 'required'
        ),
        array(
                'field' => 'email',
                'label' => 'Email',
                'rules' => 'required'
        )
);

$this->form_validation->set_rules($config);
          

ვალიდაციის კასკადური კანონები

CI საშუალებას გვაძლევს ერთი ველისათვის განვსაზღვროთ ვალიდაციის რამოდენიმე წესი
$this->form_validation->set_rules(
        'username', 'Username',
        'required|min_length[5]|max_length[12]|is_unique[users.username]',
         array(
                'required'      => 'You have not provided %s.',
                'is_unique'     => 'This %s already exists.'
        )
);
$this->form_validation->set_rules('password', 'Password', 'required');
$this->form_validation->set_rules('passconf', 'Password Confirmation', 'required|matches[password]');
$this->form_validation->set_rules('email', 'Email', 'required|valid_email|is_unique[users.email]');
          
ეს კოდი განსაზღვრავს შემდეგ კანონებს
  1. "username" ველი უნდა შეიცავდეს 5 სიმბოლოზე მეტს და 12 სიმბოლოზე ნაკლებს
  2. "password" ველის მნიშვნელობა უნდა დაემთხვეს "password confirmation" ველის მნიშვნელობას
  3. "email" ველი უნდა შეიცავდეს კორექტულ ელ_ფოსტას

მონაცემთა მომზადება

$this->form_validation->set_rules('username', 'Username', 'trim|required|min_length[5]|max_length[12]');
$this->form_validation->set_rules('password', 'Password', 'trim|required|min_length[8]');
$this->form_validation->set_rules('passconf', 'Password Confirmation', 'trim|required|matches[password]');
$this->form_validation->set_rules('email', 'Email', 'trim|required|valid_email');
მოყვანილ მაგალითში ხდება მონაცემთა "გადამზადება", მოწმდება სიგრძეები სადაც ეს საჭიროა და აგრეთვე მოწმდება ემთხვევა თუ არა პაროლები. ნებისმიერი PHP-ის ფუნქცია, რომელსაც გადაეცემა ერთი პარამეტრი, შესაძლებელია გამოყენებულ იქნას როგორც ვალიდაციის წესი. მაგალითად "htmlspecialchars()", "trim()" და ა.შ

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

ველთა განმეორებითი, ავტომატურად შესავსებად გამოიყენება set_value('field name') ფუნქცია. გავხსნათ myform.php წარმოდგენის ფაილი
<html>
<head>
<title>My Form</title>
</head>
<body>

<?php echo validation_errors(); ?>

<?php echo form_open('form'); ?>

<h5>Username</h5>
<input type="text" name="username" value="<?php echo set_value('username'); ?>" size="50" />

<h5>Password</h5>
<input type="text" name="password" value="<?php echo set_value('password'); ?>" size="50" />

<h5>Password Confirm</h5>
<input type="text" name="passconf" value="<?php echo set_value('passconf'); ?>" size="50" />

<h5>Email Address</h5>
<input type="text" name="email" value="<?php echo set_value('email'); ?>" size="50" />

<div><input type="submit" value="Submit" /></div>

</form>

</body>
</html>
          
თუ ფორმის ველების დასახელებები მოქცეული გვაქვს მასივში, მაშინ set_value() ფუნქცია უნდა გამოვიყენოთ ასე <input type="text" name="colors[]" value="" size="50" />

ვალიდაციის საკუთარი კანონები, საპასუხო ფუნქციები

CI საშუალებას გვაძლევს ვალიდაციის კლასი მოვარგოთ ჩვენს საჭიროებებს, მაგალითად გვაინტერესებს რეგისტრაციისას მომხმარებლის მიერ შეყვანილი სახელი უკვე გამოყენებული ხომ არ აქვს ვინმეს, ამის შემოწმება უნდა მოხდეს შესაბამის საპასუხო ფუნქციაში (callback). კონტროლერში სახელის ვალიდაციის წესი იქნება შემდეგნაირი $this->form_validation->set_rules('username', 'Username', 'callback_username_check'); ახლა კი უნდა აღვწეროთ username_check() ფუნქცია, რომელიც მოახდენს სახელის უნიკალურობის გადამოწმებას
<?php

class Form extends CI_Controller {

        public function index()
        {
                $this->load->helper(array('form', 'url'));

                $this->load->library('form_validation');

                $this->form_validation->set_rules('username', 'Username', 'callback_username_check');
                $this->form_validation->set_rules('password', 'Password', 'required');
                $this->form_validation->set_rules('passconf', 'Password Confirmation', 'required');
                $this->form_validation->set_rules('email', 'Email', 'required|is_unique[users.email]');

                if ($this->form_validation->run() == FALSE)
                {
                        $this->load->view('myform');
                }
                else
                {
                        $this->load->view('formsuccess');
                }
        }

        public function username_check($str)
        {
                if ($str == 'test')
                {
                        $this->form_validation->set_message('username_check', 'The {field} field can not be the word "test"');
                        return FALSE;
                }
                else
                {
                        return TRUE;
                }
        }

}            
          
ამის შემდეგ თუ ფორმას დავარესტარტებთ და მომხმარებლის სახელად შევივანთ სიტყვას - “test”, ვიხილავთ username_check() ფუნქციის მუშაობის შედეგს.

ვალიდაციის კანონში ფუნქციის მითითება უნდა მოხდეს “callback_” წინსართთან ერთად.

ვალიდაციისას წესები, კრიტერიუმები

წესი პარამეტრი აღწერა მაგალითი
required არა აბრუნებს FALSE-ს თუ ფორმის ელემენტი ცარიელია.  
matches დიახ აბრუნებს FALSE-ს თუ ფორმის ელემენტის მნიშვნელობა არ ემთხვევა პარამეტრად გადაცემულ მნიშვნელობას. matches[form_item]
regex_match დიახ აბრუნებს FALSE-ს თუ ფორმის ელემენტის მნიშვნელობა არ ემთხვევა რეგულარულ გამოსახულებას. regex_match[/regex/]
differs დიახ აბრუნებს FALSE-ს თუ ფორმის ელემენტის მნიშვნელობა არ განსხვავდება პარამეტრად გადაცემული მნიშვნელობისაგან. differs[form_item]
is_unique დიახ აბრუნებს FALSE-ს თუ ფორმის ელემენტის მნიშვნელობა არ არის უნიკალური პარამეტყრად მითითებული ცხრილის ველის მნიშვნელობებს შორის. შენიშვნა: ამ წესის გამოსაყენებლად აუცილებელია ვიყენებდეთ Query Builder-ს. is_unique[table.field]
min_length დიახ აბრუნებს FALSE-ს ფორმის ელემენტის მნიშვნელობის სიგრძე ნაკლებია მითითებულ პარამეტრზე. min_length[3]
max_length დიახ აბრუნებს FALSE-ს ფორმის ელემენტის მნიშვნელობის სიგრძე მეტია მითითებულ პარამეტრზე. max_length[12]
exact_length დიახ აბრუნებს FALSE-ს თუ ფორმის ელემენტის მნიშვნელობის სიგრძე არ ემთხვევა მითითებულ პარამეტრს. exact_length[8]
greater_than დიახ აბრუნებს FALSE-ს თუ ფორმის ელემენტის მნიშვნელობა ნაკლებია ან ტოლი პარამეტრზე, ან საერთოდ არ არის რიცხვითი ტიპის. greater_than[8]
greater_than_equal_to დიახ აბრუნებს FALSE-ს თუ ფორმის ელემენტის მნიშვნელობა ნაკლებია პარამეტრზე, ან საერთოდ არ არის რიცხვითი ტიპის. greater_than_equal_to[8]
less_than დიახ აბრუნებს FALSE-ს თუ ფორმის ელემენტის მნიშვნელობა მეტია ან ტოლი პარამეტრზე, ან საერთოდ არ არის რიცხვითი ტიპის. less_than[8]
less_than_equal_to დიახ აბრუნებს FALSE-ს თუ ფორმის ელემენტის მნიშვნელობა მეტია პარამეტრზე, ან საერთოდ არ არის რიცხვითი ტიპის. less_than_equal_to[8]
in_list დიახ აბრუნებს FALSE-ს თუ ფორმის ელემენტის მნიშვნელობა არ არის წინასწარ განსაზღვრულ სიაში. in_list[red,blue,green]
alpha არა აბრუნებს FALSE-ს თუ ფორმის ელემენტის მნიშვნელობა შეიცავს რაიმეს გარდა ასოებისა.  
alpha_numeric არა აბრუნებს FALSE-ს თუ ფორმის ელემენტის მნიშვნელობა შეიცავს რაიმეს გარდა ასოებისა და ციფრებისა.  
alpha_numeric_spaces არა აბრუნებს FALSE-ს თუ ფორმის ელემენტის მნიშვნელობა შეიცავს რაიმეს გარდა ასოებისა, ციფრებისა და გამოტოვებული ადგილებისა.  
alpha_dash არა აბრუნებს FALSE-ს თუ ფორმის ელემენტის მნიშვნელობა შეიცავს რაიმეს გარდა ასოებისა, ციფრებისა, ტირეებისა და ქვედა ტირეებისა.  
numeric არა აბრუნებს FALSE-ს თუ ფორმის ელემენტის მნიშვნელობა შეიცავს რაიმეს გარდა ციფრებისა.  
integer არა აბრუნებს FALSE-ს თუ ფორმის ელემენტის მნიშვნელობა შეიცავს რაიმეს გარდა მთელი რიცხვებისა.  
decimal არა აბრუნებს FALSE-ს თუ ფორმის ელემენტის მნიშვნელობა შეიცავს რაიმეს გარდა ათწილადი რიცხვებისა.  
is_natural არა აბრუნებს FALSE-ს თუ ფორმის ელემენტის მნიშვნელობა შეიცავს რაიმეს გარდა ნატურალური რიცხვებისა.  
is_natural_no_zero არა აბრუნებს FALSE-ს თუ ფორმის ელემენტის მნიშვნელობა შეიცავს რაიმეს გარდა ნატურალური რიცხვებისა, არ უნდა უდრიდეს 0-ს.  
valid_url არა აბრუნებს FALSE-ს თუ ფორმის ელემენტის მნიშვნელობა არ შეიცავს კორექტულ URL მისამართს.  
valid_email არა აბრუნებს FALSE-ს თუ ფორმის ელემენტის მნიშვნელობა არ შეიცავს ელ_ფოსტის კორექტულ მისამართს.  
valid_emails არა აბრუნებს FALSE-ს თუ მძიმით გამოყოფილი მნიშვნელობებიდან ერთი მაინც არ შეიცავს ელ_ფოსტის კორექტულ მისამართს.  
valid_ip დიახ აბრუნებს FALSE-ს თუ მითითებული IP მისამართი არ არის კორექტული.  
3. CI - input კლასი
ამ კლასის ინიციალიზაცია ავტომატურტად ხდება, ამიტომ ჩვენ აღარ გვჭირდება მისი ჩატვირთვა.

ფორმის მონაცემებთან წვდომა

POST, GET, COOKIE, SERVER მონაცემების გამოყენება

input კლასის მეთოდების მეშვეობით შესაძლებელია დავაფიქსიროთ POST, GET, COOKIE ან SERVER გლობალურ ცვლადებში მოთავსებული მონაცემები. როგორც ვიცით PHP-ში მაგალითად POST ტიპის ინფორმაციის მიღება ხდება შემდეგნაირად $something = isset($_POST['something']) ? $_POST['something'] : NULL; CI-ში კი იგივე მოხდება შემდეგნაირად $something = $this->input->post('something'); ანუ post() მეთოდი ამოწმებს არსებობს თუ არა POST გლობალურ ცვლადში ინფორმაცია, თუ არსებობს აბრუნებს მას თუ არადა აბრუნებს NULL-ს. input კლასის ძირითადი მეთოდებია
  • $this->input->post()
  • $this->input->get()
  • $this->input->cookie()
  • $this->input->server()

post()

მეთოდის გამოყენების მაგალითი $this->input->post('some_data'); პირველი პარამეტრი უნდა შეიცავდეს POST მასივის იმ გასაღებს რომლის მნიშვნელობასაც ვეძებთ, ბრუნდება NULL თუ ეს მნიშვნელობა განსაზღვრული არ არის. POST მასივში მოთავსებული ყველა მნიშვნელობის დასაბრუნებლად post() მეთოდი უნდა გამოვიძახოთ პარამეტრების გარეშე $this->input->post(NULL, TRUE); // XSS ფილტრით
$this->input->post(NULL, FALSE); // XSS ფილტრის გარეშე
კონკრეტული მნიშვნელობების დასავრუნებლად მეთოდს პარამეტრებად უნდა გადავცეთ ფორმის შესაბამისი ველების დასახელებები $this->input->post(array('field1', 'field2'));

get()

ეს მეთოდი არის post() მეთოდის იდენტური, უბრალოდ იგი აბრუნებს GET მასივში მოთავსებულ მნიშვნელობებს.

server()

ეს მეთოდიც მუშაობდ post() და get() მეთოდების ანალოგიურად. $this->input->server('some_data'); თუ რამოდენიმე მნიშვნელობის ამორება გვურს $_SERVER გლობალური მასივიდან ვიქცევით ასე $this->input->server(array('SERVER_PROTOCOL', 'REQUEST_URI'));

ip_address()

მეთოდი აბრუნებს ვისიტორის ip მისამართს, თუ ეს მისამართი არაკორეკტულია ბრუნდება ‘0.0.0.0’ echo $this->input->ip_address();

valid_ip()

მეთოდი აბრუნებს TRUE აბ FALSE მნიშვნელობებს, გამომდინარე იქიდან, კორექტულია თუ არა ip
if ( ! $this->input->valid_ip($ip))
{
        echo 'Not Valid';
}
else
{
        echo 'Valid';
}
          
4. CI - pagination კლასი

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

« პირველი < 1 2 3 4 5 > ბოლო » მოვიყვანოთ მაგალითი თუ როგორ უნდა გაკეთდეს პაგინაცია კონტროლერის მეთოდის მეშვეობით $this->load->library('pagination');

$config['base_url'] = 'http://example.com/index.php/test/page/';
$config['total_rows'] = 200;
$config['per_page'] = 20;

$this->pagination->initialize($config);

echo $this->pagination->create_links();

შენიშვნები

$config მასივი შეიცავს კონფიგურაციულ ცვლადებს, ამ მასივის გადაცემა ხდება $this->pagination->initialize() ჩანაწერით, შესაძლებელია სხვა კონფიგურაციული პარამეტრების გადაცემაც მაგრამ ეს სამი არის აუცილებელი და ძირითადი
  1. base_url - ეს არის პაგინაციის კონტროლერის კლასის/ფუნქციის სრული URL მისამართი, ამ მაგალითის მიხედვით ხდება “Test” კლასისა და მისი “page” მეთოდის გამოძახება.
  2. - ეს რიცხვი განსაზღვრავს შედეგთა ნაკრებში ჩანაწერების რაოდენობას, როგორც წესი ეს რიცხვი ტოლია ხოლმე მბ-დან დაბრუნებული, პასუხთა ნაკრების სიგრძისა.
  3. - ეს რიცხვი განსაზღვრავს თუ რამდენი ჩანაწერი უნდა გამოჩნდეს ერთ გვერდზე.
create_links() მეთოდი აბრუნებს ცარიელ სტრიქონს თუ პაგინაციაში მოსათავსებლად ვერაფერი მოიძებნება.

პარამეტრების განსაზღვრა კონფიგურაციის ფაილში

პაგინაციის კონფიგურაციული პარამეტრების განსაზღვრა შესაძლებელია ცალკე ფაილშიც, application/config/ დირექტორიაში გავაკეთოთ ფაილი pagination.php, მასში შევქმნათ მასივი $config, მისი გამოყენება მოხდება ავტომატურად, ამ შემთხვევაში $this->pagination->initialize() ჩანაწერის გამოყენება აღარ დაგვჭირდება.

$config[‘uri_segment’] = 3;

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

$config[‘num_links’] = 2;

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

$config[‘page_query_string’] = TRUE;

ნაგულისხმეობის პრინციპით, პაგინაციის კლასი აღიქვამს დაახლოებით შემდეგნაირ URI მისამართებს http://example.com/index.php/test/page/20 თუ $config['enable_query_strings']-ს განვუსაზღვრავთ მნიშვნელობას - TRUE, მაშინ შესაძლებელი იქნება ასეთი URI მისამართების გამოყენებაც http://example.com/index.php?c=test&m=page&per_page=20

პაგინაციის ბლოკის HTML ელემენტში მოქცევა

$config[‘full_tag_open’] = ‘<p>’;

$config[‘full_tag_close’] = ‘<p>’;

"პირველი" ბმულის შექმნა

$config[‘first_link’] = ‘პირველი’;

$config[‘first_tag_open’] = ‘<div>’;

გამხსნელი ტეგი "პირველი" ბმულისათვის.

$config[‘first_tag_close’] = ‘<div>’;

დამხურავი ტეგი "პირველი" ბმულისათვის

$config[‘first_url’] = ‘’;

ალტერნატიული URL მისამართი "პირველი" ბმულისათვის.

"ბოლო" ბმულის შექმნა

$config[‘last_link’] = ‘ბოლო’;

$config[‘last_tag_open’] = ‘<div>’;

გამხსნელი ტეგი "ბოლო" ბმულისათვის.

$config[‘last_tag_close’] = ‘<div>’;

დამხურავი ტეგი "ბოლო" ბმულისათვის.

"შემდეგი" ბმულის შექმნა

$config[‘last_link’] = ‘შემდეგი’;

ან

$config[‘last_link’] = ‘>’;

$config[‘next_tag_open’] = ‘<div>’;

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

$config[‘next_tag_close’] = ‘<div>’;

დამხურავი ტეგი "შემდეგი" ბმულისათვის.

"წინა" ბმულის შექმნა

$config[‘prev_link’] = ‘წინა’;

ან

$config[‘prev_link’] = ‘<’;

$config[‘prev_tag_open’] = ‘<div>’;

გამხსნელი ტეგი "წინა" ბმულისათვის.

$config[‘prev_tag_close’] = ‘<div>’;

დამხურავი ტეგი "წინა" ბმულისათვის.

"მიმდინარე" ბმულის შექმნა

$config[‘cur_tag_open’] = ‘<b>’;

გამხსნელი ტეგი "მიმდინარე" ბმულისათვის.

$config[‘cur_tag_close’] = ‘<b>’;

დამხურავი ტეგი "მიმდინარე" ბმულისათვის.

პაგინაციის ბმულების ატრიბუტები

დავუშვათ გვინდა, რომ პაგინაციის ბმულებს დავუმატოთ ახალი ატრიბუტები. ამისათვის პაგინაციის კონფიგურაციულ მასივს - $config-ს უნდა დავუმატოთ შემდეგი გასაღები // შედეგი: class="myclass"
$config['attributes'] = array('class' => 'myclass');
5. CI - session კლასი

სესიის ინიციალიზაცია

სესიის ინიციალიზაცია შეიძლება მოხდეს კონტროლერის კონსტრუქტორში, ან ასესიების კლასი ვტომატურად ჩაიტვირთოს სისტემის მიერ. კონტროლერის კონსტრუქტორში უნდა გამოვიყენოთ შემდეგი ჩანაწერი $this->load->library('session'); იმის გამო, რომ კლასის ინიციალიზაცია ხდება CI-ს საბაზისო კონტროლერის მიხედვით, კონტროლერის კონსტრუქტორში ბიბლიოთეკის ჩატვირთვამდე უნდა გამოვიყენოთ parent::__construct() ჩანაწერი. ამის შემდეგ სესიების გამოყენება მოხდება ასე $this->session

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

სესიის მასივში მოთავსებული ინფორმაციის ნებისმიერი ნაწილის დაბრუნება შესაძლებელია $_SESSION სუპერგლობალური ცვლადის მეშვეობით $_SESSION['item'] ან მაგიური გეტერის მეშვეობით $this->session->item ან userdata() მეთოდის მეშვეობით $this->session->userdata('item'); სადაც "item" არის საძიებელი ინფორმაციის შესაბამისი გასაღები $_SESSION მასივში, მაგალითად გვსურს დავაბრუნოთ "name" გასარების მნიშვნელობა და შევინახოთ ცვლადში $name
$name = $_SESSION['name'];

// ან:

$name = $this->session->name

// ან:

$name = $this->session->userdata('name');
          
userdata() მეთოდი აბრუნებს NULL-ს თუ შესაბამისი გასარების მნიშვნელობა არ არის განსაზღვრული.

სესიის ინფორმაციის დამატება

დავუშვათ რომ ჩვენს საიტზე დარეგისტრირდა ახალი მომხმარებელი. აუთჰენტიკაციის შემდეგ ჩვენ შეგვიძლია მისი სახელი და ელ_ფოსტა დავამატოთ სესიაში, რათა ეს მონაცემები იყოს გლობალურად ხელმისაწვდომი ჩვენთვის, მბ-სთან დაკავშირების გარეძშე. ამისათვის ეს მონაცემები უნდა გადავცეთ $_SESSION მასივს, ალტერნატიულ ვარიანტში შეგვიძლია გამოვიყენოთ “userdata” მეთოდი $this->session->set_userdata($array); სადაც $array არის მასივი რომელიც შეიცავს სესიაში დასამატებელ ინფორმაციას
$newdata = array(
        'username'  => 'johndoe',
        'email'     => 'johndoe@some-site.com',
        'logged_in' => TRUE
);

$this->session->set_userdata($newdata);
          
იმის გადასამოწმებლად უკვე ხომ არ არსებობს სესიაში ესა თუ ის მნიშვნელობა, უნდა გამოვიყენოთ isset() ფუნქცია // დააბრუნებს FALSE-ს თუ სესია არ შეიცავს 'some_name' მნიშვნელობას ან ეს მნიშვნელობა უდრის NULL-ს,
// TRUE სხვა შემთხვევაში:
isset($_SESSION['some_name'])
ალტერნატიული ვარიანტია has_userdata() მეთოდის გამოყენება $this->session->has_userdata('some_name');

სესიის ინფორმაციის წაშლა

unset($_SESSION['some_name']);

// ან რამოდენიმე მნიშვნელობა ერთად :

unset(
        $_SESSION['some_name'],
        $_SESSION['another_name']
);
          
ალტერნატიული ვარიანტია unset_userdata() მეთოდის გამოყენება $this->session->unset_userdata('some_name'); რამოდენიმე მნიშვნელობის ერთდროულად წასაშლელად, მეთოდს უნდა გადავცეთ მასივი $array_items = array('username', 'email');
$this->session->unset_userdata($array_items);

Flashdata

CI-ში ჩადგმულია სესიური ინფორმაცია, ე.წ "Flashdata", ეს არის ინფორმაცია რომლის გამოყენებაც ხდება ერთჯერადად და შემდეგ ავტომატურად სუფთავდება. "Flashdata"-ს გამოყენება ხელსაყრელია სხვადასხვა სახის შეტყობინებების გამოსატანად (შეცდომა, სტატუსი, გაფრთხილება და ა.შ), მას შეიძლება ჰქონდეს ამდაგვარი ტექსტი "სიახლე წარმატებით დაემატა", "შეტყობინება გაგავნილია" და ა.შ. რაიმე ჩანაწერის "Flashdata"-ად მონიშვნა ხდება შემეგნაირად $this->session->mark_as_flash('item'); ან რამდენიმე ჩანაწერის ერთდროულად მონიშვნა $this->session->mark_as_flash(array('item', 'item2')); მონიშვნის შემდეგ კი ეს ინფორმაცია უნდა გადეცეს სესიას $this->session->set_flashdata('item', 'value'); "Flashdata"-ში მოქცეული ინფორმაციის წაკითხვა ხდება ისევე როგორც სესიაში მოქცეული სხვა ინფორმაციისა $_SESSION['item'] თუმცა შესაძლებელია ამ ინფორმაციის ასე წაკითხვაც $this->session->flashdata('item'); მაგალითისათვის მოვიყვანოთ ასეთი შემთხვევა: ვთქვათ დარეგისტრირდა ახალი მომხმარებელი, რეგისტრაციის შემდეგ კი ხდება მთავარ გვერდზე გადამისამართება (redirect) და გვსურს, რომ ამ გვერდზე მომხმარებელმა იხილოს შეტყობინება "თქვენ წარმატებით დარეგისტრირდით". კონტროლერის იმ ნაწილს, რომელიც გადამისამარტებას ახდენს ექნება შემდეგი სახე
...

// შეტყობინების განსაზღვრა
$this->session->set_flashdata('user_registered','თქვენ წარმატებით დარეგისტრირდით');

redirect('index');
          
set_flashdata ფუნქციას პირველ პარამეტრად გადავეცით "flashdata" ინფორმაციის დასახელება, მეორე პარამეტრად კი შესაბამისი ტექსტი. ახლა გამოვიყენოთ ეს შეტყობინება index გვერდზე
<?php if($this->session->flashdata('user_registered')) : ?>
    <p class="alert alert-success">session->flashdata('user_registered'); ?></p>
<?php endif; ?>
          

Tempdata

CI-ში ჩადგმულია სესიური ინფორმაცია, ე.წ "Tempdata", ეს არის ინფორმაცია, რომელსაც განსაზღვრული აქვს მოქმედები ვადა, ვადის გასვლის შემდეგ ხდება ამ ინფორმაციის წაშლა. ინფორმქაციის “tempdata”-ად მონიშვნა ხდება შემდეგნაირად // 'item' წაიშლება 300 წამის შემდეგ
$this->session->mark_as_temp('item', 300);
მოვნიშნოთ რამოდენიმე ინფორმაცია ერთდროულად
//  'item' და 'item2' წაიშლება 300 წამში
$this->session->mark_as_temp(array('item', 'item2'), 300);

// 'item' წაიშლება  300 წამში,  'item2'
// კი წაიშლება  240 წამში
$this->session->mark_as_temp(array(
        'item'  => 300,
        'item2' => 240
));
          
მონიშვნის შემდეგ შესაძლებელია დავამატოთ ინფორმაცია სესიაში $this->session->set_tempdata('item', 'value', 300); ამ ინფორმაციის წაკითხვა კი ხდება შემდეგნაირად $this->session->tempdata('item');

სესიის დახურვა

სესიის დახურვა შესაძლებელია ჩვეულებრივი PHP ფუნქციით - session_destroy(), ან CI ფუნქციით sess_destroy() session_destroy();

// ან

$this->session->sess_destroy();


CI - მონაცემთა ბაზასთან მუშაობა



1. CI - მბ-ს სწრაფი გაშვება, კოდის ნიმუში

მონაცემთა ბაზის კლასის ინიციალიზაცია

$this->load->database();

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

$query = $this->db->query('SELECT name, title, email FROM my_table');

foreach ($query->result() as $row)
{
        echo $row->title;
        echo $row->name;
        echo $row->email;
}

echo 'Total Results: ' . $query->num_rows();
          
result() ფუნქცია დააბრუნებს ობიექტების მასივს. მაგ: $row->title.

სტანდარტული მოთხოვნა რამოდენიმე შედეგით (მასივის მაგალითი)

$query = $this->db->query('SELECT name, title, email FROM my_table');

foreach ($query->result_array() as $row)
{
        echo $row['title'];
        echo $row['name'];
        echo $row['email'];
}
          
result() ფუნქცია დააბრუნებს მასივს სტანდარტული ინდექსებით. მაგ: $row[‘title’].

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

$query = $this->db->query('SELECT name FROM my_table LIMIT 1');
$row = $query->row();
echo $row->name;
row() ფუნქცია დააბრუნებს ობიექტს. მაგ: $row->name.

სტანდარტული მოთხოვნა ერთი შედეგით (მასივის მაგალითი)

$query = $this->db->query('SELECT name FROM my_table LIMIT 1');
$row = $query->row_array();
echo $row['name'];
row_array() ფუნქცია დააბრუნებს მასივს. მაგ: $row[‘name’].

სტანდარტული INSERT ბრძანება

$sql = "INSERT INTO mytable (title) VALUES (".$this->db->escape($title).")";
$this->db->query($sql);
echo $this->db->affected_rows();

Query Builder ბრძანება

Query Builder ანუ მოთხოვნათა ამგები, შემქმნელი საშუალებას გვაძლევს გავამარტივოთ მონაცემთა ამოღების სინტაქსი, მასზე ვისაუბრებთ მოგვიანებით.
$query = $this->db->get('table_name');

foreach ($query->result() as $row)
{
        echo $row->title;
}
          
get() ფუნქცია ამოიღებს ყველა ჩანაწერს მითითებული ცხრილიდან.

Query Builder Insert

$data = array(
        'title' => $title,
        'name' => $name,
        'date' => $date
);

$this->db->insert('mytable', $data);  // შედეგი : INSERT INTO mytable (title, name, date) VALUES ('{$title}', '{$name}', '{$date}')
          
2. CI - მბ კონფიგურაცია
მონაცემთა ბაზის კონფიგურაციული პარამეტრების განსაზღვრა ხდება application/config/database.php ფაილში, ხშირად საჭიროა მბ-გავმართოთ განსხვავებული გარემოებისათვის (შექმნის გარემო ანუ როცა პროექტი კეთდება და მეორე - როცა პროქტი უკვე გაშვებულია წარმოებაში), CI-ს მრავალგანზომილებიანი მასივის მეშვეობით შესაძლებელია მბ-ს პარამეტრების განსაზღვრა სხვადასხვა გარემოებისათვის, კონფიგურაციული პარამეტრები მასივში შემდეგნაირადაა მოთავსებული
$db['default'] = array(
    'dsn'   => '',
    'hostname' => 'localhost',
    'username' => 'root',
    'password' => '',
    'database' => 'database_name',
    'dbdriver' => 'mysqli',
    'dbprefix' => '',
    'pconnect' => TRUE,
    'db_debug' => TRUE,
    'cache_on' => FALSE,
    'cachedir' => '',
    'char_set' => 'utf8',
    'dbcollat' => 'utf8_general_ci',
    'swap_pre' => '',
    'encrypt' => FALSE,
    'compress' => FALSE,
    'stricton' => FALSE,
    'failover' => array()
);
          
მასივის ელემენტები შეგვიძლია დავტოვოთ უცვლელად გარდა შემდეგი ელემენტებისა : hostname, username, password, database და dbdriver.
  • hostname − აქ უნდა განისაზღვროს მბ-ს მდებარეობა მაგ: localhost ან IP მისამართი.
  • username − აქ უნდა განისაზღვროს მბ-ს მომხმარებლის სახელი.
  • password − აქ უნდა განისაზღვროს მბ-ს მომხმარებლის პაროლი.
  • database − აქ უნდა განისაზღვროს მბ-ს სახელი.
  • dbdriver − აქ უნდა განისაზღვროს მბ-ს ტიპი, მაგ: MySQL, MySQLi, Postgre SQL, ODBC, MS SQL.
მბ-ს ზოგიერთი დრაივერისათვის (მაგ: PDO), შესაძლებელია საჭირო გახდეს DSN-ის (database source name) მთლიანი სტრიქონის ჩაწერა. // PDO
$db['default']['dsn'] = 'pgsql:host=localhost;port=5432;dbname=database_name';
თუ გვსურს სხვადასხვა სამუშაო გარემოსათვის სხვადასხვა ბაზებთან დაკავშირება მაშინ ზემოთ მოყვანილი მასივის $db['default'] გასაღები უნდა შევცვალოთ, და განვსაზღვროთ მბ-ს სხვა კონფიგურაციული პარამეტრები, ამ გასაღებს მივანიჭოთ მაგალითად "test" მნიშვნელობა და აღვწეროთ პარამეტრები ისე რომ არ შევეხოთ ძირითად კონფიგურაციას.
$db['test'] = array(
      'dsn'   => '',
      'hostname' => 'localhost',
      'username' => 'root',
      'password' => '',
      'database' => 'database_name',
      'dbdriver' => 'mysqli',
      'dbprefix' => '',
      'pconnect' => TRUE,
      'db_debug' => TRUE,
      'cache_on' => FALSE,
      'cachedir' => '',
      'char_set' => 'utf8',
      'dbcollat' => 'utf8_general_ci',
      'swap_pre' => '',
      'encrypt' => FALSE,
      'compress' => FALSE,
      'stricton' => FALSE,
      'failover' => array()
);
          
შემდეგ კი სისტემას მივაწოდოთ ინფორმაცია, თუ რომელი ბაზის ჩატვირთვა გვსურს $active_group = 'test';

მოთხოვნათა შემქმნელი (Query Builder)

მოთხოვნათა შემქმნელის კლასის გამოსართავად ან ჩასართთავად $query_builder ცვლადს უნდა მივანიჭოთ ლოგიკური მნიშვნელობები TRUE/FALSE , ნაგულისხმეობის პრინციპით ცვლადის მნიშვნელობა არის TRUE ანუ ეს კლასი ჩართულია ავტომატურად. $query_builder = TRUE;
3. CI - მბ-სთან დაკავშირება
მბ-სთან დაკავშირება შესაძლებელია ორნაირად
  • ავტომატური დაკავშირება - ეს შესაძლებელია application/config/autoload.php ფაილის დახმარებით, ბაზასთან ავტომატური დაკავშირება მოხდება ვებ-გვერდის ყველა ქვე-გვერდზე. ამისათვის უბრალოდ database ბიბლიოთეკა უნდა დავამატოთ $autoload['libraries'] მასივში
$autoload['libraries'] = array(‘database’);
  • სამომხმარებლო დაკავშირება - თუ ბაზასთან დაკავშირება საჭიროა მხოლოდ რამოდენიმე გვერდზე, მაშინ ავტომატური დაკავშირება არ გამოგვადგება, ამ შემთხვევაში ბაზასთან დასაკავშირებლად რომელიმე კლასში უნდა დავამატოთ შემდეგი ხაზი.
$this->load->database(); ამ ჩანაწერში არანაირი არგუმენტის მითითება არ ხდება რადგან ყველაფერი მითითებულია application/config/database.php ფაილში.

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

$this->load->database('group_name'); სადაც "group_name" არის ჯგუფის სახელი (მაგალითად ჩვენ რომ გავაკეთეთ "test" ჯგუფი).

მბ-სთან კავშირის დახურვა

$this->db->close();
4. CI - მოთხოვნათა გაშვება

საბაზისო მოთხოვნები

რეგულარული მოთხოვნები

მოთხოვნის გასაგზავნად გამოიყენება query ფუნქცია. $this->db->query('YOUR QUERY HERE'); query() ფუნქცია აბრუნებს მოთხოვნის პასუხის ობიექტს იმ შემთხვევაში თუ მოთხოვნა წაკითხვის ტიპისაა, ამ შედეგის გამოტანაზე ქვემოთ ვისაუბრებთ, როცა ჩაწერის ტიპის მოთხოვნა სრულდება, ფუნქცია აბრუნებს TRUE ან FALSE მნიშვნელობებს წარმატებიდან გამომდინარე, როდესაც შედეგის მიღება, დაჭერა გვსურს ის უნდა მოვათავსოთ ჩვენს საკუთარ ცვლადში $query = $this->db->query('YOUR QUERY HERE');

გამარტივებული მოთხოვნები

simple_query მეთოდი არის $this->db->query() მეთოდის გამარტივებული ვერსია, ამ მეთოდის ერთადერთი დანიშნულებაა მოთხოვნის გაგზავნა, წაკითხვის ტიპის მოთხოვნებთან მუშაობისას (INSERT, DELETE ან UPDATE), მეთოდი აბრუნებს TRUE/FALSE მნიშვნელობებს, წარმატებიდან გამომდინარე
if ($this->db->simple_query('YOUR QUERY')){
  echo "Success!";
}
else{
  echo "Query failed!";
}
          

უსაფრთხოება

უსაფრთხოების ძალიან კარგი პრაქტიკაა თუ დავამუშავებთ მონაცემებს ბაზაში გაგზავნამდე, CI-ს აქვს სამი მეთოდი ამისათვის
  1. $this->db->escape() - ეს ფუნქცია ადგენს მონაცემთა ტიპს და მუშაობს მხოლოდ სტრიქონულ მონაცემებთან. ფუნქცია ავტომატურად ამატებს ერთმაგ ბრჭყალებს მონაცემის ირგვლივ ასე რომ ჩვენ აღარ გვჭირდება შემდეგი ჩანაწერის გაკეთება $sql = "INSERT INTO table (title) VALUES(".$this->db->escape($title).")";
  2. $this->db->escape_str() - ეს ფუნქცია მუშაობს ნებისმიერი ტიპის ინფორმაციასთან მაგრამ გამოიყენება იშვიათად $sql = "INSERT INTO table (title) VALUES('".$this->db->escape_str($title)."')";
  3. $this->db->escape_like_str() - ეს ფუნქცია გამოიყენება როდესაც სტრიქონული ინფორმაცია ჩართულია LIKE ტიპის მოთხოვნებში. $search = '20% raise';
    $sql = "SELECT id FROM table WHERE column LIKE '%" .
    $this->db->escape_like_str($search)."%' ESCAPE '!'";

მოთხოვნათა მაკავშირებლები

მოთხოვნათა მაკავშირებლები საშუალებას გვაძლევენ გავამარტივოთ მოთხოვნის სინტაქსი $sql = "SELECT * FROM some_table WHERE id = ? AND status = ? AND author = ?";
$this->db->query($sql, array(3, 'live', 'Rick'));
ეს კითხვის ნიშნები ავტომატურად შეიცვლება query ფუნქციის მეორე პარამეტრად მითითებული მასივის ელემენტებით. მაკავშირებლები გამოიყენება IN ოპერატორთან მუშაობისასაც $sql = "SELECT * FROM some_table WHERE id IN ? AND status = ? AND author = ?";
$this->db->query($sql, array(array(3, 6), 'live', 'Rick'));
ეს მოთხოვნა დაგენერირდება ასე SELECT * FROM some_table WHERE id IN (3,6) AND status = 'live' AND author = 'Rick'

შეცდომათა დამუშავება

$this->db->error();

თუ გვჭირდება ბოლოს დაშვებული შეცდომის გამოტანა უნდა გამოვიყენოთ error() მეთოდი, რომელიც დააბრუნებს მასივს შეცდომის კოდითა და შეცდომის შეტყობინებით
if ( ! $this->db->simple_query('SELECT `example_field` FROM `example_table`')){
  $error = $this->db->error(); // აქვს გასაღებები 'code' და 'message'
}
          
5. CI - მოთხოვნის შედეგთა გენერირება

შედეგები მასივში

result()

ეს მეთოდი შედეგს აბრუნებს როგორც ობიექტთა მასივს ან აბრუნებს ცარიელ მასივს წარუმატებლობის შემთხვევაში, როგორც წესი მისი დამუშავება ხდება foreach ციკლში
$query = $this->db->query("YOUR QUERY");

foreach ($query->result() as $row){
  echo $row->title;
  echo $row->name;
  echo $row->body;
}
          

result_array()

ეს მეთოდი შედეგს ინახავს ჩვეულებრივ მასივში, თუ შედეგი არ ბრუნდება მასივი ცარიელია, როგორც წესი მისი დამუშავება ხდება foreach ციკლში
$query = $this->db->query("YOUR QUERY");

foreach ($query->result_array() as $row){
  echo $row['title'];
  echo $row['name'];
  echo $row['body'];
}
          

შედეგთა სტრიქონები

row()

ეს მეთოდი აბრუნებს შედეგთა მხოლოდ ერთ ჩანაწერს, სტრიქონს, თუ შედეგად რამოდენიმე ჩანაწერი ამოირჩევა ცხრილიდან მეთოდი დააბრუნებს პირველ მათგანს. შედეგი ბრუნდება ობიექტის სახით
      $query = $this->db->query("YOUR QUERY");

      $row = $query->row();

      if (isset($row)){
        echo $row->title;
        echo $row->name;
        echo $row->body;
      }
          
თუ კონკრეტული ჩანაწერის ამოღება გვსურს შედეგთა ჯგუფიდან მაშინ row() მეთოდს პარამეტრად უნდა მივუთითოთ ამ ჩანაწერის ნომერი $row = $query->row(5);

row_array()

ეს მეთოდი არის წინა მეთოდის იდენტური, უბრალოდ შედეგად ბრუნდება მასივი და არა ობიექტი
      $query = $this->db->query("YOUR QUERY");

      $row = $query->row_array();

      if (isset($row)){
        echo $row['title'];
        echo $row['name'];
        echo $row['body'];
      }
          
თუ კონკრეტული ჩანაწერის ამოღება გვსურს შედეგთა ჯგუფიდან მაშინ row() მეთოდს პარამეტრად უნდა მივუთითოთ ამ ჩანაწერის ნომერი $row = $query->row_array(5); შედეგთა ჯგუფში ნავიგაციისათვის ანუ მოძრაობისათვის გამოიყენება შემდეგი ვარიანტები $row = $query->first_row()
$row = $query->last_row()
$row = $query->next_row()
$row = $query->previous_row()
ნაგულისმეობის პრინციპით ეს მეთოდები აბრუნებენ ობიექტებს, თუ გვსურს რომ დააბრუნონ მასივები მაშინ პარამეტრად უნდა მივუთითოთ სიტყვა “array” $row = $query->first_row('array')
$row = $query->last_row('array')
$row = $query->next_row('array')
$row = $query->previous_row('array')

შედეგთა დამუშავების დამხმარე მეთოდები

num_rows()

მეთოდი გამოიყენება დაბრუნებული ჩანაწერების რაოდენობის დასათვლელად $query = $this->db->query('SELECT * FROM my_table');
echo $query->num_rows();

num_fields()

მეთოდი გამოიყენება მოთხოვნის შედეგში შემავალი ველების რაოდენობის დასათვლელად $query = $this->db->query('SELECT * FROM my_table');
echo $query->num_fields();
6. CI - მოთხოვნათა დამხმარე ფუნქციები

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

$this->db->insert_id()

მბ-ს ცხრილში ჩანაწერების შეტანისას აბრუნებს ჩასმული ჩანაწერის ID-ს.

$this->db->affected_rows()

აბრუნებს იმ ჩანაწერთა რაოდენობას, რომლებიც ცვლილებას განიცდიან "ჩასაწერი" ტიპის მოთხოვნათა შესრულების დროს (insert, update, ..)

$this->db->last_query()

აბრუნებს ბოლოს გაშვებულ მოთხოვნას (მოთხოვნის ტექსტს და არა შედეგს) $str = $this->db->last_query(); // Produces: SELECT * FROM sometable....

ინფორმაცია მბ-ს შესახებ

$this->db->count_all()

საშუალებას გვაძლევს გავიგოთ თუ რამდენი ჩანაწერია კონკრეტულ ცხრილში, პარამეტრად უნდა გადაეცეს ცხრილის სახელი echo $this->db->count_all('my_table'); // მაგ: 25

$this->db->platform()

აბრუნებს მბ-ს პლატფორმას (MySQL, MS SQL, Postgres, ...) echo $this->db->platform();

$this->db->version()

აბრუნებს მბ-ს ვერსიას echo $this->db->version();

მოთხოვნათა გამარტივება

$this->db->insert_string()

ფუნქცია ამარტივებს მბ-ში ინფორმაციის შეტანის პროცესს $data = array('name' => $name, 'email' => $email, 'url' => $url);
$str = $this->db->insert_string('table_name', $data);
პირველი პარამეტრი არის ცხრილის სახელი მეორე კი ასოციაციური მასივი სადაც შეტანილია ველთა დასახელებები გასაღებების სახით და შესატანი მონაცემები ამ გასაღებთა მნიშვნელობების სახით. ზემოთ მოყვანილი კოდი იმუშავებს ასე INSERT INTO table_name (name, email, url) VALUES ('Rick', 'rick@example.com', 'example.com')

$this->db->update_string()

ფუნქცია ამარტივებს მბ-ში ინფორმაციის განახლების პროცესს $data = array('name' => $name, 'email' => $email, 'url' => $url);
$where = "author_id = 1 AND status = 'active'";
$str = $this->db->update_string('table_name', $data, $where);
პირველი პარამეტრი არის ცხრილის სახელი მეორე კი ასოციაციური მასივი სადაც შეტანილია ველთა დასახელებები გასაღებების სახით და შესატანი მონაცემები ამ გასაღებთა მნიშვნელობების სახით. მოყვანილი კოდი იმუშავებს ასე INSERT INTO table_name (name, email, url) VALUES ('Rick', 'rick@example.com', 'example.com') პირველი პარამეტრი არის ცხრილის სახელი მეორე კი ასოციაციური მასივი სადაც შეტანილია ველთა დასახელებები გასაღებების სახით და შესატანი გასანახლებელი ამ გასაღებთა მნიშვნელობების სახით, მესამე პარამეტრი კი განსაზღვრავს “where” წინადადებას მოყვანილი კოდი იმუშავებს ასე UPDATE table_name SET name = 'Rick', email = 'rick@example.com', url = 'example.com' WHERE author_id = 1 AND status = 'active'
7. CI - მოთხოვნათა შექმნის კლასი (Query Builder)
CI-ში ჩადგმულია Query Builder (პირდაპირი მნიშვნელობით მოთხოვნათა ამშენებელი, შემქმნელი,) კლასი. ეს არის ერთგვარი შაბლონი, რომელიც საშუალებას გვაძლევს ამოვიღოთ, განვაახლოთ ან შევიტანოთ ინფორმაცია მბ-ში კოდის მინიმალური რაოდენობის საშუალებით. ხშირ შემთხვევებში საჭიროა ორიოდ ხაზი კოდის დაწერა მბ-სთან დაკავშირებული რაიმე ქმედების შესასრულებლად.

მონაცემთა ამოღება ბაზიდან

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

$this->db->get()

უშვებს ამორჩევის მოთხოვნას და აბრუნებს შედეგს, მაგალითად ამოვიღოთ ყველა ჩანაწერი ცხრილიდან $query = $this->db->get('mytable'); // იგივეა რაც: SELECT * FROM mytable შეგვიძლია მივუთითოთ მეორე და მესამე პარამეტრები limit და offset წინადადებებისათვის $query = $this->db->get('mytable', 10, 20);

// შესრულდება: SELECT * FROM mytable LIMIT 20, 10
შევნიშნოთ რომ ფუნქცია მოთავსებულია $query ცვლადში, რომელიც გამოიყენება შედეგის სანახავად
$query = $this->db->get('mytable');

foreach ($query->result() as $row){
  echo $row->title;
}
          

$this->db->get_compiled_select()

აბრუნებს SQL მოთხოვნას სტრიქონის სახით $sql = $this->db->get_compiled_select('mytable');
echo $sql; // დაბეჭდავს: SELECT * FROM mytable

$this->db->get_where()

მეთოდი გამოიყენება კონკრეტული ჩანაწერის ამოსარჩევად $query = $this->db->get_where('mytable', array('id' => $id), $limit, $offset);

$this->db->select()

$this->db->select('title, content, date');
$query = $this->db->get('mytable');

// შესრულდება: SELECT title, content, date FROM mytable

$this->db->select_max()

$this->db->select_max('age');
$query = $this->db->get('members'); // შესრულდება: SELECT MAX(age) as age FROM members

$this->db->select_max('age', 'member_age');
$query = $this->db->get('members'); // შესრულდება: SELECT MAX(age) as member_age FROM members
მისი ანალოგიური მეთოდია $this->db->select_min()

$this->db->select_avg()

$this->db->select_avg('age');
$query = $this->db->get('members'); // შესრულდება: SELECT AVG(age) as age FROM members

$this->db->select_sum()

$this->db->select_sum('age');
$query = $this->db->get('members'); // შესრულდება: SELECT SUM(age) as age FROM members

$this->db->join()

$this->db->select('*');
$this->db->from('blogs');
$this->db->join('comments', 'comments.id = blogs.id');
$query = $this->db->get();

// შესრულდება:
// SELECT * FROM blogs JOIN comments ON comments.id = blogs.id

კონკრეტული ჩანაწერის ამოღება

$this->db->where()

ფუნქცია საშუალებას გვაძლევს განვსაზღვროთ WHERE წინადადებები შემდეგი ოთხი ვარიანტიდან ერთ-ერთის მეშვეობით
  1. მარტივი გასაღები/მნიშვნელობა მეთოდი

    $this->db->where('name', $name); // Produces: WHERE name = 'Joe' თუ გამოვიყენებთ ამ მეთოდის რამოდენიმე ჩანაწერს, მათში შეტანილი პარამეტრები გაერთიანდება AND ოპერატორის მიერ $this->db->where('name', $name);
    $this->db->where('title', $title);
    $this->db->where('status', $status);
    // WHERE name = 'Joe' AND title = 'boss' AND status = 'active'
  2. შერჩევითი გასაღები/მნიშვნელობა მეთოდი

    $this->db->where('name !=', $name);
    $this->db->where('id <', $id); // Produces: WHERE name != 'Joe' AND id < 45
  3. ასოციაციური მასივის მეთოდი

    $array = array('name' => $name, 'title' => $title, 'status' => $status);
    $this->db->where($array);
    // Produces: WHERE name = 'Joe' AND title = 'boss' AND status = 'active'
  4. შერჩევითი სტრიქონი

    $where = "name='Joe' AND status='boss' OR status='active'";
    $this->db->where($where);

$this->db->or_where()

$this->db->where('name !=', $name);
$this->db->or_where('id >', $id); // Produces: WHERE name != 'Joe' OR id > 50

$this->db->where_in()

$names = array('Frank', 'Todd', 'James');
$this->db->where_in('username', $names);
// Produces: WHERE username IN ('Frank', 'Todd', 'James')

$this->db->or_where_in()

$names = array('Frank', 'Todd', 'James');
$this->db->or_where_in('username', $names);
// Produces: OR username IN ('Frank', 'Todd', 'James')

$this->db->where_not_in()

$names = array('Frank', 'Todd', 'James');
$this->db->where_not_in('username', $names);
// Produces: WHERE username NOT IN ('Frank', 'Todd', 'James')

მსგავსი ჩანაწერის ამოღება

$this->db->like()

$this->db->like('title', 'match');
// Produces: WHERE `title` LIKE '%match%' ESCAPE '!'

$this->db->or_like()

$this->db->like('title', 'match'); $this->db->or_like('body', $match);
// WHERE `title` LIKE '%match%' ESCAPE '!' OR `body` LIKE '%match%' ESCAPE '!'

$this->db->not_like()

$this->db->not_like('title', 'match'); // WHERE `title` NOT LIKE '%match% ESCAPE '!'

$this->db->group_by()

$this->db->group_by("title"); // Produces: GROUP BY title

$this->db->distinct()

$this->db->distinct();
$this->db->get('table'); // Produces: SELECT DISTINCT * FROM table

შედეგთა დალაგება

$this->db->order_by()

$this->db->order_by('title', 'DESC'); // Produces: ORDER BY `title` DESC

შედეგთა ლიმიტი და დათვლა

$this->db->limit()

this->db->limit(10); // Produces: LIMIT 10

მონაცემთა შეტანა ცხრილში

$this->db->insert()

ფუნქციას ცხცრილში შესატანი მნიშვნელობები შეიძლება გადაეცეს მასივის ან ობიექტის სახით.
$data = array(
  'title' => 'My title',
  'name' => 'My Name',
  'date' => 'My date'
);

$this->db->insert('mytable', $data);
// Produces: INSERT INTO mytable (title, name, date) VALUES ('My title', 'My name', 'My date')
           
პირველი პარამეტრი არის ცხრილის სახელი, მეორე კი- მასივი
/*
class Myclass {
   public $title = 'My Title';
   public $content = 'My Content';
   public $date = 'My Date';
}
*/

$object = new Myclass;
$this->db->insert('mytable', $object);
// Produces: INSERT INTO mytable (title, content, date) VALUES ('My Title', 'My Content', 'My Date')
         

მონაცემთა განახლება ცხრილში

$this->db->update()

ფუნქციას ცხცრილში შესატანი მნიშვნელობები შეიძლება გადაეცეს მასივის ან ობიექტის სახით.
$data = array(
  'title' => $title,
  'name' => $name,
  'date' => $date
);

$this->db->where('id', $id);
$this->db->update('mytable', $data);
// Produces:
//
//      UPDATE mytable
//      SET title = '{$title}', name = '{$name}', date = '{$date}'
//      WHERE id = $id
          
/*
class Myclass {
 public $title = 'My Title';
 public $content = 'My Content';
 public $date = 'My Date';
}
*/

$object = new Myclass;
$this->db->where('id', $id);
$this->db->update('mytable', $object);
// Produces:
//
// UPDATE `mytable`
// SET `title` = '{$title}', `name` = '{$name}', `date` = '{$date}'
// WHERE id = `$id`
         

ჩანაწერის წაშლა ცხრილში

$this->db->delete()

$this->db->delete('mytable', array('id' => $id)); // Produces: // DELETE FROM mytable // WHERE id = $id
8. CI - მეტაინფორმაცია მბ-ს შესახებ

მეტაინფორმაცია ცხრილების შესახებ

მბ-ში არსებული ცხრილების სია

მბ-ში არსებული ცხრილების სანახავად გამოიყენება $this->db->list_tables(); ფუნქცია
$tables = $this->db->list_tables();

foreach ($tables as $table)
{
        echo $table;
}
          

არსებობს თუ არა ცხრილი მბ-ში

იმის დასადგენად არსებობს თუ არა ცხრილი მბ-ში გამოიყენება $this->db->table_exists(); ფუნქცია. აბრუნებს TRUE/FALSE მნიშვნელობებს.
if ($this->db->table_exists('table_name'))
{
        // კოდი ...
}
          

მეტაინფორმაცია ცხრილის ველების შესახებ

ცხრილის ველების სია

ცხრილის ველების სანახავად გამოიყენება list_fields() ფუნქცია რომელიც აბრუნებს მასივს
$fields = $this->db->list_fields('table_name');

foreach ($fields as $field)
{
        echo $field;
}
            

არსებობს თუ არა ცხრილი ესა თუ ის ველი

ამის დასადგენად გამოიყენება field_exists() ფუნქცია, რომელიც აბრუნებს TRUE/FALSE მნიშვნელობებს.
if ($this->db->field_exists('field_name', 'table_name'))
{
        // კოდი ...
}
            


CI - მარტივი შინაარსის ბლოგი



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

მოდელი

როგორც ადრე ვთქვით, მონაცემთა ბაზასთან დაკავშირებული ბრძანებები უნდა აღიწეროს მოდელში. მოდელში აღწერილმა კოდმა უნდა უზრუნველჰყოს მბ-ში ინფორმაციის შეტანა, განახლება წაშლა, წაკითხვა. application/models/ საქაღალდეში შევქმნათ ფაილი News_model.php შემდეგი კოდით
<?php
class News_model extends CI_Model {

        public function __construct()
        {
                $this->load->database();
        }
}
           
ამ მომენტისათვის უკვე განსაზღვრული უნდა გვქონდეს მონაცემთა ბაზის კონფიგურაციული პარამეტრები ("CI - მონაცემთა ბაზასთან მუშაობა" განყოფილების მე-2-ე თავი). ახლა შევქმნათ სიახლეების ცხრილი მონაცემთა ბაზაში და დავარქვათ მას news
CREATE TABLE news (
        id int(11) NOT NULL AUTO_INCREMENT,
        title varchar(128) NOT NULL,
        slug varchar(128) NOT NULL,
        text text NOT NULL,
        PRIMARY KEY (id),
        KEY slug (slug)
);
           
ახლა მოდელში ჩავამატოთ მეთოდი get_news, რომელიც ამოიღებს ჩანაწერებს news ცხრილიდან
<?php
class News_model extends CI_Model {

        public function __construct()
        {
           $this->load->database();
        }

        public function get_news($slug = FALSE)
        {
           if ($slug === FALSE)
           {
              $query = $this->db->get('news');
              return $query->result_array();
           }

           $query = $this->db->get_where('news', array('slug' => $slug));
           return $query->row_array();
        }
}
           
get_news()მეთოდის მეშვეობით შესაძლებელია ორი სახის მოთხოვნის შესრულება: შეგვიძლია ცხრილიდან ამოვიღოთ ყველა ჩანაწერი, ან ამოვიყოთ კონკრეტული ჩანაწერი $slug პარამეტრის მიხედვით.

$slug პარამეტრის შესახებ

$slug პარამეტრის უკან მოიაზრება URL მისამართის კონკრეტული ნაწილი, დავუშვათ გვაქვს URL მისამართი , რომელიც იღებს ყველა ჩანაწერს მბ-ს ცხრილიდან http://localhost/news მაგრამ თუ კონკრეტული სიახლის ამოღება გვინდა მაშინ URL მისამართი მიიღებს შემდეგ სახეს http://localhost/news/georgia შევნიშნოთ, რომ მისამართი ახალი სეგმენტის დამატების შემდეგაც საკმაოდ ლოგიკური და აფვილად წაკითხვადია, როგორც ადამიანისათვის, ასევე საძიებელი სისტემებისათვის. მისამართში გამოყენებული სიტყვა georgia შესაძლებელია იყოს უნიკალური იდენტიფიკატორი ცხრილში არსებული კონკრეტული ჩანაწერისათვის, სიახლისათვის. დავუშვათ გვაქვს ცხრილი შემდეგი ველებით id
news_title
news_author
news_unique_identifier
ამ ცხრილიდან კონკრეტული ჩანაწერის ამოღებისას slug პარამეტრის მნიშვნელობად უნდა გამოვიყენოთ news_unique_identifier ველი.

ახლა დავუბრუნდეთ ჩვენს მიერ შექმნილ მოდელს

public function get_news($slug = FALSE)
{
   if ($slug === FALSE)
   {
      $query = $this->db->get('news');
      return $query->result_array();
   }

   $query = $this->db->get_where('news', array('slug' => $slug));
   return $query->row_array();
}
           
ამ მეთოდში აღწერილი კოდი სისტემას ეუბნება რომ თუ $slug პარამეტრის მნიშვნელობა არის FALSE, მაშინ ცხრილიდან ამოიღოს ყველა ჩანაწერი. ხოლო თუ URL მისამართში გაჩნდება ახალი სეგმენტი, მისი მნიშვნელობა აღიქვას როგორც $slug პარამეტრი და ცხრილიდან ამოიღოს ის ჩანაწერი, რომლის უნიკალური ველის (slug) მნიშვნელობაც არის ამ პარამეტრის მიმდინარე მნიშვნელობის ტოლი (get_where('news', array('slug' => $slug));).

სიახლეების გამოტანა

მას შემდეგ რაც მოდელში აღიწერა ჩანაწერების ამოსაღები მოთხოვნები, ეს მოდელი უნდა დაკავშირდე შესაბამის წარმოდგენასთან, რომელშიც მომხმარებელი იხილავს ცხრილიდან ამოღებულ სიახლეებს. შევქმნათ ახალი კონტროლერი application/controllers/News.php შემდეგი კოდით
<?php
class News extends CI_Controller {

        public function __construct()
        {
                parent::__construct();
                $this->load->model('news_model');
                $this->load->helper('url_helper');
        }

        public function index()
        {
                $data['news'] = $this->news_model->get_news();
        }

        public function view($slug = NULL)
        {
                $data['news_item'] = $this->news_model->get_news($slug);
        }
}
           
__construct() მეთოდი იძახებს News კლასის მშობელი კლასის - CI_Controller-ის კონსტრუქტორს, ტვირთავს მოდელს და URL მისამართების დამხმარეს. შემდეგ აღწერილია ორი მეთოდი: პირველი გამოიყენება ყველა ჩანაწერის სანახავად მეორე კი ერთი კონკრეტულისა. მეორე მეთოდში გამოძახებულ მოდელის get_news() ფუნქციას პარამეტრად გადაცემული აქვს $slug ცვლადი, რომელიც კონტროლერში დაფიქსირდება იმ შემთხვევაში თუ URL მისამართში გაჩნდება ახალი სეგმენტი, და რომელსაც მოდელი იყენებს კონკრეტული ჩანაწერის იდენტიფიკაციისათვის.

მას შემდეგ რაც კონტროლერსაც მივაწოდეთ საჭირო ინფორმაცია, ისღა დაგვრჩენია საქმეში ჩავრთოთ წარმოდგენის ფაილი

public function index()
{
        $data['news'] = $this->news_model->get_news();
        $data['title'] = 'News archive';

        $this->load->view('templates/header', $data);
        $this->load->view('news/index', $data);
        $this->load->view('templates/footer');
}
           
ეს კოდი მოდელიდან მიღებულ ყველა ჩანაწერს მოათავსებს $data მასივში, აგრეთვე განსაზღვრავს სიახლეების გვერდის სათაურს $data['news'] = $this->news_model->get_news();
$data['title'] = 'News archive';
სწორედ ეს მასივი უნდა გადაეცეს შესაბამის წარმოდგენას, შევქმნათ წარმოდგენის ფაილი application/views/news/index.php შემდეგი კოდით
<h2><?php echo $title; ?></h2>

<?php foreach ($news as $news_item): ?>

        <h3><?php echo $news_item['title']; ?></h3>
        <div class="main">
                <?php echo $news_item['text']; ?>
        </div>
        <p><a href="<?php echo site_url('news/'.$news_item['slug']); ?>">View article</a></p>

<?php endforeach; ?>
           
foreach ციკლის დახმარებით მოხდება ცხრილში არსებული ჩანაწერების ცალ-ცალკე გამოტანა წარმოდგენაში. ერთ გვერდზე ყველა ჩანაწერი გამოვიტანეთ, ახლა შესაქმნელია კონკრეტული სიახლის სანახავი წარმოდგენის შექმნა, ამისათვის ჯერ კონტროლერს უნდა დავამატოთ შესაბამისი მეთოდი view
public function view($slug = NULL)
{
        $data['news_item'] = $this->news_model->get_news($slug);

        if (empty($data['news_item']))
        {
                show_404();
        }

        $data['title'] = $data['news_item']['title'];

        $this->load->view('templates/header', $data);
        $this->load->view('news/view', $data);
        $this->load->view('templates/footer');
}
           
როგორც ვხედავთ get_news() მეთოდს გადაეცა პარამეტრი $slug, კონკრეტული ჩანაწერის იდენტიფიკატორი. ახლა შევქმნათ წარმოდგენის ფაილი application/views/news/view.php შემდეგი კოდით
<?php
echo '<h2>'.$news_item['title'].'</h2>';
echo $news_item['text'];
           

მარშრუტიზაცია

განვსაზღროთ შესაბამისი მარშრუტები application/config/routes.php საქაღალდეში $route['news/(:any)'] = 'news/view/$1';
$route['news'] = 'news';
$route['(:any)'] = 'pages/view/$1';
$route['default_controller'] = 'pages/view';

ჩანაწერის დამატება ცხრილში

ფორმის შექმნა

შევქმნათა წარმოდგენის ახალი ფაილი application/views/news/create.php და აღვწეროთ მასში ჩანაწერის დასამატებელი ფორმა
<h2><?php echo $title; ?></h2>

<?php echo validation_errors(); ?>

<?php echo form_open('news/create'); ?>

    <label for="title">Title</label>
    <input type="input" name="title" /><br />

    <label for="text">Text</label>
    <textarea name="text"></textarea><br />

    <input type="submit" name="submit" value="Create news item" />

</form>
           
ახლა კონტროლერში დავამატოთ ჩანაწერის დასამატებელი მეთოდი create
public function create()
{
    $this->load->helper('form');
    $this->load->library('form_validation');

    $data['title'] = 'Create a news item';

    $this->form_validation->set_rules('title', 'Title', 'required');
    $this->form_validation->set_rules('text', 'Text', 'required');

    if ($this->form_validation->run() === FALSE)
    {
        $this->load->view('templates/header', $data);
        $this->load->view('news/create');
        $this->load->view('templates/footer');

    }
    else
    {
        $this->news_model->set_news();
        $this->load->view('news/success');
    }
}
           
კოდის პირველი ხაზი ტვირთავს ფორმის დამხმარეს, მეორე კი - ვალიდაციის ბიბლიოთეკას. ამის შემდეგ ხდება ვალიდაციის წესების განსაზღვრა, set_rules() ფუნქციას გადაეცემა სამი პარამეტრი: ველის სახელი, ველის სახელი შეცდომებში გამოსატანად და თავად ვალიდაციის წესი. ამ შემთხვევაში სათაურის და ტექსტის ველების შეყვანა აუცილებელია.

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

<h2>სიახლე წარმატებით დაემატა.</h2>

მოდელი

ახლა საჭიროა შევქმნათ მოდელი, რომელიც მბ-ში შეიტანბს მონაცემებს. ადრე შექმნილ მოდელს დავამატოთ შემდეგი კოდი
public function set_news()
{
    $this->load->helper('url');

    $slug = url_title($this->input->post('title'), 'dash', TRUE);

    $data = array(
        'title' => $this->input->post('title'),
        'slug' => $slug,
        'text' => $this->input->post('text')
    );

    return $this->db->insert('news', $data);
}
          
მოდელში გამოყენებულია url_title() ფუნქცია, ეს ფუნქცია განთავსებულია URL დამხმარეში ახდენს მიწოდებული სტრიქონის ჩასწორებას: გამოტოვებული ადგილები იცვლება ტირით, აგრეთვე ყველა სიტყვა იწერება პატარა ასოებით.

ახლა გავარკვიოთ თუ რა ხდება $data მასივში. მისი ყველა ელემენტი შეესაბამება მბ-ში გაკეთებული ცხრილის ველთა დასახელებებს, შემდეგ გამოყენებულია input ბიბლიოთეკის post() მეთოდი, რომელიც ახდენს ველებში შეყვანილი ინფორმაციის გასუფთავებას და გადამოწმებას. input ბიბლიოთეკის ჩატვირთვა ხდება ავტომატურად, სისტემის მიერ. ამის შემდეგ კი ხდება $data მასივში მოთავსებული ინფორმაციის მბ-ში შეტანა.

მარშრუტიზაცია

$route['news/create'] = 'news/create';
$route['news/(:any)'] = 'news/view/$1';
$route['news'] = 'news';
$route['(:any)'] = 'pages/view/$1';
$route['default_controller'] = 'pages/view';