Code.ge Blog » PHP

STL: Simple Template Language Preview

იოსები — Wed, 02 Dec 2009 08:41:15 +0000

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

რა არის STL? როგორც სათაურმა მიგანიშნათ ეს არის PHP – ზე დაწერილი მარტივი და მოქნილი შაბლონების ენა და ამ ენის პროცესორი. STL არის მარტივად გამოყენებადი შაბლონების ენა რომელიც არის საკმაოდ მარტივად ასათვისებელი თუ თქვენ გაგაჩნიათ ნებისმიერ მსგავს შაბლონების ენასთან სულ მცირედი მუშაობის გამოცდილებაც კი. მისი სინტაქსი წააგავს Django, Jinja2, Smarty და სხვა მსგავსი შაბნოლენბის ენებს.

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

რა არის საჭირო მისი გამოყენებისთვის? სულ მცირედი: 1) თქვენს პროექტში უნდა ჩატვირთოთ stl.lib.php რომლის გადაწერაც შეგიძლიათ ზემოთ მითითებული მისამართიდან; 2) შექმნათ შაბლონი ნებისმიერ ტექსტურ ფორმატში(html, txt, xml და ა.შ); 3) შექმნათ STL_template კლასის ობიექტი, გადასცეთ მას საჭირო ტექსტური შაბლონი და კონტესტური ცვლადები და შეასრულოთ. სულ ეს არის და ეს. როგორ? მაგალითი იხილეთ ქვემოთ:

HTML შაბლონი – test.html

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

{if students}
<h1>This is students list</h1>
<ul>
{for student in students}
<li>
<h2>{fn:ucfirst(strtolower(%student.name%))}</h2>
<ul>
{for friend in student.friends}
<li>%friend.name%</li>
{/for}
</ul>
</li>
{/for}
</ul>
{else}
<h1>The students list is empty :(</h1>
{/if}

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

//შაბლონის ობიექტის შექმნა
$tpl = new STL_template('test.html', true);

//შაბლონში მონაცემების დამატება
$tpl->put('students', array(
array(
'name' => 'John',
'friends' => array(
array(
'name' => 'Ann'
),
array(
'name' => 'Suzan'
),
array(
'name' => 'Tom'
)
)
),
array(
'name' => 'Tom',
'friends' => array(
array(
'name' => 'David'
),
array(
'name' => 'Mary'
)
)
)
));

//შაბლონის პროცესინგი, შესრულება და გამობეჭდვა
echo $tpl->process();

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

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

if/elseif/else ოპერატორი
ეს არის ერთერთი ყველაზე ხშირად გამოყენებადი ოპერატორი და შესაბამისად მაქსიმუმი გავაკეთე იმისთვის რომ მისი გამოყენება მაქსიმალურად ეფექტურად იყოს შესაძლებელი. მაგალითში ნაჩვენები კოდის ფრაგმენტი “{if students}” უბრალოდ ამოწმებს არის თუ არა აღწერილი ცვლადი სახელით “students” და აქვს თუ არა მას მინიჭებული საწყისი მნიშვნელობა. თუმცა პირობა შესაძლებელია იყოს გაცილებით უფრო კომპლექსური. ქვემოთ ნაჩვენებია ამ ოპერატორის გამოყენების ნიმუშები:

1
2
3
4
5
6
7

{if students && someOtherVariable=="some test value" || testValue in someCollection}
Do something
{elseif !students && !someOtherVariable}
Do something else
{else}
UPS :D
{/if}

გარდა if/elseif/else ოპერატორისა ასევე შეგიძლიათ პოპულარული და უმნიშვნელოვანი foreach ოპერატორის გამოყენება, მაგ:

1
2
3

{for student in students}
%student.name%
{/for}

ნაჩვენებ მაგალითში მოხდება “students” კოლექციის იტერაცია ხოლო ყოველი მომდევნო ელემენტის ახალ “student” ცვლადზე მინიჭება. მოგვიანებით კი შეგიძლიათ ახალი “student” ობიექტისა და მისი თვისებების გამოყენება.

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

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

1	{fn:ucfirst(strtolower(%student.name%))}

ფრაგმენტიდან ჩანს რომ ხდება ორი ფუნქციის გამოძახება: 1) strtolower() PHP ფუნქცია რომელიც მნიშვნელობას გადაიყვანს ქვედა რეგისტრის სიმბოლოებში; 2) ucfirst PHP ფუნქცია რომელიც სტრიქონის პირველ სიმბოლოს გადაიყვანს ზედა რეგისტრის სიმბოლოში.

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

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

PHP: Array Tricks Part 1

იოსები — Sat, 07 Feb 2009 09:42:40 +0000

ამ პოსტს ჩემი ერთი მეგობრის თხოვნით ვწერ რომელთანაც გუშინ საუბარი მქონდა PHP – ს მასივებსა და for/foreach კონსტრუქციებთან მუშაობის შესახებ.

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

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

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

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

1
2
3

function getArray($flag) {
return $flag == true ? array(1, 2, 3) : null;
}

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

1
2
3
4
5
6

