რატომ PHP?

threads

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

მოდი ცოტა შორიდან დავიწყებ.
ერთხელაც, .net რომ ვითარდებოდა ვებში, შემოვიდა asp ვებ ფორმები და პოპულარული გახდა. რამდენჯერ ვცადე შიგნით გარკვევა, რა წიგნები არ წავიკითხე, მაგრამ არ მიმივიდა გული არცერთხელ, თუმცა მიზეზს ვერ ვასახელებდი მაშინ. ეგ მიზეზი იყო თავსმოხვეული ხელოვნურობა. გეუბნებოდა ფრეიმვორკი, რომ მე ვიცი რასაც ვაკეთებ, შენ მარტო ეს ღილაკი დასვი და იმას დააჭირე. მერე მიდიოდა და ზურგს უკან რას აკეთებდა?! 😀 ამხელა სტეიტს დაათრევდა აქეთ იქით რიქვესთებს შორის. მე მგონი პლატფორმა კი არა, ერთი დიდი workaround იყო ვებისთვის.

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

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

Java EE-ში რიქვესთების საპასუხოდ პროგრამისტები ვწერთ სერვლეტ კლასებს, იქ კი instance ცვლადების გაკეთება არ არის კარგი. იცით რატომ? იმიტომ რომ თითო სერვლეტის ერთი ობიექტი გამოიყენება ყველა რიქვესთის საპასუხოდ (მთლად მაგაზე დაყრდნობაც არ შეიძლება, რადგან კონტეინერი აკონტროლებს როდის მოკლას ან ჩაანაცვლოს ის ინსტანსი). სტატიკური რაღაცები, სინგლტონ კლასები – ყველაფერი ჩვეულებრივ არსებობს აპლიკაციაში და shared არის მომხმარებლებს შორის. სპეციალურადაც კი არის ობიექტი – ‘აპლიკაციის კონტექსტი’ რომელიც სერვლეტებს შორის shared მონაცემებს დაატარებს და არაერთ best practice-ში გამოიყენება, თუნდაც რაღაც ობიექტების კეშირებისთვის. ამ ყველაფერს კი სჭირდება სინქრონიზაცია. უნდა იცოდეს პროგრამისტმა რა ბიბლიოთეკები და კლასებია thread-safe, იცოდეს კოდის რა ნაწილი მოხვდება ცალკე ნაკადში და რა ნაწილი იქნება გაზიარებული. მერე შესაბამისად lock-ებით და სინქრონიზაციის სხვადასხვა მექანიზმებით უნდა აკონტროლოს ეს ყველაფერი.

იყო რაღაც ფრეიმვორკები, ახლაც არის. ახლების ნახვის სურვილი აღარც გამჩენია მათ შემდეგ, იმიტომ რომ მე მგონი იმ ვებ ფორმებზე უარესად აფარებდნენ ფარდებს ყველაფერს. მახსოვს Struts რომ მიშრობდა სისხლს. xml-ში აკონფიგურირებდი და მერე ჯადოსნურად უნდა ემუშავა ბევრ რამეს. მაგრამ უმეტეს გაშვებაზე ერთი შეცდომა გამოდიოდა ხოლმე, რაც ჭირივით მეზიზღებოდა 😀 ფაილს ვერ ვპოულობო. ვერ გაიგებდი რა უნდოდა, xml-ში გამოგრჩა წერტილი თუ გადატვირთვა დააკლდა სერვერს. Spring-ზე არც დავიწყებ…

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

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

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

მეორე გახდა node.js, რომელზეც ქვევით ვიტყვი უფრო დეტალურად.

როცა PHP-ის ვებ სერვერზე ვიყენებთ, უმეტეს შემთხვევაში ისე ვაკონფიგურირებთ რომ ის არ ინახავს არანაირ state-ს. თუ CGI-ის, FastCGI-ის ან Apache-ს Prefork რეჟიმს გამოვიყენებთ, სერვერთან მოსული თითოეული რიქვესთისთვის ახალი პროცესი გაეშვება და მარტო ერთ ნაკადში შესრულდება php-ის კოდი. მაშინაც კი თუ php-ის კომპილირებული ფაილების კეშირებას ვაკეთებთ, სკრიპტის თითოეული ინსტანსი მაინც ცალკე შეიქმნება და ფიზიკური მეხსიერებაც ცალკე გამოეყოფა.
თურმე სახელიც ჰქონია ასეთ მიდგომას – Shared nothing architecture.

