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;
ექო"
არის კიდევ ერთი მნიშვნელოვანი პუნქტი, რომელიც უნდა აღინიშნოს როგორც OR, ასევე || ოპერატორებთან დაკავშირებით. . ლოგიკური OR ოპერატორი იწყებს შეფასებას მისი მარცხენა ოპერანდით, თუ ის დააბრუნებს true, მაშინ მარჯვენა ოპერანდი არ შეფასდება. ეს დაზოგავს შესრულების დროს, მაგრამ ზრუნვა უნდა იქნას მიღებული იმის უზრუნველსაყოფად, რომ კოდი, რომელზედაც შეიძლება იყოს დამოკიდებული პროგრამის სწორი მოქმედება, არ იყოს განთავსებული მარჯვენა ოპერანდში.
ლოგიკური 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;< 3) xor (5 != 5)); // true ?>
var_dump ($a1); // => 19 var_dump(true xor true); // false var_dump((2
ლოგიკური არა (!)
თუ თქვენ გჭირდებათ გამოხატვის მნიშვნელობის შებრუნება, როგორიცაა a && b, თქვენ უნდა გამოიყენოთ ფრჩხილები: !(a && b) . ასევე ოპერატორის დახმარებით! თქვენ შეგიძლიათ გადაიყვანოთ ნებისმიერი x მნიშვნელობა მის ლოგიკურ ეკვივალენტში ოპერატორის გამოყენებით: !!x ორჯერ.
ამ ოპერატორის მოქმედებაში მთავარია მდგომარეობა. თუ ინგლისურიდან ითარგმნება ნიშნავს თუ. პირობა მიიღება არგუმენტად (რაც არის ფრჩხილებში). პირობა შეიძლება იყოს ლოგიკური გამოხატულება ან ლოგიკური ცვლადი. მარტივად რომ ვთქვათ, გამოთქმის მნიშვნელობა ასეთი იქნება:
თუ (პირობა) (
პირობა დაკმაყოფილებულია, გააკეთე ეს
}
სხვა
{
პირობა არ არის დაკმაყოფილებული, გააკეთე სხვანაირად
}
იმედი მაქვს, პირობითი ოპერაციის ლოგიკა გასაგებია. ახლა მოდით შევხედოთ მაგალითს.
$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 ენიჭება გადაცემული მნიშვნელობა.
}
?>
წაიკითხეთ კომენტარები კოდზე და ყველაფერი გასაგები უნდა იყოს.
გმადლობთ ყურადღებისთვის!
ორი ძირითადი განცხადება, რომელიც უზრუნველყოფს პირობით განშტოების სტრუქტურებს, არის if და switch. ყველაზე ფართოდ გამოყენებული if განაცხადი გამოიყენება პირობითი ნახტომის სტრუქტურებში. მეორეს მხრივ, გარკვეულ სიტუაციებში, განსაკუთრებით იმ შემთხვევაში, თუ თქვენ მოგიწევთ ნავიგაცია მრავალრიცხოვან ფილიალში, რომელიც დამოკიდებულია ერთი გამონათქვამის მნიშვნელობაზე, და რამდენიმე if განცხადების გამოყენება იწვევს უფრო რთულ კოდს, switch განაცხადი უფრო მოსახერხებელი ხდება. .
ამ ოპერატორების შესწავლამდე, თქვენ უნდა გესმოდეთ ლოგიკური გამონათქვამები და ოპერაციები.
ლოგიკური ოპერაციები
ლოგიკური ოპერაციები საშუალებას გაძლევთ დააკავშიროთ ლოგიკური მნიშვნელობები (ასევე უწოდებენ ჭეშმარიტების მნიშვნელობებს) ახალი ლოგიკური მნიშვნელობების შესაქმნელად. როგორც ქვემოთ მოცემულია ცხრილში, PHP მხარს უჭერს სტანდარტულ ლოგიკურ ოპერატორებს (და, ან, არა, და xor), პირველ ორს აქვს ალტერნატიული ვერსიები.
| ოპერაცია | აღწერა |
|---|---|
| და | ოპერაცია, რომლის შედეგი არის ჭეშმარიტი, თუ და მხოლოდ მაშინ, თუ მისი ორივე ოპერანდი მართალია |
| ან | ოპერაცია, რომლის შედეგი არის ჭეშმარიტი, თუ მისი ერთ-ერთი ოპერანდი (ან ორივე ოპერანდი) მართალია |
| ! | ოპერაცია, რომლის შედეგი არის ჭეშმარიტი, თუ მისი ერთი ოპერანდი (მოცემულია ოპერაციის ნიშნის მარჯვნივ) არის false, და მცდარია, თუ მისი ოპერანდი არის true. |
| xor | ოპერაცია, რომლის შედეგი არის ჭეშმარიტი, თუ მისი რომელიმე ოპერანდი (მაგრამ არა ორივე) მართალია |
| && | იგივეა, რაც და ოპერატორი, მაგრამ აკავშირებს მის ოპერანდებს უფრო მჭიდროდ ვიდრე ეს ოპერატორი |
| || | იგივეა, რაც ან ოპერატორი, მაგრამ აკავშირებს მის ოპერანდებს უფრო მჭიდროდ ვიდრე ეს ოპერატორი |
ოპერაციები && და || უნდა იყოს ნაცნობი C-ის პროგრამისტებისთვის! ჩვეულებრივ უწოდებენ არა იმიტომ, რომ ხდება ოპერანდის უარყოფა, რომელზეც ის გამოიყენება.
იმის შესამოწმებლად, არის თუ არა ორივე ოპერანდი TRUE, იყენებთ AND ოპერატორს, რომელიც ასევე შეიძლება დაიწეროს როგორც ორმაგი ამპერსანტი (&&). ორივე AND და& ოპერატორები ლოგიკური ოპერატორებია, ერთადერთი განსხვავება ისაა, რომ && ოპერატორს უფრო მაღალი უპირატესობა აქვს, ვიდრე AND ოპერატორს. იგივე ეხება OR და || ოპერატორებს. AND ოპერატორი აბრუნებს TRUE-ს მხოლოდ იმ შემთხვევაში, თუ ორივე ოპერანდი არის TRUE; წინააღმდეგ შემთხვევაში, FALSE დაბრუნდება.
იმის შესამოწმებლად, არის თუ არა მინიმუმ ერთი ოპერანდი TRUE, იყენებთ OR ოპერატორს, რომელიც ასევე შეიძლება დაიწეროს ორმაგი ვერტიკალური ხაზის სახით (||). ეს ოპერატორი აბრუნებს TRUE-ს, თუ მისი ერთ-ერთი ოპერანდი მაინც არის TRUE.
პროგრამაში OR ოპერატორის გამოყენებისას შეიძლება გამოჩნდეს დახვეწილი ლოგიკური შეცდომები. თუ PHP აღმოაჩენს, რომ პირველი ოპერანდი არის TRUE, ის არ შეაფასებს მეორე ოპერანდის მნიშვნელობას. ეს დაზოგავს შესრულების დროს, მაგრამ ფრთხილად უნდა იყოთ, რომ დარწმუნდეთ, რომ კოდი, რომელზედაც პროგრამა დამოკიდებულია სწორად გაშვებაზე, არ არის განთავსებული მეორე ოპერანდში.
XOR ოპერატორი საშუალებას გაძლევთ შეამოწმოთ არის თუ არა მხოლოდ ერთი ოპერანდი (მაგრამ არა ორივე) TRUE. ეს ოპერატორი აბრუნებს TRUE-ს, თუ მისი ერთ-ერთი ოპერანდი არის TRUE. თუ ორივე ოპერანდი არის TRUE, ოპერატორი დააბრუნებს FALSE-ს.
ლოგიკური მნიშვნელობის ინვერსია შეგიძლიათ NOT ოპერატორის გამოყენებით, რომელიც ხშირად იწერება ძახილის ნიშნის სახით (!). ის აბრუნებს TRUE-ს, თუ ოპერანდი არის FALSE და FALSE, თუ ოპერანდი არის TRUE.
ქვემოთ მოყვანილი ცხრილი აჩვენებს ზოგიერთს ლოგიკური გამონათქვამებიდა მათი შედეგები:
შედარების ოპერაციები
ქვემოთ მოყვანილი ცხრილი გვიჩვენებს შედარების ოპერაციებს, რომლებიც შეიძლება გამოყენებულ იქნას რიცხვებთან ან სტრიქონებთან:
| ოპერაცია | სახელი | აღწერა |
|---|---|---|
| == | უდრის | ოპერაცია, რომლის შედეგი არის ჭეშმარიტი, თუ მისი ოპერანდები ტოლია და მცდარი |
| != | არა თანაბარი | ოპერაცია, რომლის შედეგიც მცდარია, თუ მისი ოპერანდები ტოლია და სხვაგვარად ჭეშმარიტი |
| < | ნაკლები | ოპერაცია, რომლის შედეგი არის true, თუ მარცხენა ოპერანდი ნაკლებია მარჯვენა ოპერანდზე, ხოლო მცდარი სხვა შემთხვევაში |
| > | მეტი | ოპერაცია, რომლის შედეგი არის true, თუ მარცხენა ოპერანდი მეტია მარჯვენა ოპერანდზე, ხოლო მცდარი სხვა შემთხვევაში |
| <= | ნაკლები ან ტოლი | ოპერაცია, რომლის შედეგი არის true, თუ მარცხენა ოპერანდი ნაკლებია ან ტოლია მარჯვენა ოპერანდზე, ხოლო მცდარი სხვა შემთხვევაში. |
| >= | მეტი ან ტოლი | ოპერაცია, რომლის შედეგი არის ჭეშმარიტი, თუ მარცხენა ოპერანდი მეტია ან ტოლია მარჯვენა ოპერანდზე, ხოლო მცდარი სხვა შემთხვევაში. |
| === | იდენტურად | ოპერაცია, რომლის შედეგი არის true, თუ ორივე ოპერანდი თანაბარი და ერთი და იგივე ტიპისაა, ხოლო მცდარი სხვა შემთხვევაში |
ერთი ძალიან გავრცელებული შეცდომა, რომელიც უნდა დაუშვათ არის ის, რომ არ აურიოთ დავალების ოპერატორი (=) შედარების ოპერატორთან (==).
ოპერაციის პრიორიტეტი
რა თქმა უნდა, არ უნდა გამოიყენოთ პროგრამირების სტილი, რომელშიც ოპერაციების თანმიმდევრობა ძირითადად განისაზღვრება უპირატესობის წესების გამოყენებით, რადგან ამ სტილში დაწერილი კოდი რთული გასაგებია მათთვის, ვინც მოგვიანებით შეისწავლის მას, მაგრამ უნდა აღინიშნოს, რომ შედარება ოპერაციებს უფრო მაღალი პრიორიტეტი აქვს ვიდრე ლოგიკურ ოპერაციებს. ეს ნიშნავს, რომ განცხადება შემოწმების გამოხატვით, როგორიცაა ქვემოთ
PHP კოდი $var1 = 14; $var2 = 15; თუ (($var1< $var2) && ($var2 < 20)) echo "$var2 больше $var1 но меньше 20";შეიძლება გადაიწეროს როგორც
PHP კოდი ...თუ ($var1< $var2 && $var2 < 20) ...თუ სხვა განცხადება
ინსტრუქციები თუსაშუალებას აძლევს კოდის ბლოკის შესრულებას, თუ ამ ინსტრუქციის პირობითი გამოხატულება შეფასდება TRUE-მდე; წინააღმდეგ შემთხვევაში კოდის ბლოკი არ შესრულდება. ნებისმიერი გამონათქვამი შეიძლება გამოყენებულ იქნას როგორც პირობა, მათ შორის ტესტები არა-ნულოვანი მნიშვნელობისთვის, თანასწორობისთვის, NULL ცვლადების და ფუნქციების მიერ დაბრუნებული მნიშვნელობების ჩათვლით.
არ აქვს მნიშვნელობა, რომელი ცალკეული პირობითი მდგომარეობით ადგენს პირობით წინადადებას. თუ პირობა მართალია, პროგრამის კოდი, რომელიც ჩასმულია ხვეული ბრეკეტებში (()) შესრულდება. წინააღმდეგ შემთხვევაში, PHP უგულებელყოფს მას და გადადის მეორე პირობის შემოწმებაზე, ამოწმებს თქვენს მიერ ჩაწერილ ყველა პირობას, სანამ არ მოხვდება განცხადებაში. სხვა, რის შემდეგაც ის ავტომატურად შეასრულებს ამ ბლოკს. სხვა განცხადება არჩევითია.
if განცხადების სინტაქსია:
თუ (პირობითი გამოხატულება) (პროგრამის კოდის ბლოკი;)
თუ პირობითი გამოხატვის შეფასების შედეგი არის TRUE, მაშინ შესრულდება პროგრამის კოდის ბლოკი, რომელიც მდებარეობს მის შემდეგ. შემდეგ მაგალითში, თუ $username დაყენებულია "Admin", გამოჩნდება მისასალმებელი შეტყობინება. წინააღმდეგ შემთხვევაში არაფერი მოხდება:
PHP კოდი $username = "ადმინისტრატორი"; if ($username == "Admin") (echo "მოგესალმებით ადმინისტრატორის გვერდზე"; )თუ პროგრამის კოდის ბლოკი შეიცავს მხოლოდ ერთ ინსტრუქციას, მაშინ ხვეული ბრეკეტები არჩევითია, თუმცა, კარგი ჩვევაა მათი ყოველთვის გამოყენება, რადგან ისინი ამარტივებს კოდს წაკითხვასა და რედაქტირებას.
არასავალდებულო else განცხადება არის კოდის ბლოკი, რომელიც შესრულებულია ნაგულისხმევად, როდესაც პირობითი გამოხატულება ფასდება FALSE-მდე. სხვა განცხადება არ შეიძლება გამოყენებულ იქნას if განცხადებისგან განცალკევებით, რადგან else არ აქვს საკუთარი პირობითი გამოხატულება. ანუ, else და if ყოველთვის ერთად უნდა იყოს თქვენს კოდში:
თუ და სხვა განცხადებები $username = "ადმინისტრატორის გარეშე"; if ($username == "Admin") (echo "მოგესალმებით ადმინისტრატორის გვერდზე."; ) else (echo "კეთილი იყოს თქვენი მობრძანება მომხმარებლის გვერდზე.";)არ დაგავიწყდეთ, რომ დახუროთ კოდის ბლოკი if განცხადებაში ხვეული სამაგრით, თუ ბლოკის დასაწყისში დააყენებთ ხვეულ ბრეკეტს. სხვა ბლოკს ასევე უნდა ჰქონდეს გასახსნელი და დახურული ხვეული ბრეკეტები, ისევე როგორც if ბლოკს.
ეს ყველაფერი კარგია, გარდა იმ შემთხვევებისა, როდესაც ზედიზედ რამდენიმე პირობის შემოწმება გჭირდებათ. ინსტრუქციები შესაფერისია ამისათვის elseif. ის საშუალებას გაძლევთ შეამოწმოთ დამატებითი პირობები, სანამ არ მოიძებნება true ან სხვა ბლოკი არ მიიღწევა. ყოველ elseif ინსტრუქციას აქვს კოდის საკუთარი ბლოკი, რომელიც განთავსებულია სხვათა შორის პირობითი გამოხატვის შემდეგ. elseif განცხადება მოდის if განცხადების შემდეგ და სხვა განცხადებამდე, თუ არსებობს.
elseif განცხადების სინტაქსი ცოტა უფრო რთულია, მაგრამ შემდეგი მაგალითი დაგეხმარებათ მის გაგებაში:
მრავალი პირობის შემოწმება $username = "სტუმარი"; if ($username == "ადმინისტრატორი") ( echo "მოგესალმებით ადმინისტრატორის გვერდზე."; ) elseif ($username == "სტუმარი") (echo "ნახვა მიუწვდომელია."; ) else (echo "კეთილი იყოს თქვენი მობრძანება გვერდზე" მომხმარებელი.";)აქ მოწმდება ორი პირობა და $username ცვლადის მნიშვნელობიდან გამომდინარე, შესრულებულია სხვადასხვა მოქმედებები. და კიდევ არის შესაძლებლობა რაღაცის გაკეთება, თუ ცვლადის მნიშვნელობა განსხვავდება პირველი ორისგან.
სამეული ოპერატორი?:
?: ოპერატორი არის სამჯერადი (სამიანი) ოპერატორი, რომელიც იღებს სამ ოპერანდს. ის მუშაობს if განაცხადის მსგავსად, მაგრამ აბრუნებს ორიდან ერთ-ერთი გამონათქვამის მნიშვნელობას. გამოხატულება, რომელიც შეფასდება, განისაზღვრება პირობითი გამოსახულებით. ორწერტილი (:) ემსახურება როგორც გამოხატვის გამყოფს:
(პირობა)? შეფასება_თუ_პირობა_true: შეფასება_თუ_პირობა_მცდარი;
ქვემოთ მოყვანილი მაგალითი ამოწმებს მნიშვნელობას და აბრუნებს სხვადასხვა სტრიქონებს იმისდა მიხედვით, არის თუ არა ის TRUE თუ FALSE:
შეტყობინებების შექმნა ოპერატორის გამოყენებით: $logged_in = TRUE; $user = "იგორ"; $banner = (!$logged_in) ? "დარეგისტრირდი!" : "კეთილი იყოს თქვენი მობრძანება, $user!"; echo $ბანერი;აშკარაა, რომ ზემოაღნიშნული განცხადება ექვივალენტურია შემდეგი განცხადების:
PHP კოდი $logged_in = TRUE; $user = "იგორ"; if (!$logged_in) ( $banner = "რეგისტრაცია!"; ) else ( $banner = "კეთილი იყოს თქვენი მობრძანება, $user!"; ) echo $banner;შეცვლა განცხადება
ინსტრუქციები შეცვლაადარებს გამონათქვამს რამდენიმე მნიშვნელობით. როგორც წესი, ცვლადი გამოიყენება როგორც გამოხატულება, იმის მიხედვით, თუ რა მნიშვნელობა აქვს კოდის კონკრეტული ბლოკის შესრულებას. მაგალითად, წარმოიდგინეთ $action ცვლადი, რომელსაც შეიძლება ჰქონდეს მნიშვნელობები "ADD", "MODIFY" (change) და "DELETE". გადართვის განაცხადი აადვილებს კოდის ბლოკის განსაზღვრას, რომელიც უნდა შესრულდეს თითოეული ამ მნიშვნელობისთვის.
იმისთვის, რომ ნახოთ განსხვავება if და switch განცხადებებს შორის, მოდით შევამოწმოთ ცვლადი მრავალი მნიშვნელობის წინააღმდეგ. ქვემოთ მოყვანილი მაგალითი გვიჩვენებს პროგრამის კოდს, რომელიც ახორციელებს ასეთ შემოწმებას if განაცხადის საფუძველზე და შემდეგ მაგალითში, switch განაცხადის საფუძველზე:
ტესტირება რამდენიმე მნიშვნელობიდან ერთ-ერთის წინააღმდეგ (თუ განცხადება) if ($action == "ADD") ( ექო "შეასრულეთ დამატება."; ექო "ინსტრუქციების რაოდენობა თითოეულ ბლოკში შეუზღუდავია."; ) elseif ($action == "MODIFY") (echo "შეასრულეთ ცვლილება" ."; ) elseif ($action == "წაშლა") (echo "შეასრულეთ წაშლა.";) ტესტირება რამდენიმე მნიშვნელობიდან ერთ-ერთზე (გადამრთველის განცხადება) შეცვლა ($action) ( case "ADD": echo "Perform an add."; echo "ინსტრუქციების რაოდენობა თითოეულ ბლოკში შეუზღუდავია."; break; case "MODIFY": echo "Perform a change."; break; საქმე "DELETE" : echo "შეასრულე წაშლა.";switch განცხადება იღებს მნიშვნელობას switch საკვანძო სიტყვის გვერდით და იწყებს მის შედარებას საკვანძო სიტყვების გვერდით არსებულ ყველა მნიშვნელობასთან. საქმე, პროგრამაში მათი ადგილმდებარეობის მიხედვით. თუ შესატყვისი ვერ მოიძებნა, არცერთი ბლოკი არ შესრულდება. როდესაც შესატყვისი იპოვება, კოდის შესაბამისი ბლოკი სრულდება. ქვემოთ მოყვანილი კოდის ბლოკები ასევე შესრულებულია - გადართვის განაცხადის დასრულებამდე ან სანამ საკვანძო სიტყვა შესვენება. ეს მოსახერხებელია პროცესის ორგანიზებისთვის, რომელიც შედგება რამდენიმე თანმიმდევრული ეტაპისგან. თუ მომხმარებელმა უკვე დაასრულა რამდენიმე ნაბიჯი, მას შეეძლება გააგრძელოს პროცესი იქიდან, სადაც შეჩერდა.
switch განაცხადის გვერდით გამოსახულებამ უნდა დააბრუნოს პრიმიტიული ტიპის მნიშვნელობა, როგორიცაა რიცხვი ან სტრიქონი. მასივი შეიძლება გამოყენებულ იქნას მხოლოდ ცალკეულ ელემენტად, რომელსაც აქვს ელემენტარული ტიპის მნიშვნელობა.
ნაგულისხმევი შერჩევა
თუ პირობითი გამოხატვის მნიშვნელობა არ ემთხვევა case განცხადებებში შემოთავაზებულ არცერთ ვარიანტს, switch განაცხადი ამ შემთხვევაში საშუალებას გაძლევთ გააკეთოთ რაღაც, ისევე, როგორც if, elseif, else კონსტრუქციის else განცხადება. ამისათვის თქვენ უნდა გააკეთოთ ინსტრუქცია, როგორც ბოლო ვარიანტი შერჩევის სიაში ნაგულისხმევი:
შეცდომის შეტყობინების შექმნა ნაგულისხმევი განცხადების გამოყენებით $action = "REMOVE"; შეცვლა ($action) ( case "ADD": echo "Perform an add."; echo "ინსტრუქციების რაოდენობა თითოეულ ბლოკში შეუზღუდავია."; break; case "MODIFY": echo "Perform a change."; break; case "DELETE" : echo "Perform deletion.";ჩვეულებრივის გარდა, switch განაცხადი მხარს უჭერს ალტერნატიულ სინტაქსს - საკვანძო სიტყვის კონსტრუქციას გადამრთველი/გადამრთველი, განსაზღვრავს განცხადების დასაწყისს და დასასრულს ხვეული ბრეკეტების ნაცვლად:
switch განაცხადი მთავრდება საკვანძო სიტყვით endswitch switch ($action): case "ADD": echo "Perform adding.";echo "ინსტრუქციების რაოდენობა თითოეულ ბლოკში შეუზღუდავია.";
შესვენება;
case "MODIFY": echo "შეასრულეთ მოდიფიკაცია."; შესვენება;case "DELETE": echo "Deleteration";
შესვენება;
"; }
თუ $action ცვლადი დაყენებულია "ASSEMBLE ORDER", ამ ფრაგმენტის შედეგი იქნება შემდეგი:
შეაგროვეთ შეკვეთა. შეფუთვა. მიწოდება მომხმარებელს.
თუ ვივარაუდებთ, რომ აშენების ეტაპი უკვე დასრულებულია და $action ცვლადი დაყენებულია "PACKAGE", მიიღება შემდეგი შედეგი:
შეფუთვა. მიწოდება მომხმარებელს.
ზოგჯერ, შესვენების განაცხადის არქონა სასარგებლოა, როგორც ზემოთ მოყვანილ მაგალითში, სადაც შეკვეთის ეტაპები იქმნება, მაგრამ უმეტეს შემთხვევაში ეს განცხადება უნდა იქნას გამოყენებული.
მონაცემთა ტიპები ციკლები 1 2 3 4 5 6 7 8 9 10>> მე წავიკითხე რამდენიმე ასეთი პასუხი და გულწრფელად ვერ ვიპოვე ისეთი, რომელიც ახსნიდა განსხვავებებს "||" და "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-ზე პირველი დავალება წარმატებული იყო, ამიტომ "მოკლე ჩართვა" იწყება და ლოგიკური ტესტი მთავრდება დანარჩენის შეფასების გარეშე.
თუმცა, თუ შეცვლით || მხოლოდ | ამ "თუ" განცხადებაში თქვენ მიიღებთ გამომავალს:
გამარჯობა
მსოფლიო
ბლადან ()
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. გამოიცანით არა. იქნებ ეს არის
დიზაინის არჩევანი.
ბოლო განახლება: 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>>y - გადააქვს რიცხვი x მარჯვნივ y ციფრით. მაგალითად, 16>>1 ცვლის რიცხვს 16 (რომელიც ბინარში არის 10000) ერთი ადგილით მარჯვნივ, ასე რომ, შედეგი არის 1000 ან რიცხვი 8 ათწილადში.
სტრიქონების შეერთება
წერტილის ოპერატორი გამოიყენება სტრიქონების შესაერთებლად. მაგალითად, დავაკავშიროთ რამდენიმე ხაზი:
$a="გამარჯობა,"; $b=" სამყარო"; ექო $a . $b. "!";
თუ ცვლადები წარმოადგენენ სტრიქონების გარდა სხვა ტიპებს, როგორიცაა რიცხვები, მაშინ მათი მნიშვნელობები გარდაიქმნება სტრიქონებად და შემდეგ ხდება სტრიქონების შეერთების ოპერაციაც.