შესაძლებელია თუ არა რთული ლოგიკა PHP-ში? ოპერაციები PHP-ში

გაკვეთილი მოიცავს პირობით php განცხადებებს: if და switch ინსტრუქციებს

PHP პირობითი განცხადებები წარმოდგენილია სამი ძირითადი კონსტრუქტით:

  • მდგომარეობის ოპერატორი თუ,
  • გადართვის ოპერატორი შეცვლა
  • და სამეული ოპერატორი.

მოდით უფრო ახლოს მივხედოთ თითოეულ მათგანს.

PHP if განცხადება

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


ბრინჯი. 3.2. IF ELSE პირობითი განცხადების სინტაქსი


ბრინჯი. 3.3. IF elseif პირობითი განცხადების სრული სინტაქსი

მოდით შევაჯამოთ:

სრული სინტაქსი:

if (პირობა) ( // თუ პირობა არის ჭეშმარიტი ოპერატორი1; ოპერატორი2; ) elseif(პირობა) (ოპერატორი1; ... ) else ( // თუ პირობა არის მცდარი ოპერატორი1; ოპერატორი2; )

  • შემოკლებული სინტაქსი შეიძლება არ შეიცავს else პუნქტის ნაწილებს და არ შეიცავს დამატებით elseif პირობას
  • ფუნქციური სიტყვის ნაცვლად elseif, შეგიძლიათ დაწეროთ other if (ცალკე)
  • შეიძლება არსებობდეს რამდენიმე სხვა თუ კონსტრუქცია ერთში. პირველი elseif გამონათქვამი, რომელიც ტოლია TRUE-ს, შესრულდება.
  • თუ არსებობს ალტერნატიული elseif პირობა, სხვა პუნქტი ბოლო უნდა იყოს სინტაქსში.

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

ბრინჯი. 3.4. პირობითი განცხადება If და Endif php-ში

მაგალითი:

if($x > $y): echo $x." მეტია ვიდრე ".$y; elseif($x == $y): // ":"-ის გამოყენებისას თქვენ არ შეგიძლიათ დაწეროთ ცალკე სხვა თუ echo $x." უდრის ".$y; else: echo $x." not > and not = ".$y; დაასრულე თუ;

Მნიშვნელოვანი:კონსტრუქციაში ხვეული ბრეკეტების ნაცვლად მსხვილი ნაწლავის გამოყენებისას, elseif ორი სიტყვით ვერ ჩაიწერება!

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

ფრჩხილებში მოცემული if მდგომარეობა შეიძლება შეიცავდეს შემდეგ ოპერაციებს:

მაგალითი:შეამოწმეთ რიცხვითი ცვლადის მნიშვნელობა: თუ ის 10-ზე ნაკლებია ან ტოლია, აჩვენეთ შეტყობინება "10-ზე ნაკლები ან ტოლი რიცხვი", წინააღმდეგ შემთხვევაში აჩვენეთ შეტყობინება "10-ზე მეტი რიცხვი"


გამოსავალი:

$ნომერი=15; თუ ($ ნომერი<=10) { echo "число меньше или равно 10"; } else { echo "число больше 10"; }

PHP კოდის ბლოკები შეიძლება დაირღვეს, მოდით შევხედოთ მაგალითს:

მაგალითი:ეკრანზე html კოდის ჩვენება "ა უდრის 4", თუ $a ცვლადი ნამდვილად 4-ის ტოლია


1 გამოსავალი:
1 2 3 4

2 გამოსავალი:

1 2 3 A უდრის 4-ს

A უდრის 4-ს

php სამუშაო 3_1:აჩვენეთ ფერების თარგმანი ინგლისურიდან რუსულად, შეამოწმეთ ცვლადის მნიშვნელობა (რომელშიც ფერი მინიჭებულია: $a="blue")


php სამუშაო 3_2:იპოვეთ მაქსიმუმ სამი რიცხვი

შედარების ოპერაციები და სიცრუის წესი

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

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

1 2 3 4 $a = 1; თუ ($a) (echo $a;)

$a=1; თუ ($a) (echo $a;)

მაგალითში PHP ენის მთარგმნელი ფრჩხილებში ცვლადს სიცრუის წესად ჩათვლის:

ტყუილის წესი ან ის, რაც ტყუილად ითვლება:

  • ლოგიკური ყალბი
  • მთელი ნული ( 0 )
  • რეალური ნული ( 0.0 )
  • ცარიელი ხაზიდა სიმებიანი «0»
  • მასივი ელემენტების გარეშე
  • ობიექტი ცვლადების გარეშე
  • სპეციალური ტიპი NULL

ამრიგად, განხილულ მაგალითში $a ცვლადი უდრის ერთს, შესაბამისად პირობა იქნება true და ოპერატორი echo $a; აჩვენებს ცვლადის მნიშვნელობას.

php სამუშაო 3_3:მოცემულია ცვლადი a სტრიქონის მნიშვნელობით. თუ a უდრის სახელს, მაშინ დაბეჭდეთ "გამარჯობა, სახელი!", თუ a უდრის ცარიელ მნიშვნელობას, მაშინ გამომავალი "Გამარჯობა უცნობო!"

ლოგიკური კონსტრუქტები AND OR და NOT პირობით ოპერატორში

  1. ზოგჯერ საჭიროა რამდენიმე პირობის ერთდროულად შესრულება. შემდეგ პირობები გაერთიანებულია ლოგიკური ოპერატორი AND — && :

    2. $a=1; თუ ($a>0 || $a>1) ( ექო "a > 0 ან a > 1"; )

  2. მცდარი მდგომარეობის დასადგენად გამოიყენეთ ლოგიკური ოპერატორი NOT — ! :
    3. 1 2 3 4 $a = 1; თუ (! ($a< 0 ) ) { echo "a не < 0" ; }

    $a=1; თუ (!($a<0)) { echo "a не < 0"; }

გადართვის ოპერატორი PHP

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

Სინტაქსი:

1 2 3 4 5 6 7 8 9 10 შეცვლა ($ცვლადი) ( case "value1" : operator1 ; break ; case "value2" : operator2 ; break ; case "value3" : operator3 ; break ; [ default : operator4 ; break ; ] )

switch($variable)( case "value1": ოპერატორი1; break; case "value2": operator2; break; case "value3": operator3; break; )

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

ბრინჯი. 3.5. პირობითი გადართვის განცხადება


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


გამოსავალი:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 $names = მასივი ("ივანე" , "პეტრე" , "სემიონი" ); switch ($names [ 0 ] ) ( case "Peter" : echo "Hello, Petya!" ; break ; case "Ivan" : echo "Hello, Vanya!" ; break ; case "Semyon" : echo "Hi, Vanya! " ; break ; ნაგულისხმევი : echo "გამარჯობა, $names!"; შესვენება ; )

$names=მასივი ("ივანე", "პიტერი", "სემიონი"); switch($names)( case "Peter": echo "Hello, Petya!"; break; case "Ivan": echo "Hello, Vanya!"; break; case "Semyon": echo "Hello, Vanya!"; break ; ნაგულისხმევი: ექო "გამარჯობა, $names!"; შესვენება;)

php სამუშაო 3_4:

  • შექმენით $day ცვლადი და მიანიჭეთ მას თვითნებური რიცხვითი მნიშვნელობა
  • გადამრთველის კონსტრუქციის გამოყენებით დაბეჭდეთ ფრაზა "სამუშაო დღეა", თუ $day ცვლადის მნიშვნელობა ხვდება რიცხვების დიაპაზონში 1-დან 5-მდე (მათ შორის)
  • დაბეჭდეთ ფრაზა "დასვენების დღეა", თუ $day ცვლადის მნიშვნელობა უდრის 6 ან 7 რიცხვებს
  • დაბეჭდეთ ფრაზა "უცნობი დღე", თუ $day ცვლადის მნიშვნელობა არ ჯდება 1-დან 7-მდე რიცხვების დიაპაზონში (მათ შორის)

შეავსეთ კოდი:

1 2 3 4 5 6 7 8 9 10 11 12 ... შეცვლა (... ) ( case 1 : case 2 : ... echo "სამუშაო დღეა"; შესვენება ; შემთხვევა 6 : ... ნაგულისხმევი : ... )

შეცვლა (...)( შემთხვევა 1: შემთხვევა 2: ... ექო "სამუშაო დღეა"; შესვენება; შემთხვევა 6: ... ნაგულისხმევი: ... )

PHP სამჯერადი ოპერატორი

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

მდგომარეობა? ოპერატორი1: ოპერატორი2;

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

ამ სტატიაში ჩვენ ვისწავლით რა არის php ოპერატორები. ფაქტობრივად, ზოგიერთ მათგანს თითქმის ბავშვობიდან ვიცნობთ, მაგრამ მხოლოდ ნიშნებად ვიცნობთ (+, -, =, !, ?).

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

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

დავიწყოთ თანმიმდევრობით.

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

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

+ არის დამატების ოპერატორი;
— — გამოკლების ოპერატორი;
/ - სამმართველოს ოპერატორი;
* — გამრავლების ოპერატორი;
% არის გაყოფის დროს ნაშთის მიღების ოპერატორი;
++ — ერთით გაზრდის ოპერატორი (ნამატით);
— — — შემცირება ერთი ოპერატორით (კლება)

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

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

ექო (6 + 7 ) * (7 + 8); // 195
?>

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

ექო 8/3; //2.66666666666
?>

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

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

echo 53328 % 4 ; //0
?>

ოპერაციები არითმეტიკული ოპერატორებით, გარდა ნამატისა და შემცირებისა, ეწოდება ორობითი, რადგან ისინი მოიცავს ორ ოპერანდს (ტერმინი + ტერმინი, დივიდენდი / გამყოფი და ა.შ.)

ზრდისა და შემცირების მოქმედებები ე.წ ერთიანი, ვინაიდან ისინი მოიცავს ერთ ოპერანდს. კიდევ არის კიდევ პირობითი ოპერაცია, რომელიც მოიცავს სამ ოპერანდს.

ზრდის (++) და კლების (- -) ოპერატორები ვრცელდება მხოლოდ ცვლადებზე.

ცვლადის ტიპის მთელი რიცხვი (მთლიანი რიცხვები)

$შემდეგი = 3 ;
ექო +$შემდეგი; // 4
?>

ცვლადი ტიპის სტრიქონი

$next = "abc";
ექო $ შემდეგი; //აბდ
?>

ასო „დ“ იბეჭდება ასო „გ“-ს ნაცვლად, რადგან ანბანში შემდეგია და ცვლადის მნიშვნელობა ერთით გავზარდეთ.

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

ბიტიური ოპერატორები

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

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

& - ბიტური კავშირი AND (and);
~ — ბიტის უარყოფა (არა);
| — ბიტური კავშირი OR (ან);
^ - ბიტიური ელიმინაცია OR (xor);
<< — сдвиг влево битового значения операнда;
>> — ოპერანდის ბიტის მნიშვნელობის მარჯვნივ გადატანა;

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

შედარება ოპერატორები

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

> - ოპერატორი აღემატება;
=> - მეტი ან ტოლი ოპერატორი;
< — оператор меньше;
<= — оператор меньше или равно;
== — თანასწორობის ოპერატორი;
!= — უტოლობის ოპერატორი;
=== — ეკვივალენტობის ოპერატორი (ცვლადის მნიშვნელობა და ტიპი ტოლია);
!== — არაეკვივალენტური ოპერატორი;

შედარების შედეგად ეკრანზე გამოჩნდება ან ერთი, რომელიც შეესაბამება true (true), ან ცარიელი სტრიქონი, რომელიც შეესაბამება false-ს (false).

ექო 1 > 0; // 1
ექო 1< 0 ; // пустая строка
ექო 1 => 0 ; // 1
ექო 1 == 1 ; // 1
?>

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

პირობითი განცხადებები if, else, elseif.

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

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



თუ ($ შემდეგი< $nexT)
{
ექო "ნალექის ალბათობა"; // გამომავალი ნალექი შესაძლებელია
}
?>

$next = "ჰაერის ტენიანობა 80%";
$nexT = "ჰაერის ტენიანობა 90%";
თუ ($ შემდეგი > $ შემდეგი)
{
ექო "ნალექის ალბათობა"; // ცარიელი ხაზის ამობეჭდვა
}
?>

თუ პროგრამას სჭირდება ორი მოქმედების მითითება, რომელთაგან ერთი შესრულდება, თუ მნიშვნელობა არის true, ხოლო მეორე, თუ მნიშვნელობა false, მაშინ if განცხადებასთან ერთად გამოიყენება else განცხადება.

$next = "ჰაერის ტენიანობა 80%";
$nexT = "ჰაერის ტენიანობა 90%";
თუ ($ შემდეგი > $ შემდეგი)
{
ექო "ნალექის ალბათობა";
}
სხვა
{
ექო "ნალექი არ არის მოსალოდნელი";
}
?>

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

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



თუ ($ შემდეგი > $ შემდეგი)
{
ექო "მე ვხედავ";
}
elseif ($ შემდეგი<= $nexT)
{
ექო "თოვლი";
}
elseif ($ შემდეგი >= $ შემდეგი)
{
ექო "წვიმა";
}
elseif ($ შემდეგი == $ შემდეგი)
{
ექო "გვალვა";
}
სხვა
{
ექო "ნალექის ალბათობა";
}
?>

ეს პროგრამა გამოსცემს "თოვლს". თუ არცერთი პირობა არ ემთხვევა, გამოჩნდება "ნალექის ალბათობა".

if განცხადება შეიძლება შეიცავდეს იმდენ elseif ბლოკს, რამდენიც გსურთ, მაგრამ მხოლოდ ერთი სხვა განცხადება.

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

$next = "ჰაერის ტენიანობა 50%";
$nexT = "ჰაერის ტენიანობა 60%";
თუ ($ შემდეგი<= $nexT):

ექო "თოვლი";

elseif ($ შემდეგი >= $ NextT):

ექო "წვიმა";

elseif ($ შემდეგი == $ NextT):

ექო "გვალვა";

სხვა:

ექო "ნალექის ალბათობა";
დაასრულე თუ ;
?>

ლოგიკური ოპერატორები

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

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

&& - დამაკავშირებელი კავშირი AND;
და - ასევე AND, მაგრამ უფრო დაბალი პრიორიტეტით;
|| - გამყოფი კავშირი OR;
ან - ასევე OR, მაგრამ უფრო დაბალი პრიორიტეტით;
xor - ექსკლუზიური OR;
! - უარყოფა;

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

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

დავალების ოპერატორი

მინიჭების ოპერატორი = ანიჭებს მარჯვენა ოპერანდის მნიშვნელობას მარცხენა ოპერანდს.

$next = "გამარჯობა"
ექო "გამარჯობა" // გამარჯობა
?>

ოპერატორის წერტილი

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

$ შემდეგი = 22 ;
echo "დღეს შემდეგ" .$next. "მოსალოდნელია ყინვა"; // დღეს 22 წლის შემდეგ ყინვაა მოსალოდნელი
?>

ფრჩხილების ოპერატორი

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

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

ხვეული ბრეკეტების ოპერატორი

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

1. BSD სტილი - ფრჩხილები გასწორებულია მარცხნივ.

თუ ($ შემდეგი)
{

}

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

თუ ($ შემდეგი)
{
echo "გამარჯობა ძვირფასო დამწყებ პროგრამისტებო";
}

3. K&R სტილი - ოპერატორის ხაზზე იხსნება ფრჩხილები

თუ ($ შემდეგი) (
echo "გამარჯობა ძვირფასო დამწყებ პროგრამისტებო";
}

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

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

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

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

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

ამ პრობლემის გადასაჭრელად, არსებობს ლოგიკური ოპერატორები:

= 5 და $ ფასი<= 10) echo "Это число находится между 5 и 10"; ?>

