გადმოწერა

1. რა არის PHP ?

რა არის PHP ?

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

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

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-ის მხარდაჭერა.
  • ჯერ დავაინსტალიროთ ვებ-სერვერი ჩვენს PC-ში, შემდეგ კი 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-ში წარმოადგენენ ჩანაწერებს, რომლებიც არ განიხილება, როგორც პროგრამის ნაწილი. კომენტარები გამოიყენება შემდეგი მიზნით:
  • გაარკვიონ სხვებმა თუ რას ვაკეთებთ კოდში
  • გავარკვიოთ ჩვენვე თუ რა გავაკეთეთ რადგან კოდის დაწერიდან რამდენიმე წლის შემდეგ რთულია ზუსტად გვახსოვდეს თუ რას აკეთებს კოდის თითოეული ფრაგმენტი.
<?php
    // ერთხაზიანი კომენტარი
    #ერთხაზიანი კომენტარი
    /*
    რამდენიმეხაზიანი კომენტარი
    შეიცავს სხვადასხვა ხაზებზე განთავსებულ რამდენიმე ჩანაწერს
    */
?>

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

ერთი და იმავე შედეგს მოგვცემს შემდეგ მაგალითში მოყვანილი სამივე ჩანაწერი <?php
    ECHO "Hello World!<br>";
    echo "Hello World!<br>";
    EcHo "Hello World!<br>";
?>
ქვემოთ მოყვანილ მაგალითში მხოლოდ პირველი "echo" ჩანაწერი იმუშავებს სწორად <?php
    $color = "red";
    echo "My car is " . $color . "<br>";
    echo "My house is " . $COLOR . " <br>";
    echo "My boat is " . $coLOR . "<br>";
?>
3. ცვლადები

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

PHP-ში ცვლადის სახელს წინ ერთვის სიმბოლო <?php
    $txt = "Hello world!";
    $x = 5;
    $y = 10.5;
?>
პროგრამირების სხვა ენებისაგან განსხვავებით PHP-ში არ გვხვდება ცვლადთა გამოცხადების ბრძანებები, ცვლადი იქმნება მაშინ, როდესაც პირველად ავკრეფთ მის დასახელებას.

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

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

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

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

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

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

Global და Local თვალთახედვა

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

function myTest() {
    // x ცვლადის ფუნქციაში გამოყენება გამოიწვეწვს შეცდომას
    echo "<p>Variable x inside function is: $x</p>";
}
myTest();

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

// x ცვლადის ფუნქციის გარეთ გამოყენება გამოიწვეწვს შეცდომას echo "<p>Variable x outside function is: $x</p>";

სიტყვა გასაღები 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 ჩანაწერის გამოყენება შესაძლებელია ფრჩხილებითაც და მათ გარეშეც - echo ან echo(). echo-სთვის პარამეტრად გადაცემული ტექსტი შეიძლება შეიცავდეს html ნიშნებს echo "<h2>PHP is Fun!</h2>";
echo "Hello world!<br>";
echo "I'm about to learn PHP!<br>";
echo "This ", "string ", "was ", "made ", "with multiple parameters.";

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

$txt1 = "Learn PHP";
$txt2 = "W3Schools.com";
$x = 5;
$y = 4;

echo "<h2>$txt1</h2>";
echo "Study PHP at $txt2<br>";
echo $x + $y;

print ჩანაწერი

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

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

print "<h2>PHP is Fun!</h2>";
print "Hello world!<br>";
print "I'm about to learn PHP!";

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

$txt1 = "Learn PHP";
$txt2 = "W3Schools.com";
$x = 5;
$y = 4;

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

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

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

მთელი ტიპი

მონაცემთა მთელი ტიპი არის არა მცოცამძიმიანი რიცხვები -2,147,483,648-სა და 2,147,483,647-ს შორის. (2,147,483,647 =231 − 1. ეს რიცხვი არის ერთ-ერთი იმ ოთხი ცნობილი მარტივი რიცხვიდან, რომლებიც მიიღება 2-ის რომელიღაც ხარისხში აყვანის შედეგზე ერთის გამოკლებით 2n − 1 და არის უდიდესი მნიშვნელობა, რომელიც შეიძლება ჩაიწეროს 32 ბიტიან ორობით კოდში). მთელი ტიპის ცვლადი
  • უნდა შეწიცავდეს ერთ ციფრს მაინც
  • არ უნდა შეიცავდეს მცოცავ მძიმეს
  • შეიძლება იყოს დადებითიც და უარყოფითიც