მესმის რომ წარმადობის პრობლემა შეექმნება ასე, მაგრამ საშუალო ზომის ვებ აპლიკაციების შემთხვევაში რამდენჯერ მისულხართ მაგ პრობლემამდე?

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

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

ისიც მესმის, რომ ნელ-ნელა გარდაუვალი გახდება წარმადობაზე ფიქრი და წინსვლისთვის მაინც მოგვიწევს ისეთი პროგრამების შექმნა, რომლებიც ბევრი პროცესორისთვის და ბევრი ნაკადისთვის იმუშავებს, მაგრამ რაღაცნაირად იმედი მაქვს რომ იქნება რაღაც იდეები (მაგალითად როგორც node.js ან როგორც nosql ბაზები) და ნაწილობრივ მაინც მოგვაცილებენ shared state-ის თავისტკივილს.

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

Zend PHP Certification: PHP Basics, part 2

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

Integer ტიპის ზომა პლატფორმაზეა დამოკიდებული.
32 ბიტიანი სისტემისთვის რიცხვი უნდა იყოს შუალედში -2^31 და 2^31-1
64 ბიტიანი სისტემისთვის -2^63 და 2^63-1

თექვსმეტობით (hexadecimal) წარმოდგენილი რიცხვისთვის ეს შუალედები განსხვავდება:
32 ბიტიანი სისტემისთვის 0-დან 2^31-1 -მდე
64 ბიტიანი სისტემისთვის 0-დან 2^63-1 -მდე.

თუ ინტერპრეტატორს შეხვდება რიცხვი ამ საზღვრებს გარეთ (overflow), ის რიცხვს float ტიპად მიიღებს.

$large_number = 2147483647; // = 2^31-1
var_dump($large_number);
// output: int(2147483647)

$large_number = 2147483648; // = 2^31
var_dump($large_number);
// output: float(2147483648)

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

Float ტიპის რიცხვები შეიძლება წარმოვადგინოთ შემდეგი სინტაქსით (მთელის და წილადის გამოსაყოფად აუცილებლად წერტილია საჭირო და არა მძიმე):

<?php
$a = 1.234;
$b = 1.2e3;
$c = 7E-10;
?>

გასათვალისწინებელია, რომ PHP-ის შემთხვევაში ამ ტიპის რიცხვები სიზუსტეს კარგავს ბინარულში გადასვლის შემდეგ. მაგალითად (int)((0.1 + 0.7) * 10) საბოლოო ჯამში მოგვცემს 7-ს და არა 8-ს. (0.1 + 0.7)*10 გვაძლევს 7.99999..-ს. (მთელ რიცხვზე (int) დაყვანის დროს, რიცხვი ქვედა ზღვრისკენ მრგვალდება.)

ამიტომ თუ მათემატიკური გამოთვლები ან შედარება გვჭირდება float ტიპით, ყოველთვის BC math ან gmp ფუნქციები უნდა გამოვიყენოთ.

ოპერატორები

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

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

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

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

ბიტური ოპერატორები
გასათვალისწინებელია შესრულების მიმდევრობა. მაგალითად == შედარებას უფრო მაღალი პრიორიტეტი აქვს ვიდრე & ბიტურ ოპერაციას, ამიტომ  $a & $b  == true  შემთხვევაში ჯერ შედარება შესრულდება.

კიდევ ერთი რამ: რატომ ვწერთ ხოლმე შეცდომების რეპორტინგის ჩართვის დროს მაგალითად ასეთ რამეს? E_ALL & ~E_NOTICE

error_reporting-ი მიმდინარე სეთინგების შესანახად bitmask-ს იყენებს. თითოეულ ასეთი კონსტანტის უკან ბიტების ერთობლიობა დგას.

მაგალითად
E_ALL –ს შეესაბამება  00000000000000000111011111111111.
E_NOTICE  => 00000000000000000000000000001000
(ანუ ბოლოდან მეოთხე ბიტი როცა ”ჩართულია”, ეს ნიშნავს რომ E_NOTICE ჩართულია)
~E_NOTICE გამოვა => 11111111111111111111111111110111
E_ALL & ~E_NOTICE   => 00000000000000000111011111110111

საბოლოო ჯამში მოგცემს მთელ სიმრავლეს ოღონდ შენიშვნების (notice) გამოკლებით.

