1. რა არის PHP ?

რა არის PHP ?

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

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

ჰიპერტექსტის პრეპროცესორი

PHP კოდის ჩასმა შესაძლებელია HTML კოდის ნებისმიერ ადგილას: 
<!DOCTYPE html>
<html>
    <head>
        <title>PHP</title>
    </head>
    <body>

        <?php
            echo "ეს PHP კოდია !";
        ?>

    </body>
</html>

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



***

PHP იმდენად მძლავრი იარაღია რომ მასზეა დაფუძნებული ინტერნეტსივრცეში არსებული ბლოგების ყველაზე დიდი გაერთიანება WordPress და მსოფლიოს უდიდესი სოციალური ქსელი Facebook.

რა არის PHP ფაილი ?

PHP ფაილი შეიძლება შეიცავდეს ჩვეულებრივ ტექსტს, HTML, CSS, JavaScript და რა თქმა უნდა PHP კოდს. PHP კოდი ეშვება სერვერზე, შედეგი კი ბრაუზერში ბრუნდება HTML-ის დახმარებით. PHP ფაილების გაფართოებაა '.php'

რა შეუძლია PHP-ს ?

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

რატომ PHP ?

PHP არის მულტიპლატფორმული (Windows, Linux, Unix, Mac OS X და ა.შ), აგრეთვე თავსებადია დღეისათვის არსებულ ყველა პოპლულარულ სერვერთან (Apache, IIS და ა.შ), PHP-ს გადმოწერა უფასოდაა შესაძლებელი ოფიციალური ვებ-გვერდიდან (www.php.net).

ინსტალაცია

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

ზოგადი ტერმინები

რა არის ვებ-ჰოსტინგ სერვისი ?

ვებ-ჰოსტინგ სერვისი არის ინტერნეტ-ჰოსტინგის (ინგ: hosting-მასპინძლობა, მაგ: ინტერნეტ გვერდების :)) ) ერთ-ერთი სახე, რომლის დახმარებითაც კონკრეტულ პიროვნებებს ან ორგანიზაციებს ეძლევათ საშუალება შექმნან მსოფლიო ქსელში (www - World Wide Web) ჩართული საკუთარი ვებ-გვერდი. ჰოსტინგ-პროვაიდერების უმრავლესობა მომხმარებელს სთავაზობს სერვისთა სხვადასხვა კომბინაციებს (მაგალითად ელ_ფოსტის ჰოსტინგი). DNS-ჰოსტინგის სამსახური როგორც წესი დაკავშირებულია დომენის რეგისტრაციასთან. ინტერნეტ-ჰოსტინგის ზოგადი მახასიათებელი კი არის სერვერი, სადაც მომხმარებელს შეუძლია გაუშვას, განათავსოს ნებისმიერი რამ.

რა არის DNS ?

DNS იშიფრება როგორც Domain Name System. იგი არის სისტემა რომელსაც დომენის სახელები გადაჰყავს რიცხვით IP მისამართებში. DNS ჰოსტინგ-სერვისი კი არის სერვისი, რომელიც ამ სისტემას ამუშავებს.

რა არის IP-მისამართი ?

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

ძირითადი სინტაქსი

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

კომენტარები

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

#ერთხაზიანი კომენტარი

/*
რამდენიმეხაზიანი  კომენტარი

შეიცავს სხვადასხვა ხაზებზე განთავსებულ რამდენიმე ჩანაწერს

*/

რეგისტრზე დამოკიდებულება

ერთი და იმავე შედეგს მოგვცემს შემდეგ მაგალითში მოყვანილი სამივე ჩანაწერი 
ECHO "გამარჯობა!<br>";
echo "გამარჯობა!<br>";
EcHo "გამარჯობა!<br>";
ქვემოთ მოყვანილ მაგალითში მხოლოდ პირველი "echo" ჩანაწერი იმუშავებს სწორად 
$color = "ლურჯი"; 

echo $color . "<br>";
echo $COLOR . " <br>";
echo $coLOR . "<br>";
3. ცვლადები

ცვლადის შექმნა

PHP-ში ცვლადის სახელს წინ ერთვის '$' სიმბოლო : 
$txt = "გამარჯობა მსოფლიოვ!";

$x = 5;

$y = 10.5;
პროგრამირების სხვა ენებისაგან განსხვავებით PHP-ში არ გვხვდება ცვლადთა გამოცხადების ბრძანებები, ცვლადი იქმნება მაშინ, როდესაც პირველად ავკრეფთ მის დასახელებას.

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

  • ცვლადის სახელს წინ ერთვის '' სიმბოლო
  • ცვლადის სახელი იწყება ლათინური ანბანის ასობგერით ან ქვედა ტირით
  • ცვლადის სახელი არ შეიძლება დაიწყოს ციფრით
  • ცვლადის სახელი შეიძლება შეიცავდეს მხოლოდ ანბანის ასოებს, ქვედა ტირეს და ციფრებს (A-z, 0-9, და _ )
  • ცვლადის სახელები არის რეგისტრზე დამოკიდებული ($age და $AGE სხვადახვა ცვლადებია)

ცვლადთა გამოტანა

PHP-ში ინფორმაციის ეკრანზე გამოსატანად ყველაზე ხშირად გამოიყენება 'echo' ჩანაწერი. 
$txt = "W3Schools.com";
echo "მე მიყვარს $txt!";
იგივე შედეგს მოგვცემს შემდეგი ჩანაწერიც : 
$txt = "W3Schools.com";
echo "მე მიყვარს " . $txt . "!";
ეს ჩანაწერი კი გამოიტანს ორი ცვლადის ჯამს 
$x = 5;
$y = 4;
echo $x + $y;

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

ცვლადი შეიძლება გამოცხადდეს კოდის ნებისმიერ ადგილას. ცვლადის თვალთახედვის არე არის კოდის ნაწილი, სადაც შეიძლება, რომ გამოვიყენოთ ეს ცვლადი. თვალთახედვის არე PHP-ში შეიძლება იყოს სამნაირი :
  • ლოკალური (local)
  • გლობალური (global)
  • სტატიკური (static)

გლობალური და ლოკალური თვალთახედვა

ფუნქციის გარეთ გამოცხადებულ ცვლადს აქვს გლობალური თვალთახედვა და შეიძლება გამოვიყენოთ მხოლოდ ფუნქციის გარეთ 
$x = 5; // გლობალური თვალთახედვა

function myTest() 
{
    // x ცვლადის ფუნქციაში გამოყენება გამოიწვეწვს შეცდომას
    echo $x;
} 

myTest();

echo $x; // 5
ფუნქციაში გამოცხადებულ ცვლადს აქვს ლოკალური თვალთახედვა და შეიძლება გამოვიყენოთ მხოლოდ ფუნქციის შიგნით : 
function myTest() 
{
    $x = 5; // ლოკალური თვალთახედვა
    echo $x; // 5
} 

myTest();

echo $x; // x ცვლადის ფუნქციის გარეთ გამოყენება გამოიწვეწვს შეცდომას
შესაძლებელია ერთი და იგივე სახელის მქონე ლოკალური ცვლადების სხვადასხვა ფუნქციებში გამოყენება, რადგან ლოკალური ცვლადი აღიქმება მხოლოდ იმ ფუნქციაში, რომელშიც აღწერილია იგი. : 
function myTest() 
{
    echo $x = 5; 
} 

function yourTest() 
{
    echo $x = 15; 
} 

myTest(); // 5
yourTest(); // 15

სიტყვა გასაღები global

სიტყაგასაღები global გამოიყენება ფუნქციაში გლობალურ ცვლადთან წვდომისათვის, ამისათვის საჭიროა, ფუნქციაში ცვლადის დასახელებების წინ გამოვიყენოთ სიტყვაგასაღები global : 
$x = 5; 
$y = 10;

function myTest() 
{
    global $x, $y;
    $y = $x + $y;
}

myTest();
echo $y; // შედეგი 15
გლობალურ ცვლადებს PHP ინახავს $GLOBALS[index] მასივში. index არის გლობალური ცვლადის სახელი. ამ მასივის გამოყენება შესაძლებელია ფუნქციაშიც : 
$x = 5;
$y = 10;

function myTest() 
{
    $GLOBALS['y'] = $GLOBALS['x'] + $GLOBALS['y'];
} 

myTest();

echo $y; // outputs 15

სიტყვა გასაღები static

როდესაც ფუნქციაში აღწერილი ქმედებები შესრულდება/დასრულდება, ამ ფუნქციის ყველა ცვლადი იშლება. მაგრამ ხანდახან საჭიროა, რომ ლოკალური ცვლადი არ წაიშალოს, რადგან იგი საჭიროა შემდეგი ოპერაციისათვის. ამისათვის გამოიყენება სიტყაგასაღები static : 
function myTest() 
{
    static $x = 0;
    echo $x;
    $x++;>
}

myTest();
myTest();
myTest();
ამ შემთხვევაში, ყოველ ჯერზე როდესაც ფუნქციას გამოვიძახებთ ცვლადი შეინახავს იმ ინფორმაციას რომელიც მიიღო ფუნქციის წინა გამოძახებისას (მიუხედავად ამისა ცვლადი მაინც ლოკალურ ცვლადად რჩება).
4. echo და print
PHP-ში ინფორმაციის გამოტანის ორი ძირითადი ხერხი არსებობს: echo და print. ეს ორი მეთოდი თითქმის ერთი და იგივე შინაარსისაა, თუმცა არის მცირე სხვაობაც : echo-ს შეიძლება გადაეცეს რამოდენიმე პარამეტრი (მაგ: echo "and a ", 1, 2, 3; თუმცა ასეთი გამოყენება იშვიათია), print-ს კი შეძლება გააჩნდეს მხოლოდ ერთი არგუმენტი (მაგ: print "and a 123";). echo უფრო სწრაფია ვიდრე print.

echo ჩანაწერი

ტექსტის გამოტანა

echo ჩანაწერის გამოყენება შესაძლებელია ფრჩხილებითაც და მათ გარეშეც - echo ან echo() . echo -სთვის პარამეტრად გადაცემული ტექსტი შეიძლება შეიცავდეს html ნიშნულებს : echo "<h2>PHP!</h2>";
echo "გამარჯობა მსოფლიოვ!<br>";
echo "ეს სტრიქონი ", "შეიქმნა ", "რამოდენიმე ", "პარამეტრის მეშვეობით";

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

$txt1 = "ვისწავლოთ PHP";
$x = 5;
$y = 4;

echo "<h2>$txt1</h2>";
echo $x + $y;

print ჩანაწერი

print ჩანაწერის გამოყენებაც შესაძლებელია ფრჩხილებითაც და მათ გარეშეც - print ან print().

ტექსტის გამოტანა

print "<h2>PHP</h2>";
print "გამარჯობა მსოფლიოვ!<br>";

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

$txt1 = "Learn PHP";
$x = 5;
$y = 4;

print "<h2>$txt1</h2>";
print $x + $y;
5. მონაცემთა ტიპები
ცვლადში შეიძლება შევინახოთ სხვადასხვა ტიპის ინფორმაცია, სხვადასხვა ტიპის ინფორმაცით კი შეიძლება გავაკეთოთ სხვადასხვა რამ. PHP-ში გვხვდება შემდეგი ტიპის მონაცემები :
  • სტრიქონული (String)
  • მთელი (Integer)
  • მცოცავმძიმიანი ანუ ათწილადი (Float)
  • ლოგიკური (Boolean)
  • მასივი (Array)
  • ობიექტი (Object)
  • NULL

სტრიქონული ტიპი

სტრიქონი არის სიმბოლოების თანმიმდევრობა. მაგალითად "გამარჯობა მსოფლიოვ!". სტრიქონად აღიქმება ბრჭყალებში მოქცეული ნებისმიერი ტექსტი, შესაძლებელია, როგორც ორმაგი, ასევე ჩვეულებრივი ბრჭყალების გამოყენება : $x = "გამარჯობა მსოფლიოვ!";
$y = 'გამარჯობა მსოფლიოვ!';

მთელი ტიპი

მონაცემთა მთელ ტიპს მიეკუთვნება [-2147483648 - 2147483647] ინტერვალში მოქცეული ნებისმიერი მთელი რიცხვი.

2 147 483 647

მათემატიკაში მერსენის მარტივი რიცხვი ეწოდება მარტივ რიცხვს, რომელიც მიიღება 2-ის რომელიღაც ხარისხში აყვანის შედეგზე ერთის გამოკლებით : Mn = 2n − 1 სადაც n მთელი რიცხვია.

2 147 483 647 არის უდიდესი მნიშვნელობა, რომელიც შეიძლება ჩაიწეროს 32 ბიტიან ორობით კოდში. ეს რიცხი ასევე არის მერსენის ერთ-ერთი მარტივი რიცხვი :

231−1 = 2 147 483 647

***

მთელი ტიპის ცვლადი :

  • უნდა შეწიცავდეს ერთ ციფრს მაინც
  • არ უნდა შეიცავდეს მცოცავ მძიმეს
  • შეიძლება იყოს დადებითიც და უარყოფითიც
მოყვანილ მაგალითში $x არის მთელი. : $x = 5985;
var_dump($x); // int(5985)

ათწილადი ტიპი

ათწილადი ტიპის, ანუ იგივე მცოცავმძიმიანი ტიპის არის რიცხვი რომელიც შეიცავს ათწილადის წერტილს და ჩაწერილია ექსპონენციალური ფორმით. $x = 10.365;
var_dump($x); // float(10.365)

ლოგიკური ტიპი

ლოგიკურმა ტიპმა შეიძლება მიიღოს ორი მნიშვნელობიდან ერთ-ერთი - true ან false, ანუ ჭეშმარიტი ან მცდარი.

ტიპი მასივი

მასივი არის ერთ ცვლადში გაერთიანებული რამოდენიმე მნიშვნელობა. $cars = array("Volvo","BMW","Toyota");

PHP ობიექტი

ობიექტი ეს არის მონაცემთა ტიპი რომელშიც ინახება მონაცემები და ინფორმაცია იმის შესახებ თუ როგორ დავამუშავოთ ეს მონაცემები. პირველ რიგში უნდა გამოვაცხადოთ ობიექტის კლასი, ამისათვის გამოიყენება სიტყვა-გასაღები class, კლასი არის სტრუქტურა, რომელიც შეიცავს მეთოდებსა და თვისებებს 
class Car 
{
    function Car() 
    {
        $this->model = "BMW";
    }
}

// შეიქმნა ობიექტი
$car = new Car();

// ობიექტის თვისებების ნახვა
echo $car->model;  // BMW

NULL

NULL არის მონაცემთა სპეციალური ტიპი, რომელსაც გააჩნია ერთადერთი მნიშვნელობა - NULL. NULL ტიპის მონაცემის შემცველი ცვლადი ეს არის ცვლადი რომელსაც არ აქვს მითითებული მნიშვნელობა. თუ ცვლადი შექმნილია მნიშვნელობის გარეშე მაშინ მისი მნიშვნელობა ავტომატურად ხდება NULL. შესაძლებელია ცვლადის მნიშვნელობის გასუფთავება მასზე NULL მნიშვნელობის მინიჭებით : $x = "გამარჯობა მსოფლიოვ!";
$x = null;
var_dump($x);
6. სტრიქონები

strlen()

სტრიქონის სიგრძის გაგება echo strlen("გამარჯობა მსოფლიოვ!"); // შედეგი იქნება 19

str_word_count()

სტრიქონში შემავალი სიტყვების რაოდენობის დათვლა echo str_word_count("გამარჯობა მსოფლიოვ!"); // შედეგი იქნება 2

strrev()

სტრიქონის შებრუნება echo strrev("გამარჯობა მსოფლიოვ!"); // შედეგი იქნება !dlrow olleH

strpos()

strpos() ფუნქცია გამოიყენება განსაზღვრული ტექსტის საძებნელად სტრიქონში. თუ დამთხევა დაფიქსირდება, ფუნქცია დააბრუნებს იმ სიმბოლოს პოზიციას რომელიც პირველად დაემთხვევა, თუ დამთხევა არ დაფიქსირდება დაბრუნდება false. 
// შედეგი იქნება 10 რადგან სტრიქონის პირველი სიმბოლოს პოზიციაა 0 და არა 1
echo strpos("გამარჯობა მსოფლიოვ!", "მსოფლიოვ");

explode()

სტრიქონში შემავალი სიტყვების მასივში მოთავსება $str = "გამარჯობა მსოფლიოვ";
print_r (explode(" ",$str)); // Array ( [0] => გამარჯობა [1] => მსოფლიოვ )

implode()

მასივის ელემენტების სტრიქონად გაერთიანება $arr = array('გამარჯობა','მსოფლიოვ');
echo implode(" ",$arr); // გამარჯობა მსოფლიოვ

lcfirst()

სტრიქონის პირველ ასოს წერს დაბალ რეგისტრში. echo lcfirst("გამარჯობა"); // hello

md5()

ითვლის სტრიქონის md5 ჰეშს (MD5 - Message Digest 5, ჰეშირების ალგორითმი). $str = "გამარჯობა";
echo md5($str); // 1094cd1a709a9e40abbdc31468fbfe08

str_ireplace()

str_replace() ფუნქცია სტრიქონში შემავალ რომელიმე სიმბოლოს ანაცვლებს სხვა სიმბოლოთი. ფუნქცია არის რეგისტრზე დამოკიდებული. რეგისტრზე დამოუკიდებელი, ანალოგიური შინაარსის ფუნქცია არის str_ireplace(). ფუნქციის სინტაქსი ასეთია : str_replace(find,replace,string,count)
  • find - აუცილებელია მითითება. რასაც ვეძებთ
  • replace - აუცილებელია მითითება. რითაც ვანაცვლებთ იმას რასაც ვეძებთ
  • string - აუცილებელია მითითება. სტრიქონი რომელშიც ვეძებთ
  • count - არააუცილებელია მითითება. მთვლელი რომელიც ითვლის თუ რამდენი სიმბოლო ჩანაცვლდა

str_repeat()

str_repeat() ფუნქცია იმეორებს სტრიქონს პარამეტრად მითითებულ რიცხვჯერ. გამოყენების სინტაქსი ასეთია : str_repeat(string,repeat) echo str_repeat(".",13); // შედეგი იქნება .............

strcasecmp()

strcasecmp() ფუნქცია ადარებს ორ სტრიქონს, მისი მუშაობა რეგისტრზე დამოკიდებული არ არის. გამოყენების სინტაქსი ასეთია : strcasecmp(string1,string2) შედეგი კი არის შემდეგი :
  • 0 - თუ სტრიქონები ტოლია
  • უარყოფითი რიცხვი - თუ string1 ნაკლებია ვიდრე string2
  • დადებითი რიცხვი - თუ string1 მეტია ვიდრე string2

strip_tags()

strip_tags() ფუნქცია ასუფთავებს სტრიქონს HTML, XML, da PHP ტეგებისაგან. გამოყენების სინტაქსი ასეთია : strip_tags(string,allow) // allow პარამეტრად მითითებული ტეგები არ წაიშლება // შედეგი იქნება 'გამარჯობა მსოფლიოვ' და არა 'გამარჯობა მსოფლიოვ'
echo strip_tags("გამარჯობა <i>მსოფლიოვ</i>");

substr()

substr() ფუნქცია აბრუნებს სტრიქონის ნაწილს. გამოყენების სინტაქსი ასეთია : substr(string,start,length)
  • string - აუცილებელია მითითება. მიუთითებს სტრიქონს რომლის ნაწილის დაბრუნებაც გვინდა
  • start - აუცილებელია მითითება. მიუთითებს თუ რომელი პოზიციიდან გვინდა ამოჭრა. თუ დადებითი რიცხვია მაშინ ამოჭრას დაიწყებს ამ რიცხის ტოლი პოზიციიდან, თუ უარყოფითი რიცხვია მაშინ ამოჭრას დაიწყებს სტრიქონის ბოლოდან, ხოლო თუ ნოლია მაშინ სტრიქონის დასაწყისიდან.
  • length - აუცილებელია მითითება. მიუთითებს თუ რამდენი სიმბოლოს ამოჭრა გვინდა
7. კონსტანტები
კონსტანტა თავისი შინაარსით წააგავს ცვლადს, უბრალოდ მათ შორის ის განსხვავებაა, რომ როდესაც კონსტანტა განისაზღვრება შემდეგ შეუძლებელია მისი მნიშვნელობის შეცვლა. კონსტანტის დასახელება იწყება ლათინური ანბანის ასოთი ან ქვედა ხაზით. ('$' ნიშანი არ გამოიყენება). ცვლადებისაგან განსხვავებით კონსტანტა გამოცხადებისთანავე გლობალურია მთლიანი სკრიპტის მასშტაბით. კონსტანტის შესაქმნელად გამოიყენება define() ფუნქცია, შექმნის სინტაქსი ასეთია : define(name, value)
  • name - განსაზღრავს კონსტანტის სახელს.
  • value - განსაზღრავს კონსტანტის მნიშვნელობას.
კონსტანტის შექმნის მაგალითი : define("GREETING", 'გამარჯობა');
echo GREETING;

defined() ფუნქცია

defined() ფუნქცია ამოწმებს უკვე შექმნილია თუ არა ესა თუ ის კონსტანტა : 
define("GREETING", 'გამარჯობა');
echo defined("GREETING"); // 1
8. ოპერატორები
ოპერატორები გამოიყენება ცვლადებზე ოპერაციების ჩასატარებლად. PHP-ში ოპერატორები იყოფა შემდეგ ჯგუფებად :
  • არითმეტიკული ოპერატორები
  • მინიჭების ოპერატორები
  • შედარებითი ოპერატორები
  • ინკრემენტ/დეკრემენტ ოპერატორები
  • ლოგიკური ოპერატორები
  • სტრიქონული ოპერატორები
  • მასივის ოპერატორები

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

არითმეტიკული ოპერაციები გამოიყენება რიცხვითი მნიშვნელობების მქონე ცვლადებზე ისეთი ოპერაციების ჩასატარებლად როგორებიცაა მიმატება, გამოკლება, გამრავლება, გაყოფა და ა.შ.
ოპერატორი დასახელება მაგალითი შედეგი
+ მიმატება $x + $y $x და $y ცვლადების ჯამი
- გამოკლება $x - $y $x და $y ცვლადების სხვაობა
* გამრავლება $x * $y $x და $y ცვლადების ნამრავლი
/ გაყოფა $x / $y $x და $y ცვლადების განაყოფი
% ნაშთიანი გაყოფა $x % $y $x ცვლადის $y ცვლადზე გაყოფის შედეგად მიღებული ნაშთი
** ახარისხება $x$y $x ცვლადი $y ხარისხში

მინიჭების ოპერატორები

მინიჭების ოპერატორები გამოიყენება რიცხვითი ტიპის ცვლადებზე მნიშვნელობათა მინიჭებისათვის.
ოპერატორი იგივეა რაც ... აღწერა
x = y x = y მარცხენა ოპერანდს მიენიჭება მარჯვენა ოპერანდის მნიშვნელობა
x += y x = x + y მიმატება
x -= y x = x - y გამოკლება
x *= y x = x * y გამრავლება
x /= y x = x / y გაყოფა
x %= y x = x % y x-ის y-ე გაყოფის ნაშთი

შედარებითი ოპერატორები

შედარებითი ოპერატორები გამოიყენება ორი ოპერანდის შესადარებლად
ოპერატორი დასახელება მაგალითი შედეგი
== ტოლია $x == $y შედეგი ჭეშმარიტია თუ $x უდრის $y-ს
=== იდენტურია $x === $y შედეგი ჭეშმარიტია თუ $x უდრის $y-ს და $x და $y ერთი და იგივე ტიპისაა
!= არ უდრის $x != $y შედეგი ჭეშმარიტია თუ $x არ უდრის $y-ს
<> არ უდრის $x <> $y შედეგი ჭეშმარიტია თუ $x არ უდრის $y-ს
!== არაიდენტურია $x !== $y შედეგი ჭეშმარიტია თუ $x არ უდრის $y-ს ან ისინი არ არიან ერთიდა იმავე ტიპისანი
> მეტია $x > $y შედეგი ჭეშმარიტია თუ $x მეტია $y-ზე
< ნაკლებია $x < $y შედეგი ჭეშმარიტია თუ $x ნაკლებია $y-ზე
>= მეტია ან ტოლი $x >= $y შედეგი ჭეშმარიტია თუ $x მეტია ან ტოლი $y-ზე
<= ნაკლებია ან ტოლი $x <= $y შედეგი ჭეშმარიტია თუ $x ნაკლებია ან ტოლი $y-ზე

ინკრემენტ/დეკრემენტ ოპერატორები

ოპერატორი დასახელება აღწერა
++$x პრე-ინკრემენტი ზრდის $x-ს ერთით და შემდეგ აბრუნებს $x-ს
$x++ პოსტ-ინკრემენტი ჯერ აბრუნებს $x-ს და შემდეგ ზრდის ერთით
--$x პრე-დეკრემენტი ამცირებს $x-ს ერთით და შემდეგ აბრუნებს $x-ს
$x-- პოსტ-დეკრემენტი ჯერ აბრუნებს $x-ს და შემდეგ ამცირებს ერთით

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

ლოგიკური ოპერაციები გამოიყენება პირობითი ოპერატორების კომბინირებისათვის.
ოპერატორი დასახელება მაგალითი შედეგი
and და $x and $y ჭეშმარიტია თუ ჭეშმარიტია $x-ც და $y-იც
or ან $x or $y ჭეშმარიტია თუ ჭეშმარიტია $x ან $y
xor Xან $x xor $y ჭეშმარიტია თუ ჭეშმარიტია $x ან $y, მაგრამ არა ორივე ერთდროულად
&& და $x && $y ჭეშმარიტია თუ ჭეშმარიტია $x-ც და $y-იც
|| ან $x || $y ჭეშმარიტია თუ ჭეშმარიტია $x ან $y
! არა !$x ჭეშმარიტია თუ მცდარია $x

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

ოპერატორი დასახელება მაგალითი შედეგი
. კონკატენაცია ანუ გაერთიანება $txt1 . $txt2 $txt1 და $tx2t-ის გაერთიანება
.= კონკატენაცია ანუ გაერთიანება $txt1 .= $txt2 $txt1-ს დაამატებს $txt2-ს

მასივის ოპერატორები

ოპერატორი დასახელება მაგალითი შედეგი
+ კავშირი $x + $y $x-ის და $y-ს შეერთება
=== იდენტურია $x === $y შედეგი ჭეშმარიტია თუ $x უდრის $y-ს და $x და $y ერთი და იგივე ტიპისაა
== ექვივალენტურობა $x == $y შედეგი ჭეშმარიტია თუ $x-ს და $y-ს აქვთ ერთნაირი გასაღები/მნიშვნელობა წყვილები
== იდენტურობა $x === $y შედეგი ჭეშმარიტია თუ $x-ს და $y-ს აქვთ ერთნაირი გასაღები/მნიშვნელობა წყვილები, და ისინი ერთი და იგივე ტიპისანებიც არიან
!= არაექვივალენტურობა $x != $y შედეგი ჭეშმარიტია თუ $x არ უდრის $y-ს
<> არაექვივალენტურობა $x <> $y შედეგი ჭეშმარიტია თუ $x არ უდრის $y-ს
!== არაიდენტურობა $x!=== $y შედეგი ჭეშმარიტია თუ $x არ არის $y-ის ექვივალენტური
9. if...else...elseif
კოდის წერისას ხშირია შემთხვევები, როდესაც სხვადასხვა პირობებისას სხვადასხვა ქმედებების შესრულება გვიწევს. PHP-ში არსებობს პირობითი ჩანაწერების შემდეგი ვარიანტები :
  • if - რომელიმე კოდი სრულდება მაშინ როდესაც პირობა ჭეშმარიტია
  • if...else - რომელიმე კოდი სრულდება მაშინ როდესაც პირობა ჭეშმარიტია და სრულდება სხვა კოდი თუ პირობა მცდარია
  • if...elseif....else - სრულდება სხვადასხვბა კოდები სხვადასხვა პირობების ჭეშმარიტობის მიხედვით
  • switch - შესასრულებლად არჩევს რამდენიმე ბლოკიდან ერთ-ერთს
if ჩანაწერის გამოყენების სინტაქსი : 
if(პირობა) 
{ 
    კოდი შესრულდება თუ პირობა ჭეშმარიტია;
}
კონკრეტული მაგალითი : 
$num = 5;

if($num > 0) 
{ 
    echo "დედაბითი რიცხვი";
}
if...else ჩანაწერის გამოყენების სინტაქსი : 
if (პირობა) 
{
    კოდი შესრულდება თუ პირობა ჭეშმარიტია;
} 
else 
{
    კოდი შესრულდება თუ პირობა მცდარია;
}
კონკრეტული მაგალითი : 
$num = 5;

if($num > 0) 
{ 
    echo "დედაბითი რიცხვი";
}
else
{
    echo "უარყოფითი რიცხვი";
}
if...elseif....else ჩანაწერის გამოყენების სინტაქსი : 
if (პირობა) 
{
    კოდი შესრულდება თუ ეს პირობაა ჭეშმარიტი;
} 
elseif (პირობა) 
{
    კოდი შესრულდება თუ ეს პირობაა ჭეშმარიტი;
} 
else 
{
    კოდი შესრულდება თუ ორივე პირობა მცდარია;
}
კონკრეტული მაგალითი : 
$num = 0;

if($num > 0) 
{ 
    echo "დედაბითი რიცხვი";
}
elseif ($num < 0)
{
    echo "უარყოფითი რიცხვი";
}
else
{
    echo "0-ის ტოლია";
}
10. switch ჩანაწერი
switch ჩანაწერი გამოიყენება რამდენიმე ბლოკიდან ერთის ამორჩევისა და შესრულებისათვის : 
switch (n) 
{
    case label1:
        კოდი შესრულდება თუ n=label1;
        break;
    case label2:
        კოდი შესრულდება თუ n=label2;
        break;
    case label3:
        კოდი შესრულდება თუ n=label3;
        break;
    ...
    default:
        კოდი შესრულდება თუ n != არც ერთ ზემოთა ვარიანტს;
}
კონკრეტული მაგალითი : 
$favcolor = "ლურჯი";

switch ($favcolor) 
{
    case "ლურჯი":
        echo "თქვენი ფავორიტი ფერია ლურჯი";
        break;
    case "წითელი":
        echo "თქვენი ფავორიტი ფერია წითელი";
        break;
    case "მწვანე":
        echo "თქვენი ფავორიტი ფერია მწვანე";
        break;
    default:
        echo "თქვენი ფავორიტი ფერია ნარინჯისფერი";
}
11. ციკლები
კოდის წერისას ხშირია შემთხვევები, როდესაც საჭიროა ერთი და იგივე ბლოკის რამოდენიმეჯერ შესრულება. ამისათვის გამოიყენება ციკლები. PHP ში არსებობს შემდეგი სახის ციკლები :
  • while - ციკლი არის ასე ვთქვათ წინაპირობითი, პრეპირობითი, რაც ნიშნავს იმას, რომ პირობის შემოწმება/შესრულება ხდება ციკლის გამოძახებამდე, ციკლის ტანის შესრულებამდე გამოითვლება ლოგიკური პირობის მნიშვნელობა, თუ პირობა ჭერშმარიტია მაშინ ციკლიც სრულდება, ამის შემდეგ ისევ მოწმდება პირობა, ციკლი მეორდება მანამ სანამ პირობა არის ჭეშმარიტი - true.
  • do...while - ციკლი while - საგან განსხვავეიბით არის პოსტპირობითი ანუ ციკლის გაგრძელების ლოგიკური პირობა იწერება ციკლის ტანის შემდეგ. ციკლის ტანში აღწერილი მოქმედება მინიმუმ ერთხელ სრულდება და ამის შემდეგ მოწმდება ციკლის გაგრძელების პირობა, თუ იგი ჭეშმარიტია ანუ true, მაშინ ციკლი კიდევ სრულდება.
  • for - ციკლის ეს ოპერატორი თავის თავში მოიცავს ცვლადს, ე.წ ციკლის პარამეტრს ან ციკლის მთვლელს. ციკლი იწყება სიტყვა გასარებით for შემდეგ ფრჩხილებში იწერება კონსტრუქცია, რომელიც მოიცავს ციკლის პარამეტრის ინიციალიზაციას, ლოგიკურ გამოსახულებას და ამ პარამეტრის მოდიფიკაციის ანუ ცვლილების ჩანაწერს.
  • foreach - ბლოკში აღწერილ ქმედებებს ასრულებს მასივის თითოეული ელემენტისათვის.

while ციკლი

ინგლ: while - ამ დროს, ამ ხნის განავლობაში, მანამ;

ციკლის გამოყენების სინტაქსი ასეთია : 
while (პირობა ჭეშმარიტია) 
{
    შესასრულებელი ინსტრუქცია;
}
                    
$x = 1; 

while($x < 10) 
{
    echo  $x . "<br>";
    $x+=2 ;
}
შედეგი იქნება : 1
3
5
7
9



do...while ციკლი

