1 Star2 Stars3 Stars4 Stars5 Stars
Loading...Loading...

» PHP ქართულად – ნაწილი II (მოწინავე PHP)

“წიგნით, თავიდან ბოლომდე შეისწავლით PHP-ს საწყისებს. წიგნი განკუთვნილია დამწყებთათვის”
წიგნის ავტორი: ღონღაძე გიორგი.
წიგნის ვებ-ვიზუალიზაცია: Gigol.net

PHP თარიღი

PHP DATE() ფუნქცია
სინტაქსი:

date(format,timestamp)

პარამეტრი
აღწერა

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

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

PHP თარიღი – რა არის დროის ნიშნული?
დროის ნიშნული არის წამების რიცხვი, როგორც January 1, 1970 at 00:00:00 GMT. ეს ასევე ცნობილია როგორც Unix დროის ნიშნული.
PHP თარიღი – თარიღის ფორმატი
პირველი პარამეტრი date() ფუნქციაში არის დროის/თარიღის ფორმატის სპეციფიკაცია. დროის/თარიღის გამოსასახავად ის იყენებს ასოებს. ქვემოთ მოყვანილია ის ასოები, რომლებიც შესაძლოა გამოყენებულ იქნას:
· d – რიცხვი/დღე (01-31)
· m – მიმდინარე თვე (01-12)
· Y – მიმდინარე წელი

სხვა სიმბოლოები, როგორიცაა”/”, “.”, ან “-” შესაძლებელია ასევე ჩაისვას ასოებს შორის:

<?php 
echo date("Y/m/d"); 
echo "<br />"; 
echo date("Y.m.d"); 
echo "<br />"; 
echo date("Y-m-d"); 
?>

კოდი დაბეჭდავს:

2007/07/11
2007.07.11
2007-07-11

PHP თარიღი – დროის ნიშნულის დამატება
წამების პარამეტრი date() ფუნქციაში არის დროის ნიშნულის სპეციფიკაცია. ეს პარამეტრი არასავალდებულოა. თუ ჩვენ არ ვიყენებთ დროის ნიშნულს, მაშინ გამოიყენება მიმდინარე დრო.
შემდეგ მაგალითში, მომდევნო დღის დროის ნიშნულის შესაქმნელად გამოვიყენებთ mktime() ფუნქციას.
mktime() ფუნქცია დააბრუნებს Unix დროის ნიშნულს სპეციფიური თარიღისათვის.
სინტაქსი:

mktime(hour,minute,second,month,day,year,is_dst)

მომდევნო დღეზე გადასასვლელად საჭიროა დაემატოს ერთი არგუმენტი mktime():

<?php 
$tomorrow = mktime(0,0,0,date("m"),date("d")+1,date("Y")); echo "Tomorrow is ".date("Y/m/d/", $tomorrow); 
?>

კოდი დაბეჭდავს:

Tomorrow is 2006/07/12

PHP – ფაილის ჩასმა

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

INCLUDE() ფუნქცია
include() ფუნქციას მთლიანი ტექსტი მიაქვს სპეციფიურ ფაილში და აკოპირებს იმ ფაილში რომელიც გამოიყენება ჩამატების ფუნქციით.
მაგალითი 1:
წარმოვიდგინოთ რომ გვაქვს სტანდარტული სათაურის ფაილი, რომელსაც ქვია “header.php”. გვერდზე სათაურის ჩამატებისათვის, გამოვიყენოთ include() ფუნქცია შემდეგნაირად:

<html> 
<body> 
<?php include("header.php"); ?> 
<h1>Welcome to my home page</h1> 
<p>Some text</p> 
</body> 
</html>

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

<html> 
<body> 
<a href="http://geocg.myweb.ge/index.php">Home</a> | 
<a href="http://geocg.myweb.ge/about.php">About Us</a> |  
<a href="http://geocg.myweb.ge/contact.php">Contact Us</a>	 
 
ეს სამი ფაილი, "index.php", "about.php", და "contact.php" ჩაემატება ფაილში "menu.php" .  
კოდი: 
 
<?php include("menu.php"); ?> 
<h1>Welcome to my home page</h1> 
<p>Some text</p> 
</body> 
</html>

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

<html> 
<body> 
<a href="default.php">Home</a> | 
<a href="about.php">About Us</a> |  
<a href="contact.php">Contact Us</a> 
<h1>Welcome to my home page</h1> 
<p>Some text</p> 
</body> 
</html>

REQUIRE() ფუნქცია
თუ ჩვენ ფაილს ჩავსვავთ include() ფუნქციით და მოხდება შეცდომა, შესაძლოა მივიღოთ შემდეგი შეტყობინება.
PHP კოდი:

<html> 
<body> 
<?php 
include("wrongFile.php"); 
echo "Hello World!"; 
?> 
</body> 
</html>

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

Warning: include(wrongFile.php) [function.include]:
failed to open stream:
No such file or directory in C:\home\website\test.php on line 5
Warning: include() [function.include]:
Failed opening ‘wrongFile.php’ for inclusion
(include_path=’.;C:\php5\pear’)
in C:\home\website\test.php on line 5
Hello World!

გავითვალისწინოთ რომ echo ოპერატორი კვლავ მუშაობს! ეს იმიტომ რომ გაფრთხილება არ აჩერებს სკრიპტის მუშაობას.
ახლა გავუშვათ მსგავსი მაგალითი require() ფუნქციით.
PHP კოდი:

<html> 
<body> 
<?php 
require("wrongFile.php"); 
echo "Hello World!"; 
?> 
</body> 
</html>

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

Warning: require(wrongFile.php) [function.require]:
failed to open stream:
No such file or directory in C:\home\website\test.php on line 5
Fatal error: require() [function.require]:
Failed opening required ‘wrongFile.php’
(include_path=’.;C:\php5\pear’)
in C:\home\website\test.php on line 5

echo პარამეტრმა აღარ იმუშავა რადგან გამოვიდა გარდაუვალი შეცდომის შეტყობინება.
რეკომენდირებულია გამოვიყენოთ require() ფუნქცია.

PHP – ფაილი

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

<html> 
<body> 
<?php 
$file=fopen("welcome.txt","r"); 
?> 
</body> 
</html>

ფაილი შესაძლებელია გაიხსნას ქვემოთ მოყვანილიდან ერთ-ერთ რეჟიმში:

რეჟიმი
აღწერა

r
კითხვა. იწყება ფაილის დასაწყისიდან