მოყვანილ მაგალითში $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 = "VW";
    }
}

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

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

NULL

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

strlen()

სტრიქონის სიგრძის გაგება echo strlen("Hello world!"); // შედეგი იქნება 12

str_word_count()

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

strrev()

სტრიქონის შებრუნება echo strrev("Hello world!"); // შედეგი იქნება !dlrow olleH

strpos()

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

explode()

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

implode()

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

lcfirst()

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

levenshtein()

levenshtein() ფუნქცია აბრუნებს ორ სტრიქონს შორის არსებულ ე.წ ლევენშტეინის მანძილს. ლევენშტეინის მანძილი არის სიმბოლოთა რაოდენობა რომლებიც უნდა წავშალოთ ან ჩავანაცვლოთ ან ჩავსვათ $string1 სტრიქონში რათა მივიღოთ $string2 სტრიქონი. ეს ფუნქცია არ არის რეგისტრზე დამოკიდებული. სინტაქსი ასეთია levenshtein(string1,string2,insert,replace,delete)
  • string1 - აუცილებელია მითითება. პირველი სტრიქონი.
  • string1 - აუცილებელია მითითება. მეორე სტრიქონი.
  • insert - არააუცილებელია მითითება. სიმბოლოს ჩასმის წილი, წონა საერთო ჯამში. გაჩუმების პრინციპით არის 1.
  • replace - არააუცილებელია მითითება. სიმბოლოს ჩანაცვლების წილი, წონა საერთო ჯამში. გაჩუმების პრინციპით არის 1.
  • delete - არააუცილებელია მითითება. სიმბოლოს წაშლის წილი, წონა საერთო ჯამში. გაჩუმების პრინციპით არის 1.
echo levenshtein("Hello World","ello World",10,20,30); // 30

md5()

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

str_ireplace()

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

str_repeat()

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

strcasecmp()

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

strip_tags()

strip_tags() funqcia asufTavebs striqons HTML, XML, da PHP ტეგებისაგან. სინტაქსი ასეთია strip_tags(string,allow) // allow პარამეტრად მითითებული ტეგები არ წაიშლება echo strip_tags("Hello < i>world!< /i>"); // შედეგი იქნება Hello world! და არა Hello world!

substr()

substr() ფუნქცია აბრუნებს სტრიქონის ნაწილს. სინტაქსი ასეთია substr(string,start,length)
  • string - აუცილებელია მითითება. მიუთითებს სტრიქონს რომლის ნაწილის დაბრუნებაც გვინდა
  • start - აუცილებელია მითითება. მიუთითებს თუ რომელი პოზიციიდან გვინდა ამოჭრა. თუ დადებითი რიცხვია მაშინ ამოჭრას დაიწყებს ამ რიცხის ტოლი პოზიციიდან, თუ უარყოფითი რიცხვია მაშინ ამოჭრას დაიწყებს სტრიქონის ბოლოდან, ხოლო თუ ნოლია მაშინ სტრიქონის დასაწყისიდან.
  • length - აუცილებელია მითითება. მიუთითებს თუ რამდენი სიმბოლოს ამოჭრა გვინდა
7. კონსტანტები
კონსტანტა თავისი შინაარსით წააგავს ცვლად, უბრალოდ მათ შორის ის განსხვავებაა, რომ როდესაც კონსტანტა განისაზღვრება შემდეგ შეუძლებელია მისი მნიშვნელობის შეცვლა. კონსტანტის დასახელება იწყება ლათინური ანბანის ასოთი ან ქვედა ხაზით. ($ ნიშანი არ გამოიყენება). ცვლადებისაგან განსხვავებით კონსტანტა გამოცხადებისთანავე გლობალურია მთლიანი სკრიპტის მასშტაბით. კონსტანტის შესაქმნელად გამოიყენება define() ფუნქცია, შექმნის სინტაქსი ასეთია define(name, value, case-insensitive)
  • name - განსაზღრავს კონსტანტის სახელს.
  • value - განსაზღრავს კონსტანტის მნიშვნელობას.
  • case-insensitive - განსაზღვრავს იყოს თუ არა კონსტანტის დასახელება რეგისტრზე დამოკიდებული, ნაგულისმეობის პრინციპით არის false.
რეგისტრის მიმართ მგრძნობიარე კონსტანტის შექმნის მაგალითი define("GREETING", "Welcome to W3Schools.com!", true);
echo greeting;

defined() ფუნქცია