ასევე ე.წ. && ოპერატორი ლოგიკური და, გარდაქმნის მნიშვნელობებს მარცხნივ და მარჯვნივ ლოგიკურ ტიპად, შემდეგ კი თავად აბრუნებს ლოგიკურ მნიშვნელობას: true, თუ მარცხენა და მარჯვენა არის true, ან false, თუ ერთ-ერთი პირობა არის false.

სხვა სიტყვებით რომ ვთქვათ, თუ ორივე პირობა ჭეშმარიტია, მაშინ && ოპერატორი აბრუნებს true. ეს არის ის, რაც ასახავს ოპერატორის სახელს.

ოპერატორი || ან ლოგიკური ანბრუნდება true, როდესაც ორი პირობიდან ერთი მაინც არის ჭეშმარიტი:

5 || 1 > 2) ექო "პირობა დაკმაყოფილებულია."; ?>

ზემოთ მოცემულ კოდში, echo ბრძანება შესრულდება, რადგან ერთ-ერთი პირობა მართალია.

ყველა ლოგიკური ოპერატორი PHP-ში

&& და და ოპერატორებს შორის, ასევე ||-ს შორის და ან არის მცირე განსხვავება - შესრულების თანმიმდევრობა.

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

უცნაურია, არა? ვინაიდან y = აქვს უფრო მაღალი პრიორიტეტი, PHP კოდს ასე განმარტავს:

($var = true) და false;

იმათ. ჯერ $var-ს აყენებს true-ზე და შემდეგ აკეთებს true და false ოპერაციას, რაც უაზროა, რადგან არ ახდენს გავლენას ცვლადის მნიშვნელობაზე.

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

  • ++ -- ~ (int) (float) (სტრიქონი) (მაივი) (ობიექტი) (bool) @
  • * / %
  • + - .
  • < <= > >=
  • == != === !== <> <=>
  • ? : (სამიანი ოპერატორი)
  • = += -= *= **= /= .= %= &= |= ^= <<= >>=

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


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

თუ (პირობა) (
პირობა დაკმაყოფილებულია, გააკეთე ეს
}
სხვა
{
პირობა არ არის დაკმაყოფილებული, გააკეთე სხვანაირად
}
იმედი მაქვს, პირობითი ოპერაციის ლოგიკა გასაგებია. ახლა მოდით შევხედოთ მაგალითს.

$a = 5;
$b = 25;

// ახლა ყურადღება! მდგომარეობა: თუ $b მეტია $a-ზე
// ნიშნები > და< , как и в математике, обозначают больше и меньше
if ($b > $a)
{
// თუ პირობა დაკმაყოფილებულია, მაშინ შეასრულეთ ეს მოქმედება
ექო "$b მეტია ვიდრე $a";
}
სხვა
{
// თუ არ არის შესრულებული, მაშინ ეს
echo "$a მეტია ან ტოლია $b-ზე";
}
?>
დემონსტრაცია ჩამოტვირთეთ წყაროები
შედეგად, სკრიპტი გამოვა 25-ით მეტი 5-ზე. მაგალითი საკმაოდ მარტივია. იმედია ყველაფერი ნათელია. ახლა მე გთავაზობთ უფრო რთული სიტუაციის განხილვას, სადაც რამდენიმე პირობა უნდა დაკმაყოფილდეს. ყოველი ახალი პირობა შეიცავს ძირითად მდგომარეობას თუ ()- დამხმარე, რომელიც იწერება როგორც სხვა თუ (). ბოლოს როგორც ყოველთვის იქნება სხვა.

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