ციკლის გამოყენების სინტაქსი ასეთია : 
do 
{
    შესასრულებელი ინსტრუქცია;
} 
while (პირობა ჭეშმარიტია);
კონკრეტული მაგალითი : 
$x = 5; 

do 
{
    echo  $x . "<br>";
    $x++;
} 
while ($x <= 5);
$x ცვლადის განსაზღვრის შემდეგ პირდაპირ ციკლის ინსტრუქციაში შევდივართ ასე, რომ $x რიცხვი მინიმუმ ერთხელ დაიბეჭდება, შემდეგ შემდეგ $x რიცხვი უნდა გავზარდოთ ერთით, ამის შემდეგ კი გადავამოწმოთ პირობა $x <= 5, ამ დროს კი რიცხვი უკვე 6-ის ტოლია, ანუ $x დაიბეჭდება მხოლოდ ერთხელ.

for ციკლი

გამოყენების სინტაქსი ასეთია : 
for (მთვლელის ინიციალიზაცია; ციკლის მთვლელი; მთვლელის ცვლილება) 
{
    შესასრულებელი ინსტრუქცია;

}
კონკრეტული მაგალითი : 
for ($x = 0; $x <= 4; $x++) 
{
    echo  $x . "<br>";
}
შედეგი იქნება : 0
1
2
3
4

foreach ციკლი

foreach ციკლი მუშაობს მხოლოდ მასივებთან და გამოიყენება ციკლის ყველა გასაღები/მნიშვნელობა წყვილის დასაბრუნებლად, გამოყენების სინტაქსი ასეთია : 
foreach ($array as $value) 
{
    შესასრულებელი ინსტრუქცია;
}
ციკლის ყოველ იტერაციაზე ციკლის მიმდინარე ელემეტი თავსდება $value ცვლადში და შემდეგ ხდება მასივში ერთი ბიჯით წინ წანაცვლება, მანამ სანამ მასივის ბოლო ელემენტიც არ მოხვდება $value ცვლადში. 
$colors = array("წითელი", "ყვითელი", "მწვანე");

foreach ($colors as $value) 
{
    echo "$value <br>";
}
შედეგი იქნება : წითელი
ყვითელი
მწვანე
12. ფუნქციები
ფუნქცია არის კოდის ნაწილი, რომელიც შეგვიძლია გამოვიყენოთ, სხვადასხვა დროსა და სხვადასხვა ადგილას. ფუნქციაში აღწერილი ოპერაციები სრულდება მაშინ, როდესაც ფუნქციას გამოვიძახებთ. ფუნქციის შექმნის სინტაქსი ასეთია : 
function functionName() 
{  
    //  ფუნქციის კოდი
}
ფუნქციის დასახელება შეიძლება დაიწყოს ლათინური ანბანის ასოთი ან ქვედა ტირით (მაგრამ არა ციფრით), სასურველია ფუნქციის სახელი ასოცირდებოდეს იმ ოპერაციასთან რასაც თავად ფუნქცია ასრულებს. ფუნქციის სახელები არ არის რეგისტრის მიმართ მგძნობიარე.

ფუნქციის არგუმენტები

ფუნქციას ინფორმაცია შეიძლება მიეწოდოის არგუმენტების საშუალებით. არგუმენტების მითითება ხდება ფუნქციის დასახელების შემდეგ მრგვალ ფრჩხილებში, თუ რამოდენიმე არგუმენტს ვუთითებთ ისინი ერთმანეთისაგან უნდა გამოვყოთ მძიმით. 
function familyName($fname) 
{
    echo $fname;
}

familyName("ვასო");
familyName("გიორგი");
იმისათვის რათა ფუნქციამ დააბრუნოს რაიმე შედეგი, გამოიყენება return ჩანაწერი : 
function sum($x, $y) 
{
    $z = $x + $y;
    return $z;
}

echo sum(5, 10); // 15
13. მასივები
მასივი არის ცვლადის ტიპი, რომელშიც ერთდროულად ინახება რამოდენიმე მნიშვნელობა.

მასივის შექმნა

მასივი იქმნება array() ფუნქციის დახმარებით. PHP-ში გვხვდება სამი სახის მასივი :
  • ინდექსირებული მასივი - მასივი რომლის ინდექსებიც ციფრებია.
  • ასოციაციური მასივი - მასივი სახელდებული ინდექსებით.
  • მრავალგანზომილებიანი მასივი - მასივი რომელიც მოიცვავს რამოდენიმე მასივს.

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

ინდექსირებული მასივის შექმნის ორი ვარიანტი არსებობს : $cars = array("Volvo", "BMW", "Toyota"); ან : $cars[0] = "Volvo";
$cars[1] = "BMW";
$cars[2] = "Toyota";
 მასივის სიგრძის გასაგებათ გამოიყენება count() ფუნქცია $cars = array("Volvo", "BMW", "Toyota");
echo count($cars); // 3

ინდექსირებული მასივის დათვალიერება

$cars = array("Volvo", "BMW", "Toyota");
$arrlength = count($cars);

for($x = 0; $x < $arrlength; $x++) 
{
    echo $cars[$x];
    echo "<br>";
}

ასოციაციური მასივი

ასოციაციურ მასივში ელემენტთა იდენტიფიკაციისათვის გამოყენებულია სახელდებული სიტყვაგასაღებები. ასეთი მასივი შეიძლება შეიქმნას შემდეგნაირად : $age = array("Peter"=>"35", "Ben"=>"37", "Joe"=>"43"); ან : $age['Peter'] = "35";
$age['Ben'] = "37";
$age['Joe'] = "43";

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

$age = array("Peter"=>"35", "Ben"=>"37", "Joe"=>"43");

foreach($age as $x => $x_value) 
{
    echo "გასაღები=" . $x . ", მნიშვნელობა=" . $x_value;
    echo "<br>";
}

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

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

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

ორგანზომილებიანი მასივი არის მასივების მასივი. (სამგანზომილებიანი - მასივების მასივების მასივი და ა.შ). 
$cars = array(
    array("Volvo",22,18),
    array("BMW",15,13),
    array("Saab",5,2),
    array("Land Rover",17,15)
);
$cars მასივი მოიცავს ოთხ მასივს, და მას აქვს ორი ინდექსი: სტრიქონი და სვეტი, ამიტომ ამ მასივის ელემენტებთან წვდომისათვის უნდა მივუთითოთ ორი პარამეტრი - სტრიქონი და სვეტი echo $cars[0][0].": დარჩენილია: ".$cars[0][1].", გაყიდულია: ".$cars[0][2]; მასივის მთლიანად დასათვალიერებლად კი უნდა გამოვიყენოთ for ციკლში შაშენებული კიდევ ერთი for ციკლი : 
for ($row = 0; $row < 4; $row++) 
{
    echo "<ul>";
        for ($col = 0; $col < 3; $col++) 
        {
            echo "<li>".$cars[$row][$col]."</li>";
        }
    echo "</ul>";
}

მასივთან სამუშაო ფუნქციები

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

sort()

sort() მეთოდით შესაძლებელია მასივის ელემენტების დალაგება ზრდადობის მიხედვით. როდესაც მასივის ელემენტები შეიცავენ ტექსტური ტიპის ინფორმაციას მაშინ მეთოდი მათ ალაგებს ანბანის მიხედვით/
$cars = array("Volvo", "BMW", "Toyota");
sort($cars); // BMW, Toyota, Volvo ხოლო რიცხვითი ტიპის ელემენტები ლაგდება ზრდადობის მიხედვით $numbers = array(4, 6, 2, 22, 11);
sort($numbers); // 2, 4, 6, 11, 22 sort() ფუნქციის შებრუნებული ფუნქციაა rsort(), რომელიც კლებადობის მიხედვით ალაგებს მასივს.

asort() და ksort()

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

arsort() და krsort()

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

სხვა ფუნქციები

array_chunk()

ინგ: chunk - ნაჭერი, ნატეხი;

array_chunk() ფუნქცია, მარტივად რომ ვთქვათ, აკეთებს შემდეგ რამეს: მასივს ჭრის პატარა მასივებად და ამ ნაჭრებს ათავსებს ერთ დიდ მასივში. ფუნქციის გამოყენების სინტაქსი ასეთია : array_chunk(array,size,preserve_key);
  • array - აუცილებელია მითითება. მასივი რომელთანაც ვმუშაობთ.
  • size - აუცილებელია მითითება. მთელი რიცხვი რომელიც განსაზღვრავს "ნაჭრების" სიგრძეს.
  • preserve_key - არააუცილებელია მითითება. ნაგულისმეობის პრინციპით არის false. სავარაუდო მნიშვნელობები :
    • true - ინახავს გასაღებებს
    • false - ნაჭრებს გადანომრავს რიცხვითი ინდექსებით
$cars=array("Volvo","BMW","Toyota","Honda","Mercedes","Opel");

echo "<pre>";
print_r(array_chunk($cars,2));
echo "</pre>";
შედეგი იქნება : 
Array
(
    [0] => Array
        (
            [0] => Volvo
            [1] => BMW
        )

    [1] => Array
        (
            [0] => Toyota
            [1] => Honda
        )

    [2] => Array
        (
            [0] => Mercedes
            [1] => Opel
        )
)

array_column()

array_column() ფუნქცია მრავალგანზომილებიან მასივში შემავალი ყველა ქვე-მასივიდან იღებს ერთ რომელიმე სვეტს და ათავსებს ახალ მასივში. გამოყენების სინტაქსი ასეთია : array_column(array,column_key,index_key);
  • array - აუცილებელია მითითება. მასივი რომელთანაც ვმუშაობთ.
  • column_key - აუცილებელია მითითება. მტელი ან ტექსტური გასაღები, იმ სვეტის დასახელება რომლის მნიშვნელობებსაც ვაგროვებთ ახალ მასივში.
  • index_key - არააუცილებელია მითითება. სვეტი რომლის მნიშვნელობებიც გამოიყენება როგორც ინდექსი/გასაღები ახალ მასივში. 
$a = array( 
    array(
        'id' => 5698,
        'first_name' => 'Peter',
        'last_name' => 'Griffin',
    ),
    array(
        'id' => 4767,
        'first_name' => 'Ben',
        'last_name' => 'Smith',
    ),
    array(
        'id' => 3809,
        'first_name' => 'Joe',
        'last_name' => 'Doe',
    )
);

$last_names = array_column($a, 'last_name');
print_r($last_names);
შედეგი იქნება : 
                
Array
(
    [0] => Griffin
    [1] => Smith
    [2] => Doe
)
ახლა მივუთითოთ მესამე პარამეტრი index_key : $last_names = array_column($a, 'last_name', 'id');
print_r($last_names);
 შედეგი იქნება : 
Array
(
    [5698] => Griffin
    [4767] => Smith
    [3809] => Doe
)

array_combine()

ინგ : combine – შეერთება, მიმაგრება, მიერთება, გაერთიანება, შერევა;

array_combine() ფუნქცია ქმნის ასოციაციურ მასივს რომლის გასაღებებიცაა არგუმენტად გადაცემული პირველი ჩვეულებრივი მასივის ელემენტები, ხოლო მნიშვნელობები კი არგუმენტად გადაცემული მეორე ჩვეულებრივი მასივის ელემენტები. ორივე მასივს უნდა ჰქონდეს ერთი და იგივე რაოდენობის ელემენტები. ფუნქციის გამოყენების სინტაქსი ასეთია : array_combine(keys,values);
  • keys - აუცილებელია მითითება. გასაღებების მასივი
  • values - აუცილებელია მითითება. მნიშვნელობების მასივი
$fname=array("Peter","Ben","Joe");
$age=array("35","37","43");

$c=array_combine($fname,$age);
print_r($c); შედეგი იქნება : Array
(
    [Peter] => 35
    [Ben] => 37
    [Joe] => 43
)

array_count_values()

array_count_values() ფუნქცია თვლის თუ რამდენჯერ მეორდება მასივის თითოეული ელემენტი მასივში. გამოყენების სინტაქსი ასეთია : array_count_values(array)
  • array - აუცილებელია მითითება. განსაზღრავს მასივს რომლის ელემენტებსაც ვთვლით.
$a=array("A","Cat","Dog","A","Dog");
print_r(array_count_values($a)); შედეგი იქნება : Array
(
    [A] => 2
    [Cat] => 1
    [Dog] => 2
)

array_diff()

array_diff() ფუნქცია ადარებს ორ ან მეტ მასივს და აბრუნებს სხვაობას. სინტაქსი ასეთია : array_diff(array1,array2,array3...);
  • array1 - აუცილებელია მითითება. განსაზღრავს პირველ მასივს
  • array2 - აუცილებელია მითითება. განსაზღრავს მეორე მასივს
  • array3 - არააუცილებელია მითითება. განსაზღრავს მესამე მასივს
  • ...
$a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
$a2=array("e"=>"red","f"=>"green","g"=>"blue");

$result=array_diff($a1,$a2);
print_r($result); შედეგი იქნება Array
(
    [yellow] => 1
)

array_intersect()

array_intersect() ფუნქცია ადარებს ორ ან მეტ მასივს და აბრუნებს პირველი მასივის იმ ელემენტებს, რომლებიც დანარჩენ მასივებშიცაა. სინტაქსი ასეთია : array_intersect(array1,array2,array3...);
  • array1 - აუცილებელია მითითება. განსაზღრავს პირველ მასივს
  • array2 - აუცილებელია მითითება. განსაზღრავს მეორე მასივს
  • array3 - არააუცილებელია მითითება. განსაზღრავს მესამე მასივს
  • ...
$a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
$a2=array("e"=>"red","f"=>"green","g"=>"blue");

$result=array_intersect($a1,$a2);
print_r($result); შედეგი იქნება Array
(
    [a] => red
    [b] => green
    [c] => blue
)

array_filter()

array_filter() ფუნქცია ფილტრავს მასივის ელემენტებს საპასუხო ფუნქციის საშუალებით, საპასუხო ფუნქციაში ტარდება მასივის ყველა ელემენტი და თუ საპასუხო ფუნქცია დააბრუნებს მნიშვნელობას true, მაშინ მასივის მიმდინარე ელემენტი ხვდება პასუხების მასივში. სინტაქსი ასეთია : array_filter(array,callbackfunction);
  • array1 - აუცილებელია მითითება. განსაზღრავს გასაფილტრ მასივს
  • callbackfunction - აუცილებელია მითითება. განსაზღრავს საპასუხო ფუნქციას
მაგალითად გავფილტროთ მასივის ის ელემენტები, რომელთა მნიშვნელობებიც მეტია ერთზე. function test_odd($var){
    return($var > 1);
}

$a1=array("a","b",2,3,4);
print_r(array_filter($a1,"test_odd")); შედეგი იქნება Array ( [2] => 2 [3] => 3 [4] => 4 )

array_flip()

array_flip() ფუნქცია ადგილს უცვლის მასსივის გასაღებებსა და მნიშვნელობებს, მნიშვნელობები ხდება გასაღებები, და პირიქით. სინტაქსი ასეთია : array_flip(array);
  • array - აუცილებელია მითითება. განსაზღრავს სამუშაო მასივს
$a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
$result=array_flip($a1);
print_r($result);
 შედეგი იქნება Array ( [red] => a [green] => b [blue] => c [yellow] => d )

array_key_exists()

array_key_exists() ფუნქცია ამოწმებს გვხვდება თუ არა მასივში განსაზღვრული გასაღები, თუ გვხვდება აბრუნებს true-ს, ხოლო თუ არა false-ს. სინტაქსი ასეთია array_key_exists(key,array)
  • key - აუცილებელია მითითება. განსაზღრავს გასაღებს
  • array - აუცილებელია მითითება. განსაზღრავს მასივს
$a=array("Volvo"=>"XC90","BMW"=>"X5");
if (array_key_exists("Volvo",$a)){
    echo "Key exists!";
}
else{
    echo "Key does not exist!";
} თუ გასაღებს არ მივუთითებთ გენერირდება გასაღები მნიშვნელობით - 0, და შემდეგ ყოველი ელემენტისათვის ეს მნიშვნეკლობა იზრდება ერთით.

array_keys()

array_keys() ფუნქცია მასივის გასაღებებს ალაგებს ცალკე მასივში. სინტაქსი ასეთია array_keys(array,value,strict)
  • array - აუცილებელია მითითება. განსაზღრავს მასივს
  • value - არააუცილებელია მითითება. ამოიკრიფება მხოლოდ ამ მნიშვნელობის მქონე გასაღებები
$a=array("Volvo"=>"XC90","BMW"=>"X5","Toyota"=>"Highlander"); print_r(array_keys($a)); შედეგი იქნება Array ( [0] => Volvo [1] => BMW [2] => Toyota )

array_map()

array_map() ფუნქცია მასივის ყველა ელემენტს აგზავნის მომხმარებლის მიერ შექმნილ ფუნქციაში და აბრუნებს ახალ მასივს ახალი მნიშვნელობებით, იმ მნიშვნელობებით რომლებსაც მასივის ელემენტები მიიღებენ ფუნქციაში მოხვედრისას. სინტაქსი ასეთია array_map(myfunction,array1,array2,array3...)
  • myfunction - აუცილებელია მითითება. ეს არის მომხმარებლის ფუნქციის სახელი
  • array1 - აუცილებელია მითითება. განსაზღრავს მასივს
  • array2 - არააუცილებელია მითითება. განსაზღრავს მასივს
  • ...
მაგალითად array_map() ფუნქციის დახმარებით ავიყვანოთ მასივის ყველა ელემენტი კვადრატში function myfunction($v){
    return($v*$v);
}

$a=array(1,2,3,4,5);
print_r(array_map("myfunction",$a)); შედეგი იქნება Array
(
    [0] => 1
    [1] => 4
    [2] => 9
    [3] => 16
    [4] => 25
)

array_merge()

array_merge() ფუნქცია აერთიანებს 0რ ან მეტ მასივს ერთ მასივში (merge - შერწყმა). თუ რამდენიმე მასივს აქვს ერთნაირი გასაღებები მაშინ ბოლო მათგანის მნიშვნელობა გადაეწერება დანარჩნებს. სინტაქსი ასეთია array_merge(array1,array2,array3...)
  • - აუცილებელია მითითება. განსაზღრავს მასივს
  • - არააუცილებელია მითითება. განსაზღრავს მასივს
  • ...
$a1=array("a"=>"red","b"=>"green");
$a2=array("c"=>"blue","b"=>"yellow");
print_r(array_merge($a1,$a2)); შედეგი იქნება Array
(
    [a] => red
    [b] => yellow
    [c] => blue
) array_merge() ფუნქციაში განვსაზღვრავთ მხოლოდ ერთ მასივს, რომლის გასაღებებიც მთელი რიცხვებია, ფუნქცია დააბრუნებს ახაკლ მასივს, რომლის ინდექსებიც აგრეთვე მთელი რიცხვები იქნება, უბრალოდ გადათვლა დაიწყება 0-დან და გაიზრდება ერთით $a=array(3=>"red",4=>"green");
print_r(array_merge($a)); შედეგი იქნება Array
(
    [0] => red
    [1] => green
)

array_pop()

შლის მასივის ბოლო ელემენტს. სინტაქსი ასეთია array_pop(array) $a=array("red","green","blue");
array_pop($a);
print_r($a); შედეგი იქნება Array ( [0] => red [1] => green )

array_push()

array_push() ამატებს ერთ ან რამდენიმე ელემენტს მასივის ბოლოში. სინტაქსი ასეთია array_push(array,value1,value2...) თუ მასივში სტრიქონული ტიპის გასაღებებია მაშინ დამატებული ელემენტების ფასაღებები იქნება რიცხვითი ტიპის, ათვლა კი დაიწყება 0-დან $a=array("a"=>"red","b"=>"green");
array_push($a,"blue","yellow");
print_r($a); შედეგი იქნება Array ( [a] => red [b] => green [0] => blue [1] => yellow )

array_product()

ითვლის მასივის ელემენტების ნამრავლს array_product(array) $a=array(5,5,2,10);
echo(array_product($a)); // 500

array_rand()

array_rand() ფუნქცია აბრუნებს შემთხვევით გასაღებს. იმ შემთხვევაში თუ ფუნქციას მივუთითებთ პარამეტრად რაიმე x რიცხვს, მაშინ ამოიკრიფება x ცალი გასაღები, ისინი გაერთიანდებიან მასივში და დაბრუნდება ეს მასივი. სინტახსი ასეთია array_rand(array,number) $a=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow"); print_r(array_rand($a,2));

array_search()

array_search() ფუნქცია ეძებს მასივში მნიშვნელობას და აბრუნებს ამ მნიშვნელობის გასაღებს. სინტაქსი ასეთია array_search(value,array,strict)
  • value - აუცილებელია მითითება. განსაზღრავს მნიშვნელობას
  • array - აუცილებელია მითითება. განსაზღრავს მასივს
  • strict - არააუცილებელია მითითება. თუ ეს პარამეტრი არის TRUE, მაშინ ეწს ფუნქცია მოძებნის იდენტურ მნიშვნელობებს მასივში. პარამეტრის სავარაუდო მნიშვნელობებია true და false (ნაგულისხმეობის პრინციპით). როდესაც მითითებულია true, რიცხვი 5 და სტრიქონი 5 აღიქმება სხვადასხვა რამეებად.
$a=array("a"=>"5","b"=>5,"c"=>"5");
echo array_search(5,$a,true); // b

array_shift()

array_shift() ფუნქცია შლის მასივის პირველ ელემენტს და აბრუნებს წაშლილი ელემენტის მნიშვნელობას. თუ გასაღებები არის რიცხვითი ტიპის, ყველა ელემენტი მიიღებს ახალ გასაღებს, გადათვლა დაიწყება 0-დან. სინტაქსი ასეთია array_shift(array) $a=array(0=>"red",1=>"green",2=>"blue");
echo array_shift($a);
print_r ($a); შედეგი იქნება red
Array ( [0] => green [1] => blue )

array_unshift()

array_unshift() ფუნქცია ამატებს ელემენტებს მასივის დასაწყისში და აბრუნებს ახალი მასივის სიგრძეს. რიცხვითი გასაღებების გადათვლა დაიწყება 0-დან, ტექსტურები კი იგივე დარჩება. სინტაქსი ასეთია array_unshift(array,value1,value2,value3...) $a=array("a"=>"red","b"=>"green");
print_r(array_unshift($a,"blue"));
print_r($a); შედეგი იქნება 3
Array (
    [0] => blue
    [a] => red
    [b] => green
)

array_slice()

array_slice() ფუნქცია აბრუნებს მასივის მითითებულ ნაწილს. თუ მასივს აქვს ტექსტური გასაღებები, დაბრუნებული მასივი ყოველთვის ინახავს გასაღებებს. სინტაქსი ასეთია array_slice(array,start,length,preserve)
  • array - აუცილებელია მითითება. განსაზღრავს მასივს
  • start - აუცილებელია მითითება. რიცხვითი მნიშვნელობა. მიუთითებს თუ საიდან უნდა დაიწყოს ფუნქციამ ამოჭრა. 0 = პირველ ელემენტს. თუ ამ პარამეტრის მნიშვნელობა უარყოფითია, ფუნქცია მასივის ბოლოდან გადმოთვლის პარამეტრის აბსოლიტური მნიშვნელობის ტოლ ელემენტს და იქიდან დაიწყებს ამოჭრას.
  • length - არააუცილებელია მითითება. რიცხვითი მნიშვნელობა. განსაზღრავს დასაბრუნებელი მასივის სიგრძეს. თუ ამ პარამეტრის მნიშვნელობა უარყოფითია, ფუნქცია მასივის ბოლო ელემენტიდან გადმოთვლის პარამეტრის აბსოლიტური მნიშვნელობის ტოლ ელემენტს და მასზე გააჩერებს ამოჭრას. ხოლო თუ ეს პარამეტრი საერთოდ არ იქნება მითითებული ამოჭრა მოხდება start-დან მასივის ბოლომდე.
  • array - არააუცილებელია მითითება. განსაზღრავს შეინახოს თუ არა ფუნქციამ გასაღებები. პარამეტრის სავარაუდო მნიშვნელობებია true(ინახავს გასაღებებს) და false (ნაგულისმეობის პრინციპით, ანახლებს გასაღებებს).
$a=array("red","green","blue","yellow","brown");
print_r(array_slice($a,1,2)); // შედეგი იქნება Array
(
    [0] => green
    [1] => blue
) $a=array("red","green","blue","yellow","brown");
print_r(array_slice($a,1,2,true)); // შედეგი იქნება Array
(
    [1] => green
    [2] => blue
)

array_sum()

array_sum() ფუნქცია ითვლის მასივის ელემენტების ჯამს. სინტაქსი ასეთია array_sum(array) $a=array(5,5,2,10);
echo(array_sum($a)); // 22

array_unique()

array_unique() ფუნქცია შლის გამეორებად ელემენტებს მასივში. როდესაც მნიშვნელობების გამეორება ხდება, იშლება ყველა მათგანი პირველის გარდა. სინტაქსი ასეთია array_unique(array) $a=array("a"=>"red","b"=>"green","c"=>"red");
print_r(array_unique($a)); შედეგი იქნება Array
(
    [a] => red
    [b] => green
)

array_values()

array_values() ფუნქცია აბრუნებს მასივს, რომელშიც შესულია პირველი მასივის მხოლოდ მნიშვნელობები. დაბრუნებულ მასივს ექნება რიცხვითი გასაღებები, გადათვლა დაიწყება 0-დან. სინტაქსი ასეთია array_values(array) $a=array("Name"=>"Peter","Age"=>"41","Country"=>"USA");
print_r(array_values($a)); შედეგი იქნება Array
(
    [0] => Peter
    [1] => 41
    [2] => USA
)

compact()

compact() ფუნქცია ცვლადებისა და მათი მნიშვნელობებისაგან აკეთებს მასივს. სინტაქსი ასეთია compact(var1,var2...) $firstname = "Peter";
$lastname = "Griffin";
$age = "41";

$result = compact("firstname", "lastname", "age");

print_r($result); შედეგი იქნება Array ( [firstname] => Peter [lastname] => Griffin [age] => 41 )

in_array()

in_array() ფუნქცია ამოწმებს არის თუ არა კონკრეტული მნიშვნელობა მასივში. თუ საძიებელი პარამეტრი არის სტრიქონული ტიპის type პარამეტრი არის TRUE, მაშიბ ძებნა არის რეგისტრის მიმართ მგრძნობიარე. სინტაქსი ასეთია in_array(search,array,type) $people = array("Peter", "Joe", "Glenn", "Cleveland");

if (in_array("Glenn", $people)) {
    echo "Match found";
}
else{
    echo "Match not found";
}
14. სუპერგლობალური ცვლადები
PHP-ში არსებობს რამოდენიმე წინასწარგანსაზღვრული, სუპერგლობალური ცვლადი, რომელთა გამოყენებაც შესაძლებელია ნებისმიერ ფუნქციაში, კლასში, ფაილში და ა.შ ამისათვის არაფრის გაკეთება აღარაა საჭირო, ეს ცვლადები უკვე განსაზღვრულია. სუპერგლობალური ცვლადებია :
  • $GLOBALS
  • $_SERVER
  • $_REQUEST
  • $_POST
  • $_GET
  • $_FILES
  • $_ENV
  • $_COOKIE
  • $_SESSION

$GLOBALS

$GLOBALS არის სუპერგლობალური ცვლადი გლობალურ ცვლადებთან წვდომისათვის სკრიპტის ნებისმიერი ადგილიდან. PHP ინახავს ყველა გლობალურ ცვლადს მასივში, რომლის სახელიცაა - $GLOBALS[index] სადაც index არის ცვლადის სახელი. $x = 75;
$y = 25;

function addition() {
    $GLOBALS['z'] = $GLOBALS['x'] + $GLOBALS['y'];
}

addition();
echo $z; როგორც ვხედავთ, $GLOBALS მასივის დახმარებით, ფუნქციაში გამოვიყენეთ ისეთი ცვლადები, რომლებიც ამ ფუნქციაში არ არის აღწერილი.

$_SERVER

$_SERVER არის სუპერგლობალური ცვლადი რომელიც ინახავს ინფორმაციას სათაურების(headers), გზების(paths) და სკრიპტების მდებარეობის შესახებ.
ელემენტი/კოდი აღწერა
$_SERVER['PHP_SELF'] აბრუნებს იმ ფაილის სახელს რომელშიც აღწერილია მიმდინარე მომენტში გაშვებული კოდი (მაგ: /learn/php/index.php)
$_SERVER['SCRIPT_NAME'] აბრუნებს მიმდინარე სკრიპტის გზას (მაგ: /learn/php/index.php)
$_SERVER['GATEWAY_INTERFACE'] აბრუნებს სერვერის მიერ გამოყენებული CGI-ს ვერსიას (CGI - Common Gateway Interface ანუ ინტერფეისის სტანდარტი, რომელიც გამოიყენება შიდა პროგრამის სერვერთან დასაკავშირებლად)
$_SERVER['SERVER_ADDR'] აბრუნებს ჰოსტინგ სერვერის IP მისამართს
$_SERVER['SERVER_NAME'] აბრუნებს ჰოსტინგ სერვერის დასახელებას (მაგ: www.w3schools.com ან )
$_SERVER['SERVER_SOFTWARE'] აბრუნებს სერვერის იდენტიფიკაციის სტრიქონს (მაგ: Apache/2.4.23)
$_SERVER['SERVER_PROTOCOL'] აბრუნებს ინფორმაციის პროტოკოლის სახელს და ვერსიას (მაგ: HTTP/1.1 )
$_SERVER['REQUEST_METHOD'] აბრუნებს თუ რა სახის მოთხოვნა იგზავნება სერვერზე იმისათვის რათა ჩაიტვირთოს მიმდინარე გვერდი (მაგ: GET )
$_SERVER['REQUEST_TIME'] აბრუნებს მოთხოვნის დაწყების მომენტის დროის ნიშბულს (მაგ: 1491234638)
$_SERVER['QUERY_STRING'] აბრუნებს მოთხოვნის სტრიქონს, თუმიმდინარე გვერდი გამოძახებულია მოთხოვნის სტრიქონით (მაგ: მიმდინარე გვერდის URL არის test.php?q=4 მაშინ ფუნქცია დააბრუნებს : q=4)
$_SERVER['REMOTE_ADDR'] აბრუნებს IP მისამართს საიდანაც მომხმარებელი ათვალიერებს მიმდინარე გვერდს
$_SERVER['REMOTE_HOST'] აბრუნებს ჰოსტის სახელს საიდანაც მომხმარებელი ათვალიერებს მიმდინარე გვერდს
$_SERVER['SCRIPT_FILENAME'] აბრუნებს აბსოლიტურ, მთლიან გზას იმ სკრიპტისას რომელიც მიმდინარე მომენტშია გაშვებული (მაგ: E:/wamp/www/learn/php/index.php )
$_SERVER['SERVER_PORT'] აბრუნებს პორტის ნომერს რომელზეც სერვერია გაშვებული (მაგ: 80)

$_REQUEST

PHP $_REQUEST გამოიყენება HTML ფორმის გაგზავნის შემდეგ (submit form) აკრეფილი ინფორმაციის გასაერთიანებლად. დავუშვათ HTML ფორმას მითითებული არ აქვს acttion ატრიბუტი, ანუ ფორმა იგზავნება იმავე გვერდზე სადაც მოთავსებულია : 
<form method="post" action="<?php echo $_SERVER['PHP_SELF'];?>"> 
    სახელი: <input type="text" name="fname">
    <input type="submit">
</form>

<?php

if ($_SERVER["REQUEST_METHOD"] == "POST") 
{
    $name = $_REQUEST['fname'];

    if (empty($name)) 
    {
        echo "სახელი ცარიელია";
    } 
    else 
    {
        echo $name;

    }
}

?>
ამ პირობის მითითების გარეშე : if ($_SERVER["REQUEST_METHOD"] == "POST") მიმდინარე გვერდზე შემოსვლისას დაფიქსირდებოდა შემდეგი შეცდომა : Notice: Undefined index: fname in ..... on line x რაც ნიშნავს, რომ სკრიპტისთვის გაურკვეველია fname ცვლადის მნიშვნელობა და ეს ლოგიკურიცაა რადგან გვერდზე შენოსვლისას, რა თქმა უნდა, ავტომატურად ვერ დაეჭირება 'submit' ღილაკს, აქედან გამომდინარე, არ არსებობს მოთხოვნა სერვერზე, რაც თავის მხრივ ნიშნავს, რომ არ არსებობს POST ტიპის მოთხოვნა ანუ არ არსებობს $name.

$_POST

$_POST მეთოდი გამოიყენება HTML-ფორმის 'POST' მეთოდით გაგზავნის შემდეგ აკრეფილი ინფორმაცის შესაკრებად : 
<form method="post" action="<?php echo $_SERVER['PHP_SELF'];?>"> 
    სახელი: <input type="text" name="fname">
    <input type="submit">
</form>

<?php

if ($_SERVER["REQUEST_METHOD"] == "POST") 
{
    $name = $_POST['fname'];
    
    if (empty($name)) 
    {
        echo "სახელი ცარიელია";
    } 
    else 
    {
        echo $name;
    }
}