r+
კითხვა/ჩაწერა. იწყება ფაილის დასაწყისიდან

w
მხოლოდ ჩაწერა. ხსნის და ასუფთავებს ფაილის შემცველობას; ან ქმნის ახალ ფაილს თუ ის არ არსებობს

w+
კითხვა/ჩაწერა. ხსნის და ასუფთავებს ფაილის შემცველობას; ან ქმნის ახალ ფაილს თუ ის არ არსებობს

a
დამატება. ხსნის და წერს ფაილის ბოლოში, ან ქმნის ახალ ფაილს, თუ ის არ არსებობს

a+
კითხვა/დამატება. აკონსერვებს ფაილის შემცველობას ფაილის ბოლოში ჩაწერით

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

x+
კითხვა/ჩაწერა. ქმნის ახალ ფაილს. აბრუნებს FALSE და შეცდომას, თუ ფაილი უკვე არსებობს

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

<html> 
<body> 
<?php 
$file=fopen("welcome.txt","r") or exit("Unable to open file!"); ?> 
</body> 
</html>

ფაილის დახურვა
fclose() ფუნქცია გამოიყენება გახსნილი ფაილის დასახურად:

<?php 
$file = fopen("test.txt","r"); 
//some code to be executed 
fclose($file); 
?>

END-OF-FILE-ის შემოწმება
feof() ფუნქცია ამოწმებს, მიღწეულია თუ არა(“end-of-file” (EOF)) ფაილის ბოლოში. feof() ფუნქცია გამოსადეგია უცნობი სიგრძის მონაცემთა ციკლისათვის.
შენიშვნა: ჩვენ ვერ წავიკითხავს ფაილიდან, რომელიც გახსნილია w, a, და x რეჟიმებში!

if (feof($file)) echo “End of file”;

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

<?php 
$file = fopen("welcome.txt", "r") or exit("Unable to open file!"); 
//Output a line of the file until the end is reached 
while(!feof($file)) 
  { 
  echo fgets($file). "<br />"; 
  } 
fclose($file); 
?>

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

<?php 
$file=fopen("welcome.txt","r") or exit("Unable to open file!"); 
while (!feof($file))  
  {  
  echo fgetc($file);  
  } 
fclose($file); 
?>

PHP – ფაილის ატვირთვა

ფაილის ატვირთვის ფორმის შექმნა
ქვემოთ მოყვანილია ფაილების ატვირთვის HTML ფორმა:

<html> 
<body> 
<form action="upload_file.php" method="post" 
enctype="multipart/form-data"> 
<label for="file">Filename:</label> 
<input type="file" name="file" id="file" />  
<br /> 
<input type="submit" name="submit" value="Submit" /> 
</form> 
</body> 
</html>

გავითვალისწინოთ შემდეგი HTML ფორმისათვის:
· enctype ატრიბუტი form ტეგისათვის სპეციფიკაციას აკეთებს, თუ რომელი შემცველობითი ტიპი გამოიყენოს ფორმის გამოყენებისას.
· “multipart/form-data” გამოიყენება, როდესაც ფორმა მოითხოვს ბინარულ მონაცემებს, როგორიცაა ასატვირთი ფაილის შემცველობა.

შენიშვნა: მომხმარებელთათვის ფაილების ატვირთვის უფლების მიცემა წარმოადგენს დიდ რისკს.
ატვირთვის სკრიპტის შექმნა
“upload_file.php” შეიცავს ატვირთვის კოდს:

<?php 
if ($_FILES["file"]["error"] > 0) 
  { 
  echo "Error: " . $_FILES["file"]["error"] . "<br />"; 
  } 
else 
  { 
  echo "Upload: " . $_FILES["file"]["name"] . "<br />"; 
  echo "Type: " . $_FILES["file"]["type"] . "<br />"; 
  echo "Size: " . ($_FILES["file"]["size"] / 1024) . " Kb<br />"; 
  echo "Stored in: " . $_FILES["file"]["tmp_name"]; 
  } 
?>

გლობალური PHP $_FILES მასივების გამოყენებით ჩვენ შეგვიძლია კომპიუტერიდან სერვერზე ავტვირთოთ ფაილები.
პირველი პარამეტრი არის input სახელი, ხოლო მეორე პარამეტრი შესაძლოა იყოს ნებისმიერი “name”, “type”, “size”, “tmp_name”, ან “error”. ამის მსგავსად:
· $_FILES[“file”][“name”] – ატვირთული ფაილის სახელი
· $_FILES[“file”][“type”] – ატვირთული ფაილის ტიპი
· $_FILES[“file”][“size”] – ატვირთული ფაილის ზომა ბაიტებში
· $_FILES[“file”][“tmp_name”] – სერვერზე დაბრუნებული ფაილის დროებითი ასლი
· $_FILES[“file”][“error”] – შეცდომის კოდი

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

შეზღუდვა ატვირთვაზე
სკრიპტში ჩვენ ჩავამატებთ ფაილის ატვირთვის ზოგიერთ შეზღუდვებს. მომხმარებელს შეეძლება ატვირთოს მხოლოდ .gif, ან .jpeg ფაილები და ფაილის ზომა არ უნდა აღემატებოდეს 20 kb-ს:

<?php 
if ((($_FILES["file"]["type"] == "image/gif") 
|| ($_FILES["file"]["type"] == "image/jpeg") 
|| ($_FILES["file"]["type"] == "image/pjpeg")) 
&& ($_FILES["file"]["size"] < 20000)) 
  { 
  if ($_FILES["file"]["error"] > 0) 
    { 
    echo "Error: " . $_FILES["file"]["error"] . "<br />"; 
    } 
  else 
    { 
    echo "Upload: " . $_FILES["file"]["name"] . "<br />"; 
    echo "Type: " . $_FILES["file"]["type"] . "<br />"; 
    echo "Size: " . ($_FILES["file"]["size"] / 1024) . " Kb<br />"; 
    echo "Stored in: " . $_FILES["file"]["tmp_name"]; 
    } 
  } 
else 
  { 
  echo "Invalid file"; 
  } 
?>

შენიშვნა: IE-სათვის jpg ფაილების ცნობისათვის ტიპი უნდა იყოს pjpeg, ხოლო FireFox-სათვის ტიპი უნდა იყოს jpeg.

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

