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

ตรรกะหรือ (OR และ ||)

ตัวดำเนินการเชิงตรรกะ 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;

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

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

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

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

ก่อนอื่น มาดูกันว่าตัวดำเนินการ && ทำงานอย่างไร ดังนั้น หากตัวถูกดำเนินการทั้งสองเป็นจริง ก็จะคืนค่าเป็น true หากตัวถูกดำเนินการอย่างน้อยหนึ่งตัวหรือทั้งสองตัวคืนค่า false มันก็จะส่งคืน false เช่นกัน

ตัวดำเนินการ 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

ตรรกะไม่ (!)

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

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

ถ้า (เงื่อนไข)(
ตรงตามเงื่อนไข ให้ทำดังนี้
}
อื่น
{
ไม่ตรงตามเงื่อนไข ให้ทำอย่างอื่น
}
ฉันหวังว่าตรรกะของการดำเนินการตามเงื่อนไขจะชัดเจน ตอนนี้เรามาดูตัวอย่างกัน

$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 "เราควรเขียนแบบทดสอบอีกครั้ง...";
}
?>
สาธิต ดาวน์โหลดแหล่งที่มา
นักเรียนของเราที่มีเวลาทั้งพักผ่อนและเขียนข้อสอบปกติได้ คะแนน 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 จะถูกกำหนดค่าที่ส่งผ่าน
}
?>
อ่านความคิดเห็นต่อโค้ดและทุกอย่างชัดเจน

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

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

ก่อนที่จะศึกษาตัวดำเนินการเหล่านี้ คุณต้องเข้าใจนิพจน์และการดำเนินการเชิงตรรกะเสียก่อน

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

การดำเนินการเชิงตรรกะช่วยให้คุณสามารถรวมค่าตรรกะ (หรือที่เรียกว่าค่าความจริง) เพื่อสร้างค่าตรรกะใหม่ ดังที่แสดงในตารางด้านล่าง PHP รองรับตัวดำเนินการเชิงตรรกะมาตรฐาน (และ, หรือ, ไม่ใช่ และ xor) โดยสองตัวแรกมีเวอร์ชันอื่น

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

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

การดำเนินงาน && และ || โปรแกรมเมอร์ภาษา C ควรจะคุ้นเคยกับ Operation! มักจะถูกเรียกว่าไม่ใช่เพราะมันกลายเป็นการปฏิเสธของตัวถูกดำเนินการที่ใช้

หากต้องการทดสอบว่าตัวถูกดำเนินการทั้งสองเป็นจริงหรือไม่ คุณใช้ตัวดำเนินการ 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

ตารางด้านล่างแสดงบางส่วน การแสดงออกทางตรรกะและผลลัพธ์:

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

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

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

การดำเนินการ	ชื่อ	คำอธิบาย
==	เท่ากับ	การดำเนินการที่ผลลัพธ์เป็นจริงหากตัวถูกดำเนินการเท่ากันและเป็นเท็จ
!=	ไม่เท่ากัน	การดำเนินการที่ผลลัพธ์เป็นเท็จหากตัวถูกดำเนินการเท่ากันและเป็นเท็จอย่างอื่น
<	น้อย	การดำเนินการที่ผลลัพธ์เป็นจริงหากตัวถูกดำเนินการทางซ้ายน้อยกว่าตัวถูกดำเนินการทางขวาและเป็นเท็จหากอย่างอื่น
>	มากกว่า	การดำเนินการที่ผลลัพธ์เป็นจริงหากตัวถูกดำเนินการทางซ้ายมากกว่าตัวถูกดำเนินการทางขวา และเป็นเท็จหากอย่างอื่น
<=	น้อยกว่าหรือเท่ากับ	การดำเนินการที่ผลลัพธ์เป็นจริงหากตัวถูกดำเนินการทางซ้ายน้อยกว่าหรือเท่ากับตัวถูกดำเนินการทางขวาและเป็นเท็จอย่างอื่น
>=	มากกว่าหรือเท่ากับ	การดำเนินการที่ผลลัพธ์เป็นจริงหากตัวถูกดำเนินการทางซ้ายมากกว่าหรือเท่ากับตัวถูกดำเนินการทางขวา และเป็นเท็จอย่างอื่น
===	เหมือนกัน	การดำเนินการที่มีผลลัพธ์เป็นจริงหากตัวถูกดำเนินการทั้งสองเท่ากันและเป็นประเภทเดียวกัน และเป็นเท็จ หากอย่างอื่น

ข้อผิดพลาดทั่วไปประการหนึ่งที่คุณต้องทำคืออย่าสร้างความสับสนระหว่างตัวดำเนินการกำหนด (=) กับตัวดำเนินการเปรียบเทียบ (==)

ลำดับความสำคัญของการดำเนินการ

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

รหัสพีเอชพี $var1 = 14; $var2 = 15; ถ้า (($var1< $var2) && ($var2 < 20)) echo "$var2 больше $var1 но меньше 20";

สามารถเขียนใหม่ได้เป็น