?>

$_GET

$_GET მეთოდი ხშირად გამოიყენება HTML-ფორმის 'GET' მეთოდით გაგზავნის შემდეგ აკრეფილი ინფორმაცის შესაკრებად. ამ თოდს აგრეთვე შეუძლია ინფორმაციის მიღება URL-დან. ვთქვათ გვაქვს ასეთი სახის ბმული : <a href="test_get.php?fname=ვასო&lname=ნადირაძე">ტესტი</a> როდესაც მომხმარებელი დააწვება ამ ბმულს, პარამეტრები "fname" და "lname" გაიგზავნება "test_get.php" გვერდზე, მათი მნიშვნელობების გასაგებად კი ამ გვერდის კოდში დაგვეხმარება $_GET მეთოდი : echo "სახელი : " . $_GET['fname'] . " გვარი " . $_GET['lname'];
15. ფორმები
PHP-ს სუპერგლობალური ცვლადები $_GET და $_POST გამოიყენება HTML ფორმაში აკრეფილი ინფორმაციების დასამუშავებლად. განვიხილოთ მარტივი HTML ფორმა : <form action="welcome.php" method="post">
    სახელი: <input type="text" name="name">
    ელ_ფოსტა: <input type="text" name="email">
    <input type="submit">
</form> როდესაც მომხმარებელი შეავსებს ველებს და დააწვება გაგზავნის ღილაკს, აკრეფილი ინფორმაცია დასამუშავებლად გაიგზავნება PHP ფაილში სახელად - "welcome.php". ინფორმაცია გაიგზავნება HTTP POST მეთოდით. welcome.php გვერდზე ამ ინფორმაციის გამოტანა მოხდება ასე : გამარჯობა <?php echo $_POST["name"]; ?>
თქვენი ელ_ფოსტის მისამართი : <?php echo $_POST["email"]; ?> შედეგი იქნება რაღაც ამის მსგავსი : გამარჯობა ვასო
თქვენი ელ_ფოსტის მისამართი : vaso@gmail.com იგივეს გაკეთება შესაძლებელია HTTP GET მეთოდითაც : <form action="welcome_get.php" method="get">
    სახელი: <input type="text" name="name">
    ელ_ფოსტა: <input type="text" name="email">
    <input type="submit">
</form> welcome_get.php გვერდზე ამ ინფორმაციის გამოტანა მოხდება ასე გამარჯობა <?php echo $_GET["name"]; ?>
თქვენი ელ_ფოსტის მისამართი: <?php echo $_GET["email"]; ?>

GET vs POST

ორივე მათგანი GET და POST ქმნის მასივს (მაგ: array( key => value, key2 => value2, key3 => value3, ...)). მასივი შეიცავს 'გასაღები/მნიშვნელობა' წყვილებს, სადაც გასაღებები არის ფორმის ელემენტების სახელები (ატრიბუტი name), ხოლო მნიშვნელობები მომხმარებლის მიერ ამ ელემენტებში შეტანილი ინფორმაციები. $_GET და $_POST არიან სუპერგლობალური ცვლადები, რაც ნიშნავს რომ მათთან წვდომა შესაძლებელია კოდის ნებისმიერი მონაკვეთიდან და ნებისმიერ დროს.



როდის გამოვიყენოთ GET ?

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

როდის გამოვიყენოთ POST ?

POST მეთოდით გაგზავნილი ინფორმაცია სხვებისათვის უხილავია (ყველა სახელი/მნიშვნელობა ჩადებულია HTTP მოთხოვნის ტანში), ამასთანავე ამ ინფორმაციის მოცულობა შეუზღუდავია.
16. ფორმის ვალიდაცია
ფორმებთან მუშაობისას აუცილებლად უნდა ვიფიქროთ უსაფრთხოებაზე ! ფორმიდან გაგზავნილი ინფორმაციის გადამოწმება ანუ ფორმის ვალიდაცია უმნიშვნელოვანესი რამაა თუ გვსურს რომ თავი დავიცვათ ჰაკერებისაგან. განვიხილოთ ასეთი ფორმა : <form method="post" action="<?php echo htmlspecialchars($_SERVER["PHP_SELF"]);?>">
   სახელი: <input type="text" name="name">
   ელ_ფოსტა: <input type="text" name="email">
   ვებ-გვერდი: <input type="text" name="website">
   კომენტარი: <textarea name="comment" rows="5" cols="40"></textarea>
   <input type="submit" name="submit" value="გაგზავნა">
</form>

$_SERVER["PHP_SELF"]

ეს ჩანაწერი : <form method="post" action="<?php echo htmlspecialchars($_SERVER["PHP_SELF"]);?>"> ნიშნავს, რომ ფორმის გაგზავნის შემდეგ ინფორმაციის გაგზავნა მოხდება 'POST' მეთოდით. $_SERVER["PHP_SELF"] არის სუპერგლობალური ცვლადი, რომელიც აბრუნებს იმ ფაილის გზას (path), რომელშიც მიმდინარე სკრიპტია აღწერილი, ინფორმაცია დასამუშავებლად გაიგზავნება იმავე გვერდზე სადაც ფორმაა მოთავსებული, მაგრამ აქ ყურადრება უნდა მიექცეს ერთ მომენტს: ვთქვათ "test_form.php" გვაქვს ასეთი ფორმა: <form method="post" action="<?php echo $_SERVER["PHP_SELF"];?>"> ახლა თუ მომხმარებელი მისამართის ველში აკრეფს კორექტულ URL-ს, მაგალითად : "http://www.example.com/test_form.php", ზედა ჩანაწერი გადაითარგმნება ასე <form method="post" action="test_form.php"> ამ შემთხვევაში ყველაფერი რიგზეა, მაგრამ თუ მომხმარებელი, მისამართის ველში ჩაწერს შემდეგს http://www.example.com/test_form.php/%22%3E%3Cscript%3Ealert('hacked')%3C/script%3E ზედა კოდი გადაითარგმნება რეოგორც : <form method="post" action="test_form.php/"><script>alert('hacked')</script> როგორც ვხედავთ URL-ს დაემატა alert ბრძანება და როდესაც გვერდი ჩაიტვირტება javascript შეასრულებს ამ ბრძანებას. ეს არის PHP_SELF ცვლადის ცუდად გამოყენების ყველაზე უწყინარი და უბრალო შემთხვევა, მაგრამ შესაძლებელია გაცილებით დიდი საფრთხის წინაშე დავდგეთ. რადგან <script> ტეგში ნებისმიერი სკრიპტის ჩაწერაა შესაძლებელი, ჰაკერს შეუძლია მომხმარებელი გადაიყვანოს სხვა სერვერზე არსებულ ფაილში, ეს ფაილი კი შეიძლება შეიცავდეს სახიფათო კოდს, რომელსაც შეუძლია შეცვალოს გლობალური ცვლადები ან ფორმიდან გაგზავნილი ინფორმაცია შესანახად გააგზავნოს სხვა მისამართზე.

როგორ ავარიდოთ თავი ამ ყველაფერს ?

ამაში დაგვეხმარება htmlspecialchars() ფუნქცია <form method="post" action="<?php echo htmlspecialchars($_SERVER["PHP_SELF"]);?>"> ფუნქცია htmlspecialchars() წინასწარგანსაზღვრულ სიმბოლოებს გარდაქმნის html ელემენტებად. წინასწარგანსაზღვრულ სიმბოლოებში იგულიხმება :
  • & - გარდაიქმნება & amp; - ად
  • " - გარდაიქმნება & quot; - ად
  • ' - გარდაიქმნება & #039; - ად
  • < - გარდაიქმნება & lt; - ად
  • > - გარდაიქმნება & gt; - ად
ასე რომ ზემოთ მოყვანილი სახიფათო URL გარდაიქმნება ასე : <form method="post" action="test_form.php/& quot;& gt;& lt;script& gt;alert('hacked')& lt;/script& gt;">

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

პირველი რაც უნდა გავაკეთოთ, არის ის, რომ PHP-ს ნებისმიერი ინფორმაცია დასამუშავებლად უნდა გადავცეთ htmlspecialchars() ფუნქციის საშუალებით. ამ შემთხვევაში თუ მომხმარებელი ცდილობს შეასრულოს ეს ბრძანება : <script>location.href('http://www.hacked.com')</script> ეს არ გამოუვა რადგან ბრძანება აღიქმება როგორც html დაფარული კოდი: <script& gt;location.href('http://www.hacked.com')</script& gt; ახლა უნდა გაკეთდეს შემდეგი :
  1. აკრეფილ მონაცემებში წავშალოთ არასაჭირო სიმბოლოები (ცარიელი სიმბოლო ანუ პრაბელი, ახალი ხაზი და ა.შ) ამას აკეთებს ფუნქცია trim()
  2. აკრეფილ მონაცემებში წავშალოთ დახრილი ხაზები(\), ამას აკეთებს stripslashes() ფუნქცია.

აუცილებლად შესავსები ველები

ფორმაში შეიძლება იყოს ისეთი ველები რომელთა შევსებაც აუცილებელია, ამის გადამოწმება შეიძლება ასე : 
if ($_SERVER["REQUEST_METHOD"] == "POST") 
{
    if (empty($_POST["name"])) 
    {
        $nameErr = "არ აგიკრეფიათ სახელი";
    } 
    else 
    {
        $name = $_POST["name"];
    }
}

ელ_ფოსტის ვალიდაცია

სწორია თუ არა აკრეფილი ელ_ფოსტის მისამართი ? ამის გაგების ყველაზე მარტივი საშუალებაა filter_var() ფუნქცია. 
$email = $_POST["email"];

if (!filter_var($email, FILTER_VALIDATE_EMAIL)) 
{
    $emailErr = "არასწორი ელ_ფოსტა";
}

URL მისამართის ვალიდაცია

ქვემოთ მოყვანილ მაგალითში რეგულარული გამოსახულების დახმარებით ვგებულობთ სწორი ფორმატისაა თუ არა აკრეფილი URL მისამართი : 
$website = $_POST["website"];

if (!preg_match("/\b(?:(?:https?|ftp):\/\/|www\.)[-a-z0-9+&@#\/%?=~_|!:,.;]*[-a-z0-9+&@#\/%=~_|]/i",$website)) 
{
    $websiteErr = "არასწორი URL";
}
17. თარიღი და დრო
თარიღთან და დროსთან სამუშაო ფუნქციები საშუალებას გვაძლევენ მივიღოთ თარიღი/დრო იმ სერვერიდან სადაც გაშვებულია ჩვენი სკრიპტი.

Date() ფუნქცია

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

თარიღის გამოტანა

თარიღის ფორმატირებსას ყველაზე ხშირად გამნოყენებადი სიმბოლოებია :
  • d - წარმოადგენს თვის დღეს (01-დან 31-ის ჩათვლით)
  • m - წარმოადგენს თვეს (01-დან 12-ის ჩათვლით)
  • y - წარმოადგენს წელს (ოთხციფრიან ფორმატში, მაგ : 2017)
  • d - წარმოადგენს თვის დღეს (01-დან to 31-ის ჩათვლით)
  • l (ანუ პატარა L) - წარმოადგენს კვირის დღეს
სიმბოლოები როგორებიცაა "/", ".", ან "-" შესაძლებელია ჩავსვათ ზემოთ ჩამოთვლილ სომბოლოებს შორის და ამით მივიღოთ თარიღისა და დროის ჩაწერის სხვადასხვა ფორმატი. echo "დღეს არის " . date("Y/m/d") . "<br>"; // დღეს არის 2017/04/07
echo "დღეს არის " . date("Y.m.d") . "<br>"; // დღეს არის 2017.04.07
echo "დღეს არის " . date("Y-m-d") . "<br>"; // დღეს არის 2017-04-07
echo "დღეს არის " . date("l"); // დღეს არის Friday

Copyright ანუ საავტორო უფლებების წელი

© 2010-<?php echo date("Y");?>

დროის გამოტანა

დროის ფორმატირებსას ყველაზე ხშირად გამნოყენებადი სიმბოლოებია
  • h - 12 საათიანი საათების ფორმატი ნოლებით (01-დან 12-ის ჩათვლით)
  • i - წუთები ნოლებით (00-დან 59-ის ჩათვლით)
  • s - წამები ნოლებით (00-დან 59-ის ჩათვლით)
  • a - Ante meridiem Post meridiem (am და pm)
echo "მიმდინარე დრო " . date("h:i:sa"); // მიმდინარე დრო 10:38:26pm უნდა აღინიშნოს, რომ ფუნქცია date() თარიღს/დროს აბრუნებს სერვერის მიხედვით.

დროის სარტყელის გამოტანა

თუ კოდის მიხედვით გამოტანილი დრო არ არის სწორი, ეს ნიშნავს რომ ჩვენი სერვერი განთავსებულია სხვა ქვეყანაში ან მორგებულია სხვა დროის სარტელს. ასე რომ დროის სწორად გამოტანისათვის უნდა მივუთითოთ დროის სარტყელი : date_default_timezone_set("Asia/Tbilisi"); echo "მიმდინარე დრო " . date("h:i:sa");

mktime()

როგორც ვთქვით date() ფუნქციის პარამეტრი timestamp განსაზღვრავს დროის ნიშნულს. თუ ამ პარამეტრს არ მივუთითებთ გამოყენებულ იქნება მიმდინარე დრო. mktime() ფუნქცია აბრუნებს Unix დროის ნიშნულს.

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

mktime(hour,minute,second,month,day,year) $d=mktime(11, 14, 54, 8, 12, 2014);
echo "შექმნის თარიღი " . date("Y-m-d h:i:sa", $d); // შექმნის თარიღი 2014-08-12 11:14:54am

strtotime()

გამოიყენება UNIX დროის ადამიანისათვის წასაკითხ ფორმატში ჩასაწერად : strtotime(time,now) $d=strtotime("10:30pm April 15 2014");
echo "შექმნის თარიღი " . date("Y-m-d h:i:sa", $d);

date_create()

აბრუნებს ახალ DateTime ობიექტს. date_create(time,timezone);
  • time - არააუცილებელია მითითება. განსაზღვრავს თარიღი/დრო სტრიქონს.
  • timezone - არააუცილებელია მითითება. განსაზღვრავს დროის სარტყელს, ნაგულისმეობის პრინციპით არის მიმდინარე ლოკაციის დროის სარტყელი.
$date=date_create("2013-03-15");
echo date_format($date,"Y/m/d"); // 2013/03/15

date_date_set()

განსაზღვრავს ახალ თარიღს date_date_set(object,year,month,day);
  • object - აუცილებელია მითითება. განსაზღვრავს date_create() ფუნქციით დაბრუნებულ DateTime ობიექტს.
  • year - აუცილებელია მითითება. განსაზღვრავს თარიღის წელს.
  • month - აუცილებელია მითითება. განსაზღვრავს თარიღის თვეს.
  • day - აუცილებელია მითითება. განსაზღვრავს თარიღის დღეს.
$date=date_create();
date_date_set($date,2020,10,30);
echo date_format($date,"Y/m/d");
// 2020/10/30

date_default_timezone_get()

აბრუნებს სკრიპტში გამოყენებული თარიღი/დრო ფუნქციების შესაბამის დროის სარტყელს : date_default_timezone_get(); echo date_default_timezone_get(); // Asia/Tbilisi

date_default_timezone_set()

მიუთითებს სკრიპტში გამოყენებული თარიღი/დრო ფუნქციების შესაბამის დროის სარტყელს : date_default_timezone_set(); date_default_timezone_set("Asia/Tbilisi");
echo date_default_timezone_get();

date_diff()

აბრუნებს სხვაობას ორ სხვადსხვა თარიღს შორის $date1=date_create("2013-03-15");
$date2=date_create("2013-12-12");
$diff=date_diff($date1,$date2); // +272 days
18.ფაილების ჩასმა include/require
ოპერატორი include (ან require) იღებს მთლიან კოდს მითითებული ფაილიდან და აკოპირებს მას იმ ფაილში, რომელიც იყენებს include (ან require) ფუნქციას. ეს ფუნქციები საკმაოდ კარგი საშუალებაა, როდესაც ერთი და იგივე html/php სკრიპტის გამოყენება გვიხდება სხვადასხვა გვერდებზე.

include და require ოპერატორები

ერთი PHP ფაილის მეორეში ჩასასმელად გამოიყენება include ან require ოპერატორები. ეს ორი ოპერატორი თითმის იდენტურია, თუმცა არის სხვაობაც, რაიმე არაზუსტობის შემთხვევაში, მაგალითად თუ გამოძახებული ფაილის მისამართი არაზუსტია :
  • require იძახებს ფატალურ შეცდომას E_COMPILE_ERROR და წყვეტს სკრიპტის მუშაობას
  • include-ს კი გამოაქვს გაფრთხილება E_WARNING და სკრიპტი აგრძელებს მუშაობას
include 'filename';

ან

require 'filename'; require ფუნქცია უნდა გამოვიყენოთ მაშინ როდესაც მოთხოვნილი ფაილი აუცილებელია აპლიკაციის მუშაობის გასაგრძელებლად, ხოლო თუ ამ ფაილის ვერ პოვნის შემთხვევაში მაინც შესაძლებელია რომ აპლიკაციამ იმუშაოს, მაშინ უნდა გამოვიყენოთ include ფუნქცია.
19. მუშაობა ფაილებთან, readfile()
PHP-ს აქვს რამოდენიმე ფუნქცია ფაილების შესაქმნელად, წასაშლელად, წასაკითხად, შესაცვლელად, ასატვირთად. როდესაც ვახდენთ ფაილებით მანიპულირებას უნდა ვიყოთ ძალიან ფრთხილად, რადგან რამეს თუ არასწორად გავაკეთებთ შეიძლება ბევრი რამ გავაფუჭოთ. ხშირად დაშვებული შეცდომებია : არასწორი ფაილის რედაქტირება, მყარი დისკის შევსება დაფიქსირებული შეცდომების შესახებ ინფორმაციით, ფაილების შიგთავსის შემთხვევითი, უნებლიედ წაშლა.

readfile()

კითხულობს ფაილს და წერს მას გამოსატან ბუფერში. ვთქვათ სერვერზე გვაქვს ფაილი webdictionary.txt რომელშიც მოთავსებულია შემდეგი ინფორმაცია AJAX = Asynchronous JavaScript and XML
CSS = Cascading Style Sheets
HTML = Hyper Text Markup Language
PHP = PHP Hypertext Preprocessor
SQL = Structured Query Language
SVG = Scalable Vector Graphics
XML = EXtensible Markup Language ამ ფაილის წაკითხვა მოხდება შემდეგნაირად echo readfile("webdictionary.txt"); ანუ თუ გვსურს რომ უბრალოდ გავბსხნათ ფაილი და წავიკითხოთ მისი შიგთავსი, უნდა გამოვიყენოთ readfile() ფუნქცია.
20. მუშაობა ფაილებთან, Open/Read/Close ...

fopen()

ფაილის გახსნის ზემოთ მოყვანიულ მაგალითზე უკეთესი მეთოდია fopen(). ამ ფუნქციას აქვს უფრო მეტი შესაძლებლობები ვიდრე readfile() ფუნქციას. fopen() ფუნქციის პირველი პარამეტრი არის იმ ფაილის დასახელება რომლის გახსნაც გსვურს, მეორე პარამეტრი კი მიუთითებს თუ რომელ რეჟიმში გვინდა ფაილის გახსნა. $myfile = fopen("webdictionary.txt", "r") or die("Unable to open file!");
echo fread($myfile,filesize("webdictionary.txt"));
fclose($myfile); ფაილი შეიძლება გაიხნას შემდეგი რეჟიმებით
რეჟიმი აღწერა
r ფაილი გაიხსნება მხოლოდ წასაკითხად, კითხვა იწყება ფაილის დასაწყისიდან
w ფაილი გაიხსნება მხოლოდ ჩასაწერად, ფაილში უკვე არსებული შიგთავსი იშლება, ან იქმნება ახალი ფაილი თუ ის საერთოდ არ არსებობს. ჩაწერა დაიწყება ფაილის დასაწყისიდან.
a ფაილი გაიხსნება მხოლოდ ჩასაწერად, ფაილში უკვე არსებული შიგთავსი ინახება, იქმნება ახალი ფაილი თუ ის საერთოდ არ არსებობს. ჩაწერა დაიწყება ფაილის შიგთავსის ბოლოდან.
x ქმნის ახალ ფაილს, რომელშიც მხოლოდ ჩაწერაა შესაძლებელი, აბრუნებს FALSE და error-ს თუ ფაილი უკვე არსებობს.
r+ ფაილი გაიხსნება ჩაწერა/წაკითხვისათვის, მუშაობა დაიწყება ფაილის დასაწყისიდან.
w+ ფაილი გაიხსნება ჩაწერა/წაკითხვისათვის, ფაილში უკვე არსებული შიგთავსი იშლება, ან იქმნება ახალი ფაილი თუ ის საერთოდ არ არსებობს. ჩაწერა დაიწყება ფაილის დასაწყისიდან.
a ფაილი გაიხსნება ჩაწერა/წაკითხვისათვის, ფაილში უკვე არსებული შიგთავსი ინახება, იქმნება ახალი ფაილი თუ ის საერთოდ არ არსებობს. ჩაწერა დაიწყება ფაილის შიგთავსის ბოლოდან.
x+ ქმნის ახალ ფაილს, რომელშიც ჩაწერა/წაკითხვაა შესაძლებელი, აბრუნებს FALSE და error-ს თუ ფაილი უკვე არსებობს.

fread()

კითხულობს გახსნილ ფაილს. ფუნქციის პირველი პარამეტრი შეიცავს წასაკითხი ფაილის სახელს, მეორე პარამეტრი მიუთითებს წასაკითხი ბაიტების მაქსიმალურ რაოდენობას fread($myfile,filesize("webdictionary.txt"));

fclose()

გამოიყენება გახსნილი ფაილის დასახურად. კარგი პრაქტიკაა თუ ფაილს დავხურავთ მას შემდეგ რაც მოვრჩებით მასთან მუშაობას, რადგან გახსნილი ფაილი იკავებს მეტ რესურსს სერვერზე $myfile = fopen("webdictionary.txt", "r");
// some code to be executed....
fclose($myfile);

fgets()

გამოიყენება ფაილის რომელიმე ერთი კონკრეტული ხაზის წასაკითხად. ქვემოთ მოყვანილი მაგალითი წაიკითხავს ფაილის პირველ ხაზს $myfile = fopen("webdictionary.txt", "r") or die("Unable to open file!");
echo fgets($myfile);
fclose($myfile); fgets() ფუნქციის გამოძახების შემდეგ ფაილის მიმთითებელი ან სხვაგვარად რომ ვთქვათ "კურსორი" გადადის შემდეგ ხაზზე.

basename()

აბრუნებს ფაილის სახელს გზიდან(path). basename(path,suffix)
  • path - აუცილებელია მითითება
  • suffix - არააუცილებელია მითითება. განსაზღვრავს ფაილის გაფართოებას, თუ ფაილს აქვს გაფართოება ის არ გამოჩნდება.
$path = "/testweb/home.php";

//Show filename with file extension
echo basename($path) ."< br/>"; // home.php

//Show filename without file extension
echo basename($path,".php"); // home

pathinfo()

აბრუნებს მასივს, რომელშიც შესულია ინფორმაცია გზის(path) შესახებ. მასივში შესულია სამი ელემენტი [dirname], [basename] და [extension]. სინტაქსი ასეთია pathinfo(path,options) options პარამეტრის მითითება სავარაუდო არ არის, ნაგულისმეობის პრინციპით მოიცავს სამივე შესაძლო მნიშვნელობას
  • PATHINFO_DIRNAME - დაბრუნდება მხოლოდ დირექტორია
  • PATHINFO_BASENAME - დაბრუნდება მხოლოდ ფაილის სახელი
  • PATHINFO_EXTENSION - დაბრუნდება მხოლოდ ფაილის გაფართოება
print_r(pathinfo("/testweb/test.txt")); Array
(
   [dirname] => /testweb
   [basename] => test.txt
   [extension] => txt
)

dirname()

აბრუნებს დირექტორიის სახელს გზიდან(path). dirname(path)
  • path - აუცილებელია მითითება. განსაზღრავს შესამოწმებელ გზას
echo dirname("c:/testweb/home.php") . "< br />"; // c:/testweb
echo dirname("/testweb/home.php"); // /testweb

copy()

აკოპირებს ფაილს, წარმატების შემთხვევაში ბრუნდება TRUE on success, ხოლო შეცდომისას FALSE. copy(file,to_file)
  • file - აუცილებელია მითითება, განსაზღრავს დასაკოპირებელ ფაილს
  • to_file - აუცილებელია მითითება, განსაზღრავს თუ სად უნდა დაკოპირდეს ფაილი
echo copy("source.txt","target.txt"); // თუ წარმატებით დაკოპირდება შედეგი იქნება 1

unlink()

შლის ფაილს, წარმატების შემთხვევაში ბრუნდება TRUE on success, ხოლო შეცდომისას FALSE. $file = "test.txt";
if (!unlink($file)){
    echo ("Error deleting $file");
}
else{
    echo ("Deleted $file");
}

disk_free_space()

აბრუნებს განსაზღვრულ დირექტორიაზე არსებულ თავისუფალ ადგილს ბაიტებში disk_free_space(directory) echo disk_free_space("C:"); // 79540879360

file()

ფაილის კონტენტს ათავსებს მასივში. მასივის ელემენტებში მოთავსებულია ფაილის სხვადასხვა ხაზები print_r(file("webdictionary.txt")); შედეგი იქნება Array
(
    [0] => AJAX = Asynchronous JavaScript and XML

    [1] => CSS = Cascading Style Sheets

    [2] => HTML = Hyper Text Markup Language

    [3] => PHP = PHP Hypertext Preprocessor

    [4] => SQL = Structured Query Language

    [5] => SVG = Scalable Vector Graphics

    [6] => XML = EXtensible Markup Language

)

file_exists()

ამოწმებს არსებობს თუ არა ფაილი ან საქაღალდე. ბრუნდება TRUE თუ არსებობს, ბრუნდება FALSE თუ არ არსებობს echo file_exists("webdictionary.txt"); // 1

filemtime()

აბრუნებს ფაილის ბოლო განახლების დროს, Unix დროის ნიშნულს წარმატების შემთხვევაში, თუ არადა აბრუნებს FALSE-ს. echo filemtime("test.txt");
echo "< br />";
echo "Last modified: ".date("F d Y H:i:s.",filemtime("test.txt"));
 შედეგი იქნება 1139919766
Last modified: February 14 2006 13:22:46.

filesize()

წარმატების შემთხვევაში აბრუნებს ფაილის ზომას ბაიტებში , თუ არადა FALSE-ს echo filesize("webdictionary");

glob()

აბრუნებს მასივს, რომელშიც შესულია იმ ფაილების ან საქაღალდეების სახელები, რომლებიც აკმაყოფილებენ მითითებულ შაბლონს print_r(glob("*.txt")); Array
(
   [0] => target.txt
   [1] => source.txt
   [2] => test.txt
   [3] => test2.txt
)

is_dir()

ამოწმებს არის თუ არა ფაილი დირექტორია. $file = "images";
if(is_dir($file)){
    echo ("$file is a directory");
}
else{
    echo ("$file is not a directory");
}

is_uploaded_file()

ამოწმებს ატვირთულია თუ არა ფაილი HTTP POST - ით, თუ ეს ასეა ბრუნდება TRUE. $file = "test.txt";
if(is_uploaded_file($file)){
    echo ("$file is uploaded via HTTP POST");
}
else{
    echo ("$file is not uploaded via HTTP POST");
}

mkdir()

ქმნის დირექტორიას თუ უკვე არ არსებობს დირექტორია მითიტებული სახელით. წარმატებისას აბრუნებს TRUE-ს, წინააღმდეგ შემთხვევაში FALSE-ს. mkdir("testing");

move_uploaded_file()

გადააქვს ატვირთული ფაილი ახალ ლოკაციაზე. წარმატებისას აბრუნებს TRUE-ს, წინააღმდეგ შემთხვევაში FALSE-ს. move_uploaded_file(file,newloc) ფუნქცია მუშაობს მხოლოდ HTTP POST - ით ატვირთულ ფაილებთან, თუ მითითებული ფაილი უკვე არსებობს მითითებულ ლოკაციზე, ახალი გადაეწერება ძველს.

rename()

სახელის გადარქმევა ფაილზე ან საქაღალდეზე. rename("images","pictures");

rmdir()

შლის ცარიელ საქაღალდეს. წარმატებისას აბრუნებს TRUE-ს, წინააღმდეგ შემთხვევაში FALSE-ს. $path = "images";
if(!rmdir($path))
{
echo ("Could not remove $path");
}
21.ფაილის ატვირთვა
იმისათვის რათა PHP-ის საშუალებით ფაილი ავტვირთოთ სერვერზე, პირველ რიგში "php.ini" ფაილში მითითებული უნდა იყოს file_uploads = On ფაილის ატვირთვას, რასაკვირველია ჭირდება html ფორმა <form action="upload.php" method="post" enctype="multipart/form-data">
    <input type="file" name="fileToUpload" id="fileToUpload">
    <input type="submit" value="Upload Image" name="submit">
</form> არსებობს რამდენიმე წესი რომელიც უნდა დავიცვათ ფაილის ასატვუირთი ფორმის გაკეთებისას
  • დავრწმუნდეთ რომ ფორმა იყენებს method="post"
  • ფორმას აქვს enctype="multipart/form-data" ატრიბუტი
ამ ორი პირობის გარეშე ფაილს ვერ ავტვირთავთ. ტეგი <input>-ს ატრიბუტი type = "file" შესაყვან ველს გარდაქმნის ფაილის ასარჩევ ელემენტად, აგრეთვე ჩნდება ღილაკი «Browse» .
ფაილის ატვირთვისას აგრეთვე გამოიყენება სუპერგლობალური ცვლადი $_FILES, რომელიც მოიცავს ინფორმაციას ატვირთული ფაილის შესახებ.
  • $_FILES['fileToUpload']['name'] - ასატვირთი ფაილის ორიგინალი სახელი
  • $_FILES['fileToUpload']['type'] - ასატვირთი ფაილის ტიპი
  • $_FILES['fileToUpload']['size'] - ასატვირთი ფაილის ზომა ბაიტებში
  • $_FILES['fileToUpload']['tmp_name'] - ასატვირთი ფაილის დროებითი სახელი სერვერზე (tmp = temporary = დროებითი), ეს სახელი აქვს ფაილს მანამ სანამ ატვირთვის პროცესი მიმდინარეობს.
  • $_FILES['fileToUpload']['error'] - ფაილის ატვირთვასთან დაკავშირებული შეცდომა
echo $_FILES["fileToUpload"]["name"]; // upload.jpg
echo $_FILES["fileToUpload"]["type"]; // image/jpeg
echo $_FILES["fileToUpload"]["size"]; // 70882
echo $_FILES["fileToUpload"]["tmp_name"]; // E:\wamp\tmp\php683E.tmp



  • $target_dir = "uploads/" - განსაზღვრავს დირექტორიას რომელშიც უნდა აიტვირთოს ფაილი
  • $target_file განსაზღვრავს ასატვირთი ფაილის მთლიან გზას (uploads + ფაილის სახელი)
  • $imageFileType ინახავს ფაილის გაფართოებას
ახლა გავარკვიოთ იგივე ფაილი უკვე ატვირთული ხომ არ არის // Check if file already exists
if (file_exists($target_file)) {
    echo "Sorry, file already exists.";
    $uploadOk = 0;
} ახლა გავარკვიოთ ფაილის ზომა იმის გათვალისწინებით რომ ასატვირთ ფაილის ზომაზე გვაქვს ლიმი, ვთქვათ 500KB // Check file size
if ($_FILES["fileToUpload"]["size"] > 500000) {
    echo "Sorry, your file is too large.";
    $uploadOk = 0;
} ახლა გავარკვიოთ ფაილის ტიპი // Allow certain file formats
if($imageFileType != "jpg" && $imageFileType != "png" && $imageFileType != "jpeg"
&& $imageFileType != "gif" ) {
    echo "Sorry, only JPG, JPEG, PNG & GIF files are allowed.";
    $uploadOk = 0;
} ამ ყველაფრის გაერთიანებით მივიღთებთ შემდეგს $target_dir = "uploads/";
$target_file = $target_dir . basename($_FILES["fileToUpload"]["name"]);
$uploadOk = 1;
$imageFileType = pathinfo($target_file,PATHINFO_EXTENSION);

// Check if image file is a actual image or fake image
if(isset($_POST["submit"])) {
    $check = getimagesize($_FILES["fileToUpload"]["tmp_name"]);
    if($check !== false) {
       echo "File is an image - " . $check["mime"] . ".";
       $uploadOk = 1;
    } else {
       echo "File is not an image.";
       $uploadOk = 0;
    }
}

// Check if file already exists
if (file_exists($target_file)) {
    echo "Sorry, file already exists.";
    $uploadOk = 0;
}