$ტესტი = 82; // ვთქვათ, მოსწავლემ დაწერა ტესტი 82 ქულით

// დაწერეთ პირველი პირობა ხუთისთვის
if ($test > 90)
{
// თუ პირობა დაკმაყოფილებულია, მაშინ შეასრულეთ ეს მოქმედება.
ექო "რეიტინგი 5";
}
// && ნიშანი ნიშნავს "და, გაერთიანებას", რომ პირობა დაკმაყოფილებულია, თუ ორივე მართალია
// ანუ ქულა არის 91-ზე ნაკლები და 80-ზე მეტი, შემდეგ 4. წინააღმდეგ შემთხვევაში პირობები იკითხება შემდგომ
სხვა შემთხვევაში, თუ ($test< 91 && $test > 80)
{
ექო "რეიტინგი 4";
}
სხვა შემთხვევაში, თუ ($test< 81 && $test > 70)
{
ექო "რეიტინგი 3";
}
სხვა
{
ექო „ტესტი ისევ უნდა დავწეროთ...“;
}
?>
დემონსტრაცია ჩამოტვირთეთ წყაროები
ჩვენი მოსწავლე, რომელსაც აქვს დრო დაისვენოს და დაწეროს ნორმალური ტესტი, იღებს რეიტინგი 4! იმედი მაქვს მოქმედების პრინციპი გასაგებია.

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