<?php 
if (($_FILES["file"]["type"] == "image/gif") 
|| ($_FILES["file"]["type"] == "image/jpeg") 
|| ($_FILES["file"]["type"] == "image/pjpeg") 
&& ($_FILES["file"]["size"] < 20000)) 
  { 
  if ($_FILES["file"]["error"] > 0) 
    { 
    echo "Return Code: " . $_FILES["file"]["error"] . "<br />"; 
    } 
  else 
    { 
    echo "Upload: " . $_FILES["file"]["name"] . "<br />"; 
    echo "Type: " . $_FILES["file"]["type"] . "<br />"; 
    echo "Size: " . ($_FILES["file"]["size"] / 1024) . " Kb<br />"; 
    echo "Temp file: " . $_FILES["file"]["tmp_name"] . "<br />"; 
    if (file_exists("upload/" . $_FILES["file"]["name"])) 
      { 
      echo $_FILES["file"]["name"] . " already exists. "; 
      } 
    else 
      { 
      move_uploaded_file($_FILES["file"]["tmp_name"], 
      "upload/" . $_FILES["file"]["name"]); 
      echo "Stored in: " . "upload/" . $_FILES["file"]["name"]; 
      } 
    } 
  } 
else 
  { 
  echo "Invalid file"; 
  } 
?>

PHP COOKIES(ბმულები)

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

როგორ შევქმნათ ბმული?
setcookie() ფუნქცია გამოიყენება ბმულების დასასმელად.
შენიშვნა: setcookie() ფუნქცია უნდა დაიწეროს ტეგამდე.
სინტაქსი:

setcookie(name, value, expire, path, domain);

მაგალითი:
ქვემოთ მოყვანილ მაგალითში ჩვენ შევქმნი ბმულს სახელით “user” და მივანიჭებთ მნიშვნელობას “Alex Porter”:

<?php  
setcookie("user", "Alex Porter", time()+3600); 
?> 
<html> 
<body> 
</body> 
</html>

როგორ შევასწოროთ ბმული?
PHP $_COOKIE ცვლადი გამოიყენება ბმულის მნიშვნელობების შესასწორებლად. ქვემოთ მოყვანილ მაგალითში, ჩვენ შევასწორებთ ბმულს სახელად “user” და გამოვსახავთ მას გვერდზე:

<?php // Print a cookie echo $_COOKIE["user"]; 
// A way to view all cookies 
print_r($_COOKIE); 
?>

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

<html> 
<body> 
<?php 
if (isset($_COOKIE["user"])) 
  echo "Welcome " . $_COOKIE["user"] . "!<br />"; 
else 
  echo "Welcome guest!<br />"; 
?> 
</body> 
</html>

როგორ წავშალოთ ბმული?
წაშლის მაგალითი:

<?php  
// set the expiration date to one hour ago setcookie("user", "", time()-3600); 
?>

თუ ბრაუზერი არ უზრუნველყოფს ბმულებს
თუ ბრაუზერი არ უზრუნველყოფს ბმულებს, ჩვენ უნდა გამოვიყენოთ სხვა მეთოდი, რათა ინფორმაცია გადავცეთ ერთი გვერდიდან მეორე გვერდზე.
ქვემოთ მოცემული ფორმა გადასცემს მომხმარებლის ინფორმაციას “welcome.php”-ს როდესაც მომხმარებელი იმოქმედებს “Submit” ღილაკზე:

<html> 
<body> 
<form action="welcome.php" method="post"> 
Name: <input type="text" name="name" /> 
Age: <input type="text" name="age" /> 
<input type="submit" /> 
</form> 
</body> 
</html>

შევასწოროთ მნიშვნელობა “welcome.php”-ში შემდეგის მსგავსად:

<html> 
<body> 
Welcome <?php echo $_POST["name"]; ?>.<br /> 
You are <?php echo $_POST["age"]; ?> years old. 
</body> 
</html>

PHP სესიები

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

PHP სესიის დაწყება
სანამ ჩვენ შევაგროვებთ ინფორმაციას PHP სესიაზე, ჩვენ უნდა დავიწყოთ სესია.
შენიშვნა: session_start() ფუნქცია იწერება ტეგამდე:

<?php session_start(); ?> 
<html> 
<body> 
</body> 
</html>

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

სესიის ცვლადების შეგროვება
სწორი გზა სესიის ცვლადების შეგროვებისა და ჩასწორების არის PHP $_SESSION ცვლადის გამოყენება:

<?php 
session_start(); 
// store session data 
$_SESSION['views']=1; 
?> 
<html> 
<body> 
<?php 
//retrieve session data 
echo "Pageviews=". $_SESSION['views']; 
?> 
</body> 
</html>

დაბეჭდავს:

Pageviews=1

ქვემოთ მოყვანილ მაგალითში, ჩვენ შევქმნით უბრალო მთვლელს. isset() ფუნქცია შეამოწმებს “views” ცვლადი უკვე დასმულია თუ არა. თუ “views” უკვე დასმულია, ჩვენ შეგვიძლია გავზარდოთ ჩვენი მთვლელი. თუ “views” არ არსებობს, ჩვენ ვქმნით”views” ცვლადს და ვაყენებთ მას 1-ზე:

<?php  
session_start(); 
if(isset($_SESSION['views']))   $_SESSION['views']=$_SESSION['views']+1;  
else   $_SESSION['views']=1; echo "Views=". $_SESSION['views'];  ?>

სესიის განადგურება
თუ გვსურს სესიის მონაცმეთა წაშლა,ჩვენ შეგვიძლია გამოვიყენოთ unset(), ან session_destroy() ფუნქციები.
unset() ფუნქცია გამოიყენება სესიის ცვლადის გასანთავისუფლებლად:

<?php unset($_SESSION['views']); 
?>

ჩვენ ასევე შეგვიძლია საბოლოო გავანადგუროთ სესიის ცვლადი session_destroy() ფუნქციის გამოყენებით:

<?php session_destroy(); 
?>

შენიშვნა: session_destroy() ფუნქცია წაშლის ყველა მონაცემს ცვლადში.
PHP ელ. ფოსტის გაგზავნა
PHP MAIL() ფუნქცია
PHP mail() ფუნქცია გამოიყენება სკრიპტიდან ელ. ფოსტის გასაგზავნად.
სინტაქსი

mail(to,subject,message,headers,parameters)

პარამეტრი აღწერა

to
აუცილებელი. ელ.ფოსტის მიმღების/მიმღებების სპეციფიკაცია

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

message
აუცილებელი. განსაზღვრავს გასაგზავნ შეტყობინებას. თითოეული ხაზი გამოიყოფა LF (\n)-ით.