// Check file size
if ($_FILES["fileToUpload"]["size"] > 500000) {
    echo "Sorry, your file is too large.";
    $uploadOk = 0;
}

// Allow certain file formats
if($imageFileType != "jpg" && $imageFileType != "png" && $imageFileType != "jpeg" && $imageFileType != "gif" ) {
    echo "Sorry, only JPG, JPEG, PNG & GIF files are allowed.";
    $uploadOk = 0;
}

// Check if $uploadOk is set to 0 by an error
if ($uploadOk == 0) {
    echo "Sorry, your file was not uploaded.";

// if everything is ok, try to upload file
} else {
    if (move_uploaded_file($_FILES["fileToUpload"]["tmp_name"], $target_file)) {
       echo "The file ". basename( $_FILES["fileToUpload"]["name"]). " has been uploaded.";
    } else {
       echo "Sorry, there was an error uploading your file.";
    }
}
22. დირექტორიები
PHP დირექტორიების ანუ საქაღალდეების ფუნქციები საშუალებას გვაძლევენ მივიღოთ ინფორმაცია საქაღალდეების და მათი შიგთავსის შესახებ.

chdir() ფუნქცია

chdir() ფუნქცია ცვლის მიმდინარე დირექტორიას, მისი გამოყენების სინტაქსი ასეთია chdir(directory); ვთქვათ ვიმყოფებით /home/php დირექტორიაში <?php
// დავაბრუნოთ მიმდინარე დირექტორია
echo getcwd() . "<br>";

// შევცვალოთ დირექტორია
chdir("images");

// დავაბრუნოთ მიმდინარე დირექტორია
echo getcwd();
?> შედეგი იქნება /home/php
/home/php/images

getcwd() ფუნქცია

getcwd() ფუნქცია აბრუნებს მიმდინარე დირექტორიას. მისი გამოყენების სინტაქსი ასეთია getcwd(); ვთქვათ ვიმყოფებით /home/php დირექტორიაში <?php
echo getcwd();
?> შედეგი იქნება /home/php

scandir() ფუნქცია

scandir() ფუნქცია აბრუნებს მასივს, რომელშიც მოთავსებულია განსაზღვრულ საქაღალდეში მდებარე ფაილების და საქაღალდეების დასახელებები. მისი გამოყენების სინტაქსი ასეთია scandir(directory,sorting_order); sorting_order ატრიბუტი განსაზღვრავს დასახელებათა დალაგების პრინციპს. ნაგულისმეობის პრინციპით დასახელებები ლაგდება ანბანის მიხედვით, თუ პარამეტრის მნიშვნელობად მივუთითებთ SCANDIR_SORT_DESCENDING ან 1-ს მაშინ დალაგდება ანბანის საწინააღმდეგოდ, ხოლო თუ საერთოდ არ გვსურს ანბანის მიხედვით დალაგება მაშინ ატრიბუტის მნიშვნელობად ვუთითებთ SCANDIR_SORT_NONE-ს. ატრიბუტის მითითება არ არის აუცილებელი <?php
$dir = "/images/";

// დალაგება ზრდადობის მიხედვით
$a = scandir($dir);

// დალაგება კლებადობის მიხედვით
$b = scandir($dir,1);

print_r($a);
print_r($b);
?> შედეგი იქნება Array
(
[0] => .
[1] => ..
[2] => cat.gif
[3] => dog.gif
[4] => horse.gif
[5] => myimages
)

Array
(
[0] => myimages
[1] => horse.gif
[2] => dog.gif
[3] => cat.gif
[4] => ..
[5] => .
)
23. Cookie
ინგ : cookie - მონაცემების მცირე ფრაგმენტი კონკრეტული მომხმარებლის კონკრეტულ სერვერთან მიმართვის წინა ისტორიაზე, ავტომატურად შექმნილი სერვერის მიერ.

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

Cookie-ს შექმნა

Cookie-ს შესაქმნელად გამოიყენება setcookie() ფუნქცია : setcookie(name, value, expire, path, domain, secure, httponly); აუცილებელად მისათითებელია მხოლოდ name პარამეტრი, დანარჩენი პარამეტრების მითითება არასავალდებულოა.

Cookie-ს შექმნა/დაბრუნება

ქვემოთ მოყვანილი მაგალითი შექმნის cookie-ს სახელად 'user', მასში შეინახავს მნიშვნელობას - 'ვასო ნადირაძე'. cookie-ს მოქმედების ვადა იქნება 30 დღე (86400 * 30). ახლა ჩვენ შეგვიძლია მივიღოთ cookie 'user'- ის მნიშვნელობა (გლობალური ცვლადის - '$_COOKIE-ს მეშვეობით). აგრეთვე გამოვიყენებთ ფუნქცია isset()-ს რათა გავიგოთ არსებობს თუ არა cookie : 
<?php 
    $cookie_name = "user";
    $cookie_value = "ვასო ნადირაძე";
    setcookie($cookie_name, $cookie_value, time() + (86400 * 30), "/"); // 86400 წამი = 1 დღე
?>

<html>
<body>

    <?php
        if(!isset($_COOKIE[$cookie_name])) 
        {
            echo "Cookie სახელად '" . $cookie_name . "' არ არსებობს!";
        } 
        else 
        {
            echo "Cookie '" . $cookie_name . "' არსებობს!<br>";
            echo "მისი მნიშვნელობაა  " . $_COOKIE[$cookie_name];
        }
    ?>

</body>
</html>
setcookie()-ს მეშვეობით შექმნილი cookie სერვერზე გაიგზავნება სხვა HTTP სათაურებთან (headers) ერთად. cookie-ც, ისევე, როგორც ნებისმიერი HTTP სათაური, სერვერზე უნდა გაიგზავნოს ჩვენი კოდის მიერ შესრულებულ ნებისმიერ ქმედებაზე ადრე, სწორედ ამიტომ აუცილებელია, რომ setcookie() ფუნქცია გამოვიყენოთ <html> da <head> ტეგებამდე.

Cookie-ს რედაქტირება

Cookie-ს რედაქტირებისათვის უბრალოდ Cookie უნდა დავნიშნოთ თავიდან setcookie() ფუნქციის დახმარებით.

Cookie-ს წაშლა

Cookie-ს წაშლაც setcookie() ფუნქციით ხდება. უბრალოდ მოქმედების ვადად უნდა მივუთითოთ უკვე გასული დროის მომენტი : 
<?php
    // მოქმედების ვადა ერთი საათის უკანდელი მომენტი
    setcookie("user", "", time() - 3600);
?>

<html>
<body>

    <?php
        echo "Cookie სახელად 'user' წაიშლა.";
    ?>

</body>

</html>
24. SESSION
სესია არის საშუალება, შევინახოთ ინფორმაცია სხვადასხვა გვერდებზე გამოყენების მიზნით. cookie-სგან განსხვავებით ეს ინფორმაცია მომხმარებლის კომპიუტერში არ ინახება.

ვთქვათ 'example.ge' გვერდზე ვიმყოფებით მომხმარებლის სახელით - 'user' და გვინდა იგივე ინფორმაცია გადაგვყვეს 'example.ge/test.php' გვერდზეც. სესიის ცვლადების დახმარებით შესაძლებელია ამ საკითხის გადაწყვეტა, როგორც აღვნიშნეთ მათში ინახება სასურველი ინფორმაცია სხვადასხვა გვერდებზე გამოყენების მიზნით. ნაგულისმეობის პრინციპით სესიის ცვლადები ინახება მანამ სანამ მომხმარებელი არ დახურავს ბრაუზერს.

სესიის დაწყება

სესიის დაწყება ხდება session_start() ფუნქციით, სესიის ცვლადები კი მოთავსებულია გლობალურ ცვლადში $_SESSION. გავაკეთოთ სატესტო გვერდი სახელად demo_session1.php : 
<?php 
    session_start(); // სესიის დაწყება
?>

<!DOCTYPE html>
<html>
<body>

    <?php
        // სესიის ცვლადების განსაზღვრა
        $_SESSION["first_name"] = 'ვასო';
        $_SESSION["last_name"] = 'ნადირაძე';
    ?>

</body>
</html>
session_start() უნდა იყოს პირველი ჩანაწერი დოკუმენტში! როდესაც ამ ჩანაწერის მეშვეობით სესიებთან მუშაობას ვიწყებთ, იქმნება სესიის იდენტიფიკატორი (PHPSESSID), რომელიც წარმოადგენს შემთხვევითად გენერირებულ სტრიქონს და ინახება Cookie-ში, თავად სესიაში შენახული ინფორმაცია კი, როგორც აღვნიშნეთ, ინახება სერვერის მხარეს.



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

სესიის იდენტიფიკატორთან წვდომისათვის გამოიყენება session_id() ფუნქცია: 

<?php 
    session_start();
    echo session_id(); // bdbba219fa278ee2a73ae21bc60f2ba0
?>

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

გავაკეთოთ კიდევ ერთი სატესტო გვერდი სახელად demo_session2.php, სადაც დავამყარებთ წვდომას პირველ გვერდზე გამოცხადებულ სესიის მნიშვნელობებთან. აღვნიშნოთ, რომ სესიის ცვლადების განსაზღრა სათითაო გვერდებზე არ ხდება, მათი მნიშვნელობები ავტომატურად გადაეცემა ნებისმიერ გვერდს, რომელიც session_start() ჩანაწერით იწყება. 
<?php 
    session_start(); // სესიის დაწყება
?>

<!DOCTYPE html>
<html>
<body>

    <?php
        echo "სახელი " . $_SESSION["first_name"] . ".<br>";
        echo "გვარი " . $_SESSION["last_name"] . ".";
    ?>

</body><
</html>

სესიის მნიშვნელობების ცვლილება

სესიის მნიშვნელობის ცვლილებისათვის ძველ მნიშვნელობას უბრალოდ უნდა გადავაწეროთ ახალი : $_SESSION["first_name"] = "გიორგი";

სესიის წაშლა

სესიის ყველა ცვლადის წაშლისა და სესიის დახურვისათვის გამოიყენება session_unset() და session_destroy() ფუნქციები : 
<?php
    session_start();
?>

<!DOCTYPE html>
<html>
<body>

<?php
    session_unset(); // სესიაში არსებული ყველა ცვლადის წაშლა
    session_destroy(); // სესიის დახურვა, გაუქმება
?>

</body>
</html>
განსხვავება მათ შორის არის ის, რომ session_destroy() შლის მთლიან სესიას, ხოლო session_unset() უბრალოდ ასუფთავებს სესიის ცვლადების მნიშვნელობებს ანუ session_unset() იგივეა რაც $_SESSION = array();
25. ფილტრები
მონაცემთა ვალიდაცია (Validating data) ანუ გადამოწმება ნიშნავს გავიგოთ ეს მონაცემი გადმოცემულია თუ არა სწორი ფორმით. მონაცემთა 'გაწმენდა' (Sanitizing data) კი ნიშნავს წავშალოთ ყველა არასასურველი სიმბოლო მონაცემიდან. php ფილტრები გამოიყენება სწორედ ამ ორი რამის - მონაცემთა ვალიდაციისა და გაწმენდისათვის. php-ს აქვს ბევრი ფუნქცია მომხმარებლის მიერ შეყვანილი ინფორმაციის გადასამოწმებლად.

რატომ უნდა გამოვიყენოთ ფილტრები ?

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

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

FILTER_VALIDATE_BOOLEAN

  • აბრუნებს TRUE-ს შემდეგი მნიშვნელობებისათვის: "1", "true", "on" და "yes"
  • აბრუნებს FALSE -ს შემდეგი მნიშვნელობებისათვის: "0", "false", "off" და "no"
  • აბრუნებს NULL-ს ყველა სხვა შემთხვევაში
$var="yes";
var_dump(filter_var($var, FILTER_VALIDATE_BOOLEAN)); // bool(true)

FILTER_VALIDATE_EMAIL

ახდენს ელ_ფოსტის ვალიდაციას. $email = "john.doe@example.com";
if (!filter_var($email, FILTER_VALIDATE_EMAIL) === false) {
    echo("$email is a valid email address");
} else {
    echo("$email is not a valid email address");
}

FILTER_VALIDATE_EMAIL

ამოწმებს არის თუ არა მონაცემი მცოცავმძიმიანი ათწილადის სახით ჩაწერილი $var=12.3;
var_dump(filter_var($var, FILTER_VALIDATE_FLOAT)); // float(12.3)

FILTER_VALIDATE_INT

ამოწმებს მთელია თუ არა რიცვხვი $int = 100;

if (!filter_var($int, FILTER_VALIDATE_INT) === false) {
    echo("Variable is an integer");
} else {
    echo("Variable is not an integer");
}

FILTER_VALIDATE_IP

ამოწმებს კორექტულოია თუ არა IP მისამართი $ip = "127.0.0.1";
if (!filter_var($ip, FILTER_VALIDATE_IP) === false) {
    echo("$ip is a valid IP address");
} else {
    echo("$ip is not a valid IP address");
}

FILTER_VALIDATE_URL

ამოწმებს კორექტულოია თუ არა URL მისამართი $url = "https://www.w3schools.com";

if (!filter_var($url, FILTER_VALIDATE_URL) === false) {
    echo("$url is a valid URL");
} else {
    echo("$url is not a valid URL");
}

წინასწარ განსაზღვრული გაწწენდის კონსტანტები

FILTER_SANITIZE_EMAIL

შლის არასასურველ სიმბოლოებს ელ_ფოსტიდან $email = "john(.doe)@exa//mple.com";
$email = filter_var($email, FILTER_SANITIZE_EMAIL);
echo $email;

FILTER_SANITIZE_STRING

შლის HTML ტეგებს სტრიქონიდან $str = "< h1>გამარჯობა!</h1>";
$newstr = filter_var($str, FILTER_SANITIZE_STRING);

FILTER_SANITIZE_URL

შლის ყველა არასასურველ სიმბოლოს URL-იდან ($-_.+!*'(),{}|\\^~[]`">< #%;/?:@&=) $var="https://www.w3schoo��ls.co�m";
echo filter_var($var, FILTER_SANITIZE_URL); // https://www.w3schools.com
26. გამონაკლისები, Try, throw და catch

ინგ: try - ცდა, სინჯვა; გამოცდა, შემოწმების, ცდების ჩატარება;

ინგ: throw - გადაგდება (ნაკადის), გადასროლა, გადატყორცნა;

ინგ: catch - დაჭერა; ხელში ჩაგდება;

Try catch ჩანაწერი გამოიყენება გამონაკლისების (exceptions) დასამუშავებლად. გამონაკლისი არის პროგრამის გაუთვალისწინებელი ანუ მოულოდნელი შედეგი ან მდგომარეობა, რომლის დამუშავებაც პროგრამაშივეა შესაძლებელი.

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

როდესაც ხდება, რომელიმე გამონაკლისზე 'გადახტომა', 'გადახტომის' ინსტრუქციის (throw) შემდეგ არსებული კოდი აღარ სრულდება და PHP ცდილობს იპოვოს ამ 'გადახტომის' შესაბამისი catch ბლოკი.

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

ini_set('display_errors', '1');

// შევქმნათ ფუნქცია გამონაკლისით
function checkNum($number) 
{
    if($number>1) 
    {
        throw new Exception("მნიშვნელობა უნდა იყოს 1 ან 1-ზე ნაკლები");
    }

    return true;
}

checkNum(2);
შედეგი იქნება : 
Fatal error: Uncaught Exception: მნიშვნელობა უნდა იყოს 1 ან 1-ზე ნაკლები in test.php:7 
Stack trace: #0 test.php(13): 
checkNum(2) #1 {main} thrown in test.php on line 7
მსგავსი შეცდომების თავიდან ასაცილებლად უნდა შევქმნათ გამონაკლის დასამუშავებელი კორექტული კოდი. კორექტული ანუ გამართული კოდი კი უნდა შეიცავდეს :
  • try - გამონაკლისის შემცველი ფუნქციის გამოძახება უნდა მოხდეს try ბლოკში. თუ გამონაკლისის გამოძახება არ მოხდება კოდი ჩვეულებრივად გააგრძელებს მუშაობას. წინააღმდეგ შემთხვევაში კი ხდება ამ გამონაკლისზე გადასროლა, გადახტომა.
  • throw - მისი მეშვეობით ხდება გამონაკლისის გამოძახება, გამონაკლისზე 'გადახტომა'. ყველა throw ჩანაწერს უნდა უკავშირდებოდეს მინიმუმ ერთი catch ბლოკი.
  • catch - ეს ბლოკი ღებულობს გამონაკლისს და ქმნის ობიექტს, რომელიც შეიცავს ინფორმაციას ამ გამონაკლისის გარეშე.
გადავაკეთოთ ჩვენი კოდი ამ ყველაფრის გათვალისწინებით : 
ini_set('display_errors', '1');

function checkNum($number) 
{
    if($number>1) 
    {
        throw new Exception("მნიშვნელობა უნდა იყოს 1 ან 1-ზე ნაკლები");
    }

    return true;
}


// გამონაკლისის გამოძახება try ბლოკში
try 
{
    checkNum(2);
    // თუ მოხდება გამონაკლისზე გადახტომა ეს შეტყობინება არ გამოჩნდება
    echo 'თუ თქვენ ხედავთ ამ შეტობინებას, მაშინ რიცხვი ერთი ან ერთზე ნაკლებია';
}

// გამონაჯლისის დაჭერა
catch(Exception $e) 
{
    echo 'შეტყობინება: ' .$e->getMessage();
}
შედეგი იქნება : შეტყობინება: მნიშვნელობა უნდა იყოს 1 ან 1-ზე ნაკლები განვმარტოთ კოდი :
  1. შეიქმნა checkNum() ფუნქცია. იგი ამოწმებს არის თუ არა რიცხვი ერთზე მეტი. თუ კი, მაშინ ხდება გამონაკლისზე გადასვლა, გადახტომა
  2. checkNum() ფუნქციის გამოძახება ხდება try ბლოკში
  3. საჭირო ხდება checkNum() ფუნქციაში აღწერილ გამონაკლისზე გადახტომა
  4. catch" ბლოკი ღებულობს გამონაკლისს და ქმნის $e ობიექტს (ცვლადის სახელწოდება პირობითია), რომელიც შეიცავს ინფორმაციას გამონაკლისის შესახებ
  5. სასურველი შეტყობინების გამოტანა ხდება $e ობიექტის getMessage() მეთოდით

გამონაკლისებთან სამუშაო სამომხმარებლო კლასების შექმნა

თუ გვსურს შევქმნათ გამონაკლისების საკუთარი დამმუშავებელი, მაშინ უნდა აღვწეროთ კლასი, რომელიც იქნება, PHP-ში ჩაშენებული, გამონაკლისებთან სამუშაო ძირითადი კლასის - Exception-ის მემკვიდრე. ჩვენს მიერ შექმნილ კლასს, მემკვიდრეობით ერგება მშობელი კლასის მეთოდები და ასევე ჩვენც შეგვიძლია ჩავამატოთ ჩვენი საკუთარი მეთოდები მასში. 
ini_set('display_errors', '1');

class customException extends Exception
{
    public function errorMessage()
    {
        // შეცსომის აღწერა შეტყობინებაში
        $errorMsg = 'შეცდომა ხაზზე : '.$this->getLine().', ფაილში : '.$this->getFile()
        .': <b>'.$this->getMessage().'</b> არ არის ელ_ფოსტის სწორი მისამართი';
        
        return $errorMsg;
    }
}

$email = "someone@example...com";

try 
{
    if(filter_var($email, FILTER_VALIDATE_EMAIL) === FALSE) 
    {
        // გადავიდეთ გამონაკლისზე თუ ელ_ფოსტის მისამართი არასწორია
        throw new customException($email);
    }
}

catch (customException $e) 
{
    // შეტყობინების გამოტანა
    echo $e->errorMessage();
}
განვმარტოთ კოდი :
  1. შეიქმნა Exception კლასის მემკვიდრე customException() სამომხმარებლო კლასი
  2. შეიქმნა errorMessage() ფუნქცია, რომელიც აბრუნებს შეტყობინებას შეცდომის შესახებ იმ შემთხვევაში თუ გადაცემული ელ_ფოსტის მისამართი არასწორია.
  3. $email ცვლადში შენახულ იქნა ელ_ფოსტის არასწორი მისამართი
  4. შესრულდა try ბლოკში აღწერილი ინსტრუქცია და შესაბამისად გადავედით გამონაკლისზე, იმდენად რამდენადაც ელ_ფოსტის მითითებული მისამართი არასწორია. მივაქციოთ ყურადღება შემდეგ ჩანაწერს : throw new customException($email); ანუ $email ცვლადი არგუმენტად გადავეცით Exception კლასის მემკვიდრე customException() სამომხმარებლო კლასს.
  5. catch ბლოკმა დააქიქსირა შეცდომა, დაამუშავა გამონაკლისი და დააბრუნა შესაბამისი შეტყობინება
ძირითადი კლასის - Exception-ის აღწერილობა ასეთია : 
Exception implements Throwable 
{
    /* თვისებები */
    protected string $message ;
    protected int $code ;
    protected string $file ;
    protected int $line ;

    /* მეთოდები */
    public __construct ( string $message = "" , int $code = 0 , Throwable $previous = null )
    final public getMessage ( ) : string
    final public getPrevious ( ) : Throwable
    final public getCode ( ) : mixed
    final public getFile ( ) : string
    final public getLine ( ) : int
    final public getTrace ( ) : array
    final public getTraceAsString ( ) : string
    public __toString ( ) : string
    final private __clone ( ) : void
}
დავბეჭდოთ გამონაკლისების ჩვენი პირადი დამმუშავებელი customException : 
...

catch (customException $e) 
{
    echo '<pre>';
    print_r($e);
    echo '</pre>';
    die;
    
    // შეტყობინების გამოტანა
    echo $e->errorMessage();
}
შედეგი იქნება : 
customException Object
(
    [message:protected] => someone@example...com
    [string:Exception:private] => 
    [code:protected] => 0
    [file:protected] => /home/vnadirad/public_html/info/php/test.php
    [line:protected] => 23
    [trace:Exception:private] => Array
        (
        )

    [previous:Exception:private] => 
)

რამოდენიმე გამონაკლისის გამოყენება ერთდროულად

ini_set('display_errors', '1');

class customException extends Exception 
{
    public function errorMessage() 
    {
        // შეცსომის აღწერა შეტყობინებაში
        $errorMsg = 'შეცდომა ხაზზე : '.$this->getLine().', ფაილში : '.$this->getFile()
        .': <b>'.$this->getMessage().'</b> არ არის ელ_ფოსტის სწორი მისამართი';
        
        return $errorMsg;
    }
}

$email = "someone@example.com"; // ამჯერად მივუთითეთ ელ_ფოსტის სწორი მისამართი

try 
{
    // შევამოწმოთ ვალიდურია თუ არა ელ_ფოსტის მისამართი
    if(filter_var($email, FILTER_VALIDATE_EMAIL) === FALSE) 
    {
        // გადავიდეთ შესაბამის გამონაკლისზე თუ ელ_ფოსტის მისამართი არასწორია
        throw new customException($email);
    }
    
    // შევამოწმოთ ურევია თუ არა სიტყვა "example" ელ_ფოსტის მისამართში
    if(strpos($email, "example") !== FALSE) 
    {
        throw new Exception("$email ჩანაწერი მოიცავს სიტყვა 'example'-ს");
    }
}

catch (customException $e) 
{
    // შეტყობინების გამოტანა
    echo $e->errorMessage();
}

catch(Exception $e) 
{
    // შეტყობინების გამოტანა
    echo $e->getMessage();
}
შედეგი იქნება : someone@example.com ჩანაწერი მოიცავს სიტყვა 'example'-ს

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

set_exception_handler() ფუნქციის მეშვეობით შესაძლებელია განისაზღვროს გამონაკლისების პრიორიტეტული დამმუშავებლი: 
ini_set('display_errors', '1');

function myException($exception) 
{
    echo "<b>შეტყობინება:</b> " . $exception->getMessage();
}

set_exception_handler('myException');

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

განსხვავება try catch ინსტრუქციასა და სხვა პირობით ოპერატორებს შორის

თუ ყოველივე ზემოთქმულს შევაჯამებთ, try catch ინსტრუქციის მეშვეობით პროგრამას მივმართავთ ასე : 
შეეცადე 
{
    შეასრულო ეს ინსტრუქციები;
    თუ არ გამოვა რაიმე, მაშინ შეასრულე ქვემოთ აღწერილი გამონაკლისი
}

გამონაკლისი 
{
    // გამონაკლისის აღწერა
}
მივაქციოთ ყურადღება სიტყა 'თუ'-ს. გამოდის, რომ კონკრეტული პირობის შესრულება/არშესრულებამდე დადის ყველაფერი. შეიძლება გაჩნდეს კითხვა : 'რა საჭიროა try catch ? ჩვენ ხომ უკვე გვაქვს პირობითი ოპერატორი if..else ?'

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

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

27. მონაცემთა ბაზა

რა არის MySQL ?

  • MySQL არის მონაცემთა ბაზა, რომელიც გამოიყენება ვებში.
  • MySQL არის მონაცემთა ბაზა, რომლის გაშვებაც ხდება სერვერზე
  • MySQL არის იდეალური ვარიანტი დიდი და პატარა აპლიკაციებისათვის
  • MySQL არის ძალიან სწრაფი, საიმედო და მარტივი გამოსაყენებელი
  • MySQL იყენებს SQL-ის სტანდარტებს
  • MySQL კომპილირდება რამოდენიმე პლატფორმაზე (ანუ არის კროსპლატფორმული)
  • MySQL გადმოწერა და ინსტალაცია უფასოა
  • MySQL შეიმუშავა და გაავრცელა კორპორაცია Oracle-მა
  • MySQL ეწოდა ერთ-ერთი დამაარსებლის (Monty Widenius) ქალიშვილის საპატივცემულოდ, რომლის სახელიც არის My :))
MySQL მონაცემთა ბაზაში ინფორმაცია ინახება ცხრილებში, ცხრილი არის ერთმანეთთან დაკავშირებული ინფორმაციების ნაკრები და შედგება სვეტებისა და სტრიქონებისაგან.

მოთხოვნები მონაცემთა ბაზაში

ჩვენ შეგვიძლია მივმართოთ ბაზას კონკრეტული თხოვნით და მივიღოთ საპასუხო ჩანაწერი ან ჩანაწერების ნაკრები. SELECT LastName FROM Employees
28. დაკავშირება ბაზასთან
PHP 5 და უფრო ახალ ვერსიებში MySQL მბ-სთან მუშაობა შესაძლებელია შემდეგი ორი რამის გამოყენებით: MySQLi გაფართოება ("i" აღნიშნავს სიტყვა improved-ის პირველ ასოს, improved=გაუმჯობესებული) და PDO (PHP Data Objects). ძველი ვერსიები იყენებდნენ MySQL გაფართოებას, რომელიც პრაქტიკიდან ამოღებულ იქნა 2012 წელს.

MySQLi თუ PDO ?

პასუხი ასეთია - რომელიც გვინდა ! ორივე მათგანს აქვს თავისი უპირატესობები : PDO იმუშავებს 12 განსხვავებულ მბ სისტემასთან, MySQLi კი მხოლოდ MySQL მბ-სთან. ასე რომ თუ პროექტის სხვა მბ-ში გადატანა მოგვიხდება PDO-ს საშუალებით ეს გაცილებით მარტივია, ორივე მათგანი ობიექტზე ორიენტირებულია თუმცა MySQLi არის პროცედურული API-ც.

MySQLi მბ-სთან დაკავშირება (ოოპ)

$servername = "localhost";
$username = "username";
$password = "password";

// დაკავშირება ბაზასთან
$conn = new mysqli($servername, $username, $password);

// გადავამოწმოთ ხომ არ დაფიქსირდა რაიმე შეცდომა დაკავშირებისას
if ($conn->connect_error) 
{
    die("დაფიქსირდა შეცდომა : " . $conn->connect_error);
} 

echo "ბაზასთან დავკავშირდით წარმატებით";

MySQLi მბ-სთან დაკავშირება (პროცედურული)

$servername = "localhost";
$username = "username";<
$password = "password";

// დაკავშირება ბაზასთან
$conn = mysqli_connect($servername, $username, $password);

// გადავამოწმოთ ხომ არ დაფიქსირდა რაიმე შეცდომა დაკავშირებისას
if (!$conn) 
{
    die("დაფიქსირდა შეცდომა : " . mysqli_connect_error());
}

echo "ბაზასთან დავკავშირდით წარმატებით";

MySQLi მბ-სთან დაკავშირება (PDO)

$servername = "localhost";
$username = "username";
$password = "password";

try 
{
    $conn = new PDO("mysql:host=$servername;dbname=myDB", $username, $password);
    
    // განვსაზღვროთ PDO შეცდომების რეჟიმი გამონაკლისებისათვის
    $conn->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

    echo "ბაზასთან დავკავშირდით წარმატებით";
}
catch(PDOException $e)
{
    echo "დაფიქსირდა შეცდომა : " . $e->getMessage();
}

connect.php

ბაზასთან დაკავშირების კოდი ხშირად დაგვჭირდება მაგალითებში, ამიტომ შევქმნათ connect.php ფაილი და შემდეგ საჭირო ადგილას ჩავსვათ ხოლმე იგი require ფუნქციის გამოყენებით: 
<?php

$servername = "localhost";
$username = "username";
$password = "password";

// დაკავშირება ბაზასთან
$conn = mysqli_connect($servername, $username, $password);

// გადავამოწმოთ ხომ არ დაფიქსირდა რაიმე შეცდომა დაკავშირებისას
if (!$conn) 
{
    die("დაფიქსირდა შეცდომა : " . mysqli_connect_error());
}

echo "ბაზასთან დავკავშირდით წარმატებით";

?>
mysqli_connect ფუნქციას გადაეცემა კიდევ ერთი პარამეტრი, ესაა - მონაცემთა ბაზის სახელი. შემდეგ თავში ვნახავთ თუ როგორ იქმნება მონაცემთა ბაზა, ამის შემდეგ კი ჩავასწორებთ connect.php ფაილს და დავამატებთ აღნიშნულ პარამერტრს.

MySQLi კავშირის დახურვა (ოოპ)

$conn->close();

MySQLi კავშირის დახურვა (პროცედურული)

mysqli_close($conn);

MySQLi კავშირის დახურვა (PDO)

$conn = null;
29. ბაზის შექმნა
MySQLi მბ-ს შესაქმნელად გამოიყენება CREATE DATABASE ჩანაწერი.

MySQLi მბ-ს შექმნა (ოოპ)

require_once('connect.php');

// ბაზის შესაქმნელი ბრძანების სინტაქსი
$sql = "CREATE DATABASE myDB";

// ბაზის შესაქმნელი ბრძანების უშუალოდ გაშვება
if ($conn->query($sql) === TRUE) 
{
    echo "ბაზა წარმატებით შეიქმნა";
} 
else 
{
    echo "დაფიქსირდა შეცდომა : " . $conn->error;
}

$conn->close();

MySQLi მბ-ს შექმნა (პროცედურული)

require_once('connect.php');

// ბაზის შესაქმნელი ბრძანების ტექსტი
$sql = "CREATE DATABASE myDB";

// ბაზის შესაქმნელი ბრძანების უშუალოდ გაშვება
if (mysqli_query($conn, $sql)) 
{
    echo "ბაზა წარმატებით შეიქმნა";
} 
else 
{
    echo "დაფიქსირდა შეცდომა : " . mysqli_error($conn);
}

$conn->close();
წინა თავში შექმნილი ფაილი connect.php-ში, mysqli_connect ფუნქციას დავამატოთ მეოთხე პარამეტრი - მონაცემთა ბაზის სახელი : 
<?php

$servername = "localhost";
$username = "username";
$password = "password";
$dbname = "myDB";

// დაკავშირება ბაზასთან
$conn = mysqli_connect($servername, $username, $password, $dbname);

// გადავამოწმოთ ხომ არ დაფიქსირდა რაიმე შეცდომა დაკავშირებისას
if (!$conn) 
{
    die("დაფიქსირდა შეცდომა : " . mysqli_connect_error());
}

echo "ბაზასთან დავკავშირდით წარმატებით";

?>
30. ცხრილის შექმნა ბაზაში
მბ-ს ცხრილებს აქვთ უნიკალური სახელები და შედგებიან სვეტებისა და სტრიქონებისაგან. ცხრილის შესაქმნელად გამოიყენება CREATE TABLE ჩანაწერი. გავაკეთოთ ცხრილი სახელად 'MyGuests', რომელსაც ექნება 5 ველი:
  • id
  • firstnam
  • lastname
  • email
  • reg_date