შედარების ოპერატორები
ამ ოპერატორებიდან and და && ზუსტად ერთნაირად მოქმედებენ. ასევეა or და ||. განსხვავება მათ შორის მხოლოდ შესრულების მიმდევრობის პრიორიტეტებშია. && და ||  ოპერატორებს უფრო მაღალი პრიორიტეტი აქვთ შესრულების დროს ვიდრე მათ შესაბამის სიტყვიერ ჩანაწერებს.

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

სისტემური ბრძანების შესრულების ოპერატორები
ასეთი ბრძანების გასაშვებად გამოიყენება ` ` ბრჭყალები (backticks). მაგალითად echo `ls -al`;

ისინი არ მუშაობენ თუ ჩართულია safe_mode ან გამორთულია shell_exec()

მნიშნველობის გასაზრდელი/შესამცირებელი ოპერატორები (++ –)
boolean ტიპზე არ მოქმედებს.

ლოგიკური ოპერატორები
აქ მხოლოდ იმას შევნიშნავ, რომ ოპერანდების მნიშვნელობიდან და ოპერატორიდან გამომდინარე შედეგის მისაღებად ყველა ოპერანდის შესრულება საჭირო არ არის და არც სრულდება. მაგალითად if (false && some_function()) { }  ასეთ შემთხვევაში some_function() არასდროს გამოიძახება, რადგან false და && უკვე ნიშნავს რომ საბოლოო შედეგიც false იქნება.

სტრიქონის ოპერატორები ( .   .= )

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

ტიპის ოპერატორები (instanceof)

შეკითხვები:

1. რა მნიშვნელობები იქნება float1 და float2 ცვლადებში? (php.net)

$float1 = (float) '1.5';
$float2 = (float) '1,5';

1.5
1

2. რა შედეგი ექნება კოდს? (php.net)

<?php
var_dump(25/7);
var_dump((int) (25/7));
var_dump(round(25/7));
?>

float(3.5714285714286) -> / ოპერატორი არ ასრულებს მთელ გაყოფას და ჩვეულებრივ float-ს გვაძლევს შედეგად.
int(3)
float(4)

3. რა შედეგი ექნება f() ფუნქციის გამოძახებას? (php.net)

int f()
{
int a, b;
a = 2, b = 4;

return a;
}

პარსირების შეცდომა მოხდება. C ენისგან განსხვავებით php-ში მძიმის გამოყენება არ შეიძლება ესეთი კომბინირებული expression-ების დასაწერად. თუმცა for ციკლში დაშვებულია. ასეთი რამ იმუშავებს: for ($a = 2, $b = 4; $a < 3; $a++) { }
4. რა შედეგი ექნება კოდს?
 $a = -10 % 3; $a += "1"; echo $a; 

0 მოდულით გაყოფის დროს თუ ერთ ერთი უარყოფითია, პასუხიც უარყოფითია. რიცხვით ტიპს თუ ვამატებთ სტრიქონს, სტრიქონი რიცხვზე დაიყვანება და ისე შესრულდება ოპერაცია.
5. რა შედეგი ექნება კოდს?(php.net)
 $a=1; $a += $a++ + ++$a; echo $a; 

1. ++$a is first incremented. Now $a is 2. $a += $a++ + 2 $a is 2 2. $a++ is added to 2 then $a is incremented $a += 2 + 2 $a is 3 3. now the value of 2 + 2 is added to $a ($a is 3) $a = $a + 2 + 2 Answer: 3 + 2 + 2 = 7
6. რა მნიშვნელობა იქნება $a ცვლადში ამ სტრიქონის შესრულების შემდეგ (php.net)?
$a = true ? 0 : true ? 1 : 2; 

(true ? 0 : true) ? 1 : 2 = 2
7. რას დაბეჭდავს კოდი (php.net)?
echo 2 ^ "3"; echo "2" ^ 3; 

1 1 ორივე შემთხვევაში int-ზე დაიყვანს 2 ^ ((int)”3″) => 1
((int)”2″) ^ 3 => 1

8. რას დაბეჭდავს კოდი?

function f(){
echo 'I am inside f function\n';
return false;
}

if (true | f()){
echo 'bla bla bla';
}

I am inside f function
bla bla bla

| ოპერატორი || -ის მსგავსად short-circuit არ არის. ორივე მხარე შესრულდება, იმის მიუხედავად, რომ პირველი ოპერანდი true-ს უდრის.

9. რას დაბეჭდავს კოდი?

$a=true;
$a--;
echo $a;

1
++ და — ოპერატორები ბულის ტიპებზე არ მოქმედებს.

Zend PHP Certification: PHP Basics

PHP ტეგები

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