defined() ფუნქცია ამონწმებს უკვე შექმნილია თუ არა ესა თუ ის კონსტანტა. <?php
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 (პირობა) {
    კოდი შესრულდება თუ პირობა ჭეშმარიტია;
}
if...else ჩანაწერის სინტაქსი if (პირობა) {
    კოდი შესრულდება თუ პირობა ჭეშმარიტია;
} else {
    კოდი შესრულდება თუ პირობა მცდარია;
}
if...elseif....else ჩანაწერის სინტაქსი if (პირობა) {
    კოდი შესრულდება თუ ეს პირობაა ჭეშმარიტი;
} elseif (პირობა) {
    კოდი შესრულდება თუ ეს პირობაა ჭეშმარიტი;
} else {     კოდი შესრულდება თუ ორივე პირობა მცდარია;
}
10. switch ჩანაწერი
switch ჩანაწერი გამოიყენება რამდენიმე ბლოკიდან ერთის ამორჩევისა და შესრულებისათვის. switch (n) {
    case label1:
       კოდი შესრულდება თუ n=label1;
       break;
    case label2:
       კოდი შესრულდება თუ n=label2;
       break;
    case label3:
       კოდი შესრულდება თუ n=label3;
       break;
    ...
    default:
       კოდი შესრულდება თუ n != არც ერთ ზემოთა ვარიანტს;
}
11. ციკლები
კოდის წერისას ხშირია შემთხვევები, როდესაც საჭიროა ერთი და იგივე ბლოკის რამოდენიმეჯერ შესრულება. ამისათვის გამოიყენება ციკლები. PHP ში არსებობს შემდეგი სახის ციკლები
  • while - ციკლი არის ასე ვთქვათ წინაპირობითი, პრეპირობითი ანუ ციკლში პირობის შემოწმება/შესრულება ხდება ციკლის გამოძახებამდე , ციკლის ტანის შესრულებამდე გამოითვლება ლოგიკური პირობის მნიშვნელობა, თუ პირობა ჭერშმარიტია მაშინ ციკლიც სრულდება, ამის შემდეგ ისევ მოწმდება პირობა, ციკლი მეორდება მანამ სანამ პირობა არის true.
  • do...while - ციკლი while - საგან განსხვავეიბით არის პოსტპირობითი ანუ ციკლის გაგრძელების ლოგიკური პირობა იწერება ციკლის ტანის შემდეგ. ციკლის ტანში აღწერილი მოქმედება მინიმუმ ერთხელ სრულდება და ამის შემდეგ მოწმდება ციკლის გაგრძელების პირობა, თუ იგი ჭეშმარიტია ანუ true, მაშინ ციკლი კიდევ სრულდება.
  • for - ციკლის ეს ოპერატორი თავის თავში მოიცავს ცვლადს, ე.წ ციკლის პარამეტრს ან ციკლის მთვლელს. ციკლი იწყება სიტყვა გასარებით for შემდეგ ფრჩხილებში იწერება კონსტრუქცია, რომელიც მოიცავს ციკლის პარამეტრის ინიციალიზაციას, ლოგიკურ გამოსახულებას და ამ პარამეტრის მოდიფიკაციის ანუ ცვლილების ჩანაწერს.
  • foreach - ბლოკში აღწერილ ქმედებებს ასრულებს მასივის თითოეული ელემენტისათვი.ს

while ციკლი

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

ციკლის სინტაქსი ასეთია while (პირობა ჭეშმარიტია) {
   შესასრულებელი ინსტრუქცია;
}
<?php
   $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 Refsnes.<br>";
}

