PHP მხარს უჭერს სტანდარტულ ლოგიკურ ოპერატორებს AND და &&, OR და || , ! (არა) და XOR . ლოგიკური ოპერატორები საშუალებას გაძლევთ შეადაროთ ორი ოპერანდის (მნიშვნელობის ან გამოხატვის) შედეგები, რათა დაადგინოთ, დააბრუნებს თუ არა ერთს ან ორივეს true ან false და აირჩიეთ, გააგრძელოთ თუ არა სკრიპტის შესრულება დაბრუნებული მნიშვნელობის მიხედვით. შედარების ოპერატორების მსგავსად, ლოგიკური ოპერატორები აბრუნებენ ერთ ლოგიკურ მნიშვნელობას - true ან false, დამოკიდებულია ოპერატორის ორივე მხარეს არსებულ მნიშვნელობებზე.
ლოგიკური OR (OR და ||)
ლოგიკური OR ოპერატორი აღინიშნება როგორც OR ან || . ის ასრულებს ლოგიკურ OR ოპერაციას ორ ოპერანდზე. თუ ერთი ან ორივე ოპერანდი არის true, ის აბრუნებს true. თუ ორივე ოპერანდი არის false, ის აბრუნებს false-ს. ალბათ გაგიჩნდებათ შეკითხვა: რატომ შექმნეს ერთი ოპერატორის ორი ვერსია? ლოგიკური OR ოპერატორის ორი განსხვავებული ვარიანტის აზრი არის ის, რომ ისინი მუშაობენ განსხვავებული პრიორიტეტებით.
ჯერ ვნახოთ, როგორ მუშაობს ||. . ასე რომ, თუ მისი ერთი ან ორივე ოპერანდი არის true, ის აბრუნებს true. თუ ორივე ოპერანდი დააბრუნებს false მნიშვნელობებს, ის დააბრუნებს false-ს.
OR ოპერატორი მუშაობს ისევე, როგორც ||. ერთი გამონაკლისის გარდა, თუ OR ოპერატორი გამოიყენება დავალებით, ის ჯერ შეაფასებს და დააბრუნებს მარცხენა ოპერანდის მნიშვნელობას, წინააღმდეგ შემთხვევაში ის მუშაობს ზუსტად ისევე, როგორც || , ე.ი. თუ მისი ერთი ან ორივე ოპერანდი არის true, ის აბრუნებს true. თუ ორივე ოპერანდი დააბრუნებს false-ს, ის დაბრუნდება false-ზე.
იმის გასაგებად, თუ როგორ მუშაობენ ისინი, მოვიყვანოთ შემდეგი მაგალითი:
1 // ჯერ ცვლადს ენიჭება მნიშვნელობა false, შემდეგ კი მეორე ოპერანდის შეფასება // პრიორიტეტული მოქმედება: ($var2 = false) ან true $var2 = false ან true; echo $var2; // false არ იბეჭდება // ($var3 = 0) ან 3 $var3 = 0 ან 3; ექო"
$var3"; // => 0 ?>
ნებისმიერი შედარება და ლოგიკური ოპერატორები შეიძლება გაერთიანდეს უფრო რთულ სტრუქტურებში:
არის კიდევ ერთი მნიშვნელოვანი პუნქტი, რომელიც უნდა აღინიშნოს როგორც OR, ასევე || ოპერატორებთან დაკავშირებით. . ლოგიკური OR ოპერატორი იწყებს შეფასებას მისი მარცხენა ოპერანდით, თუ ის დააბრუნებს true, მაშინ მარჯვენა ოპერანდი არ შეფასდება. ეს დაზოგავს შესრულების დროს, მაგრამ ზრუნვა უნდა იქნას მიღებული იმის უზრუნველსაყოფად, რომ კოდი, რომელზედაც შეიძლება იყოს დამოკიდებული პროგრამის სწორი მოქმედება, არ იყოს განთავსებული მარჯვენა ოპერანდში.
ლოგიკური AND (AND და &&)
ლოგიკური AND ოპერატორი აღინიშნება როგორც AND ან &&. ის ასრულებს ლოგიკურ AND ოპერაციას ორ ოპერანდზე. ის აბრუნებს true-ს, თუ და მხოლოდ იმ შემთხვევაში, თუ ორივე ოპერანდი აფასებს true-ს. თუ ერთი ან ორივე ოპერანდი დააბრუნებს false-ს, ოპერატორი დააბრუნებს false-ს. "ლოგიკური და" ოპერატორის ორი განსხვავებული ვერსიის მნიშვნელობა იგივეა, რაც ორი წინა ოპერატორი, კერძოდ, რომ ისინი მუშაობენ სხვადასხვა პრიორიტეტებით.
ჯერ ვნახოთ, როგორ მუშაობს && ოპერატორი. ასე რომ, თუ მისი ორივე ოპერანდი არის true, ის აბრუნებს true. თუ მისი ოპერანდებიდან ერთი ან ორივე მაინც დააბრუნებს false, ის ასევე დაბრუნდება false-ზე.
AND ოპერატორი მუშაობს ისევე, როგორც && ოპერატორი ერთი გამონაკლისით, თუ AND ოპერატორი გამოიყენება დავალებით, ის ჯერ შეაფასებს და დააბრუნებს მარცხენა ოპერანდის მნიშვნელობას, წინააღმდეგ შემთხვევაში მუშაობს ზუსტად ისევე, როგორც && ოპერატორი. თუ მისი ერთ-ერთი ოპერანდი მაინც დააბრუნებს false-ს, ის ასევე დააბრუნებს false-ს და თუ ორივე ოპერანდი დააბრუნებს false-ს, ის დააბრუნებს false-ს.
იმის გასაგებად, ახლა ვნახოთ, როგორ მუშაობს ეს პრაქტიკაში:
$bar3"; // => 9 ?>
ექსკლუზივი OR (XOR)
ექსკლუზიური OR ოპერატორი აღინიშნება როგორც XOR. ის აბრუნებს true-ს, თუ მისი ერთ-ერთი ოპერანდი არის true. თუ ორივე ოპერანდი არის true, ოპერატორი დააბრუნებს false-ს.
იმის გამო, რომ XOR ოპერატორს აქვს იგივე პრიორიტეტი, როგორც AND და OR ოპერატორებს (დანიშნულების ოპერატორზე დაბალი) და იგი გამოიყენება მინიჭების გამოხატულებაში, ის ჯერ აფასებს და აბრუნებს მარცხენა ოპერანდის მნიშვნელობას.
6 $a1 = 19 xor 5 > 6; var_dump ($a1); // => 19 var_dump(true xor true); // false var_dump((2< 3) xor (5 != 5)); // true ?>
ლოგიკური არა (!)
ლოგიკური NOT ოპერატორი, რომელსაც ასევე უწოდებენ უარყოფას, მითითებულია ნიშნით! . ეს არის ერთიანი ოპერატორი, რომელიც მოთავსებულია ერთი ოპერანდის წინ. ლოგიკური NOT ოპერატორი გამოიყენება მისი ოპერანდის ლოგიკური მნიშვნელობის ინვერსიისთვის და ყოველთვის აბრუნებს true ან false.
თუ თქვენ გჭირდებათ გამოხატვის მნიშვნელობის შებრუნება, როგორიცაა a && b, თქვენ უნდა გამოიყენოთ ფრჩხილები: !(a && b) . ასევე ოპერატორის დახმარებით! თქვენ შეგიძლიათ გადაიყვანოთ ნებისმიერი x მნიშვნელობა მის ლოგიკურ ეკვივალენტში ოპერატორის გამოყენებით: !!x ორჯერ.
ბოლო განახლება: 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 . "!";
თუ ცვლადები წარმოადგენენ სტრიქონების გარდა სხვა ტიპებს, როგორიცაა რიცხვები, მაშინ მათი მნიშვნელობები გარდაიქმნება სტრიქონებად და შემდეგ ასევე შესრულებულია სტრიქონების შეერთების ოპერაცია.
გაკვეთილი მოიცავს პირობითი 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 პირობით ოპერატორში
- ზოგჯერ საჭიროა რამდენიმე პირობის ერთდროულად შესრულება. შემდეგ პირობები გაერთიანებულია ლოგიკური ოპერატორი AND — && :
- მცდარი მდგომარეობის დასადგენად გამოიყენეთ ლოგიკური ოპერატორი NOT — ! :
$a=1; if ($a>0 || $a>1) ( ექო "a > 0 ან a > 1"; )
| 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 მხარს უჭერს შემდეგ სტანდარტს ლოგიკური ოპერატორები: "AND" და "&&" (ლოგიკური AND), "OR" და "||" (ლოგიკური ან), "!" (ლოგიკური NOT) და "XOR" (ექსკლუზიური OR). ყველა მათგანი გამოიყენება ლოგიკურ გამონათქვამებში პროგრამის შესრულების ამა თუ იმ კურსის დასადგენად გამონათქვამის მიერ დაბრუნებული შედეგის მიხედვით და ეხება ორობით ოპერატორებს, გარდა ოპერატორის "!" , რომელიც უნივერსალურია. ლოგიკური ოპერატორების გამოყენებისას მათი ოპერანდები გარდაიქმნება ლოგიკური მონაცემების ტიპად () და შედეგი დამოკიდებულია ოპერანდების მოცემულ ლოგიკურ მნიშვნელობებზე და ლოგიკური ოპერატორის ტიპზე (იხ. ცხრილი No1).
ცხრილი No1. ლოგიკური ოპერატორები
განსხვავება "AND" და "&&" ოპერატორებს და "OR" და "||" შორის. არის ის, რომ "AND" , "OR" და "XOR" ოპერატორებს აქვთ უფრო დაბალი უპირატესობა, რაც უფრო დაბალია, ვიდრე მინიჭების ოპერატორები (იხ. PHP ოპერატორის ცხრილი).
მნიშვნელოვანია გვესმოდეს, თუ როგორ ამუშავებს თარჯიმანი ლოგიკურ გამონათქვამებს. თუ გამონათქვამში ოპერატორთან "||" პირველ (მარცხნივ) ოპერანდს ექნება მნიშვნელობა true ან გამონათქვამში "&&" ოპერატორით პირველ ოპერანდს ექნება მნიშვნელობა false, შემდეგ მეორე (მარჯვნივ) ოპერანდი აღარ იქნება გამოთვლილი. ეს გამოწვეულია იმით, რომ ასეთ შემთხვევებში საბოლოო შედეგი არ შეიცვლება (იხ. ცხრილი No1) და ამიტომ არ არის საჭირო დროის დახარჯვა მეორე ოპერანდის კოდის დამუშავებაზე. თუმცა, ფრთხილად უნდა იყოთ, რომ არ მოათავსოთ კოდი სწორ ოპერანდში, რომელზეც შეიძლება დამოკიდებული იყოს პროგრამის სწორი მოქმედება.
ლოგიკური ოპერატორების გამოყენება ნაჩვენებია მაგალითში No2.
მცდარი $a=0||მცდარი; //ახლა $a==true, რადგან 5->true და 8->true $a=5& //ახლა $a==false, რადგან "0"->false $a="0"& //ახლა $a==true $a=!false; //ახლა $a==false, რადგან 5->true $a=!5; /* ფუნქცია foo() არ გამოიძახება შუნტების გამო */ $a=(false&&foo()); $b=(true||foo()); $c=(false და foo()); $d=(true ან foo()); /* განსხვავება "||" "ან"-დან და "&&"-დან "and"-დან */ //მოქმედებს მსგავსად ($a=(false||true)) $a=false||true; //მოქმედებს როგორც (($a=false) ან true) $a=false ან true; //მოქმედებს როგორც ($a=(ცრუ&&true)) $a=false& //მოქმედებს ისე, როგორც (($a=false) and true) $a=false და true; //ახლა $a==5, მოქმედებს როგორც (($a=5) xor 0) $a=5 xor 0; //ახლა $a==5, მოქმედებს როგორც (($a=5) და 0) $a=5 და 0; //ახლა $a==5, მოქმედებს როგორც (($a=5) ან 0) $a=5 ან 0; //ახლა $a==true, მოქმედებს როგორც ($a=(5||0)) $a=5||0; //ახლა $a==false, მოქმედებს როგორც ($a=(5&&0)) $a=5& //ახლა $a==true, მოქმედებს როგორც ($a=(5 xor 6)) $a=(5 xor 6); ?>
მაგალითი No2. ლოგიკური ოპერატორების გამოყენება
>> მე წავიკითხე ამ პასუხებიდან რამდენიმე და გულწრფელად ვერ ვიპოვე ერთი, რომელიც ხსნიდა განსხვავებებს "||" და "OR" ოპერატორებს შორის.
განსხვავება ახსნილია ბმულზე ოპერატორის უპირატესობაზე.
"||" ოპერატორები ფასდება მინიჭებამდე ("="), ხოლო "ან" ოპერატორები ფასდება მინიჭების შემდეგ. თქვენს მეორე მაგალითში თქვენ ეუბნებით PHP-ს, რომ ჯერ მიაკუთვნოს შედეგი "(choice1 != false ? "hah" : "boo")" $val-ს, შემდეგ "ან" ის დანარჩენი განცხადების წინააღმდეგ. სცადეთ ქვემოთ მოყვანილი მაგალითი და მიხვდებით, რას ვგულისხმობ (წინასწარმეტყველების აღსასრულებლად გაითვალისწინეთ დამატებითი ფრჩხილები):
define ("არჩევანი1" , მცდარი );
define ("არჩევანი2" , "ძაღლი" );
define ("default1" , "სხვა");
$val = მასივი();
$val [ "ტესტი 1" ] = (არჩევა1 != მცდარი ? "hah" : "boo" ) || (choice2 != false ? "hah2" : "boo2" ) || (default1 != false ? "hah3" : "boo3" );
$val ["ტესტი 1b" ] = ((არჩევა1 != მცდარი ? "ჰა" : "ბუ") || (არჩევანი2 != მცდარი? "hah2": "boo2") || (ნაგულისხმევი1 != მცდარია? "hah3 " : "boo3" ));
$val [ "Test 2" ] = (choice1 != false ? "hah" : "boo" ) ან (choice2 != false ? "hah2" : "boo2" ) ან (default1 != false ? "hah3" : " boo3");
$val [ "Test 2b" ] = ((choice1 != false ? "hah" : "boo" ) ან (choice2 != false ? "hah2" : "boo2" ) ან (default1 != false ? "hah3" : "boo3" ));
Foreach ($val როგორც $test => $result ) (
print("$test:"); var_dump ($ შედეგი); ბეჭდვა"
\n
\n" ;
}
?>
ტესტი hto dot com-ზე
იმიტომ, რომ OR სტენოგრამა if ბლოკს შეუძლია მეტის წარმოება
იკითხებადი კოდი ნაკლები აკრეფით, მაცდურია ფუნქციების წარმოება, რომლებიც დააბრუნებს FALSE-ს წარუმატებლობის შემთხვევაში ან სხვა მონაცემთა ტიპს წარმატების შემთხვევაში. მოსწონს mysql_connect, რომელიც "აბრუნებს MySQL ბმულის იდენტიფიკატორს წარმატების შემთხვევაში, ან FALSE-ს წარუმატებლობისას."
ახალბედა php php დეველოპერმა თავი უნდა აარიდოს ფუნქციების შექმნას, რომლებმაც შეიძლება წარმოქმნან FALSE წარუმატებლობისას და მთელი რიცხვი წარმატებაზე, თუ არის რაიმე შანსი, რომ მთელი რიცხვი შეიძლება იყოს ნული.
ბლა ბლა ბლა;
$i = give_me_liberty () ან die("FATAL DB ERROR!" );
ბლა ბლა ბლა;
?>
ironmo67 yahoo dot com-ზე
აღმოვაჩინე გარკვეულწილად შემაშფოთებელი განსხვავება PHP-სა და Perl-ს შორის:
if (! some_function ()) return false ;
?>
არ შეიძლება გადაიწეროს როგორც უფრო ლამაზი:
ფუნქცია some_function ()( return false ;)
some_function () ან დაბრუნების false ;
?>
თუმცა შემდეგი იმუშავებს:
ფუნქცია some_function ()( return false ;)
some_function() ან die();
?>
შეგიძლიათ გამოიცნოთ რატომ? უბრალოდ, die() არის ფუნქცია და "return" არის განცხადება (როგორიცაა განსხვავება print()-სა და echo-ს შორის. ეს ნამდვილად ცუდია, რადგან მე მიმაჩნია, რომ if(!)() ვერსია დაღლილი და წაუკითხავია, მაგრამ ჰეი, ეს უკეთესია ვიდრე if (some_c_function == 0) ( რაღაცის გაკეთება ).
ქვემოთ მოყვანილი ბევრი დისკუსიის თავიდან აცილება შეიძლებოდა უბრალოდ იმის გარკვევით, რომ &, | და ^ არის *არ* ლოგიკური ოპერატორები. ამიტომ ისინი არ არიან ჩამოთვლილი ამ გვერდზე. ისინი არიან ოპერატორები, რომლებიც მოქმედებენ რიცხვების ბინარულ გამოსახულებებზე. ისინი არ იღებენ ლოგიკურ მნიშვნელობებს (მაგ., "true" ან "false") არგუმენტებად, პირველ რიგში მათი 1 და 0 რიცხვებში გადაყვანის გარეშე. არც ბრუნდებიან. ლოგიკური მნიშვნელობები, მაგრამ რიცხვები, რა თქმა უნდა, შეგიძლიათ მოგვიანებით მოექცეთ ამ ციფრებს, თითქოს ისინი იყვნენ ლოგიკური მნიშვნელობები (ამ შემთხვევაში, 0 გადაიცემა "false"-ზე და სხვა ყველაფერი გადაიცემა "true"-ზე), მაგრამ ეს არის შედეგი. PHP-ის ტიპის ჩამოსხმის წესები და არაფერი აქვს საერთო ოპერატორების ქცევასთან.
თუ გსურთ ლოგიკური ოპერაციები, გამოიყენეთ ლოგიკური ოპერატორები; თუ გსურთ ბიტიური ოპერაციები, გამოიყენეთ ბიტიური ოპერატორები... ერთი მეორისთვის გამოყენება კარგი გზაა საქმის გასართულებლად.
kws_ hotpop dot com-ზე
"მხოლოდ იმიტომ, რომ შეგიძლია, არ ნიშნავს რომ უნდა."
მე ასევე ვგრძნობ, რომ მოკლე ჩართვის შეფასების გვერდის ავლით და პირობით გამონათქვამებში გვერდით ეფექტებზე დაყრდნობა ცუდი სტილია. კოდის დაწერა, რომელიც თავად ამტკიცებს მკაფიო და პირდაპირი კონსტრუქციების გამოყენებით, ბევრად უკეთესი პრაქტიკაა, ვიდრე ჩახლართული და ძნელად წასაკითხი გამონათქვამის გამოყენება და კომენტარებით ახსნა (ან უარესი, საერთოდ არ დოკუმენტირება!) მართლაც, წყაროს კოდი უნდა იყოს დაწერილი უფრო პროგრამისტის თვალისთვის, ვიდრე კომპიუტერისთვის.
ბიტიური ოპერატორების ლოგიკურ კონტექსტში გამოყენებამ შეიძლება დაარღვიოს მკითხველის მოლოდინი და შეიძლება გამოიწვიოს დაბნეულობა, რადგან ბიტიური ოპერატორები გულისხმობენ ბიტ-ველის ოპერანდებს.
მე ასევე ვგრძნობ, რომ თუ ვივარაუდებთ, რომ მოკლე ჩართვის შეფასება საუკეთესოა ლოგიკური კონსტრუქციებისთვის, არის კომპილატორის „უფლებებში“, რადგან როდესაც ლოგიკური ოპერატორები გამოიყენება მათი დანიშნულებისამებრ, დაშვებები, რომ მოკლე ჩართვა *ARE* ლოგიკურს ხდის და აკეთებს. (კიდევ ერთხელ, სწორად გამოყენების შემთხვევაში) ლოგიკური გამონათქვამების შეფასების ოპტიმიზაცია.
ჩემი განზრახვა არ არის უშუალოდ გავაჩაღო ან შეურაცხყოფა მიაყენო რომელიმე ინდივიდს, არამედ მხოლოდ დავკარგო ცუდი სტილის გამოყენება და წავახალისო ახალი (და თუნდაც გამოცდილი) პროგრამისტები, დაწერონ მკაფიო და ვრცელი კოდი და იფიქრონ პროგრამისტებზე და არა კომპიუტერები, რომლებიც შეიძლება დასრულდეს თქვენი შემოქმედების გაშიფვრის მცდელობაზე.
braintreno-ს პასუხად:
მეორე მაგალითი, რომელიც თქვენ მოიტანეთ, არის ამის გაკეთების სწორი გზა! ეს საერთოდ არ არის ჩახლართული ლოგიკა, ეს არის ის, რაც ხდის თქვენს კოდს წაკითხვას, გაურკვეველ გვერდით ეფექტებს არ დაეყრდნობით!! მისი წაკითხვა ბევრად უფრო ადვილია, ვიდრე პირველი და ბევრად უფრო ადვილია მისი შენარჩუნება.
იმისათვის, რომ CheckThisOrOther() ფუნქციის მხოლოდ მომხმარებლისთვის ინფორმაციის გამოხმაურება მისცეთ, თქვენ უნდა ჩამოერთვათ კოდირების ლიცენზია. თუ ოდესმე მომიწევდა შენი სკრიპტების შენარჩუნება, უნდა შემძულდე.
ეს არ იგულისხმება ისე, როგორც ეს შეიძლება ჟღერდეს! წყაროს კოდი არ იწერება კომპიუტერების შესასრულებლად, არამედ კოდირებისთვის წასაკითხად! შეინახეთ ეს გულში და თქვენი თანამშრომლები მადლობას მოგახსენებთ ამისათვის!
ბრეინტრინო
Shadedecho-ს პოსტი, რომელიც აიძულებს ორივე OR გამოხატვის შეფასებას, არის ზუსტად ის, რაც უნდა გაკეთდეს მოკლე ჩართვის ოპტიმიზაციის ჩასახშობად.
არის მრავალი შემთხვევა, როდესაც არ გინდათ, რომ შემდგენელმა შეაჩეროს რაიმე შეფასება, განსაკუთრებით მაშინ, როდესაც გსურთ გააკეთოთ ან/და სიტუაცია. მოკლე ჩართვის შეფასება აკეთებს OR ოპერაციას, მაგრამ არა AND/OR ოპერაციას!!!
მაგალითად, თუ მსურს შევამოწმო მომხმარებლის მოთხოვნის ფორმა, რათა ვნახო, მომხმარებელმა გამოტოვა თუ არა პასუხი რომელიმე ჩანაწერზე და/ან თუ მომხმარებელმა ერთი და იგივე პასუხი დუბლირებული იყო ერთზე მეტი ჩანაწერისთვის, მაშინ მე უნდა გავუგზავნო ფორმა კლიენტს. აცნობებს რისი გამოსწორება მინდა.
ფუნქცია SomeAnswersAre Missing()
{
...
echo "აჰ! თქვენ გამოტოვეთ რამდენიმე კითხვაზე პასუხის გაცემა.";
დაბრუნება TRUE;
}
ფუნქცია SomeAnswersAreDuplicated()
{
...
echo "აჰ! შეგიძლიათ ორივეს ერთნაირად უპასუხოთ.";
დაბრუნება TRUE;
}
If (SomeAnswersAreMissing() || SomeAnswersAreDuplicated())
SendFormAgain();
თუ ამას გავაკეთებ, მომხმარებელი დაინახავს მხოლოდ გამოტოვებული პასუხის გაფრთხილებას, მაგრამ არა დუბლირებული პასუხის გაფრთხილებას, მაშინაც კი, თუ ორივე სიმართლეა. მომხმარებლისთვის ეს არ არის ინფორმატიული, რადგან მას მოუწევს ფორმის ხელახლა გაგზავნა ორჯერ, სანამ გააცნობიერებს ყველაფერს, რაც მან არასწორად ჩაიდინა და გააფუჭებს მათ გატეხვას. ეს არ არის მოსახერხებელი მომხმარებლისთვის.
If (SomeAnswersAreMissing() | SomeAnswersAreDuplicated())
SendFormAgain();
შემდეგ ორივე გამაფრთხილებელი შეტყობინება იგზავნება ერთდროულად და მომხმარებელს შეუძლია მისი გამოსწორება ერთი ხელახალი გაგზავნით.
მადლობა shadedecho, მე ვეძებდი გზას, რომ გადამეშალა შემდგენელის სულელური მოკლე ჩართვა ოპტიმიზაცია. კომპიუტერს არ შეუძლია უბრალოდ ჩათვალოს, რომ მოკლე ჩართვა საუკეთესოა:(
BTW, რა თქმა უნდა, შეგიძლიათ გააკეთოთ:
$თქვენ_დაუშვით_შეცდომა = ყალბი;
If (SomeAnswersAre Missing())
თუ (SomeAnswersAreDuplicated())
$თქვენ_დაუშვით_შეცდომა = მართალია;
თუ ($you_made_a_mistake)
SendFormAgain();
მაგრამ ეს ჩახლართული ლოგიკაა!!!
ჰოპ
ძვირფასო ახალბედა,
(რადგან მე ვერ ვხედავ ასეთ იდეებს გამოცდილ პროგრამისტების გონებაში...)
გთხოვთ ყურადღება არ მიაქციოთ shadedecho-ს პოსტს 14-მარ-2003 04:02! ის დიდად ეყრდნობა ბუნდოვან გვერდით ეფექტებს, რაც არა მხოლოდ ძალიან ცუდი პროგრამირების პრაქტიკაა, არამედ ვერ აღწევს იმ ოპტიმიზაციას, როგორსაც ფიქრობს.
ამის გაკეთების სწორი გზა
ექო $a;
}
მუშაობა, როგორც shadedecho-ს სურს, არის (თუმცა მაგალითი მთლიანობაში საკმაოდ შეუსაბამოა):
$a .= ბლა();
$a .= blah2();
თუ ($a) (echo $a;)
თუ წაიკითხავთ დისკუსიას, რომელსაც ის აკავშირებს, აღმოაჩენთ, რომ მას ნამდვილად სურდა ყველა განსხვავებული ჩანაწერის მიღება ორი განსხვავებული db ცხრილიდან. იქაც ცდება. ამის გაკეთების სწორი გზაა პირველი ცხრილის დამუშავება და შემდეგ მეორე ცხრილის დამუშავება.
ეს არა მხოლოდ ბევრად უფრო იკითხება, ვიდრე გამოსავალი "|", ის ასევე არ არის ყველაზე ნელი.
შადედეჩო
როგორც ჩანს (ბევრი იმედგაცრუებული, მაგრამ საბოლოო ჯამში სასარგებლო ძიების და დისკუსიის შემდეგ ფორუმებზე, როგორიცაა tek-tips)
|| და && არის "მოკლე ჩართვა", როგორც უკვე აღინიშნა, მაგრამ | და & ოპერატორები (დოკუმენტირებული PHP-ის მიერ, როგორც ბიტიური ოპერატორები) იქცევიან, როგორც მათი არამოკლე ჩართვის კონტრასტები, შესაბამისად.
ფუნქცია blah() (
ექო "გამარჯობა< br>";
დაბრუნება "ბლადან ()< br>";
}
ფუნქცია blah2() (
ექო "სამყარო\"< br>";
დაბრუნება "blah2-დან ()< br>";
}
თუ (($a .= ბლა()) || ($a .= blah2())) (
ექო $a;
}
ეს გამოიწვევს შემდეგ გამომავალს:
გამარჯობა
ბლადან ()
ყურადღება მიაქციეთ, რომ "მსოფლიო" არ მიიღო echo"d და "from blah2()" არ მიიღო concat"d $a ცვლადში, რადგან $a-ს პირველი დავალება წარმატებული იყო, ამიტომ "მოკლე ჩართვა" იწყება და ლოგიკური ტესტი მთავრდება დანარჩენის შეფასების გარეშე.
თუმცა, თუ შეცვლით || მხოლოდ | ამ "if" განცხადებაში თქვენ მიიღებთ გამომავალს:
გამარჯობა
მსოფლიო
ბლადან ()
blah2-დან ()
ევრიკა! ლოგიკური ტესტის ყველა ნაწილი ფასდება მოსალოდნელი მარცხნიდან მარჯვნივ და ყველა ნორმალური უპირატესობის წესების დაცვით, რამდენადაც მე ვხედავ.
ეს სრულიად ლოგიკურია... ბიტვური ოპერატორების გამოყენებით, რაც ხდება, არის ბიტიური დონის ოპერაცია ორი არაბიტიური ოპერაციის (დავალებების) შედეგზე. თუ არაბიტიური ოპერაცია დააბრუნებს null-ს (სხვა სიტყვებით რომ ვთქვათ, მინიჭებული მნიშვნელობა აღმოჩნდება null ან 0), ბიტიური ოპერატორი დააკავშირებს მას (ან უფრო სწორად, "ხედავს" მას) როგორც "0", წინააღმდეგ შემთხვევაში, ის დაინახავს არა-ნულს (ბიტების სტრიქონი მინიმუმ ერთი "1"-ით).
მერე ცოტა | კეთდება ორ მნიშვნელობაზე, და თუ რომელიმე მათგანი არ არის ნულოვანი (აქვს "1" ბიტი), მაშინ შედეგს ექნება "1" ბიტი მასში (არა ნულოვანი), და if განცხადება ინტერპრეტირებს ნებისმიერ არა- ნულოვანი მნიშვნელობა, როგორც ჭეშმარიტი ლოგიკურ ტესტში. ანალოგიურად, თუ ორივე ოპერანდი | იყო null ან 0, მაშინ შედეგი იქნება ნულოვანი მნიშვნელობა, რომელიც "if" ინტერპრეტირდება როგორც მცდარი.
ზემოთ მოცემული if დებულება ცოტათი | (ამ შემთხვევაში) ორ არანულოვან მნიშვნელობაზე (მასში "1" ბიტის დონეზე), ასე რომ | ოპერაცია აბრუნებს არა-ნულოვან მნიშვნელობას, რომელიც შემდეგ ხელახლა არის ინტერპრეტირებული if დებულებით, როგორც TRUE!
ასე რომ, ამ განსაკუთრებულ შემთხვევაში, როდესაც თქვენ ცდილობთ დააკავშიროთ არამოკლე ჩართვის ლოგიკური ტესტები, ეს ოპერატორები მუშაობენ თავიანთ ოპერანდებზე ბიტალურ დონეზე და რადგან ისინი არ არიან შედარების ოპერატორები, არამედ მათემატიკური ოპერატორები, ისინი არ შეიძლება იყოს მოკლე. წრიული, და შედეგად მიღებული ქცევა არის არამოკლედ ჩართვის "ბულის ტესტი".
ვიცი, თქვენ უნდა გგონიათ, რომ გიჟი ვარ, რომ ვცდილობ მსგავსი ჩაშენებული ოპტიმიზაციის შემოვლას, მაგრამ გარწმუნებთ, რომ ამის ძალიან კარგი მიზეზი არსებობს და თუ გაინტერესებთ, შეგიძლიათ გადახედოთ ამ თემას, როგორც მე მაქვს ძალიან გრძელი პოსტი იქ, რომელიც განმარტავს, რის გაკეთებას ვცდილობდი:
ეს არის მე-9 პოსტი ქვემოთ, სადაც ნახავთ ჩემს აღწერას ჩემი მონაცემთა ბაზის შეკითხვის შესახებ, რომლის ოპტიმიზაციაც მინდოდა.
რაც ალბათ არ არის ის რაც გინდა.
ეს შეიძლება დაეხმაროს მათ, ვისაც მოსწონს, რომ მათი კოდი ინგლისურად წაიკითხოს და შეიძლება ფიქრობს, რომ ამ ოპერატორების პრიორიტეტული განსხვავებები შედარებით ეგზოტიკურია: ისინი ასე არ არიან.
რაც შემეხება ამ პრობლემას, რადგან არ არსებობს სიმბოლური ლოგიკური XOR (მაგალითად, არ არის ^^), ამიტომ მომიწია გამომეყენებინა XOR და შემდეგ მივხვდი, რომ მსგავს ადგილებში მე უნდა გამომეყენებინა AND და OR, შემდეგ კი ჩემი კოდი გატეხილია :)
ასე რომ, ახლა მე უნდა
$a = ($b xor $c);
ჯესი ტომპსონი
bend.com
yohgaki hotmail dot com-ზე
PHP4-ში, "and", "or", "&&", "||" -- ყველა არის "მოკლე ჩართვა", როგორც C/C++-ში. PHP3-ში მგონი ასე არ იყო.
„მოკლე ჩართვა“ ნიშნავს, რომ ენა წყვეტს გამოხატვის შეფასებას, როდესაც განისაზღვრება პირობები. (ენების უმეტესობა იყენებს მოკლე ჩართვის შეფასებას ლოგიკური მდგომარეობისთვის)
$a = მართალია;
$b = ყალბი;
თუ ($a || $b) (
}
ეს "თუ" განცხადება მხოლოდ $a-ს აფასებს, რადგან $a არის ჭეშმარიტი და მთელი პირობა უნდა იყოს ჭეშმარიტი. (ანუ თუ $b არის ფუნქცია მნიშვნელობის ნაცვლად, ფუნქცია არ გამოიძახება)
იხილეთ ვებ-სტერ dot com
იმედი მქონდა, რომ ვიპოვე ოპერატორის მსგავსი ||= ფუნქციები perl-ში. ჩემი პირველი აზრი იქნება:
$i = $i ან "ნაგულისხმევი"
მაგრამ ან ასე არ მუშაობს, თუ გსურთ თქვენს ცვლადებს ნაგულისხმევი მნიშვნელობის მინიჭება მხოლოდ იმ შემთხვევაში, თუ ისინი უკვე არ არიან მინიჭებული, შეგიძლიათ გააკეთოთ:
$i ან $i = "ნაგულისხმევი"
პირველი მაგალითი არ მუშაობს, რადგან ან ოპერატორი არ არის გადატვირთული, როგორც ეს არის Perl-ში.
dante at heartme dot com
ასეთი რამის გაკეთება მინდოდა:
$choice1 = "";
$choice2 = "ძაღლი";
$default = "სხვა";
$val = $არჩევანი1 || $არჩევანი2 || $ნაგულისხმევი;
მაგრამ მაშინ $val1 შეიცავს მხოლოდ 1-ს ან 0-ს. ამის ნაცვლად მე გავაკეთე ეს:
$choice1 = "";
$choice2 = "ძაღლი";
$default = "სხვა";
$val = $choice1 ან $choice2 ან $default;
ახლა $val შეიცავს სტრიქონს "dog". ესე იგი
უცნაურია, რომ "ან" განსხვავდება "||"-სგან... და მე გავაკეთებდი
იფიქრეთ, რომ "||" უნდა იყოს საკმარისად ჭკვიანი, რომ გაუმკლავდეს
სტრიქონები... ისე, როგორც ამას აკეთებს PERL. Მგონი არა. იქნებ ეს არის
დიზაინის არჩევანი.
