ოპერატორები PHP-ში
PHP-ში არსებობს შემდეგი სახის ოპერატორები: არითმეტიკული, მინიჭების, ლოგიკური, შემადარებელი, ბიტური და ასევე არის დამატებით სხვა ოპერატორები, მაგალითად, ოპერატორი, რომელიც განსაზღვრავს მონაცემთა ტიპებს. დაწვრილებით ამ საკითხზე ქვემოთ ვისაუბრებთ. ოპერატორების უმრავლესობა მუშაობს განსაზღვრული ტიპის ოპერანდთან. მაგ. არითმეტიკული ოპერატორი ჩვეულებრივ მუშაობს რიცხვით არგუმენტებთან. ანალოგიურად სხვა ოპერატორების შემთხვევაში. ოპერატორი ნიშნავს, შემადარებელ საშუალებას, ნიშანს, რომლის საშუალებითაც ხდება პროგრამირებაში მონაცემთა, მიმართებათა, მნიშვნელობათა და ფუნქციათა შედარებები.
არითმეტიკული ოპერატორები
|
ოპერატორი |
აღწერა |
მაგალითი |
შედეგი |
|
+ |
შეკრება |
X=3; x+3 |
6 |
|
- |
გამოკლება |
X=3; 5-x |
2 |
|
* |
გამრავლება |
X=3; x*5 |
15 |
|
/ |
გაყოფა |
15/3 |
5 |
|
% |
მოდული |
5%2 |
1 |
|
++ |
გაზრდა |
X=3; x++ |
X=4 |
|
-- |
შემცირება |
X=3; x-- |
X=2 |
მოვიყვანოთ რამოდენიმე მაგალითი:
html
head
title მაგალითი /title
/head
body
?php
//დაბეჭდავს 6
print(2+2*2);
print("br\n");
//დაბეჭდავს 2.5
print(5/2);
print("br\n");
//დაბეჭდავს 1
print(5%2);
print("br\n");
//დაბეჭდავს 35
print("7 little Indians" *5);
print("br\n");
?
/body
/html
ბრაუზერში გამოჩნდება ასეთი სახით:
6
2.5
1
35
html
head
title მაგალითი /title
/head
body
?php
$visitorstoday=1;
//დაბეჭდავს 1
print($visitorstoday++);
//ცვლადის მნიშვნელობა გავზარდოთ 2-ით
print("br\n");
//დაბეჭდავს 3
print(++$visitorstoday);
print("br\n");
//დაბეჭდავს 4.14
$pi=3.14;
$pi++;
print($pi);
print("br\n");
//დაბეჭდავს PHP
$php="PHP";
print($php);
$php++;
print($php);
print("br\n");
//დაბეჭდავს PHP
$php="PHP";
$php--;
print($php);
print("br\n");
?
/body
/html
ბრაუზერში გამოჩნდება ასეთი სახით:
1
3
4.14
PHPPHQ
PHP
მინიჭების ოპერატორი
მინიჭების ყველა ოპერატორი ცვლადს ანიჭებს განსაზღვრულ მნიშვნელობას. ქვემოთ ჩამოთვლილია მინიჭების ოპერატორის სახეები:
|
ოპერატორი |
მაგალითი |
...იგივეა, რაც |
|
= |
X=y |
x=y |
|
+= |
X+=y |
x=x+y |
|
-= |
x-=y |
x=x-y |
|
*= |
X*=y |
x=x*y |
|
/= |
X/=y |
x=x/y |
|
%= |
X%=y |
x=x%y |
მოვიყვანოთ მაგალითი, რომელიც წარმოდგენას შეგვიქმნის მინიჭების ოპერატორზე:
html
head
title = operator /title
/head
body
?php
$count=0;
$count=$count+5;
print($count);
print("br\n");
$count=0;
$count+=5;
print($count);
print("br\n");
//დაბეჭდავს 13
print($a=$b=13);
print("br\n");
//დაბეჭდავს 7
$count=2;
print($count+=5);
print("br\n");
print($a);
print("br\n");
print($b);
?
/body
/html
ბრაუზერში გამოჩნდება ასეთი სახით:
5
5
13
7
13
13
ლოგიკური და შედარების ოპერატორები
ლოგიკური ოპერატორები ასრულებს ლოგიკურ ოპერაციებს, რომლებმაც შეიძლება მიიღოს მხოლოდ ორი მნიშვნელობა ჭეშმარიტი და მცდარი. ეს მნიშვნელობები აღინიშნებიან იდენტიფიკატორებით TRUE და FALSE. მნიშვნელობა, რომელიც გამოიყენება ლოგიკურ ოპერატორში შედარების ოპერაციის შემდეგ აბრუნებს ლოგიკურ მნიშვნელობას. რიცხვითი მნიშვნელობის დროს ნულოვანი მნიშვნელობა გაიგივებულია როგორც - FALSE, ყველა დანარჩენი, როგორც - TRUE. ცარიელი სტრიქონის მნიშვნელობას წარმოადგენს FALSE, ხოლო ყველა დანარჩენი არაცარიელი სტრიქონის მნიშვნელობას წარმოადგენს TRUE. ქვემოთ ჩამოთვლილია ლოგიკური და შედარების ოპერატორის სახეები:
ლოგიკური ოპერატორები
|
ოპერატორი |
აღწერა |
მაგალითი |
|
|
And |
x=4 y=2 (x 10 y 1) დააბრუნებს true |
|
|| |
Or |
x=4 y=2 (x==5 || y==5) დააბრუნებს false |
|
! |
Not |
x=4 y=2 !(x==y) დააბრუნებს true |
შედარების ოპერატორები
|
ოპერატორი |
აღწერა |
მაგალითი |
|
== |
უდრის |
5==8, აბრუნებს False |
|
!= |
არ უდრის |
5!=8, აბრუნებს True |
|
|
მეტია |
58, აბრუნებს False |
|
|
ნაკლებია |
58, აბრუნებს True |
|
= |
მეტია, ან ტოლია |
5=8, აბრუნებს False |
|
= |
ნაკლებია, ან ტოლია |
5=8, აბრუნებს True |
თუ ჩვენთვის ცნობილია ლოგიკური ოპერაციები, ისე როგორც მოცემული გვაქვს ქვედა ცხრილში. სადაც პირველ ორ სვეტში მოცემულია ყველა შესაძლო კომპინაცია p და q მნიშვნელობების. მაშინ დანარჩენ სამ სვეტში ლოგიკური ოპერაციების შესრულების შედეგად p და q შესაძლებელია მიიღოს შემდეგი მნიშვნელობები:
|
p |
q |
p and q |
p or q |
!p |
|
False |
False |
False |
False |
True |
|
False |
True |
False |
True |
True |
|
True |
False |
False |
True |
False |
|
True |
True |
True |
True |
False |
html
head
title Log. operator /title
/head
body
?php
$numerator=5;
$divisor=0;
if (($divisor==0) or (($num/$divisor) 1))
{
print("შედეგი 1");
}
?
/body
/html
ბრაუზერში გამოჩნდება ასეთი სახით:
შედეგი 1
ბიტური ოპერატორი
ბიტური ოპერატორების გამოყენება არცთუ ხშირად გვიწევს მაგრამ არის შემთხვევები როდესაც მათი გამოყენება შეიძლება სასარგებლო და ხშირ შემთხვევაში საუკეთესო გამოსავალიც კი იყოს. PHP აღჭურვილია შესაბამისი ოპერატორებით, რომლებიც შეიძლება გამოვიყენოთ ბიტური ოპერაციების ჩატარებისათვის.
პირველ რიგში მართებული იქნება თუ მიმოვიხილავთ ბაიტებსა და ბიტებს. ცნობილია რომ ბაიტი შედგება რვა(8) ბიტისაგან, ბიტს თავისთავად შეიძლება გააჩნდეს მხოლოდ ორი მნიშვნელობა 1(ერთი) ან 0(ნული). ბაიტის მაქსიმალური მნიშვნელობა განისაზღვრება 255 - ით.
თუ ბაიტს ვიზუალურად გამოვსახავთ შემდეგი ცხრილის სახით, სადაც თითოეული ბიტი წარმოადგენს 1, ანუ მაქსიმალურ მნიშვნელობას ბიტისას, მაშინ ბაიტის მაქსიმალურ მნიშვნელობას მივიღებთ 255:
|
1 |
1 |
1 |
1 |
1 |
1 |
1 |
1 |
= |
255 |
ვინაიდან, 128 + 64 + 32 + 16 + 8 + 4 + 2 + 1 = 255
შემდეგ ცხრილში მოცემულია ოპერატორების ცხრილი შესაბამისი განმარტებებით:
|
მაგალითი |
დასახელება |
რეზულტატი |
|
$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:
html
head
title Byte operator /title
/head
body
?php
$a = 7;
$b = 6;
echo $a $b;
?
/body
/html
თუ რატომ არის ამ გამოსახულების შედეგი 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:
html
head
title Byte operator /title
/head
body
?php
$a = 11;
$b = 6;
echo $a | $b;
?
/body
/html
თუ რატომ არის ამ გამოსახულების შედეგი 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:
html
head
title Byte operator /title
/head
body
?php
$a = 11;
$b = 6;
echo $a ^ $b;
?
/body
/html
თუ რატომ არის ამ გამოსახულების შედეგი 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:
?php
$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
ოპერატორი , მარცხნივ წაძვრის ოპერატორი
მაგალითისათვის შევასრულოთ შემდეგი კოდი:
?php
$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-ს:
?php
$a = 32;
echo $a 3;
?
ხოლო $a 3 ამ გამოსახულების გადაწერა შეიძლება შემდეგნაირად: 32/2/2/2=4
