ไวยากรณ์ง่ายๆ
หากล่ามพบเครื่องหมายดอลลาร์ ($) ตัวแปลจะดึงอักขระให้ได้มากที่สุดเพื่อสร้างชื่อตัวแปรที่ถูกต้อง หากคุณต้องการระบุส่วนท้ายของชื่อ ให้ใส่ชื่อตัวแปรไว้ในเครื่องหมายปีกกา
$เบียร์ = "ไฮเนเก้น" ;
echo "รสชาติของ $beer" เยี่ยมมาก" ; // ใช้งานได้ """ เป็นอักขระที่ไม่ถูกต้องสำหรับชื่อตัวแปร
echo "เขาดื่ม $เบียร์" ; // ใช้งานไม่ได้ "s" เป็นอักขระที่ถูกต้องสำหรับชื่อตัวแปร
echo "เขาดื่ม $(เบียร์)s" ; //ทำงาน
echo "เขาดื่มไปบ้าง ($เบียร์)" ; //ทำงาน
?>
องค์ประกอบอาร์เรย์ ( อาร์เรย์) หรือคุณสมบัติของวัตถุ ( วัตถุ- ในดัชนีอาร์เรย์จะมีวงเล็บเหลี่ยมปิด ( ] ) เป็นจุดสิ้นสุดของคำจำกัดความดัชนี กฎเดียวกันนี้ใช้กับคุณสมบัติของอ็อบเจ็กต์เช่นเดียวกับตัวแปรอย่างง่าย แม้ว่าจะไม่สามารถหลอกได้เหมือนที่ใช้กับตัวแปรก็ตาม
// ตัวอย่างเหล่านี้เกี่ยวกับการใช้อาร์เรย์ภายในโดยเฉพาะ
// บรรทัด. ภายนอกสตริง ให้ใส่คีย์สตริงของคุณไว้เสมอ
// อาร์เรย์ในเครื่องหมายคำพูดและห้ามใช้สตริงภายนอก (วงเล็บ)
// มาแสดงข้อผิดพลาดทั้งหมดกัน
error_reporting(E_ALL);
$fruits = array("สตรอเบอร์รี่" => "สีแดง" , "กล้วย" => "สีเหลือง" );
// ใช้งานได้ แต่โปรดทราบว่าภายนอกสตริงที่ยกมานั้นทำงานแตกต่างออกไป
เสียงสะท้อน "กล้วยเป็นผลไม้";
//ทำงาน
เสียงสะท้อน "กล้วยคือ ($ผลไม้ ["กล้วย"])";
// ใช้งานได้ แต่ PHP ตามที่อธิบายไว้ด้านล่าง ค้นหาก่อน
//กล้วยคงที่.
เสียงสะท้อน “กล้วยคือ ($ผลไม้)”;
// ใช้งานไม่ได้ ให้ใช้วงเล็บปีกกา ซึ่งจะทำให้เกิดข้อผิดพลาดในการประมวลผล
เสียงสะท้อน "กล้วยคือ $ผลไม้["กล้วย"]";
//ทำงาน
echo "กล้วยคือ" . $ผลไม้ [ "กล้วย" ] . - -
//ทำงาน
เสียงสะท้อน "สี่เหลี่ยมจัตุรัสนี้มีความกว้าง $square->กว้าง เมตร";
// ใช้งานไม่ได้. ดูไวยากรณ์ที่ซับซ้อนสำหรับการแก้ปัญหา
เสียงสะท้อน "สี่เหลี่ยมจัตุรัสนี้มีความกว้าง $สี่เหลี่ยม->ความกว้าง00 เซนติเมตร";
?>
สำหรับงานที่ซับซ้อนมากขึ้น คุณสามารถใช้ไวยากรณ์ที่ซับซ้อนได้
ไวยากรณ์ที่ซับซ้อน (หยิก)
ไวยากรณ์นี้เรียกว่าซับซ้อนไม่ใช่เพราะว่าเข้าใจยาก แต่เนื่องจากอนุญาตให้ใช้นิพจน์ที่ซับซ้อนได้
ที่จริงแล้ว คุณสามารถรวมค่าใดๆ ที่อยู่ในเนมสเปซในบรรทัดเดียวกับไวยากรณ์นี้ได้ คุณเพียงแค่เขียนนิพจน์ในลักษณะเดียวกับที่คุณทำนอกบรรทัด แล้วใส่ไว้ใน ( และ ) เนื่องจากคุณไม่สามารถหลีก "(" ได้ ไวยากรณ์นี้จะรับรู้ก็ต่อเมื่อ $ ตามหลังทันที (. (ใช้ "(\$" หรือ "\($" เพื่อหลีก "($") ตัวอย่างบางส่วน:
// มาแสดงข้อผิดพลาดทั้งหมดกัน
error_reporting(E_ALL);
$great = "มหัศจรรย์" ;
// ใช้งานไม่ได้ จะแสดงผล: นี่คือ ( มหัศจรรย์)
echo "นี่คือ ($ เยี่ยมมาก)" ;
// ใช้งานได้ พิมพ์: นี่มันเยี่ยมมาก
echo "นี่คือ ($ เยี่ยมมาก)" ;
echo "นี่คือ $(เยี่ยมมาก)" ;
//ทำงาน
เสียงสะท้อน "สี่เหลี่ยมจัตุรัสนี้มีความกว้าง ($สี่เหลี่ยม -> กว้าง) 00 เซนติเมตร";
//ทำงาน
เสียงสะท้อน "มันได้ผล: ($arr)";
// สิ่งนี้ไม่ถูกต้องด้วยเหตุผลเดียวกันกับที่ $foo ไม่ถูกต้องภายนอก
// บรรทัด. กล่าวอีกนัยหนึ่ง มันจะยังคงใช้งานได้
// แต่เนื่องจาก PHP ค้นหาค่าคงที่ foo ก่อน สิ่งนี้จะทำให้เกิด
// ข้อผิดพลาดระดับ E_NOTICE (ค่าคงที่ไม่ได้กำหนด)
เสียงสะท้อน "นี่เป็นสิ่งที่ผิด: ($arr)";
//ทำงาน. เมื่อใช้อาร์เรย์หลายมิติภายใน
// บรรทัดจะใช้เครื่องหมายปีกกาเสมอ
เสียงสะท้อน "ใช้งานได้: ($arr["foo"])";
//ทำงาน.
echo "ใช้งานได้:" . $arr [ "ฟู" ][ 3 ];
เอคโค่ "คุณสามารถเขียน ($obj->values->name)";
เอคโค่ "นี่คือค่าของตัวแปรชื่อ $name: ($($name))";
?>
อักขระในสตริงสามารถใช้และแก้ไขได้โดยการระบุออฟเซ็ตจากจุดเริ่มต้นของสตริง เริ่มต้นที่ศูนย์ ในวงเล็บปีกกาหลังสตริง นี่คือตัวอย่างบางส่วน:
// รับอักขระตัวแรกของสตริง
$str = "นี่คือการทดสอบ" -
$แรก = $str ( 0 );
// รับอักขระตัวที่สามของสตริง
$สาม = $str ( 2 );
// รับอักขระตัวสุดท้ายของสตริง
$str = “มันยังคงเป็นการทดสอบ”;
$สุดท้าย = $str ( strlen ($str ) - 1 );
// เปลี่ยนอักขระตัวสุดท้ายของบรรทัด
$str = "มองทะเล";
$str ( strlen ($str ) - 1 ) = "ตัวเอง" ;
?>
ฟังก์ชันสตริงและตัวดำเนินการ
ตัวดำเนินการสตริง
ภาษาการเขียนโปรแกรมที่แตกต่างกันใช้ตัวดำเนินการการต่อสตริง (เข้าร่วม) ที่แตกต่างกัน ตัวอย่างเช่น Pascal ใช้ตัวดำเนินการ "+" การใช้ตัวดำเนินการ "+" เพื่อต่อสตริงใน PHP ไม่ถูกต้อง: หากสตริงมีตัวเลข แทนที่จะต่อสตริง จะดำเนินการเพิ่มตัวเลขสองตัวแทน
PHP มีโอเปอเรเตอร์สองตัวที่ทำการต่อข้อมูล
ตัวแรกคือตัวดำเนินการต่อข้อมูล (".") ซึ่งส่งคืนการต่อข้อมูลของอาร์กิวเมนต์ด้านซ้ายและขวา
ประการที่สองคือตัวดำเนินการมอบหมายที่มีการต่อข้อมูลซึ่งต่อท้ายอาร์กิวเมนต์ที่ถูกต้องทางด้านซ้าย
เรามายกตัวอย่างเฉพาะ:
$a = "สวัสดี" ;
$ข = $a "โลก!" - // $b มีสตริง "Hello World!" - นี่คือการต่อข้อมูล
$a = "สวัสดี" ;
$a .= "โลก!" - // $a มีสตริง "Hello World!" - นี่คืองานที่มีการต่อข้อมูล
?>
ตัวดำเนินการเปรียบเทียบสตริง
ไม่แนะนำให้ใช้ตัวดำเนินการเปรียบเทียบ == และ != เพื่อเปรียบเทียบสตริง เนื่องจากจำเป็นต้องมีการแปลงประเภท ตัวอย่าง:
$x = 0 ; x - สตริงว่าง y - สตริงว่าง
$y=1;
ถ้า ($x == "" ) เสียงก้อง "
ถ้า ($y == "" ) เสียงก้อง "
// เอาท์พุต:
// x เป็นสตริงว่าง
?>
สคริปต์นี้บอกเราว่า $x เป็นสตริงว่าง นี่เป็นเพราะความจริงที่ว่าสตริงว่าง ("") จะถูกถือว่าก่อนเป็น 0 และต่อจากนั้นจะเป็น "ว่างเปล่า" เท่านั้น ใน PHP ตัวถูกดำเนินการจะถูกเปรียบเทียบเป็นสตริงก็ต่อเมื่อเป็นทั้งสองสตริงเท่านั้น มิฉะนั้นจะถูกเปรียบเทียบเป็นตัวเลข ในกรณีนี้ สตริงใดๆ ที่ PHP ไม่สามารถแปลงเป็นตัวเลขได้ (รวมถึงสตริงว่างด้วย) จะถือเป็น 0
ตัวอย่างการเปรียบเทียบสตริง:
$x = "สตริง" ; สตริง X เท่ากับสตริง Z สตริง X เท่ากับสตริง Y สตริง X ไม่เท่ากับสตริง Z
$y = "สตริง" ;
$ z = "เส้น" ;
ถ้า ($x == $z) สะท้อน "
ถ้า ($x == $y) สะท้อน "
ถ้า ($x != $z) สะท้อน "
// เอาท์พุต:
// String X เท่ากับ string Y
?>
เพื่อหลีกเลี่ยงความสับสนและการแปลงประเภท ขอแนะนำให้ใช้ตัวดำเนินการเทียบเท่าเมื่อเปรียบเทียบสตริง ตัวดำเนินการเทียบเท่าช่วยให้คุณสามารถเปรียบเทียบสตริงได้อย่างถูกต้องเสมอ เนื่องจากจะเปรียบเทียบค่าทั้งตามค่าและตามประเภท:
$x = "สตริง" ; สตริง X เท่ากับสตริง Z สตริง X เท่ากับสตริง Y สตริง X ไม่เท่ากับสตริง Z
$y = "สตริง" ;
$ z = "เส้น" ;
ถ้า ($x == = $z) เสียงก้อง "
ถ้า ($x === $y) สะท้อน "
ถ้า ($ x !== $ z ) สะท้อน "
// เอาท์พุต:
// String X เท่ากับ string Y
// String X ไม่เท่ากับ string Z
?>
ตัวแปร $GLOBALS- อาร์เรย์แบบเชื่อมโยงที่มีการอ้างอิงถึงตัวแปรขอบเขตส่วนกลางของสคริปต์ทั้งหมดที่กำหนดไว้ในปัจจุบัน ชื่อตัวแปรคือคีย์อาร์เรย์
หากต้องการประกาศตัวแปรโกลบอล เพียงวางไว้ในอาร์เรย์ $GLOBALS
$GLOBALS["testkey2"]="testvalue2";
คุณสามารถแสดงค่าทั้งหมดของตัวแปรอาร์เรย์ $GLOBALS ได้โดยใช้ print_r($GLOBALS); หรือเช่นนี้:
Foreach ($GLOBALS เป็น $key=>$value) echo "GLOBALS[".$key."] == ".$value"
";
ตัวแปร $_SERVER.
$_REQUEST ตัวแปร- อาร์เรย์แบบเชื่อมโยง (อาร์เรย์) ซึ่งโดยค่าเริ่มต้นจะมีข้อมูลของตัวแปร $_GET, $_POST และ $_COOKIE ตัวแปรในอาร์เรย์ $_REQUEST จะถูกส่งผ่านไปยังสคริปต์โดยใช้วิธี GET, POST หรือ COOKIE ดังนั้นจึงไม่สามารถเชื่อถือได้เนื่องจาก ผู้ใช้ระยะไกลอาจเปลี่ยนแปลงได้ การมีอยู่และลำดับของการเพิ่มข้อมูลลงในอาร์เรย์ที่เกี่ยวข้องนั้นถูกกำหนดโดยคำสั่ง Variables_order (GPCS ถูกตั้งค่าเป็นค่าเริ่มต้น)
ตัวแปร $_SESSION
ตัวแปร $_ENV- กรอกหากสคริปต์ถูกเรียกใช้จากบรรทัดคำสั่ง อาร์เรย์ $_SERVER จะมีตัวแปรทั้งหมดจากอาร์เรย์ $_ENV
ตัวแปร $http_response_header
ความคิดเห็น: ใน PHP 7.0.0 บนแพลตฟอร์ม 64 บิต ไม่มีการจำกัดความยาวบรรทัด ในระบบ 32 บิต และใน PHP เวอร์ชันก่อนหน้า บรรทัดต้องมีขนาดไม่เกิน 2 GB (2147483647 ไบต์)
ไวยากรณ์
สตริงสามารถกำหนดได้สี่วิธี:
- คำพูดเดียว
- เครื่องหมายคำพูดคู่
- ไวยากรณ์ nowdoc (ตั้งแต่ PHP 5.3.0)
คำพูดเดี่ยว
วิธีที่ง่ายที่สุดในการกำหนดสตริงคือการใส่เครื่องหมายคำพูดเดี่ยว (สัญลักษณ์ " ).
หากต้องการใช้เครื่องหมายคำพูดเดี่ยวภายในสตริง ให้หลีกด้วยเครื่องหมายแบ็กสแลช ( \ - หากคุณต้องการเขียนแบ็กสแลชเอง ให้ทำซ้ำ ( \\ - การใช้แบ็กสแลชอื่นๆ ทั้งหมดจะถูกตีความว่าเป็นอักขระปกติ ซึ่งหมายความว่าหากคุณพยายามใช้ลำดับหลีกอื่นๆ เช่น \rหรือ \nพวกมันจะถูกส่งออกตามที่เป็นอยู่ แทนที่จะเป็นพฤติกรรมพิเศษใดๆ
เสียงสะท้อน "นี่คือสตริงง่ายๆ";
เสียงสะท้อน “คุณยังสามารถแทรกลงในบรรทัดได้
อักขระขึ้นบรรทัดใหม่เช่นนี้
นี่ก็โอเค";
// ผลลัพธ์: อาร์โนลด์เคยกล่าวไว้ว่า: "ฉันจะกลับมา"
เสียงสะท้อน “วันหนึ่งอาร์โนลด์พูดว่า 'ฉันจะกลับมา';
เอคโค่ "คุณได้ลบ C:\\*.* หรือไม่?";
// ผลลัพธ์: คุณลบ C:\*.* หรือไม่?
echo "คุณได้ลบ C:\*.* หรือไม่?" -
// ผลลัพธ์: สิ่งนี้จะไม่ถูกขยาย: \n ขึ้นบรรทัดใหม่
เสียงสะท้อน "สิ่งนี้จะไม่ถูกขยาย: \n ขึ้นบรรทัดใหม่";
// ผลลัพธ์: $expand และตัวแปร $ตัวใดตัวหนึ่งจะไม่ถูกขยาย
เสียงสะท้อน "$expand และ $either ตัวแปรไม่ถูกขยาย";
?>
เครื่องหมายคำพูดคู่
หากสตริงอยู่ในเครื่องหมายคำพูดคู่ (") PHP จะจดจำลำดับการหลีกอักขระพิเศษต่อไปนี้:
| ลำดับต่อมา | ความหมาย |
|---|---|
| \n | ขึ้นบรรทัดใหม่ (LF หรือ 0x0A (10) ในรูปแบบ ASCII) |
| \r | แคร่กลับ (CR หรือ 0x0D (13) ในรูปแบบ ASCII) |
| \t | แท็บแนวนอน (HT หรือ 0x09 (9) ในรูปแบบ ASCII) |
| \v | แท็บแนวตั้ง (VT หรือ 0x0B (11) ใน ASCII) (ตั้งแต่ PHP 5.2.5) |
| \e | อักขระหลีก (ESC หรือ 0x1B (27) ใน ASCII) (ตั้งแต่ PHP 5.4.4) |
| \ฉ | ฟีดหน้า (FF หรือ 0x0C(12) ใน ASCII) (ตั้งแต่ PHP 5.2.5) |
| \\ | แบ็กสแลช |
| \$ | เครื่องหมายดอลลาร์ |
| \" | เครื่องหมายคำพูดคู่ |
| \{1,3} | ลำดับของอักขระที่ตรงกับนิพจน์ทั่วไปของอักขระฐานแปดที่ล้นอย่างเงียบ ๆ เพื่อให้พอดีกับไบต์ (เช่น "\400" === "\000") |
| \x(1,2) | ลำดับของอักขระที่สอดคล้องกับนิพจน์ทั่วไปของอักขระในรูปแบบเลขฐานสิบหก |
| \ ยู(+) | ลำดับของอักขระที่ตรงกับนิพจน์ทั่วไปของอักขระ Unicode ที่จับคู่กับสตริงในการแทนค่า UTF-8 (เพิ่มใน PHP 7.0.0) |
เช่นเดียวกับสตริงที่อยู่ในเครื่องหมายคำพูดเดี่ยว การยกเว้นอักขระใดๆ จะเป็นเอาต์พุตของอักขระ Escape ด้วยเช่นกัน ก่อน PHP 5.1.1 ให้แบ็กสแลชเข้า \($วาร์)ไม่ได้เผยแพร่
เฮริด็อก
วิธีที่สามในการกำหนดสตริงคือการใช้ไวยากรณ์ heredoc: <<< - หลังจากโอเปอเรเตอร์นี้ คุณต้องระบุตัวระบุ จากนั้นจึงป้อนบรรทัด หลังจากนั้นจะมีบรรทัดขึ้นมา จากนั้นตัวระบุเดียวกันจะปิดการแทรก
เส้น ควรเริ่มต้นด้วยตัวระบุการปิด เช่น จะต้องปรากฏในคอลัมน์แรกของแถว นอกจากนี้ ตัวระบุจะต้องเป็นไปตามกฎการตั้งชื่อเดียวกันกับแท็กอื่นๆ ทั้งหมดใน PHP: มีเพียงอักขระตัวอักษรและตัวเลขและเครื่องหมายขีดล่าง และต้องไม่ขึ้นต้นด้วยตัวเลข (อนุญาตให้ใช้เครื่องหมายขีดล่างได้)
ความสนใจ
เป็นสิ่งสำคัญมากที่จะต้องทราบว่าบรรทัดตัวระบุการปิดจะต้องไม่มีอักขระอื่นใดยกเว้นเครื่องหมายอัฒภาค ( ; - ซึ่งหมายความว่ารหัส ไม่ควรเยื้องและต้องไม่มีช่องว่างหรือแท็บใดๆ ก่อนหรือหลังเครื่องหมายอัฒภาค สิ่งสำคัญคือต้องเข้าใจว่าอักขระตัวแรกก่อนตัวระบุการปิดต้องเป็นอักขระขึ้นบรรทัดใหม่ตามที่กำหนดโดยระบบปฏิบัติการของคุณ ตัวอย่างเช่น ในระบบ UNIX รวมถึง macOS นี่คือ \n- หลังจากตัวระบุการปิด บรรทัดใหม่จะต้องเริ่มต้นทันที
หากกฎนี้ถูกละเมิดและตัวระบุการปิดไม่ "สะอาด" จะถือว่าตัวระบุการปิดหายไปและ PHP จะพยายามค้นหาต่อไป หากในกรณีนี้ไม่พบตัวระบุการปิดที่ถูกต้อง จะทำให้เกิดข้อผิดพลาดในการแยกวิเคราะห์โดยมีหมายเลขบรรทัดที่ส่วนท้ายของสคริปต์
ตัวอย่างที่ 1 ตัวอย่างไวยากรณ์ที่ไม่ถูกต้อง
คลาสฟู (
สาธารณะ $bar =<<
อีโอที;
// ไม่อนุญาตให้เยื้องหน้าตัวระบุการปิด
}
?>
ตัวอย่างที่ 2 ตัวอย่างไวยากรณ์ที่ถูกต้อง
คลาสฟู (
สาธารณะ $bar =<<
อีโอที;
}
?>
Heredoc ไม่สามารถใช้ในการเริ่มต้นฟิลด์คลาสได้
ข้อความ Heredoc ทำงานในลักษณะเดียวกับสตริงในเครื่องหมายคำพูดคู่โดยไม่ต้องมี
ซึ่งหมายความว่าคุณไม่จำเป็นต้องใช้ Escape เครื่องหมายคำพูดใน Heredoc แต่คุณยังสามารถใช้ Escape Sequence ด้านบนได้
ตัวแปรได้รับการประมวลผล แต่คุณต้องระมัดระวังเมื่อใช้ตัวแปรที่ซับซ้อนภายใน Heredoc เช่นเดียวกับเมื่อทำงานกับสตริง<<
$str =
ตัวอย่างบรรทัด
ทอดยาวหลายบรรทัด
ใช้ไวยากรณ์ heredoc
{
อีโอดี;
คลาสฟู
var $foo ;
{
var $บาร์ ;
ฟังก์ชั่น__สร้าง()
}
}
$นี่ -> ฟู = "ฟู" ;
$นี่ ->
$foo = ใหม่ foo();<<
เสียงสะท้อนฉันชื่อ "$ชื่อ" ฉันพิมพ์ $foo -> foo .
ตอนนี้ฉันกำลังอนุมาน
อีโอที;
?>
( $foo -> บาร์ [ 1 ])
สิ่งนี้ควรแสดงอักษรตัวใหญ่ "A": \x41
ฉันชื่อ "ชื่อ" ฉันพิมพ์ฟู ตอนนี้ฉันส่งออก Bar2 สิ่งนี้ควรแสดงอักษรตัวใหญ่ "A": A
นอกจากนี้ยังเป็นไปได้ที่จะใช้ไวยากรณ์ heredoc เพื่อส่งข้อมูลผ่านอาร์กิวเมนต์ของฟังก์ชัน:
ตั้งแต่เวอร์ชัน 5.3.0 เป็นไปได้ที่จะเริ่มต้นตัวแปรสแตติกและคุณสมบัติคลาส/ค่าคงที่โดยใช้ไวยากรณ์ Heredoc:
ตัวอย่าง #5 การใช้ Heredoc เพื่อเริ่มต้นตัวแปรคงที่
{
// ตัวแปรแบบคงที่<<
$บาร์คงที่ =
}
ไม่มีอะไรที่นี่...
ฉลาก;
{
// ค่าคงที่/คุณสมบัติของคลาส<<
const บาร์ =
ตัวอย่างการใช้ค่าคงที่<<
const บาร์ =
}
?>
สาธารณะ $baz =
ตัวอย่างการใช้สนาม
ใน PHP 5.3.0 คุณยังสามารถล้อมรอบตัวระบุ Heredoc ด้วยเครื่องหมายคำพูดคู่: โนว์ด็อก Nowdoc จะเหมือนกันสำหรับสตริงที่มีเครื่องหมายคำพูดเดี่ยว ในขณะที่ Heredoc ใช้สำหรับสตริงที่มีเครื่องหมายคำพูดคู่ Nowdoc คล้ายกับ Heredoc แต่อยู่ข้างใน ไม่มีการทดแทน
- การออกแบบนี้เหมาะสำหรับการฝังโค้ด PHP หรือบล็อกข้อความขนาดใหญ่อื่นๆ โดยไม่ต้องหลบหนี ในกรณีนี้จะคล้ายกับโครงสร้าง SGML เล็กน้อย <<< โดยการประกาศบล็อกข้อความที่ไม่ได้ตั้งใจให้ประมวลผล <<<"EOT" Nowdoc ถูกระบุด้วยลำดับเดียวกัน
ซึ่งใช้ใน heredoc แต่ตัวระบุต่อไปนี้อยู่ในเครื่องหมายคำพูดเดี่ยว เช่น
$foo = ใหม่ foo();<<<"EOD"
- เงื่อนไขทั้งหมดที่ใช้กับตัวระบุ Heredoc ยังใช้กับ nowdoc ด้วย โดยเฉพาะเงื่อนไขที่ใช้กับตัวระบุการปิด
ตัวอย่าง #7 ตัวอย่างการใช้ nowdoc
ข้อความตัวอย่าง
ทอดยาวหลายบรรทัด
ใช้ไวยากรณ์ nowdoc แบ็กสแลชจะได้รับการปฏิบัติตามตัวอักษรเสมอ
เช่น \\ และ \"
ตัวอย่างข้อความที่ขยายหลายบรรทัดโดยใช้ไวยากรณ์ nowdoc เครื่องหมายแบ็กสแลชจะถูกใช้ตามตัวอักษรเสมอ เช่น \\ และ \"
ตัวอย่าง #8 ตัวอย่างการอ้างอิงสตริง Nowdoc พร้อมตัวแปร
/* ตัวอย่างที่ซับซ้อนยิ่งขึ้นพร้อมตัวแปร -
ฉลาก;
{
สาธารณะ $foo ;
สาธารณะ $บาร์ ;
var $foo ;
{
var $บาร์ ;
$นี่ -> bar = array("Bar1" , "Bar2" , "Bar3" );
}
}
$นี่ -> ฟู = "ฟู" ;
$นี่ ->
$foo = ใหม่ foo();<<<"EOT"
ฉันชื่อ "$name" ฉันพิมพ์ $foo->foo
ตอนนี้ฉันพิมพ์ ($foo->bar)
สิ่งนี้ไม่ควรแสดงตัวพิมพ์ใหญ่ "A": \x41
อีโอที;
?>
เช่น \\ และ \"
ฉันชื่อ "$name" ฉันพิมพ์ $foo->foo ตอนนี้ฉันพิมพ์ ($foo->bar) สิ่งนี้ไม่ควรแสดงตัวพิมพ์ใหญ่ "A": \x41
ตัวอย่าง #9 ตัวอย่างการใช้ข้อมูลคงที่
คลาสฟู (
สาธารณะ $bar =<<<"EOT"
บาร์
อีโอที;
}
?>
ความคิดเห็น:
เพิ่มการรองรับ nowdoc ใน PHP 5.3.0
การจัดการตัวแปร
หากระบุสตริงด้วยเครื่องหมายคำพูดคู่ หรือใช้ Heredoc ตัวแปรภายในจะถูกประมวลผล
ไวยากรณ์มีสองประเภท: ง่ายและซับซ้อน อาร์เรย์ไวยากรณ์แบบง่ายนั้นง่ายกว่าและสะดวกกว่า ทำให้สามารถประมวลผลตัวแปรซึ่งเป็นค่าอาร์เรย์ ( วัตถุ) หรือคุณสมบัติของวัตถุ (
) โดยใช้ความพยายามน้อยที่สุด
ไวยากรณ์ที่ซับซ้อนสามารถระบุได้ด้วยเครื่องหมายปีกกาที่ล้อมรอบนิพจน์
ไวยากรณ์ง่ายๆ $ หากล่ามพบเครื่องหมายดอลลาร์ (
) โดยจะจับอักขระให้ได้มากที่สุดเพื่อสร้างชื่อตัวแปรที่ถูกต้อง หากคุณต้องการระบุส่วนท้ายของชื่อ ให้ใส่ชื่อตัวแปรไว้ในเครื่องหมายปีกกา
$juice = "แอปเปิ้ล" ;
echo "เขาดื่มน้ำผลไม้ $ นิดหน่อย" - PHP_EOL ;
// ไม่ถูกต้อง. "s" เป็นอักขระที่ถูกต้องสำหรับชื่อตัวแปร แต่ตัวแปรชื่อ $juice
echo "เขาดื่มน้ำผลไม้ที่ทำจากน้ำผลไม้ $" -
// ถูกต้อง. ส่วนท้ายของชื่อตัวแปรจะถูกระบุอย่างเคร่งครัดโดยใช้วงเล็บ:
?>
เช่น \\ และ \"
echo "เขาดื่มน้ำผลไม้ที่ทำจาก $( น้ำผลไม้ ) s." -
เขาดื่มน้ำแอปเปิ้ล เขาดื่มน้ำผลไม้ที่ทำจาก. เขาดื่มน้ำผลไม้ที่ทำจากแอปเปิ้ล อาร์เรย์องค์ประกอบอาร์เรย์ ( วัตถุ) หรือคุณสมบัติของวัตถุ ( ] - ในดัชนีอาร์เรย์จะมีวงเล็บเหลี่ยมปิด (
) เป็นจุดสิ้นสุดของคำจำกัดความดัชนี กฎเดียวกันนี้ใช้กับคุณสมบัติของวัตถุเช่นเดียวกับตัวแปรอย่างง่าย
ตัวอย่างที่ 10 ตัวอย่างไวยากรณ์อย่างง่าย
กำหนด ("KOOLAID" , "koolaid1" );
$juices = array("apple" , "orange" , "koolaid1" => "purple" );
echo "เขาดื่มน้ำผลไม้ $juices [ 0 ]" - PHP_EOL ;
echo "เขาดื่มน้ำผลไม้ $juices [1]" - PHP_EOL ;
echo "เขาดื่มน้ำผลไม้ $juices [ koolaid1 ] บ้าง" - PHP_EOL ;
คนในชั้นเรียน (
สาธารณะ $john = "จอห์น สมิธ" ;
สาธารณะ $jan = "เจน สมิธ" ;
สาธารณะ $robert = "โรเบิร์ตพอลเซ่น" ;
}
สาธารณะ $สมิธ = "สมิธ" ;
echo "$people -> john ดื่ม $juices [ 0 ] น้ำผลไม้" - PHP_EOL ;
echo " $people -> john กล่าวสวัสดี $people -> jane " - PHP_EOL ;
echo "$people -> ภรรยาของ john "ทักทาย $people -> robert" . PHP_EOL;
echo " $people -> robert ทักทาย $people สองคน -> smiths " - //จะไม่ทำงาน
?>
เช่น \\ และ \"
เขาดื่มน้ำแอปเปิ้ล เขาดื่มน้ำส้ม เขาดื่มน้ำผลไม้สีม่วง จอห์น สมิธดื่มน้ำแอปเปิ้ล จากนั้นจอห์น สมิธก็กล่าวทักทายเจน สมิธ ภรรยาของจอห์น สมิธทักทายโรเบิร์ต พอลเซน ทักทายทั้งสอง
เพิ่มการรองรับ PHP 7.1.0 เชิงลบดัชนีตัวเลข
ตัวอย่างที่ 11 ดัชนีตัวเลขติดลบ
$string = "สตริง" ;
เสียงสะท้อน “อักขระที่ดัชนี -2 เท่ากับ$string [- 2 ] ." , PHP_EOL ;
$string [- 3 ] = "o" ;
เสียงสะท้อน "การเปลี่ยนอักขระที่ตำแหน่ง -3 เป็น 'o' จะสร้างบรรทัดต่อไปนี้:$string." , PHP_EOL;
?>
เช่น \\ และ \"
อักขระที่มีดัชนี -2 เท่ากับ n การเปลี่ยนอักขระที่ตำแหน่ง -3 เป็น "o" จะทำให้ได้บรรทัดต่อไปนี้: strong
สำหรับสิ่งที่ซับซ้อนกว่านี้ ให้ใช้ไวยากรณ์ที่ซับซ้อน
ไวยากรณ์ที่ซับซ้อน (หยิก)
มันถูกเรียกว่าซับซ้อนไม่ใช่เพราะว่ามันยากที่จะเข้าใจ แต่เพราะมันทำให้สามารถใช้สำนวนที่ซับซ้อนได้
ตัวแปรสเกลาร์ องค์ประกอบอาร์เรย์ หรือคุณสมบัติของอ็อบเจ็กต์ใดๆ ที่แมปกับสตริงสามารถแสดงเป็นสตริงได้โดยใช้ไวยากรณ์นี้ เพียงเขียนนิพจน์ในลักษณะเดียวกับที่คุณเขียนนอกบรรทัดแล้วจึงปิดท้าย { และ } - เพราะ { ไม่สามารถหลีกหนีได้ ไวยากรณ์นี้จะรับรู้เมื่อเท่านั้น $ ตามมาโดยตรง { - ใช้ {\$ เพื่อพิมพ์ {$ - ตัวอย่างบางส่วน:
// แสดงข้อผิดพลาดทั้งหมด
error_reporting(E_ALL);
$great = "เยี่ยมมาก" ;
// ใช้งานไม่ได้ ผลลัพธ์: นี่คือ (เยี่ยมมาก)
echo "นี่คือ ( $great )" ;
// ใช้งานได้ ผลลัพธ์: เยี่ยมมาก
echo "นี่คือ ( $great ) " ;
//ทำงาน
เสียงสะท้อน “จัตุรัสนี้กว้าง( $square -> width ) 00 เซนติเมตร" ;
// ใช้งานได้ คำหลักที่ยกมาใช้งานได้กับไวยากรณ์วงเล็บปีกกาเท่านั้น
echo "ใช้งานได้: ( $arr [ "key" ]) " ;
//ทำงาน
echo "ใช้งานได้: ( $arr [ 4 ][ 3 ]) " ;
// สิ่งนี้ไม่ถูกต้องด้วยเหตุผลเดียวกันกับ $foo ภายนอก
// เส้น. กล่าวอีกนัยหนึ่ง มันจะยังคงใช้งานได้
// แต่เนื่องจาก PHP ค้นหาค่าคงที่ foo ก่อน สิ่งนี้จะทำให้เกิด
// ข้อผิดพลาดระดับ E_NOTICE (ค่าคงที่ไม่ได้กำหนด)
เสียงสะท้อน “นี่เป็นสิ่งที่ผิด:( $arr [ ฟู ][ 3 ]) " ;
//ทำงาน. เมื่อใช้อาร์เรย์หลายมิติภายใน
// บรรทัดจะใช้เครื่องหมายปีกกาเสมอ
echo "ใช้งานได้: ( $arr [ "foo" ][ 3 ]) " ;
//ทำงาน.
echo "ใช้งานได้:" . $arr [ "ฟู" ][ 3 ];
เสียงสะท้อน “วิธีนี้ใช้ได้ผลเช่นกัน:( $obj -> ค่า [ 3 ]-> ชื่อ ) " ;
เสียงสะท้อน “นี่คือค่าของตัวแปรที่ตั้งชื่อ$name : ($( $name )) " ;
เสียงสะท้อน "นี่คือค่าของชื่อตัวแปรที่ getName() ส่งคืน:($( getName ())) " ;
เสียงสะท้อน "นี่คือค่าของตัวแปรตามชื่อที่ \$object->getName() ส่งกลับ:($( $object -> getName ())) " ;
// ใช้งานไม่ได้ ผลลัพธ์: นี่คือสิ่งที่ getName() ส่งคืน: (getName())
เสียงสะท้อน "นี่คือสิ่งที่ getName() ส่งคืน: (getName())";
?>
นอกจากนี้ยังสามารถเข้าถึงคุณสมบัติของอ็อบเจ็กต์ภายในสตริงโดยใช้ไวยากรณ์นี้ได้
คลาสฟู (
var $bar = "ฉันคือบาร์" -
}
$นี่ -> ฟู = "ฟู" ;
$บาร์ = "บาร์" ;
$baz = array("foo" , "bar" , "baz" , "quux" );
echo " ( $foo -> $bar ) \n" ;
echo " ( $foo ->( $baz [ 1 ])) \n" ;
?>
เช่น \\ และ \"
ฉันคือบาร์ ฉันคือบาร์
ความคิดเห็น:
ฟังก์ชัน การเรียกเมธอด ตัวแปรคลาสแบบสแตติก และค่าคงที่คลาสทำงานภายใน {$} เริ่มต้นด้วย PHP 5 อย่างไรก็ตาม ค่าที่ให้มาจะถือเป็นชื่อตัวแปรในบริบทเดียวกับบรรทัดที่กำหนดไว้ การใช้เครื่องหมายปีกกาเดี่ยว ( {} ) จะไม่ทำงานในการเข้าถึงค่าของฟังก์ชัน วิธีการ ค่าคงที่ของคลาส หรือตัวแปรคลาสแบบคงที่
// แสดงข้อผิดพลาดทั้งหมด
error_reporting(E_ALL);
คลาสเบียร์ (
const softdrink = "รูทเบียร์" ;
สาธารณะ $ale = "ipa" ;
}
$rootbeer = "เอ แอนด์ ดับบลิว" ;
$ipa = "อเล็กซานเดอร์ คีธ\"s" ;
// ใช้งานได้ ผลลัพธ์: ฉันต้องการ A&W
echo "ฉันต้องการ ($( เบียร์ :: softdrink )) \n" ;
// วิธีนี้ใช้ได้ผลเช่นกัน ผลลัพธ์: ฉันต้องการของ Alexander Keith
echo "ฉันต้องการ ($( เบียร์ :: $ale )) \n" ;
?>
การเข้าถึงและการเปลี่ยนอักขระในสตริง
อักขระในสตริงสามารถใช้และแก้ไขได้โดยการระบุออฟเซ็ตจากจุดเริ่มต้นของสตริง โดยเริ่มต้นด้วยศูนย์ ในวงเล็บเหลี่ยมหลังสตริง เช่น $str คิดว่าสตริงสำหรับจุดประสงค์นี้เป็นอาร์เรย์ของอักขระและ หากคุณต้องการรับหรือแทนที่อักขระมากกว่า 1 ตัว คุณสามารถใช้ฟังก์ชันได้.
ความคิดเห็น: ซับสเตร() substr_replace()ตั้งแต่ PHP 7.1.0 รองรับค่าออฟเซ็ตเชิงลบ พวกเขาระบุออฟเซ็ตจากท้ายบรรทัด การชดเชยเชิงลบก่อนหน้านี้ทำให้เกิดข้อผิดพลาดระดับ E_ประกาศ
ความคิดเห็น: เมื่ออ่าน (ส่งคืนสตริงว่าง) หรือ
ความสนใจ
E_คำเตือน พวกเขาระบุออฟเซ็ตจากท้ายบรรทัด การชดเชยเชิงลบก่อนหน้านี้ทำให้เกิดข้อผิดพลาดระดับเมื่อเขียน (ปล่อยให้บรรทัดไม่เปลี่ยนแปลง)
ความสนใจ
สตริงใน PHP เป็นอาร์เรย์ภายในของไบต์ ด้วยเหตุนี้ การเข้าถึงหรือแก้ไขสตริงที่ออฟเซ็ตจึงไม่ปลอดภัยในการเข้ารหัสหลายไบต์ และควรทำด้วยสตริงในการเข้ารหัสไบต์เดียวเท่านั้น เช่น ISO-8859-1
ความคิดเห็น: ตั้งแต่ PHP 7.1.0 การใช้ดัชนีว่างจะทำให้เกิดข้อผิดพลาดร้ายแรง ก่อนหน้านี้ ในกรณีนี้ สตริงจะถูกแปลงเป็นอาร์เรย์โดยไม่มีการเตือน
ตัวอย่างที่ 12 ตัวอย่างสตริงบางส่วน
// รับอักขระตัวแรกของสตริง
$str = "นี่คือการทดสอบ" -
$แรก = $str [ 0 ];
// รับอักขระตัวที่สามของสตริง
$สาม = $str [ 2 ];
// รับอักขระตัวสุดท้ายของสตริง
$str = "นี่ยังคงเป็นการทดสอบ" -
$last = $str [ strlen ($str ) - 1 ];
// เปลี่ยนอักขระตัวสุดท้ายของบรรทัด
$str = "มองไปที่ทะเล" ;
$str [ strlen ($str )- 1 ] = "e" ;
?>
ตั้งแต่ PHP 5.4 เป็นต้นไป ค่าชดเชยในสตริงจะต้องระบุเป็นจำนวนเต็มหรือสตริงที่มีตัวเลข มิฉะนั้น จะมีการแจ้งเตือน ก่อนหน้านี้ชดเชยที่กำหนดโดยสตริงเช่น "ฟู"โดยไม่มีการแจ้งเตือนถูกแปลงเป็น 0 .
ตัวอย่าง #13 ความแตกต่างระหว่าง PHP 5.3 และ PHP 5.4
$str = "เอบีซี" ;
Var_dump($str["1"]);
var_dump (isset($str [ "1" ]));
Var_dump($str["1.0"]);
var_dump (isset($str [ "1.0" ]));
Var_dump($str["x"]);
var_dump (isset($str [ "x" ]));
Var_dump($str["1x"]);
var_dump (isset($str [ "1x" ]));
?>
ผลลัพธ์ของการรันตัวอย่างนี้ใน PHP 5.3:
สตริง (1) "b" บูล (จริง) สตริง (1) "b" บูล (จริง) สตริง (1) "a" บูล (จริง) สตริง (1) "b" บูล (จริง)
ผลลัพธ์ของการรันตัวอย่างนี้ใน PHP 5.4:
string(1) "b" bool(true) คำเตือน: สตริงที่ผิดกฎหมาย offset "1.0" ใน /tmp/t.php ออนไลน์ 7 string(1) "b" bool(false) คำเตือน: สตริงที่ผิดกฎหมาย offset "x" in / tmp/t.php ออนไลน์ 9 string(1) "a" bool(false) string(1) "b" bool(false)
ความคิดเห็น:
กำลังพยายามเข้าถึงตัวแปรประเภทอื่น (ไม่รวมอาร์เรย์หรือออบเจ็กต์ที่ใช้อินเทอร์เฟซบางอย่าง) โดยใช้ หรือ {} จะกลับมาอย่างเงียบๆ โมฆะ.
ความคิดเห็น:
PHP 5.5 เพิ่มการรองรับสำหรับการเข้าถึงอักขระในตัวอักษรสตริงโดยใช้ไวยากรณ์ หรือ {} .
มีฟังก์ชันที่มีประโยชน์มากมายสำหรับการแก้ไขสตริง
ฟังก์ชันพื้นฐานอธิบายไว้ในส่วนฟังก์ชันสตริง และสำหรับการค้นหาขั้นสูงและแทนที่ ฟังก์ชันนิพจน์ทั่วไปที่เข้ากันได้กับ Perl
แปลงเป็นสตริง
ค่าสามารถแปลงเป็นสตริงได้โดยใช้การร่าย (เชือก)หรือฟังก์ชัน สตราวาล()- ในนิพจน์ที่จำเป็นต้องมีสตริง การแปลงจะเกิดขึ้นโดยอัตโนมัติ เสียงสะท้อนหรือ สิ่งนี้จะเกิดขึ้นเมื่อคุณใช้ฟังก์ชันพิมพ์ หรือเมื่อเปรียบเทียบค่าของตัวแปรกับสตริง การอ่านส่วนประเภทและการจัดการประเภทของคู่มือจะทำให้สิ่งต่อไปนี้ชัดเจนยิ่งขึ้น ดูเพิ่มเติม.
อาร์เรย์จะถูกแปลงเป็นสตริงเสมอ "อาร์เรย์"ดังนั้นคุณจึงไม่สามารถแสดงเนื้อหาของอาร์เรย์ได้ ( อาร์เรย์), โดยใช้ เสียงสะท้อนหรือ สิ่งนี้จะเกิดขึ้นเมื่อคุณใช้ฟังก์ชันเพื่อดูว่ามีอะไรอยู่บ้าง หากต้องการดูองค์ประกอบเดียว ให้ใช้สิ่งที่ต้องการ เสียงสะท้อน $arr["foo"]- ดูคำแนะนำด้านล่างเกี่ยวกับวิธีการแสดง/ดูเนื้อหาทั้งหมด
ในการแปลงตัวแปรประเภท "วัตถุ"ในประเภท เชือกใช้เมธอดเวทย์มนตร์ __toString
ความหมาย โมฆะจะถูกแปลงเป็นสตริงว่างเสมอ
ดังที่คุณเห็นข้างต้น การแปลงอาร์เรย์ วัตถุ หรือทรัพยากรโดยตรงเป็นสตริงไม่ได้ให้ข้อมูลที่เป็นประโยชน์เกี่ยวกับค่าอื่นนอกเหนือจากประเภท วิธีที่ดีกว่าในการส่งออกค่าสำหรับการดีบักคือการใช้ฟังก์ชันและ พิมพ์_r().
var_dump() ค่าส่วนใหญ่ใน PHP สามารถแปลงเป็นสตริงสำหรับจัดเก็บข้อมูลถาวรได้ วิธีการนี้เรียกว่าการทำให้เป็นอนุกรม และสามารถทำได้โดยใช้ฟังก์ชัน.
ทำให้เป็นอนุกรม()
การแปลงสตริงให้เป็นตัวเลข
ถ้าสตริงได้รับการยอมรับว่าเป็นค่าตัวเลข ค่าผลลัพธ์และประเภทจะถูกกำหนดดังนี้ หากสตริงไม่มีอักขระใดๆ ".", "e" หรือ "E" และค่าของตัวเลขอยู่ในช่วงจำนวนเต็ม (กำหนดไว้ PHP_INT_MAX ) สตริงจะถูกรับรู้เป็นจำนวนเต็ม (จำนวนเต็ม - ในกรณีอื่นๆ ทั้งหมดจะถือเป็นจำนวนจุดลอยตัว ().
ลอย
ค่าถูกกำหนดโดยจุดเริ่มต้นของสตริง หากบรรทัดขึ้นต้นด้วยค่าตัวเลขที่ถูกต้อง ระบบจะใช้ค่านั้น มิฉะนั้นค่าจะเป็น 0 (ศูนย์) ค่าตัวเลขที่ถูกต้องคือตัวเลขตั้งแต่หนึ่งหลักขึ้นไป (ซึ่งอาจมีจุดทศนิยม) โดยอาจนำหน้าด้วยเครื่องหมาย ตามด้วยเลขชี้กำลังที่เป็นทางเลือก เลขชี้กำลังคือ "e" หรือ "E" ตามด้วยตัวเลขหนึ่งหลักขึ้นไป $foo = 1 + "10.5" ;
// $foo เป็นแบบลอยตัว (11.5) $foo = 1 + "-1.3e3" ;
// $foo เป็นแบบลอยตัว (-1299)
$foo = 1 + "บ๊อบ-1.3e3" ; // $foo เป็นจำนวนเต็ม (1)
$foo = 1 + "บ๊อบ3" ; // $foo เป็นจำนวนเต็ม (1) $foo = 1 + "หมูตัวเล็ก 10 ตัว" ;
// $foo เป็นจำนวนเต็ม (11) $foo = 4 + "10.2 ลูกหมูน้อย" ;
// $foo เป็นแบบลอยตัว (14.2)
$foo = "10.0 สุกร " + 1 ; // $foo ลอย (11)
?>
$foo = "10.0 สุกร " + 1.0 ; // $foo ลอย (11)
สำหรับข้อมูลเพิ่มเติมเกี่ยวกับการแปลงนี้ โปรดดูหัวข้อ strtod(3) ในเอกสารประกอบ Unix
หากคุณต้องการทดสอบตัวอย่างใดๆ ในส่วนนี้ ให้คัดลอกและวางและบรรทัดต่อไปนี้เพื่อดูว่าเกิดอะไรขึ้น:
echo "\$foo== $foo ; พิมพ์: " gettype ($foo) . -
?>
อย่าคาดหวังว่าจะได้รับโค้ดของอักขระโดยการแปลงเป็นจำนวนเต็ม (ดังที่ทำเสร็จแล้ว เช่น ใน C) หากต้องการแปลงอักขระเป็นรหัส ASCII และย้อนกลับ ให้ใช้ฟังก์ชัน ลำดับ()และ ch().
รายละเอียดการใช้งานประเภทสตริง
7 ปีที่แล้ว
เอกสารไม่ได้กล่าวถึง แต่อัฒภาคปิดที่ส่วนท้ายของเอกสารนี้จริงๆ แล้วถูกตีความว่าเป็นอัฒภาคจริง และด้วยเหตุนี้ บางครั้งจึงนำไปสู่ข้อผิดพลาดทางไวยากรณ์
$ฟู =<<
จบ;
?>
สิ่งนี้ไม่ได้:
ฟู (<<
จบ;
);
// ข้อผิดพลาดทางไวยากรณ์, ไม่คาดคิด ";"
?>
หากไม่มีเครื่องหมายอัฒภาคก็จะทำงานได้ดี:
ฟู (<<
จบ
);
?>
3 ปีที่ผ่านมา
คุณสามารถใช้สตริงเหมือนอาร์เรย์ของถ่าน (เช่น C)
$a = "การทดสอบอาร์เรย์สตริง";
var_dump($a);
// ส่งคืนสตริง (17) "การทดสอบอาร์เรย์สตริง"
var_dump($a);
// กลับสตริง (1) "S"
// -- ด้วยการส่งอาร์เรย์ --
var_dump((อาร์เรย์) $a);
// ส่งคืนอาร์เรย์ (1) ( => string (17) "การทดสอบอาร์เรย์สตริง")
var_dump((อาร์เรย์) $a);
// กลับสตริง (17) "S"
โนริฮิโอริ
1 ปีที่ผ่านมา
นิพจน์เดี่ยวใดๆ แม้จะซับซ้อนก็ตาม ที่ขึ้นต้นด้วย $ (เช่น ตัวแปร) สามารถฝัง () ไว้ในสตริงที่มีเครื่องหมายคำพูดคู่ได้:
Echo "การแสดงออก ( $h -> q ()[ "x)" ]-> p (9 == 0 ? 17 : 42 )) ได้รับการแยกวิเคราะห์เช่นเดียวกับ "- $h -> q ()[ "x)" ]-> p (9 == 0 ? 17 : 42 ) "ทำ." -
?>
2 ปีที่แล้ว
ทั้งสองควรจะทำงาน :(
การทดสอบในชั้นเรียน (
สาธารณะคงที่ $VAR = "คงที่" ;
สาธารณะ const VAR = "const" ;
ฟังก์ชั่นสาธารณะ sayHelloStatic() (
echo "สวัสดี: ( $this :: $VAR ) " ;
}
ฟังก์ชั่นสาธารณะ sayHelloConst() (
echo "สวัสดี: ( $this ::VAR) " ; //ข้อผิดพลาดในการแยกวิเคราะห์: ข้อผิดพลาดทางไวยากรณ์, ไม่คาดคิด ")", กำลังคาดหวัง "["
}
}
$obj = การทดสอบใหม่();
$obj -> sayHelloStatic();
$obj -> พูด HelloConst ();
14 ปีที่แล้ว
คุณสามารถใช้ไวยากรณ์ที่ซับซ้อนเพื่อใส่ค่าของทั้งคุณสมบัติของวัตถุและวิธีการของวัตถุภายในสตริง ตัวอย่างเช่น...
ระดับทดสอบ{
สาธารณะ$หนึ่ง=
1
;
งานสาธารณะสอง() {
กลับ2
;
}
}
$ทดสอบ= ใหม่ทดสอบ();
เสียงสะท้อน"ฟู{
$ทดสอบ->
หนึ่ง}
บาร์{
$ทดสอบ->
สอง()}
"
;
?>
จะส่งออก "foo 1 bar 2"
อย่างไรก็ตาม คุณไม่สามารถทำเช่นนี้กับทุกค่าในเนมสเปซของคุณได้ ค่าคงที่คลาสและคุณสมบัติ/วิธีการคงที่จะไม่ทำงานเนื่องจากไวยากรณ์ที่ซับซ้อนค้นหา "$"
ระดับทดสอบ{
ค่าคงที่หนึ่ง=
1
;
}
เสียงสะท้อน"แถบ foo (ทดสอบ::ONE)";
?>
สิ่งนี้จะส่งออก "foo (Test::one) bar" คุณสมบัติค่าคงที่และคงที่ต้องการให้คุณแยกสตริงออก
6 ปีที่แล้ว
ศูนย์นำหน้าในสตริง (แปลกใจน้อยที่สุด) ไม่ถือเป็นฐานแปด
พิจารณา:
$x = "0123" + 0;
$y = 0123 + 0;
echo "x คือ $x, y คือ $y"; // พิมพ์ "x คือ 123, y คือ 83"
กล่าวอีกนัยหนึ่ง:
* ศูนย์นำหน้าในตัวอักษรตัวเลขในซอร์สโค้ดจะตีความว่าเป็น "ฐานแปด" c.f. สตรอทอล()
* ศูนย์นำหน้าในสตริง (เช่น ข้อมูลที่ผู้ใช้ส่ง) เมื่อแปลง (โดยนัยหรือชัดเจน) เป็นจำนวนเต็มจะถูกละเว้น และถือเป็นทศนิยม c.f. สเตรท็อด()
3 ปีที่ผ่านมา
ระวังว่าสอดคล้องกับ "การแปลงสตริงเป็นตัวเลข":
ถ้า ("123เอบีซี"==
123
) เสียงก้อง"(intstr == int) ทดสอบไม่ถูกต้องว่าเป็นจริง";
// เนื่องจากด้านหนึ่งเป็นตัวเลข สตริงจึงถูกแปลงจาก intstr เป็น int อย่างไม่ถูกต้อง ซึ่งจะตรงกับหมายเลขทดสอบ // เป็นจริงสำหรับทุกเงื่อนไข เช่น คำสั่ง if และ switch (อาจเป็น while ลูปด้วย)! // นี่อาจเป็นความเสี่ยงด้านความปลอดภัยอย่างมากเมื่อทำการทดสอบ/ใช้งาน/บันทึกอินพุตของผู้ใช้ ในขณะที่คาดหวังและทดสอบเพียงจำนวนเต็มเท่านั้น // ดูเหมือนว่าทางแก้ไขเดียวคือให้ 123 เป็นสตริงเป็น "123" ดังนั้นจึงไม่มีการแปลงเกิดขึ้น
?>
10 ปีที่แล้ว ต่อไปนี้เป็นเคล็ดลับง่ายๆ ที่จะอนุญาตให้สตริงที่มีเครื่องหมายคำพูดคู่และเอกสาร Heredocs มีนิพจน์ที่กำหนดเองในไวยากรณ์วงเล็บปีกกา รวมถึงค่าคงที่และการเรียกใช้ฟังก์ชันอื่นๆ:
// ประกาศแฮ็ก
//สนามเด็กเล่นของเรา
$ก=
3
; การทำงาน ค($ก,
$ข) (กลับ$ก+
$ข; }
//การใช้งาน // ไวยากรณ์ทั่วไปคือ ($_expr(...)) 11 ปีที่แล้ว เพื่อรักษาจิตใจของคุณ อย่าอ่านความคิดเห็นก่อนหน้าเกี่ยวกับวันที่ ;) เมื่อทั้งสองสายสามารถแปลงเป็นตัวเลขได้ (ในการทดสอบ ("$a"> "$b") จากนั้นจะใช้ตัวเลขที่เป็นผลลัพธ์ มิฉะนั้น สตริงทั้งหมดจะถูกเปรียบเทียบแบบอักขระต่ออักขระ: var_dump("1.22"
>
"01.23"
);
//บูล(เท็จ) 2 ปีที่แล้ว ฉันคิดว่าการเพิ่มความคิดเห็นนี้จะเป็นประโยชน์เพื่อให้ข้อมูลอย่างน้อยปรากฏบนหน้าขวาของไซต์ PHP โปรดทราบว่าหากคุณต้องการใช้สตริงที่มีเครื่องหมายคำพูดคู่กับคีย์ที่เชื่อมโยง คุณอาจพบข้อผิดพลาด T_ENCAPSED_AND_WHITESPACE บางคนถือว่านี่เป็นหนึ่งในข้อความแสดงข้อผิดพลาดที่ชัดเจนน้อยกว่า การแสดงออกเช่น: $ผลไม้=อาร์เรย์( พิมพ์ “นี่คือก$ผลไม้[
"ก"]";
// T_ENCAPSED_AND_WHITESPACE คุณสามารถแก้ไขได้ดังนี้: สิ่งนี้จะเกิดขึ้นเมื่อคุณใช้ฟังก์ชัน“นี่คือก$ผลไม้[
ก]
"
;
// ยกเลิกเครื่องหมายคำพูดที่สำคัญ ยังไม่ชัดเจน (สำหรับฉันอย่างน้อย) ทำไม PHP ตีความเครื่องหมายคำพูดเดี่ยวในนิพจน์ผิด แต่ฉันคิดว่ามันมีบางอย่างที่เกี่ยวข้องกับข้อเท็จจริงที่ว่าเครื่องหมายคำพูดไม่ได้เป็นส่วนหนึ่งของสตริงค่า - เมื่อสตริงถูกแยกวิเคราะห์เครื่องหมายคำพูดแล้ว ขวางทาง... ? สำหรับการแก้ไขสตริง จากคู่มือ: มันไม่ได้เรียกว่าซับซ้อนเนื่องจากไวยากรณ์มีความซับซ้อนดังนั้นจึงอนุญาตให้มีการแสดงออกที่ซับซ้อนได้ ตัวแปรสเกลาร์ องค์ประกอบอาร์เรย์ หรือคุณสมบัติของอ็อบเจ็กต์ใดๆ ที่มีการแทนค่าสตริงสามารถรวมผ่านไวยากรณ์นี้ได้ เพียงเขียนนิพจน์เหมือนที่คุณทำนอกสตริง จากนั้นล้อมด้วย ( และ ) เนื่องจาก ( ไม่สามารถหลีกได้ ไวยากรณ์นี้จะรับรู้ได้ก็ต่อเมื่อ $ ตามหลัง ( . ใช้ (\$ เพื่อรับค่าตามตัวอักษร ($ . ตัวอย่างบางส่วนเพื่อให้ชัดเจน:
width)กว้าง 00 เซนติเมตร"; // ใช้งานได้, คีย์ที่ยกมาใช้งานได้โดยใช้ไวยากรณ์วงเล็บปีกกาเท่านั้น echo "ใช้งานได้: ($arr["key"])"; // ใช้งานได้ echo "ใช้งานได้: ($arr)" ; // สิ่งนี้ผิดด้วยเหตุผลเดียวกับที่ $foo ผิดนอกสตริง // กล่าวอีกนัยหนึ่ง มันจะยังคงใช้งานได้ แต่เพียงเพราะว่า PHP ค้นหา // ค่าคงที่ที่ไม่ได้กำหนดไว้ก่อน) จะเป็น / / Thrown. echo "นี่มันผิด: ($arr)"; arr["foo"])"; // ได้ผล echo "สิ่งนี้ได้ผล: " . $arr["foo"]; echo "นี่ก็ใช้ได้เช่นกัน: ( $obj->values->name)"; echo "นี่คือค่าของ var ที่ชื่อ $name: ($($name))"; echo "นี่คือค่าของ var ที่ตั้งชื่อตามค่าที่ส่งคืนของ getName( ): ($(getName()))"; echo "นี่คือค่าของ var ที่ตั้งชื่อตามค่าที่ส่งคืนของ \$object->getName(): ($($object->getName()))"; // ใช้งานไม่ได้ เอาต์พุต: นี่คือค่าตอบแทนของ getName(): (getName()) echo "นี่คือค่าตอบแทนของ getName(): (getName())"; - บ่อยครั้งไม่จำเป็นต้องใช้ไวยากรณ์นี้ ตัวอย่างเช่น: $a = "เอบีซีดี"; $ออก = "$a $a"; // "abcd abcd"; มีพฤติกรรมเช่นนี้: $ออก = "($a) ($a)"; // เดียวกัน จึงไม่จำเป็นต้องมีเหล็กดัดฟัน แต่สิ่งนี้: $ออก = "$aefgh"; จะใช้งานไม่ได้หรือสร้างข้อผิดพลาดขึ้นอยู่กับระดับข้อผิดพลาดของคุณเนื่องจากไม่มีตัวแปรชื่อ $aefgh ดังนั้นคุณต้องทำ: $ออก = "$(a)efgh"; // หรือ $out = "($a)efgh"; สวัสดีโปรแกรมเมอร์มือใหม่ที่รัก เรามาศึกษาองค์ประกอบที่ประกอบกันต่อไป ในบทความนี้ เราจะมาเรียนรู้ว่า php Operator คืออะไร อันที่จริงเราคุ้นเคยกับบางคนมาตั้งแต่เด็ก แต่เรารู้จักพวกเขาเพียงสัญญาณเท่านั้น (+, -, =, !, ?) ใน php พวกเขาทั้งหมดเรียกว่าตัวดำเนินการซึ่งค่อนข้างสมเหตุสมผลเนื่องจากพวกมันทำการกระทำหรือการดำเนินการเฉพาะ คุณยังสามารถพูดได้ว่าอักขระที่พิมพ์ได้ทั้งหมดที่ไม่ใช่ตัวอักษรหรือตัวเลขเป็นตัวดำเนินการใน PHP แต่นั่นไม่ใช่ทั้งหมด เนื่องจากมีตัวดำเนินการที่ประกอบด้วยตัวอักษร มาเริ่มกันตามลำดับ ตัวดำเนินการทางคณิตศาสตร์ใช้ในการดำเนินการกับตัวเลข + เป็นตัวดำเนินการบวก เมื่อเขียน มักจะเว้นวรรคก่อนและหลังตัวดำเนินการ สิ่งนี้ทำเพื่อความสะดวกในการอ่านโค้ดเท่านั้น แม้ว่าช่องว่างนี้จะไม่ส่งผลกระทบใดๆ และคุณสามารถทำได้โดยไม่ต้องใช้มันหากต้องการ นิพจน์ที่ซับซ้อนประกอบขึ้นตามกฎที่ยอมรับกันในวิชาเลขคณิต กล่าวคือ การคูณและการหารจะมีลำดับความสำคัญมากกว่าการบวกและการลบ และเมื่อมีทั้งสองนิพจน์อยู่ในนิพจน์ นิพจน์หลังจะอยู่ในวงเล็บ เสียงก้อง (6 + 7 ) * (7 + 8 ); // 195 เมื่อทำการหารจำนวนเต็มด้วยจำนวนเต็ม ในกรณีที่ได้เศษเหลือ ผลลัพธ์จะถูกแปลงเป็นจำนวนจริงโดยอัตโนมัติ (จำนวนจุดลอยตัว) เสียงก้อง 8/3 ; //2.66666666666 จำนวนหลักที่พิมพ์เป็นเศษส่วนจะขึ้นอยู่กับค่าที่ตั้งไว้ในคำสั่งความแม่นยำที่พบในไฟล์ php.ini โดยปกติจะเป็น 12 ตัวอักษรไม่นับจุด ตัวดำเนินการ % มักใช้เพื่อพิจารณาว่าตัวเลขหนึ่งหารด้วยอีกจำนวนหนึ่งลงตัวโดยไม่มีเศษหรือไม่ เสียงสะท้อน 53328 % 4 ;//0 การดำเนินการกับตัวดำเนินการทางคณิตศาสตร์ ยกเว้นการเพิ่มขึ้นและการลดลง จะถูกเรียก ไบนารี่เนื่องจากเกี่ยวข้องกับตัวถูกดำเนินการสองตัว (เทอม + เทอม เงินปันผล / ตัวหาร ฯลฯ) เรียกว่าการดำเนินการของการเพิ่มขึ้นและการลดลงเอกนารี เนื่องจากเกี่ยวข้องกับตัวถูกดำเนินการตัวเดียว ยังมีอีกมาก การดำเนินการตามเงื่อนไข ซึ่งเกี่ยวข้องกับตัวถูกดำเนินการสามตัว จำนวนเต็มชนิดตัวแปร (จำนวนเต็ม) $ถัดไป = 3 ; // 4 สตริงประเภทตัวแปร สะท้อน $ ถัดไป; // Abd & - การเชื่อมต่อระดับบิต และ (และ); มีโอกาสค่อนข้างมากที่คุณจะพบกับโอเปอเรเตอร์เหล่านี้ เนื่องจากข้อมูลไบนารี่มีการใช้กันอย่างแพร่หลายในการพัฒนาโปรแกรมคอมพิวเตอร์กราฟิก แต่หากต้องการศึกษาสิ่งเหล่านี้ หากมีใครต้องการ พวกเขาก็จะต้องเรียนหลักสูตรแยกต่างหากในแหล่งข้อมูลอื่น ตัวดำเนินการเปรียบเทียบคือตัวดำเนินการเชิงตรรกะและใช้ในการเปรียบเทียบตัวแปร ไม่สามารถเปรียบเทียบอาร์เรย์และวัตถุได้โดยใช้สิ่งเหล่านี้ > - ตัวดำเนินการมากกว่า; จากผลของการเปรียบเทียบ จะมีรายการใดรายการหนึ่งแสดงบนหน้าจอซึ่งสอดคล้องกับความจริง (จริง) หรือสตริงว่างซึ่งสอดคล้องกับเท็จ (เท็จ) เสียงสะท้อน 1 > 0 ; // 1 // 1 ดังนั้นตัวดำเนินการเปรียบเทียบจึงแทบจะไม่เคยใช้เลย วัตถุประสงค์หลักคือเพื่อทำงานร่วมกับคำสั่ง if ถ้า ($ต่อไป $nexT = "ความชื้นในอากาศ 90%"; ถ้า ($ต่อไป สะท้อน "โอกาสที่ฝนจะตก"; อื่น สะท้อน "ฝน"; คำสั่ง if สามารถมีบล็อก elseif ได้มากเท่าที่คุณต้องการ แต่จะมีคำสั่งอื่นได้เพียงคำสั่งเดียวเท่านั้น อนุญาตให้ใช้ตัวเลือกการบันทึกอื่น - โดยไม่ต้องใช้เครื่องหมายปีกกา ในกรณีนี้ บรรทัดของคำสั่ง if, else, elseif จะลงท้ายด้วยเครื่องหมายโคลอน และโครงสร้างทั้งหมดจะลงท้ายด้วยคีย์เวิร์ด (ตัวดำเนินการ) endif $next = "ความชื้นในอากาศ 50%"; บ่อยครั้งมีความจำเป็นต้องตั้งค่ามากกว่าสองเงื่อนไข จากนั้นเพื่อตรวจสอบตามลำดับ จะใช้ตัวดำเนินการ elseif elseif ($ถัดไป >= $nexT): elseif ($ถัดไป elseif ($ ถัดไป == $ ถัดไป): elseif ($ถัดไป >= $nexT) อื่น: ถ้า ($ ถัดไป > $ ถัดไป) ตัวดำเนินการเชิงตรรกะจะคล้ายกับตัวดำเนินการระดับบิต ข้อแตกต่างระหว่างทั้งสองคือแบบแรกทำงานด้วยตัวแปรลอจิคัล และแบบหลังทำงานด้วยตัวเลข ตัวดำเนินการเชิงตรรกะจะใช้ในกรณีที่คุณจำเป็นต้องรวมเงื่อนไขหลายข้อ ซึ่งจะลดจำนวนคำสั่ง if ซึ่งจะช่วยลดโอกาสที่จะเกิดข้อผิดพลาดในโค้ด && - เชื่อมต่อร่วมและ; ลำดับความสำคัญต่ำกว่าหมายความว่า หากมีตัวดำเนินการทั้งสองตัว ตัวดำเนินการที่มีลำดับความสำคัญสูงกว่าจะถูกดำเนินการก่อน ในอนาคต เราจะอาศัยตัวดำเนินการเชิงตรรกะโดยละเอียดมากขึ้นโดยใช้ตัวอย่างของสคริปต์ที่ซับซ้อนมากขึ้น ตัวดำเนินการมอบหมาย = กำหนดค่าของตัวถูกดำเนินการทางขวาให้กับตัวถูกดำเนินการทางซ้าย $ถัดไป = "สวัสดี" ตัวดำเนินการจุดแยกส่วนจำนวนเต็มของตัวเลขออกจากส่วนที่เป็นเศษส่วน และรวมสตริงหลายตัวและตัวเลขให้เป็นสตริงเดียวทั้งหมด $ ถัดไป = 22 ; เช่นเดียวกับในทางคณิตศาสตร์ ตัวดำเนินการในวงเล็บจะให้ความสำคัญกับการกระทำที่อยู่ในวงเล็บ ข้อมูลที่อยู่ในวงเล็บจะถูกดำเนินการก่อน จากนั้นจึงดำเนินการส่วนที่เหลือทั้งหมด มีสามวิธีหรือสไตล์ในการวางเครื่องหมายปีกกาใน PHP 1. รูปแบบ BSD - วงเล็บจัดชิดซ้าย ถ้า ($ ถัดไป) 2. สไตล์ GNU - วงเล็บจะเยื้องจากขอบด้านซ้าย ถ้า ($ ถัดไป) 3. รูปแบบ K&R - วงเล็บเปิดบนบรรทัดตัวดำเนินการ ถ้า ($ถัดไป)( ตั้งแต่เริ่มต้นคุณจะต้องเลือกสไตล์ใดสไตล์หนึ่งและในอนาคตเมื่อเขียนสคริปต์ให้ใช้เฉพาะสไตล์นั้นเท่านั้น ยิ่งกว่านั้นไม่สำคัญเลยว่าคุณชอบสไตล์ไหน สิ่งสำคัญคือต้องมีความสม่ำเสมอตลอดโปรแกรม ฉันคิดว่าตอนนี้ก็เพียงพอแล้ว โดยหลักการแล้ว ไม่เพียงแต่สัญญาณเท่านั้น แต่ยังรวมถึงฟังก์ชันและองค์ประกอบอื่น ๆ ที่เป็นตัวดำเนินการได้ ดังนั้นจึงเป็นเรื่องยากมากที่จะแสดงรายการทั้งหมด และไม่มีประเด็นใด ๆ ก็เพียงพอแล้วที่จะมีแนวคิดพื้นฐานพื้นฐาน และเราจะวิเคราะห์ส่วนที่เหลือโดยใช้ตัวอย่างเชิงปฏิบัติ ชาวไอริชคนหนึ่งเดินไปรอบๆ สนามบินเชเรเมเทียโวทั้งน้ำตา พนักงานคนหนึ่งตัดสินใจแสดงความเห็นอกเห็นใจ:
การทำงาน_อธิบาย($v) (กลับ$v; }
$_อธิบาย=
"_expr";
กำหนด("คิว",
"อสด์");
กำหนด("zxc",
5
);
$ข=
4
;
เสียงสะท้อน"ก่อน{
$_อธิบาย(1
+
2
)}
โพสต์\n";
// ส่งออก "โพสต์ก่อนหน้า 3"
เสียงสะท้อน"ก่อน{
$_อธิบาย(คิว)}
โพสต์\n";
// ส่งออก "pre asd post"
เสียงสะท้อน"ก่อน{
$_อธิบาย(ค($ก,
$ข)+
zxc*
2
)}
โพสต์\n";
// ส่งออก "โพสต์ก่อน 17"
?>
var_dump("1.22.00"
>
"01.23.00"
);
//บูล(จริง)
var_dump("1-22-00"
>
"01-23-00"
);
//บูล(จริง)
var_dump((ลอย)"1.22.00"
> (ลอย)"01.23.00"
);
//บูล(เท็จ)
?>
"ก"=>
"แอปเปิล",
"ข"=>
"กล้วย",
//ฯลฯ
);
?>
คงแตกเป็นเสี่ยงๆแน่
สิ่งนี้จะเกิดขึ้นเมื่อคุณใช้ฟังก์ชัน“นี่คือก${
ผลไม้[
"ก"]}
"
;
// ไวยากรณ์ที่ซับซ้อน
สิ่งนี้จะเกิดขึ้นเมื่อคุณใช้ฟังก์ชัน“นี่คือก{
$ผลไม้[
"ก"]}
"
;
// รูปแบบไวยากรณ์ที่ซับซ้อน
?>
ฉันมีความชอบส่วนตัวสำหรับรูปแบบสุดท้ายเนื่องจากเป็นธรรมชาติมากกว่าและใกล้เคียงกับการแสดงออกภายนอกสตริงมากขึ้น
ไวยากรณ์ที่ซับซ้อน (หยิก)
ตัวดำเนินการทางคณิตศาสตร์
— — ตัวดำเนินการลบ;
/ - ผู้ดำเนินการแผนก;
* — ตัวดำเนินการคูณ;
% เป็นตัวดำเนินการหาส่วนที่เหลือระหว่างการหาร
++ — ตัวดำเนินการสำหรับการเพิ่มขึ้นหนึ่ง (เพิ่มขึ้น);
— — — ลดลงหนึ่งตัวดำเนินการ (ลดลง)
?>
?>
?>
ตัวดำเนินการการเพิ่มขึ้น (++) และการลด (- -) ใช้กับตัวแปรเท่านั้น
?>
เสียงสะท้อน +$ถัดไป;
?>
$ถัดไป = "เอบีซี";
~ — การปฏิเสธระดับบิต (ไม่ใช่);
- — สหภาพระดับบิต หรือ (หรือ);
^ — ระดับบิตหรือ (xor);
<<
— сдвиг влево битового значения операнда;
>> — เลื่อนไปทางขวาตามค่าบิตของตัวถูกดำเนินการตัวดำเนินการเปรียบเทียบ
=> - ตัวดำเนินการมากกว่าหรือเท่ากับ;
<
— оператор меньше;
<=
— оператор меньше или равно;
== — ตัวดำเนินการความเท่าเทียมกัน;
!= — ตัวดำเนินการอสมการ;
=== — ตัวดำเนินการสมมูล (ค่าและประเภทของตัวแปรเท่ากัน)
!== — ตัวดำเนินการที่ไม่เทียบเท่า;
// 1<
0
;
// пустая строка
เสียงสะท้อน 1
เสียงก้อง 1 => 0 ;
?>
เสียงก้อง 1 == 1 ;
คำสั่งแบบมีเงื่อนไข if, else, elseif< $nexT)
{
ตัวดำเนินการแบบมีเงื่อนไขถูกเรียกเช่นนี้เนื่องจากได้รับการออกแบบมาเพื่อทดสอบสภาวะบางอย่าง ขึ้นอยู่กับว่าการกระทำใดถูกดำเนินการ คำสั่ง if รับตัวแปรบูลีนหรือนิพจน์เป็นอาร์กิวเมนต์ หากเงื่อนไขเป็นจริง ผลลัพธ์จะแสดงขึ้น หากไม่เป็นจริง จะแสดงบรรทัดว่าง
}
?>
สะท้อน "โอกาสที่ฝนจะตก";
// สามารถตกตะกอนเอาท์พุตได้
{
ตัวดำเนินการแบบมีเงื่อนไขถูกเรียกเช่นนี้เนื่องจากได้รับการออกแบบมาเพื่อทดสอบสภาวะบางอย่าง ขึ้นอยู่กับว่าการกระทำใดถูกดำเนินการ $next = "ความชื้นในอากาศ 80%";
}
?>
สะท้อน "โอกาสที่ฝนจะตก";
// สามารถตกตะกอนเอาท์พุตได้
{
ถ้า ($ ถัดไป > $ ถัดไป)
}
// พิมพ์บรรทัดว่าง
{
หากโปรแกรมจำเป็นต้องระบุสองการกระทำ โดยอย่างหนึ่งจะดำเนินการหากค่าเป็นจริง และอีกอย่างหนึ่งหากค่าเป็นเท็จ จากนั้นจะใช้คำสั่ง else ร่วมกับคำสั่ง if ร่วมกับคำสั่ง if
}
?>
// สามารถตกตะกอนเอาท์พุตได้
{
echo "คาดว่าจะไม่มีฝนตก";
}
ในกรณีนี้ "ไม่คาดว่าจะมีฝนตก" จะปรากฏขึ้น และหากในนิพจน์คุณเปลี่ยนเครื่องหมาย "มากกว่า" เป็น "น้อยกว่า" ก็จะแสดง "อาจมีฝนตก" นี่คือวิธีที่ตัวดำเนินการแบบมีเงื่อนไขตรวจสอบเงื่อนไขและแสดงผลลัพธ์ที่ถูกต้องตามนั้น<= $nexT)
{
บ่อยครั้งมีความจำเป็นต้องตั้งค่ามากกว่าสองเงื่อนไข จากนั้นเพื่อตรวจสอบตามลำดับ จะใช้ตัวดำเนินการ elseif
}
สะท้อน "ฉันเห็น";
{
elseif ($ถัดไป
}
สะท้อน "หิมะ";
{
elseif ($ถัดไป >= $nexT)
}
// พิมพ์บรรทัดว่าง
{
ถ้า ($ ถัดไป > $ ถัดไป)
}
?>
$nexT = "ความชื้นในอากาศ 60%";
คำสั่งแบบมีเงื่อนไข if, else, elseif<= $nexT):
สิ้นสุด;
?>
ตัวดำเนินการเชิงตรรกะ
และ - และด้วย แต่มีลำดับความสำคัญต่ำกว่า
- - แยกร่วมหรือ;
หรือ - เช่นกัน OR แต่มีลำดับความสำคัญต่ำกว่า
xor - เอกสิทธิ์หรือ;
- - การปฏิเสธ;ผู้ดำเนินการมอบหมาย
ก้อง "สวัสดี" // สวัสดี
?>
ตัวดำเนินการจุด
สะท้อน "วันนี้หลังจาก" .$next "คาดว่าจะมีน้ำค้างแข็ง"; // วันนี้หลัง 22 คาดว่าจะมีน้ำค้างแข็ง
?>
ตัวดำเนินการวงเล็บ
ผู้ดำเนินการจัดฟันแบบหยิก
{
}
{
echo “สวัสดีโปรแกรมเมอร์มือใหม่ที่รัก”;
}
echo “สวัสดีโปรแกรมเมอร์มือใหม่ที่รัก”;
}
— คุณคิดถึงบ้านเกิดของคุณหรือไม่?
- ไม่เลย. ฉันเพิ่งสูญเสียกระเป๋าเดินทางทั้งหมดของฉัน
- สิ่งนี้เกิดขึ้นได้อย่างไร?
- ฉันไม่เข้าใจตัวเอง ดูเหมือนว่าฉันเสียบปลั๊กอย่างถูกต้อง