CREATE TABLE MyGuests (
    id INT(6) UNSIGNED AUTO_INCREMENT PRIMARY KEY,
    firstname VARCHAR(30) NOT NULL,
    lastname VARCHAR(30) NOT NULL,
    email VARCHAR(50),
    reg_date TIMESTAMP
)
მონაცემთა ტიპი განსაზღვრავს თუ რა ტიპის მონაცემი შეიძლება შევინახოთ კონკრეტულ ველში :
  • NOT NULL - თუ სვეტს ეს თვისება აქვს მითიტებული მაშინ ის აუცილებლად უნდა შეიცავდეს რაიმე ჩანაწერს, ცარიელი ანუ NULL ტიპის ინფორმაციის შეტანა არ შეიძლება
  • DEFAULT - მნიშვნელობა რომელიც ნაგულისმეობის პრინციპით მიენიჭება თუ სხვა კონკრეტუილ მნიშვნელობას არ მივანიჭებთ
  • UNSIGNED - გამოიყენება რიცხვითი ტიპისათვის, შეიძლება მიიღოს 0 ან 0-ზე მეტი მნიშვნელობა
  • AUTO INCREMENT - MySQL ავტომატურად გაზრდის ველის მნიშვნელობას 1-ით ყოველი ახალი ჩანაწერის დამატებისას
  • PRIMARY KEY - გამოიყენება ცხრილში უნიკალური სტრიქონის იდენტიფიკაციისათვის. PRIMARY KEY თვისების მქონე სვეტში ხშირად ინახება ID რიცხვი და გამოიყენება AUTO_INCREMENT თვისებასთან ერთად
ყველა ცხრილს უნდა გააჩნდეს PRIMARY KEY(პირველადი გასაღები) ველი, მისი მნიშვნელობა ცხრილის ყველა ჩანაწერისათვის უნიკალური იქნება. require_once('connect.php');

$sql = "CREATE TABLE MyGuests (
id INT(6) UNSIGNED AUTO_INCREMENT PRIMARY KEY,
firstname VARCHAR(30) NOT NULL,
lastname VARCHAR(30) NOT NULL,
email VARCHAR(50),
reg_date TIMESTAMP
)";

if($conn->query($sql) === TRUE){
     echo "Table MyGuests created successfully";
}
else{
     echo $conn->error;
}

$conn->close();
31. მონაცემთა შეტანა ცხრილში
ცხრილში ინფორმაციის შეტანისას უნდა გავითვალისწინოთ შემდეგი წესები
  • SQL მოთხოვნა უნდა ჩაისვას ბრჭყალებში
  • SQL მოთხოვნაში არსებული სტრიქონული მნიშვნელობები უნდა ჩაისვას ბრჭყალებში
  • რიცხვითი მნიშვნელობები არ უნდა ჩაისვას ბრჭყალებში
  • სიტყვა NULL არ უნდა ჩაისვას ბრჭყალებში
ცხრილში მონაცემთა შესატანად გამოიყენება INSERT INTO ჩანაწერი. სინტაქსი ასეთია INSERT INTO table_name (column1, column2, column3,...) VALUES (value1, value2, value3,...) თუ სვეტი არის AUTO_INCREMENT ან TIMESTAMP მაშინ SQL მოთხოვნაში მათი განსაზღვრა საჭირო არ არის, MySQL ავტომატურად შეიყვანს მათ. require_once('connect.php');

$sql = "INSERT INTO MyGuests (firstname, lastname, email)
VALUES ('John', 'Doe', 'john@example.com')";
if($conn->query($sql) === TRUE){
echo "ok";
}
else{
     echo $conn->error;
}

$conn->close();

ბოლო ჩანაწერის ID

თუ ვასრულებთ INSERT ან UPDATE ოპერაციას ცხრილში რომელსაც გააჩნია AUTO_INCREMENT ველი, შეგვიძლია მივიღოთ ბოლოს ჩასმული/განახლებული ჩანაწერის ID. require_once('connect.php');

$sql = "INSERT INTO MyGuests (firstname, lastname, email)
VALUES ('John', 'Doe', 'john@example.com')";
if($conn->query($sql) === TRUE){

echo $last_id;
}
else{
     echo $conn->error;
}

$conn->close();

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

მრავალჯერადი SQL მოთხოვნების შესრულება ხდება mysqli_multi_query() ფუნქციის დახმარებით. require_once('connect.php');

$sql = "INSERT INTO MyGuests (firstname, lastname, email)
VALUES ('John', 'Doe', 'john@example.com');";
$sql .= "INSERT INTO MyGuests (firstname, lastname, email)
VALUES ('Mary', 'Moe', 'mary@example.com');";
$sql .= "INSERT INTO MyGuests (firstname, lastname, email)
VALUES ('Julie', 'Dooley', 'julie@example.com')";

if ($conn->multi_query($sql) === TRUE) {
     echo "New records created successfully";
} else {
     echo "Error: " . $sql . "<br>" . $conn->error;
}

$conn->close();
32. პრეპარირებული განაცხადები
პრეპარირება: რისამე დამუშავება გარკვეული წესით; რამესთვის გარკვეული სახის მიცემა.

პრეპარირებული განაცხადების მუშაობის სქემა ასეთია
  1. Prepare: მზადდება sql მოთხოვნის შაბლონი და იგზავნება მონაცემთა ბაზაში ისე რომ პარამეტრები განსაზღრული არ არის, მათ მაგივრად მითითებულია "?" ნიშნები, მაგ: INSERT INTO MyGuests VALUES(?, ?, ?)
  2. მონაცემთა ბაზა აკეთებს გაგზავნილი შაბლონის ანალიზს, ოპტიმიზაციას და ინახავს შედეგს შესრულების გარეშე.
  3. Execute: ამის შემდეგ აპლიკაცია განსაზღვრავს, მიამაგრებს პარამეტრებს და მათ კონკრეტულ მნიშვნელობებს მონაცემთა ბაზა კი ასრულებს წინასწარ მიღებულ შაბლონში მითითებულ მოთხოვნას, შაბლონში აღწერილი მოთხოვნა შესრულდება იმდენჯერ რამდენი პარამეტრიც განისაზღვრება.
SQL მოთხოვნის დაუყოვნებლივ შესრულებასთან მიმართებაში, ამ სქემას აქვს შემდეგი უპირატესობები:
  • SQL განაცხადთა პრეპარირება ამცირებს მოთხოვნის დამუშავების დროს, რადგან მოთხოვნის შესაბამისი პრეპარირება ხდება მხოლოდ ერთხელ, მიუხედავად იმისა რომ SQL ოპერატორი შეიძლება შესრულდეს რამოდენიმეჯერ.
  • სერვერის გამტარუნარიანობის მიუხედავად ყველაფერი ხდება გაცილებით სწრაფად რადგან იმის ნაცვლად რომ ყოველ ჯერზე გაიგზავნოს მთლიანი მოთხოვნა, იგზავნება მხოლოდ პარამეტრთა მნიშვნელობები.
  • პრეპარირებული განაცხადები საკმაოდ ეფექტური იარაღია SQL ინექციის წინააღმდეგ.

mysqli_stmt კლასი

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

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

mysqli_stmt::prepare

mysqli_stmt კლასის prepare მეთოდი ახდენს SQL ბრძანების შაბლონის გამზადებას, პრეპარირებას (ინგ: prepare - მომზადება, მზადება, გამზადება ). SQL ბრძანების ტანი, შაბლონი, ბუნებრივია შეიცავს კონკრეტულ პარამეტრებს, ცვლადებს, რომელთა მიხედვითაც უნდა შესრულდეს ესა თუ ის ბრძანება. ამ პარამეტრების გადაცემა პრეპარირებისას ხდება ე.წ ნიშნულების ანუ მარკერების სახით და ამ ნიშნულებში პარამეტრთა რეალური მნიშვნელობების ნაცვლად გამოიყენება კითხვის ნიშნები - '?'. 
<?php
$mysqli = new mysqli("localhost", "my_user", "my_password", "world");

/* check connection */
if (mysqli_connect_errno()) {
    exit();
}
$stmt = $mysqli->prepare("SELECT District FROM City WHERE Name=?");

mysqli_stmt::bind_param

mysqli_stmt კლასის bind_param მეთოდი შექმნილ შაბლონს ამაგრებს ცვლადებს როგორც პარამეტრებს, ანუ კითხვის ნიშნები - '?' იცვლება ამ მეთოდით გადაცემული ცვლადების მნიშვნელობებით (ინგ: bind - მიბმა; დამაგრება, დავალება, დაკისრება). მეთოდს არგუმენტებად უნდა გადაეცეს საჭირო ცვლადები და აგრეთვე აუცილებელია ამ ცვლადთა ტიპების მითითებაც სპეციალური სიმბოლოების მეშვეობით. ეს სიმბოლოებია:
სიმბოლო აღწერა
i თუ შესაბამისი ცვლადი მთელი ტიპისაა
d თუ შესაბამისი ცვლადი ათწილადი ტიპისაა
s თუ შესაბამისი ცვლადი სტრიქონული ტიპისაა
b თუ შესაბამისი ცვლადი BLOB ტიპისაა (BLOB: binary large object - დიდი ორობითი ობიექტი) 
<?php
$mysqli = new mysqli("localhost", "my_user", "my_password", "world");

/* check connection */
if (mysqli_connect_errno()) {
    exit();
}
$name = "Tbilisi";
$stmt = $mysqli->prepare("SELECT District FROM City WHERE Name=?");
$stmt->bind_param('s',$name);

mysqli_stmt::execute

mysqli_stmt კლასის execute მეთოდი ახდენს SQL ბრძანების შესრულებას, გაშვებას (ინგ: execute - შესრულება, ასრულება, სისრულეში მოყვანა). 
<?php
$mysqli = new mysqli("localhost", "my_user", "my_password", "world");

/* check connection */
if (mysqli_connect_errno()) {
    exit();
}
$name = "Tbilisi";
$stmt = $mysqli->prepare("SELECT District FROM City WHERE Name=?");
$stmt->bind_param('s',$name);
$stmt->execute();
თუ ბრძანება არის UPDATE, DELETE ან INSERT ტიპის, ზემოქმედებული სტრიქონების საერთო რაოდენობის გაგება შესაძლებელია mysqli_stmt::affected_rows მეთოდის მეშვეობით, რომლის შესახებაც ქვემოთ ვისაუბრებთ, ხოლო თუ ბრძანება აბრუნებს შედეგთა ნაკრებს, გამოიყენება ფუნქცია mysqli_stmt::fetch, რომელსაც აგრეთვე ოდნავ მოგვიანებით განვიხილავთ.

mysqli_stmt::bind_result

როგორც მოყვანილ მაგალითში ჩანს City ცხრილიდან ვარჩევთ District ველის მნიშვნელობას იმ ჩანაწერისათვის რომელშიც Name სვეტის მნიშვნელობა არის Tbilisi. ჩნდება კითხვა: სად შევინახოთ დაბრუნებული შედეგები ? ამაში დაგვეხმარება mysqli_stmt კლასის bind_result მეთოდი. მას არგუმენტად გადაეცემა ცხრილის სვეტების შესაბამისი ცვალდები, რომლებსაც ჩვენ ვარქმევთ პირობით სახელებს, სასურველია ეს სახელები კავშირში იყოს ცხრილის სვეტებთან. ჩვენს შემთხვევაში ვეძებთ District ველის მნიშვნელობას და ცვლადსაც დავარქვათ ასე - $district. 
<?php
$mysqli = new mysqli("localhost", "my_user", "my_password", "world");

/* check connection */
if (mysqli_connect_errno()) {
    exit();
}
$name = "Tbilisi";
$stmt = $mysqli->prepare("SELECT District FROM City WHERE Name=?");
$stmt->bind_param('s',$name);
$stmt->execute();
$stmt->bind_result($district);
დაბრუნებული შედეგები შევინახეთ, ახლა საჭიროა მივმართოთ მათ, ამაში დაგვეხმარება mysqli_stmt კლასის fetch მეთოდი.

mysqli_stmt::fetch

mysqli_stmt კლასის fetch მეთოდი ახდენს პრეპარირებულ ბრძანების შედეგების, ამ ბრძანებაზე bind_result მეთოდით მიმაგრებულ ცვლადებში შენახვას (ინგ: fetch - ამოღება, დაძახება, მიღება). ანუ ფუნქცია ბრძანებიდან იღებს შედეგებს და ათავსებს ცვლადებში. 
<?php
$mysqli = new mysqli("localhost", "my_user", "my_password", "world");

/* check connection */
if (mysqli_connect_errno()) {
    exit();
}
$name = "Tbilisi";
$stmt = $mysqli->prepare("SELECT District FROM City WHERE Name=?");
$stmt->bind_param('s',$name);
$stmt->execute();
$stmt->bind_result($district);
while ($stmt->fetch()) {
    echo $district . "<br>";
}
ინფორმაციის მიღება ხდება ბუფერიზაციის ანუ მეხსიერებაში შენახვის გარეშე თუ არ გამოვიძახებთ store_result მეთოდსაც (მასზე ქვემოთ ვისაუბრებთ), რამაც შეიძლება შეამციროს შედეგთა გამოყენების არეალი მაგრამ სამაგიეროდ იზოგება მეხსიერება.

mysqli_stmt::$affected_rows

როგორც ადრე ვთქვით, თუ ბრძანება არის UPDATE, DELETE ან INSERT ტიპის, ზემოქმედებული სტრიქონების საერთო რაოდენობის გაგება შესაძლებელია mysqli_stmt::$affected_rows მეთოდის მეშვეობით (ინგ: affected - რომელიც განიცდის ზემოქმედებას, ზემოქმედებაგანცდილი). 
<?php
$mysqli = new mysqli("localhost", "my_user", "my_password", "world");

/* check connection */
if (mysqli_connect_errno()) {
    exit();
}
$name = "Tbilisi";
$district = "Kartli"; 
$stmt = $mysqli->prepare("UPDATE City SET District=?  WHERE Name=?");
$stmt->bind_param('ss', $district, $name);
$stmt->execute();
echo $stmt->affected_rows;

mysqli_stmt::$num_rows

mysqli_stmt კლასის num_rows მეთოდი აბრუნებს შედეგთა ნაკრებში შემავალი სტრიქონების რაოდენობას. ამ მეთოდის გამოყენება - არ გამოყენება დამოკიდებულია იმაზე ვიყენებთ თუ არა mysqli_stmt::store_result მეთოდს შედეგთა ნაკრების ბუფერიზაციისათვის. mysqli_stmt::store_result მეთოდი იღებს ბოლო მოთხოვნის შედეგად მიღებულ პასუხთა ნაკრებს. 
<?php
$mysqli = new mysqli("localhost", "my_user", "my_password", "world");

/* check connection */
if (mysqli_connect_errno()) {
    exit();
}
$name = "Tbilisi";
$stmt = $mysqli->prepare("SELECT District FROM City WHERE Name=?");
$stmt->bind_param('s',$name);
$stmt->execute();
$stmt->store_result();
echo $stmt->num_rows;

ეს მნიშვნელოვანია !

თუ პრეპარირებული ბრძანების შესრულების შემდეგ ჯერ არ გამოგვიყენებია mysqli_stmt::store_result ფუნქცია და ისე მივმართავთ mysqli_stmt::$num_rows ფუნქციას, მაშინ ეს უკანასკნელი, როგორც წესი აბრუნებს 0-ს, რადგან მან არ იცის რამდენი ჩანაწერია შედეგთა ნაკრებში ვინაიდან შედეგთა ნაკრები ჯერ არ არის შენახული მეხსიერებაში.

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

33. მონაცემთა ამოღება ცხრილიდან
ცხრილიდან ინფორმაციის ამოსაღებად გამოიყენება SELECT ჩანაწერი, თუ კონკრეტული სვეტების მნიშვნელობების ამოღება გვინდა: SELECT column_name(s) FROM table_name ხოლო თუ მთლიანი ჩანაწერის ანუ ყველა სვეტის მნიშვნელობებს ვიღებთ SELECT * FROM table_name

MySQLi მბ-ის ცხრილიდან ინფორმაციის ამოღება (ოოპ)

<?php
  require_once('connect.php');

  $sql = "SELECT id, firstname, lastname FROM MyGuests";
  $result = $conn->query($sql);

  if ($result->num_rows > 0) {
      // გამოვსახოთ ცხრილის ყველა ჩანაწერი
      while($row = $result->fetch_assoc()) {
        echo "id: " . $row["id"]. " - სახელი: " . $row["firstname"]. " " . $row["lastname"]. "<br>";
      }
  }
  else {
     echo "0 შედეგი";
  }

  $conn->close();
?> განვმარტოთ კოდი: პირველ რიგში განისაზღვრა SQL მოთხოვნა რომელიც ამოარჩევს id, firstname და lastname ველების მნიშვნელობებს MyGuests ცხრილიდან. ვინაიდან არ გვაქვს არანაირი დამატებითი შეზღუდვა (მაგ: ამოირჩეს მხოლოდ ის ჩანაწერები სადაც ასაკი მეტია 20 წელზე და ა.შ) ამოირჩევა ცხრილის ყველა ჩანაწერის id, firstname და lastname სვეტთა მნიშვნელობები.



კოდის შემდეგი ხაზი აგზავნის ამ მოთხოვნას და შედეგს ინახავს ცვლადში სახელად - $result. შემდეგ num_rows() ფუნქცია ამოწმებს დაბრუნდა თუ არა ერთი ჩანაწერი მაინც პასუხად (ჩვენს შემთხვევაში დაბრუნდება 4 ჩანაწერი). შემდეგ fetch_assoc() ფუნცია ამ პასუხს მოაქცევს ასოციაციურ მასივში. while() ციკლის საშუალებით კი ყველა პასუხად მოსული ჩანაწერისაგან დავაბრუნებთ id, firstname და lastname სვეტების მნიშვნელობებს: id: 1 - სახელი: დათა თუთაშხია
id: 2 - სახელი: სოლომონ მორბელაძე
id: 3 - სახელი: ლუარსაბ თათქარიძე
id: 4 - სახელი: ალუდა ქეთელაური

MySQLi მბ-ის ცხრილიდან ინფორმაციის ამოღება (პროცედურული)

<?php
  require_once('connect.php');

  $sql = "SELECT id, firstname, lastname FROM MyGuests";
  $result = mysqli_query($conn, $sql);
  if (mysqli_num_rows($result) > 0) {
    // output data of each row
    while($row = mysqli_fetch_assoc($result)) {
       echo "id: " . $row["id"]. " - Name: " . $row["firstname"]. " " . $row["lastname"]. "<br>";
    }
  }
  else {
    echo "0 results";
  }

   mysqli_close($conn);
?>
34. მონაცემთა წაშლა ცხრილიდან
მბ ცხრილიდან ინფორმაციის წასაშლელად გამოიყენება DELETE ჩანაწერი DELETE FROM table_name WHERE some_column = some_value მივაქციოთ ყურადღება WHERE სიტყვა-გასაღებს DELETE ჩანაწერის სინტაქსში: WHERE სიტყვა-გასაღები მიუთითებს თუ რომელი ჩანაწერი უნდა წაიშალოს ცხრილში, თუ ამ პირობას არ მივუთითებთ ცხრილიდან ყველა ჩანაწერი წაიშლება !

MySQLi მბ-ის ცხრილიდან ინფორმაციის წაშლა (ოოპ)

ცხრილიდან წავშალოთ ჩანაწერი რომლის id=3 <?php

  require_once('connect.php');

  // sql ჩანაწერი
  $sql = "DELETE FROM MyGuests WHERE id=3";

  if ($conn->query($sql) === TRUE) {
    echo "ჩანაწერი წაიშალა";
  }
   else {
     echo "ჩანაწერი ვერ წაიშალა: " . $conn->error;
  }

  $conn->close();
?>

MySQLi მბ-ის ცხრილიდან ინფორმაციის წაშლა (პროცედურული)

<?php

  require_once('connect.php');

  // sql ჩანაწერი
  $sql = "DELETE FROM MyGuests WHERE id=3";

  if (mysqli_query($conn, $sql)) {
     echo "ჩანაწერი წაიშალა";
  }
  else {
     echo "ჩანაწერი ვერ წაიშალა: " . mysqli_error($conn);
  }

  mysqli_close($conn);
?>
35. მონაცემთა განახლება ცხრილში
მბ-ს ცხრილში მონაცემთა განახლება ხდება UPDATE ჩანაწერის დახმარებით UPDATE table_name SET column1=value, column2=value2,... WHERE some_column=some_value მივაქციოთ ყურადღება WHERE სიტყვა-გასაღებს UPDATE ჩანაწერის სინტაქსში: WHERE სიტყვა-გასაღები მიუთითებს თუ რომელი ჩანაწერი უნდა განახლდეს ცხრილში, თუ ამ პირობას არ მივუთითებთ, განახლდება ცხრილის ყველა ჩანაწერი !

MySQLi მბ-ის ცხრილში ჩანაწერის განახლება (ოოპ)

<?php

  require_once('connect.php');

  $sql = "UPDATE MyGuests SET lastname='Doe' WHERE id=2";

  if ($conn->query($sql) === TRUE) {
    echo "ჩანაწერი განახლდა";
  }
  else {
     echo "ჩანაწერი ვერ განახლდა: " . $conn->error;
  }

   $conn->close();
?>

MySQLi მბ-ის ცხრილში ჩანაწერის განახლება (პროცედურული)

<?php

  require_once('connect.php');

  $sql = "UPDATE MyGuests SET lastname='Doe' WHERE id=2";

  if (mysqli_query($conn, $sql)) {
    echo "ჩანაწერი განახლდა";
  }
  else {
    echo "ჩანაწერი ვერ განახლდა: " . mysqli_error($conn);
  }

   $conn->close();
?>
36. ინფორმაციის ლიმიტი
MySQL-ში არის სიტყვა-გასაღები LIMIT, რომელიც გამოიყენება დასაბრუნებელი ჩანაწერების რაოდენობის განსასაზღვრავად. არის შემთხვევები როდესაც დიდი ზომის ბაზებთან მუშაობისას ამა თუ იმ მოთხოვნის შედეგად ვღებულობთ ძალიან დიდი რაოდენობი საპასუხო ჩანაწერებს და მათი მოთავსება ერთ გვერდზე საკმაოდ არაკომფორტული და მოუხერხებელია, ამ დროს საჭიროა ხოლმე ეს ინფორმაცია დაიყოს და განთავსდეს რამოდენიმე გვერდზე (ე.წ პაგინაცია ანუ გვერდების გადანომრვა), ამაში გვეხმარება LIMIT ჩანაწერი. მაგალითად გვინდა პირველი 30 ჩანაწერის ამოღება ცხრილიდან "Orders" $sql = "SELECT * FROM Orders LIMIT 30"; მაგრამ როგორ მოვიქცეთ თუ გვინდა 16 - 25 ჩანაწერების ამოღება ? ამაში დაგვეხმარება OFFSET ჩანაწერი. ქვემოთ მოყვანილი მაგალითი ამბობს: "დააბრუნე მხოლოდ 10 ჩანაწერი, დაიწყე 16 ჩანაწერიდან (15 ჩანაწერი არ შედის)" $sql = "SELECT * FROM Orders LIMIT 10 OFFSET 15"; ეს ჩანაწერი შეიძლება ჩაიწეროს უფრო მარტივადაც $sql = "SELECT * FROM Orders LIMIT 15, 10"; შევნიშნოთ რომ რიცხვები შებრუნებული თანმიმდევრობით იწერება როცა შემოკლებულ სინტაქსს ვხმარობთ.
37. MySQLi ფუნქციები (პროცედურული მიდგომა)

mysqli_connect() ფუნქცია

mysqli_connect() ფუნქცია ხსნის, ქმნის ახალ კავშირს MySQL სერვერთან. mysqli_connect(host,username,password,dbname); <?php
   $con=mysqli_connect("localhost","my_user","my_password","my_db");
   // კავშირის გადამოწმება
   if (mysqli_connect_errno()) {
     echo "Failed to connect to MySQL: " . mysqli_connect_error();
   }

   mysqli_close($con);
?> ყურადღება მივაქციოთ $con ცვლადს, რომელშიც აღწერილია მონაცემთა ბაზასთან დაკავშირება და მონაცემთა ბაზის აღწერა. mysqli ფუნქციებიდან ბევრ მათგანს სწორედ ეს ცვლადი უნდა გადაეცეს პირველ პარამეტრად.

mysqli_affected_rows() ფუნქცია

ინგლ: affected - რომელიც განიცდის, ზემოქმედება განცდილი.

affected_rows ანუ ზემოქმედება განცდილი ჩანაწერები.

როდესაც ვიყენებთ SQL მოთხოვნებს SELECT, INSERT, UPDATE, REPLACE ან DELETE ბუნებრივია მივმართავთ მონაცემთა ბაზის ცხრილს და ამ ცხრილის ერთ ან რამოდენიმე ჩანაწერზე ვახდენთ მოთხოვნის შესაბამის ქმედებას. ვთქვათ გვაქვს კონკრეტული მოთხოვნა mysqli_query($con,"DELETE FROM myguests WHERE Age>32"); ამ მოთხოვნის შერულების შემდეგ mysqli_affected_rows() ფუნქცია დააბრუნებს ცხრილის იმ ჩანაწერთა რაოდენობას რომლებიც მოთხოვნის შედეგად განიცდიან ზემოქმედებას, ამ შემთხვევაში წაშლას. სხვა სიტყვებით რომ ვთქვათ დაბრუნდება იმ ჩანაწერთა რაოდენომა რომლებშიც ასაკი მეტია 32-ზე (Age>32). ანალოგიურად დაბრუნდება შედეგი სხვა SQL მოთხოვნებისთვისაც.

mysqli_character_set_name() ფუნქცია

mysqli_character_set_name() ფუნქცია აბრუნებს ბაზასთან კავშირის, ნაგულისმეობის პრინციპით მინიჭებულ ენკოდინგს. mysqli_character_set_name(connection); <?php
   $con=mysqli_connect("localhost","my_user","my_password","my_db");
   // კავშირის გადამოწმება
   if (mysqli_connect_errno()) {
     echo "Failed to connect to MySQL: " . mysqli_connect_error();
   }

   $charset=mysqli_character_set_name($con);
   echo "Default character set is: " . $charset;

   mysqli_close($con);
?>

mysqli_close() ფუნქცია

mysqli_close() ფუნქცია ხურავს ბაზასთან კავშირს. $con=mysqli_connect("localhost","my_user","my_password","my_db");

// .... PHP კოდი ....

mysqli_close($con);

mysqli_connect_errno() ფუნქცია

mysqli_connect_errno() ფუნქცია აბრუნებს ბაზასთან ბოლო დაკავშირებისას აღმოჩენილი შეცდომის კოდს (თუ საერთოდ დაფიქსირდა იგი). <?php
   $con=mysqli_connect("localhost","my_user","my_password","my_db");
   // კავშირის გადამოწმება
   if (mysqli_connect_errno()) {
     echo "Failed to connect to MySQL: " . mysqli_connect_error();
   }

   mysqli_close($con);
?>

mysqli_errno() ფუნქცია

mysqli_errno() ფუნქცია აბრუნებს ყველაზე ბოლოს შესრულებული ოპერაციისას დაფიქსირებული შეცდომის კოდს // მოთხოვნის შესრულება, შეცდომების გადამოწმება
if (!mysqli_query($con,"INSERT INTO Persons (FirstName) VALUES ('Glenn')")) {
  echo("Errorcode: " . mysqli_errno($con));
}

mysqli_error() ფუნქცია

mysqli_error() ფუნქცია აბრუნებს ყველაზე ბოლოს შესრულებული ოპერაციისას დაფიქსირებული შეცდომის აღწერას // მოთხოვნის შესრულება, შეცდომების გადამოწმება
if (!mysqli_query($con,"INSERT INTO Persons (FirstName) VALUES ('Glenn')")) {
  echo("Errorcode: " . mysqli_errno($con));
}

mysqli_fetch_array() ფუნქცია

ინგლ: Fetch - მოტანა, ამოღება, მიღწევა;

mysqli_fetch_array() ფუნქცია SQL მოთხოვნის შედეგად ცხრილიდან ამოღებულ შედეგს ანუ ცხრილის ჩანაწერება ათავსებს აცოციაციურ ან ნუმერაციულ ან ერთდროულად ორივე სახის მასივში. შენიშვნა: ამ ფუნქციით დაბრუნებული ცხრილის სვეტთა დასახელებები არიან რეგისტრის მიმართ მგრძნობიარენი. სინტაქსი ასეთია mysqli_fetch_array(result,resulttype); პირველი პარამეტრის მითითება აუცილებელია, იგი განსაზღვრავს დაბრუნებულ შედეგს, რომლის მოქცევაც გვინდა მასივში. resulttype პარამეტრის მითითება კი ნებაყოფლობითია, იგი განსაზღვრავს თუ რა სახის მასივში უნდა მოექცეს შედეგი - ასოციაციურში თუ რიცვით ინდექსებიანში. ამ პარამეტრმა შეიძლება მიიღოს შემდეგი მნიშვნელობები
  • MYSQLI_ASSOC
  • MYSQLI_NUM
  • MYSQLI_BOTH
ვთქვათ გვაქვს შემდეგი ცხრილი



და შემდეგი სახის SQL მოთხოვნა $sql="SELECT * FROM Persons WHERE id=1";
$result=mysqli_query($con,$sql); ანუ შედეგად ვღებულობთ ცხრილის პირველ ჩანაწერს. ახლა ეს ჩანაწერი მოვაქციოთ რივხვით ინდექსებიან მასივში $row=mysqli_fetch_array($result,MYSQLI_NUM); და დავბეჭდოთ იგი echo "<pre>";
print_r($row);
echo "</pre>";
 შედეგი იქნება 
Array
(
    [0] => 1
    [1] => John
    [2] => Rambo
    [3] => rambo@example.com
    [4] => 2017-06-30 00:00:00
    [5] => 24
)
ახლა ვთქვათ გვინდა დავაბრუნოთ ცხრილის firstname სვეტის მნიშვნელობა ამ ჩანაწერისათვის, ცხრილში ეს სვეტი არის მეორე, მასივში კი აქვს ინდექსი 1, echo $row[1]; // John ახლა შედეგი მოვაქციოთ ასოციაციურ მასივში და დავბეჭდოთ იგი, შედეგი იქნება 
Array
(
    [id] => 1
    [firstname] => John
    [lastname] => Rambo
    [email] => rambo@example.com
    [reg_date] => 2017-06-30 00:00:00
    [age] => 24
)
firstname სვეტის მნიშვნელობა კი დაბრუნდება ასე echo $row['firstname']; // John თუ resulttype ატრიბუტის მნიშვნელობას საერთოდ არ მივუთითებთ შედეგი მოთავსდება ორივე სახის მასივში: ასოციაციურშიც და რიცხვით ინდექსებიანშიც 
Array
(
    [0] => 1
    [id] => 1
    [1] => John
    [firstname] => John
    [2] => Rambo
    [lastname] => Rambo
    [3] => rambo@example.com
    [email] => rambo@example.com
    [4] => 2017-06-30 00:00:00
    [reg_date] => 2017-06-30 00:00:00
    [5] => 24
    [age] => 24
)

mysqli_fetch_assoc() ფუნქცია

mysqli_fetch_assoc() ფუნქცია SQL მოთხოვნის შედეგს ათავსებს ასოციაციურ მასივში, ასოციაციური მასივის მუშაობის პრინციპი ზემოთ უკვე ვნახეთ და აქ აღარ მოვიყვანთ.

mysqli_fetch_row() ფუნქცია

mysqli_fetch_row() ფუნქცია SQL მოთხოვნის შედეგს ათავსებს რიცხვით ინდექსებიან მასივში,ასეთი მასივის მუშაობის პრინციპი ზემოთ უკვე ვნახეთ და აქ აღარ მოვიყვანთ.

mysqli_fetch_object() ფუნქცია

mysqli_fetch_object() ფუნქცია SQL მოთხოვნის შედეგს აბრუნებს როგორც ობიექტს. $sql="SELECT * FROM myguests WHERE id=1";
$result=mysqli_query($con,$sql);

// შედეგი როგორც ობიექტი
$obj=mysqli_fetch_object($result);
// დავბერჭდოთ ობიექტი
echo "<pre>";
print_r($obj);
echo "</pre>";
 შედეგი იქნება 
stdClass Object
(
    [id] => 1
    [firstname] => John
    [lastname] => Rambo
    [email] => rambo@example.com
    [reg_date] => 2017-06-30 00:00:00
    [age] => 24
)
stdClass არის ცარიელი კლასი რომელსაც აგენერირებს PHP. ახლა კვლავინდებურად დავადგინოთ firstname სვეტის მნიშვნელობა echo $obj->firstname; // John

mysqli_field_count() ფუნქცია

mysqli_field_count() ფუნქცია აბრუნებს ბოლოს შესრულებულ SQL მოთხოვნაში გათვალისწინებული სვეტების რაოდენობას, სინტაქსი ასეთია mysqli_field_count(connection); $con=mysqli_connect("localhost","my_user","my_password","my_db");
mysqli_query($con,"SELECT id, name, phone FROM Friends");
echo mysqli_field_count($con);
/*
შედეგი იქნება სამი, რადგან მოვითხოვეთ სამი სვეტის
მნიშვნელობების დაბრუნება - id, name და phone
*/

mysqli_num_rows() ფუნქცია