headers
არა აუცილებელი. სათაურების სპეციფიკაცია, როგორც From, Cc და Bcc. სათაურები გამოიყოფა CRLF (\r\n)-ით

parameters
არა აუცილებელი. დამატებითი პარამეტრების სპეციფიკაცია

PHP უბრალო ელ. ფოსტა

უბრალო გზა PHP-ს დახმარებით ელ. ფოსტის გაგზავნისა არის ტექსტური მეილის გაგზავნა.
ქვემოთ მოყვანილ მაგალითში ჩვენ გამოვაცხადებთ ცვლადებს ($to, $subject, $message, $from, $headers), შემდეგ ამ ცვლადებს გამოვიყენებთ mail() ფუნქციაში:

<?php 
$to = "someone@example.com"; 
$subject = "Test mail"; 
$message = "Hello! This is a simple email message."; 
$from = "someonelse@example.com"; 
$headers = "From: $from"; 
mail($to,$subject,$message,$headers); 
echo "Mail Sent."; 
?>

PHP ფოსტის ფორმა

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

<html> 
<body> 	 
 
<?php 
if (isset($_REQUEST['email'])) 
//if "email" is filled out, send email 
  { 
  //send email 
  $email = $_REQUEST['email'] ;  
  $subject = $_REQUEST['subject'] ; 
  $message = $_REQUEST['message'] ; 
  mail( "someone@example.com", "Subject: $subject", 
  $message, "From: $email" ); 
  echo "Thank you for using our mail form"; 
  } 
else 
//if "email" is not filled out, display the form 
  { 
  echo "<form method='post' action='mailform.php'> 
  Email: <input name='email' type='text' /><br /> 
  Subject: <input name='subject' type='text' /><br /> 
  Message:<br /> 
  <textarea name='message' rows='15' cols='40'> 
  </textarea><br /> 
  <input type='submit' /> 
  </form>"; 
  } 
?> 
</body> 
</html>

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

PHP ელ.ფოსტის დაცვა
PHP ელ. ფოსტის ინექციები
პირველი, შევხედოთ PHP კოდს წინა პარაგრაფიდან:

<html> 
<body> 
<?php 
if (isset($_REQUEST['email'])) 
//if "email" is filled out, send email 
  { 
  //send email 
  $email = $_REQUEST['email'] ;  
  $subject = $_REQUEST['subject'] ; 
  $message = $_REQUEST['message'] ; 
  mail("someone@example.com", "Subject: $subject", 
  $message, "From: $email" ); 
  echo "Thank you for using our mail form"; 
  } 
else 
//if "email" is not filled out, display the form 	 
 
  { 
  echo "<form method='post' action='mailform.php'> 
  Email: <input name='email' type='text' /><br /> 
  Subject: <input name='subject' type='text' /><br /> 
  Message:<br /> 
  <textarea name='message' rows='15' cols='40'> 
  </textarea><br /> 
  <input type='submit' /> 
  </form>"; 
  } 
?> 
</body> 
</html>

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

someone@example.com%0ACc:person2@example.com
%0ABcc:person3@example.com,person3@example.com,
anotherperson4@example.com,person5@example.com
%0ABTo:person6@example.com

mail() ფუნქცია ზემოთ მოყვანილ ტექტს წერს ფოსტის სათაურების ველში და ახლა სათაურს აქვს ექსტრა Cc:, Bcc: და To: ველი. როდესაც მომხმარებელი იმოქმედებს “Submit” ღილაკზე, ფოსტა გაიგზავნება ზემოთ მოყვანილ ყველა მისამართზე.

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

<html> 
<body> 
<?php 
function spamcheck($field) 
  { 
//eregi() performs a case insensitive regular expression match 
  if(eregi("to:",$field) || eregi("cc:",$field))  
    { 
    return TRUE; 
    } 
  else 
    { 
    return FALSE; 
    } 
  } 
//if "email" is filled out, send email 
if (isset($_REQUEST['email'])) 
  { 
  //check if the email address is invalid 
  $mailcheck = spamcheck($_REQUEST['email']); 
  if ($mailcheck==TRUE) 
    { 
    echo "Invalid input"; 
    } 
  else 
    {  
    //send email 
    $email = $_REQUEST['email'] ;  
    $subject = $_REQUEST['subject'] ; 
    $message = $_REQUEST['message'] ; 
    mail("someone@example.com", "Subject: $subject", 
    $message, "From: $email" ); 
    echo "Thank you for using our mail form"; 
    } 
  } 
else 
//if "email" is not filled out, display the form 
  { 
  echo "<form method='post' action='mailform.php'> 
  Email: <input name='email' type='text' /><br /> 
  Subject: <input name='subject' type='text' /><br /> 
  Message:<br /> 
  <textarea name='message' rows='15' cols='40'> 
  </textarea><br /> 
  <input type='submit' /> 
  </form>"; 
  } 
?> 
</body> 
</html>

PHP – შეცდომა

PHP შეცდომის შეტყობინება
როდესაც ვქმნით სკრიპტებს და ვებ პროგრამებს, შეცდომის გამოტანა არის საკმაოდ მნიშვნელოვანი. თუკი ჩვენ კოდს არ აქვს კოდში შეცდომების შემოწმების საშუალება, ჩვენი პროგრამა იქნება არაპროფესიონალური და შესაძლოა დაუცველი.
არსებობს შეცდომის გამოტანის რამოდენიმე საშუალება:
· უბრალო “die()” ოპერატორები
· ინდივიდუალური შეცდომები და შეცდომის კვანძები
· შეცდომის ანგარიშები

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

<?php 
$file=fopen("welcome.txt","r"); 
?>

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

Warning: fopen(welcome.txt) [function.fopen]: failed to open stream:
No such file or directory in C:\webfolder\test.php on line 2

იმისათვის რომ მომხმარებელმა არ მიიღოს მსგავსი შეტყობინება, მანამ, სანამ მოვითხოვთ ფაილს, უნდა დავტესტოთ არსებობს იგი თუ არა:

<?php 
if(!file_exists("welcome.txt")) 
 { 
 die("File not found"); 
 } 
else 
 { 
 $file=fopen("welcome.txt","r"); 
 } 
?>

ახლა უკვე თუ ფაილი არ არსებობს, გამოვა მსგავსი შეტყობინება:

File not found

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

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

error_function(error_level,error_message,
error_file,error_line,error_context)