familyName("Jani");
familyName("Hege");
იმისათვის რათა ფუნქციამ დააბრუნოს რაიმე შედეგი, გამოიყენება return ჩანაწერი function sum($x, $y) {
    $z = $x + $y;
    return $z;
}
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 "Key=" . $x . ", Value=" . $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].": In stock: ".$cars[0][1].", sold: ".$cars[0][2].".<br>"; მასივის მთლიანად დასათვალიერებლად კი უნდა გამოვიყენოთ for ციკლში შაშენებული კიდევ ერთი for ციკლი for ($row = 0; $row < 4; $row++) {
    echo "<p><b>Row number $row</b></p>";
    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()

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

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 $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', 'id');
print_r($last_names);
შედეგი იქნება Array
    (
    [5698] => Griffin
    [4767] => Smith
    [3809] => Doe
    )

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

<?php
if ($_SERVER["REQUEST_METHOD"] == "POST") {
   // collect value of input field
   $name = $_REQUEST['fname'];
   if (empty($name)) {
       echo "Name is empty";
   } else {
       echo $name;
   }
}
?>
if ($_SERVER["REQUEST_METHOD"] == "POST") ამ პირობის მითითების გარეშე მიმდინარე გვერდზე შემოსვლისას დაფიქსირდებოდა შემდეგი შეცდომა : "Notice: Undefined index: fname in ..... on line x" რაც ნიშნავს რომ სკრიპტისთვის გაურკვეველია fname ცვლადის მნიშვნელობა და ეს ლოგიკურიცაა რადგან გვერდზე შენოსვლისას რა თქმა უნდა ავტომატურად ვერ დაეჭირება submit ღილაკს => არ არსებობს მოთხოვნა სერვერზე => არ არსებობს POST ტიპის მოთხოვნა => არ არსებობს $name.

$_POST

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

<?php
if ($_SERVER["REQUEST_METHOD"] == "POST") {
   // collect value of input field
   $name = $_POST['fname'];
   if (empty($name)) {
       echo "Name is empty";
   } else {
       echo $name;
   }
}
?>

$_GET

$_GET მეთოდი ხშირად გამოიყენება HTML-ფორმის (method = "GET") გაგზავნის შემდეგ აკრეფილი ინფორმაცის შესაკრებად. $_GET მეთოდს აგრეთვე შეუძლია ინფორმაციის მიღება URL-დან. ვთქვათ გვაქვს ასეთი სახის ბმული : < a href="test_get.php?subject=PHP&web=W3schools.com">Test $GET< /a> როდესაც მომხმარებელი დააწვება ამ ბმულს, პარამეტრები "subject" და "web" გაიგზავნება "test_get.php" გვერდზე, მათი მნიშვნელობების გასაგებად კი "test_get.php" გვერდზე დაგვეხმარება $_GET მეთოდი. echo "Study " . $_GET['subject'] . " at " . $_GET['web'];
15. ფორმები
PHP-ს სუპერგლობალური ცვლადები $_GET და $_POST გამოიყენება ფორმის ინფორმაციების დასამუსავებლად. განვიხიოთ მარტივი HTML ფორმა <form action="welcome.php" method="post">
    Name: <input type="text" name="name">
    E-mail: <input type="text" name="email">
    <input type="submit">
</form>
როდესაც მომხმარებელი შეავსებს ველებს და დააწვება გაგზავნის ღილაკს, აკრეფილი ინფორმაცია დასამუშავებლად გაიგზავნება PHP ფაილში სახელად - "welcome.php". ინფორმაცია გაიგზავნება HTTP POST მეთოდით. welcome.php გვერდზე ამ ინფორმაციის გამოტანა მოხდება ასე Welcome <?php echo $_POST["name"]; ?>
Your email address is: <?php echo $_POST["email"]; ?>
შედეგი იქნება რაღაც ამის მსგავსი Welcome givi
Your email address is: chven_vart_givi@example.com
იგივეს გაკეთება შესაძლებელია HTTP GET მეთოდითაც. <form action="welcome_get.php" method="get">
    Name: <input type="text" name="name">
    E-mail: <input type="text" name="email">
    <input type="submit">
</form>
welcome_get.php გვერდზე ამ ინფორმაციის გამოტანა მოხდება ასე Welcome <?php echo $_GET["name"]; ?>
Your email address is: <?php echo $_GET["email"]; ?>
ზემოთ მოყვანილი კოდი საკმაოდ მარტივია, მითუმეტეს, რომ უმნიშვნელოვანესი მომენტი როგორიცაა ფორმის ვალიდაცია გამოტოვებულია. ფორმის ვალიდაცია არის უმნიშვნელოვანესი რამ უსაფრთხოების თვალსაზრისით.

GET vs POST

ორივე მათგანი GET და POST ქმნის მასივს (მაგ: array( key => value, key2 => value2, key3 => value3, ...)). მასივი შეიცავს გასაღები/მნიშვნელობა წყვილებს, სადაც გასაღებები არის ფორმის ელემენტების სახელები, ხოლო მნიშვნელობები კი მომხმარებლის მიერ ამ ელემენტებში შეტანილი ინფორმაციები. $_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"]);?>"> ეს ჩანაწერი ნიშნავს, რომ ფორმის გაგზავნის (ანუ submit) შემდეგ ინფორმაციის გაგზავნა მოხდება 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-ს საშუალებით

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

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

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

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

სწორია თუ არა ელ_ფოსტის ფორმატი ამის გაგების ყველაზე მარტივი საშუალებაა PHP-ს filter_var() ფუნქცია. $email = $_POST["email"];
if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
   $emailErr = "არასწორი ელ_ფოსტა";
}

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