$ასაკი = 19; // ცვლადი ასაკის მიხედვით

თუ ($age > 17)(
echo "ესე იგი! მე შემიძლია გავაკეთო რაც მინდა! მე უკვე $ასე ვარ!";
}
პირობითი ოპერაციის მოკლე აღნიშვნის საკმაოდ კარგი მაგალითია. სხვაარ არის საჭირო დაწერა.

ოპერატორების შედარება PHP-ში

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

მაგალითი სახელის შედეგი
$a == $b უდრის True თუ $a უდრის $b
$a === $b იდენტურია True-ს, თუ $a უდრის $b-ს და ორივე ცვლადი ერთი ტიპისაა
$a != $b არ უდრის True-ს, თუ $a არ არის $b-ის ტოლი
$a === $b არ არის იდენტური True-ს, თუ $a არ არის $b-ის ტოლი და ორივე ტიპი არ არის იგივე
$a > $b მეტი True, თუ $a მეტია $b-ზე
$a< $b Меньше чем True, если $a меньше, чем $b
$a >= $b მეტი ან ტოლი True, თუ $a მეტია ან ტოლია $b-ზე
$a<= $b Меньше или равно True, если $a меньше или равно $b
ახლა მოდით შევხედოთ ოპერატორებს მაგალითებით:

// ჩვევის საწინააღმდეგოდ = ნიშნავს ცვლადისთვის მნიშვნელობის მინიჭებას და == ტოლია
თუ ($a == 5)(
ექო "$a არის 5"; // დაბეჭდავს "5 უდრის 5"
) სხვა (
echo "$a არ არის 5-ის ტოლი";
}

თუ ($a != 6)(
ექო "$a არ არის 6-ის ტოლი"; // დაბეჭდავს "5 არ არის 6-ის ტოლი". უარის შემთხვევაში აუცილებელია
) სხვა (
echo "$a რატომღაც უდრის 6";
}

// მეტი და ნაკლები მგონი ყველაფერი გასაგებია. ამიტომ მაგალითი უფრო რთულია
თუ ($a<= 6){
echo "$a არის 6-ზე ნაკლები ან ტოლი"; // დაბეჭდავს "5 არის 6-ზე ნაკლები ან ტოლი"
) სხვა (
ექო "$a მეტია 6-ზე";
}

PHP ლოგიკური ოპერატორები

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

მაგალითი სახელის შედეგი
$a და $b ლოგიკური "და" TRUE, თუ ორივე $a და $b არის TRUE.
$a ან $b ლოგიკური "ან" TRUE თუ $a ან $b არის TRUE.
$a xor $b ექსკლუზიური "ან" TRUE თუ $a ან $b არის TRUE, მაგრამ არა ორივე.
! $a TRUE-ის უარყოფა, თუ $a არ არის TRUE.
$a && $b ლოგიკური "და" TRUE თუ $a და $b არის TRUE.
$a || $b ლოგიკური "ან" TRUE თუ $a ან $b არის TRUE.
ჩვენ უკვე შევნიშნეთ ეს ოპერაციებისთვის დადა ანარის დამატებითი ოპერატორები? ეს კეთდება კომპლექსური შედარების ოპერაციების პრიორიტეტის მინიჭების მიზნით. ცხრილში ლოგიკური ოპერატორები ჩამოთვლილია პრიორიტეტის მიხედვით: უმცირესიდან უდიდესამდე, ანუ, მაგალითად, || აქვს უფრო მაღალი პრიორიტეტი ვიდრე ან.

მოდით გადავიდეთ მაგალითებზე

$a = 5;
$b = 6;
$c = 7;

// პირობა: თუ 5 არ არის 6-ის ტოლი (TRUE) და 6 არ არის 7-ის ტოლი (TRUE)
თუ ($a< 6 && $b != $c){
ექო "ნამდვილად ასეა!"; // დაბეჭდავს "ნამდვილად ასეა!" რადგან ორივე პირობა მართალია
) სხვა (
ექო "ერთ-ერთი პირობა არ შეესაბამება სიმართლეს";
}

// პირობა: თუ 6 არ არის 6-ის ტოლი (FALSE) ან 6 არ არის 7-ის ტოლი (TRUE)
თუ ($b != 6 || $b != $c)(
ექო "ესე იგი!"; // გამოჩნდება "ესე იგი!", რადგან მინიმუმ ერთი პირობა არის TRUE
) სხვა (
ექო "ორივე პირობა მცდარია";
}

მესამეული ოპერატორი

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

კოდის არსი:(პირობა)? მნიშვნელობა a if true: მნიშვნელობა a if false

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

// სამიანი ოპერატორის გამოყენების მაგალითი
$settings = (ცარიელი($_POST["პარამეტრები"])) ? "ნაგულისხმევი" : $_POST["პარამეტრები"];

// ზემოთ მოცემული კოდი მსგავსია შემდეგი ბლოკის გამოყენებით if/else
თუ (ცარიელი ($_POST["პარამეტრები"])) (
$settings = "ნაგულისხმევი"; // თუ არაფერი არ არის გადაცემული, დატოვეთ ის როგორც "ნაგულისხმევი"
) სხვა (
$settings = $_POST["პარამეტრები"]; // თუ გავიდა, მაშინ $settings ენიჭება გადაცემული მნიშვნელობა.
}
?>
წაიკითხეთ კომენტარები კოდზე და ყველაფერი გასაგები უნდა იყოს.

Გმადლობთ ყურადღებისთვის!