პარამეტრი
აღწერა

error_level
აუცილებელი. შეცდომის დონის სპეციფიკაცია. მნიშვნელობა უნდა იყოს რიცხვი

error_message
აუცილებელი. შეცდომის შეტყობინების სპეციფიკაცია

error_file
არა აუცილებელი. ფაილის სახელის სპეციფიკაცია, რომელშიც აღმოჩნდა შეცდომა

error_line
არა აუცილებელი. ხაზის ნომრის სპეციფიკაცია, რომელშიც აღმოჩნდა შეცდომა

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

შეცდომის დონე
შეცდომის დონეები:

მნიშვნელობა
მუდმივი
აღწერა

2
E_WARNING
არა გარდაუვალი ”რან-თაიმ” შეცდომა. სკრიპტის მუშაობა არ შეჩერდება

8
E_NOTICE
”რან-თაიმ” განცხადება. სკრიპტმა იპოვა რაღაც, რომელის შესაძლოა იყოს შეცდომა

256
E_USER_ERROR
სამომხმარებლოს გარდაუვალი შეცდომა. ეს მსგავსია პროგრამისტის მიერ PHP ფუნქცია trigger_error()-ის გამოყენებით დასმული E_ERROR-სა

512
E_USER_WARNING
არა გარდაუვალი სამომხმარებლო გაფრთხილება. ეს მსგავსია პროგრამისტის მიერ PHP ფუნქცია trigger_error()-ის გამოყენებით დასმული E_WARNING-სა

1024
E_USER_NOTICE
სამომხმარებლო განცხადება. ეს მსგავსია პროგრამისტის მიერ PHP ფუნქცია trigger_error()-ის გამოყენებით დასმული E_NOTICE -სა

4096
E_RECOVERABLE_ERROR
დამჭერი გარდაუვალი შეცდომა. ეს მსგავსია E_ERROR-სა, მაგრამ შესაძლოა გამოიწვიოს მომხმარებლის განსაზღვრულმა ქმედებამ

8191
E_ALL
ყველა შეცდომა და გაფრთხილება, გარდა E_STRICT -სა

ახლა შევქმნათ შეცდომის შეტყობინების ფუნქცია:

function customError($errno, $errstr)
{
echo “Error: [$errno] $errstr
“;
echo “Ending Script”;
die();
}

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

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

set_error_handler(“customError”);

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

<?php 
//error handler function 
function customError($errno, $errstr) 
 {  
 echo "<b>Error:</b> [$errno] $errstr"; 
 } 
//set error handler 
set_error_handler("customError"); 
//trigger error 
echo($test); 
?>

კოდი დაბეჭდავს მსგავსს:

Custom error: [8] Undefined variable: test

შეცდომის გაშვება
სკრიპტში სადაც მომხმარებელს შეუძლია შეიყვანოს მონაცემები, საკმაოდ გამოყენებადია გავუშვათ შეცდომა, როდესაც აღმოჩენილ იქნება არალეგალური მონაცემები. PHP-ში ეს ხდება trigger_error() ფუნქციით.
მაგალითი:
მაგალითში გამოვა შეცდომა, თუ “test” ცვლადი მეტია, ვიდრე “1”:

<?php 
$test=2; 
if ($test>1) 
{ 
trigger_error("Value must be 1 or below"); 
} 
?>

კოდი დაბეჭდავს მსგავსს:

Notice: Value must be 1 or below
in C:\webfolder\test.php on line 6

შეცდომის გაშვება შესაძლებელია სკრიპტში, ნებისმიერ ადგილზე და მეორე პარამეტრის დამატებით, ჩვენ შეგვიძლია შეცდომის დონის სპეციფიკაციის გაკეთება.
შესაძლო შეცდომის ტიპები:
· E_USER_ERROR – გარდაუვალი სამომხმარებლო რან-თაიმ შეცდომა. სკრიპტის მუშაობა შეჩერდება.
· E_USER_WARNING – არაგარდაუვალი სამომხმარებლო რან-თაიმ გაფრთხილება. სკრიპტის მუშაობა არ ჩერდება.
· E_USER_NOTICE – სტანდარტული. სამომხმარებლო რან-თაიმ შენიშვნა. სკრიპტმა იპოვა რაღაც, რომელიც შესაძლოა იყოს შეცდომა.

მაგალითი:
ეს არის E_USER_WARNING მაგალითი. გამოვა შეცდომა, თუ “test” ცვლადი მეტია, ვიდრე “1”. თუ E_USER_WARNING გამოვა ჩვენ გამოვიყენებთ ჩვენ მიერ შექმნილ შეცდომის გამოტანას და შევაჩერებთ სკრიპტის მუშაობას:

<?php 
//error handler function 
function customError($errno, $errstr) 
 {  
 echo "<b>Error:</b> [$errno] $errstr<br />"; 
 echo "Ending Script"; 
 die(); 
 } 
//set error handler 
set_error_handler("customError",E_USER_WARNING); 
//trigger error 
$test=2; 
if ($test>1) 
 { 
 trigger_error("Value must be 1 or below",E_USER_WARNING); 
 } 
?>

კოდი დაბეჭდავს მსგავსს:

Error: [512] Value must be 1 or below
Ending Script

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

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

<?php 
//error handler function 
function customError($errno, $errstr) 
 {  
 echo "<b>Error:</b> [$errno] $errstr<br />"; 
 echo "Webmaster has been notified"; 
 error_log("Error: [$errno] $errstr",1, 
 "someone@example.com","From: webmaster@example.com"); 
} 
//set error handler 
set_error_handler("customError",E_USER_WARNING); 
//trigger error 
$test=2; 
if ($test>1) 
 { 
 trigger_error("Value must be 1 or below",E_USER_WARNING); 
 } 
?>

კოდი დაბეჭდავს მსგავსს:

Error: [512] Value must be 1 or below
Webmaster has been notified

და ელ-ფოსტაზე მიიღება მსგავსი:

Error: [512] Value must be 1 or below

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

PHP გამონაკლისი

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

ქვემოთ ნაჩვენებია შეცდომის გამოტანის სხვადასხვა მეთოდები:

· ბაზური გამოყენების გამონაკლისები
· ინდივიდუალური გამონაკლისების შექმნა
· რამოდენიმე გამონაკლისი
· გამონაკლისის ასხლეტვა
· ზე-დონის გამონაკლისის გამომტანის კონფიგურაციები