//თუ ფუნქციამ დააბრუნებს მასივს გამოვბეჭდოთ მისი მნიშვნელობები
if ($array = getArray(true)) {
foreach($array as $key => $value) {
printf('key = %s and value = %s
', $key, $value);
}
}

ნჩვენებ კოდში ვიძახებთ getArray(true) ფუნქციას და ვანიჭებთ მას $array ცვლადს, რადგან ეს ხდება IF პირობის ოპერატორში მნიშვნელობის შემოწმებაც მომენტალურად ხდება და მისი არსებობის შემთხვევაში მასივის ელემენტები გამოიბეჭდება ეკრანზე.

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

1
2
3
4
5
6
7
8
9

//ეს ფუნქცია ნებისმიერ შემთხვევაში აბრუნებს მასივს
function getArray($flag) {
return $flag == true ? array(1, 2, 3) : array();
}

$array = getArray(true);
foreach($array as $key => $value) {
printf('key = %s and value = %s
', $key, $value);
}

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

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

1
2
3
4
5
6
7
8
9
10
11

//ეს ფუნქცია ნებისმიერ შემთხვევაში აბრუნებს მასივს
function getArray($flag) {
//ფუნქციის გამოძახების ინდიკატორი
echo ('invoked
');
return $flag == true ? array(1, 2, 3) : array();
}

//getArray() ფუნქციის გამოძახება foreach კონსტრუქციაში
foreach(getArray(true) as $key => $value) {
printf('key = %s and value = %s
', $key, $value);
}

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

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

1
2
3
4

//getArray() ფუნქციის დაბრუნებული მნიშვნელობის მინიჭება
foreach($array = getArray(true) as $key => $value) {
printf('key = %s and value = %s
', $key, $value);
}

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

და ასევე ბონუსის სახით გეტყვით რომ თუ მაინც გვესაჭიროება IF პირობის შესრულება ისე როგორც ეს ნაჩვენები იყო პირველ მაგალითში არც ამაზეა არანაირი პრობლემა

პირველ მაგალითში ნაჩვენები პირობა, ანუ:

if ($array = getArray(false)) {
   //rest of code here
}

იმუშავებს ერთნაირად მიუხედავად იმისა ფუნქცია დააბრუნებს ცარიელ მასივსა თუ null მნიშვნელობას რადგან PHP fale, null, array() და 0 მნიშვნელობის ასეთი შემოწმების შემთხვევაში ყოველთვის დააბრუნებს false – ს.

PHP: Document Root for FTP Client?

იოსები — Sat, 17 Jan 2009 13:52:29 +0000

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

სერვერზე ფაილებთან მუშაობა PHP – ს შესაბამისი ფუნქციებით(fopen, fwrite, touch და ა.შ) საკმაოზე უფრო მოუხერხებელია უსაფრთხოების დეტალების გამო. არავისთვის არ წარმოადგენს საიდუმლოს რომ ვებ სერვერზე განთავსებულ ფაილებს უნდა გააჩნდეთ შექმნის, ჩაწერის, წაკითხვისა და წაშლის შეზღუდვები.

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

რატომ FTP? იმიტომ, რომ სწორედ FTP მომხმარებელს გააჩნია ფაილებთან წვდომის შესაბამისი პერმიშენები, განსხვავებით იმ მომხმარებლისგან რომელიც ტრადიცულად აქვს PHP – ს.

პრობლემა
რამდენადაც ყველასათვის ცონბილია ვებ აპლიკაცია მუშაობს ე.წ. DOCUMENT_ROOT – ის შიგნით. მაგ:

/home/code.ge/public_html

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

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

//ტრადიციული შემთხვევა
/home/code.ge/public_html/dir/some-file.gif
//FTP - ს კლიენტის გამოყენების შემთხვევაში
/public_html/dir/some-file.gif

განსხვავება თვალსაჩიანოა?

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

მარტივ შემთხვევაში ამ პრობლემის გადასაჭრელად უბრალოდ საკმარისია მსგავსი PHP კოდის დაწერა:

1
2
3
4
5
6

$ftp_mode = true;
if ($ftp_mode) {
define('_DOC_ROOT', '/public_html');
} else {
define('_DOC_ROOT', $_SERVER['DOCUMENT_ROOT']);
}

ამ შემთხვევაში ფაილებთან მუშაობისას გაუგებრობების თავიდან ასარიდებლად ყოველი ფაილის მისამართის წინ უბრალოდ შეგვიძლია “_DOC_ROOT” კონსტანტის გამოყენება, მაგ:

1
2
3
4

//FTP მოდულის გამოყენებით
ftp_mkdir($conn, _DOC_ROOT . '/foldername');
//ან უბრალოდ
mkdir(_DOC_ROOT . '/foldername');

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

//მიმდინარე დირექტორია FTP კლიენტისათვის
$pwd = ftp_pwd($conn);

//ვინდოუსის შემთხვევაში დავიზღვიოთ თავი და შევცვალოთ მარცხენა სლეში მარჯვენათი
$pwd = str_replace('\', '/', $pwd);

//თუ მიმდინარე დირექტორია არ არის უბრალოდ "/", მოვაშალოთ თავსა და ბოლოში სლეშები
if ($pwd !== '/') {
$pwd = trim($pwd, '\/');
}

//აპლიკაციის ინსტალაციის დირექტორია, იგულისხმება რომ იგი ავტომატურად გამოთვლილია სკრიპტის მიერ
define('_APP_PATH', '/my-app-path');

//დავამუშავოთ ვებ სერვერის DOCUMENT_ROOT და მივამატოთ მას აპლიკაციის ინსტალაციის დირექტორია
$docroot = preg_replace(
array('~\\\~', '~^[a-z]:~i', '~^/|/$~'),
array('/', '', ''),
$_SERVER['DOCUMENT_ROOT']
) . _APP_PATH;

//დამხმარე ფუნქცია დროებითი მისამართის გენერაციისათვის
function path($pwd, $path) {
$tokens = array();
if ($pwd = trim($pwd, '\/')) {
$tokens[] = $pwd;
}
$tokens[] = $path;
return '/' . implode('/', $tokens);
}

//DOCUMENT_ROOT დავყოთ ნაწილებად
$tokens = explode('/', $docroot);
$apppath = null;

//შევასრულოთ ftp_chdir ფუნქცია იქამდე სანამ იგი არ დაგვიბრუნებს "true" - ს
while(ftp_chdir($conn, $apppath = path($pwd, implode('/', $tokens))) !== true) {
//DOCUMENT_ROOT მასივიდან ყოველ იტერაციაზე ამოვაგდოთ მასივის დასაწყისში მყოფი ელემენტი
array_shift($tokens);
$apppath = null;
}

//გამოვბეჭდოთ გამოთვლილი დირექტორია
echo $apppath;

სულ ეს არის

Mac Os X XAMPP: Tidy – ს ინსტალაცია PHP-5.2.6 – სთვის

იოსები — Thu, 18 Dec 2008 08:35:50 +0000

ამ პოსტში მინდა მოგითხროთ პატარა ისტორია Mac OS X – ზე PHP – ს რეკომპილაციით მიღებულ “სიამოვნებასა” და უსაზღვრო “კომფორტზე” რომელიც ბოლო ორი დღის განმავლობაში მივიღე.

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

რა არის საჭირო ამ მიზნის მისაღწევად? მივყვეთ ნაბიჯ ნაბიჯ:

შეინახეთ ყველა არსებული პროექტი უსაფრთხო ადგილას;
გაანადგუროთ ყველა არსებული PHP ინსტალაცია, ამისათვის ტერმინალში აკრიფეთ შემდეგი ბრძანებები:
```
sudo rm -rf /Applications/xampp
sudo rm -rf /usr/include/php
sudo rm -rf /usr/lib/php
```
გადმოწეროთ XAMPP ის ბოლო ვერსია და დააინსტალირეთ;
გადმოწერეთ XAMPP – ის დეველოპერ პაკეტი ნებისმიერ ადგილას, შედით შესაბამის კატალოგში და დააინსტალირეთ შემდეგი ბრძანებით:
```
sudo tar xvfpz xampp-macosx-0.7.4-dev.tar.gz -C /Applications/xampp
```
გადმოწერეთ PHP 5.2.6 – ის დისტრიბუტივი და გახსენით არქივი ნებისმიერ მისამართზე, მაგ:
```
/Users/iosebdzmanashvili/Documents/PHP/php-5.2.6
```

გაუშვით XAMPP, შექმენით ნებისმიერი PHP ფაილი და გამობეჭდეთ phpinfo.

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

./configure --prefix=/Applications/xampp/xamppfiles --program-suffix=-5.2.6 --libdir=/Applications/xampp/xamppfiles/lib/php/php5 --includedir=/Applications/xampp/xamppfiles/include/php/php5 --with-apxs2=/Applications/xampp/xamppfiles/bin/apxs --with-config-file-path=/Applications/xampp/etc --with-mysql=/Applications/xampp/xamppfiles --disable-debug --enable-bcmath --enable-calendar --enable-ctype --enable-dbase --enable-discard-path --enable-exif --enable-filepro --enable-force-cgi-redirect --enable-ftp --enable-gd-imgstrttf --enable-gd-native-ttf --with-ttf --enable-magic-quotes --enable-memory-limit --enable-safe-mode --enable-shmop --enable-sigchild --enable-sysvsem --enable-sysvshm --enable-track-vars --enable-trans-sid --enable-wddx --enable-yp --with-ftp --with-ncurses=/Applications/xampp/xamppfiles --with-gdbm=/Applications/xampp/xamppfiles --with-jpeg-dir=/Applications/xampp/xamppfiles --with-png-dir=/Applications/xampp/xamppfiles --with-freetype-dir=/Applications/xampp/xamppfiles --without-xpm --with-zlib=yes --with-zlib-dir=/Applications/xampp/xamppfiles --with-openssl=/Applications/xampp/xamppfiles --with-expat-dir=/Applications/xampp/xamppfiles --enable-xslt=/Applications/xampp/xamppfiles --with-xsl=/Applications/xampp/xamppfiles --with-dom=/Applications/xampp/xamppfiles --with-ldap=/Applications/xampp/xamppfiles --with-gd=/Applications/xampp/xamppfiles --with-mysql-sock=/Applications/xampp/xamppfiles/var/mysql/mysql.sock --with-mcrypt=/Applications/xampp/xamppfiles --with-mhash=/Applications/xampp/xamppfiles --enable-sockets --with-curl=/Applications/xampp/xamppfiles --enable-mbregex --enable-zend-multibyte --with-zip=/Applications/xampp/xamppfiles --enable-exif --with-sqlite --with-libxml-dir=/Applications/xampp/xamppfiles --enable-soap --enable-pcntl --enable-dbx --with-mysqli=/Applications/xampp/xamppfiles/bin/mysql_config --with-bz2=/Applications/xampp/xamppfiles --with-ming=shared,/Applications/xampp/xamppfiles --with-pear=/Applications/xampp/xamppfiles/lib/php/pear --with-mssql=/Applications/xampp/xamppfiles --with-imap-dir=/Applications/xampp/xamppfiles --with-imap=/Applications/xampp/xamppfiles --enable-mbstring=all,/usr --with-gettext=/Applications/xampp/xamppfiles --with-pdo-mysql=/Applications/xampp/xamppfiles

ახლა იწყება ყველაზე საინტერესო და არასასიამოვნო პროცესი რომლის გარკვევაზეც არცთუ ცოტა დრო დამეხარჯა:

გახსენით ფაილი:
```
/Users/iosebdzmanashvili/Documents/PHP/php-5.2.6/ext/tidy/tidy.c
```
მოძებნეთ გახსნილ ფაილში #include “tidy.h” და გადაიტანეთ იგი ფაილის დასაწყისში.
tidy – ს xampp – ში დასაკოპირებლად ტერმინალში აკრიფეთ შემდეგი ბრძანება:
```
sudo ditto /usr/include/tidy /Applications/xampp/xamppfiles/include
```
ეს პროცედურა მნიშნველოვანია რადგან PHP – სთან არსებული კონფლიქტის გამო საჭიროა tidy – ს ფაილებში ცვლილების შეტანა, ხოლო XAMPP – ში tidy არ დევს.

ახლად დაკოპირებული კატალოგიდან გახსენით ფაილი:

/Applications/xampp/xamppfiles/include/tidy/platform.h

და 526 – ე ხაზიდან 531 ხაზის ჩათვლით არსებული კოდი:

#if !defined(HPUX_OS) && !defined(CYGWIN_OS) && !defined(MAC_OS_X) && !defined(BE_OS) && !defined(SOLARIS_OS) && !defined(BSD_BASED_OS) && !defined(OSF_OS) && !defined(IRIX_OS) && !defined(AIX_OS) && !defined(LINUX_OS)
typedef unsigned int uint;
#endif
#if defined(HPUX_OS) || defined(CYGWIN_OS) || defined(MAC_OS) || defined(BSD_BASED_OS) || defined(_WIN32)
typedef unsigned long ulong;
#endif

ჩაანაცვლეთ შემდეგი კოდით რათა თავიდან ავირიდოთ PHP – სთან არათავსებადობის პრობლემა:

#if !defined(HPUX_OS) && !defined(CYGWIN_OS) && !defined(MAC_OS_X) && !defined(BE_OS) && !defined(SOLARIS_OS) && !defined(BSD_BASED_OS) && !defined(OSF_OS) && !defined(IRIX_OS) && !defined(AIX_OS) && !defined(LINUX_OS)
#undef uint; /* avoid conflict with PHP */
typedef unsigned int uint;
#endif
#if defined(HPUX_OS) || defined(CYGWIN_OS) || defined(MAC_OS) || defined(BSD_BASED_OS) || defined(_WIN32)
#undef ulong; /* avoid conflict with PHP */
typedef unsigned long ulong;
#endif

შენახულ PHP – ს კონფიგურაციას დაამატეთ შემდეგი ორი პარამეტრი.

იმ შემთხვევაში iconv არ არის თქვენს კონფიგურაციაში, საჭიროა მისი ცხადად მითითება, წინააღმდეგ შემთხვევაში კომპილაცია წარუმატებელი იქნება:
```
--with-iconv=/Applications/xampp/xamppfiles
```
ასევე მიუთითეთ tidy – ს გასააქტიურებლად საჭირო პარამეტრი:
```
--with-tidy=/Applications/xampp/xamppfiles
```

კონფიგურაციის პარამეტრების მომზადების შემდეგ ტერმინალიდან გადადით PHP – ს დისტრიბუტივის კატალოგში:

cd /Users/iosebdzmanashvili/Documents/PHP/php-5.2.6

და ტერმინალში შეასრულეთ შემდეგი ბრძანება:

./configure --prefix=/Applications/xampp/xamppfiles --program-suffix=-5.2.6 --libdir=/Applications/xampp/xamppfiles/lib/php/php5 --includedir=/Applications/xampp/xamppfiles/include/php/php5 --with-apxs2=/Applications/xampp/xamppfiles/bin/apxs --with-config-file-path=/Applications/xampp/etc --with-mysql=/Applications/xampp/xamppfiles --disable-debug --enable-bcmath --enable-calendar --enable-ctype --enable-dbase --enable-discard-path --enable-exif --enable-filepro --enable-force-cgi-redirect --enable-ftp --enable-gd-imgstrttf --enable-gd-native-ttf --with-ttf --enable-magic-quotes --enable-memory-limit --enable-safe-mode --enable-shmop --enable-sigchild --enable-sysvsem --enable-sysvshm --enable-track-vars --enable-trans-sid --enable-wddx --enable-yp --with-ftp --with-ncurses=/Applications/xampp/xamppfiles --with-gdbm=/Applications/xampp/xamppfiles --with-jpeg-dir=/Applications/xampp/xamppfiles --with-png-dir=/Applications/xampp/xamppfiles --with-freetype-dir=/Applications/xampp/xamppfiles --without-xpm --with-zlib=yes --with-zlib-dir=/Applications/xampp/xamppfiles --with-openssl=/Applications/xampp/xamppfiles --with-expat-dir=/Applications/xampp/xamppfiles --enable-xslt=/Applications/xampp/xamppfiles --with-xsl=/Applications/xampp/xamppfiles --with-dom=/Applications/xampp/xamppfiles --with-ldap=/Applications/xampp/xamppfiles --with-gd=/Applications/xampp/xamppfiles --with-mysql-sock=/Applications/xampp/xamppfiles/var/mysql/mysql.sock --with-mcrypt=/Applications/xampp/xamppfiles --with-mhash=/Applications/xampp/xamppfiles --enable-sockets --with-curl=/Applications/xampp/xamppfiles --enable-mbregex --enable-zend-multibyte --with-zip=/Applications/xampp/xamppfiles --enable-exif --with-sqlite --with-libxml-dir=/Applications/xampp/xamppfiles --enable-soap --enable-pcntl --enable-dbx --with-mysqli=/Applications/xampp/xamppfiles/bin/mysql_config --with-bz2=/Applications/xampp/xamppfiles --with-ming=shared,/Applications/xampp/xamppfiles --with-pear=/Applications/xampp/xamppfiles/lib/php/pear --with-mssql=/Applications/xampp/xamppfiles --with-imap-dir=/Applications/xampp/xamppfiles --with-imap=/Applications/xampp/xamppfiles --enable-mbstring=all,/usr --with-gettext=/Applications/xampp/xamppfiles --with-pdo-mysql=/Applications/xampp/xamppfiles --with-iconv=/Applications/xampp/xamppfiles --with-tidy=/Applications/xampp/xamppfiles

./configure ოპერაციის დასრულების შემდეგ ტერმინალში აკრიფეთ შემდეგი სამი ბრძანება:

პროცესის დასრულების შემდეგ:

make clean //გაუგებრობების თავიდან ასაცილებლად
make //აქ შეგიძლიათ ყავა მოიმზადოთ, სიგარეტი მოწიოთ და კურიერს უყუროთ   
sudo make install

გილოცავთ! ინსტალაცია დასრულებულია გადატვირთეთ Apache და განაგრძეთ მუშაობა

P.S.
ფაილების მისამართებში გამოყენებული მომხმარებელის სახელი “iosebdzmanashvili” უნდა შეცვალოთ თქვენი მომხმარებლის სახელით

PHP 5.3 alpha1 – ცვლილებები ენაში

იოსები — Thu, 28 Aug 2008 13:14:14 +0000

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

თუმცა, მიუხედავად ყველაფრისა ცხოვრება გრძელდება და მეც ვცდილობ დავუბრუნდე ჩვეულ რითმს, რასაც ამ მცირე მიმოხილვით დავიწყებ

მიმდინარე წლის დასაწყისში ენდი გუტმანსმა გააკეთა გარკვეული პროგნოზები თუ როგორი იქნებოდა ტექნოლოგიუირი 2008 წელი

გარკვეული პერიოდის შემდეგ Google – ს თანამშროლმელმა და ajaxian.com – ის რედაქტორმა, Dion Almaer – მა, დაწერა საპასუხო პოსტი – Andi Gutmans Predicts – ენდის პროგნოზების შესახებ… რომლის ბოლო აბზაციც თავად PHP – განვითარებასა და მომავალს ეხება:

I wonder what 2008 will be like for PHP, Andi. I have no doubt that it will continue to power a huge number of websites. But, what is PHP doing in 2008 to increase its share in the non-hacker-kiddie crowd? Is the Zend Framework going to compete with Rails and the like? How is PHP going to evolve? I want to be able to do richer DSLs with full open classes and meta-support.

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

მაშ ასე რა ცვლილებებთან გვაქვს საქმე?

Namespace

ნეიმსპეისები, რომელიც პირველი PHP 5 – ის ალფა რელიზში იყო და შემდეგ უკვე გაუგებარი მიზეზების გამო რამდენიმე წლით გაქრა… ეს არის ძალიან, ძალიან სასარგებლო თვისება ენისა კოდის უკეთესი ორგანიზებისათვის. იგივე შესაძლებლობა გვხდება C# – ში, ანალოგიური სახელით და ასევე Java – ში პაკეტების სახელით.

Late Static Bindings და __callStatic()

სტატიკური გვიანი დაკავშირება. OOP – ს მცოდნეთათვის არ არის უცხო გვიანი დაკავშირების(Late Binding) კონცეფცია, და დამეთანხმებით რომ იგი მიეკუთვნება ობიექტზე ორიენტირებული პრინციპების ერთერთ უმნიშვნელოვანეს შესაძლებლობათა რიცხვს. PHP – ში გვიანი დაკავშირება აქამდე ვრცელდებოდა მხოლოდ ობიექტების იერარქიის კონტექსტში. ამიერიდან ეს უკვე შესაძლებელია სტატიკური მემკვიდრეობის კონტექსტშიც. ჩემის აზრით ენის ეს ახალი შესაძლებლობა ძალიან მნიშვნელოვანია.

ასევე ამ განახლების რიგს მიეუკთვნება ე.წ. ჯადოსნური(magic) __callStatic მეთოდის გამოჩენა… PHP 5 – ის მცოდნეთათვის არ არის უცხო __call ჯადოსნური მეთოდი რომელიც გამოიძახება არ არსებულ მეთოდზე მიმართვის შემთხვევაში, და იგი ძალიან მოქნილი მექანიზმია მსგავსი სიტუაციების კონტროლისათვის. __call მეთოდი მასიურად არის გამოყენებული PHP – ს SOAP გაფართოვებაში. ვისაც გიმუშავიათ ამ გაფართოვებასთან გამოცდილი გექნებათ აღნიშნული მეთოდის სიმძლავრე… თუმცა აქამდე ეს მეთოდი მხოლოდ ობიექტის კონტექსტში მუშაობდა და სტატიკურ კონტექსტში მისი გამოყენების არანაირი შანსი არ არსებობდა… ახალი ჯადოსნური __callStatic მეთოდით, რომელიც გამოჩნდა ამ განახლებაში უკვე კლასის სტატიკურ კონტექსტსაც გაცილებით უფრო მოქნილსა და სასარგებლოს გახდის.

Lambda functions and closures

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

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

   function replace_in_array ($search, $replacement, $array) {
     $map = function ($text) use ($search, $replacement) {
       if (strpos ($text, $search) > 50) {
         return str_replace ($search, $replacement, $text);
       } else {
         return $text;
       }
     };
     return array_map ($map, $array);
   }

ასევე საგულისხმოა კლასებში _ _invoke ჯადოსნური მეთოდის გამოჩენა. ეს მეთოდი ე.წ. callable object კონცეფციის ნაწილია. ქვემოთ მოყვანილ კოდში ნაჩვენებია ამ მეთოდის გამოყენების მაგალითი:

class Example {
  public function __invoke () {
    echo "Hello World!\n";
  }
}
$foo = new Example;
$foo ();

enjoy

PHP: nl2p(aragraph) vs nl2br

იოსები — Fri, 18 Jul 2008 15:51:49 +0000

როგორ იქცევით ისეთ შემთხვევაში, როდესაც საჭიროა HTML textarea ელემენტიდან მიღებული ტექსტის, HTML დოკუმენტში უცვლელად გამობეჭვდაა საჭირო ანუ ტექსტის ფორმატირების გათვალისწინებით?

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

მაგალითად ასეთი ტექსტი:

ეს არის ჩვეულებრივი აბზაცი.

ეს არის შემდეგი აბზაცი...

და კიდევ ერთი აბზაცი..

ამ შემთხვევაში ტექსტის გამოსაბეჭდად გამოვიყენე

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

როგორც HTML სპეციფიკაცია გვეუბნება, აბზაცების ფორმატირებისათვის უნდა გამოვიყენოთ 
 ტეგი, თუმცა PHP – ს ასეთი ფუნქცია არ გააჩნია.
მარტივი რეგულარული გამოსახულების დახმარებით მივიღე ასეთი ფუნქცია, რომელიც აღწერილ პრობლემას მარტივად და სწრაფად აგვარებს:
1
2
3
function nl2p($input) {

    return preg_replace('~^\s*(.*?)\s*$~smx', '$1
', $input);

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

აღსანიშნავია რომ, ეს ფუნქცია იგნორირებას უკეთებს ერთმანეთის მიყოლებით აკრეფილ ახალი სტრიქონის სიმბოლოებს.
როგორ მუშაობს თავად რეგულარული გამოსახულება:
$regex = '~
    ^            # 1) შევამოწმოთ სტრიქონის დასაწყისი
    \s*          # 2) ნებისმიერი რაოდენობის უხილავი სიმბოლო
    (.*?)        # 3) ნებისმიერი რაოდენობის ნებისმიერი სიმბოლო
    \s*          # 4) ნებისმიერი რაოდენობის უხილავი სიმბოლო
    $            # 5) შევამოწმოთ სტრიქონის დასასრული
~smx'            # 6) smx - გამოსახულების მოდიფიკატორები

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

RoR – ის მამა PHP – აქებს?

იოსები — Tue, 15 Jul 2008 00:35:56 +0000

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

ბევრი წერით არ შეგაწყენთ თავს. უბრალოდ ვიტყვი რომ ეს პოსტი ეკუთვნის თავად David Heinemeier Hansson ცნობილი ფრეიმვორკის Ruby on Rails – ის ავტორს!

The immediacy of PHP

I’ve been writing a little bit of PHP again today. That platform has really received an unfair reputation. For the small things I’ve been used it for lately, it’s absolutely perfect.

I love the fact that it’s all just self-contained. That the language includes so many helpful functions in the box. And that it managed to get distributed with just about every instance of Apache out there.

For the small chores, being quick and effective matters far more than long-term maintenance concerns. Or how pretty the code is. PHP scales down like no other package for the web and it deserves more credit for tackling that scope.

ჩემის აზრით ფრიად საინტერესო და საღი დამოკიდებულებაა PHP – სადმი

PHP: callback ფსევდო ტიპი

იოსები — Thu, 25 Oct 2007 09:23:15 +0000

PHP – ში არსებობს ე.წ. ფესევდო ტიპის ცნება. ფსევდო ტიპები რამდენიმეა და ერთერთი ყველაზე საინტერესო მათ შორის არის callback ფსევდო ტიპი.

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

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

//კლასის სტატიკური მეთოდის გამოძახების შემთხვევაში
array('ClassName', 'methodName')

//კლასის არა სტატიკური მეთოდის გამოძახების შემთხვევაში
array(new ClassName(), 'methodName');

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

თუმცა PHP5 – ში, მეთოდებთან private წვდომის მოდიფიკატორის გამოყენების საშუალება არსებობს, ეს ძალიან სასარგებლოა ხშირ შემთხვევაში რადგან კლასის ინტერფეისისათვის ყოვლად უსარგებლო მეთოდებს მთლიანად ვმალავთ მომხმარებლისათვის. რა ხდება ასეთ დროს როდესაც ვცდილობთ კლასის private მეთოდის გამოყენებას callback პარამეტრის შემთხვევაში?

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

მაგალითად:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

class CallBackTest {

//სტატიკური private მეთოდი რომელიც სტრიქონს გადაიყვანს ქვედა რეგისტრში
private static function testStaticPrivateMethod($param) {
return strtolower($param);
}

//ობიექტის private მეთოდი რომელიც სტრიქონს გადაიყვანს ზედა რეგისტრში
private function testInstanceMethod($param) {
return strtoupper($param);
}

//მასივის გამოსაბეჭდი დამხმარე მეთოდი
private static function pre($arr) {
echo '

';

        print_r($arr);

        echo '

';
}

//public მეთოდი, სტატიკური private testStaticPrivateMethod მეთოდის მუშაობის ტესტირებისათვის
public static function staticTest() {

$input = array(
'Test Value1',
'Value Test',
'Test TEST, TeSt'
);

//callback პარამეტრს გადავცემთ მასივის სახით,
//რომლის პირველი ელემენტი არის self რომელიც მიუთითებს კლასის სტატიკურ კონტექსტს
$r1 = array_map(array('self', 'testStaticPrivateMethod'), $input);

//მასივის გამობეჭდვა
self::pre($r1);

//ამ შემთხვევაში ასევე დასაშვებია ქვემოთ მითითებული კონსტრუქციის გამოყენება
//სადაც self - ის ნაცვლად ვუთითებთ პირდაპირ კლასის სახელს
//$r1 = array_map(array('CallBackTest', 'testStaticPrivateMethod'), $input);

}

//public მეთოდი, არასტატიკური private testInstanceMethod მეთოდის მუშაობის ტესტირებისათვის
public function instanceTest() {

$input = array(
'Test Value1',
'Value Test',
'Test TEST, TeSt'
);

//callback პარამეტრს გადავცემთ მასივის სახით, რომლის პირველი ელემენტი არის მიმდინარე კლასის ობიექტი
$r2 = array_map(array($this, 'testInstanceMethod'), $input);

//მასივის გამობეჭდვა
self::pre($r2);

}

}

//სტატიკური სატესტო მეთოდის გამოძახება
CallBackTest::staticTest();

//კლასის ობიექტის ინსტანციაცია
$o = new CallBackTest();
//ობიექტის სატესტო მეთოდის გამოძახება
$o->instanceTest();

კოდის შესრულების შედეგი CallBackTest::staticTest() გამოძახებისათვის იქნება:

Array
(
    [0] => test value1
    [1] => value test
    [2] => test test, test
)

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

ხოლოდ შედეგი $o->instanceTest() გამოძახებისათვის იქნება:

Array
(
    [0] => TEST VALUE1
    [1] => VALUE TEST
    [2] => TEST TEST, TEST
)

მასივის ყველა მნიშვნელობა გადაყვანილია ზედა რეგისტრში, ეს ნიშნავს იმას რომ ობიექტის private მეთოდმა იმუშავა.

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

Registry პატერნი, array_map და ტექსტში შაბლონით ძებნა

იოსები — Fri, 19 Oct 2007 14:35:54 +0000

ამ დღეებში ვატარებდი მცირე ექსპერიმენტებს ტექსტში შაბლონებით ძიებაზე, და მცირე სასარგებლო აღმოჩენები გავაკეთე. ჩემი ამოცანა მდგომარეობდა იმაში რომ ტექსტში მომეძებნა გარკვეული ფრაგმენტები და შემდეგ ჩამენაცვლებინა ისინი სხვა მნიშვნელობებით, ეს მნიშვნელობები კი სისტემის გლობალური ცვლადები იყო. ფრაგმენტებს ტრადიციული სახე მივეცი რადგან შაბლონებით ძიება მარტივი ყოფილიყო, ანუ რაღაც ამის მსგავსი {var:encoding}, ყველასათვის ცნობილი და მიღებული ფორმით…

როგორ გადავწყვიტე საბოლოოდ ეს ამოცანა? პირველ რიგში მინდა ავღნიშნო რომ არ მიყვარს ე.წ. გლობალური ცვლადების გამოყენება და ამის თავიდან ასარიდებლად ყოველთვის ვიყენებ Registry პატერნს, რომლის მეშვეობითაც იოლად ვირიდებ თავიდან გლობალურ ცვლადებთან მუშაობის არასასიამოვნო დეტალებს.

პატერნის რეალიზაცია PHP5 – ისთვის გამოიყურება შემდეგნაირად(დეტალური ახსნა თუ რანაირად მუშაობს ეს პატერნი იხილეთ ზემოთ მითითებულ ბმულზე):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

class Registry {

private static $stack = array();

public static function add($key, $value) {
self::$stack[$key] = $value;
}

public static function get($key) {
if (isset(self::$stack[$key])) {
return self::$stack[$key];
}
}

public static function has($key) {
return isset(self::$stack[$key]);
}

}

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

1
2
3
4
5
6
7
8
9

//მონაცემების დამატება
Registry::add('encoding', 'UTF-8');
Registry::add('url', 'http://www.code.ge');
Registry::add('test', 'testvar');

//მონაცემების წაკითხვა
Registry::get('encoding');
Registry::get('url');
Registry::get('test');

როგორც ხედავთ ყველაფერი ძალიან მარტივია, და რაც მთავარია არ ვიყენებთ საშინელ $GLOBALS მასივს…

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


     {var:encoding} 
     {var:url} 
     {var:test} 
     {var:fake_variable}

ეს არის ჩვეულებრივი HTML კოდი რომელშიც ჩასმული გვაქვს ე.წ. ცვლადები, შემდეგი სახით: {var:encoding}, {var:url} და ა.შ. ასეთი ტექსტისათვის რეგულარული გამოსახულების შაბლონის დაწერა ძალიან მარტივია /\{(?:var:)(\w+)}/, მისი მეშვეობით შეგვიძლია მოვძებნოთ ყველა საჭირო ფრაგმენტი ტექსტში:

1
2
3
4
5

if (preg_match_all('/\{(?:var:)(\w+)}/', $template, $vars)) {
echo '

';

    print_r($vars);

    echo '

';
}

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

Array
(
    [0] => Array
        (
            [0] => {var:encoding}
            [1] => {var:url}
            [2] => {var:test}
            [3] => {var:fake_variable}
        )

    [1] => Array
        (
            [0] => encoding
            [1] => url
            [2] => test
            [3] => fake_variable
        )

)

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

1
2
3
4
5

if (preg_match_all('/\{(?:var:)(\w+)}/', $template, $vars)) {
$values = array_map(array('Registry', 'get'), $vars[1]);
$template = str_replace($vars[0], $values, $template);
}
echo $template;

ამ კოდის შესრულების შედეგად მივიღებთ უკვე დამუშავებულ შედეგს:


     UTF-8 
     http://www.code.ge 
     Test Variable

როგორ მუშაობს ეს კოდი:

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

ამ ფუნქცის პირველი პარამეტრი არის ე.წ. callback ტიპის. თავისთავად callback PHP – ში წარმოადგენს რთულ ტიპს, ნებისმიერი ფუნქცია რომელიც ღებულობს ამ ტიპის პარამეტრს, შეგვიძლია გადავცეთ ნებისმიერი ფუნქციის სახელი, მაგ: array_map(‘trim’). მასივის მეშვეობით შეგვიძლია გადავცეთ კლასის სახელი და კლასის მეთოდი, მაგ: array_map(array(‘Registry’, ‘get’)) სადაც Registry არის კლასის სახელი, ხოლო get სტატიკური მეთოდის სახელი, და ასევე შეგვიძლია მასივის მეშვეობით გადავცეთ ნებისმიერი კლასის ობიექტი და მეთოდის სახელი, მაგ: array_map(array(new MyClass, ‘myMethod’)).

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

სწორედ ამ ფუნქციის მეშვეობით ვიღებთ Registry კლასიდან ჩვენთვის საჭირო მნიშვნელობებს (რამდენადაც get მეთოდს გადაეცემა $vars მასივის პირველი ელემენტის სათითაო ელემენტი იგი დაგვიბრუნებს შესაბამის მნიშვნელობას ამ key – სთვის, თუ ასეთი არსებობს) და ვანიჭებთ მის მიერ დაბრუნებულ მასივს $values ცვლადს.
str_replace ფუნქციის მეშვეობით ვახორციელებთ საჭირო ფრაგმენტების ჩანაცვლებას მოპოვებული მნიშვნელობებით. ამ ფუნქციას პირველ პარამეტრად გადავცემთ ჩასანაცვლებელი ფრაგმენტების მასივს ($vars[0] მასივი) და მეორე პარამეტრად გადავცმეთ საბოლოო მნიშვნელობებს (array_map – ის მეშვეობით მოვპოვებული $values მასივი), ხოლო მესამე პარამეტრად დაუმუშავებელ შაბლონს, შედეგად ვღებულობთ უკვე დამუშავებულ ტექსტს.

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

PHP 4 end of life announcement – მეფე მოკვდა! გაუმარჯოს მეფეს!

იოსები — Tue, 14 Aug 2007 09:55:54 +0000

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

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

მაშ ასე => მეფე მოკვდა! გაუმარჯოს მეფეს!

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

რითი არის(იყო) PHP4 ცუდი და რატომ არის PHP5 უკეთესი და რის გამო უნდა მოხდეს ენის ამ ვერსიაზე რაც შეიძლება სწრაფი გადასვლა? მათთვის ვისთვისაც ამ ორ ვერსიას შორის სხვაობა უცნობია შეუძლიათ წაიკითხონ ეს პოსტი რომელიც რამდენიმე წლის წინ ვთარგმნე, ანუ მაშინ როდესაც პირველი ოფიციალური რელიზი გამოვიდა. მას მერე უამრავი რამ შეიცვალა PHP5 – ში და საგრძნობლად დაიხვეწა თითქმის სრული ვერსია, თუმცა რაც ყველაზე მთავარი და მნიშვნელოვანია ჩემის აზრით ეს არის ის რომ PHP 5.1.6 ვერსიის გამოსვლის შემოდგომ უკუთავსებადობა PHP – ს წინა ვერსიასთან აყვანიალი 100% – ზე თუ არა 99% – ზე ნამდვილად, რაც უდავოდ უზარმაზარი პლიუსია.

რას მოგვცემს ჩვენ დეველოპერებს ამ ვერსიაზე საბოლოოდ გადასვლა? პირველ რიგში ეს არის ნორმალური პროგრამირების შესაძლებლობა!!! დახვეწილი OOP მოდელი რომელიც რეალიზებული იყო ამ ვერსიაში ნამდვილად რევოლუციის ტოლფასია PHP4 – ის კასტრირებულ OOP მოდელთან შედარებით (თუმცა Java და C# დეველოპერებს ვისთვისაც ეს ენა უცხო გარკვეულ დისკომფორტს შეუქმნის თუნდაც ეს დახვეწილი OOP მოდელი)

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

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

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

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

იოსები — Fri, 01 Jun 2007 05:57:13 +0000

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

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

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

მაგალითად შემდეგი კოდი არის აღწერილი შემთხვევის ნიმუში:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

class Parent {

function Parent() {
echo 'initializing parent';
}

}

class Child extends Parent {

function Child() {
parent::Parent();
echo '
initializing child';
}

}

new Child();

მემკვიდრე კლასიდან ცხადად ვიძახებთ მშობელი კლასის კონსტრუქტორს parent::Parent();. თუ მსგავსად არ იქნება გამოძახებული მშობელი კლასის კონსტრუქტორი იგი არასოდეს არ შესრულდება რამაც შესაძლებელია გარკვეული პრობლემები წარმოქმნას. თუმცა როგორც შემთხვევით აღმოვაჩინე (რამაც დამაბნია და გარკვეული დრო დამაკარგვინა სანამ მივხვდი ) თუ მემკვიდრე კლასსში საერთოდ არ განვსაზღვრავთ კონსტრუქტორს მშობელი კლასის კონსტრუქტორის გამოძახება მოხდება ავტომატურად…

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

class Item {

var $name;

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

}

class Parent {

//class variable
var $item;

/**
* Parent class constructor
* @param Item $item
*/
function Parent(&$item) {
$this->item = &$item;
}

//abstract method
function doSomething() {
die('method is not implemented');
}

}

class Child extends Parent {

//overrided method
function doSomething() {
echo 'Implemented in ' . $this->item->name;
}

}

$o = &new Child(new Item('test item'));
$o->doSomething();

კოდის შესრულების შედეგია:

Implemented in test item

მიუხედავად იმისა რომ Child კლასში არ გვაქვს განსაზღვრული კონსტრუქტორი new Child(new Item(‘test item’)) გამოსახულების შესრულებით იძახება მშობელი(Parent) კლასის კონსტრუქტორი რომელიც პარამეტრად ღებულობს Item ტიპის ობიექტს. ხოლო შემდგომ doSomething() მეთოდში ხდება სწორედ Parent კონსტრუქტორისთვის პარამეტრად გადაცემული Item ობიექტის გამოყენება. აქედან დასკვნა:

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

უფრო მეტიც, მაგალითად თუ შევასრულებთ ასეთ კოდს: new Child() მაშინ PHP გამოგვიტანს შემდეგ გაფრთხილებას Warning: Missing argument 1 for parent()

ფაილების მისამართებთან მუშაობა PHP – თი

იოსები — Wed, 30 May 2007 11:04:50 +0000

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

პლატფორმებს შორის არსებული სხვაობები:

ფაილების გამყოფი: ვინდოუსზე ფაილის გამყოფად გამოიყენება მარცხენა სლეში ანუ \ ხოლო უნიქს სისტემებში იგივე მიზნისთვის გამოიყენება მარჯვენა სლეში /

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

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

არეული ფაილების გამყოფები: მაგალითად შემდეგი მისამართი გარკვეულ პრობლემებს იწვევს – c:\usr\local\www/appdir/datafolder/filename.php
არასაჭირო(ზედმეტი) ფაილის გამყოფები: მაგ. /usr/local/www//appdir///datafolder/filename.php
ზედმეტი წერტილები: მაგ. /usr/local/www//appdir///d..//../atafolder…..//filename.php

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

რა პირობებს უნდა აკმაყოფილებდეს ასეთი კლასი?

იგი არ უნდა იყოს დამოკიდებული ე.წ. DOCUMENT_ROOT – ზე რადგან იმ შემთხვევაში თუ ფაილებთან მუშაობა გვიწევს ftp ფუნქციების მეშვეობით ნაცვლად სტანდარტული ფუნქციებისა, სხვაობა DOCUMENT_ROOT – სა და ftp მისამართებს შორის აუცილებლად იარსებებს;
უნდა აღმოფხვრას ე.წ. არეული ფაილების გამყოფების პრობლემა
გადაცემული მისამართიდან უნდა ააგოს: აპლიკაციის საწყისი მისამართი (დირექტორია სადაც რეალურად არის დაინსტალირებული აპლიკაცია), ფაილის სრული მისამართი (DOCUMENT_ROOT – ის ჩათვლით), ე.წ. relative მისამართი, უნდა გამოყოს ფაილის სახელი მისამართიდან(ფაილის სახელში მოიაზრება როგორც ჩვეულებრივი ფაილი სახელი ასევე დირექტორიის სახელი)

ჩამოთვლილი მიზნების მისაღწევად სავსებით საკმარისია ქვემოთ ნაჩვენები პატარა კლასი:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

class FilePath {

var $docRoot; //document root of the site
var $appPath; //actual application path, document root + application installation folder
var $relPath; //relative path of the requested file
var $absPath; //absolute path of the file, $docRoot concatenated with $relPath
var $fileName; //actual file/directory name

function FilePath($path, $docRoot = null) {

/**
* if no $docRoot was passed used default DOCUMENT ROOT
*/
if (!$docRoot) {
$docRoot = $_SERVER['DOCUMENT_ROOT'];
}

//cleanup document root
$this->docRoot = $this->cleanup($docRoot);

//cleanup application path
$this->appPath = $this->cleanup(dirname(__FILE__));

//cleanup relative path
$this->relPath = $this->cleanup(preg_replace('!^' . $this->appPath . '!', '', $path));

//build absolute path
$this->absPath = $this->appPath . $this->relPath;

//retrive file name from path
$this->fileName = basename($this->relPath);

}

function cleanup($path) {
$path = str_replace('', '/', $path);
$path = preg_replace('!\.+/!', '', $path);
$path = trim(trim($path), '\/');
$path = preg_replace('!/+!', '/', $path);
if (!preg_match('!^\w:!', $path)) {
$path = '/' . $path;
}
return $path;
}

function getDocRoot() {
return $this->docRoot;
}

function getAppPath() {
return $this->appPath;
}

function getRelativePath() {
return $this->relPath;
}

function getAbsolutePath() {
return $this->absPath;
}

function getFileName() {
return $this->fileName;
}

function getParent() {
return dirname($this->absPath);
}

}

კლასს გააჩნია ორ პარამეტრიანი კონსტრუქტორი, სადაც პირველი პარამეტრი არის უშუალოდ იმ ფაილის/დირექტორიის მისამართი რომელთანაც ვაპირებთ მუშაობას, ხოლო მეორე არასავალდებულო პარამეტრი არის ე.წ. DOCUMENT_ROOT – ისთვის რომლის გამოყენებაც შესაძლებელია იმ შემთხვევაში თუ ვმუშოაბთ ftp რეჟიმში(რადგან ftp – ს შემთხვევაში DOCUMENT_ROOT განსხვავდება).

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

მაგალითად თუ აპლიკაცია დაინსტალირებულია /public_html/blog/ დირექტორიაში, ხოლო კონკრეტული სკრიფტში(რომელიც განთავსებულია მისამართზე /public_html/blog/dir/util/filemanager.php) რომლის მეშვეობითაც გვსურს გარკვეული მანიპულაციების ჩატარება /public_html/blog/data/uploads/images/img.gif ფაილზე, საკმარისია დავწეროთ შემდეგი კოდი:

$fp = &new FilePath('data/uploads/images/img.gif);

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

FilePath კლასის გამოყენების მარტივი ნიმუში:

1
2
3
4
5
6
7
8
9
10
11
12
13

$fp = &new FilePath('..//...../data/test...////....\////subdir//anot..../../.\hersubdir/');

echo 'Document Root: ' . $fp->getDocRoot();
echo '

';
echo 'Application Path: ' . $fp->getAppPath();
echo '

';
echo 'Relative Path: ' . $fp->getRelativePath();
echo '

';
echo 'Absolute Path: ' . $fp->getAbsolutePath();
echo '

';
echo 'Parent Directory: ' . $fp->getParent();
echo '

';
echo 'File Name: ' . $fp->getFileName();

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

Document Root: c:/program files/easyphp1-8/www

Application Path: c:/program files/easyphp1-8/www/test/io

Relative Path: /data/test/subdir/anothersubdir

Absolute Path: c:/program files/easyphp1-8/www/test/io/data/test/subdir/anothersubdir

Parent Directory: c:/program files/easyphp1-8/www/test/io/data/test/subdir

File Name: anothersubdir

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

გამოყენების სხვა ნიმუშები:

1
2
3
4
5
6
7
8
9
10
11
12
13

$fp = &new FilePath('data/images/file.jpg');

if (is_dir($fp->getAbsolutePath())) {
echo 'is directory';
}

if (is_file($fp->getAbsolutePath())) {
echo 'is file';
}

if (file_exists($fp->getAbsolutePath())) {
echo 'file exists';
}

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

Quercus – PHP in Java

იოსები — Wed, 28 Mar 2007 13:08:45 +0000

აჟიტირებული ვარ სრული ამ სიტყვის მნიშნველობით… ასეთ რამეს მართლა არ ველოდი და ხელი მქონდა დიდი ხანია ჩაქნეული… ამასწინათ იკას ბლოგზე ვნახე პოსტი სათაურით: Breakthrough: Java Implementation of PHP5 თავისთავად დამაინტერესა(რატომღაც), დღეს გამოვნახე დრო და გავტესტე… სიმართლე უნდა ითქვას შედეგმა ყოველგვარ მოლოდინს გადააჭარბა…

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

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

პირველ რიგში ამისათვის საჭიროა Resin Server – ი, რომელიც კარგად არის ნაცნობი Java დეველოპერებისათვის და იგი შეგიძლიათ გადმოწეროთ შემდეგი მისამართიდან: Resin Pro 3.1.0 Download.

ასევე საჭიროა JDK 5 ან უფრო მაღალი ვერსია, მისი ინსტალაციის ინსტრუქცია შეგიძლიათ ნახოთ ამ მისმართზე.

Resin – ის გადმოწერის შემდეგ საჭიროა მისი დეარქივაცია, ჩემს შემთხვევაში ეს გავაკეთე C:\web\resin მისამართზე. მეტი ინსტალაციისათვის არაფერი არ არის საჭირო. სერვერის გასაშვებად საკმარისია httpd.exe ფაილის გაშვება, ხოლო http://localhost:8080/ მისამართის გახსნის შემდეგ დავინახავთ შესაბამის გვერდს რომელიც გვატყობინებს რომ Resin დასტარტულია.

როგორ გავუშვათ PHP სკრიპტი? ამისათვის საკმარისია C:\web\resin\webapps\ROOT კატალოგში შევქმნათ კატალოგი სასურველი სახელით, ჩემს შემთხვევაში კატალოგს დავარქვი test. შემდეგ ახლად შექმნილ კატალოგში უნდა შევქმნათ WEB-INF კატალოგი და მასში მოვათავსოთ web.xml ფაილი და ჩავწეროთ მასში შემდეგი ინსტრუქციები:


  
    
      iso-8859-1

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

class Test {

private $test;

function __construct() {
$this->test = "this is test";
}

static function runTest() {
return "This is static method";
}

public function getVar() {
return $this->test;
}

public function testArrayList() {

//create ArrayList object
$list = java("java.util.ArrayList", array(1, 2, 3, 4));

//add instance of class Test into arraylist
$list->add(new Test());

//create another ArrayList instance
$l1 = java("java.util.ArrayList", array("Test Array List"));

//add $l1 to $list arraylist object
$list->add($l1);

//output object
echo '

';

    print_r($list);

    

  }

  

}



$t = new Test();



$t->testArrayList();



echo $t->getVar();



echo '
';



echo Test::runTest();

კოდის მუშაობის შედეგი შეგიძლიათ შემოწმოთ http://localhost:8080/test/index.php მისამართზე. როგორც მაგალითიდან ჩანს ჩვეულებრივ PHP – ს კოდთან გვაქვს საქმე რომელიც ისევე ჩვეულებრივად მუშაობს Resin – ზე როგორც იმუშავებდა PHP5/Apache2 ტანდემის შემთხვევაში, თუმცა ყურადღება უნდა მივაქციოთ testArrayList მეთოდს რომელიც უშუალოდ მუშაობს Java – ს ArrayList კლასთან.

java() ფუნქციის მეშვეობით შეგვიძლია ნებისმიერი Java – ს კლასის ობიექტის შექმნა და შემდეგ უკვე მისი გამოყენება PHP კოდში, როგორც მაგალითშია ნაჩვენები ამ ფუნქციას პირველ პარამეტრად გადაეცემა სასურველი Java კლასი, ხოლო შემდეგ პარამეტრებად პარამეტრები Java კლასის კონსტრუქტორის. (საგულისხმოა ის დეტალი რომ Quercus ავტომატურად ახორციელებს Java ობიექტების PHP ობიექტებად გარდაქმნას და პირიქით საჭიროების შემთხვევაში)

java() ფუნქციის მიერ დაბრუნებული ობიექტი შეგვიძლია გამოვიყენოთ ისევე როგორც ამას გავაკეთებდით Java – ში. მაგალითად: $list->add(new Test()); ამ შემთხვევაში add არის ArrayList კლასის მეთოდი. გამომდინარე იქიდან რომ ArrayList არის კონტეინერი მისი იტერაცია შეგვიძლია PHP – ს foreach ოპერატორის გამოყენებით.

დამატებითი დეტალებისთვის დოკუმენტაცია იხილეთ შესაბამის მისამართებზე:
Resin Documentaion
Quercus Documentaion

ბიტური ოპერატორები PHP – ში

იოსები — Tue, 20 Mar 2007 10:13:27 +0000

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

პირველ რიგში მართებული იქნება თუ მიმოვიხილავთ ბაიტებსა და ბიტებს. ცნობილია რომ ბაიტი შედგება რვა(8) ბიტისაგან, ბიტს თავისთავად შეიძლება გააჩნდეს მხოლოდ ორი მნიშვნელობა 1(ერთი) ან 0(ნული). თუ ბიტის მნიშვნელობა უდრის 1 – ს ეს ნიშნავს რომ ბიტი მონიშნულია ხოლო თუ მისი მნიშვნელობა უდროს 0 – ს ეს ავტომატურად ნიშნავს რომ ბიტი არ არის მონიშნული. ბაიტის მაქსიმალური მნიშვნელობა განისაზღვრება 255 – ით, ანუ თუ ბაიტის შემადგენილი ყველა ბიტი არის მონიშნული ბაიტის მნიშვნელობა იქნება 255.

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

1 ბაიტი (8 ბიტი)
ბიტის ინდექსი	7	6	5	4	3	2	1	0
ბიტის მნიშვნელობა	128	64	32	16	8	4	2	1

სადაც “ბიტის ინდექსი” ასახავს ბიტის პოზიციას ბაიტში(ინდექსაცია იწყება 0 – იდან). ხოლოდ “ბიტის მნიშნვნელობა” კონკრეტულ პოზიციაზე ბიტის შესაძლო მნიშვნელობას თუ იგი მონიშნულია(ანუ უდრის 1 – ს).

როგორც ზემოთ ავღნიშნე თუ ბაიტის შემადგენელი ყველა ბიტი არის მონიშნული მაშინ ბაიტის მნიშვნელობა იქნება 255 – ის ტოლი, რაც ვიზუალურად გამოსახულია შემდეგ ცხრილში:

1 ბაიტი (8 ბიტი)
ბიტის ინდექსი	7	6	5	4	3	2	1	0
ბიტის მნიშვნელობა	128	64	32	16	8	4	2	1
	1	1	1	1	1	1	1	1	=	255

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

128 + 64 + 32 + 16 + 8 + 4 + 2 + 1 = 255

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

გამომდინარე აქედან შეგვიძლია გამოვითვალოთ მაგალითად რიცხვი 36:

1 ბაიტი (8 ბიტი)
ბიტის ინდექსი	7	6	5	4	3	2	1	0
ბიტის მნიშვნელობა	128	64	32	16	8	4	2	1
	0	0	1	0	0	1	0	0	=	36

რატომ არის ამ გამოსახულების რეზულტატი 36 – ის ტოლი? რადგან ცხრილში ნაჩვენებია რომ მოვნიშნეთ მხოლოდ ორი ბიტი, სადაც ერთი ბიტის მნიშნელობა არის 32(პოზიცია ინდექსით 5) ხოლო მეორე ბიტის მნიშვნელობა კი 4(პოზიცია ინდექსით 2) შეგვიძლია დავწეროთ ასეთი გამოსახულება:

32 + 4 = 36

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

PHP-ს ბიტური ოპერატორები

შემდეგ ცხრილში მოცემულია ოპერატორების ცხრილი შესაბამისი განმარტებებით:

მაგალითი	დასახელება	რეზულტატი
$a & $b	And	ბიტები რომლებიც მონიშნულია(და საერთოა) ორივე $a და $b ცვლადებში.
$a \| $b	Or	ბიტები რომლებიც მონიშნულია ან $a ან $b ცვლადებში.
$a ^ $b	Xor	ბიტები რომლებიც მონიშნულია ან $a ცვლადში ან $b ცვლადში მაგრამ არა ორივეში.
~ $a	Not	ბიტები რომლებიც არ არის მონიშნული $a ცვლადში, და პირიქით.
$a << $b	Shift left	$a ცვლადის ბიტების წაძვრა $b ბიჯით მარცხნივ(ყოველი ბიჯი ნიშნავს “გაამრავლზე ორზე”)
$a >> $b	Shift right	$a ცვლადის ბიტების წაძვრა $b ბიჯით მარჯვნი (ყოველი ბიჯი ნიშნავს “გაყავი ორზე”)

განვიხილოთ ცხრილში მოცემული ყველა ოპერატორი:

AND(&) ოპერატორი
& ოპერატორი აბრუნებს გამოსახულების მარცხენა და მარჯვენა მხარეს არსებული მნიშვნელობების იმ ბიტების ჯამს რომლებიც საერთოა ორივესთვის, მაგალითად შემდეგ კოდის შესრულების შემდეგ ეკრანზე გამოიბეჭდება 6:

1
2
3
4

$a = 7;
$b = 6;

echo $a & $b;

თუ რატომ არის ამ გამოსახულების შედეგი 6 – ის ტოლი ნაჩვენებია ჩემდეგ ცხრილში:

1 ბაიტი (8 ბიტი)
ბიტის ინდექსი	7	6	5	4	3	2	1	0
ბიტის მნიშვნელობა	128	64	32	16	8	4	2	1
$a	0	0	0	0	0	1	1	1	=	7 (ანუ: 4+2+1)
$b	0	0	0	0	0	1	1	0	=	6 (ანუ: 4+2)

ცხრილში შეგვიძლია ვიზუალურად დავინახოთ რომ $a და $b ცვლადებს აქვთ მონიშნული საერთო ბიტები პოზიციებზე ინდექსით 1 და 2, რადგან მოცემულ პოზიციებზე ბიტების მნიშვნელობებია შესაბამისად 4 და 2 ამ რიცხვების ჯამი იქნება 6: 4+2 = 6

OR(|) ოპერატორი
| ოპერატორი აბრუნებს გამოსახულების მარცხენა და მარჯვენა მხარეს არსებული მნიშვნელობების იმ ბიტების ჯამს რომლებიც მონიშნულია ან მარცხენა ან მარჯვენა ოპერანდში, მაგალითად შემდეგ კოდის შესრულების შემდეგ ეკრანზე გამოიბეჭდება 15:

1
2
3
4

$a = 11;
$b = 6;

echo $a | $b;

თუ რატომ არის ამ გამოსახულების შედეგი 15 – ის ტოლი ნაჩვენებია ჩემდეგ ცხრილში:

1 ბაიტი (8 ბიტი)
ბიტის ინდექსი	7	6	5	4	3	2	1	0
ბიტის მნიშვნელობა	128	64	32	16	8	4	2	1
$a	0	0	0	0	1	0	1	1	=	11 (ანუ: 8+2+1)
$b	0	0	0	0	0	1	1	0	=	6 (ანუ: 4+2)

ცხრილიდან ჩანს რომ ორივე $a და $b ცვლადებისათვის ბიტები მონიშნულია ინდექსებზე 0, 1, 2 და 3 ხოლო ამ პოზიციებზე არსებული მნიშვნელობების დაჯამებით მივიღებთ 15-ს: 8+4+2+1=15

XOR(^) ოპერატორი
^ ოპერატორი აბრუნებს გამოსახულების მარცხენა და მარჯვენა მხარეს არსებული მნიშვნელობების იმ ბიტების ჯამს რომლებიც მონიშნულია ან მარცხენა ან მარჯვენა ოპერანდში მაგრამ არა ორივეში, მაგალითად შემდეგ კოდის შესრულების შემდეგ ეკრანზე გამოიბეჭდება 13:

1
2
3
4

$a = 11;
$b = 6;

echo $a ^ $b;

თუ რატომ არის ამ გამოსახულების შედეგი 13-ის ტოლი ნაჩვენებია ჩემდეგ ცხრილში:

1 ბაიტი (8 ბიტი)
ბიტის ინდექსი	7	6	5	4	3	2	1	0
ბიტის მნიშვნელობა	128	64	32	16	8	4	2	1
$a	0	0	0	0	1	0	1	1	=	11 (ანუ: 8+2+1)
$b	0	0	0	0	0	1	1	0	=	6 (ანუ: 4+2)

ამ შემთხვევაში $a ცვლადისათვის ისეთი ბიტები რომლებიც არ არის მონიშნული $b ცვლადში გვხვდება პოზიციებზე ინდექსებით 3 და 1, ხოლო $b ცვლადისათვის ასეთი ბიტი მდებარეობს პოზიციაზე ინდექსით 2. თუ დავაჯამებთ ამ პოზიციების შესაბამის მნიშვნელობებს მივიღებთ 13-ს: 8+4+1=13

NOT(~) ოპერატორი
თუ შევასრულებთ შემდეგ კოდს რომელშიც გამოიყენება ~ ოპერატორი, ეკრანზე გამოიბეჭდება 9:

1
2
3
4

$a = 11;
$b = 6;

echo $a & ~$b;

თუ რატომ არის ამ გამოსახულების შედეგი 9 – ის ტოლი ნაჩვენებია ჩემდეგ ცხრილში:

1 ბაიტი (8 ბიტი)
ბიტის ინდექსი	7	6	5	4	3	2	1	0
ბიტის მნიშვნელობა	128	64	32	16	8	4	2	1
$a	0	0	0	0	1	0	1	1	=	11 (ანუ: 8+2+1)
$b	0	0	0	0	0	1	1	0	=	6 (ანუ: 4+2)

რადგან $a & ~$b გამოსახულებაში ~ გამოიყენება $b-სთან, იგი შეგვიძლია განვმარტოთ შემდეგნაირად: დააბრუნე $a ცვლადის იმ ბიტების ჯამი რომლებიც არ არის მონიშნული $b ცვლადში. ხოლო როგორც ცხრილიდან ჩანს $a ცვლადისათვის ასეთი ბიტები გვხვდება პოზიციებზე ინდექსით 3 და ინდექსით 0, შედეგად 8+1=9

<< ოპერატორი, მარცხნივ წაძვრის ოპერატორი

მაგალითისათვის შევასრულოთ შემდეგი კოდი:

1
2
3

$a = 4;

echo $a << 3;

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

1 ბაიტი (8 ბიტი)
ბიტის ინდექსი	7	6	5	4	3	2	1	0
ბიტის მნიშვნელობა	128	64	32	16	8	4	2	1
$a – საწყისი	0	0	0	0	0	1	0	0	=	4
$a – წაძვრის შემდეგ	0	0	1	0	0	0	0	0	=	32

ცხრილიდან $a – ს საწყისი და საბოლოო შედეგების შედარებისას ნათელია რომ << მეშვეობით მონიშნული ბიტი წავძარით მარცხნივ სამი(3) ბიჯით, გამომდინარე შედეგინდან, რათა უფრო მარტივი გასაგები გახდეს $a <<3 გამოსახულება შეიძლება ავსახოთ შემდეგნაირად: 4*2*2*2=32

>> ოპერატორი, მარჯვნივ წაძვრის ოპერატორი
ეს ოპერატორი მუშაობს წინა ოპერატორის მსგავსად მხოლოდ ბიტების წაძვრა ხდება მარცხნიდან მარჯვნივ, მაგალითად შემდეგი კოდის შესრულებით შედეგად მივიღებთ 4-ს:

1
2
3

$a = 32;

echo $a >> 3;

ხოლო $a >> 3 ამ გამოსახულების გადაწერა შეიძლება შემდეგნაირად: 32/2/2/2=4

phpDocumentor – ის ინტეგრაცია PHPEclipse 3.2 – ში

იოსები — Wed, 14 Mar 2007 07:33:55 +0000

პირველ რიგში რისთვის არის phpDocumentor და რა არის PHPEclipse? ორივე ძალიან საჭირო და სასარგებლო ინსტრუმენტია რომელიც საგრძნობლად აადვილებს საქმეს… phpDocumentor არის შესანიშნავი ინსტრუმენტი PHP – ს API დოკუმენტაციის დასაგენერირებლად ხოლო PHPEclipse ჩემის აზრით საუკეთესო IDE PHP – სთვის. ნებისმიერ PHP დეველოპერს ვინც არ იყენებს ამ ინსტრუმენტებს ვურჩევდი მათ გამოყენებას. phpDocumentor შეიძლება გადმოვიწეროთ ამ მისამართიდან ხოლო PHPEclipse ამ მისამართიდან

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

1) პირველ რიგში გავხსნათ შემდეგი დიალოგი (Run->External Tools->External Tools)

2) შემდეგ მოვნიშნოთ Program სექცია მარცხენა მენიუში და New ღილაკის მეშვეობით შევქმნათ ახალი კონფიგურაცია

Name – კონფიგურაციის დასახელება
Location - მისამართი სადაც აყენია PHP – ს შესრულებადი ფაილი (php.exe)
Working Directory – მისამართი სადაც უნდა დაგენერირდეს დოკუმენტაცია
Arguments – phpDocumentor – ის შესასრულებლად საჭირო არგუმენტები

Working Directory – ს მისათითებლად ავირჩიოთ საჭირო კატალოგი (Browse Workspace ღილაკით გამოიძახება შემდეგი დიალოგი). დაგენერირებული API დოკუმენტაცია განთავსდება არჩეულ კატალოგში.

3) შევქმნათ phpDocumentor – ის კონფიგურაცია რათა შემდეგ მივუთითოთ Arguments ველში.
ამისათვის საჭიროა phpDocumentor – ში არსებული user ქვეკატალოგში დავაკოპიროთ default.ini ფაილი(რომელიც განთავსებულია user კატალოგში) და დავარქვათ მას სასურველი სახელი (ჩემს შემთხვევაში ფაილს დავარქვი ioseb.ini) და მივუთითოთ შესაბამისი პარამეტრები.

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

“C:\webservers\apache\www\PHPDOC\phpDocumentor\phpdoc.inc” -c ioseb

ბრჭყალებში განსაზღვრულია phpDocumentor – ის phpdoc.inc ფაილის მისამართი, შემდეგ -c ioseb რაც ნიშნავს რომ phpDocumentor დოკუმენტაციას დააგენერირებს სასურველი კონფიგურაციის მიხედვით ამ შემთხვევაში ioseb.ini.

4) გადავიდეთ Common განყოფილებაში და Display in favorites menu ველში მოვნიშნოთ External Tools

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

phpDocumentor – ის გაშვება უკვე შესაძლებელია პირდაპირ მენიუდან:

ხოლო შესრულების რეზულტატი გამოჩნდება Eclipse – ს კონსოლში.

Registry პატერნი – php4

იოსები — Fri, 23 Feb 2007 22:18:53 +0000

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

PHP-ში გლობალურ მონაცემებთან ორი გზით არის შესაძლებელი:

global – საკვანძო სიტყვის გამოყენებით
$GLOBALS – PHP-ს უკვე არსებული მასივი რომელზეც წვდომა შესაძლებელია კოდის ნებისმიერ ადგილიდან

მაგალითში ნაჩვენებია ორივე მეთოდის გამოყენება:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

$myVar = "sample text";

/*$myVar ცვლადი ამ შემთხვევაში ფუნქციის
ლოკალური ცვლადია და არაფერი საერთო არ გააჩნია
ფუნქციის გარეთ აღწერილ იგივე ცვლადთან
*/
function printMyVar() {
echo $myVar;
}

/*ამ ფუნქციაში $myVar ცვლადზე წვდომა ხორციელდება
global-ის გამოყენებით. ფუნქციის შიდა ცვლადი და მის
გარეთ აღწერილი ცვლადი ერთი და იგივეა
*/
function printMyVar() {
global $myVar;
echo $myVar;
}

/*ამ შემთხვევაში $myVar ცვლადს მივმართავთ $GLOBALS
მასივის მეშვეობით
*/
function printMyVar() {
$myVar = &$GLOBALS['myVar'];
echo $myVar;
}

/*პირდაპირ გამოიყენება $GLOBALS['myVar']*/
function printMyVar() {
echo $GLOBALS['myVar'];
}

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

/**
*@access public
*@package util
*/
class Registry {

/** @ignore */
var $stack;

/**
*Default private constructor
*@access private
*/
function Registry() {
$this->stack = array();
}

/**
*@access public
*@param string a string specifying object's key
*@param mixed an item to be stored during the request
*/
function add($key, &$item) {
$reg = &Registry::getInstance();
$reg->stack[$key] = &$item;
}

/**
*@param string a string specifying object's key
*@return mixed an object if it exists in the object stack or null
*/
function &get($key) {
$reg = &Registry::getInstance();
return $reg->stack[$key];
}

/**
*@param string a string specifying object's key
*@return boolean true if an object exists in the object stack or false
*/
function has($key) {
$reg = &Registry::getInstance();
return !is_null($reg->get($key));
}

/**
*@return Registry the Registry instance
*/
function &getInstance() {
static $registry = array();
if (!$registry) {
$registry[0] = &new Registry();
}
return $registry[0];
}

}

კოდი შედგება ოთხი მეთოდისგან ესენია:

add – მეთოდი მონაცემების მასივში ამატებს ახალ ობიექტს მითითებული სახელით
get – მეთოდი დააბრუნებს ობიექტს მითითებული სახელით, თუ მსგავსი ინახება ობიექტების მასივში
has – მეთოდი ამოწმებს არსებობს თუ არა ობიექტი მითითებული სახელით ობიექტების მასივში
getInstance – მეთოდი აბრუნებს უკვე არსებულ Registry კლასის ობიექტს (თუ იგი არ არსებობს წინასწარ ქმნის მასე, ასე რომ ამ მეთოდის პირველი გამოყენების თანავე Registry კლასის ობიექტი იქმნება ერთხელ და ინახება $registry სტატიკურ(static) ცვლადში რაც იძლევე იმის გარანტიას რომ ამ მეთოდის ხელმეორე გამოყენების შემთხვევაში $registry ცვლადი ხელმეორედ აღარ შეიქმნება)

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

ამ კლასის გამოყენების მაგალითები მოყვანილია ქვემოთ:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

class Test {
var $testData;
function Test() {
$this->testData = "this is my test data";
}
}

$test = &new Test();
Registry::add('test', $test);

function useTest() {
$test = &Registry::get('test');
echo $test->testData;
}

class DatabaseConnection() {
var $connection;

function DatabaseConnection($host, $user, $pass) {
$this->connection = mysql_connect($host, $user, $pass);
}

function getConnection() {
return $this->connection;
}

}

$dbConn = &new DatabaseConnection();
Registry::add('db', $dbConn);

function useDbConnection() {
$db = Registry::get('db');
//$db->getConnection();
}

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

Singleton პატერნი – PHP4 და PHP5

იოსები — Fri, 23 Feb 2007 03:01:53 +0000

შესაძლებელია თუ არა ამ საჭირო პატერნის რეალიზაცია PHP4 – ში? მიუხედავად იმისა რომ უმრავი რამ არის ნათქვამი PHP-ს ამ ვერსიის არასრულფასოვან ობიექტზე ორიენტირებულ შესაძლებლობებზე – ეს შესაძლებელია თუმცა გარკვეულწილად ეს არის ხელოვნური და შედარებით რთული გზა ვიდრე PHP5-სა და Java-ში. (დეტალურად ამ პატერნის შესახებ შეგიძლიათ წაიკითხოთ ამ პოსტში).

რითია ეს სირთულე გამოწვეული ეს სირთულე PHP4 – ში? ამის რამდენიმე მიზეზია რომელსაც ჩამოვთვლილია ქვევით:

არ არსებობს წვდომის მოდიფიკატორები(public, protected, private) კლასის ცვლადებისა და მეთოდებისათვის.
არ არსებობს სტატიკური (static) კლასის ცვლადები.

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

განვიხილოთ მაგალითი:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

class Singleton {

//private constructor
function Singleton() {}

function &getInstance() {

static $singleton = array();

if (!$singleton) {
$singleton[0] = &new Singleton();
}

return $singleton[0];

}

}

თუმცა PH5 – სთვის საქმე გაცილებით უკეთ არის და მისი რეალიზაცია თითქმის იდენტურია Java-ს რეალიზაციისა.

მაგალითი PHP5 – სთვის:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

class Singleton {

static private $instance = null;

//private constructor
private function __construct() { }

public static function getInstance() {
if (self::$instance == null) {
self::$instance = new Singleton();
}
return self::$instance;
}

}

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

static – გამოიყენება როგორც კლასის ცვლადის ასევე კლასის მეთოდთან.
public, private – წვდომის მოდიფიკატორები რომლებიც მანამდე არ არსებობდა PHP – ში.
_counstruct - PHP5 – ში კონსტრუქტორის სახელი (კლასის სახელი გამოყენება წინა ვერსიაში ავტომატურად გულისხმობდა რომე ეს ფუნქცია იყო კონსტრუქტორი)
self – ეს საკვანძო სიტყვა გულისხმობს მიმდინარე კლასს, მხოლოდ სტატიკურ კონტექსტში.

რა არის ახალი PHP 5-ში

იოსები — Fri, 16 Feb 2007 23:19:54 +0000

Andi Gutmans, Stig Bakken და Derick Rethans-ის ახალი წიგნის “PHP 5 Power Programming” II თავი.

ორიგინალის მისამართი: http://www.zend.com/php5/andi-book-excerpt.php

შესავალი
ენის ახალი შესაძლებლობები
- ახალი ობიექტზე-ორიენტირებული მოდელი
- ახალი ობიექტზე-ორიენტირებული მიდგომა ენის სხვა ახალი შესაძლებლობები
PHP-ში შესული ძირითადი ცვლილებები
- XML და ვებ სერვისები
- ახალი გაფართოება MySQLi (დახვეწილი MySQL)
- გაფართოება SQLite
- Tidy გაფართოება
- Perl გაფართოება
- PHP 5-ის სხვა სიახლეები
დასკვნა

საუკეთესო გზა რათა მოვემზადოთ მომავლისათვის – ეს არის მისი გამოგონება. John Sculley

შესავალი

მხოლოდ დრო გვაჩვენებს, იქნება PHP 5 ისეთივე წარმატებული, როგორც მისი წინამორბედები (PHP 3 და PHP 4). ახალი შესაძლებლობები და თვისებები მიმართულია PHP – ს სუსტი მხარეების აღმოსაფხვრელად, და ლიდერის სტატუსის შესანარჩუნებლად ვებში.

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

ამ განყოფილებაში განხილულ იქნება:

ენის ახალი შესაძლებლობები;
სიახლეები, PHP – ს გაფართოებების (extensions) შესახებ;
სხვა ცვლილებები, რომლებიც ყურადღებას იმსახურებს.

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

ახალი ობიექტზე-ორიენტირებული მოდელი

როდესაც ზივ სერასკიმ (Zeev Suraski) დაამატა ობიექტზე-ორიენტირებული (ОО) სინტაქსი PHP 3-ში, ამის განხილვა შეიძლებოდა როგორც „სინტაქსური დამატკბობელი კლასების მხარდაჭერისათვის“ (“syntactic sugar for accessing collections”). ობიექტზე-ორიენტირებულმა მოდელმა მიიღო მემკვიდრეობის მხარდაჭერა და კლასსა (და ობიექტს) მიეცა საშუალება გაეერთიანებინა მეთოდები და თვისებები, მაგარამ არა უმეტეს. როდესაც ზივმა და ენდიმ გადაწერეს ძრავი PHP 4-სთვის, ეს იყო სრულიად ახალი ძრავი, რომელიც მუშაობდა საგრძნობლად სწრაფად, ბევრად სტაბილურად და დამატებით გააჩნდა სხვა უამრავი საშუალება. მაგრამ, ეს ცვლილებები პრაქტიკულად არ შეხებია ობიექზე-ორიენტირებულ მოდელს, რომელიც დანერგილი იყო ჯერ კიდევ PHP 3 – ში.

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

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

მაგალითად:

კოდი:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

class Person {
var $name;

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

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

function Person($name) {
$this->setName($name);
}

}

function changeName($person, $name) {
$person->setName($name);
}

კოდი:

1
2
3
4

$person = new Person("Andi");
changeName($person, "Stig");

print $person->getName();

PHP 4-ში ეს კოდი გამოიტანს “Andi” – ს. მიზეზი მდგომარეობს იმაში, რომ ჩვენ ფუნქციას changeName() გადავცემთ $person ობიექტს მნიშვნელობით (By Value), და არა მისამართით (By Reference) ამგვარად, იბიექტი $person იქნება დუბლირებული, და ფუნქცია changeName() უკვე იმუშავებს $person ობიექტის დუბლიკატთან.

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

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

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

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

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

ახალი ობიექტზე-ორიენტირებული მიდგომა

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

ქვევით მოყვანილია ძირითადი ცვლილებების მიმოხილვა:

1.public/private/protected – მოდიფიკატორები მეთოდებსა და თვისებებზე მიმართვისათვის.

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

კოდი:

1
2
3
4
5
6
7
8

class MyClass {
private $id = 18;

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

}

2. უნიფიცირებული კონსტრუქტორი __construct()

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

კოდი:

1
2
3
4
5
6
7

class MyClass {

function __construct() {
print "Inside constructor";
}

}

3. კლასის დესტრუქტორის მხარდაჭერა, განსაზღვრული როგორც მეთოდი __destructor()

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

კოდი:

1
2
3
4
5
6
7

class MyClass {

function __destruct() {
print "Destroying object";
}

}

4. ინტერფეისები

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

კოდი:

1
2
3
4
5
6
7
8
9
10
11

interface Display {
function display();
}

class Circle implements Display {

function display() {
print "Displaying circle ";
}

}

5. ოპერატორი instanceof

სხვა ობიექტებზე დამოკიდებულების შემოწმების საშუალება. PHP 4 – ის ფუნქციის is_a() გამოყენება არ არის რეკომენდირებული, მის მაგივრად გამოიყენება instanceof:

კოდი:

1
2
3
4
5

if ($obj instance of Circle) {

print '$obj is a Circle';

}

6. final მეთოდები

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

კოდი:

1
2
3
4
5
6
7
8
9

class MyClass {

final function getBaseClassName() {

return __CLASS__;

}

}

7. final კლასები

კლასი გამოცხადებული როგორც final არ შეიძლება იყოს მემკვიდრეობით მიღებული სხვა კლასის მიერ. შემდეგი მაგალითი გამოიწვევს შეცდომას:

კოდი:

1 2	final class FinalClass { } class BogusClass extends FinalClass { }

8. ობიექტის ღიად კლონირება

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

კოდი:

1
2
3
4
5
6
7
8
9
10

class MyClass {

function __clone() {
print "Object is being cloned";
}

}

$obj = new MyClass();
clone $obj;

9. კლასის კონსტანტები

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

კოდი:

1
2
3
4
5
6

class MyClass {
const SUCCESS = "Success";
const FAILURE = "Failure";
}

print MyClass::SUCCESS;

10. კლასის სტატიკური

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

კოდი:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

class Singleton {

static private $instance = NULL;private function __construct() { }

static public function getInstance() {

if (self::$instance == NULL) {
self::$instance = new Singleton();
}

return self::$instance;

}

}

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

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

კოდი:

1
2
3
4
5
6
7
8
9

class MyClass {

static function helloWorld() {
print "Hello, world";
}

}

MyClass::helloWorld();

12. აბსტრაქტული კლასები

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

კოდი:

1
2
3
4
5
6
7

abstract class MyBaseClass {

function display() {
print "Default display routine being called";
}

}

13. აბსტრაქტული მეთოდები

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

კოდი:

1
2
3
4
5

abstract class MyBaseClass {

abstract function display();

}

14. კლასის როგორც ტიპის მითითება

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

კოდი:

1	function expectsMyClass(MyClass $obj) { }

16. იტერატორები

PHP 5 საშუალებას გვაძლევს მიმდევრობით მივმართოთ კლასის ელემენტებს froeach() კონსტრუქციის მეშვეობით.

კოდი:

1
2
3
4
5

$obj = new MyIteratorImplementation();

foreach ($obj as $value) {
print "$value";
}

17. __autoload()

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

კოდი:

1
2
3
4
5
6
7
8

function __autoload($class_name) {

include_once($class_name . "php");

}

$obj = new MyClass1();
$obj2 = new MyClass2();

ენის სხვა ახალი შესაძლებლობები

1.შეცდომების დამუშავება

PHP 5 – ში დამატებულია შეცდომების დამუშავების დამუშავების ახალი მექანიზმი, try/throw/catch სტრუქტურის შემოტანით. თქვენ მხოლოდ გჭირდებათ ობიექტის შექმნა, რომელიც მემკვიდრეობით მიიღებს შეცდომების დამუშავების კლასს Exception.

კოდი:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

class SQLException extends Exception {

public $problem;

function __construct($problem) {
$this->problem = $problem;
}

}

try {

...

throw new SQLException("Couldn’t connect to database");

...

} catch (SQLException $e) {
print "Caught an SQLException with problem $obj->problem";
} catch (Exception $e) {
print "Caught unrecognized exception";

}

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

2. foreach მისამართით

PHP 4-ში თქვენ არ შეგეძლოდ მასივის იტერაციის დროს გეცვალათ მისი ელემენტების მნიშვნელობები. PHP 5-ში დაშვებული foreach() – ის შესრულებ, მისმართის აღმნიშვნელის (‘&’) გამოყენებით, ამგვარად, ცვლადის შეცვლისას, თქვენ ცვლით მასივის ელემენტს, რომელზეც ხორციელდება იტერაცია.

კოდი:

1
2
3
4
5
6
7
8
9

foreach ($array as &$value) {

if ($value === "NULL") {

$value = NULL;

}

}

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

PHP 4-ში მნიშვნელობის წინასწარ განსაზღვრა პარამეტრისათვის შესაძლებელი იყო მხოლოდ იმ შემთხვევაში თუ ის გადაეცემოდა მნიშვნელობით. ამჟამად შესაძლებელია მისამართით გადაცემული პარამეტრებისათვის მნიშვნელობების წინასწარ განსაზღვრა.

კოდი:

1
2
3
4
5
6
7
8
9

function my_func(&$arg = null) {

if ($arg === NULL) {

print '$arg is empty';

}

}my_func();

PHP-ში შესული ძირითადი ცვლილებები
XML და ვებ სერვისები

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

XML-ის მხარდაჭერა PHP 4-ში ბაზირებული იყო სხვადასხვა XML ბიბლიოთეკებზე. SAX-ის მხარდაჭერა ხორციელდებოდა Expat-ის ძველი ბიბლიოთეკის მეშვეობით, XSLT-ს გამოსაყენებლად საჭირო იყო Sablotron ბიბლიოთეკა, DOM-თან სამუშაოდ გამოიყენებოდა უფრო მძლავრი libxml2 – პროექტი GNOME-ს ბიბლიოთეკა.

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

PHP 5-ში XML-ს ყველა გაფართოება იყო ხელმეორედ გადაწერილი, რათა გამოყენებული ყოფილიყო libxml2 (http://www.xmlsoft.org/)-ის მიერ წარმოდგენილი ინსტრუმენტების განსხვავებული კრებული. ეს არის შესაძლებლობებით მდიდარი ბიბლიოთეკა, რემელშიც ეფექტურად არის რეალიზებული XML სტანდარტები, რაც საშუალებას აძლევს PHP-ს გამოიყენოს XML ტექნოლოგიის მოწინავე შესაძლებლობები.
ყველა ზემოთ ხსენებული გაფართოებები (SAX, DOM и XSLT) ამჟამად იყენებს libxml2-ს, ისევე როგორც ახალი დამატებით გაფართოებები – SimpleXML da SOAP.

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

DOM
თუმცა DOM-ის მხარდაჭერა PHP 4-ში ასევე ეყრდნობოდა libxml2 ბიბლიოთეკას, მასში იყო უამრავი შეცდომა, და აღნიშნული API ხშირ შემთხვევაში არ ესადაგებოდა W3C რეკომენდაციებს. DOM გაფართოება მთლიანად იქნა გადაწერილი PHP 5-სათვის. გარდა ამისა, გაფართოება იყო საფუძველშივე შეცვლილი, ამჟამად იგი შეესაბამება W3C რეკომენდაციებს. მაგალითად, ფუნქციების დასახელებები იყენებენ ნოტაციას studlyCaps (სახელების მინიჭება სხვადასხვა რეგისტრის სიმბოლოების გამოყენებით) როგორც განსაზღვრულია W3C სტანდარტში, რაც ამარტივებს თქვენს მიერ W3C დოკუმენტაციაში წაკითხულის გამოყენებას PHP-ში. გარდა ამისა, DOM გაფართოება მხარს უჭერს XML დოკუმენტის ვალიდაციის სამ სქემას – DTD, XML Schema და RelaxNG.

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

XSLT
PHP 4-ში, იყო ორი გაფართოება, რომლებიც უზრუნველყოფდნენ XSL-გარდაქმნას. პირველი გაფართოება იყენებდა Sablotron-ს, მეორე XSLT მხარდაჭერას DOM გაფართოებიდან. PHP 5-ში ახალი გაფართოება XSL იყო დაფუძნებული libxml2-ის გამოყენებაზე. მაგალითად PHP 5-ში XSL-გარდაქმნა არ ღებულობს XSLT სტილების ცხრილს პარამეტრის სახით, მაგრამ დამოკიდებულია DOM-ზე, რათა ჩატვირთოს ის. შესაძლებელია სტილების ცხრილის კეშირება მეხსიერებაში, და დასაშვებია მისი გამოყენება მრავალ დოკუმენტთან შესრულების დროის არსებითი ეკონომიისათვის.

SimpleXML
ალბათ, ერთი ან ორი წლის მერე, როდესაც მოვიხედავთ უკან, შევძლებთ ვთქვათ, რომ SimpleXML-მა ძირეულად შეცვალა XML დოკუმენტებთან მუშაობა PHP პროგრამისტებისათვის. SimpleXML-ს მართლაც შეიძლება ვუწოდოთ „XML დამწყებთათვის“. იმის მაგივრად, რომ საქმე გვქონდეს DOM-თან ან, რაც უფრო უარსეია, SAX-თან, SimpleXML საშუალებას გვაძლევს წარმოადგინოთ თქვენი XML დოკუმენტი როგორც PHP-ს მშობლიური ობიექტი. თქვენ შეგიძლიათ წაიკითოთ, ჩაწეროთ ან უბრალოდ გადაურბინოთ თქვენს XML დოკუმენტს და მარტივად მიმართოთ დოკუმენტის ელემენტებსა და ატრიბუტებს.

გადახედეთ შემდეგ XML დოკუმენტს:

კოდი:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

>

>

>John Doe>

>87234838>

>

>

>Janet Smith>

>72384329>

>

>

კოდის შემდეგი ფრაგმენტი ბეჭდავს ყოველი კლიენტის სახელს და მისი ანგარიშის ნომერს:

კოდი:

1
2
3
4
5
6
7

$clients = simplexml_load_file('clients.xml');

foreach ($clients->client as $client) {

print "$client->name has account number $client->account_number ";

}

როგორც მაგალითიდან ვხედავთ, SimpleXML მართლაც მარტივია.

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

SOAP
PHP 4-ში SOAP-ის ოფიციალური მხარდაჭერა არ არსებობდა. საერთოდ, SOAP-ის გამოყენების საჭიროების შემთხვევაში, საჭირო ხდებოდა PEAR (PHP Extension and Application Repository http://pear.php.net/) გამოყენება, მაგრამ რამდენადაც კოდი დაწერილი იყო მთლიანად PHP-თი, აპლიკაციებს არ შეეძლოთ ისე შესრულება როგორც ინტეგრირებულ C-გაფართოებებს. სხვა არსებულმა C გაფართოებებმა ვერ შეძლეს მიეღწიათ სტაბილური ვერსიებისათვის, და ამიტომ არ მოხდა მათი ჩართვა PHP 5-ში.

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

შემდეგი კოდით ხორციელდება WSDL ფაილში განსაზღვრული SomeFunction() ფუნქციის გამოძახება:

კოდი:

1
2
3

$client = new SoapClient("some.wsdl");

$client->SomeFunction($a, $b, $c);

ახალი გაფართოება MySQLi (დახვეწილი MySQL)

PHP 5-ში MySQL AB (http://www.mysql.com/) – სთვის იყო დაწერილი ახალი გაფართოება MySQL, რომელიც საშუალებას გაძლევთ სრულად გამოიყენოთ MySQL 4.1-ის და უფრო ახალი ვერსიების ფუნქციონალური საშუალებების უპირატესობები. გაფართოების ძველი ვერსიის საპირისპიროდ ახალი გაფართოება გაძლევთ საშუალებას გამოიყენოთ ორივე ინტერფეისი: ფუნქციონალური და ობიექტზე-ორიენტირებული. გაფართოებაში რეალიზებულია რიგი ახალი შესაძლებლობები, მათ შორის ტრანზაქციების კონტროლი, რეპლიკაცია, SSL და მრავალი სხვა…

გაფართოება SQLite

SQLite-ს (http://www.sqlite.org/) მხარდაჭერა თავდაპირველად დანერგილი იყო PHP 4.3.x ვერსიებში. ეს არის SQL-ის ინტეგრირებული ბიბლიოთეკა, რომელიც არ საჭიროებს SQL-სერვერებს. დასახელების მიუხედავად, SQLite გააჩნია მდიდარი შესაძლებლობები და უზრუნველყოფს ტრანზაქციებს, Sub Selects, Views.

Tidy გაფართოება

PHP 5-ში ასევე უზრუნველყოფილია ძალზედ საჭირო ბიბლიოთეკა Tidy (http://tidy.sf.net/). იგი HTML დოკუმენტის გარჩევის, გასუფთავების და აღდგენის საშუალებას გვაძლევს. Tidy უზრუნველყოფს როგორც ფუნქციონალურ, ასევე ობიექტზე-ორიენტირებულ ინტერფეისს, და მის API-ში გამოიყენება PHP 5-ში არსებული შეცდომების დამუშავების მექანიზმი.

Perl გაფართოება

Perl გაფართოება საშუალებას გაძლევთ გამოიძახოთ Perl-სკრიპტები, გამოიყენოთ Perl ობიექტები და გამოიყენოთ Perl-ის სხვა ფუნქციონალური საშუალებები უშუალოდ PHP კოდიდან. ეს ახალი გაფართოება შეიძლება მოიძიოთ მისამართზე http://pecl.php.net/package/perl..

PHP 5-ის სხვა სიახლეები

მეხსიერების ახალი მენეჯერი

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

შეწყვეტილია Windows 95-ის მხარდაჭერა

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

დასკვნა

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