รหัสพีเอชพี ...ถ้า ($var1< $var2 && $var2 < 20) ...

คำสั่ง if-else

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

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

ไวยากรณ์ของคำสั่ง if คือ:

ถ้า (นิพจน์แบบมีเงื่อนไข) (บล็อกของโค้ดโปรแกรม;)

หากผลลัพธ์ของการประเมินนิพจน์แบบมีเงื่อนไขเป็น TRUE บล็อกของโค้ดโปรแกรมที่อยู่หลังจากนั้นจะถูกดำเนินการ ในตัวอย่างต่อไปนี้ หากตั้งค่า $username เป็น "Admin" ข้อความต้อนรับจะปรากฏขึ้น มิฉะนั้นจะไม่มีอะไรเกิดขึ้น:

รหัสพีเอชพี $ชื่อผู้ใช้ = "ผู้ดูแลระบบ"; if ($ชื่อผู้ใช้ == "ผู้ดูแลระบบ") ( echo "ยินดีต้อนรับสู่หน้าผู้ดูแลระบบ"; )

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

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

คำสั่ง if และ else $username = "ไม่มีผู้ดูแลระบบ"; if ($username == "Admin") ( echo "ยินดีต้อนรับสู่หน้าผู้ดูแลระบบ"; ) else ( echo "ยินดีต้อนรับสู่หน้าผู้ดูแลระบบ"; )

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

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

ไวยากรณ์คำสั่ง elseif นั้นซับซ้อนกว่าเล็กน้อย แต่ตัวอย่างต่อไปนี้จะช่วยให้คุณเข้าใจได้:

การตรวจสอบเงื่อนไขหลายประการ $ชื่อผู้ใช้ = "แขก"; if ($username == "Admin") ( echo "ยินดีต้อนรับสู่หน้าผู้ดูแลระบบ"; ) elseif ($username == "Guest") ( echo "ไม่สามารถดูได้"; ) else ( echo "ยินดีต้อนรับสู่เพจ ผู้ใช้"; )

มีการตรวจสอบเงื่อนไขสองข้อที่นี่ และการดำเนินการที่แตกต่างกันจะถูกดำเนินการ ขึ้นอยู่กับค่าของตัวแปร $username และยังมีโอกาสที่จะทำอะไรบางอย่างหากค่าของตัวแปรแตกต่างจากสองตัวแรก

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

ตัวดำเนินการ ?: คือตัวดำเนินการแบบไตรภาค (ternary) ที่รับตัวถูกดำเนินการสามตัว มันทำงานคล้ายกับคำสั่ง if แต่ส่งกลับค่าของหนึ่งในสองนิพจน์ นิพจน์ที่จะถูกประเมินจะถูกกำหนดโดยนิพจน์แบบมีเงื่อนไข เครื่องหมายทวิภาค (:) ทำหน้าที่เป็นตัวคั่นนิพจน์:

(เงื่อนไข) ? ประเมิน_if_condition_true: ประเมิน_if_condition_false;

ตัวอย่างด้านล่างตรวจสอบค่าและส่งกลับสตริงที่แตกต่างกัน ขึ้นอยู่กับว่าเป็น TRUE หรือ FALSE:

การสร้างข้อความโดยใช้ตัวดำเนินการ ? $logged_in = จริง; $user = "อิกอร์"; $แบนเนอร์ = (!$logged_in) ? "ลงทะเบียน!" : "ยินดีต้อนรับกลับมา, $user!"; สะท้อน $แบนเนอร์;

เห็นได้ชัดว่าข้อความข้างต้นเทียบเท่ากับข้อความต่อไปนี้:

รหัสพีเอชพี $logged_in = จริง; $user = "อิกอร์"; if (!$logged_in) ( $banner = "ลงทะเบียน!"; ) else ( $banner = "ยินดีต้อนรับกลับมา ผู้ใช้ $!"; ) echo $banner;

คำสั่งสลับ

คำแนะนำ สวิตช์เปรียบเทียบนิพจน์ที่มีหลายค่า ตามกฎแล้ว ตัวแปรจะถูกใช้เป็นนิพจน์ ขึ้นอยู่กับค่าที่ต้องดำเนินการบล็อกโค้ดเฉพาะ ตัวอย่างเช่น ลองจินตนาการถึงตัวแปร $action ที่สามารถมีค่า "ADD", "MODIFY" (เปลี่ยนแปลง) และ "DELETE" คำสั่ง switch ทำให้ง่ายต่อการกำหนดบล็อกของโค้ดที่ควรดำเนินการสำหรับแต่ละค่าเหล่านี้

หากต้องการแสดงความแตกต่างระหว่างคำสั่ง if และ switch ให้ทดสอบตัวแปรกับค่าหลายค่า ตัวอย่างด้านล่างแสดงโค้ดโปรแกรมที่ใช้การตรวจสอบดังกล่าวตามคำสั่ง if และในตัวอย่างต่อไปนี้ ตามคำสั่ง switch:

ทดสอบกับค่าใดค่าหนึ่งจากหลายค่า (ถ้าคำสั่ง) if ($action == "ADD") ( echo "ดำเนินการเพิ่มเติม"; echo "จำนวนคำสั่งในแต่ละบล็อกไม่ จำกัด"; ) elseif ($action == "MODIFY") ( echo "ทำการเปลี่ยนแปลง "; ) elseif ($action == "DELETE") ( echo "ดำเนินการลบ"; ) การทดสอบกับค่าใดค่าหนึ่งจากหลายค่า (คำสั่ง switch) switch ($action) ( case "ADD": echo "ดำเนินการเพิ่มเติม"; echo "จำนวนคำสั่งในแต่ละบล็อกไม่ จำกัด"; break; case "MODIFY": echo "ทำการเปลี่ยนแปลง"; break; case "DELETE" : echo "ทำการลบ";

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

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

การเลือกเริ่มต้น

ถ้าค่าของนิพจน์เงื่อนไขไม่ตรงกับตัวเลือกใดๆ ที่เสนอในคำสั่ง case คำสั่ง switch ในกรณีนี้จะอนุญาตให้คุณทำบางอย่างได้ เช่นเดียวกับคำสั่ง else ของโครงสร้าง if, elseif, else ในการดำเนินการนี้ คุณจะต้องสร้างคำสั่งเป็นตัวเลือกสุดท้ายในรายการตัวเลือก ค่าเริ่มต้น:

การสร้างข้อความแสดงข้อผิดพลาดโดยใช้คำสั่งเริ่มต้น $การกระทำ = "ลบ"; switch ($action) ( case "ADD": echo "ดำเนินการเพิ่มเติม"; echo "จำนวนคำสั่งในแต่ละบล็อกไม่ จำกัด"; break; case "MODIFY": echo "ทำการเปลี่ยนแปลง"; break; กรณี "DELETE" : echo "ดำเนินการลบ"; ค่าเริ่มต้น: echo "ข้อผิดพลาด: คำสั่ง $action ไม่ถูกต้อง ". "ใช้ได้เฉพาะคำสั่ง ADD, MODIFY และ DELETE";

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

คำสั่ง switch ลงท้ายด้วยคีย์เวิร์ด endswitch สวิตช์ ($การกระทำ): case "ADD": echo "ดำเนินการเพิ่ม";

echo "จำนวนคำสั่งในแต่ละบล็อกไม่จำกัด";

หยุดพัก; กรณี "MODIFY": echo "ทำการแก้ไข";

หยุดพัก; กรณี "ลบ": echo "ดำเนินการลบ"; หยุดพัก; ค่าเริ่มต้น: echo "ข้อผิดพลาด: คำสั่ง $action ไม่ถูกต้อง"
"สามารถใช้ได้เฉพาะคำสั่ง ADD, MODIFY และ DELETE เท่านั้น"; เอนด์สวิตซ์;
ขัดจังหวะการดำเนินการ
"; }

หากตัวแปร $action ถูกตั้งค่าเป็น "ASSEMBLE ORDER" ผลลัพธ์ของส่วนนี้จะเป็นดังนี้:

รวบรวมคำสั่งซื้อ หีบห่อ. ส่งมอบให้กับลูกค้า.

สมมติว่าขั้นตอนการสร้างเสร็จสมบูรณ์แล้วและตัวแปร $action ถูกตั้งค่าเป็น "PACKAGE" ผลลัพธ์ต่อไปนี้จะได้รับ:

หีบห่อ. ส่งมอบให้กับลูกค้า.

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

ประเภทข้อมูล รอบ 1 2 3 4 5 6 7 8 9 10

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

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

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

กำหนด ("choice1" , false );
กำหนด ("choice2" , "สุนัข" );
กำหนด ("default1" , "อื่นๆ" );
$วาล = อาร์เรย์();

$val [ "ทดสอบ 1" ] = (choice1 != false ? "hah" : "boo" ) || (choice2 != false ? "hah2" : "boo2" ) || (default1 != false ? "hah3" : "boo3" );
$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 "อ๊ะ! คุณสามารถตอบทั้งสองแบบได้";
กลับจริง;
}

ถ้า (คำตอบบางอย่างหายไป () || คำตอบบางอย่างซ้ำกัน ())
ส่งแบบฟอร์มอีกครั้ง();

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

ถ้า (คำตอบบางอันหายไป() | บางคำตอบซ้ำซ้อน())
ส่งแบบฟอร์มอีกครั้ง();

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

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

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

$you_made_a_mistake = เท็จ;

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

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

ถ้า ($you_made_a_mistake)
ส่งแบบฟอร์มอีกครั้ง();

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

กระโดด

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

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

โปรดอย่าไปสนใจโพสต์ของ 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;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

ตอนนี้ฉันต้องไปแล้ว
$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 | $บี1; // เท่ากับ 5

~ (การปฏิเสธเชิงตรรกะ)

แปลงบิตทั้งหมด: หากค่าบิตเป็น 1 ก็จะกลายเป็นศูนย์ และในทางกลับกัน

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

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

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

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

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

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