შენიშვნა: გამონაკლისების გამოყენება შესაძლოა მხოლოდ შეცდომისთვის და ის არ გამოიყენება კოდის სხვა წერტილში გადასახტომად.
ბაზური გამოყენების გამონაკლისები
როდესაც გამონაკლისი გასროლილია, მასზე გაყოლილი კოდი არ იმუშავებს და PHP შეეცდება იპოვოს “დაჭერა” ბლოკის დამთხვევა.
თუ გამონაკლისი არ იქნება დაჭერილი, გამოვა გარდაუვალი შეცდომა “Uncaught Exception” შეტყობინებით.
მაგალითი:

<?php 
//create function with an exception 
function checkNum($number) 
 { 
 if($number>1) 
  { 
  throw new Exception("Value must be 1 or below"); 
  } 
 return true; 
 } 
 
//trigger exception 
checkNum(2); 
?>

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

Fatal error: Uncaught exception ‘Exception’
with message ‘Value must be 1 or below’ in C:\webfolder\test.php:6
Stack trace: #0 C:\webfolder\test.php(12):
checkNum(28) #1 {main} thrown in C:\webfolder\test.php on line 6

ცდა, გასროლა და დაჭერა
ზემოთ მოყვანილ მაგალითში შეცდომისგან თავის ასარიდებლად, ჩვენ გვჭირდება შევქმნათ გამონაკლისის გამოტანის ჩვეული კოდი.
გამონაკლისის ჩვეული კოდი შეიცავს:
1. ცდა – ფუნქცია იყენებს გამონაკლისს, რომელიც იქნება “try” ბლოკში. თუ გამონაკლისი არ გაეშვება, კოდი გააგძელებს ნორმალურად მუშაობას. თუმცა, თუ გამონაკლისი გაეშვება, გამონაკლისი იქნება”გასროლილი”.
2. გასროლა – ეს არის, თუ როგორ ვუშვებთ გამონაკლისს. თითოეულ “გასროლას” უნდა ჰქონდეს სულ მცირე ერთი “დაჭერა”.
3. დაჭერა- “დაჭერა” ბლოკი იპოვის გამონაკლისს და შექმნის ობიექტს, რომელიც შეიცავს გამონაკლისის ინფორმაციას.

მაგალითი:

<?php 
//create function with an exception 
function checkNum($number) 
 { 
 if($number>1) 
  { 
  throw new Exception("Value must be 1 or below"); 
  } 
 return true; 
 } 
 
//trigger exception in a "try" block 
try 
 { 
 checkNum(2); 
 //If the exception is thrown, this text will not be shown 
 echo 'If you see this, the number is 1 or below'; 
 } 
 
//catch exception 
catch(Exception $e) 
 { 
 echo 'Message: ' .$e->getMessage(); 
 } 
?>

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

Message: Value must be 1 or below

მაგალითის ახსნა:
ზემოთ მოყვანილი კოდი ისვრის და იჭერს გამონაკლისებს:
1. checkNum() ფუნქცია შექმნილია. ის ამოწმებს, რიცხვი მეტია, თუ არა 1-ზე. თუ ის მეტია, გამონაკლისი გაისროლება.
2. checkNum() ფუნქცია გამოძახებულია “try” ბლოკში
3. გამონაკლისი checkNum() ფუნქციაში გასროლილია
4. “catch” ბლოკი პოულობს გამონაკლისს და ქმნის ობიექტს($e) , რომელიც შეიცავს გამონაკლისის ინფორმაციას
5. შეცდომის შეტყობინება გამონაკლისიდან დაბეჭდილია $e->getMessage()-ის გამოძახებით გამონაკლისი ობიექტიდან.

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

<?php 
class customException extends Exception 
 { 
 public function errorMessage() 
  { 
  //error message 
  $errorMsg = 'Error on line '.$this->getLine().' in '.$this->getFile() 
  .': <b>'.$this->getMessage().'</b> is not a valid E-Mail address'; 
  return $errorMsg; 
  } 
 } 
$email = "someone@example...com"; 
try 
 { 
 //check if  
 if(filter_var($email, FILTER_VALIDATE_EMAIL) === FALSE) 
  { 
  //throw exception if email is not valid 
  throw new customException($email); 
  } 
 } 
catch (customException $e) 
 { 
 //display custom message 
 echo $e->errorMessage(); 
 } 
?>

ახალი კლასი არის ძველი გამონაკლისის კლასის ასლი errorMessage() ფუნქციით. მას შემდეგ რაც ის გახდა ძველი კლასის ასლი და მას მემკვიდრეობით მიენიჭა ძველი კლასის თვისებები და მეთოდები, ჩვენ შეგვიძლია გამოვიყენოთ შემდეგი გამონაკლისების კლასის მეთოდები – getLine() და getFile() და getMessage().
მაგალითის ახსნა:
ზემოთ მოყვანილი კოდი გაისვრის გამონაკლისს და დაიჭერს მას ინდივიდუალური გამონაკლისის კლასით:
1. customException() კლასი შექმნილია, როგორც ძველი გამონაკისის კლასის გაფართოება. ამ მეთოდით ის მემკვიდრეობით იღებს ძველი კლასის თვისებებს და მეთოდებს
2. errorMessage() ფუნქცია შექმნილია. ფუნქცია დააბრუნებს შეცდომის შეტყობინებას, თუ ელ-ფოსტის მისამართი არასწორია
3. “try” ბლოკი ამუშავდა და გამონაკლისი გაისროლა, მას შემდეგ რაც ელ-ფოსტის მისამართი არასწორი აღმოჩნდა
4. “catch” ბლოკი იჭერს გამონაკლისს და გამოსახავს შეცდომის შეტყობინებას

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

<?php 
class customException extends Exception 
{ 
public function errorMessage() 
{ 
//error message 
$errorMsg = 'Error on line '.$this->getLine().' in '.$this->getFile() 
.': <b>'.$this->getMessage().'</b> is not a valid E-Mail address'; 
return $errorMsg; 
} 
} 
 
$email = "someone@example.com"; 
 
try 
 { 
 //check if  
 if(filter_var($email, FILTER_VALIDATE_EMAIL) === FALSE) 
  { 
  //throw exception if email is not valid 
  throw new customException($email); 
  } 
 //check for "example" in mail address 
 if(strpos($email, "example") !== FALSE) 
  { 
  throw new Exception("$email is an example e-mail"); 
  } 
 } 
 
catch (customException $e) 
 { 
 echo $e->errorMessage(); 
 } 
