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

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';

პასუხის ნახვა

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

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

პასუხის ნახვა

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

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

  return a;
}

პასუხის ნახვა

4. რა შედეგი ექნება კოდს?

$a = -10 % 3;
$a += "1";
echo $a;

პასუხის ნახვა

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

$a=1;
$a  +=  $a++   +   ++$a;
echo $a;

პასუხის ნახვა

6. რა მნიშვნელობა იქნება $a ცვლადში ამ სტრიქონის შესრულების შემდეგ (php.net)?

$a = true ? 0 : true ? 1 : 2; 

პასუხის ნახვა

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

echo 2 ^ "3";
echo "2" ^ 3;

პასუხის ნახვა

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

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

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

პასუხის ნახვა

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

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

პასუხის ნახვა

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?";

პასუხის ნახვა

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

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

პასუხის ნახვა

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

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

პასუხის ნახვა

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"

პასუხის ნახვა

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

echo 01090;

პასუხის ნახვა

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

პასუხის ნახვა

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

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

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

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

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

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

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

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

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

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

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

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

String regex="[a-zA-Z]+”;
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(”StringToMatch”);
System.out.println(matcher.matches());


იგივე გადავიტანე მეორე ენაზე.

$regex="/[a-zA-Z]/”;
echo preg_match($regex,’StringToMatch’);


მაგრამ ეს პატერნი ერგებოდა როგორც მაგალითად StringToMatch სტრიქონს, ისე asdf1234. asdf45fg67-საც.. და საერთოდ neb1$mier_texts.

საქმე იმაშია, რომ preg_match ფუნქცია აბრუნებს 1-ს იმ შემთხვევაშიც, თუ ერთხელ მაინც შეხვდა სადმე პატერნის შესაბამისი ტექსტი. თუ გვინდა რომ მთელს სტრიქონზე იმუშაოს, მაშინ უნდა ჩავამატოთ დასაწყისის (^) და დასასრულის ($) აღმნიშვნელი სიმბოლოები. ანუ გამოსახულებას უნდა ჰქონდეს სახე:
$regex="/^[a-zA-Z]$/”;

დოკუმენტაციის წაკითხვა უნდოდა დაკვირვებით…