1. ჩვეულევრივი
<?php echo "Hello World"; ?>
2. short tags
<? echo "Hello World"; ?> ან <?= "Hello World" ?>
3. ASP tags
<% echo "Hello World"; %> (მისი shortcut <%= "Hello World" %>
4. Script tags
<script language="php">
echo 'Hello world';
</script>
  • ამ ოთხიდან Short და Asp ტეგების გამოყენება თუ გვინდა, php-ის კონფიგურაციაში უნდა გავააქტიუროთ შესაბამისი ფუნქციონალი. ისინი პორტატული არ არის და საერთოდ გვირჩევენ, რომ არ გამოვიყენოთ.
  • short ტეგებს კონფლიქტი მოსდით xml ჰედერთან.
  • ყველანაირი სიმბოლოები (მათ შორის ”ცარიელი” space-ები, ახალი ხაზის “\n” სიმბოლოები, ტაბები “\t”) რაც php ტეგების გარეთაა, პირდაპირ ბრაუზერის output-ში წავა. და თუ ისინი ჰედერებს გაუსწრებენ, არასასურველი შედეგი იქნება.
  • ზედა პუნქტიდან გამომდინარე php პარსერი დამხურავი ტაგის მომდევნო პირველ newline სიმბოლოს output-ში არ გაგზავნის, იმიტომ რომ ზოგი რედაქტორი ავტომატურად, ჩვენს გარეშე ამატებს ”\n”-ს ფაილის ბოლოს.
  • თუ დამხურავი ტეგი ფაილის ბოლოს არის, ის შეიძლება საერთოდ გამოვტოვოთ და ამით თავიდან ავიცილოთ ზევით განხილული შემთხვევა. შეცდომა არ იქნება, ოღონდ ეს xml პარსერს შეუშლის ხელს.

კომენტარები

  • ერთ-ხაზიანი კომენტარებისთვის შეგვიძლია // და # გამოვიყენოთ. მათი მოქმედება სრულდება იმავე ხაზის ბოლოს ან იმ ხაზზე მყოფ php-ის დამხურავ ტეგთან (ეს არ ეხება script  დამხურავ ტეგს).
  • მრავალ სტრიქონიანი კომენტარებისთვის –  /* */  ან /**  */
    მათზე php-ის დამხურავ ტეგს ზეგავლენა არ აქვს. ასევე არ აქვს მნიშვნელობა თუ რამდენ ასეთ კომენტარის ბლოკს ჩავდგამთ ერთმანეთში, მაგრამ მისი პირველივე დამხურავი ყველას ერთდროულად დახურავს.

ტიპები

PHP-ში რვა პრიმიტიული ტიპი არსებობს. აქედან:

ოთხი სკალარული: boolean, integer, float (ზუსტად იგივეა რაც double, ორი სახელი მხოლოდ ისტორიული მიზეზის გამოა შემორჩენილი), string

ორი შედგენილი: array, object

ორი სპეციალური ტიპი: resource, NULL

ასევე არის რამენიმე ფსევდო-ტიპი: mixed, number, callback

PHP მკაცრად ტიპიზირებული ენა არ არის, ამიტომ ცვლადის წინასწარ აღწერა და ტიპის გამოცხადება საჭირო არ არის. ტიპის დადგენა runtime დროს ხდება.

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

  • (int), (integer) – cast to integer
  • (bool), (boolean) – cast to boolean
  • (float), (double), (real) – cast to float
  • (string) – cast to string
  • (array) – cast to array
  • (object) – cast to object

boolean-ზე დაყვანის შემთხვევაში შემდეგი გამოსახულებები გამოდის false:

  • integer 0 (ნული)
  • float 0.0 (ნული)
  • ცარიელი სტრიქონი (string), და ასევე სტრიქონი, რომელიც მარტო ერთი ”0”-გან შედგება.
  • მასივი, რომელშიც ელემენტები არ არის.
  • სპეციალური ტიპი NULL
  • SimpleXML ობიექტი, რომელიც ცარიელი ტეგებისგან არის შექმნილი

integer ტიპზე დაყვანის დროს:

  • boolean ცვლადის დროს true გადადის ერთიანში, ხოლო false გადადის 0-იანში.
  • string ცვლადის დროს თუ სტრიქონი მხოლოდ რიცხვს არ შეიცავს, მაშინ ინტერპრეტატორი ყველანაირად ცდილობს მხოლოდ რიცხვის ნაწილი ამოიღოს. ის უგულველყოფს space-ებსაც, მაგრამ ვერაფერს იზამს, თუ სტრიქონი სხვა სიმბოლოებით იწყება (ამაზე იხილეთ სავარჯიშო 4 🙂 )

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

შეკითხვები:

შეკითხვები:
1. რას დაბეჭდავს შემდეგი კოდი:

/*
echo "Hi"
// */ echo "Am I commented out?";

Am I commented out?
*/-ს გადაფარავს //-ს.

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

// /* Hi ?> */ Am I commented out?

Am I commented out?
მიუხედავად იმისა, რომ PHP-ის დამხურავი ტეგი მრავალსტრიქონიან კომენტარებშია მოქცეული, ის მაინც დახურავს კომენტარს. როგორც ჩანს ამ შემთხვევაში //-ს გადაფარავს */-ს.

3. რას დაბეჭდავს შემდეგი კოდი (php.net):

var_dump(0 == 1);
var_dump(0 == (bool)'all');
var_dump(0 == 'all');
var_dump(0 === 'all');

boolean false
boolean false
boolean true
boolean false

4. რას შედეგი ექნება დაყვანებს (phpf1.com):

1. (int)"10"
2. (int)"10.5"
3. (int)"10,5"
4. (int)"10 "
5. (int)" 10 "
6. (int)"10test"
7. (int)"test10"

1. 10
2. 10
3. 10
4. 10
5. 10
6. 10
7. 0

5. რას დაბეჭდავს კოდი (php.net):

echo 01090;

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

6. რას დაბეჭდავს კოდი (php.net):

echo false;
echo false+false;
echo intval(false);
echo true;
echo true+true;
echo intval(true);

როგორც ჩანს boolean კონსტანტებს, true-ს და false-ს სხვადასხვანაირად ექცევა ინტერპრეტატორი.
იმის მაგივრად, რომ გამოვიდეს 000121, გამოდის 00121.
ცალკე აღებული false სტრიქონად გარდაქმნის დროს 0 არ ხდება, ხოლო true ხდება 1.

Zend PHP Certification

Zend | PHP Company

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

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

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

პ.ს. სავარჯიშოებს რაც შეეხება, ერთადერთი რაც ვნახე – The Zend PHP Certification Practice Test Book ეს არის. ეს კი ძალიან ცოტაა. ზოგადად შეცდომებზე ვსწავლობ და ბევრი ამოცანები მინდა ^^

თუ ვინმე გამიმხელთ კარგ რესურსს, მადლობელი ვიქნები 🙂

NetBeans IDE + Subversion

საიდან დავიწყო არ ვიცი… 🙂

სულ თავიდან მჭირდებოდა რამე IDE php-ისთვის. ჩვეულებრივ Dreamweavers ვიყენებ ამ ენისთვის, იშვიათად notepad++. მაგრამ დებაგს მაინც ვერ ველევი, tasklist-იც მაკლია 🙁 და დღეს გადავწყვიტე კიდევ ერთხელ ჩამოვუარო სხვა IDE-ებს.

პირველ რიგში მივიწყებული Aptana გავუშვი. დიდის ამბით გადავიტანე პროექტები, მაგრამ რად გინდა. სერვერებს ვერაფერი მოვუხერხე. ვაღიარებ, ჩემი ბრალია :blush2: მაგრამ მაინც ვერაფერი ვნახე bundled სერვერებზე. და ბოლოს იმდენად დამღალა, თავი დავანებე. + ამას რაღაცნაირად ნელია. და არც დებაგი აქვს მთლად ისეთი, რისი ხათრითაც დავრჩებოდი…

Eclipse-ს ვერ მოვერგე… მომავალ ჩამოვლაზე კიდევ შეიძლება მოსინჯვა..

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

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

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

რა შეიძლება ქნას ადამიანმა? ძველ ვერსიაზე დააბრუნოს subversion-ი. მაგრამ ოფიციალურ საიტზე ძველ ვერსიას ვერ ნახავთ 🙂 სამაგიეროდ შეხვდებით პითონზე დაწერილ დაუნგრეიდის სკრიპტს. და ინსტრუქციას: ”გამოძახების დროს პარამეტრად –help გადაეციო”. ასეთ დროს უკვე დაღლილი ხარ და შეიძლება ვერ მიხვდე რას უნდა ნიშნავდეს მთავარი პარამეტრის აბრევიატურა WC_PATH. მოკლედ დავიწყე სკრიპტში ქექვა 😀

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

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

პ.პ.ს. ბზობის დღესასწაულს გილოცავთ 🙂