catch(Exception $e) 
 { 
 echo $e->getMessage(); 
 } 
?>

მაგალითის ახსნა:
ზემოთ მოყვანილი კოდი ტესტირებას უკეთებს ორ პირობას და გაისვრის გამონაკლისს, თუ არ შეხვდა რომელიმე პირობა:
1. customException() კლასი შექნილია როგორც ძველი გამონაკლისის გაფართოება.
2. errorMessage() ფუნქცია შექმნილია. ფუნქცია დააბრუნებს შეცდომის შეტყობინებას, თუ ელ-ფოსტის მისამართი არასწორია
3. “try” ბლოკი გაშვებულია და გამონაკლისი გასროლილია პირველ პირობაზე
4. მეორე პირობა უშვებს გამონაკლისს მას მერე, რაც ელ-ფოსტა შეიცავს სტრინგს “example”
5. “catch” ბლოკი იჭერს გამონაკლისს და გამოსახავს შეცდომის შეტყობინებას
თუ არ მოხდება ინდივიდუალური გამონაკლისის დაჭერა, დაიჭირება მხოლოდ ბაზური გამონაკლისი, გამონაკლისი გამოვა იქ.
გამონაკლისების ასხლეტა
ზოგჯერ, როდესაც გამონაკლისი გაისროლება, ჩვენ შესაძლოა ვისურვოთ მისი გამოტანა სტანდარტული გზისგან განსხვავებულად. ეს შესაძლებელია გამონაკლისის მეორეჯერ გასროლით “catch” ბლოკში.
სკრიპტი დამალავს შეცდომას მომხმარებლებისაგან. სისტემური შეცდომები შესაძლებელია მნიშვნელოვანი იყოს პროგრამისტისათვის, მაგრამ ეს არ აინტერესებდეს მომხმარებელს. იმისათვის რომ გავაკეთოთ მსგავსი რამ მომხმარებლისათვის ჩვენ შეგვიძლია გავაკეთოთ გამონაკლისის ასხლეტა ”მეგობრული” შეტყობინებით:

<?php 
class customException extends Exception 
 { 
 public function errorMessage() 
  { 
  //error message 
  $errorMsg = $this->getMessage().' is not a valid E-Mail address.'; 
  return $errorMsg; 
  } 
 } 
$email = "someone@example.com"; 
try 
 { 
 try 
  { 
  //check for "example" in mail address 
  if(strpos($email, "example") !== FALSE) 
   { 
   //throw exception if email is not valid 
   throw new Exception($email); 
   } 
  } 
 catch(Exception $e) 
  { 
  //re-throw exception 
  throw new customException($email); 
  } 
 } 
catch (customException $e) 
 { 
 //display custom message 
 echo $e->errorMessage(); 
 } 
?>

მაგალითის ახსნა:
ზემოთ მოყვანილი მაგალითი ტესტავს ელ-ფოსტის მისამართს, რომელიც შეიცავს სტრინგს “example”, თუ არადა, გამონაკლისი აისხლიტება:
1. customException()კლასი შექნილია როგორც ძველი გამონაკლისის გაფართოება
2. errorMessage()ფუნქცია შექმნილია. ფუნქცია დააბრუნებს შეცდომის შეტყობინებას, თუ ელ-ფოსტის მისამართი არასწორია
3. “try” ბლოკი შეიცავს სხვა “try” ბლოკს, რათა შესაძლებელი იყოს გამონაკლისის ასხლეტა
4. გამონაკლისი გაშვებულია მას შემდეგ, რაც ელ ფოსტა შეიცავს სტრინგს “example”
5. “catch” ბლოკი იჭერს გამონაკლისს და ისხლიტავს “customException”
6. “customException” დაჭერილია და ის გამოსახავს შეცდომის შეტყობინებას
თუ გამონაკლისი არ არის დაჭერილი მიმდინარე “try” ბლოკში, ის მოიძებნება დაჭერის ბლოკში “უფრო მაღალი დონის” საშუალებით.
ზე-დონის გამონაკლისების გამოტანის დასმა

<?php 
function myException($exception) 
{ 
echo "<b>Exception:</b> " , $exception->getMessage(); 
} 
set_exception_handler('myException'); 
throw new Exception('Uncaught Exception occurred'); 
?>

კოდი დაბეჭდავს შემდეგს:

Exception: Uncaught Exception occurred

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

მარტივი წესი: თუკი ვისვრით რამეს, ჩვენ უნდა დავიჭიროთ ის.

PHP ფილტრი

რა არის PHP ფილტრი?
PHP ფილტრი გამოიყენება არა საიმედო წყაროებიდან მოსული მონაცემების დასამტკიცებლად და გასაფილტრად.

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

ფუნქციები და ფილტრები
იმისათვის რომ გავფილტროთ ცვლადი, გამოვიყენოთ ერთ-ერთი ფილტრაციის ფუნქცია:
· filter_var() – სპეციფიური ფილტრით, ფილტრავს თითო ცვლადს
· filter_var_array() – ფლიტრავს რამოდენიმე ცვლადს, ამ, ან სხვა ფილტრით
· filter_input – მივიღოთ ერთი ცვლადი და გავფილტროთ ის
· filter_input_array – მივიღოთ რამოდენიმე ცვლადი და გავფლიტროთ იგი ამ, ან სხვა ფილტრით

ქვემოთ მოყვანილ მაგალითში, ჩვენ ვამტკიცებთ რიცხვის filter_var() ფუნქციას:

<?php 
$int = 123; 
if(!filter_var($int, FILTER_VALIDATE_INT)) 
 { 
 echo("Integer is not valid"); 
 } 
else 
 { 
 echo("Integer is valid"); 
 } 
?>

ზემოთ მოყვანილი კოდი იყენებს “FILTER_VALIDATE_INT” ფილტრს. კოდი დაბეჭდავს: “Integer is valid”.
თუ ვცდით ცვლადს, რომელიც არ არის მთელი (როგორც “123abc”), კოდი დაბეჭდავს: “Integer is not valid”.
დამტკიცება და სანიტარია
აქ მოყვანილია ფილტრის ორი სახეობა:
ფილტრების დამტკიცება:
· გამოიყენება მომხმარებლის მიერ შეყვანილი ინფორმაციის გასაფილტრად
· წესების მკაცრი ფორმატი
ფილტრების სანიტარია:
· გამოიყენება სტრინგის სპეციფიური სიმბოლოების დასაშვებად ან ასაკრძალად
· არ გააჩნია მონაცემთა ფორმატის წესები
· ყოველთვის აბრუნებს სტრინგს