ქვემოთ მოყვანილ მაგალითში რეგულარული გამოსახულების დახმარებით ვგებულობთ სწორი ფორმატისაა თუ არა აკრეფილი URL მისამართი $website = test_input($_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 "Today is " . date("Y/m/d") . "<br>"; // Today is 2017/04/07
echo "Today is " . date("Y.m.d") . "<br>"; // Today is 2017.04.07
echo "Today is " . date("Y-m-d") . "<br>"; // Today is 2017-04-07
echo "Today is " . date("l"); // Today is 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 "The time is " . date("h:i:sa"); // The time is 10:38:26pm უნდა აღინიშნოს, რომ ფუნქცია date() თარიღს/დროს აბრუნებს სერვერის მიხედვით.

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

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

mktime()

როგორც ვთქვით date() ფუნქციის პარამეტრი timestamp განსაზღვრავს დროუის ნიშნულს. თუ ამ პარამეტრს არ მივუთითებთ გამოყენებულ იქნება მიმდინარე დრო. mktime() ფუნქცია აბრუნებს Unix დროის ნიშნულს. (Unix არის მრავალფუნქციური და მრავალმომხმარებლიანი ოპერაციული სისტემების ოჯახი. Unix დრო - UNIX და სხვა POSIX-თანამედროვე ოპერაციული სისტემების დანერგვის მომენტის აღწერის სისტემა, განისაზღვრება როგორც წამების რაოდენობა 1970 წლის 1 იანვრიდან მიმდინარე მომენტამდე, P.S დროის ამ მონაკვეთს ეწოდება UNIX ეპოქა) mktime(hour,minute,second,month,day,year) $d=mktime(11, 14, 54, 8, 12, 2014);
echo "Created date is " . date("Y-m-d h:i:sa", $d); // Created date is 2014-08-12 11:14:54am

strtotime()

გამოიყენება UNIX დროის ადამიანისათვის წასაკითხ ფორმატში ჩასაწერად strtotime(time,now) $d=strtotime("10:30pm April 15 2014");
echo "Created date is " . 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 ფუნქციას. ჩასასმელი ფუნქციები საკმაოდ კარგი იარაღია როდესაც ერთი და იგივე 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 მნიშვნელობების როგორც დაბრუნება ისე შექმნა.

Cookie-ს შექმნა

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

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

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

<?php
if(!isset($_COOKIE[$cookie_name])) {
    echo "Cookie named '" . $cookie_name . "' is not set!";
} else {
    echo "Cookie '" . $cookie_name . "' is set!<br>";
    echo "Value is: " . $_COOKIE[$cookie_name];
}
?>

</body>
</html>
ფუნქცია setcookie () უნდა მოთავსდეს ტეგ <html>-ის შემდეგ.

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

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

Cookie-ს წაშლა

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

<?php
    echo "Cookie 'user' is deleted.";
?>

</body>
</html>
24. SESSION
სესია არის საშუალება შევინახოთ ინფორმაცია (ცვლადში) სხვადასხვა გვერდებზე გამოყენების მიზნით. cookie-სგან განსხვავებით ეს ინფორმაცია მომხმარებლის კომპიუტერში არ ინახება. სესია შინაარსობრივად წააგავს შემდეგ პროცესს: დავუშვათ აპლიკაციასთან მუშაობისას გავხსენით იგი შევიტანეთ ცვლილებები და დავხურეთ, კომპიუტერმა იცის ვინ ვართ ჩვენ, აგრეთვე იცის როდის გავხსენით აპლიკაცია და როდის დავხურეთ, მაგრამ ინტერნეტთან მუშაობისას არის ერთი პრობლემა: ვებ-სერვერმა არ იცის ვინ ვართ და რას ვაკეთებთ, რადგან HTTP მისამართი ცვალებადია (ვთქვათ examle.ge გვერდზე ვმუშაობთ მომხმარებლის სახელით - user და გვინდა იგივე ინფორმაცია გადაგვყვეს examle.ge/test.php გვერდზე). სესიის ცვლადების დახმარებით შესაძლებელია ამ პრობლემის გადაწყვეტა, როგორც აღვნიშნეთ მათში ინახება სასურველი ინფორმაცია (მომხმარებლის სახელი, ფავორიტი ფერი და ა.შ) სხვადასხვა გვერდებზე გამოყენების მიზნით. ნაგულისმეობის პრინციპით სესიის ცვლადები ინახება მანამ სანამ მომხმარებელი არ დახურავს ბრაუზერს.

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

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

<?php
    // Set session variables
    $_SESSION["favcolor"] = "green";
    $_SESSION["favanimal"] = "cat";
    echo "Session variables are set.";
?>

</body>
</html>
session_start() უნდა იყოს პირველი ჩანაწერი დოკუმენტში.

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

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

<?php
    // Echo session variables that were set on previous page
    echo "Favorite color is " . $_SESSION["favcolor"] . ".<br>";
    echo "Favorite animal is " . $_SESSION["favanimal"] . ".";
?> </body>
</html>
და მაინც, როგორ მუშაობს სესია ? სესიების უმრავლესობა მომხმარებლის კომპიუტერში აკეთებს მომხმარებლის გასაღებს დაახლოებით ასეთი სახისას: 765487cf34ert8dede5a562e4f3a7e12, შემდეგ როდესაც სესია იხსნება ახალ ფანჯარაში სესია ახდენს კომპიუტერის სკანირებას და ეძებს უკვე შექმნილ გასაღებს, თუ დამთხვევა მოხდება მაშინ სესია აბტომატურად ხელმისაწვდომი ხდება ამ გვერდზე, თუ არა და იქმნება ახალი სესია.

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

სესიის მნიშვნელობის ცვლილებისათვის ძველ მნიშვნელობას უბრალოდ უნდა გადავაწეროთ ახალი // to change a session variable, just overwrite it
$_SESSION["favcolor"] = "yellow";

სესიის წაშლა

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

<?php
    // remove all session variables
    session_unset();

    // destroy the session
    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>Hello World!</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
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";

// Create connection
$conn = new mysqli($servername, $username, $password);

// Check connection
if ($conn->connect_error) {
     die("Connection failed: " . $conn->connect_error);
}
echo "Connected successfully";

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

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

// Create connection
$conn = mysqli_connect($servername, $username, $password);

// Check connection
if (!$conn) {
     die("Connection failed: " . mysqli_connect_error());
}
echo "Connected successfully";

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

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

try {
     $conn = new PDO("mysql:host=$servername;dbname=myDB", $username, $password);
     // set the PDO error mode to exception
     $conn->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
     echo "Connected successfully";
     }
catch(PDOException $e)
     {
     echo "Connection failed: " . $e->getMessage();
     }

connect.php

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

// Create connection
$conn = mysqli_connect($servername, $username, $password);

// Check connection
if (!$conn) {
    die("Connection failed: " . mysqli_connect_error());
}
echo "Connected successfully";
?>
              
mysqli_connect ფუნქციას გადაეცემა კიდევ ერთი პარამეტრი, ესაა - მონაცემთა ბაზის სახელი. შემდეგ თავში ვნახავთ თუ როგორ იქმნება მონაცემთა ბაზა, ამის შემდეგ კი ჩავასწორებთ connect.php ფაილს და დავამატებთ აღნიშნულ პარამერტრს.

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

$conn->close();

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

mysqli_close($conn);

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

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

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

require_once('connect.php');

// Create database
$sql = "CREATE DATABASE myDB";
if ($conn->query($sql) === TRUE) {
     echo "Database created successfully";
} else {
     echo "Error creating database: " . $conn->error;
}

$conn->close();

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

require_once('connect.php');

// Create database
$sql = "CREATE DATABASE myDB";
if (mysqli_query($conn, $sql)) {
     echo "Database created successfully";
} else {
     echo "Error creating database: " . mysqli_error($conn);
}

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

// Create connection
$conn = new mysqli($servername, $username, $password, $dbname);

// Check connection
if (!$conn) {
    die("Connection failed: " . mysqli_connect_error());
}
echo "Connected successfully";
?>
              
30. ცხრილის შექმნა ბაზაში
მბ-ს ცხრილებს აქვთ უნიკალური სახელები და შედგებიან სვეტებისა და სტრიქონებისაგან. ცხრილის შესაქმნელად გამოიყენება CREATE TABLE ჩანაწერი. გავაკეთოთ ცხრილი სახელად MyGuests", რომელსაც ექნება 5 ველი: "id", "firstname", "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) ახდენს რეალური სამყაროს ობიექტების მოდელირებას ამ ობიექტების პროგრამული ანალოგების (ეკვივალენტების) საშუალებით.

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

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

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

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

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

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

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

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

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

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

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

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