ბოლო განახლება: 11/1/2015

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

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

    + (დამატების ოპერაცია)

    მაგალითად, $a + 5

    - (გამოკლების ოპერაცია)

    მაგალითად, $a - 5

    * (გამრავლება)

    მაგალითად, $a * 5

    / (განყოფილება)

    მაგალითად, $a / 5

    % (გაყოფის დარჩენილი ნაწილის მიღება)

    მაგალითად: $a=12; echo $a % 5; // უდრის 2-ს

    ++ (მნიშვნელობის გაზრდა/გადიდება ერთით)

    მაგალითად, ++$a

    მნიშვნელოვანია გვესმოდეს განსხვავება გამონათქვამებს ++$a და $a++ შორის. Მაგალითად:

    $a=12; $b=++$a; // $b უდრის 13 echo $b-ს;

    აქ ჯერ ერთი ემატება $a ცვლადის მნიშვნელობას, შემდეგ კი მისი მნიშვნელობა უტოლდება $b ცვლადს. განსხვავებული იქნებოდა, თუ გამოთქმა ასე გამოიყურებოდა: $b=$a++; . აქ ჯერ $a ცვლადის მნიშვნელობა $b ცვლადის ტოლი იყო, შემდეგ კი $a ცვლადის მნიშვნელობა გაიზარდა.

    -- (მნიშვნელობის შემცირება/დაკლება ერთით)

    მაგალითად, --$a. ასევე, როგორც ნამატის შემთხვევაში, არსებობს ჩაწერის ორი ტიპი: --$a და $a--

დავალების ოპერატორები

    უდრის ცვლადს კონკრეტულ მნიშვნელობასთან: $a = 5

    დამატება, რასაც მოჰყვება შედეგის მინიჭება. მაგალითად: $a=12; $a += 5; ექო $a; // უდრის 17-ს

    გამოკლება, რასაც მოჰყვება შედეგის მინიჭება. მაგალითად: $a=12; $a -= 5; ექო $a; // უდრის 7-ს

    გამრავლება, რასაც მოჰყვება შედეგის მინიჭება: $a=12; $a *= 5; ექო $a; // უდრის 60-ს

    გაყოფა მოჰყვება შედეგის მინიჭებას: $a=12; $a /= 5; ექო $a; // უდრის 2,4

    შეაერთეთ რიგები და მიანიჭეთ შედეგი. ვრცელდება ორ ხაზზე. თუ ცვლადები არ ინახავს სტრიქონებს, არამედ, მაგალითად, რიცხვებს, მაშინ მათი მნიშვნელობები გარდაიქმნება სტრიქონებში და შემდეგ შესრულდება ოპერაცია: $a=12; $a .= 5; ექო $a; // უდრის 125 // იდენტურია $b="12"-ის; $b .="5"; // უდრის 125-ს

    გაყოფის ნაშთის მიღება და შემდეგ შედეგის მინიჭება: $a=12; $a %= 5; ექო $a; // უდრის 2-ს

შედარების ოპერაციები

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

    თანასწორობის ოპერატორი ადარებს ორ მნიშვნელობას და თუ ისინი ტოლია, აბრუნებს true, წინააღმდეგ შემთხვევაში აბრუნებს false: $a == 5

    პირადობის ოპერატორი ასევე ადარებს ორ მნიშვნელობას და თუ ისინი ტოლია, აბრუნებს true, წინააღმდეგ შემთხვევაში აბრუნებს false: $a === 5

    ადარებს ორ მნიშვნელობას და თუ ისინი არ არის ტოლი, აბრუნებს true, წინააღმდეგ შემთხვევაში აბრუნებს false: $a != 5

    ადარებს ორ მნიშვნელობას და თუ ისინი არ არის ტოლი, აბრუნებს true, წინააღმდეგ შემთხვევაში აბრუნებს false: $a !== 5

    ადარებს ორ მნიშვნელობას და თუ პირველი მეტია მეორეზე, მაშინ აბრუნებს true, წინააღმდეგ შემთხვევაში აბრუნებს false: $a > 5

    ადარებს ორ მნიშვნელობას და თუ პირველი ნაკლებია მეორეზე, მაშინ აბრუნებს true, წინააღმდეგ შემთხვევაში აბრუნებს false: $a< 5

    ადარებს ორ მნიშვნელობას და თუ პირველი მეტია ან ტოლია მეორეზე, მაშინ აბრუნებს true, წინააღმდეგ შემთხვევაში აბრუნებს false: $a >= 5

    ადარებს ორ მნიშვნელობას და თუ პირველი არის მეორეზე ნაკლები ან ტოლი, მაშინ აბრუნებს true, წინააღმდეგ შემთხვევაში აბრუნებს false: $a<= 5