პარამეტრები და დროშები
პარამეტრები და დროშები გამოიყენება სპეციფიურ ფილტრებზე დამატებითი ფილტრაციის პარამეტრების დამატებისთვის.
სხვადასხვა ფილტრებს გააჩნიათ სხვადასხვა პარამეტრები და დროშები.
ქვემოთ მოყვანილ მაგალითში, ჩვენ ვამტკიცებთ filter_var(), “min_range” და “max_range” პარამეტრების მომხმარებელ რიცხვს:

<?php 
$var=300; 
$int_options = array( 
"options"=>array 
 ( 
 "min_range"=>0, 
 "max_range"=>256 
 ) 
); 
if(!filter_var($var, FILTER_VALIDATE_INT, $int_options)) 
 { 
 echo("Integer is not valid"); 
 } 
else 
 { 
 echo("Integer is valid"); 
 } 
?>

ზემოთ მოყვანილი კოდის მსგავსად, პარამეტრები უნდა ჩაიდოს ასოციაციურ მასივში ”options” სახელით. თუ დროშა გამოიყენება მას არ დასჭირდება მასივი.
მას შემდეგ რაც მთელი რიცხვი მიაღწევს “300”-ს, ის არ არის სპეციფიურ მწკრივში და კოდი დაბეჭდავს შემდეგს: “Integer is not valid”.

შეტანის დამტკიცება
პრიველი რაც უნდა გავაკეთოთ, არის ის რომ დამატკიცოთ შეტანილი მონაცემები.
შემდეგ გავფლიტროთ შეტანილი მონაცემები filter_input() ფუნქციის გამოყენებით.
ქვემოთ მოყვანილ მაგალითში, შეყვანილი ცვლადი “email” გაგზავნილია PHP გვერდზე:

<?php 
if(!filter_has_var(INPUT_GET, "email")) 
 { 
 echo("Input type does not exist"); 
 } 	 
 
 
else 
 { 
 if (!filter_input(INPUT_GET, "email", FILTER_VALIDATE_EMAIL)) 
  { 
  echo "E-Mail is not valid"; 
  } 
 else 
  { 
  echo "E-Mail is valid"; 
  } 
 } 
?>

მაგალითის ახსნა:
ზემოთ მოყვანილ მაგალითს გააჩნია ველი, გაგზავნილი “GET” მეთოდით:
1. შევამოწმოთ, თუ არსებობს “GET” ტიპის “email” ცვლადი
2. თუ ცვლადი არსებობს, შევამოწმოთ ელ-ფოსტის მისამართის სისწორე

შეტანის სანიტარია
ჯერ დავრწმუნდეთ რომ შეტანის ველი არსებობს.
შემდეგ გავუკეთოთ სანიტარია შეტანილ მონაცემებს filter_input() ფუნქციის დახმარებით.
ქვემოთ მოყვანილ მაგალითში, ცვლადი “url” გაგზავნილია PHP გვერდზე:

<?php 
if(!filter_has_var(INPUT_POST, "url")) 
 { 
 echo("Input type does not exist"); 
 } 
else 
 { 
 $url = filter_input(INPUT_POST,  
 "url", FILTER_SANITIZE_URL); 
 } 
?>

მაგალითის ახსნა:
ზემოთ მოყვანილ მაგალითს აქვს ველი, გაგზავნილი “POST” მეთოდით:
1. შევამოწმოთ, თუ არსებობს “POST” ტიპის “url” ცვლადი
2. თუ ცვლადი არსებობს, გავუკეთოთ სანიტარიზაცია და მოვაგროვოთ ის $url ცვლადში

თუ სტრინგი ამის მსგავსია : “http://geocg.myweb.ge/”, $url ცვლადი სანიტარიის მერე გამოიყურება ასე:

http://geocg.myweb.ge/

რამოდენიმე შეტანის ფილტრაცია
ფორმა თითქმის ყოველთვის შეიცავს ერთზე მეტ შეტანის ველს. filter_var ან filter_input ფუნქციების გამოძახების თავიდან ასარიდებლად, გამოვიყენოთ filter_var_array, filter_input_array ფუნქციები.
ამ მაგალითში ჩვენ ვიყენებთ filter_input_array() ფუნქციას, რათა გავფილტროთ სამი GET ცვლადი. მიღებული GET ცვლადები არის სახელი, წლოვანება და ელ-ფოსტის მისამართი:

<?php 
$filters = array 
 ( 
 "name" => array 
  ( 
  "filter"=>FILTER_SANITIZE_STRING 
  ), 
 "age" => array 
  ( 
  "filter"=>FILTER_VALIDATE_INT, 
  "options"=>array 
   ( 
   "min_range"=>1, 
   "max_range"=>120 
   ) 
  ), 
 "email"=> FILTER_VALIDATE_EMAIL, 
 ); 
$result = filter_input_array(INPUT_GET, $filters); 
if (!$result["age"]) 
 { 
 echo("Age must be a number between 1 and 120.<br />"); 
 } 
elseif(!$result["email"]) 
 { 
 echo("E-Mail is not valid.<br />"); 
 } 
else 
 { 
 echo("User input is valid"); 
 } 
?>
© აქ გამოქვეყნებული ნებისმიერი რესურსის გამოყენება, დასაშვებია მხოლოდ მისივე გვერდის ბმულის წყაროდ მითითებით!

დატოვე კომენტარი↓

*გთხოვთ წეროთ ქართული ასოებით

 

 

XHTML: დამხმარე კოდები: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <s> <strike> <strong>

*

1 vote, average: 5.00 out of 51 vote, average: 5.00 out of 51 vote, average: 5.00 out of 51 vote, average: 5.00 out of 51 vote, average: 5.00 out of 5

› §44 ფატმანისგან ავთანდილის გამიჯნურება

1081
სჯობს სიშორე დიაცისა, ვისგან ვითა დაითმობის:
გილიზღებს და შეგიკვეთებს, მიგინდობს და მოგენდობის,
მართ ანაზდად გიღალატებს, გაჰკვეთს, რაცა დაესობის,
მით დიაცსა სამალავი არას თანა არ ეთხრობის.
1082
ფატმან ხათუნს ავთანდილის გულსა ნდომა შეუვიდა,
სიყვარული მეტის-მეტი მოემატა, ცეცხლებრ › › ›

DU