დესტრუქტორი

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

   function myfunc ($arg1, $arg2) {
    [..]
   }
   [..]
  }
?>
შევქმნათ კლასი სახელწოდებით - Books.
<?php
   class Books {
      /* თვისებები */
      var $price;
      var $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 არის სპეციალური ცვლადი, რომელიც მიუთითებს იმავე კლასზე, რომელშიც თავად ეს ცვლადია გამოყენებული, მისი მეშვეობით ხდება კლასის მეთოდებზე და თვისებებზე მიმართვა.

კლასის შექმნის შემდეგ შესაძლებელია შევქმნათ მისი იმდენი ეგზემპლიარი ანუ ობიექტი, რამდენიც გაგვიხარდება. ობიექტის შექმნა ხდება სიტყვაგასაღებ new-ს დახმარებით. $physics = new Books;
$maths = new Books;
$chemistry = new Books;
ამ ჩანაწერით შევქმენით სამი ერთმანეთისაგან დამოუკიდებელი ობიექტი. იმის გასაგებად არის თუ არა კონკრეტული ობიექტი კონკრეტული კლასის ეგზემპლიარი, გამოიყენება ოპერატორი 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( "Physics for High School" );
$chemistry->setTitle( "Advanced Chemistry" );
$maths->setTitle( "Algebra" );

$physics->setPrice( 10 );
$chemistry->setPrice( 15 );
$maths->setPrice( 7 );
ახლა ამავე ობიექტების სხვა მეთოდების საშუალებით გამოვიტანოთ მინიჭებული სათაურები და ფასები $physics->getTitle();
$chemistry->getTitle();
$maths->getTitle();
$physics->getPrice();
$chemistry->getPrice();
$maths->getPrice();
შედეგი იქნება Physics for High School
Advanced Chemistry
Algebra
10
15
7
3. მაგიური მეთოდები
მაგიური ფუნქციების დასახელებებს წინ ერთვის ორი ქვედა ტირე "__".

__construct()

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

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

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

__destruct()

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

       function __destruct() {
           print "Destroying " . $this->name . "\n";
       }
    }

    $obj = new MyDestructableClass();