თანასწორობისა და იდენტურობის ოპერატორი

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

ცხადია, ცვლადები ინახავს სხვადასხვა ტიპის მნიშვნელობებს. მაგრამ შედარებისას ისინი დაიყვანება იმავე ტიპზე - რიცხვით. ხოლო $a ცვლადი შემცირდება 22-მდე. და ბოლოს, ორივე ცვლადი ტოლი იქნება.

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

$a = ყალბი; $b = 0;

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

$a = "22a"; $b = 22; if($a===$b) echo "თანაბარი"; სხვას ექო "არა თანაბარი";

ახლა ცვლადები არ იქნება თანაბარი.

უტოლობის ოპერატორები != და !== მუშაობენ ანალოგიურად.

ლოგიკური ოპერაციები

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

    აბრუნებს true, თუ ორივე შედარების ოპერაცია დააბრუნებს true, წინააღმდეგ შემთხვევაში აბრუნებს false: $a == 5 && $b = 6

    && ოპერაციის მსგავსი: $a == 5 და $b > 6

    აბრუნებს true, თუ მინიმუმ ერთი შედარების ოპერაცია დააბრუნებს true, წინააღმდეგ შემთხვევაში აბრუნებს false: $a == 5 || $b = 6

    ოპერაციის მსგავსი || : $a< 5 or $b > 6

    აბრუნებს true, თუ შედარების ოპერაცია დააბრუნებს false: !($a >= 5)

    აბრუნებს true, თუ მხოლოდ ერთი მნიშვნელობა არის true. თუ ორივე მართალია ან არცერთი არ არის ჭეშმარიტი, ბრუნდება false. მაგალითად: $a=12; $b=6; if($a xor $b) echo "true"; სხვას ექო "ცრუ";

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

    $a=12; $b=NULL; if($a xor $b) echo "true"; სხვას ექო "ცრუ";

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

ბიტის ოპერაციები

ბიტის ოპერაციები შესრულებულია რიცხვის ცალკეულ ბიტებზე. რიცხვები განიხილება ბინარულ წარმოდგენაში, მაგალითად, ორობითი წარმოდგენისას 2 არის 010, რიცხვი 7 არის 111.

    & (ლოგიკური გამრავლება)

    გამრავლება ხდება ბიტზე და თუ ორივე ოპერანდს აქვს ბიტის მნიშვნელობები 1-ის ტოლი, მაშინ ოპერაცია აბრუნებს 1-ს, წინააღმდეგ შემთხვევაში ბრუნდება რიცხვი 0. მაგალითად: $a1 = 4; //100 $b1 = 5; //101 echo $a1 & $b1; // უდრის 4-ს

    აქ რიცხვი 4 ბინარულ სისტემაში არის 100, ხოლო რიცხვი 5 არის 101. გაამრავლეთ რიცხვები ცოტათი და მიიღეთ (1*1, 0*0, 0 *1) = 100, ანუ რიცხვი 4 ათწილადში. ფორმატი.

    | (ლოგიკური დამატება)

    ლოგიკური გამრავლების მსგავსად, ოპერაცია ასევე შესრულებულია ორობით ციფრებზე, მაგრამ ახლა ერთი ბრუნდება, თუ მოცემულ ციფრში ერთ რიცხვს მაინც აქვს ერთი. მაგალითად: $a1 = 4; //100 $b1 = 5; //101 ექო $a1 | $b1; // უდრის 5-ს

    ~ (ლოგიკური უარყოფა)

    აბრუნებს ყველა ბიტს: თუ ბიტის მნიშვნელობა არის 1, მაშინ ის ხდება ნული და პირიქით. $b = 5; ექო ~$b;

    x<

    x>>y - გადააქვს რიცხვი x მარჯვნივ y ციფრით. მაგალითად, 16>>1 ცვლის 16-ს (რაც ორობითში არის 10000) ერთი ადგილით მარჯვნივ, რის შედეგადაც არის 1000 ან 8 ათწილადში.

სტრიქონების შეერთება

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

$a="გამარჯობა,"; $b=" სამყარო"; ექო $a . $b. "!";

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



 

შეიძლება სასარგებლო იყოს წაკითხვა: