การดำเนินงานใน PHP คำสั่งเงื่อนไข if ในตัวแปรบูลีน PHP ในข้อมูลทั่วไปของ PHP

บทเรียนจะครอบคลุมถึงตัวดำเนินการ PHP แบบมีเงื่อนไข ได้แก่ คำสั่ง if และคำสั่ง switch

คำสั่งแบบมีเงื่อนไขของ PHP จะแสดงด้วยโครงสร้างหลักสามประการ:

• ผู้ดำเนินการตามเงื่อนไข ถ้า,
• ตัวดำเนินการสวิตช์ สวิตช์
• และ ตัวดำเนินการที่ประกอบไปด้วย.

เรามาดูแต่ละรายการกันดีกว่า

PHP ถ้าคำสั่ง

รูปที่ 3.1. ตัวดำเนินการแบบมีเงื่อนไขถ้าเป็นเวอร์ชั่นสั้น

ข้าว. 3.2. IF ELSE ไวยากรณ์คำสั่งแบบมีเงื่อนไข

ข้าว. 3.3. ไวยากรณ์แบบเต็มของคำสั่ง IF elseif แบบมีเงื่อนไข

สรุป:

ไวยากรณ์แบบเต็ม:

if (เงื่อนไข) ( // ถ้าเงื่อนไขเป็นจริง ตัวดำเนินการ1; ตัวดำเนินการ2; ) elseif(เงื่อนไข) ( ตัวดำเนินการ1; ... ) else ( // ถ้าเงื่อนไขเป็นเท็จ ตัวดำเนินการ1; ตัวดำเนินการ2; )

• ไวยากรณ์ที่สั้นลงสามารถ ไม่มีส่วนของคำสั่ง elseif และไม่มีเงื่อนไข elseif เพิ่มเติม
• แทนที่จะใช้คำฟังก์ชัน elseif คุณสามารถเขียน else if (แยกกันได้)
• อาจมีหลายสิ่งอื่นในหนึ่งเดียวหากสร้าง นิพจน์ elseif แรกที่เท่ากับ TRUE จะถูกดำเนินการ
• หากมีเงื่อนไขอื่นอีก อย่างอื่นสร้างต้องอยู่หลังสุดในรูปแบบไวยากรณ์

คำสั่งแบบมีเงื่อนไขสามารถใช้เครื่องหมายโคลอน: แทนได้ วงเล็บปีกกา- ในกรณีนี้ คำสั่งจะลงท้ายด้วยคำว่า endif เสริม

ข้าว. 3.4. คำสั่งแบบมีเงื่อนไข If และ Endif ใน php.ini

ตัวอย่าง:

if($x > $y): echo $x." มากกว่า ".$y; elseif($x == $y): // เมื่อใช้ /// คุณไม่สามารถเขียนแยกกันได้ ถ้า echo $x." เท่ากับ ".$y; อื่น: echo $x." ไม่ใช่ > และไม่ใช่ = ".$y; สิ้นสุด;

สำคัญ:เมื่อใช้เครื่องหมายทวิภาคแทนวงเล็บปีกกาในโครงสร้าง มิฉะนั้น ถ้าไม่สามารถเขียนเป็นสองคำได้!

การดำเนินการทางลอจิคัลในสภาวะ

เงื่อนไข if ในวงเล็บอาจมีการดำเนินการต่อไปนี้:

ตัวอย่าง:ตรวจสอบค่าของตัวแปรตัวเลข: หากน้อยกว่าหรือเท่ากับ 10 ให้แสดงข้อความ “ตัวเลขที่น้อยกว่าหรือเท่ากับ 10”มิฉะนั้นจะแสดงข้อความ "ตัวเลขที่มากกว่า 10"

$หมายเลข=15;<=10) { echo "число меньше или равно 10"; } else { echo "число больше 10"; }

ถ้า ($หมายเลข

ตัวอย่าง:บล็อกโค้ด PHP สามารถใช้งานไม่ได้ ลองดูตัวอย่าง: แสดงรหัส html บนหน้าจอ"เท่ากับ 4"

1 วิธีแก้ปัญหา:

A เท่ากับ 4

A เท่ากับ 4งาน PHP 3_1:

แสดงการแปลสีจากภาษาอังกฤษเป็นภาษารัสเซีย โดยตรวจสอบค่าของตัวแปร (ซึ่งกำหนดสีไว้: $a="blue")งาน PHP 3_2:

ค้นหาตัวเลขสูงสุดสามจำนวน

การดำเนินการเปรียบเทียบและกฎการโกหก โครงสร้าง if ต้องมีอยู่ในวงเล็บหรือตัวแปรซึ่งพิจารณาจากมุมมองของพีชคณิตของตรรกศาสตร์ส่งคืนค่าจริงหรือเท็จ

เหล่านั้น. ตัวแปรตัวเดียวสามารถทำหน้าที่เป็นเงื่อนไขได้ ลองดูตัวอย่าง:

ถ้า ($a) ( echo $a; )

$a=1;

ถ้า ($a) ( echo $a; )

• ในตัวอย่าง นักแปลภาษา PHP จะถือว่าตัวแปรในวงเล็บเป็นกฎโกหก: Rule of LIE หรือสิ่งที่ถือว่าเป็นเท็จ:
• ตรรกะ 0 )
• เท็จ 0.0 )
• ศูนย์ทั้งหมด (ศูนย์จริง ( «0»
• สตริงว่าง
• และสตริง
• อาร์เรย์ที่ไม่มีองค์ประกอบ วัตถุที่ไม่มีตัวแปร

ชนิดพิเศษ

โมฆะดังนั้น ในตัวอย่างที่พิจารณา ตัวแปร $a เท่ากับ 1 ดังนั้นเงื่อนไขจะเป็นจริง และผู้ดำเนินการจะสะท้อน $a; จะแสดงค่าของตัวแปร งาน PHP 3_3:จะได้รับตัวแปร a พร้อมค่าสตริง ถ้า a เท่ากับชื่อ ให้พิมพ์ "สวัสดีชื่อ!"

ถ้า a เท่ากับค่าว่าง ให้ส่งออก

1. “สวัสดีคนแปลกหน้า!” โครงสร้างเชิงตรรกะ AND OR และ NOT ในตัวดำเนินการแบบมีเงื่อนไข — && :

บางครั้งจำเป็นต้องจัดให้มีการปฏิบัติตามเงื่อนไขหลายประการพร้อมกัน จากนั้นนำเงื่อนไขมารวมกัน

2. ตัวดำเนินการเชิงตรรกะ AND $a=1; ถ้า ($a>0 || $a>1) ( echo "a > 0 หรือ a > 1"; ) — ! :

1 2 3 4

หากต้องการระบุว่าเงื่อนไขเป็นเท็จ ให้ใช้< 0 ) ) { echo "a не < 0" ; }

ตัวดำเนินการเชิงตรรกะไม่<0)) { echo "a не < 0"; }

$a = 1 ;

ถ้า (! ($a $a=1; ถ้า (!($a.

ตัวดำเนินการสวิตช์ PHP

1 2 3 4 5 6 7 8 9 10

ตัวดำเนินการสวิตช์หรือ "สวิตช์" จะแทนที่หลายตัวติดต่อกันหากสร้าง ในการดำเนินการดังกล่าว ระบบจะเปรียบเทียบตัวแปรหนึ่งตัวกับหลายค่า จึงเป็นวิธีที่สะดวกที่สุด

สำหรับการจัดหลายสาขา

• ไวยากรณ์:
• สวิตช์ ($ตัวแปร) ( กรณี "value1" : ตัวดำเนินการ1 ; break ; กรณี "value2" : ตัวดำเนินการ2 ; break ; กรณี "value3" : ตัวดำเนินการ3 ; break ; [ ค่าเริ่มต้น : ตัวดำเนินการ4 ; ตัวแบ่ง ; ] )

สวิตช์($ตัวแปร)( กรณี "value1": โอเปอเรเตอร์1; break; กรณี "value2": โอเปอเรเตอร์2; break; กรณี "value3": โอเปอเรเตอร์3; แบ่ง; )

ตัวอย่าง:ผู้ดำเนินการสามารถตรวจสอบทั้งค่าสตริง (จากนั้นระบุในเครื่องหมายคำพูด) และค่าตัวเลข (โดยไม่ต้องใส่เครื่องหมายคำพูด)

- หยุดพัก ; -

$names=array("อีวาน", "ปีเตอร์", "เซมยอน"); switch($names)( case "Peter": echo "Hello, Petya!"; break; case "Ivan": echo "Hello, Vanya!"; break; case "Semyon": echo "Hello, Vanya!"; แตก ; ค่าเริ่มต้น: echo "สวัสดี $names!";

• งาน PHP 3_4:
• สร้างตัวแปร $day และกำหนดค่าตัวเลขตามต้องการ ใช้โครงสร้างสวิตช์ พิมพ์วลี"เป็นวันทำงาน"
• หากค่าของตัวแปร $day อยู่ในช่วงตัวเลขตั้งแต่ 1 ถึง 5 (รวม) พิมพ์วลี"เป็นวันหยุด"
• หากค่าของตัวแปร $day อยู่ในช่วงตัวเลขตั้งแต่ 1 ถึง 5 (รวม) ถ้าค่าของตัวแปร $day เท่ากับตัวเลข 6 หรือ 7"วันที่ไม่รู้จัก"

หากค่าของตัวแปร $day ไม่อยู่ในช่วงตัวเลขตั้งแต่ 1 ถึง 7 (รวม)

- หยุดพัก ; กรณีที่ 6 : ... ค่าเริ่มต้น : ... )

Switch(...)( กรณีที่ 1: กรณีที่ 2: ... echo "นี่คือวันทำงาน"; หยุด; กรณีที่ 6: ... ค่าเริ่มต้น: ... )

ตัวดำเนินการแบบไตรภาคของ PHPตัวดำเนินการแบบไตรภาค

, เช่น. ด้วยตัวถูกดำเนินการสามตัว มีไวยากรณ์ที่ค่อนข้างง่าย โดยอยู่ทางด้านซ้ายของ ? มีการเขียนเงื่อนไข และทางด้านขวามีตัวดำเนินการสองตัวคั่นด้วยเครื่องหมาย: ทางด้านซ้ายของเครื่องหมายตัวดำเนินการจะถูกดำเนินการหากเงื่อนไขเป็นจริง และทางด้านขวาของเครื่องหมาย: ตัวดำเนินการจะถูกดำเนินการหากเงื่อนไขเป็น เท็จ.

เงื่อนไข? ตัวดำเนินการ1 : ตัวดำเนินการ2 ; PHP รองรับตัวดำเนินการเชิงตรรกะมาตรฐาน AND และ && , OR และ || - (ไม่ใช่) และ XORตัวดำเนินการเชิงตรรกะ

ช่วยให้คุณสามารถเปรียบเทียบผลลัพธ์ของตัวถูกดำเนินการสองตัว (ค่าหรือนิพจน์) เพื่อพิจารณาว่าตัวใดตัวหนึ่งหรือทั้งสองตัวส่งคืนค่าจริงหรือเท็จ และเลือกว่าจะรันสคริปต์ต่อไปตามค่าที่ส่งคืนหรือไม่ เช่นเดียวกับตัวดำเนินการเปรียบเทียบ ตัวดำเนินการเชิงตรรกะจะส่งคืนค่าบูลีนค่าเดียว - จริงหรือเท็จ ขึ้นอยู่กับค่าที่ด้านใดด้านหนึ่งของตัวดำเนินการ

ตัวดำเนินการเชิงตรรกะ OR จะแสดงเป็น OR หรือ || - มันดำเนินการตรรกะหรือการดำเนินการกับตัวถูกดำเนินการสองตัว ถ้าตัวถูกดำเนินการหนึ่งหรือทั้งสองเป็นจริง ก็จะส่งกลับค่าจริง หากตัวถูกดำเนินการทั้งสองเป็นเท็จ ก็จะส่งกลับค่าเท็จ คุณอาจมีคำถาม: ทำไมพวกเขาถึงสร้างโอเปอเรเตอร์ตัวเดียวสองเวอร์ชัน? จุดสำคัญของตัวแปรสองตัวที่แตกต่างกันของตัวดำเนินการเชิงตรรกะ OR ก็คือพวกมันทำงานโดยมีลำดับความสำคัญต่างกัน

ก่อนอื่น มาดูกันว่าตัวดำเนินการ ||. - ดังนั้น หากตัวถูกดำเนินการตัวใดตัวหนึ่งหรือทั้งสองตัวถูกดำเนินการเป็นจริง ก็จะคืนค่าเป็น true หากตัวถูกดำเนินการทั้งสองส่งคืนค่าเท็จ ก็จะส่งคืน false

ตัวดำเนินการ OR ทำงานเหมือนกับตัวดำเนินการ || มีข้อยกเว้นประการหนึ่ง หากใช้ตัวดำเนินการ OR กับการกำหนด ขั้นแรกจะประเมินและส่งกลับค่าของตัวถูกดำเนินการทางซ้าย มิฉะนั้นจะทำงานเหมือนกับตัวดำเนินการ || ทุกประการ , เช่น. ถ้าตัวถูกดำเนินการอย่างใดอย่างหนึ่งหรือทั้งสองเป็นจริง ก็จะส่งกลับค่าจริง หากตัวถูกดำเนินการทั้งสองส่งคืนค่า false ก็จะส่งคืนค่า false

เพื่อให้ชัดเจนยิ่งขึ้นถึงวิธีการทำงาน เรามายกตัวอย่างต่อไปนี้:

1 // อันดับแรก ตัวแปรถูกกำหนดให้เป็นค่า false จากนั้นตัวถูกดำเนินการตัวที่สองจะถูกประเมิน // การดำเนินการตามลำดับความสำคัญ: ($var2 = false) หรือ true $var2 = false หรือ true;
เสียงสะท้อน $var2; // false ไม่ได้พิมพ์ // ($var3 = 0) หรือ 3 $var3 = 0 หรือ 3;

เสียงสะท้อน "

$var3"; // => 0 ?> ตัวดำเนินการเปรียบเทียบและตัวดำเนินการเชิงตรรกะสามารถนำมารวมกันเป็นโครงสร้างที่ซับซ้อนมากขึ้นได้:อีกสิ่งหนึ่งที่ควรค่าแก่การกล่าวถึง จุดสำคัญเกี่ยวกับทั้ง OR และ || - ตัวดำเนินการเชิงตรรกะหรือเริ่มการประเมินด้วยตัวถูกดำเนินการทางซ้าย หากคืนค่าเป็นจริง ตัวถูกดำเนินการที่ถูกต้องจะไม่ถูกประเมิน ซึ่งจะช่วยประหยัดเวลาในการดำเนินการ แต่คุณต้องระมัดระวังเพื่อให้แน่ใจว่าโค้ดนั้นอาจขึ้นอยู่กับ

งานที่ถูกต้อง

โปรแกรมไม่ได้อยู่ในตัวถูกดำเนินการที่ถูกต้อง

ตรรกะและ (และและ &&)

ตัวดำเนินการ AND ทำงานเหมือนกับตัวดำเนินการ && โดยมีข้อยกเว้นหนึ่งข้อ หากใช้ตัวดำเนินการ AND กับการกำหนด ตัวดำเนินการจะประเมินและส่งกลับค่าของตัวถูกดำเนินการด้านซ้ายก่อน มิฉะนั้นจะทำงานเหมือนกับตัวดำเนินการ && ทุกประการ หากตัวถูกดำเนินการอย่างน้อยหนึ่งตัวส่งกลับค่าเท็จ ก็จะส่งกลับค่าเท็จด้วย และหากตัวถูกดำเนินการทั้งสองส่งกลับค่าเท็จ ก็จะส่งกลับค่าเท็จ

เพื่อทำความเข้าใจ มาดูกันว่าวิธีนี้ทำงานอย่างไรในทางปฏิบัติ:

$bar3"; // => 9 ?>

พิเศษหรือ (XOR)

ตัวดำเนินการพิเศษ OR จะแสดงเป็น XOR มันจะคืนค่าเป็นจริงหากตัวถูกดำเนินการเพียงตัวเดียวเท่านั้นที่เป็นจริง หากตัวถูกดำเนินการทั้งสองเป็นจริง ตัวดำเนินการจะส่งคืนค่าเท็จ

เนื่องจากตัวดำเนินการ XOR มีลำดับความสำคัญเหมือนกับตัวดำเนินการ AND และ OR (ต่ำกว่าตัวดำเนินการกำหนด) และใช้ในนิพจน์การกำหนด อันดับแรกจึงประเมินและส่งกลับค่าของตัวถูกดำเนินการด้านซ้าย

6 $a1 = 19 x หรือ 5 > 6;< 3) xor (5 != 5)); // true ?>

var_dump($a1); // => 19 var_dump(true xor true); // false var_dump((2

ตรรกะไม่ (!)

ตัวดำเนินการ NOT แบบลอจิคัล หรือที่เรียกว่าการปฏิเสธ จะถูกระบุด้วยเครื่องหมาย! - มันเป็นตัวดำเนินการเอกที่อยู่หน้าตัวถูกดำเนินการตัวเดียว ตัวดำเนินการ NOT แบบลอจิคัลใช้เพื่อกลับค่าตรรกะของตัวถูกดำเนินการ และส่งคืนค่า true หรือ false เสมอ

หากคุณต้องการกลับค่าของนิพจน์ เช่น a && b คุณจะต้องใช้วงเล็บ: !(a && b) ด้วยความช่วยเหลือจากโอเปอเรเตอร์! คุณสามารถแปลงค่า x ใดๆ ให้เทียบเท่ากับบูลีนได้โดยใช้ตัวดำเนินการ: !!x สองครั้ง

>> ฉันได้อ่านคำตอบเหล่านี้มาบ้างแล้ว แต่จริงๆ แล้วไม่พบคำตอบที่อธิบายความแตกต่างระหว่างตัวดำเนินการ "||" และ "OR"

ความแตกต่างมีการอธิบายไว้ในลิงก์ไปยังลำดับความสำคัญของตัวดำเนินการ

"||" ตัวดำเนินการจะได้รับการประเมินก่อนการกำหนด ("=") ในขณะที่ตัวดำเนินการ "หรือ" จะได้รับการประเมินหลังการกำหนด ในตัวอย่างที่สองของคุณ คุณกำลังบอกให้ PHP กำหนดผลลัพธ์ของ "(choice1 != false ? "hah" : "boo")" ให้กับ $val ก่อน จากนั้นจึง "หรือ" เทียบกับคำสั่งที่เหลือ ลองตัวอย่างด้านล่างแล้วคุณจะเห็นว่าฉันหมายถึงอะไร (สังเกตวงเล็บเพิ่มเติมเพื่อบังคับใช้ลำดับความสำคัญ):
กำหนด ("choice1" , false );
กำหนด ("choice2" , "สุนัข" );
กำหนด ("default1" , "อื่นๆ" );

$วาล = อาร์เรย์();
$val [ "ทดสอบ 1b" ] = ((choice1 != false ? "hah" : "boo" ) || (choice2 != false ? "hah2" : "boo2" ) || (default1 != false ? "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 ) (
พิมพ์("$ทดสอบ: "); var_dump ($ผลลัพธ์); พิมพ์ "
\n
\n" ;
}
?>

ทดสอบได้ที่ hto dot com

เพราะชวเลข OR สำหรับบล็อก if สามารถสร้างได้มากกว่า
โค้ดที่อ่านได้แต่พิมพ์น้อย มักดึงดูดให้สร้างฟังก์ชันที่จะคืนค่า FALSE เมื่อเกิดความล้มเหลวหรือข้อมูลประเภทอื่นเมื่อสำเร็จ เช่นเดียวกับ mysql_connect ซึ่ง "ส่งคืนตัวระบุลิงก์ MySQL เมื่อสำเร็จหรือ FALSE เมื่อล้มเหลว"

นักพัฒนา php php มือใหม่ควรหลีกเลี่ยงการสร้างฟังก์ชันที่อาจสร้าง FALSE เมื่อล้มเหลวและเป็นจำนวนเต็มเมื่อสำเร็จ หากมีโอกาสที่จำนวนเต็มอาจเป็นศูนย์

บลา บลา บลา;
$i = Give_me_liberty () หรือ die("ข้อผิดพลาดฐานข้อมูลร้ายแรง!" );
บลา บลา บลา ;
?>

ironmo67 และ yahoo ดอทคอม

ค้นพบความแตกต่างที่ค่อนข้างน่ารำคาญระหว่าง PHP และ Perl:

ถ้า (! some_function ()) กลับเท็จ ;
?>

ไม่สามารถเขียนใหม่ว่าสวยกว่าได้:

ฟังก์ชั่น some_function ()( return false ; )
some_function () หรือคืนค่าเท็จ ;
?>

อย่างไรก็ตามสิ่งต่อไปนี้จะใช้ได้:

ฟังก์ชั่น some_function ()( return false ; )
some_function() หรือ die();
?>

คุณเดาได้ไหมว่าทำไม? เพียงแค่ die() เป็นฟังก์ชันและ "return" เป็นคำสั่ง (เช่นความแตกต่างระหว่าง print() และ echo เป็นต้น) นี่แย่มากจริงๆ เพราะฉันพบว่าเวอร์ชัน if(!)() เหนื่อยและอ่านไม่ออก แต่เดี๋ยวก่อน ดีกว่า if (some_c_function == 0) ( do something )

การอภิปรายด้านล่างจำนวนมากสามารถหลีกเลี่ยงได้เพียงแค่ทำให้ชัดเจนว่า &, | และ ^ คือ *ไม่ใช่* ตัวดำเนินการเชิงตรรกะ นั่นเป็นเหตุผลว่าทำไมพวกเขาถึงไม่อยู่ในหน้านี้ พวกมันเป็นตัวดำเนินการที่ทำหน้าที่แทนค่าไบนารี่ของตัวเลข พวกมันไม่ได้ใช้ค่าตรรกะ (เช่น "จริง" หรือ "เท็จ") เป็นอาร์กิวเมนต์โดยไม่ต้องแปลงเป็นตัวเลข 1 และ 0 ตามลำดับก่อน และพวกมันก็ไม่ส่งคืน ค่าตรรกะ แต่เป็นตัวเลข แน่นอนว่าคุณสามารถปฏิบัติต่อตัวเลขเหล่านั้นได้ในภายหลังราวกับว่าเป็นค่าตรรกะ (ซึ่งในกรณีนี้ 0 จะถูกแปลงเป็น "เท็จ" และสิ่งอื่นใดจะถูกแปลงเป็น "จริง") แต่นั่นเป็นผลมาจาก กฎการคัดเลือกประเภทของ PHP และไม่เกี่ยวข้องกับพฤติกรรมของตัวดำเนินการ

หากคุณต้องการการดำเนินการเชิงตรรกะ ให้ใช้ตัวดำเนินการเชิงตรรกะ หากคุณต้องการการดำเนินการระดับบิต ให้ใช้ตัวดำเนินการระดับบิต ... การใช้ตัวใดตัวหนึ่งกับอีกตัวหนึ่งดูเหมือนจะเป็นวิธีที่ดีในการทำให้สิ่งต่าง ๆ ยากขึ้น

kws_ ที่ hotpop ดอทคอม

“เพียงเพราะคุณทำได้ ไม่ได้หมายความว่าคุณควรทำ”

ฉันยังรู้สึกว่าการหลีกเลี่ยงการประเมินการลัดวงจรและการพึ่งพาผลข้างเคียงในการแสดงออกตามเงื่อนไขถือเป็นการใช้สไตล์ที่ไม่ดี การเขียนโค้ดที่จัดทำเอกสารโดยใช้โครงสร้างที่ชัดเจนและตรงไปตรงมาถือเป็นแนวทางปฏิบัติที่ดีกว่าการใช้สำนวนที่ซับซ้อนและอ่านยากและอธิบายด้วยความคิดเห็น (หรือแย่กว่านั้นคือไม่ได้จัดทำเอกสารเลย!) แท้จริงแล้วซอร์สโค้ดควร ถูกเขียนขึ้นเพื่อสายตาของโปรแกรมเมอร์มากกว่าคอมพิวเตอร์

การใช้ตัวดำเนินการระดับบิตในบริบทเชิงตรรกะอาจละเมิดความคาดหวังของผู้อ่าน และอาจสร้างความสับสนได้ เนื่องจากตัวดำเนินการระดับบิตหมายถึงตัวถูกดำเนินการบิตฟิลด์

ฉันยังรู้สึกว่าสมมติว่าการประเมินการลัดวงจรนั้นดีที่สุดสำหรับโครงสร้างเชิงตรรกะ IS ภายใน "สิทธิ์" ของคอมไพลเลอร์ เนื่องจากเมื่อมีการใช้ตัวดำเนินการเชิงตรรกะตามวัตถุประสงค์ที่ตั้งใจไว้ สมมติฐานที่ว่าการลัดวงจรทำให้ *ARE* ตรรกะ และทำ (อีกครั้งเมื่อใช้อย่างถูกต้อง) ปรับการประเมินนิพจน์เชิงตรรกะให้เหมาะสม

ฉันไม่ได้ตั้งใจที่จะก่อกวนหรือดูถูกบุคคลใด ๆ โดยตรง แต่เพียงเพื่อกีดกันการใช้รูปแบบที่ไม่ดีและเพื่อสนับสนุนให้โปรแกรมเมอร์ใหม่ (และแม้แต่บางคนที่มีประสบการณ์) เขียนโค้ดที่ชัดเจนและละเอียด และคิดถึงโปรแกรมเมอร์ แทนที่จะเป็น คอมพิวเตอร์ที่อาจลงเอยด้วยการพยายามถอดรหัสการสร้างสรรค์ของคุณ

เพื่อตอบ Braintreno:

ตัวอย่างที่สองที่คุณนำมาคือวิธีที่ถูกต้องในการทำ! มันไม่ใช่ตรรกะที่ซับซ้อนเลย แต่เป็นสิ่งที่ทำให้โค้ดของคุณสามารถอ่านได้โดยไม่อาศัยผลข้างเคียงที่ไม่ชัดเจน!! อ่านง่ายกว่าอันแรกมากและดูแลรักษาง่ายกว่ามาก

หากต้องการให้ฟังก์ชัน CheckThisOrOther() สะท้อนข้อมูลให้กับผู้ใช้เพียงอย่างเดียว คุณควรถูกเพิกถอนสิทธิ์การใช้งานการเข้ารหัสของคุณ ถ้าฉันต้องรักษาสคริปต์ของคุณ ฉันคงเกลียดคุณแน่

นี่ไม่ได้หมายความว่าเป็นการพ่นไฟอย่างที่คิด! ซอร์สโค้ดไม่ได้เขียนเพื่อให้คอมพิวเตอร์ดำเนินการ แต่เพื่อให้ผู้เขียนโค้ดอ่าน! จำไว้เสมอแล้วเพื่อนร่วมงานของคุณจะขอบคุณสำหรับสิ่งนี้!

เบรนทริโน

การโพสต์เพื่อบังคับการประเมินนิพจน์ OR ของ Shadedecho จริงๆ แล้วเป็นสิ่งที่ควรทำเพื่อระงับการปรับให้เหมาะสมของการลัดวงจร

มีหลายครั้งที่คุณไม่ต้องการให้คอมไพลเลอร์ลัดวงจรการประเมินใดๆ โดยเฉพาะอย่างยิ่งเมื่อคุณต้องการทำ และ/หรือ สถานการณ์ การประเมินการลัดวงจรจะดำเนินการ OR แต่ไม่ใช่การดำเนินการ AND/OR !!!

ตัวอย่างเช่น หากฉันต้องการตรวจสอบแบบฟอร์มสอบถามของผู้ใช้เพื่อดูว่าผู้ใช้พลาดการตอบคำถามใด ๆ และ/หรือหากผู้ใช้ทำซ้ำคำตอบเดียวกันสำหรับมากกว่าหนึ่งรายการ ฉันต้องส่งแบบฟอร์มกลับไปยังลูกค้า แจ้งสิ่งที่ฉันต้องการแก้ไข

ฟังก์ชั่น SomeAnswersAreMissing()
{
...
echo "อ๊ะ! คุณพลาดการตอบคำถามบางข้อ";
กลับจริง;
}

ฟังก์ชั่น SomeAnswersAreDuplicated()
{
...
echo "อ๊ะ! คุณสามารถตอบทั้งสองแบบได้";
กลับจริง;
}

ถ้า (คำตอบบางอย่างหายไป () || คำตอบบางอย่างซ้ำกัน ())
SendFormAgain();

หากฉันทำเช่นนั้น ผู้ใช้จะเห็นเฉพาะคำเตือนคำตอบที่หายไป แต่จะไม่เห็นคำเตือนคำตอบที่ซ้ำกัน แม้ว่าทั้งสองจะเป็นจริงก็ตาม สิ่งนี้ไม่ได้ให้ข้อมูลแก่ผู้ใช้ เพราะเขา/เธอจะต้องส่งแบบฟอร์มอีกครั้งสองครั้งก่อนที่เขาจะรู้ตัวว่าเขา/เธอทำผิดทั้งหมด และขัดขวางการแฮ็กจากพวกเขา นั่นไม่เป็นมิตรต่อผู้ใช้

ถ้า (คำตอบบางอันหายไป() | บางคำตอบซ้ำซ้อน())
SendFormAgain();

จากนั้นข้อความเตือนทั้งสองจะถูกส่งไปพร้อมกัน และผู้ใช้สามารถแก้ไขได้ในการส่งซ้ำครั้งเดียว

ขอบคุณ shadedecho ฉันกำลังมองหาวิธีที่จะแทนที่การปรับแต่งการลัดวงจรที่โง่เขลาของคอมไพเลอร์ คอมพิวเตอร์ไม่สามารถสรุปได้ว่าการลัดวงจรนั้นดีที่สุด:(

BTW แน่นอนคุณสามารถทำได้:

$you_made_a_mistake = เท็จ;

ถ้า (บางคำตอบหายไป ())

ถ้า (คำตอบบางอย่างซ้ำกัน())
$you_made_a_mistake = จริง;

ถ้า ($you_made_a_mistake)
SendFormAgain();

แต่นั่นเป็นตรรกะที่ซับซ้อน!!!

กระโดด

เรียน คุณมือใหม่

(เพราะฉันไม่เห็นความคิดแบบนั้นคืบคลานเข้ามาในจิตใจของโปรแกรมเมอร์ที่มีประสบการณ์"...)

โปรดอย่าไปสนใจโพสต์ของ shadedecho ตั้งแต่วันที่ 14 มี.ค. 2546 เวลา 04:02 น.! เขาพึ่งพาผลข้างเคียงที่คลุมเครืออย่างมาก ซึ่งไม่เพียงแต่เป็นการฝึกเขียนโปรแกรมที่แย่มากเท่านั้น แต่ยังไม่สามารถเพิ่มประสิทธิภาพที่เขาคิดได้อีกด้วย

วิธีที่เหมาะสมในการทำเช่นนี้

เสียงสะท้อน $a;
}

ทำงานอย่างที่เชเดโชต้องการคือ (แม้ว่าตัวอย่างโดยรวมจะค่อนข้างไม่เหมาะสม):

$a .= บลา();
$a .= blah2();

ถ้า ($a) ( echo $a; )

หากคุณอ่านการสนทนาที่เขาลิงก์ไป คุณจะพบว่าเขาต้องการรับรายการที่แตกต่างกันทั้งหมดจากตาราง db สองตารางที่แตกต่างกัน แม้ว่าเขาจะเข้าใจผิดก็ตาม วิธีที่เหมาะสมในการทำเช่นนี้คือการประมวลผลตารางแรกแล้วจึงประมวลผลตารางที่สอง
นี่ไม่เพียงแต่สามารถอ่านได้ง่ายกว่าวิธีแก้ปัญหาด้วย "|" เท่านั้น แต่ยังช้ากว่าอีกด้วย

เชเดโช

ปรากฏ (หลังจากการค้นหาและการสนทนาในฟอรัมเช่น tek-tips ที่น่าหงุดหงิด แต่ท้ายที่สุดก็มีประโยชน์มาก) ว่า
- และ && นั้น "ลัดวงจร" ตามที่ระบุไว้ก่อนหน้านี้ แต่ | และตัวดำเนินการ & (จัดทำเอกสารโดย PHP ว่าเป็นตัวดำเนินการระดับบิต) ทำหน้าที่เป็นตัวดำเนินการที่ไม่ลัดวงจรตามลำดับ

ฟังก์ชั่น blah() (
สะท้อน "สวัสดี< br>";
กลับ "จาก blah()< br>";
}

ฟังก์ชัน blah2() (
สะท้อน "โลก\< br>";
กลับ "จาก blah2()< br>";
}

ถ้า (($a .= blah()) || ($a .= blah2())) (
เสียงสะท้อน $a;
}

ซึ่งจะส่งผลให้ผลลัพธ์ต่อไปนี้:

สวัสดี
จาก บลา()

สังเกตว่า "โลก" ไม่ได้รับ echo"d และ "from blah2()" ไม่ได้เชื่อมกัน"d เข้ากับตัวแปร $a เนื่องจากการกำหนดครั้งแรกให้กับ $a สำเร็จ ดังนั้น "การลัดวงจร" เริ่มต้นและการทดสอบบูลีนสิ้นสุดลงโดยไม่ต้องประเมินส่วนที่เหลือ

อย่างไรก็ตาม หากคุณแทนที่ || ด้วยเพียง | ในคำสั่ง "if" คุณจะได้ผลลัพธ์:

สวัสดี
โลก
จาก บลา()
จาก blah2()

ยูเรก้า! การทดสอบบูลีนทุกส่วนของได้รับการประเมินในลักษณะที่คาดไว้จากซ้ายไปขวา และปฏิบัติตามกฎลำดับความสำคัญปกติทั้งหมด เท่าที่ฉันเห็น

สิ่งนี้สมเหตุสมผลอย่างยิ่ง... การใช้ตัวดำเนินการระดับบิต สิ่งที่เกิดขึ้นคือการดำเนินการระดับบิตจากผลลัพธ์ของการดำเนินการที่ไม่ใช่ระดับบิตสองตัว (การกำหนด) หากการดำเนินการที่ไม่ใช่ระดับบิตคืนค่าเป็นโมฆะ (หรืออีกนัยหนึ่ง ค่าที่กำหนดกลายเป็นโมฆะหรือ 0) ตัวดำเนินการระดับบิตจะผูกกับค่านั้น (หรือเหมาะสมกว่านั้น จะ "เห็น" มัน) เป็น "0" มิฉะนั้นจะเห็นค่าที่ไม่ใช่ศูนย์ (สตริงของบิตที่มี "1" อย่างน้อยหนึ่งตัวอยู่ในนั้น)

จากนั้นบิต | เสร็จสิ้นกับค่าทั้งสอง และถ้าค่าใดค่าหนึ่งไม่เป็นศูนย์ (มีบิต "1" อยู่ในนั้น) ผลลัพธ์ก็จะมีบิต "1" เหล่านั้นอยู่ในนั้น (ไม่ใช่ศูนย์) และคำสั่ง if จะตีความค่าที่ไม่ใช่- ค่าศูนย์เป็นจริงในการทดสอบบูลีน ในทำนองเดียวกันหากตัวถูกดำเนินการทั้งสองไปที่ | เป็นโมฆะหรือ 0 ผลลัพธ์จะเป็นค่าศูนย์ ซึ่ง "ถ้า" จะตีความว่าเป็นเท็จ

คำสั่ง if ด้านบนกำลังทำ bitwise | บน (ในกรณีนี้) สองค่าที่ไม่ใช่ศูนย์ (โดยมี "1" อยู่ที่ระดับบิต) ดังนั้น | การดำเนินการส่งคืนค่าที่ไม่ใช่ศูนย์ซึ่งจะถูกตีความใหม่โดยคำสั่ง if เป็น TRUE!

ดังนั้น ในกรณีพิเศษนี้ที่คุณพยายามรวมการทดสอบบูลีนแบบไม่ลัดวงจรเข้าด้วยกัน ตัวดำเนินการเหล่านี้ทำงานกับตัวถูกดำเนินการที่ระดับบิต และเนื่องจากตัวดำเนินการเหล่านี้ไม่ใช่ตัวดำเนินการเปรียบเทียบ แต่เป็นตัวดำเนินการทางคณิตศาสตร์ จึงไม่สามารถสั้นได้ และลักษณะการทำงานที่ได้คือ "การทดสอบบูลีน" ที่ไม่ลัดวงจร

ฉันรู้ว่าคุณต้องคิดว่าฉันบ้าไปแล้วที่พยายามเลี่ยงการเพิ่มประสิทธิภาพในตัวเช่นนี้ แต่ฉันขอรับรองว่ามีเหตุผลที่ดีมากสำหรับเรื่องนี้ และหากคุณสนใจ คุณสามารถตรวจสอบกระทู้นี้ได้ตามที่ฉันมี โพสต์ยาวมากในนั้นซึ่งอธิบายสิ่งที่ฉันพยายามทำ:

โพสต์นี้เป็นครั้งที่ 9 แล้ว ซึ่งคุณจะพบคำอธิบายเกี่ยวกับการสืบค้นฐานข้อมูลของฉัน"ซึ่งฉันต้องการเพิ่มประสิทธิภาพ

ซึ่งคงไม่ใช่สิ่งที่คุณต้องการ

นี่อาจเป็นประโยชน์สำหรับผู้ที่ชื่นชอบโค้ดในการอ่านแบบภาษาอังกฤษ และอาจคิดว่าความแตกต่างของลำดับความสำคัญของโอเปอเรเตอร์เหล่านี้ค่อนข้างแปลกใหม่: ไม่ใช่เลย

สำหรับฉัน ฉันประสบปัญหานี้เนื่องจากไม่มี XOR เชิงตรรกะเชิงสัญลักษณ์ (เช่น ไม่มี ^^) ดังนั้นฉันจึงต้องใช้ XOR และคิดว่าในสถานที่ที่คล้ายกันที่ฉันควรใช้ และและหรือแล้วรหัสของฉันก็พัง :)

ตอนนี้ฉันต้องไปแล้ว
$a = ($b x หรือ $c);

เจสซี่ ทอมป์สัน
เบนด์.คอม

yohgaki ที่ hotmail ดอทคอม

ใน PHP4 "และ", "หรือ", "&&", "||" -- ทั้งหมดเป็น "ไฟฟ้าลัดวงจร" เหมือนใน C/C++ ใน PHP3 ฉันคิดว่ามันไม่ใช่

"ลัดวงจร" หมายถึงภาษาหยุดการประเมินการแสดงออกเมื่อมีการกำหนดเงื่อนไข (ภาษาส่วนใหญ่ใช้การประเมินการลัดวงจรสำหรับสภาพตรรกะ)

$a = จริง;
$ข=เท็จ;
ถ้า ($a || $b) (
}

คำสั่ง "if" นี้จะประเมินเฉพาะ $a เนื่องจาก $a เป็นจริงและเงื่อนไขทั้งหมดจะต้องเป็นจริง (เช่น ถ้า $b เป็นฟังก์ชันแทนที่จะเป็นค่า ฟังก์ชันจะไม่ถูกเรียกใช้)

muerte ที่เว็บสเตอร์ดอทคอม

ฉันหวังว่าจะพบโอเปอเรเตอร์ที่คล้ายกับ ||= ฟังก์ชันในภาษา Perl ความคิดแรกของฉันคือ:

$i = $i หรือ "ค่าเริ่มต้น"

แต่หรือไม่ทำงานเช่นนั้น หากคุณต้องการกำหนดค่าเริ่มต้นให้กับตัวแปรของคุณเฉพาะในกรณีที่ยังไม่ได้กำหนด คุณก็สามารถทำได้:

$i หรือ $i = "ค่าเริ่มต้น"

ตัวอย่างแรกใช้ไม่ได้เนื่องจากตัวดำเนินการ หรือ ไม่สามารถโหลดได้มากเกินไปเหมือนในภาษา Perl

ดันเต้ที่ฮาร์ทมีดอทคอม

ฉันอยากจะทำอะไรแบบนี้:

$choice1 = "";
$choice2 = "สุนัข";
$default = "อื่นๆ";
$val = $choice1 || $choice2 || $ค่าเริ่มต้น;

แต่แล้ว $val1 จะมีเพียง 1 หรือ 0 ฉันกลับทำสิ่งนี้:

$choice1 = "";
$choice2 = "สุนัข";
$default = "อื่นๆ";
$val = $choice1 หรือ $choice2 หรือ $default;

ตอนนี้ $val มีสตริง "dog" นั่นก็คือ
แปลกที่ "หรือ" แตกต่างจาก "||"...และฉันก็ทำ
คิดว่า "||" ควรฉลาดพอที่จะรับมือ
strings...ในแบบที่ PERL ทำ คิดว่าไม่ บางทีมันอาจจะเป็น
ทางเลือกการออกแบบ

อัปเดตครั้งล่าสุด: 11/11/2558

ใน PHP เราสามารถใช้โอเปอเรเตอร์ได้หลากหลาย เช่น เลขคณิต ตรรกะ ฯลฯ มาดูการทำงานแต่ละประเภทกัน

การดำเนินการทางคณิตศาสตร์

+ (การดำเนินการเพิ่มเติม)

ตัวอย่างเช่น $a + 5

- (การดำเนินการลบ)

ตัวอย่างเช่น $a - 5

* (การคูณ)

ตัวอย่างเช่น $a * 5

/ (แผนก)

ตัวอย่างเช่น $a/5

% (ได้รับส่วนที่เหลือของการหาร)

ตัวอย่างเช่น: $a=12; เสียงสะท้อน $a % 5; // เท่ากับ 2

++ (เพิ่ม/เพิ่มค่าทีละหนึ่ง)

ตัวอย่างเช่น ++$a

สิ่งสำคัญคือต้องเข้าใจความแตกต่างระหว่างนิพจน์ ++$a และ $a++ ตัวอย่างเช่น:

$a=12; $ข=++$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"; $ข .="5"; // เท่ากับ 125

รับส่วนที่เหลือของการหารแล้วกำหนดผลลัพธ์: $a=12; $a %= 5; เสียงสะท้อน $a; // เท่ากับ 2

การดำเนินการเปรียบเทียบ

การดำเนินการเปรียบเทียบมักจะใช้ในการสร้างตามเงื่อนไขเมื่อจำเป็นต้องเปรียบเทียบสองค่าและดำเนินการบางอย่างขึ้นอยู่กับผลลัพธ์ของการเปรียบเทียบ การดำเนินการเปรียบเทียบต่อไปนี้สามารถใช้ได้

ตัวดำเนินการความเท่าเทียมกันจะเปรียบเทียบค่าสองค่า และหากเท่ากัน จะคืนค่าเป็นจริง มิฉะนั้นจะคืนค่าเท็จ: $a == 5

ตัวดำเนินการข้อมูลประจำตัวยังเปรียบเทียบค่าสองค่าด้วย และหากเท่ากัน จะคืนค่าเป็นจริง มิฉะนั้นจะส่งคืนค่าเท็จ: $a === 5

เปรียบเทียบสองค่า และหากค่าไม่เท่ากัน จะส่งคืนค่าจริง มิฉะนั้นจะส่งคืนค่าเท็จ: $a != 5

เปรียบเทียบสองค่า และหากค่าไม่เท่ากัน จะส่งคืนค่าจริง มิฉะนั้นจะส่งคืนค่าเท็จ: $a !== 5

เปรียบเทียบสองค่า และหากค่าแรกมากกว่าค่าที่สอง จะส่งกลับค่าจริง มิฉะนั้นจะส่งกลับค่าเท็จ: $a > 5

เปรียบเทียบสองค่า และหากค่าแรกน้อยกว่าค่าที่สอง จะส่งกลับค่าจริง มิฉะนั้นจะส่งกลับค่าเท็จ: $a< 5

เปรียบเทียบสองค่า และหากค่าแรกมากกว่าหรือเท่ากับค่าที่สอง จะส่งคืนค่าจริง มิฉะนั้นจะส่งคืนค่าเท็จ: $a >= 5

เปรียบเทียบสองค่า และหากค่าแรกน้อยกว่าหรือเท่ากับค่าที่สอง จะส่งกลับค่าจริง หรือส่งกลับค่าเท็จ: $a<= 5

ตัวดำเนินการความเท่าเทียมกันและเอกลักษณ์

ตัวดำเนินการทั้งสองจะเปรียบเทียบสองนิพจน์และส่งกลับค่าจริงหากนิพจน์เท่ากัน แต่มีความแตกต่างระหว่างพวกเขา หากการดำเนินการความเท่าเทียมใช้ค่าสองค่าประเภทต่าง ๆ ค่าเหล่านั้นจะลดลงเหลือค่าเดียว - ค่าที่ล่ามพบว่าเหมาะสมที่สุด ตัวอย่างเช่น:

แน่นอนว่าตัวแปรจะเก็บค่าประเภทต่างๆ ที่แตกต่างกัน แต่เมื่อเปรียบเทียบแล้วก็จะลดเหลือประเภทเดียวกัน-ตัวเลข และตัวแปร $a จะลดลงเหลือเลข 22 และสุดท้ายตัวแปรทั้งสองจะเท่ากัน

หรือตัวอย่างเช่น ตัวแปรต่อไปนี้ก็จะเท่ากันเช่นกัน:

$a = เท็จ; $ข = 0;

เพื่อหลีกเลี่ยงสถานการณ์ดังกล่าว การดำเนินการสมมูลจะถูกนำมาใช้ ซึ่งไม่เพียงแต่คำนึงถึงค่าเท่านั้น แต่ยังรวมถึงประเภทของตัวแปรด้วย:

$a = "22a"; $ข = 22; if($a===$b) echo "เท่ากับ"; มิฉะนั้นก้อง "ไม่เท่ากัน";

ตอนนี้ตัวแปรจะไม่เท่ากัน

ตัวดำเนินการอสมการ != และ !== ทำงานในลักษณะเดียวกัน

การดำเนินการเชิงตรรกะ

โดยทั่วไปการดำเนินการทางตรรกะจะใช้ในการรวมผลลัพธ์ของการดำเนินการเปรียบเทียบสองรายการ ตัวอย่างเช่น เราจำเป็นต้องดำเนินการบางอย่างหากมีเงื่อนไขหลายประการเป็นจริง การดำเนินการทางลอจิคัลต่อไปนี้พร้อมใช้งาน:

คืนค่าเป็นจริงหากการดำเนินการเปรียบเทียบทั้งสองคืนค่าเป็นจริง มิฉะนั้นจะส่งคืนค่าเท็จ: $a == 5 && $b = 6

คล้ายกับการดำเนินการ &&: $a == 5 และ $b > 6

คืนค่าเป็นจริงหากการดำเนินการเปรียบเทียบอย่างน้อยหนึ่งรายการคืนค่าเป็นจริง มิฉะนั้นจะคืนค่าเท็จ: $a == 5 || $ข = 6

คล้ายกับการดำเนินการ || : $ก< 5 or $b > 6

คืนค่าเป็นจริงหากการดำเนินการเปรียบเทียบส่งคืนค่าเท็จ: !($a >= 5)

คืนค่าเป็นจริงหากมีเพียงค่าเดียวเท่านั้นที่เป็นจริง ถ้าทั้งสองเป็นจริงหรือไม่เป็นจริง จะส่งกลับเท็จ ตัวอย่างเช่น: $a=12; $ข=6; if($axor $b) echo "จริง"; มิฉะนั้นสะท้อน "เท็จ";

ที่นี่ผลลัพธ์ของการดำเนินการเชิงตรรกะจะเป็นเท็จเนื่องจากตัวแปรทั้งสองมีค่าเฉพาะ มาเปลี่ยนรหัสกัน:

$a=12; $ข=โมฆะ; if($axor $b) echo "จริง"; มิฉะนั้นสะท้อน "เท็จ";

ที่นี่ผลลัพธ์จะเป็นจริงอยู่แล้ว เนื่องจากไม่ได้ตั้งค่าของตัวแปรตัวใดตัวหนึ่ง หากตัวแปรมีค่าเป็น NULL ดังนั้นในการดำเนินการทางลอจิคัลค่าของตัวแปรจะถือเป็นเท็จ

การดำเนินการบิต

การดำเนินการบิตจะดำเนินการกับแต่ละบิตของตัวเลข ตัวเลขจะพิจารณาในรูปแบบไบนารี่ เช่น 2 ในรูปแบบไบนารี่คือ 010 ตัวเลข 7 คือ 111

& (การคูณเชิงตรรกะ)

การคูณจะดำเนินการในระดับบิต และหากตัวถูกดำเนินการทั้งสองมีค่าบิตเท่ากับ 1 การดำเนินการจะคืนค่า 1 มิฉะนั้นจะส่งกลับตัวเลข 0 ตัวอย่างเช่น: $a1 = 4; //100 $b1 = 5; //101 เสียงสะท้อน $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 ก็จะกลายเป็นศูนย์ และในทางกลับกัน

$ข = 5; เสียงสะท้อน ~$b;<

x

x>>y - เลื่อนตัวเลข x ไปทางขวาด้วยหลัก y ตัวอย่างเช่น 16>>1 เลื่อนตัวเลข 16 (ซึ่งก็คือ 10,000 ในเลขฐานสอง) ไปทางขวาหนึ่งตำแหน่ง ดังนั้นผลลัพธ์จึงเป็น 1,000 หรือเลข 8 ในรูปแบบทศนิยม

การต่อสายอักขระ

ตัวดำเนินการ dot ใช้ในการเชื่อมสตริงเข้าด้วยกัน ตัวอย่างเช่น เชื่อมต่อหลายบรรทัด:

$a="สวัสดี"; $b=" โลก"; เสียงสะท้อน $a $ข. -

- เงื่อนไขได้รับการยอมรับว่าเป็นอาร์กิวเมนต์ (สิ่งที่อยู่ในวงเล็บ) เงื่อนไขอาจเป็นนิพจน์เชิงตรรกะหรือตัวแปรเชิงตรรกะก็ได้ ถ้าจะให้พูดง่ายๆ ความหมายของสำนวนก็คือ:
ถ้า (เงื่อนไข)(
}
ตรงตามเงื่อนไข ให้ทำดังนี้
{
อื่น
}
ไม่ตรงตามเงื่อนไข ให้ทำอย่างอื่น

ฉันหวังว่าตรรกะของการดำเนินการตามเงื่อนไขจะชัดเจน ตอนนี้เรามาดูตัวอย่างกัน
$a = 5;

$ข = 25;
//สนใจตอนนี้! เงื่อนไข: ถ้า $b มากกว่า $a< , как и в математике, обозначают больше и меньше
// สัญญาณ > และ
{
ถ้า($b > $a)
// หากตรงตามเงื่อนไข ให้ดำเนินการนี้
}
echo "$b มากกว่า $a";
{
อื่น
// หากไม่ได้ดำเนินการก็จะเป็นเช่นนี้
}
?>
echo "$a มากกว่าหรือเท่ากับ $b"; สาธิต
ดาวน์โหลดแหล่งที่มา เป็นผลให้สคริปต์จะส่งออก 25 มากกว่า 5 - ตัวอย่างค่อนข้างง่าย ฉันหวังว่าทุกอย่างชัดเจน ตอนนี้ฉันเสนอให้พิจารณาสถานการณ์ที่ซับซ้อนกว่านี้ซึ่งต้องปฏิบัติตามเงื่อนไขหลายประการ แต่ละเงื่อนไขใหม่จะมีอยู่หลังเงื่อนไขหลักถ้า() - ตัวช่วยซึ่งเขียนเป็นอย่างอื่นถ้า() - สุดท้ายก็จะเป็นเหมือนเดิม.

อื่นการทดสอบดำเนินการที่โรงเรียน สคริปต์จำเป็นต้องคำนวณคะแนน โดยรู้เงื่อนไขในการได้รับแต่ละเกรดและคะแนนของนักเรียนเอง มาดูวิธีการเขียนกัน และอย่าลืมอ่านความเห็นด้วย

$ทดสอบ = 82; // สมมติว่านักเรียนเขียนข้อสอบได้ 82 คะแนน

// เขียนเงื่อนไขแรกสำหรับห้า
ถ้า($ทดสอบ > 90)
{
// หากตรงตามเงื่อนไข ให้ดำเนินการนี้
echo "เรตติ้ง 5";
}
// เครื่องหมาย && หมายถึง "และสหภาพ" ซึ่งตรงตามเงื่อนไขหากทั้งสองเป็นจริง
// คือคะแนนน้อยกว่า 91 และเกิน 80 แล้ว 4 มิฉะนั้นเงื่อนไขจะอ่านต่อ
อย่างอื่นถ้า ($test< 91 && $test > 80)
{
echo "เรตติ้ง 4";
}
อย่างอื่นถ้า ($test< 81 && $test > 70)
{
echo "เรตติ้ง 3";
}
ตรงตามเงื่อนไข ให้ทำดังนี้
{
echo "เราควรเขียนแบบทดสอบอีกครั้ง...";
}
?>
echo "$a มากกว่าหรือเท่ากับ $b"; สาธิต
นักเรียนของเราที่มีเวลาทั้งพักผ่อนและเขียนข้อสอบปกติได้ คะแนน 4- ฉันหวังว่าหลักการทำงานจะชัดเจน

นอกจากนี้ยังสามารถบันทึกการทำงานของการดำเนินการตามเงื่อนไขโดยย่อได้ เมื่อคุณต้องการดำเนินการเฉพาะเมื่อตรงตามเงื่อนไขเท่านั้น

$ อายุ = 19; //แปรผันตามอายุ

ถ้า ($อายุ > 17)(
echo "แค่นั้นแหละ! ฉันจะทำอะไรก็ได้ที่ฉันต้องการ! ฉันอายุ $age แล้ว!";
}
เป็นตัวอย่างที่ดีของสัญกรณ์สั้นๆ ของการดำเนินการตามเงื่อนไข - สุดท้ายก็จะเป็นเหมือนเดิมไม่จำเป็นต้องเขียน

ตัวดำเนินการเปรียบเทียบใน 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
$ก< $b Меньше чем True, если $a меньше, чем $b
$a >= $b มากกว่าหรือเท่ากับ True ถ้า $a มากกว่าหรือเท่ากับ $b
$ก<= $b Меньше или равно True, если $a меньше или равно $b
ทีนี้มาดูตัวดำเนินการกัน พร้อมตัวอย่าง:

// ตรงกันข้ามกับนิสัย = หมายถึงการกำหนดค่าให้กับตัวแปร และ == เท่ากับ
ถ้า ($a == 5)(
echo "$a คือ 5"; // จะพิมพ์ "5 เท่ากับ 5"
) อื่น (
echo "$a ไม่เท่ากับ 5";
}

ถ้า ($a != 6)(
echo "$a ไม่เท่ากับ 6"; // จะพิมพ์ "5 ไม่เท่ากับ 6" จำเป็นในกรณีที่ถูกปฏิเสธ
) อื่น (
echo "$a เท่ากับ 6";
}

//มีมากขึ้นเรื่อยๆ ผมว่าทุกอย่างชัดเจนครับ ดังนั้นตัวอย่างจึงซับซ้อนกว่า
ถ้า ($a<= 6){
echo "$a น้อยกว่าหรือเท่ากับ 6"; // จะพิมพ์ "5 น้อยกว่าหรือเท่ากับ 6"
) อื่น (
echo "$a มากกว่า 6";
}

ตัวดำเนินการเชิงตรรกะ PHP

ตัวอย่างผลลัพธ์ชื่อ
$a และ $b ตรรกะ "และ" TRUE ถ้าทั้ง $a และ $b เป็น TRUE
$a หรือ $b ตรรกะ "หรือ" TRUE ถ้า $a หรือ $b เป็นจริง
$a xor $b Exclusive "หรือ" TRUE ถ้า $a หรือ $b เป็นจริง แต่ไม่ใช่ทั้งสองอย่าง
- $a การปฏิเสธ TRUE ถ้า $a ไม่เป็น TRUE
$a && $b ตรรกะ "และ" TRUE ถ้าทั้ง $a และ $b เป็นจริง
$a || $b Boolean "หรือ" TRUE ถ้า $a หรือ $b เป็นจริง
เราได้สังเกตเห็นแล้วว่าสำหรับการดำเนินงาน และและ หรือมีโอเปอเรเตอร์เพิ่มเติมไหม? ซึ่งทำเพื่อจัดลำดับความสำคัญของการดำเนินการเปรียบเทียบที่ซับซ้อน ในตาราง ตัวดำเนินการเชิงตรรกะจะแสดงรายการตามลำดับความสำคัญ: จากน้อยไปหามาก เช่น || มีลำดับความสำคัญสูงกว่าหรือ

เดินหน้าต่อไป ถึงตัวอย่าง

$a = 5;
$ข = 6;
$ซี = 7;

// เงื่อนไข: ถ้า 5 ไม่เท่ากับ 6 (TRUE) และ 6 ไม่เท่ากับ 7 (TRUE)
ถ้า ($a< 6 && $b != $c){
echo "จริงด้วย!"; // จะพิมพ์ว่า "จริงด้วย!" เพราะ เงื่อนไขทั้งสองเป็นจริง
) อื่น (
echo "เงื่อนไขข้อหนึ่งไม่เป็นความจริง";
}

// เงื่อนไข: ถ้า 6 ไม่เท่ากับ 6 (FALSE) หรือ 6 ไม่เท่ากับ 7 (TRUE)
ถ้า ($b != 6 || $b != $c)(
echo "แค่นั้นแหละ!"; // จะแสดงคำว่า "นั่นแหละ!" เพราะ อย่างน้อยหนึ่งเงื่อนไขจะเป็น TRUE
) อื่น (
echo "เงื่อนไขทั้งสองเป็นเท็จ";
}

ตัวดำเนินการแบบไตรภาค

ส่วนสำคัญของรหัส:(เงื่อนไข) ? ค่าของถ้าเป็นจริง: ค่าของถ้าเป็นเท็จ

ดังนั้นเราจึงย่อคำสั่ง if ให้สั้นลง อย่างไรก็ตาม การดำเนินการนี้จะใช้ได้เฉพาะเมื่อกำหนดค่าให้กับตัวแปรเท่านั้น ตอนนี้เรามาดูตัวอย่างที่เสร็จแล้ว

// ตัวอย่างการใช้ตัวดำเนินการแบบไตรภาค
$settings = (empty($_POST["settings"])) ? "ค่าเริ่มต้น" : $_POST["การตั้งค่า"];

// โค้ดด้านบนคล้ายกับบล็อกต่อไปนี้โดยใช้ if/else
ถ้า (ว่าง($_POST["การตั้งค่า"])) (
$settings = "ค่าเริ่มต้น"; // หากไม่มีการโอนใดๆ ให้ปล่อยไว้เป็น "ค่าเริ่มต้น"
) อื่น (
$settings = $_POST["การตั้งค่า"]; // หากผ่าน $settings จะถูกกำหนดค่าที่ส่งผ่าน
}
?>
อ่านความคิดเห็นต่อโค้ดและทุกอย่างควรมีความชัดเจน

ขอบคุณสำหรับความสนใจของคุณ!