?>
            
შედეგი იქნება In constructor // ობიექტის შექმნისას კონსტრუქტორში აღწერილი ინსტრუქციის შესაბამისად
Destroying 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, 'hello world');
echo $tweet; // 'hello world'
           

__get() და __set()

ობიექტებთან მუშაობისას ხშირად გვჭირდება მის თვისებებთან და მეთოდებთან წვდომა, მაგალითად ასე $tweet = new Tweet(123, 'hello world');
echo $tweet->text; // 'hello world'
მაგრამ ხშირად ობიექტთა მეთოდები და თვისებები დაცულია (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. მემკვიდრეობითობა
დავუშვათ გვაქვს საბაზისო კლასი "ParentClass", თუ ჩვენ განვსაზღვრავთ ახალ კლასს "ChildClass"-ს რომელსაც ექნება იგივე მეთოდები და თვისებები რაც აქვს ParentClass-ს, ვიტყვით რომ ChildClass არის ParentClass-ის მემკვიდრე ან შვილობილი კლასი. შესაბამისად ParentClass არის ChildClass-ის წინაპარი ან მშობელი კლასი. შვილობილ კლასს შესაძლებელია გააჩნდეს დამატებითი თვისებები და მეთოდები (წინააღმდეგ შემთხვევაში აზრ ეკარგება ახალი კლასის შექმნას). ამ პროცესს ეწოდება მემკვიდრეობითობა. მემკვიდრეობითობის რეალიზება ხდება სიტყვაგასაღებ extends-ის დახმარებით. მემკვიდრე კლასის შექმნის სინტაქსი ასეთია class ChildClass extends ParentClass {
   <definition body>
}
შევქმნათ კლასი 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("Vaso","hjyu56","vaso@gmail.com","Khashuri");
   echo $first->city; // Khashuri

}
?>
           
ახლა შევქმნათ ამ კლასის მემკვიდრე კლასი "Moderator"
class Moderator extends User{

  public $info; // მემკვიდრე კლასის ახალი თვისება

}

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

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



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

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



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

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

   public static $name;

   public static function hello(){
     echo "Hello " . self::$name;
   }

}
user::$name = "Vaso";
echo user::$name; // Vaso

user::hello(); // Hello Vaso
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-ის მეშვეობით. ინტერფეისში აღწერილი ყველა მეთოდის თვალთახედვის არე უნდა იყოს 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 = "Vaso";
     public $status = "Admin";

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

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

    }

    $user1 = new Test;
    $user1->getName(); // Vaso
    $user1->getStatus(); // Admin

?>

             
11. Namespace
დიდი ზომის აპლიკაციების შექმნისას შეიძლება მოხდეს ისე რომ დიდი ზომის კოდში გამეორდეს ფუნქციების, კლასების, მეთოდების სახელები. წარმოვიდგინოთ რომერთ საქაღალდეში გვაქვს სამი ფაილი შემდეგი დასახელებებითა და კოდებით
index.php
<?php
  include "file1.php";
  include "file2.php";

  foo();
?>
            
file1.php
<?php
   function foo(){
     echo "Hello";
   }
?>
            
file2.php
<?php
   function foo(){
     echo "World";
   }
?>
            
ამ შემთხვევაში index.php ფაილის გაშვებისას დაფიქსირდება შეცდომა Fatal error: Cannot redeclare foo() (previously declared in ... შეცდომა გვატყობინებს, რომ არ შეიძლება ორ სხვადასხვა ფუნქციას გააჩნდეს ერთი სახელი (ამ შემთხვევაში foo). ამ პრობლემის მოსაგვარებლად ცნება Namespace (პირდაპირი მნიშვნელობით სახელის სივრცე, სახელის ადგილი, მდებარეობა). სახელის სივრცის განსაზღვრა ხდება სიტყვა გასაღებ namespace-ს დახმარებით, ზემოთ მოყვანილ ფაილებს განვუსაზღვროთ სახელის სივრცე
file1.php
<?php
   namespace File1;
   function foo(){
     echo "Hello";
   }
?>
            
file2.php
<?php
   namespace File2;
   function foo(){
     echo "World";
   }
?>
            
ახლა უკვე პირველი 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();
  /*
    შედეგი იქნება HelloWorld
  */
?>
            
ანუ foo() ფუნქციას განვუსაზღვრეთ სახელის სივრცეები.


ოოპ 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 "Hello World !";
    }
  }
?>
              
პარალელურად classes საქაღალდეში უნდა შეიქმნას Main.php ფაილი რომელშიც აღიწერება მთავარი გვერდის ჩამტვირთველი კლასი
<?php
  class Main extends ACore{

  }
?>
              
თუ ამ მომენტისათვის გავხსნით მთავარ გვერდს, ბრაუზერში გამოჩნდება Hello World !

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

როგორც დასაწყისში აღვნიშნეთ, შექმნილი გვაქვს მონაცემთა ბაზა. ჩვენს ვებ-გვერდზე არის ისეთი ქვე-გვერდები რომლებზეც სწორედ ბაზიდან წამოღებული ინფორმაცია უნდა განთავსდეს, ისმის კითხვა : სად მოვახდინოთ ბაზასთან დაკავშირება ? პასუხი ასეთია : შესაძლებელია ეს გავაკეთოთ ყველა ისეთი გვერდისათვის ცალ-ცალკე, რომლბსაც მბ-სთან დაკავშირება სჭირდებათ, მაგრამ უმჯობესია თუ ბასათან დაკვშირების ინსტრუქციას აღვწერთ ძირითად კლას 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 "Hello World !";
    }

  }
?>
              
ბაზასთან დავკავშირდით !

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



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

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



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

საიტის ქუდი

დავიწყოთ საიტის ქუდით, ACore კლასში აღვწეროთ შესაბამისი მეთოდი get_header. თუმცა მანამდე პროექტის ძირ საქაღალდეში შევქმნათ ფაილი header.php , სადაც მოვათავსებთ გამზადებული შაბლონის კოდიდან ამოჭრილ, საიტის ქუდის ტეგებს
<!DOCTYPE html>
<html>

<head>
 <title>OOP PHP CMS</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 end-->

</body>

</html>

              
ახლა ACore კლასში დავამატოთ შესაბამისი მეთოდი get_content()
<?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>";
    }

    protected function get_footer(){
      include("footer.php");
    }


    public function get_body(){
      $this->get_header();
      $this->get_left_bar();
      $this->get_content();
      $this->get_footer();
    }

    abstract function get_content();

  }
?>
              
ამ ყველაფრის შედეგი იქნება



სტატიები ვებ-გვერდის მთავარ გვერდზე

როგორც ვიცით ნბ-ში გვაქვს ცხრილი articles რომელშიც მოთავსებულია რამოდენიმე სტატია, Main კლასში აღვწეროთ მეთოდი რომელიც ამ სტატიებს გამოიტანს მთავარ გვერდზე
<?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 გადმოწერა