mysqli_num_rows() ფუნქცია აბრუნებს SQL მოთხოვნის შედეგად მიღებულ პასუხთა ნაკრებში ჩანაწერების რაოდენობას, მაგალითად ჩვენს ცხრილში ამოვარჩიოთ ისეთი პიროვნებები, რომელთა ასაკი მეტია 20-ზე $sql="SELECT * FROM Persons WHERE age>201";
$result=mysqli_query($con,$sql);
echo mysqli_num_rows($result); // შედეგი იქნება 2

mysqli_real_escape_string() ფუნქცია

mysqli_real_escape_string() ფუნქცია შლის სპეციალურ სიმბოლოებს სტრიქონში, ამ სტრიქონის SQL მოთხოვნაში გამოყენებამდე. მაგალითად მივიღეთ ინფორმაცია ფორმიდან POST მეთოდით $firstname = mysqli_real_escape_string($con, $_POST['firstname']);
$lastname = mysqli_real_escape_string($con, $_POST['lastname']);
$age = mysqli_real_escape_string($con, $_POST['age']);

$sql="INSERT INTO Persons (FirstName, LastName, Age) VALUES ('$firstname', '$lastname', '$age')";

mysqli_select_db() ფუნქცია

mysqli_select_db() ფუნქცია გამოიყენება სამუშაო მონაცემთა ბაზის შესაცვლელად, ასარჩევად. $con=mysqli_connect("localhost","my_user","my_password","my_db");
// Check connection
if (mysqli_connect_errno()) {
  echo "Failed to connect to MySQL: " . mysqli_connect_error();
}

// ...some PHP code for database "my_db"...

// Change database to "test"
mysqli_select_db($con,"test");

// ...some PHP code for database "test"...

mysqli_close($con);
38. MySQLi ფუნქციები (ოო მიდგომა)

დაკავშირება ბაზასთან

MySQL სერვერთან ახალი კავშირის გასახსნელად უნდა შევქმნათ mysqli კლასის ეგზემპლიარი ობიექტი, ეს ობიექტი პირობითად მოვათავსოთ $mysqli ცვლადში და გადავცეთ მას შემდეგი პარამეტრები
  • ჰოსტის დასახელება ან ip მისამართი.
  • MySQL სერვერის მომხმარებლის სახელი.
  • MySQL სერვერის მომხმარებლის პაროლი.
  • MySQL მონაცემთა ბაზის სახელი.
$mysqli = new mysqli('localhost', 'my_user', 'my_password', 'my_db');

connect_errno() და connect_error() მეთოდები

მას შემდეგ რაც გავხსნით MySQL სერვერთან ახალ კავშირს, უნდა შევამოწმოთ წარმატებულია თუ არა ეს დაკავშირება. ამაში დაგვეხმარება $mysqli ობიექტის connect_errno() და connect_error() მეთოდები, პირველი მათგანი აბრუნებს ბაზასთან დაკავშირებისას დაფიქსირებული შეცდომის კოდს, ნომერს, ხოლო მეორე მათგანი აბრუნებს შეტყობინებას ამ შეცდომის შესახებ. 
<?php
$mysqli = new mysqli('localhost', 'my_user', 'my_password', 'my_db');

/*
 * ეს არის შეცდომების გამოტანის "ოფიციალური"გზა ობიექტზე ორიენტირებული (ოო) მიდგომით,
 * მაგრამ $connect_error არ მუშობს PHP-ის 5.2.9 და 5.3.0 ვერსიებზე ადრინდელ ვერსიებში
 */
if ($mysqli->connect_error)
{
    die('Connect Error (' . $mysqli->connect_errno . ') '
            . $mysqli->connect_error);
}

/*
 * იმისათვის რათა დავრწმუნდეთ რომ კოდი იმუშვებს 5.2.9 ვერსიაზე ადრინდელ ვერსიებშიც,
 * უმჯობესია გამოვიყენოთ ასეთი კოდი
 */
if (mysqli_connect_error())
{
    die('Connect Error (' . mysqli_connect_errno() . ') '
            . mysqli_connect_error());
}

echo 'Success... ';


?>

query() მეთოდი

ეს მეთოდი გამოიყენება მონაცემთა ბაზაში მოთხოვნის გასაკეთებლად. 
<?php
$mysqli = new mysqli("localhost", "my_user", "my_password", "world");

/* კავშირის გადამოწმება */
if ($mysqli->connect_errno)
{
    printf("ვერ მოხერხდა დაკავშირება ბაზასთან: %s\n", $mysqli->connect_error);
    exit();
}

/* ზოგიერთი ბრძანება, მაგალითად ცხრილის შექმნის ბრძანება, არ აბრუნებს შედეგთა ნაკრებს */
if ($mysqli->query("CREATE TEMPORARY TABLE myCity LIKE City") === TRUE)
{
    printf("ცხრილი myCity წარმატებით შეიქმნა.\n");
}

/* Select მოთხოვნა აბრუნებს შედეგთა ნაკრებს */
if ($result = $mysqli->query("SELECT Name FROM City LIMIT 10"))
{
    printf("ok");
}

fetch_array() მეთოდი

ეს მეთოდი მოთხოვნის შედეგად მიღებულ ნაკრებს ათავსებს მასივში, მასივი შეიძლება იყოს ასოციაციური, რიცხვითინდექსებიანი ან ორივე ერთდროულად, იმის მიხედვით თუ რა პარამეტრს გადავცემთ მეთოდს, პარამეტრი კი შეიძლება იყოს ჩამოთვლილთაგან ერთ-ერთი
  • MYSQLI_NUM (რიცხვითინდექსებიანი)
  • MYSQLI_ASSOC (ასოციაციური)
  • MYSQLI_BOTH (ორივე ერთდროულად)
<?php
$mysqli = new mysqli("localhost", "my_user", "my_password", "world");

/* check connection */
if ($mysqli->connect_errno)
{
    printf("Connect failed: %s\n", $mysqli->connect_error);
    exit();
}

$query = "SELECT Name, CountryCode FROM City ORDER by ID LIMIT 3";
$result = $mysqli->query($query);

/* numeric array */
$row = $result->fetch_array(MYSQLI_NUM);
printf ("%s (%s)\n", $row[0], $row[1]);

/* associative array */
$row = $result->fetch_array(MYSQLI_ASSOC);
printf ("%s (%s)\n", $row["Name"], $row["CountryCode"]);

/* associative and numeric array */
$row = $result->fetch_array(MYSQLI_BOTH);
printf ("%s (%s)\n", $row[0], $row["CountryCode"]);
ამ მეთოდის შედეგად დაბრუნებულ ასოციაცურ მასივში, როგორც ვხედავთ, მნიშვნელობებს ვიღებთ მონაცემთა ბაზის ცხრილის ველების დასახელებების მითითებით, ველთა დასახელებები ასოთა რეგისტრის მიმართ მგრძნობიარეა.

fetch_assoc() მეთოდი

ეს მეთოდი მოთხოვნის შედეგად მიღებულ ნაკრებს ათავსებს ასოციაციურ მასივში, იგი ისევე მუშაობს, როგორც წინა მეთოდი MYSQLI_ASSOC პარამეტრთან ერთად. 
<?php
$mysqli = new mysqli("localhost", "my_user", "my_password", "world");

/* check connection */
if ($mysqli->connect_errno)
{
    printf("Connect failed: %s\n", $mysqli->connect_error);
    exit();
}

$query = "SELECT Name, CountryCode FROM City ORDER by ID DESC LIMIT 50,5";

if ($result = $mysqli->query($query))
{

    /* fetch associative array */
    while ($row = $result->fetch_assoc())
    {
        printf ("%s (%s)\n", $row["Name"], $row["CountryCode"]);
    }

}

fetch_row() მეთოდი

ეს მეთოდი მოთხოვნის შედეგად მიღებულ ნაკრებს ათავსებს რიცხვით ინდექსებიან მასივში, იგი ისევე მუშაობს, როგორც fetch_array() მეთოდი MYSQLI_NUM პარამეტრთან ერთად. 
<?php
$mysqli = new mysqli("localhost", "my_user", "my_password", "world");

/* check connection */
if (mysqli_connect_errno())
{
    printf("Connect failed: %s\n", mysqli_connect_error());
    exit();
}

$query = "SELECT Name, CountryCode FROM City ORDER by ID DESC LIMIT 50,5";

if ($result = $mysqli->query($query))
{

    /* fetch object array */
    while ($row = $result->fetch_row())
    {
        printf ("%s (%s)\n", $row[0], $row[1]);
    }
    
}

fetch_object() მეთოდი

ეს მეთოდი მონაცემთა ბაზაში გაგზავნილი მოთხოვნის შედეგად მიღებული შედეგთა ნაკრების მიმდინარე ჩანაწერს, სტრიქონს, გარდაქმნის ობიექტად. ობიექტის ატრიბუტებად ანუ თვისებებად უნდა განვიილოთ ცხრილის ველთა დასახელებები. 
<?php
$mysqli = new mysqli("localhost", "my_user", "my_password", "world");

/* check connection */
if (mysqli_connect_errno())
{
    printf("Connect failed: %s\n", mysqli_connect_error());
    exit();
}
 
$query = "SELECT Name, CountryCode FROM City ORDER by ID DESC LIMIT 50,5";

if ($result = $mysqli->query($query))
{

    /* fetch object array */
    while ($obj = $result->fetch_object())
    {
        printf ("%s (%s)\n", $obj->Name, $obj->CountryCode);
    }

}

affected_rows მეთოდი

როგორც 37-ე თავში ვთქვით affected_rows მეთოდი აბრუნებს ცხრილის იმ ჩანაწერთა რაოდენობას რომლებიც კონკრეტული მოთხოვნის შედეგად განიცდიან ზემოქმედებას (ინგლ: affected - რომელიც განიცდის, ზემოქმედება განცდილი). 
<?php
require "db/connect.php";

$query = "SELECT * FROM people";
$result = $mysqli->query($query);

echo $mysqli->affected_rows;
ეს ჩანაწერი დააბრუნებს იმ სტრიქონთა რაოდენობას, რომლებიც ამოირჩევა people ცხრილიდან.

შენიშვნა !

თუ ზემოქმედებული სტრიქონების რაოდენობა მეტია ვიდრე value( PHP_INT_MAX ) შეასაძლო მაქსიმალური მთელი მნიშვნელობისა, მაშინ მეთოდის მიერ დაბრუნებული შედეგი იქნება სტრიქონული ტიპის.

num_rows მეთოდი

ეს მეთოდი აბრუნებს კონკრეტული მოთხოვნის შედეგად მიღებულ შედეგთა სიმრავლეში შემავალი სტრიქონების რაოდენობას. 
<?php
require "db/connect.php";

$query = "SELECT * FROM people";
$result = $mysqli->query($query);

echo $result->num_rows;

set_charset მეთოდი

ეს მეთოდი მიუთითებს სიმბოლოთა კოდირებას. $mysqli->set_charset("utf8");

real_escape_string მეთოდი

real_escape_string მეთოდი შლის სპეციალურ სიმბოლოებს სტრიქონში, ამ სტრიქონის SQL მოთხოვნაში გამოყენებამდე 
<?php
require "db/connect.php";


$city = $mysqli->real_escape_string($city);

if ($mysqli->query("INSERT into myCity (Name) VALUES ('$city')")) {
    echo $mysqli->affected_rows;
}

პრეპარირებული ანუ წინასწარგანსაზღვრული ბრძანებები

პრეპარირებული განაცხადების შესახებ უკვე ვისაუბრეთ 32-ე თავში, ამიტომ აქ აღარ განვმარტავთ მის შინაარს და უბრალოდ ობიექტზე ორიენტირებული სტილით მისი გამოყენების მაგალითებს მოვიყვანთ. 
<?php
require "db/connect.php";

$name = "vaso";

// თუ წარმატებით დასრულდება მოთხოვნის სტრუქტურის განსაზღვრა
if ($stmt = $mysqli->prepare("SELECT lname FROM people WHERE fname=?")) 
{
    // პარამეტრების მიმაგრება
    $stmt->bind_param("s", $name);

    // ბრძანების შესრულება
    $stmt->execute();

    // სახელების დარქმევა ცხრილის იმ ველებზე, რომლებსაც ვიღებთ ცხრილიდან   
    $stmt->bind_result($lname);

    // მნიშვნელობების ამოღება
    $stmt->fetch();

    // ამოღებული მნიშვნელობის გამოყენება
    echo  $lname;

    // მოთხოვნის დახურვა
    $stmt->close();
}
else
{
    echo $mysqli->error;
}

აპლიკაცია

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

პრეპარირებული განაცხადების გარეშე

connect.php ფაილი

როგორც წესი მონაცემთა ბაზასთან დასაკავშირებელ ინსტრუქციას წერენ ხოლმე ცალკე ფაილში, დავარქვათ ამ ფაილს connect.php 
<?php
error_reporting(0);
$mysqli = new mysqli('localhost','root','','app');

if (mysqli_connect_error())
{
    die('Connect Error (' . mysqli_connect_errno() . ') ' . mysqli_connect_error());
}
ჩანაწერების დასამატებელი ფორმა და ბაზიდან ამოღებული ჩანაწერები კი გამოვიტანოთ index.php ფაილში, რეომელსაც ექნება შემდეგი სახე 
<?php
require_once 'connect.php';

if (isset($_POST['submit']))
{
    $fname = $mysqli->real_escape_string($_POST['fname']);
    $lname = $mysqli->real_escape_string($_POST['lname']);
    $bio   = $mysqli->real_escape_string($_POST['bio']);

    $insert = $mysqli->query("INSERT INTO people (fname, lname, bio) VALUES('$fname', '$lname', '$bio')");
    if(!$insert)
    {
        echo "ვერ მოხერხდა ჩანაწერის დამატება";
    }
    else
    {
        echo "დაემატა " . $mysqli->affected_rows . " ჩანაწერი";
    }
}


if($select = $mysqli->query("SELECT * FROM people"))
{
    if($select->num_rows != 0)
    {
        while ($result = $select->fetch_object())
        {
            echo $result->fname . " " .$result->lname . " " .$result->bio ."<br>";
        }
        
    }
    else
    {
        echo "ჩანაწერები არ არის დამატებული";
    }
}
else
{
    "ვერ მოხერხდა ჩანაწერების გამოტანა"; 
}


?>

<!DOCTYPE html>
<html>
<head>
    <title>App</title>
</head>
<body>

    <form action="" method="post">
        სახელი<input type="text" name="fname">
        სახელი<input type="text" name="lname">
        ტექსტი <textarea name="bio"></textarea>
        <input type="submit" name="submit" value="დამატება">
    </form>

</body>
</html>

პრეპარირებული განაცხადებით

39. PDO

რა არის PDO ?

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

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

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

ბაზასთან დაკავშირება ხდება ავტომატურად მას შემდეგ რაც შევქმნით საბაზისო კლასის ეგზემპლიარ PDO ობიექტს, არ აქვს მნიშვნელობა, რომელ დრაივერს ვიყენებთ, ყოველთვის უნდა გამოვიყენოთ საბაზისო კლასის დასახელება. კლასის კონსტრუქტორს უნდა გადაეცეს არგუმენტები, რომლებიც განსაზღვრავენ მონაცემთა წყაროსთან ანუ ბაზასთან დაკავშირების სქემას (ცნობილი როგორც DSN - database source name, ეს არის ჩანაწერი, სტრიქონი, რომლის სტრუქტურაც უზრუნველყოფს ინფორმაციის წყაროსთან დაკავშირებას), შესაძლებელია საჭირო იყოს მომხმარებლის სახელისა და პაროლის მითითებაც. 
<?php
$pdo = new PDO('mysql:host=localhost;dbname=test', $user, $pass);
?>
ამავე ჩანაწერში შესაძლებელია კოდირების განსაზღვრაც. 
<?php
$pdo = new PDO('mysql:host=localhost;dbname=test,charset=utf8', $user, $pass);
?>
ნებისმიერი ოპერაციის შესრულებისას და მათ შორის - მაცემთა ბაზასთან დაკავშირებისას, შეიძლება დაფიქსირდეს რაიმე შეცდომა. საჭიროა ამ შეცდომის აღმოფხვრა და შესაბამისი ქმედების ჩატარება, აუცილებელია ამ შეცდომის დამუშავება. 
<?php
try{
    $pdo = new PDO('mysql:host=localhost;dbname=test', $user, $pass);
}
catch(){
    // ....
}

?>
PDO გაფართოება საშუალებას გვაძლევს გამოვიყენოთ PDOException კლასი, რომლის მეშვეობითაც ხდება შეცდომათა დამუშავება. catch ბლოკს უნდა გადავცეთ არგუმენტად PDOException კლასის ობიექტი და ამ ობიექტთან ასოცირებადი რაიმე ცვლადი მაგალითად $e 
<?php
try{
    $pdo = new PDO('mysql:host=localhost;dbname=test', $user, $pass);
}
catch(PDOException $e){
    die($e->getMessage());
}

?>
ეს არის შეცდომის დამუშავების უმარტივესი მაგალითი - გამოგვაქვს შეტყობინება შეცდომის შესახებ.

შეცდომების დამუშავებისას შეგვიძლია $pdo ობიექტს განვუსაზღროთ სხვადასხვა პარამეტრები setAttribute() მეთოს დახმარებით. მეთოდს პირველ პარამეტრად უნდა გადეცეს იმ პარამეტრის დასახელება, რომლის განსაზღრაც გვსურს, შეცდომების დამუშავების რეჟიმისათვის ეს პარამეტრი არის ATTR_ERRMODE, ამის შემდეგ კი უნდა მივუთითოთ, რომ გსურს გამონაკლისთა (ინგ: exception - გამონაკლისი) გენერირება, შეცდომათა დამუშავების ანუ გამონაკლისთა გენერირების ერთ-ერთი სტრატეგია არის PDO::ERRMODE_EXCEPTION 

<?php
try{
    $pdo = new PDO('mysql:host=localhost;dbname=test', $user, $pass);
    $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
}
catch(PDOException $e){
    die($e->getMessage());
}

?>

მბ-სთან სამუშაო სტანდარტული ოპერაციები PDO-ს გამოყენებით

PDO::query მეთოდი

PDO::query მეთოდი ასრულებს განსაზღვრულ SQL ბრძანებას და შედეგთა ნაკრებს აბრუნებს PDOStatement ობიექტის სახით, რომელსაც გააჩნია შედეგთა ნაკრების დამუშავებისათვის აუცილებელი მეთოდები (წარუმატებლობის შემთხვევაში აბრუნებს FALSE მნიშვნელობას). ეს მეთოდი გამოიყენება ისეთი ტიპის ბრძანებებთან სამუშაოდ რომლებიც აბრუნებენ შედეგთა ნაკრებს (მაგ SELECT). 
<?php
try{
    $pdo = new PDO('mysql:host=localhost;dbname=test', $user, $pass);
    $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

    $sql = "SELECT * FROM courses";
    $result = $pdo->query($sql);

    print_r($result);

}
catch(PDOException $e){
    die($e->getMessage());
}

?>
ამ კოდის შედეგი იქნება შემდეგი PDOStatement Object ( [queryString] => SELECT * FROM courses ) რაც იმას ნიშნავს რომ შეიქმნა, დაბრუნდა PDOStatement ობიექტი, რომელიც თავის თავში მოიცავს შედეგთა ნაკრებს, შედეგთა ნაკრები კი თავის მხრივ შეიქმნა SELECT * FROM courses ბრძანებით.

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

<?php
try{
    $pdo = new PDO('mysql:host=localhost;dbname=test', $user, $pass);
    $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

    $sql = "SELECT * FROM courses";
    $result = $pdo->query($sql);

    foreach ($result as $row)
    {
        echo $row['name']. "<br>";
    }

}
catch(PDOException $e){
    die($e->getMessage());
}

?>

PDO::exec მეთოდი

PDO::exec მეთოდი ასრულებს განსაზღვრულ SQL ბრძანებას და აბრუნებს ზემოქმედებულ ჩანაწერთა რაოდენობას, გამოიყენება ისეთი ტიპის ბრძანებებთან სამუშაოდ რომლებიც შედეგთა ნაკრების ნაცვლად აბრუნებენ ზემოქმედებულ ჩანაწერთა რაოდენობას (მაგ INSERT, UPDATE, DELETE). 
<?php
try{
    $pdo = new PDO('mysql:host=localhost;dbname=app;charset=utf8','root','');
    $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

    $sql = "INSERT courses (name, price, months) VALUES('TEST','450','12')";
    
    $result = $pdo->exec($sql);

    print_r($result); // 1


}catch(PDOException $e){
    echo $e->getMessage();
}

?>

PDOStatement ობიექტის თვისებები

PDOStatement::fetch

შედეგთა ნაკრების ობიექტის ანუ PDOStatement-ის fetch მეთოდი იღებს სათითაო ჩანაწერს შედეგთა ნაკრებიდან. ამ მეთოდს შესაძლებელია გადაეცეს პარამეტრი (ამ პარამეტრს ვუწოდოთ fetch_style), რომელიც განსაზღვრავს თუ რა სახით უნდა დაბრუნდეს შედეკთა ნაკრების მიმდინარე ჩანაწერი. პარამეტრის ყველაზე ხშირად გამოყენებადი შესაძლო მნიშვნელობებია:
  • PDO::FETCH_NUM - შედეგთა ნაკრების მიმდინარე ჩანაწერს აბრუნებს რიცხვითინდექსებიანი მასივის სახით. 
    <?php

try{
    $pdo = new PDO('mysql:host=localhost;dbname=app;charset=utf8','root','');
    $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

    $sql = "SELECT * FROM courses";
    $result = $pdo->query($sql);

    while ($row = $result->fetch(PDO::FETCH_NUM))
    {
        echo $row[2]. "<br>";
    }



}catch(PDOException $e){
    echo $e->getMessage();
}
  • PDO::FETCH_ASSOC - შედეგთა ნაკრების მიმდინარე ჩანაწერს აბრუნებს ასოციაციური მასივის სახით, რომლის ინდექსებიც მბ-ს ცხრილის ველთა დასახელებებია, ხოლო მნიშვნელობები - ამ ველთა მნიშვნელობები. 
    <?php

try{
    $pdo = new PDO('mysql:host=localhost;dbname=app;charset=utf8','root','');
    $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

    $sql = "SELECT * FROM courses";
    $result = $pdo->query($sql);

    while ($row = $result->fetch(PDO::FETCH_ASSOC))
    {
        echo $row['name']. "<br>";
    }



}catch(PDOException $e){
    echo $e->getMessage();
}
  • PDO::FETCH_BOTH - შედეგთა ნაკრების მიმდინარე ჩანაწერს აბრუნებს როგორც ასოციაციური, ასევე რიცხვითინდექსებიანი მასივის სახით (ნაგულისხმევი მნიშვნელობა fetch_style პარამეტრის).
  • PDO::FETCH_OBJ - შედეგთა ნაკრების მიმდინარე ჩანაწერს აბრუნებს ანონიმური ობიექტის სახით რომლის თვისებათა დასახელებებიც ემთხვევა მბ-ს ცხრილის ველთა დასახელებებს, ხოლო მნიშვნელობები - ამ ველთა მნიშვნელობებს. 
    <?php

try{
    $pdo = new PDO('mysql:host=localhost;dbname=app;charset=utf8','root','');
    $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

    $sql = "SELECT * FROM courses";
    $result = $pdo->query($sql);

    while ($row = $result->fetch(PDO::FETCH_OBJ))
    {
        echo $row->name. "<br>";
    }



}catch(PDOException $e){
    echo $e->getMessage();
}
  • PDO::FETCH_CLASS

PDO::FETCH_CLASS

თუ fetch მეთოდს fetch_style არგუმენტად განვუსაზღვრავთ PDO::FETCH_CLASS - ს, ამ შემთხვევაში შედეგთა ნაკრები გადაეცემა სპეციალურ კლასს, რომლის დასახელებაც უნდა მივუთითოთ PDOStatement ობიექტის setFetchMode() მეთოდის დახმარებით. (აღსანიშნავია, რომ setFetchMode() მეთოდით fetch_style არგუმენტის სხვა მნიშვნელობების განსაზღვრაც შესაძლებელია, მაგრამ უფრო კომფორტულია ეს ყველაფერი ჩაიწეროს ისე როგორც ზემოთ ვწერდით) კლასი ამ დროისათვის უკვე შექმნილი უნდა იყოს და მისი თვისებების დასახელებები უნდა ემთხვეოდეს, მბ-ს ცხრილის ველთა დასახელებებს. 
<?php

class User {
    protected $id;
    protected $name;

    public function getId(){
        return $this->id;
    }

    public function getName(){
        return $this->name;
    }
}

try{
    $pdo = new PDO('mysql:host=localhost;dbname=app;charset=utf8','root','');
    $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

    $sql = "SELECT * FROM courses";
    $result = $pdo->query($sql);

    $result->setFetchMode(PDO::FETCH_CLASS, 'User');
    while($row = $result->fetch())
    {
        echo $row->getName() . "<br>";
    }



}catch(PDOException $e){
    echo $e->getMessage();
}

წინასწარგანსაზღვრული განაცახადები

PDO::prepare

PDO::prepare მეთოდის მეშვეობით ხდება SQL ბრძანების შაბლონის განსაზღვრა. 
<?php

try{
    $pdo = new PDO('mysql:host=localhost;dbname=app;charset=utf8','root','');
    $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

    $sql = "SELECT * FROM courses WHERE id= ?";
    $stmt = $pdo->prepare($sql);

}catch(PDOException $e){
    echo $e->getMessage();
}

PDOStatement::execute

PDOStatement::execute მეთოდი ასრულებს იმ ბრძანებას რომლის შაბლოპნიც განვსაზღვრეთ PDO::prepare მეთოდის მეშვეობით. მაგრამ მას უნდა გადავცეთ საჭირო ცვლადები, პარამეტრები ('?' ნიშნების მაგივრად). ეს ხდება შემდეგნაირად 
<?php

try{
    $pdo = new PDO('mysql:host=localhost;dbname=app;charset=utf8','root','');
    $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

    $id= 3;

    $sql = "SELECT * FROM courses WHERE id=?";
    $stmt = $pdo->prepare($sql);

    $stmt->execute(array($id));

}catch(PDOException $e){
    echo $e->getMessage();
}
ზედა მაგალითში გამოვიყენეთ უსახელო პარამეტრი (უბრალოდ კითხვის ნიშანი - '?'), მაგრამ შესაძლებელია ამ პარამეტრებს დავარქვათ სახელებიც, უბრალოდ ამ შემთხვევაში PDOStatement::execute მეთოდს არგუმენტად უნდა გადავცეთ ასოციაციური მასივი 
<?php

try{
    $pdo = new PDO('mysql:host=localhost;dbname=app;charset=utf8','root','');
    $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

    $id= 3;

    $sql = "SELECT * FROM courses WHERE id=:id";
    $stmt = $pdo->prepare($sql);

    $stmt->execute(array('id' => $id));

    print_r($stmt->fetchAll());
    

}catch(PDOException $e){
    echo $e->getMessage();
}
შესაძლებელია ასეთი ჩანაწერის გამოყენებაც 
<?php

try{
    $pdo = new PDO('mysql:host=localhost;dbname=app;charset=utf8','root','');
    $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

    $id= 3;

    $sql = "SELECT * FROM courses WHERE id=:id";
    $stmt = $pdo->prepare($sql);

    $stmt->execute(['id' => $id]);

    print_r($stmt->fetchAll());
    

}catch(PDOException $e){
    echo $e->getMessage();
}
პრეპარირებულ ბრძანებაზე პარამეტრთა მიმაგრება შესაძლებელია PDOStatement::bindParam მეთოდითაც.

PDOStatement::bindParam

PDOStatement::bindParam მეთოდს არგუმენტებად უნდა გადაეცეს იარლიყის სახელი, შესაბამისი ცვლადის სახელი და ამ იარლიყისა და ცვლადის ტიპის განმსაზღვრელი პარამეტრი. 
<?php

try{
    $pdo = new PDO('mysql:host=localhost;dbname=app;charset=utf8','root','');
    $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

    $id= 3;
    $name = 'PHP';
    $sql = "SELECT * FROM courses WHERE id=:id OR name=:name";
    $stmt = $pdo->prepare($sql);
    $stmt->bindParam(':id',$id,PDO::PARAM_INT); // მთელი ტიპის პარამეტრი
    $stmt->bindParam(':name',$name,PDO::PARAM_STR); // სტრიქონყლი ტიპის პარამეტრი
    $stmt->execute();

    print_r($stmt->fetchAll());
    

}catch(PDOException $e){
    echo $e->getMessage();
}

PDOStatement::bindColumn

PDOStatement::bindColumn მეთოდი მბ-ს ცხრილის სახელებს აკავშირებს ცვლადებთან 
<?php

try{
    $pdo = new PDO('mysql:host=localhost;dbname=app;charset=utf8','root','');
    $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

    $id= 3;
    $sql = "SELECT price, months FROM courses WHERE id=:id";
    $stmt = $pdo->prepare($sql);
    $stmt->bindParam(':id',$id,PDO::PARAM_INT);
    $stmt->execute();
    // ნუმერაციის მიხედვით მიმაგრება
    $stmt->bindColumn(1,$price);
    // დასახელების მიხედვით მიმაგრება
    $stmt->bindColumn('price',$price);

    while($row = $stmt->fetch())
    {
        echo $price;
    }
    

}catch(PDOException $e){
    echo $e->getMessage();
}
40. PHP შეცდომები - ERRORS

Parse Error (Syntax Error)

Parse Error (Syntax Error) ანუ შეცდომა რომელიც ფიქსირდება სინტაქსური ანალიზისას, სინტაქსური შეცდომა. იგი აჩერებს სკრიპტის მუშაობას და ბრაუზერში გამოდის შესაბამისი შეტყობინება, არსებობს ამ შეცდომის გამომწვევი უამრავი მიზეზი მაგრამ ყველაზე ხშირად ეს მიზეზებია: დაუხურავი ფრჩხილები, დაუხურავი ბრჭყალები, წერტილძძიმის გამოტოვება ჩანაწერის ბოლოს. მაგალითად არდასმული წერტილმძიმე <?php
   echo "Cat";
   echo "Dog"
   echo "Lion";
?> შედეგი



Fatal Error

Fatal Error ანუ გარდაუვალი შეცდომა ფიქსირდება მაშინ, როდესაც PHP ხვდება რაც დავწერეთ სკრიპტის კონკრეტულ ადგილას მაგრამ, მეორეს მხრივ ჩვენი ჩანაწერის შესრულება შეუძლებელია. Fatal Error ანუ გარდაუვალი შეცდომა წყვეტს სკრიპტის მუშაობას. ასეთი სახის შეცდომები ფიქსირდება მაგალითად მაშინ, როდესაც ვიძახებთ უცნობ, არარსებულ ფუნქციას <?php
function fun1(){
  echo "OK";
}
fun2();
echo "Fatal Error !!";
?> შედეგი



Warning Error

Warning Error ანუ გამაფრთხილებელი შეცდომის ძირითადი გამომწვევინმიზეზებია მაგალითად include ფუნქციის მეშვეობით არარსებული ფაილის ჩასმა გვერდზე, ან ფუნქციის პარამეტრების არასწორად მითითება, გამაფრთხილებელი შეცდომა არ აჩერებს სკრიპტის მუშაობას თუმცა შესაბამისი შეტყობინება გამოდის ბრაუზერში <?php
   echo "Warning Error!!";
   include ("Welcome.php");
?> შედეგი



Notice Error

Notice Error ანუ შეტყობინება შეცდომის შესახებ, Warning Error-ის მსგავსად არც იგი წყვეტს სკრიპტის მუშაობას და ფიქსირდება მაგალითად მაშინ თუ გამოვიენებთ უცნობ, განუსაზღვრელ ცვლადს <?php
  $a="PHP";
  echo "Notice Error !!";
  echo $b;
?>



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

მნიშვნელობა კონსტანტა აღწერა
1 E_ERROR Fatal ტიპის შეცდომები. შეცდომები რომელთა უგულებელყოფაც შეუძლებელია. ამ დროს სკრიპტის მუშაობა ჩერდება.
2 E_WARNING warning ტიპის შეცდომები. ამ დროს სკრიპტის მუშაობა არ ჩერდება.
4 E_PARSE გამოთვლითი პროცესის დროს სინტაქსურ ანალიზში დაფიქსირებული შეცდომები.
8 E_NOTICE სკრიპტის გაშვებისას ფიქსირებადი შენიშვნები. სცრიპტში აღმოჩენილია ისეთი რამ რაც შეიძლება შეცდომა იყოს მაგრამ შესაძკებელია რომ სკრიპტმა მუშაობა გააგრძელოს.
32767 E_ALL ყველანაირი PHP შეცდომა და გაფრთხილება

error_reporting() ფუნქცია

error_reporting() ფუნქცია განსაზღვრავს თუ რა სახის შეცდომების შესახებ ვიხილოთ შეტყობინებები <?php
   // შეცდომების შეტყობინებების გამორთვა
   error_reporting(0);

   //მხოლოდ სკრიპტის გაშვებისას (runtime) დაფიქსირებული შეცდომები
   error_reporting(E_ERROR | E_WARNING | E_PARSE);

   // ყველა სახის შეცდომა
   error_reporting(E_ALL);

   // იგივეა რაც error_reporting(E_ALL);
   ini_set("error_reporting", E_ALL);

   // ყველანაირი შეცდომა გარდა E_NOTICE-სა
   error_reporting(E_ALL & ~E_NOTICE);

?>
41. PHP ელ_ფოსტა
PHP-ს mail() ფუნქცია საშუალებას გვაძლევს გავაგზავნოთ ელ_ფოსტა უშუალოდ სკრიპტიდან. მისი გამოყენების სინტაქსი ასეთია mail(to,subject,message,headers,parameters);
პარამეტრი აღწერა
to აუცილებელია მითითება. განსაზღვრავს ელ_ფოსტის მიმღებს
subject აუცილებელია მითითება. განსაზღვრავს ელ_ფოსტის თემას.

შენიშვნა: ეს პარამეტრი არ შეიძლე შეიცავდეს ახალ ხაზზე გადასვლის სიმბოლოებს

message აუცილებელია მითითება. განსაზღვრავს თავად შეტყობინებას. ყოველი ახალი ხაზი უნდა გამოიყოს "\n" სიმბოლოთი, თითოეული ხაზი უნდა შეიცავდეს მაქსიმუმ 70 სიმბოლოს.
headers მითითება არ არის აუცილებელი. განსაზღვრავს დამატებით სათაურებს, როგორებიცაა, From, Cc და Bcc. დამატებითი სათაურები ერთმანეთისაგან უნდა გამოიყოს "\r\n"-ით.

შენიშვნა: ელ_ფოსტა აუცილებლად უნდა შეიცავდეს, "From" სათაურს. იგი შეიძლება განისაზღვროს ან ამ პარამეტრში ან php.ini ფაილში.

parameters მითითება არ არის აუცილებელი.
<?php
   $to = "somebody@example.com, somebodyelse@example.com";
   $subject = "HTML email";

   $message = "
   <html>
   <head>
     <title>HTML email</title>
   </head>
   <body>
   <p>This email contains HTML Tags!</p>
   <table>
     <tr>
       <th>Firstname</th>
       <th>Lastname</th>
     </tr>
     <tr>
       <td>John</td>
       <td>Doe</td>
     </tr>
   </table>
   </body>
   </html>
   ";

   // ყოველთვის უნდა განვსაზღვროთ content-type როდესაც ვგზავნით HTML-ის შემცველ ელ_ფოსტას
   $headers = "MIME-Version: 1.0" . "\r\n";
   $headers .= "Content-type:text/html;charset=UTF-8" . "\r\n";

   // დამატებითი სათაურები (headers)
   $headers .= 'From: <webmaster@example.com>' . "\r\n";
   $headers .= 'Cc: myboss@example.com' . "\r\n";

   mail($to,$subject,$message,$headers);
?>

MIME

MIME არის აბრევიატურა - Multipurpose Internet Mail Extensions ანუ მრავალმიზნობრივი ინტერნეტ ელ_ფოსტის გაფართოებები. იგი არის ინტერნეტ-სტანდარტი რომელიც უნდა გამოვიყენოთ შემდეგ შემთხვევებში
  • თუ character sets ანუ ენკოდინგში მითითებული სიმბოლოები განსხვავდება ASCII-სგან.
  • თუ ელ_ფოსტაზე მიბმულია არატექსტური ფაილები: ვიდეო, მუსიკა ...
  • ელ_ფოსტის, შეტყობინების ტექსტი შედგება რამოდენიმე ნაწილისაგან.
  • სათაურად მითითებული ინფორმაცია არც არის ASCII
42. მათემატიკური ფუნქციები

abs() ფუნქცია

აბრუნებს რიცხვის აბსოლიტურ მნიშვნელობას ანუ მოდულს. echo abs(-6.7); // 6.7

base_convert() ფუნქცია

რომელიმე რიცხვით სისტემაში ჩაწერილი რიცხვი გადაჰყავს სხვა სისტემაში (მაგ: ორობიტი რიცხვი ათობითში). სინტაქსი ასეთია base_convert(number,frombase,tobase); სამივე პარამეტრის მითითება აუცილებელია, პირველი განსაზღვრავს თავად რიცხვს, მეორე განსაზღვრავს იმ სისტემას რომელშიც რიცხვია ჩაწერილი და მესამე განსაზღვრავს იმ სისტემას რომელშიც გვინდა რომ გადავიყვანოთ რიცხვი. $oct = "10";
echo base_convert($oct,2,10); // შედეგი 2

bindec()

ორობითი სისტემის რიცხვები გადაჰყავს ათობით სისტემაში echo bindec("0011"); // 3
echo bindec("01"); // 1
echo bindec("11000110011"); // 1587
echo bindec("111"); // 111 = 1*22 + 1*21 + 1*20 = 4 + 2 + 1 = 7 bindec() ფუნქციის შებრუნებული ფუნქციაა decbin() ფუნქცია.

ceil() ფუნქცია

ამრგვალებს რიცხვს მეტობით უახლოეს მთელ რიცხვამდე echo ceil(0.60); // 1
echo ceil(0.40); // 1
echo ceil(5); // 5
echo ceil(5.1); // 6
echo ceil(-5.1); // -5
echo ceil(-5.9); // -5

floor() ფუნქცია

ამრგვალებს რიცხვს ნაკლებობით უახლოეს მთელ რიცხვამდე echo ceil(0.60); // 0
echo ceil(0.40); // 0
echo ceil(5); // 5
echo ceil(5.1); // 5
echo ceil(-5.1); // -6
echo ceil(-5.9); // -6

round() ფუნქცია

ამრგვალებს ათწილადებს ჩვეულებრივი, მათემატიკური წესით echo round(0.60); // 1 echo round(0.50); // 1 echo round(0.49); // 0 echo round(-4.40); // -4 echo round(-4.60); // -5

max() ფუნქცია

აბრუნებს მასივის ელემენტებიდან ყველაზე დიდ მნიშვნელობის მქონეს, ან მითითებული რიცხვებიდან ყველაზე დიდს echo max(2,4,6,8,10); // 10 echo max(22,14,68,18,15); // 68 echo max(array(4,6,8,10)); // 10 echo max(array(44,16,81,12)); // 81 max() ფუნქციის შებრუნებული ფუინქციაა min()

rand() ფუნქცია

აგენერირებს შემთხვევით მთელ რიცხვს. თუ გვსურს მივიღოთ შემთხვევითი რიცხვი 10-100 ინტერვალიდან უნდა მივუთითოთ rand (10,100). rand(); // შემთხვევითი რიცხვი

ან

rand(min,max); // შემთხვევითი რიცხვი კონკრეტული ინტერვალიდან getrandmax() ფუნქცია აბრუნებს rand ფუნქციით მიღებული შესაძლო რიცხვებიდან მაქსიმუმს. ზოგიერთ პლატფორმაზე მაგალითად Windows-ზე ეს რიცხვი არის 32767.

mt_rand() ფუნქცია

აგენერირებს შემთხვევით მთელ რიცხვს მერსენ ტვისტერის ალგორითმის მეშვეობით. მერსენ ტვისტერი არის ფსევდოშემთხვევითი რიცხვის გენერატორი ანუ (PRNG - pseudorandom number generator). ეს ფუნქცია გაცილებით უკეთესად მუშაობს ვიდრე rand() და არის მასზე 4-ჯერ სწრაფი. თუ გვსურს მივიღოთ შემთხვევითი რიცხვი 10-100 ინტერვალიდან უნდა მივუთითოთ mt_rand (10,100). mt_rand(); // შემთხვევითი რიცხვი

ან

mt_rand(min,max); // შემთხვევითი რიცხვი კონკრეტული ინტერვალიდან mt_getrandmax() ფუნქცია აბრუნებს mt_rand ფუნქციით მიღებული შესაძლო რიცხვებიდან მაქსიმუმს. ამ მნიშვნელობათა ზედა საზღვარი დამოკიდებული არ არის პლატფორმაზე. PHP იყენებს Mersenne Twister-ის 32-ბიტიან ვერსიას, ამიტომ mt_getrandmax() იქნება 2 * 31 - 1 = 2147483647.

pow() ფუნქცია

ახარისხება ანუ xy. სინტაქსი ასეთია pow(x,y); ორივე არგუმენტის მითითება აუცილებელია, პირველი განსაზღვრავს რიცხვს მეორე კი ხარისხს. echo pow(2,4); // 16 echo pow(-2,4); // 16 echo pow(-2,-4); // 0.0625 echo pow(-2,-3.2); // NAN

sqrt() ფუნქცია

კვადრატული ფესვის ამოღება რიცხვიდან sqrt(number); echo sqrt(4); // 2 echo sqrt(16); // 4 echo sqrt(0.64); // 0.8 echo sqrt(-2); // NAN
43. რეგულარული გამოსახულებები
რეგულარული გამოსახულება ეს არის სიმბოლოთა კონკრეტული თანმიმდევრობა ან შაბლონი. რეგულარული გამოსახულებები გამოიყენება სტრიქონებში სიმბოლოთა შაბლონების საძებნელად. მათი დახმარებით შესაძლებელია ერთი სტრიქონი მოვძებნოთ მეორეში. ჩავანაცვლოთ სტრიქონის კონკრეტული ნაწილი სხვა სტრიქონით, ან სტრიქონი დავყოთ ფრაგმენტებად. PHP-ს აქვს სპეციალური ფუნქციები რეგულარულ გამოსახულებებთან სამუშაოდ. 
<?php
  // ძირითადი სტრიქონი
  $string = 'abcdefghijklmnopqrstuvwxyz0123456789';
?>
გავარკვიოთ ამ სტრიქონში შედის თუ არა სტრიქონი "abc" 
<?php
  $string = 'abcdefghijklmnopqrstuvwxyz0123456789';
  echo preg_match("/abc/", $string);  // 1
?>
preg_match ფუნქცია დააბრუნებს 1-ს თუ შაბლონი ანუ "abc" შედის სტრიქონში, და დააბრუნებს 0-ს თუ არ შედის. ფუნქცია პირველი დამთხვევის პოვნისთანავე წყვეტს მუშაობას და აბრუნებს შედეგს.

ძებნა სტრიქონის დასაწყისში

ახლა გავიგოთ იწყება თუ არა სტრიქონი "abc" შაბლონით, ამისათვის გამოიყენება სიმბოლო ^ 
<?php
  $string = 'abcdefghijklmnopqrstuvwxyz0123456789';
  if(preg_match("/^abc/", $string)){
    echo 'დიახ';
  }
  else{
    echo 'არა';
  }
?>
როგორც ვხედავთ საძიებო შაბლონი ანუ რეგულარული გამოსახულება მოთავსებულია დახრილ ხაზებს შორის, მაგრამ მათ ნაცვლად შესაძლებელია ნებისმიერი სხვა სიმბოლოს წყვილის გამოყენება, მაგ : @regex@, #regex#, /regex/ და ა.შ.

ასოთა რეგისტრი

ახლა გადავამოწმოთ შეიცავს თუ არა სტრიქონი დიდი ასოებით ჩაწერილ შაბლონს 
<?php
  $string = 'abcdefghijklmnopqrstuvwxyz0123456789';
  echo preg_match("/^ABC/", $string) ? 'დიახ' : 'არა';  // არა
?>
ანუ ძებნა არის რეგისტრზე დამოკიდებული. თუ გვსურს რომ ძებნა განხორციელდეს რეგისტრის მიუხედავად, უნდა გამოვიყენოთ მოდიფიკატორი i 
<?php
  $string = 'abcdefghijklmnopqrstuvwxyz0123456789';

  if (preg_match("/^ABC/i", $string)) {
      echo 'დიახ';
  } else {
      echo 'არა';
  }
?>
ამ კოდის შედეგი იქნება "დიახ", რადგან ამ შემთხვევაში მოიძებნება არა მარტო "abc" არამედ ABC, Abc, aBc და ა.შ.

ძებნა სტრიქონის ბოლოში

ამისათვის გამოიყენება \z ჩანაერი. 
<?php
  $string = 'abcdefghijklmnopqrstuvwxyz0123456789';

  if (preg_match("/89\z/i", $string)) {
      echo 'დიახ';
  } else {
      echo 'არა';
  }
?>

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

სტრიქონულ კლასს განსაზღვრავს ფიგურული ფრჩხილები [ ], სტრიქონული კლასი ეს არის იმ სიმბოლოთა ნაკრები რომლებიც შესაძლებელია რომ მოხვდნენ საძიებო შაბლონში. სიმბოლოთა კლასის ჩაწერა შესაძლებელია თანმიმდევრულად [abcdef] ან დიაპაზონის სახით [a-f] 
<?php
$string = 'big';

echo preg_match("/b[aoiu]g/", $string, $matches);  // 1
?>
44. PHP და JSON
JSON (JavaScript Object Notation) — JavaScript -ზე დაფუძნებული მონაცემთა გაცვლის ტექსტური ფორმატი, რომელიც ადვილად წაკითხვადია, როგორც მანქანისათვის ისე ადამიანისათვის და რომელიც გამოიყენება სერვერსა და ბრაუზერს შორის მონაცემთა გასაცვლელად.

JSON სინტაქსი დაფუძნებულია ჯავასკრიპტის ობიექტის სინტაქსზე:
  • მონაცემები წარმოდგენილია "სახელი":"მნიშვნელობა" ("name":"value") წყვილების სახით.
  • მონაცემები ერთმანეთისგან გამოყოფილია მძიმით.
  • ფიგურულ ფრჩხილებში მოქცეულია ობიექტები.
  • კვადრატულ ფრჩხილებში მოქცეულია მასივები.
მნიშვნელობa (value) უნდა იყოს შემდეგი ტიპებიდან ერთ-ერთი :
  • ობიექტი (JSON ობიექტი)
  • მასივი
  • boolean
  • null
  • სტრიქონული
  • რიცხვითი
  • undefined
  • ფუნქცია
  • date
PHP-ს აქვს რამოდენიმე ჩაშენებული ფუნქცია JSON-თან სამუშაოდ.

json_encode() ფუნქცია

ობიექტის დაკონვერტება JSON-ად

PHP-ობიექტი შეიძლება დაკონვერტდეს JSON-ად json_encode() ფუნქციის გამოყენებით: 
<?php
class Test 
{
    //.....
}

$myObj = new Test();

$myObj->name = "John";
$myObj->age = 30;
$myObj->city = "New York";

$myJSON = json_encode($myObj);

echo $myJSON; // შედეგი : {"name":"John","age":30,"city":"New York"}

მასივის დაკონვერტება JSON-ად

json_encode() ფუნქციით შესაძლებელია მასივის დაკონვერტებაც 
<?php

$myArr = array("John", "Mary", "Peter", "Sally");

$myJSON = json_encode($myArr);

echo $myJSON; // შედეგი : ["John","Mary","Peter","Sally"]

json_decode() ფუნქცია

json_decode() ფუნქცია კი გამოიყენება JSON ფორმატის მასივად ან ობიექტად დასაკონვერტებლად 
<?php
$json = '{"a":1,"b":2,"c":3,"d":4,"e":5}';

var_dump(json_decode($json));
var_dump(json_decode($json, true));
ამ კოდის შედეგი იქნება 
object(stdClass)#1 (5) {
    ["a"] => int(1)
    ["b"] => int(2)
    ["c"] => int(3)
    ["d"] => int(4)
    ["e"] => int(5)
}

array(5) {
    ["a"] => int(1)
    ["b"] => int(2)
    ["c"] => int(3)
    ["d"] => int(4)
    ["e"] => int(5)
}
როგორც ვხედავთ მეორე შემთხვევაში მითითებულია დამატებითი პარამეტრი true, ამ პარამეტრის სახელია JSON_OBJECT_AS_ARRAY და ღებულობს true/false მნიშვნელობებს, შინაარსობრივად კი განსაზღვრავს დაფორმატდეს თუ არა JSON ტექსტი მასივად.
45. სხვადასხვა ფუნქციები

die() ფუნქცია

die() ფუნქციას გამოაქვს შეტყობინება და გამოდის მიმდინარე სკრიპტიდან. die(message) <?php
$site = "https://www.w3schools.com/";
fopen($site,"r")
or die("Unable to connect to $site");
?>

exit() ფუნქცია

exit() ფუნქციას გამოაქვს შეტყობინება და გამოდის მიმდინარე სკრიპტიდან. exit(message) <?php
$site = "https://www.w3schools.com/";
fopen($site,"r")
or exit("Unable to connect to $site");
?> exit() და die() ფუნქციებს შორის არანაირი განსხვავება არ არის.

show_source() ფუნქცია

show_source() ფუნქციას გამოაქვს ფაილის წყარო, კოდი <?php;
show_source("index.php");;
?>

uniqid() ფუნქცია

uniqid() ფუნქცია აგენერირებს უნიკალურ id-ს echo uniqid();

password_hash() ფუნქცია

password_hash() ფუნქცია ქმნის ჰეშირებულ პაროლს ჰეშირების ცალმხრივი ალგორითმის დახმარებით (one-way hashing algorithm). ცალმხრივი ალგორითმი გულისხმობს, რომ შესაძლებელია მოვახდინოთ სტრიქონის ჰეშირება, გარდაქმნა, მაგრამ უკვე გარდაქმნილი ტექსტიდან ორიგინალი სტრიქონის მიღება თითქმის შეუძლებელია, უხეშად რომ ვთქვათ, არ არსებობს 'უკან დასაბრუნებელი', შედეგიდან ორიგინალის მისაღები გზა.

ორიოდ სიტყვით ცალმხრივი ალგორითმების შესახებ

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

f(x)=y

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

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

მიმატება

4 + 3 = 7 ამ ოპერაციის შებრუნება ანუ შედეგიდან საწყის მნიშვნელობამდე მისვლა შესაძლებელია ასე 7 - 3 = 4

გამრავლება

4 * 3 = 12 ამ ოპერაციის შებრუნება ანუ შედეგიდან საწყის მნიშვნელობამდე მისვლა შესაძლებელია ასე 12 : 3 = 4

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

გაყოფის ნაშთი

22 % 7 = 1 ამ ოპერაციის შებრუნება შეუძლებელია რადგან ვერ ვიპოვით არითმეტიკულ მოქმედებას, რომელიც დაგვაბრუნებს საწყის მდგომარეობასთან 1 ? 7 = 22
1 ? 22 = 7

ისევ password_hash() ფუნქცია :))

ფუნქციის სინტაქსი ასეთია password_hash(password, algo, options) პირველი პარამეტრის მითითება აუცილებელია, ეს არის მომხმარებლის მიერ აკრეფილი პაროლი, მაგალითად $password = $_POST['password']; მეორე პარამეტრის მითითებაც აუცილებელია და იგი განსაზღვრავს ჰეშირების ალგორითმის. PHP-ს განვითარების ამ ეტაპზე შესაძლებელია ერთ-ერთის მითითება შემდეგი ორი ალგორითმიდან
  • PASSWORD_DEFAULT - ჰეშირების ნაგულისხმები ალგორითმი. უნდა აღინიშნოს, რომ ამ კონსტანტის მნიშვნელობა შესაძლებელია შეიცვალოს დროდადრო, ამიტომ დაბრუნებული შედეგის სიგრძეც სხვადასხვა იქნება, აქედან გამომდინარე სასურველია მიღებული ჰეშპაროლი შევინახოთ მონაცემთა ბაზის ცხრილის ისეთ ველში, რომელიც იტევს 60 სიმბოლოზე მეტს (რეკომენდებულია 255 სიმბოლოიანი ველი). echo password_hash("rasmuslerdorf", PASSWORD_DEFAULT); ამ ჩანაწერის შედეგი იქნება რაღაც ამის მსგავსი $2y$10$WEw3vUpjpakt7PgQrcU7.OAfYB32k4QZHJWsZT2grlmXC0Jhsa3t6
  • PASSWORD_BCRYPT - ამ ალგორითმით მიღებული ჰეშპაროლი ყოველთვის შეიცავს 60 სიმბოლოს და იყება '$2y$' ჩანაწერით. 
    $options = [
    'cost' => 12,
];
echo password_hash("rasmuslerdorf", PASSWORD_BCRYPT, $options);
?>
    ამ ჩანაწერის შედეგი იქნება რაღაც ამის მსგავსი $2y$12$QjSH496pcT5CEbzjD/vtVeH03tfHKFy36d4J0Ltp3lRtee9HDxY3K
რაც შეეხება მესამე პარამეტრს, მისი მითითება ნებაყოფლობითია და თავის თავში მოიცავს ასოციაციურ მასივს, რომელშიც მოთავსებულია პარამეტრები შერჩეული ალგორითმისათვის.

password_verify() ფუნქცია

ფუნქცია ამოწმებს ემთხვევა თუ არა პაროლი ჰეშირებულ პაროლს. მისი სინტაქსი ასეთია password_verify(password , hash) ლოგიკურია, რომ ფუნქცია აბრუნებს true/false მნიშვნელობებს. აუცილებელია ორივე პარამეტრის მითითება. 
<?php
$hash = '$2y$07$BCryptRequires22Chrcte/VlQH0piJtjXl.0t1XkA8pw9dMXTpOq';

if (password_verify('rasmuslerdorf', $hash)) {
    echo 'პაროლი სწორია !';
} else {
    echo 'პაროლი არასწორია !';
}
?>


OOP PHP



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

კლასი და ობიექტი

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

ინკაფსულაცია

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

ოოპ-ის ძირითადი იდეა არის მონაცემებისა (თვისებების) და მათზე გათვალისწინებული მოქმედებების (მეთოდების) გაერთიანება ობიექტში. ობიექტი ”ფლობს ინფორმაციას” თავისი მდგომარეობის (თვისებების) შესახებ და ”იცის” მისთვის განმარტებული ქცევის წესები (კლასში აღწერილი ფუნქციები ანუ მეთოდები). მაგალითად, ობიექტი - ტელევიზორი შეიძლება შეიცავდეს :
  • თვისებებს: ზომა - Size, ფერადობა - Color, ხმა (სიმაღლე) - Sound, არხების რაოდენობა - Channels და ა.შ
  • მეთოდებს: ჩართვა - on(), გამორთვა - off(), ხმის გათიშვა - sound_off(), არხიდან არხზე გადართვა - switching_channels().
ობიექტის მონაცემებზე პირდაპირი წვდომა აკრძალულია. ეს ნიშნავს, რომ ობიექტის მონაცემების დამუშავება შეუძლიათ მხოლოდ მისივე ფუნქციებს. პროგრამის არც ერთ სხვა ფუნქციას (გარდა ე.წ. მეგობარი ფუნქციისა) ობიექტის მონაცემების უშუალოდ გამოყენების უფლება არა აქვს. ანუ მონაცემები დაცულია გარე ზემოქმედებისაგან, შემთხვევითი არასასურველი შეცვლისაგან. ოოპ -ის ამ კონცეფციას ეწოდება ინკაფსულაცია (encapsulation).

მემკვიდრეობითობა

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

პოლიმორფიზმი

ბერძნ: polymorphos - მრავალფეროვანი.

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

კონსტრუქტორი

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

დესტრუქტორი

დესტრუქტორი არის კლასში აღწერილი ფუნქცია, რომლის გამოძახებაც ხდება ავტომატურად, როგორც კი წაიშლება ამ კლასის ეგზემპლიარი, ობიექტი.
2. კლასისა და ობიექტის შექმნა
კლასის შექმნა ხდება სიტყვაგასაღებ 'Class'-ის გამოყენებით, მის შემდეგ ვუთითებთ კლასის სახელს, ხოლო თვისებებისა და მეთოდების აღწერა ხდება ფიგურულ ფრჩხილებში : 
class phpClass 
{
    $var1;
    $var2 = "ვასო";

    function myfunc ($arg1, $arg2) 
    {
        [..]
    }

    [..]
}
შევქმნათ კლასი სახელწოდებით - Book : 
class Books 
{
    // 
}
კლასის შექმნის შემდეგ შესაძლებელია შევქმნათ მისი იმდენი ეგზემპლიარი ანუ ობიექტი, რამდენიც გაგვიხარდება. ობიექტის შექმნა ხდება სიტყვაგასაღებ 'new'-ს დახმარებით : $physics = new Books;
$maths = new Books;
$chemistry = new Books; თუ ახლა დავბეჭდავთ, რომელიმე მათგანს : var_dump($physics); ვიხილავთ ასეთ შედეგს : object(Books)#1 (0) { } ეს იმას ნიშნავს, რომ $physics ობიექტი არის ცარიელი კლასის - Book-ის კონკრეტული ეგზემპლიარი, კლასი ცარიელია რადგან - მასში ჯერ არ გვაქვს აღწერილი არანაირი მეთოდი ან თვისება. აღვწეროთ ისინი : 
class Books 
{
    /* თვისებები */
    public $price;
    public $title;

    /* მეთოდები */
    function setPrice($par)
    {
        $this->price = $par;
    }

    function getPrice()
    {
        echo $this->price ."<br/>";
    }

    function setTitle($par)
    {
        $this->title = $par;
    }

    function getTitle()
    {
        echo $this->title ." <br/>";
    }
}
$this არის სპეციალური ცვლადი, რომელიც მიუთითებს იმავე კლასზე, რომელშიც თავად ეს ცვლადია გამოყენებული, მისი მეშვეობით ხდება კლასის მეთოდებზე და თვისებებზე მიმართვა.

ამ ჩანაწერით შევქმენით ერთმანეთისაგან დამოუკიდებელი სამი ობიექტი. იმის გასაგებად არის თუ არა კონკრეტული ობიექტი კონკრეტული კლასის ეგზემპლიარი, გამოიყენება ოპერატორი 'instanceof' (ინგლ: Instance - მაგალითი, ნიმუში). var_dump($physics instanceof Books); // TRUE
var_dump($maths instanceof Books); // TRUE
var_dump($chemistry instanceof Book); // FALSE

მეთოდები და თვისებები

კლასში აღწერილ ცვლადს რომელიც ინახავს კონკრეტულ ინფორმაციას ეწოდება ამ კლასის თვისება. მაგალითად Books კლასის თვისებებია $price და $title;

კლასში აღწერილ ფუნქციას რომელიც ასრულებს რაიმე სახის ოპერაციას, ეწოდება კლასის მეთოდი. მაგალითად Books კლასის მეთოდებია setPrice(), getPrice(), setTitle() და getTitle().

ობიექტების შექმნის შემდეგ შესაძლებელია მისი მეთოდების გამოძახება. მეთოდებზე და თვისებებზე მიმართვა ხდება '->' ჩანაწერის დახმარებით. მეთოდების მეშვეობით განვსაზღვროთ ჩვენს მიერ შექმნილი ობიექტების ანუ წიგნების სათაურები და ფასები : $physics->setTitle("ფიზიკა უმაღლესი სკოლებისათვის");
$chemistry->setTitle("ქიმიის სახელძღვანელო");
$maths->setTitle("ალგებრა");

$physics->setPrice(10);
$chemistry->setPrice(15);
$maths->setPrice(7);
 ახლა ამავე ობიექტების სხვა მეთოდების საშუალებით გამოვიტანოთ მინიჭებული სათაურები და ფასები $physics->getTitle();
$chemistry->getTitle();
$maths->getTitle();
$physics->getPrice();
$chemistry->getPrice();
$maths->getPrice(); შედეგი იქნება ფიზიკა უმაღლესი სკოლებისათვის
ქიმიის სახელძღვანელო
ალგებრა
10
15
7
3. მაგიური მეთოდები
მაგიური ფუნქციების დასახელებებს წინ ერთვის ორი ქვედა ტირე "__".

__construct()

კონსტრუქტორი არის კლასის ჩვეულებრივი მეთოდი, რომლის გამოძახებაც ავტომატურად ხდება ამ კლასის ეგზემპლიარი ობიექტის შექმნისას. კონსტრუქტორის აღწერა ხდება __construct() ოპერატორის გამოყენებით. შესაძლებელია კონსტრუქტორს გადაეცეს არგუმენტებიც. Books კლასისათვის შევქმნათ კონსტრუქტორი, რომელიც მოახდენს კონკრეტული წიგნების ანუ ობიექტების სახელებისა და ფასების ინიციალიზაციას: 
function __construct($par1, $par2) 
{
    $this->title = $par1;
    $this->price = $par2;
}
ახლა აღარ დაგვჭირდება set ფუნქციების გამოძახება ობიექტთა სათაურებისა და ფასების განსაზღვრისას : $physics = new Books("ფიზიკა უმაღლესი სკოლებისათვის", 10);
$maths = new Books("ალგებრა", 15);
$chemistry = new Books ("ქიმიის სახელძღვანელო", 7);

/* მინიჭებული მნიშვნელობების გამოტანა */
$physics->getTitle();
$chemistry->getTitle();
$maths->getTitle();

$physics->getPrice();
$chemistry->getPrice();
$maths->getPrice();

__destruct()

დესტრუქტორი არის კლასის ჩვეულებრივი მეთოდი, რომლის გამოძახებაც ავტომატურად ხდება როდესაც შესრულდება განსაზღვრული ობიექტთან დაკავშირებული ყველა ოპერაცია ან დასრულდება სკრიპტის მუშაობა. 
class MyDestructableClass 
{
    function __construct() 
    {
        print "სატესტო ბეჭდვა კონსტრუქტორში<br />";
        $this->name = "კლასის წასაშლელი თვისება";
    }

    function __destruct() 
    {
        print "წაიშალა " . $this->name . "\n";
    }
}

$obj = new MyDestructableClass();
შედეგი იქნება : სატესტო ბეჭდვა კონსტრუქტორში // ობიექტის შექმნისას კონსტრუქტორში აღწერილი ინსტრუქციის შესაბამისად
წაიშალა კლასის წასაშლელი თვისება // დამთავრდა მუშაობა ობიექტთან

__invoke()

ინგლ: Invoke - მოწოდება, მოხმობა, დაძახება;

__invoke() მეთოდის გამოძახება ხდება მაშინ, როდესაც ობიექტს მივმართავთ როგორც ფუნქციას : 
class CallableClass
{
    public function __invoke($x)
    {
       echo $x;
    }
}

$obj = new CallableClass;
$obj(5); // 5

__toString()

__toString() მაგიურ მეთოდში აღწერილი ინსტრუქცია სრულდება მაშინ, როდესაც ობიექტს მივმართავთ როგორც სტრიქონს : 
public function __toString()
{
    return $this->text;
}

$tweet = new Tweet(1, 'გამარჯობა');
echo $tweet; // 'გამარჯობა'

__get() და __set()

ობიექტებთან მუშაობისას ხშირად გვჭირდება მის თვისებებთან და მეთოდებთან წვდომა, მაგალითად ასე : $tweet = new Tweet(123, 'გამარჯობა');
echo $tweet->text; // 'გამარჯობა' მაგრამ ხშირად ობიექტთა მეთოდები და თვისებები დაცულია (protected) და მათი ამ სახით გამოძახება შეცდომამდე მიგვიყვანს. სწორედ ასეთ მეთოდებთან და თვისებებთან დასაკავშირებლად გამოიყენება __get() მეთოდი : 
public function __get($property)
{
    if (property_exists($this, $property)) 
    {
        return $this->$property;
    }
}
__get() მეთოდს სასუველი თვისების დასახელება გადაეცემა არგუმენტად. ზემოთ მოყვანილ კოდში property_exists ჩანაწერის მერშვეობით ჯერ მოწმდება მიმდინარე ობიექტს საერთოდ აქვს თუ არა მითითებული თვისება, ხოლო თუ აქვს ხდება მისი გამოტანა.

ობიექტის დაცული თვისებების (protected) მნიშვნელობების მისათითებლად კი გამოიყენება __set() მეთოდი. მას უნდა გადაეცეს ორი არგუმენტი - თვისების დასახელება და თვისების მნიშვნელობა : 
public function __set($property, $value)
{
    if (property_exists($this, $property)) 
    {
        $this->$property = $value;
    }
}

$tweet->text = 'Setting up my twttr';
echo $tweet->text; // 'Setting up my twttr'

__isset() და __unset()

დავუშვათ ვიცით რომ ობიექტს აქვს რომელიღაც დაცული თვისება და გვინდა გადავამოწმოთ ამ თვისებას აქვს თუ არა მითითებული მნიშვნელობა, ამ შემთხვევაში უნდა გამოვიყენოთ მაგიური მეთოდი __isset() რომელსაც არგუმენტად გადაეცემა სასურველი თვისების დასახელება 
public function  __isset($property)
{
    return isset($this->$property);
}

isset($tweet->text); // true


დაცული თვისების მნიშვნელობის გასაუქმებლად კი გამოიყენება მაგიური მეთოდი __unset() 
public function __unset($property) 
{
    unset($this->$property);
}


4. თვალთახედვის არე - Public, Private, Protected
თვალთახედვის არედ მოიაზრება მთლიანი სკრიპტის ინ ნაწილები სადაც შესაძლებელია, კლასის მეთოდებისა და თვისებების გამოყენება.

Public

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

Private

თუ კლასში აღწერილ მეთოდს ან თვისებას წინ ერთვის წვდომის სპეციფიკატორი Private, ეს ნიშნავს რომ მათი გამოყენება შესაძლებელია მხოლოდ და მხოლოდ ამ კლასის შიგნით (ინგლ: Private - კერძო, პირადი; საიდუმლო, ფარული), სხვა სიტყვებით რომ ვთქვათ Private მეთოდები და ფუნქციები დახურულია კლასგარეშე კოდისათვის. 
Class Shops
{
    private $name;

    public function naming()
    {
        $this->name = "Biblusi";
        echo $this->name;
    }
}

$shop = new Shops();
$shop->naming();  // Biblusi
$shop->name = "Nike";  // Cannot access private property Shops::$name in ....

Protected

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

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

ინგ: Extend - გაფართოება, განვრცობა;

დავუშვათ გვაქვს საბაზისო კლასი "ParentClass", თუ ჩვენ განვსაზღვრავთ ახალ კლასს "ChildClass"-ს რომელსაც ექნება იგივე მეთოდები და თვისებები რაც აქვს ParentClass-ს, ვიტყვით რომ ChildClass არის ParentClass-ის მემკვიდრე ან შვილობილი კლასი. შესაბამისად ParentClass არის ChildClass-ის წინაპარი ან მშობელი კლასი. შვილობილ კლასს შესაძლებელია გააჩნდეს დამატებითი თვისებები და მეთოდები - წინააღმდეგ შემთხვევაში აზრი ეკარგება ახალი კლასის შექმნას. ამ პროცესს ეწოდება მემკვიდრეობითობა. მემკვიდრეობითობის რეალიზება ხდება სიტყვაგასაღებ 'extends'-ის დახმარებით. მემკვიდრე კლასის შექმნის სინტაქსი ასეთია : 
class ChildClass extends ParentClass 
{
    //
}
შევქმნათ კლასი User : 
<?php

class User
{
    public $name;
    public $password;
    public $email;
    public $city;

    function __construct($name,$password,$email,$city)
    {
        $this->name = $name;
        $this->password = $password;
        $this->email = $email;
        $this->city = $city;
    }

    $first = new User("ვასო","hjyu56","vaso@gmail.com","ხაშური");
    echo $first->city; // ხაშური
}
?>
ახლა შევქმნათ ამ კლასის მემკვიდრე კლასი "Moderator" 
class Moderator extends User
{
    public $info; // მემკვიდრე კლასის ახალი თვისება
}

$moder = new Moderator("კაკო","67erbn","kako@gmail.com","კუდიგორა");
echo $moder->name; // კაკო
როგორც ვხედავთ 'Moderator' კლასში კონსტრუქტორი აღწერილი არ გვაქვს მაგრამ ამ ჩანაწერმა მაინც იმუშავა : $moder = new Moderator("კაკო","67erbn","kako@gmail.com","კუდიგორა"); იმუშავა, რადგან 'Moderator' კლასს ფუნქცია-კონსტრუქტორი მემკვიდრეობით ერგო 'User' კლასისაგან.
6. პოლიმორფიზმი
იმის შესახებ თუ რას ნიშნავს და რას ეწოდება პოლიმორფიზმი უკვე ვისაუბრეთ პირველ თავში ამიტომ აქ მოვიყვანოთ პირდაპირ მაგალითი 
class A 
{
    // გამოიტანს თუ რომელი კლასიდან იყო გამოძახებული ფუნქცია
    function Test() 
    { 
        echo "გამოძახებულ იქნა A კლასიდან"; 
    }

    // გადამისამართება Test() ფუნქციაზე
    function Call() 
    {
        $this->Test();
    }
}

class B extends A 
{
    // ფუნქცია Test()  B კლასისათვის
    function Test() 
    {
        echo "გამოძახებულ იქნა B კლასიდან"; 
    }
}

$a=new A();
$b=new B();

$a->Call(); // გამოიტანს "გამოძახებულ იქნა A კლასიდან"
$b->Test(); // გამოიტანს "გამოძახებულ იქნა B კლასიდან"
$b->Call(); // ყურადღება ! გამოიტანს "გამოძახებულ იქნა B კლასიდან"!
აი პოლიმორფიზმის მშვენიერი მაგალითი :)))



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

OOP-ის ფუძემდებელი იდეა არის მონაცემებისა და მათზე გათვალისწინებული მოქმედებების გაერთიანება ე.წ. ობიექტში. ამ მიზნით განისაზღვრება აბსტრაქტული მონაცემთა ტიპები (მომხმარებლის მიერ განსაზღვრული ტიპები) - კლასები. კლასი შეიცავს მონაცემებს და მათი დამუშავების ფუნქციების გარკვეულ კრებულს. სწორედ კლასის საფუძველზე იქმნება ობიექტები. ობიექტი ”ფლობს ინფორმაციას” თავისი მდგომარეობის შესახებ (მონაცებებს) და ”იცის” მისთვის განმარტებული ქცევის წესები (იყენებს კლასის ფუნქციებს). მაგალითად, ობიექტი - ტელევიზორი შეიძლება შეიცავდეს
  • თვისებებს: ზომა - Size, ფერადობა - Color, ხმა (სიმაღლე) - Sound, არხების რაოდენობა - Channels და ა.შ
  • მეთოდებს: ჩართვა - on(), გამორთვა - off(), ხმის გათიშვა - sound_off(), არხიდან არხზე გადართვა - switching_channels().
ობიექტის მონაცემებზე პირდაპირი წვდომა აკრძალულია. ეს ნიშნავს, რომ ობიექტის მონაცემების დამუშავება შეუძლიათ მხოლოდ მისივე ფუნქციებს. პროგრამის არცერთ სხვა ფუნქციას (გარდა ე.წ. მეგობარი ფუნქციისა) ობიექტის მონაცემების უშუალოდ გამოყენების უფლება არა აქვს. ანუ მონაცემები დაცულია გარე ზემოქმედებისაგან, შემთხვევითი არასასურველი შეცვლისაგან. ოოპ -ის ამ კონცეფციას ეწოდება ინკაფსულაცია (encapsulation).



8. სტატიკური მეთოდები და თვისებები

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

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

კლასის მეთოდის ან თვისების სტატიკურად გამოცხადება ნიშნავს, რომ მათთან წვდომა შესაძლებელია კლასის ეგზემპლიარის, ანუ ობიექტის შექმნის გარეშე. კლასის სტატიკურ მეთოდთან ან თვისებასთან წვდომა შეუძლებელია ამ კლასის ეგზემპლიარი ობიექტიდან. სტატიკური მეთოდების და თვისებების განსაზღვრა ხდება სიტყვა გასაღებ static-ის მეშვეობით. შევქმნათ სტატიკური თვისება კლასისათვის : 
Class User
{
    public static $name;
}
სტატიკური თვისების გამოყენება არ ხდება "$this->" ჩანაწერით. ამისათვის გამოიყენება ორმაგი ორწერტილი : 
Class User
{
    public static $name;
}

user::$name = "ვასო";
echo user::$name; // ვასო
ანალოგიურად ხდება სტატიკური მეთოდის აღწერა : 
Class User
{
    public static $name;

    public static function hello()
    {
        echo "გამარჯობა " . self::$name;
    }

}

user::$name = "ვასო";
echo user::$name; // ვასო
user::hello();  // გამარჯობა ვასო
როგორც აღვნიშნეთ სტატიკური მეთოდები და თვისებები არ არის დაკავშირებული ობიექტებთან, აქედან გამომდინარე მათ არ აქვთ წვდომა კლასის არასტატიკურ თვისებებთან და მეთოდებთან. მაგალითად ეს კოდი გამოიტანს შეცდომას : 
Class User
{
    public $name;

    function set_name($par)
    {
        $this->name = $par;
    }

    public static function hello()
    {
        echo "გამარჯობა " . $this->name;
    }
}

$user = new User();
$user->set_name('ვასო');

user::hello();  // Fatal error: Uncaught Error: Using $this when not in object context in ...
აქედან გამომდინარე სტატიკური მეთოდი უნდა აღვწეროთ მხოლოდ და მხოლოდ მაშინ, როდესაც იგი არ იყენებს კლასის სხვა არასტატიკურ მეთოდებს.

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

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

შეგვიძლია ვთქვათ, რომ კლასის თვისება უნდა იყოს სტატიკური იმ შემთხვევაში თუ მოსალოდნელ არაა მისი ცვლილება, მაგალითად სრულწლოვალების ასაკი მომხმარებლებისათვის, როგორც ვიცით ეს ასაკია 18 წელი : 
Class User
{
    public static $adult_age = 18;
}

echo User::$adult_age;
9. კონსტანტები
ცვლადების მსგავსად კონსტანტებიც გამოიყენება ინფორმაციის შესანახად, ცვლადებისგან განსხვავებით კონსტანტის გამოცხადებისას ან გამოძახებისას არ გამოიყენება "$" ნიშანი, კონსტანტების თვალთახედვის არე, ნაგულისმეობის პრინციპით არის public. კონსტანტის მნიშვნელობა უნდა იყოს უცვლელი გამოსახულება, მას შემდეგ რაც კლასში მოხდება კონსტანტის აღწერა, ამ კლასის ეგზემპლიარი ობიექტების შექმნისას აღარაა საჭირო კონსტანტის თავიდან აღწერა. კონსტანტის აღწერა ხდება სიტყვა გასაღებ const-ის დახმარებით 
<?php
  class MyClass
  {
      const CONSTANT = 'значение константы';

      function showConstant() {
          echo  self::CONSTANT . "\n";
      }
  }

  echo MyClass::CONSTANT . "\n";

  $classname = "MyClass";
  echo $classname::CONSTANT . "\n";

  $class = new MyClass();
  $class->showConstant();

  echo $class::CONSTANT."\n";
?>
10. აბსტრაქტული კლასები
კლასი რომელიც შეიცავს თუნდაც ერთ აბსტრაქტულ მეთოდს, უნდა აღიწეროს როგორც აბსტრაქტული კლასი, შეუძლებელია აბსტრაქტული კლასის ეგზემპლიარი ობიექტების შექმნა. აბსტრაქტული კლასის მემკვიდრე კლასის შექმნისას მშობელ კლასში აღწერილი ყველა მეთოდი თავიდან უნდა აღიწეროს შვილობილ კლასშიც, გასათვალისწინებელია ის ფაქტი რომ მშობელ და შვილობილ კლასში აღწერილი მეთოდების თვალთახედვის არეები ან უნდა ემთხვეოდეს ერთმანეთს ან შვილობილ კლასის მეთოდების თვალთახედვის არეები უნდა იყოს ნაკლებად მკაცრი. მაგალითად თუ აბსტრაქტულ კლასში აღწერილი მეთოდი არის protected, მაშინ შვილობილ კლასში იგივე მეთოდი შეიძლება აღიწეროს როგორც protected ან public, მაგრამ არავითარ შემთხვევაში private.

აბსტრაქტული კლასის და ამ კლასის აბსტრაქტული მეთოდების განსაზღვრა ხდება სიტყვაგასაღებ abstract-ის საშუალებით : 

<?php

abstract Class User
{
    public $name;
    public $status;

    abstract public function getStatus();
}

class Admin extends User
{
    public function getStatus()
    {
        echo "Admin";
    }
}

$user = new Admin;
$user->getStatus();

?>
აბსტრაქტული მეთოდი შეიძლება შეიცავდეს მხოლოდ დასახელებასა და არგუმენტებს. მათში არავითარი ინსტრუქციის მითითება არ ხდება. აბსტრაქტულ კლასებს და მეთოდებს ვიყენებთ მაშინ, როდესაც შვილობილ კლასებს მემკვიდრეობით უნდა გადავცეთ ესა თუ ის მეთოდი, მაგრამ არ შეგვიძლია ზუსტი კოდის დაფიქსირება, რომელიც ამ მეთოდში უნდა ჩავწეროთ. ანუ შვილობილ კლასებს ეძლევათ ეს მეთოდი და უკვე შვილობილ კლასებში ხდება მეთოდის კოდის, ინსტრუქციის მითითება.
11. ინტერფეისი (Interface)
ინტერფეისი არის სტრუქტურა, შაბლონი რომელშიც განსაზღვრულია თუ რა მეთოდებსა და თვისებებს უნდა შეიცავდეს კლასი, ინტერფეისი არ უნდა შეიცავდეს მეთოდთა რეალიზაციას, ანუ მასში შესაძლებელია მხოლოდ მეთოდის გამოცხადება და არა მეთოდის მთლიანი ტანის აღწერა. ინტერფეისის აღწერა ხდება სირტყვა გასაღებ interface-ის მეშვეობით. ინტერფეისში აღწერილი ყველა მეთოდის თვალთახედვის არე უნდა იყოს public. ინტერფეისის მიხედვით კლასის შესაქმნელად გამოიყენება სიტყვა გასაღები implements. ინტერფეისის მიხედვით შექმნილ კლასში აუცილებლად უნდა მოხდეს თავად ინტერფეისში გამოცხადებული ყველა მეთოდის რეალიზაცია. შესაძლებელია კლასის შექმნა რამოდენიმე ინტერფეისის მიხედვით ერთდროულად. აგრეთვე შესაძლებელია ინტერფეისების შექმნა მემკვიდრეობითობის პრინციპით (extends). 
<?php

// პირველი ინტერფეისი
interface first
{
    public function getName();
}

// მეორე ინტერფეისი
interface second
{
    public function getStatus();
}

// მესამე ინტერფეისი, წინა ორის მემკვიდრე
interface third extends first, second
{

}

// კლასის შექმნა ინტერფეისების მიხედვით
class Test implements third 
{
    public $name = "ვასო";
    public $status = "Admin";

    public function getName()
    {
        echo $this->name;
    }

    public function getStatus()
    {
        echo $this->status;
    }
}

$user1 = new Test;
$user1->getName(); // ვასო
$user1->getStatus(); // Admin

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

index.php 
include "file1.php";
include "file2.php";

foo();
file1.php 
function foo()
{
    echo "გამარჯობა";
}
file2.php 
function foo()
{
    echo "მსოფლიოვ";
}
ამ შემთხვევაში index.php ფაილის გაშვებისას დაფიქსირდება შეცდომა : Fatal error: Cannot redeclare foo() (previously declared in ... შეცდომა გვატყობინებს, რომ არ შეიძლება ორ სხვადასხვა ფუნქციას გააჩნდეს ერთი სახელი (ამ შემთხვევაში 'foo'). ამ პრობლემის მოსაგვარებლად გამოიყენება სახელსივრცე და მისი განსაზღვრა ხდება სიტყვაგასაღებ - namespace-ს დახმარებით, ზემოთ მოყვანილ ფაილებს განვუსაზღვროთ სახელსივრცეები :

file1.php 
<?php

namespace File1;

function foo()
{
    echo "გამარჯობა";
}

?>
file2.php 
<?php

namespace File2;

function foo()
{
    echo "მსოფლიოვ";
}

?>
ახლა უკვე პირველი foo() ფუნქცია ეკუთვნის სივრცეს რომლის სახელიცაა File1, ხოლო მეორე foo() ფუნქცია ეკუთვნის სივრცეს რომლის სახელიცაა - File2, აქედან გამომდინარე აღარ მოხდება დასახელებათა კონფლიქტი, მაგრამ დაფიქსირდება შემდეგი შეცდომა : Fatal error: Call to undefined function foo() in ... ეს ნიშნავს რომ სახელის გლობალური სივრციდან ვიძახებთ foo() ფუნქციას, რომელიც აღწერილი არ არის. ჩავასწოროთ index.php ფაილი, იგი გადავაკეთებთ შემდეგნაირად : 
<?php

include "file1.php";
include "file2.php";

file1\foo();
file2\foo();

/*
  შედეგი იქნება გამარჯობა 'გამარჯობა მსოფლიოვ'
*/

?>
ანუ foo() ფუნქციას განვუსაზღვრეთ სახელის სივრცეები.
13. ტრეიტი (Trait)
ინგ: Trait - მახასიათებელი, ნიშან-თვისება, თვისება, ატრიბუტი.

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

ტრეიტის აღწერა ხდება სიტყვაგასაღებ - trait-ის მეშვეობით : 

<?php

trait TraitName 
{
    // კოდი ...
}
კონკრეტულ კლასთან კონკრეტული ტრეიტის დაკავშირება კი ხდება სიტყვაგასაღებ - use-ის მეშვეობით : 
<?php

class MyClass 
{
    use TraitName;
}
კონკრეტული მაგალითი : 
<?php

trait message1 
{
    public function msg1() 
    {
        echo "ძირს COVID-19";
    }
}

class covid
{
    use message1;
}

$obj = new covid();
$obj->msg1();
როგორც ვხედავთ საჭირო აღარაა msg1() მეთოდის ხელახლი აღწერა covid კლასში, რადგან იგი უკვე აღწერილია ტრეიტში.

შესაძლებელია, რომ ერთი კლასი დაკავშირდეს, რამოდენიმე ტრეიტთან ერთდროულად: 

trait message1 
{
    public function msg1() 
    {
        echo "ძირს COVID-19";
    }
}

trait message2
{
    public function msg2() 
    {
        echo "ძირს კარანტინი";
    }
}

class covid
{
    use message1, message2;
}

$obj = new covid();

$obj->msg1();
$obj->msg2();


ოოპ PHP CMS



1. PHP CMS
ოოპ php-ის დახმარებით შევქმნათ დაახლოებით ამდაგვარი გვერდი



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

შევქმნათ მონაცემთა ბაზა და დავარქვათ სახელი minicms, მასში გავაკეთოთ შემდეგი ცხრილები

menu

ცხრილი მენიუს პუნქტებისათვის

category

ცხრილი კატეგორიებისათვის

articles

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

პროექტის იერარქიული სისტემა

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



კონფიგურაცია

პროექტის ძირ საქაღალდეში შევქმნათ ფაილი config.php, სადაც აღიწერება ძირითადი კონფიგურაციული პარამეტრები, პირველ რიგში განვსაზღვროთ მბ-სთან დასაკავშირებელი კონსტანტები 
<?php
    define("HOST","localhost");
    define("USER","root");
    define("PASSWORD","root");
    define("DB","minicms");
?>

სისტემის მუშაობის სქემა

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



რაც შეეხება ფაილს - index.php, ეს ფაილი იქნება გვერდზე შესასვლელი ერთადერთი წერტილი, ამ გვერდის კოდში აღწერილმა ლოგიკამ უნდა გადაწყვიტოს თუ რომელი კლასი გამოიძახოს და შესაბამისად რა ჩაიტვირთოს მთავარ გვერდზე, ლოგიკას ინფორმაცია კი უნდა მივაწოდოთ GET მეთოდის პარამეტრით რომელსაც დავარქვათ page. მაგალითად თუ მიმდინარე URL იქნება http://localhost/cms/index.php?page=main უნდა ჩაიტვირთოს გვერდი "მთავარი" და ა.შ. აღვწეროთ GET პარამეტრის დამუშავების ლოგიკა : 
<?php
    require_once("config.php");
    require_once("classes/ACore.php");

    if(isset($_GET['page']))
    {
        $class = $_GET['page'];
    }
    else
    {
        $class = "main";
    }

    // შემოწმდეს არსებობს თუ არა GET პარამეტრის შესაბამისი ფაილი classes საქაღალდეში
    if(file_exists("classes/".$class.".php"))
    {
        include("classes/".$class.".php");

        // შემოწმდეს არსებობს თუ არა GET პარამეტრის შესაბამისი კლასი შესაბამის ფაილში
        if(class_exists($class))
        {
            // თუ არსებობს შესაბამისი კლასი, შეიქმნას მისი ეგზემპლიარი
            $obj = new $class;

            // მეთოდი რომელიც უზრუნველყოფს გვერდის შიგთავსის გამოტანას
            $obj->get_body();
        }
        else
        {
            exit("არასწორი მონაცემი");
        }
    }
    else
    {
        exit("არასწორი მისამართი");
    }
?>
ACore.php ფაილი ამ მომენტისათვის: 
<?php
    abstract class ACore
    {
        public function get_body()
        {
            echo "გამარჯობა !";
        }
    }
?>
პარალელურად classes საქაღალდეში უნდა შეიქმნას Main.php ფაილი, რომელშიც აღიწერება მთავარი გვერდის ჩამტვირთველი კლასი : 
<?php
    class Main extends ACore
    {

    }
?>
თუ ამ მომენტისათვის გავხსნით მთავარ გვერდს, ბრაუზერში გამოჩნდება გამარჯობა !

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

როგორც დასაწყისში აღვნიშნეთ, შექმნილი გვაქვს მონაცემთა ბაზა. ჩვენს ვებ-გვერდზე არის ისეთი ქვე-გვერდები რომლებზეც სწორედ ბაზიდან წამოღებული ინფორმაცია უნდა განთავსდეს, ისმის კითხვა : სად მოვახდინოთ ბაზასთან დაკავშირება ? პასუხი ასეთია : შესაძლებელია ეს გავაკეთოთ ყველა ისეთი გვერდისათვის ცალ-ცალკე, რომლბსაც მბ-სთან დაკავშირება სჭირდებათ, მაგრამ უმჯობესია თუ ბასათან დაკვშირების ინსტრუქციას აღვწერთ ძირითად კლას ACore-ში რადგან მისი მეთოდები მემკვიდრეობით გადაეცემა მის ყველა შვილობილ კლასს და ამიტომ ცალ-ცალკე წერა აღარ მოგვიწევს. ACore კლასში შევქმნათ მბ-სთან დამაკავშირებელი ფუნქცია კონსტრუქტორი, რომელშიც გამოვიყენებთ config.php ფაილში აღწერილ კონსტანტებს : 
<?php
    abstract class ACore
    {
        protected $con;

        public function __construct()
        {
            $this->con = mysqli_connect(HOST,USER,PASSWORD,DB);

            if(!$this->con)
            {
                exit("ვერ მოხერხდა ბაზასთან დაკავშირება");
            }
            else
            {
                mysqli_query($this->con,"SET NAMES 'UTF8'");
            }
        }

        public function get_body()
        {
            echo "გამარჯობა !";
        }
    }
?>
ბაზასთან დავკავშირდით !

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



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

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



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

საიტის ქუდი

დავიწყოთ საიტის ქუდით, ACore კლასში აღვწეროთ შესაბამისი მეთოდი get_header. თუმცა მანამდე პროექტის ძირ საქაღალდეში შევქმნათ ფაილი header.php, სადაც მოვათავსებთ გამზადებული შაბლონის კოდიდან ამოჭრილ, საიტის ქუდის კოდს : 
<!DOCTYPE html>
<html>
<head>
    <title>ოოპ PHP</title>
    <meta http-equiv="content-type" content="text/html;charset=utf-8" />
    <link rel="stylesheet" href="css/styl.css" type="text/css" />
</head>
<body>
    <div id="container">
        <div id="header">
            <h3>CompanyName</h3>
        </div>
ახლა შევქმნათ get_header მეთოდი ACore კლასში : 
<?php
    abstract class ACore
    {
        protected $con;

        public function __construct()
        {
            $this->con = mysqli_connect(HOST,USER,PASSWORD,DB);
      
            if(!$this->con)
            {
                exit("ვერ მოხერხდა ბაზასთან დაკავშირება");
            }
            else
            {
                mysqli_query($this->con,"SET NAMES 'UTF8'");
            }
        }

        protected function get_header()
        {
            include("header.php");
        }

        public function get_body(
        {
            $this->get_header();
        }
    }
?>
ახლა სკრიპტს მივყვეთ ნაბი-ნაბიჯ: ვებ-გვერდზე შესვლისას index.php ფაილის $obj = new $class; ჩანაწერით იქმნება შესაბამისი გვერდის გაშვებაზე პასუხისმგებელი კლასის ობიექტი.

შემდეგ $obj->get_body(); ჩანაწერით ხდება ამ ობიექტის get_body() მეთოდის გამოძახება, ეს მეთოდი მიმდინარე კლასს მემკვიდრეობითად ერგო ACore კლასიდან.

ACore კლასში აღწერილი get_body() მეთოდი კი პირველი რასაც აკეთებს, ესაა, რომ იძახებს get_header() მეთოდს. get_header() მეთოდი კი ითხოვს ფაილს header.php, ასე და ამგვარად შედეგად მიიღება შემდეგი სურათი :



გვერდითი მენიუ

ახლა გამოვიტანოთ გვერდითი მენიუ. ამ შემთხვევაში დაგვჭირდება მბ-სთან დაკავშირებაც რადგან კატეგორიების დასახელებები უნდა წამოვიღოთ მბ-ს ცხრილიდან category. ამ განყოფილებაში აგრეთვე შედის სტატიკური მენიუც (მთავარი, ჩვენს შესახებ, კონტაქტი), რომელსაც ასევე ცალკე left_static_menu.php ფაილში გავიტანთ 
<div id="sidebar">
    <ul>
        <li><a href="?page=main">მთავარი</a></li>
        <li><a href="?page=menu&menu_id=1">ჩვენს შესახებ</a></li>
        <li><a href="?page=menu&menu_id=2">კონტაქტი</a></li>
    </ul>
    <hr/>
ACore კლასში შევქმნათ მარცხენა მენიუს გამოსატანი მეთოდი get_left_bar() : 
<?php
    abstract class ACore
    {
        protected $con;

        public function __construct()
        {
            $this->con = mysqli_connect(HOST,USER,PASSWORD,DB);
      
            if(!$this->con)
            {
                exit("ვერ მოხერხდა ბაზასთან დაკავშირება");
            }
            else
            {
                mysqli_query($this->con,"SET NAMES 'UTF8'");
            }
        }

        protected function get_header()
        {
            include("header.php");
        }

        protected function get_left_bar()
        {
            include("left_static_menu.php");

            $query = "SELECT id,title FROM category";
            $result = mysqli_query($this->con,$query);

            echo "<ul>";
                while($row = mysqli_fetch_assoc($result))
                {
                    echo "<li><a href='?page=category&cat_id=".$row['id']."'>".$row['title']."</a></li>";
                }
            echo "</ul>
            </div>";
        }

        public function get_body()
        {
            $this->get_header();
            $this->get_left_bar();
        }
    }
?>
get_left_bar მეთოდში აღწერილი ინსტრუქციები მოგვცემს სტატიკური და დინამიური მენიუების გაერთიანებას, რომელსაც HTML თვალსაზრისით ენება ასეთი სახე :



ამ ყველაფრის შედეგი იქნება



ძირითადი შიგთავსი

როგორც ვთქვით ძირითადი შიგთავსი ცვალებადია ყველა ქვე-გვერდისათვის და მისი გამოტანის მეთოდი get_content() ცალ-ცალკე უნდა აღიწეროს ACore კლასის შვილობილ კლასებში. ამჯერად გვაქვს მხოლოდ ერთი შვილობილი კლასი main, დავიწყოთ მისგან. პირველ რიგში ACore კლასის get_body() მეთოდში ჩავამატოთ აბსტრაქტული მეთოდი get_content(). როგორც ვიცით აბსტრაქტულ მეთოდებს არ აქვთ ტანი, მათში არ არის რაიმე ინსტრუქცია აღწერილი და ეს მეთოდები აუცილებლად უნდა აღიწეროს ინსტრუქციიანად კლასის შვილობილ კლასებში : 
public function get_body()
{
    $this->get_header();
    $this->get_left_bar();
    $this->get_content();
}

abstract function get_content();
ახლა ეს აბსტრაქტული მეთოდი დავამუშავოთ შვილობილ კლასში - Main : 
<?php
    class Main extends ACore
    {
        public function get_content()
        {
            echo "<div id='content'>";
            echo "<p>
               Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod
               tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam,
               quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo
            </p>";
            echo "</div>";
        }
    }
?>
ანუ მთავარი გვერდისათვის განვსაზღვრეთ შიგთავსი.

საიტის ძირი

ახლა დავამატოთ საიტის ძირი ზუსტად ისევე როგორც დავამატეთ საიტის ქუდი, ანუ შევქმნათ ფაილი footer.php და მასში მოვათავსოთ საიტის ძირის განმსაზღვრელი HTML ტეგები : 
    <div id="footer">
         Copyright © 2005 | All Rights Reserved
    </div>

  </div>
  <!-- container-ის დასასრული-->

</body>

</html>
ახლა ACore კლასში დავამატოთ შესაბამისი მეთოდი get_footer() : 
<?php
    abstract class ACore
    {
        protected $con;

        public function __construct()
        {
            $this->con = mysqli_connect(HOST,USER,PASSWORD,DB);
      
            if(!$this->con)
            {
                exit("ვერ მოხერხდა ბაზასთან დაკავშირება");
            }
            else
            {
                mysqli_query($this->con,"SET NAMES 'UTF8'");
            }
        }

        protected function get_header()
        {
            include("header.php");
        }

        protected function get_left_bar()
        {
            include("left_static_menu.php");

            $query = "SELECT id,title FROM category";
            $result = mysqli_query($this->con,$query);

            echo "<ul>";
                while($row = mysqli_fetch_assoc($result))
                {
                    echo "<li><a href='?page=category&cat_id=".$row['id']."'>".$row['title']."</a></li>";
                }
            echo "</ul>
            </div>";
        }

        public function get_body()
        {
            $this->get_header();
            $this->get_left_bar();
        }

        protected function get_footer()
        {
            include("footer.php");
        }

        abstract function get_content();
    }
?>
ამ ყველაფრის შედეგი იქნება :



სტატიები ვებ-გვერდის მთავარ გვერდზე

როგორც ვიცით მბ-ში გვაქვს ცხრილი articles, რომელშიც მოთავსებულია რამოდენიმე სტატია, Main კლასის get_content() მეთოდი, რომელშიც ამჟამად სტატიკური ტექსტი გვაქვს (Lorem ipsum ...), გადავაკეთოთ ასე : 
<?php
    class Main extends ACore
    {
        public function get_content()
        {
            $query = "SELECT id,title,date,description,img_src FROM articles ORDER BY date DESC";
            $result = mysqli_query($this->con,$query);

            echo "<div id='content'>";

            while($row = mysqli_fetch_assoc($result))
            {
                echo "<div class='article'>
                        <h3>".$row['title']."</h3>
                        <h4>".$row['date']."</h4>
                        <img src='".$row['img_src']."' alt=''>
                         <p>
                           ".$row['description']."
                           <a href='?page=view&art_id=".$row['id']."'>სრულად</a>
                         </p>
                     </div>";
            }

            echo "</div>";
        }
    }
?>
შედეგი იქნება :



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

სიახლეების განყოფილებაში ბმულის href ატრიბუტს თუ დავაკვირდებით შევამჩნევთ, რომ GET პარამეტრის მნიშვნელობად მითითებულია view, ანუ უნდა შევქმნათ ახალი ფაილი view.php და მასში აღვწეროთ ACore კლასის კიდევ ერთი შვილობილი კლასი - View, რომელიც უზრუნველყოფს მთავარ გვერდზე ცალკეული სტატიების სრულად გამოტანას : 
<?php
    class View extends ACore
    {
        public function get_content()
        {
            if(!$_GET['art_id'])
            {
                exit("არასწორი ინფორმაცია სტატიისათვის");
            }
            else
            {
                $art_id = (int)$_GET['art_id'];
                $query = "SELECT title,date,img_src,text FROM articles WHERE id='$art_id'";
                $result = mysqli_query($this->con,$query);
                $row = mysqli_fetch_assoc($result);

                echo "<div id='content'>";
                         echo "<div class='article'>
                                   <h3>".$row['title']."</h3>
                                   <h4>".$row['date']."</h4>
                                   <img src='".$row['img_src']."' alt=''>
                                   <p>".$row['text']."</p>
                              </div>";
                echo "</div>";
            }
        }
    }
?>
შედეგი იქნება :



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

მარცხენა მენიუში განთავსებულ კატეგორიების ბმულების href ატრიბუტებს თუ დავაკვირდებით შევამჩნევთ რომ GET პარამეტრის მნიშვნელობად მითითებულია category, ანუ უნდა შევქმნათ ახალი ფაილი category.php და მასში აღვწეროთ ACore კლასის კიდევ ერთი შვილობილი კლასი category, რომელიც უზრუნველყოფს მთავარ გვერდზე სტატიების გამოტანას კატეგორიების მიხედვით : 
<?php
    class Category extends ACore
    {
        public function get_content()
        {
            if(!$_GET['cat_id'])
            {
                exit("არასწორი ინფორმაცია კატეგორიისათვის");
            }
            else
            {
                $cat_id = $_GET['cat_id'];
                $query = "SELECT id,title,date,description,img_src FROM articles WHERE cat='$cat_id'";
                $result = mysqli_query($this->con,$query);

                echo "<div id='content'>";
                        while($row = mysqli_fetch_assoc($result))
                        {
                            echo "<div class='article'>
                                   <h3>".$row['title']."</h3>
                                   <h4>".$row['date']."</h4>
                                   <img src='".$row['img_src']."' alt=''>
                                   <p>
                                     ".$row['description']."
                                     <a href='?page=view&art_id=".$row['id']."'>სრულად</a>
                                   </p>
                                 </div>";
                        }
                echo "</div>";
            }
        }
    }
?>
OOP PHP CMS გადმოწერა