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

คำพูดเดี่ยว

วิธีที่ง่ายที่สุดในการกำหนดสตริงคือการใส่ข้อความด้วยเครื่องหมายคำพูดเดี่ยว

หากเราจำเป็นต้องใช้เครื่องหมายคำพูดเดี่ยวในข้อความ เราจำเป็นต้องหลีกเลี่ยงเครื่องหมายดังกล่าวด้วยเครื่องหมายทับ (\)

ลำดับหลีกภายในเครื่องหมายคำพูดเดียวใช้ไม่ได้

ตัวอย่างการใช้เครื่องหมายคำพูดเดี่ยว:

เครื่องหมายคำพูดคู่

หากคุณเน้นข้อความด้วยเครื่องหมายคำพูดคู่ สตริงจะถูกกำหนดในลักษณะเดียวกับเครื่องหมายคำพูดเดี่ยว แต่แน่นอนว่ามีความแตกต่างระหว่างคำพูด

สถานการณ์ที่มีเครื่องหมายคำพูด Escape จะเหมือนกับสถานการณ์ที่มีเครื่องหมายคำพูดเดี่ยว

สตริงที่อยู่ในเครื่องหมายคำพูดคู่จะจดจำลำดับการหลีกเลี่ยงส่วนใหญ่สำหรับอักขระพิเศษ

ความแตกต่างที่สำคัญที่สุดคือความจริงที่ว่าเครื่องหมายคำพูดคู่จัดการกับตัวแปร

ตัวอย่างการใช้เครื่องหมายคำพูดคู่:

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

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

การคำนวณ

บนเว็บไซต์ ProfiPHP ฉันพบการคำนวณที่น่าสนใจ หัวข้อนี้. ผู้เขียนเขียนสคริปต์ง่ายๆ ซึ่งเขาคำนวณเวลาในการประมวลผลสตริง

บทความสั้น ๆ นี้แสดงวิธีการใช้และตำแหน่ง คำพูดใน PHP.

เครื่องหมายคำพูดเดี่ยว (เครื่องหมายอะพอสทรอฟี) ใน PHP

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

// แก้ไขเสียงสะท้อน "ชีวิตเป็นอย่างไรบ้าง"; echo "ชีวิตเป็นยังไงบ้าง? $name"; echo "ชีวิตเป็นอย่างไรบ้าง?".$name; // เสียงสะท้อนไม่ถูกต้อง "สบายดีไหม $name";

อักขระพิเศษในเครื่องหมายคำพูดเดี่ยวและคู่

เพื่อให้แน่ใจว่า ตัวอย่างเช่น อักขระแท็บ (\t) ถูกตีความเป็นอักขระแท็บแทนที่จะเป็นเครื่องหมายทับและตัวอักษร t คุณต้องล้อมบรรทัดข้อความที่มีอักขระแท็บด้วยเครื่องหมายคำพูดคู่ คุณสามารถใช้ \' และ \\ ในเครื่องหมายคำพูดเดี่ยวเท่านั้น ลำดับหลีกอื่นๆ ทั้งหมด (\n, \r, \$, ฯลฯ) จะไม่ได้รับอนุญาตภายในเครื่องหมายคำพูดเดี่ยว

// เสียงสะท้อนไม่ถูกต้อง "สบายดีไหม\n"; // แก้ไขเสียงก้อง "สบายดีไหม?\n";

หากต้องการหลีกเลี่ยงเครื่องหมายคำพูดคู่ภายในสตริง ให้วางเครื่องหมายคำพูดไว้หน้าเครื่องหมายแบ็กสแลช \"

// เสียงสะท้อนไม่ถูกต้อง "

ว่าไง?

"; // แก้ไขเสียงสะท้อน"

ว่าไง?

"; เอคโค่"

ว่าไง?

";

เครื่องหมายคำพูดคู่ใน PHP

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

$query = "แทรกลงในตาราง (โพสต์,ผู้เขียน,ข้อความ,วันที่) ค่า ("$id","$author","$text","$date"");

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

ฉันเพิ่งรู้ว่าในภาษา .NET หรือ C หากอยู่ในเครื่องหมายคำพูดเดี่ยว หมายความว่าเป็นอักขระ ไม่ใช่สตริง

สารละลาย

สิ่งที่คุณควรรู้

$a = "ชื่อ"; $b = "$a ของฉัน"; == "ชื่อของฉัน" $c = "$a ของฉัน"; != "ชื่อของฉัน"

ใน PHP ผู้คนใช้เครื่องหมายคำพูดเดี่ยวเพื่อกำหนดสตริงคงที่เช่น "a" , "ชื่อของฉัน" , "abc xyz" ในขณะที่ใช้เครื่องหมายคำพูดคู่เพื่อกำหนดสตริงที่มีตัวระบุเช่น "a $b $c $d"

และอีกอย่างก็คือ

ก้อง "ชื่อของฉัน";

เร็วกว่า

ก้อง "ชื่อของฉัน";

เอคโค่ "ของฉัน" . $a;

ช้ากว่า

สะท้อน "$ ของฉัน";

สิ่งนี้เป็นจริงสำหรับสตริงอื่นที่ใช้

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

$test = "ตัวแปร"; echo "สวัสดีคุณ $test"; // ผลลัพธ์จะเป็น: Hello Mr ตัวแปร echo "Hello Mr $test"; // ผลลัพธ์จะเป็น: สวัสดีคุณ $test

ในที่นี้เครื่องหมายคำพูดคู่จะแยกวิเคราะห์ค่าและเครื่องหมายคำพูดเดี่ยวจะถือเป็นค่าสตริง (โดยไม่ต้องแยกวิเคราะห์ตัวแปร $test)

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

วิธีที่ง่ายที่สุดในการกำหนดสตริงคือการใส่เครื่องหมายคำพูดเดี่ยว (สัญลักษณ์ " ).

หากต้องการใช้เครื่องหมายคำพูดเดี่ยวภายในสตริง ให้หลีกด้วยเครื่องหมายแบ็กสแลช ( \ ). หากคุณต้องการเขียนแบ็กสแลชเอง ให้ทำซ้ำ ( \\ ). การใช้แบ็กสแลชอื่นๆ ทั้งหมดจะถูกตีความว่าเป็นอักขระปกติ ซึ่งหมายความว่าหากคุณพยายามใช้ลำดับหลีกอื่นๆ เช่น \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}	ลำดับของอักขระที่สอดคล้องกับนิพจน์ทั่วไปของอักขระในระบบเลขฐานแปด
\x(1,2)	ลำดับของอักขระที่สอดคล้องกับนิพจน์ทั่วไปของอักขระในรูปแบบเลขฐานสิบหก

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

เฮริด็อก

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

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

ความสนใจ

เป็นสิ่งสำคัญมากที่จะต้องทราบว่าบรรทัดตัวระบุการปิดจะต้องไม่มีอักขระอื่นใดยกเว้นเครื่องหมายอัฒภาค ( ; ). ซึ่งหมายความว่ารหัส ไม่ควรเยื้องและต้องไม่มีช่องว่างหรือแท็บใดๆ ก่อนหรือหลังเครื่องหมายอัฒภาค สิ่งสำคัญคือต้องเข้าใจว่าอักขระตัวแรกก่อนตัวระบุการปิดต้องเป็นอักขระขึ้นบรรทัดใหม่ตามที่กำหนดโดยระบบปฏิบัติการของคุณ ตัวอย่างเช่น บนระบบ UNIX รวมถึง Mac OS X สิ่งนี้ \n. บรรทัดใหม่จะต้องเริ่มต้นทันทีหลังจากตัวระบุการปิด

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

Heredoc ไม่สามารถใช้ในการเริ่มต้นฟิลด์คลาสได้ เริ่มต้นจาก PHP 5.3 ข้อจำกัดนี้ใช้กับเอกสารที่มีตัวแปรเท่านั้น

ตัวอย่างที่ 1 ตัวอย่างที่ไม่ถูกต้อง

คลาสฟู(
สาธารณะ $bar =<<บาร์
อีโอที;
}
?>

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

ตัวอย่างที่ 2 ตัวอย่างการกำหนดสตริง heredoc

$str =<<ตัวอย่างบรรทัด
ครอบคลุมหลายบรรทัด
ใช้ไวยากรณ์ heredoc
อีโอดี;

คลาสฟู
{
var $foo ;
var $บาร์ ;

ฟังก์ชั่นฟู()
{
$นี่ -> ฟู = "ฟู" ;
$นี่ ->
}
}

$foo = ใหม่ foo();
$name = "ชื่อของฉัน" ;

เสียงสะท้อน<<ฉันชื่อ "$ชื่อ" ฉันพิมพ์ $foo -> foo .
ตอนนี้ฉันกำลังอนุมาน( $foo -> บาร์ [ 1 ]) .
สิ่งนี้ควรแสดงอักษรตัวใหญ่ "A": \x41
อีโอที;
?>

ฉันชื่อ "ชื่อของฉัน" ฉันพิมพ์ฟู ตอนนี้ฉันส่งออก Bar2 สิ่งนี้ควรแสดงอักษรตัวใหญ่ "A": A

นอกจากนี้ยังเป็นไปได้ที่จะใช้ไวยากรณ์ heredoc เพื่อส่งข้อมูลผ่านอาร์กิวเมนต์ของฟังก์ชัน:

ตั้งแต่เวอร์ชัน 5.3.0 เป็นไปได้ที่จะเริ่มต้นตัวแปรสแตติกและคุณสมบัติคลาส/ค่าคงที่โดยใช้ไวยากรณ์ Heredoc:

ตัวอย่าง #4 การใช้ Heredoc เพื่อเริ่มต้นตัวแปรคงที่

// ตัวแปรแบบคงที่
ฟังก์ชั่นฟู()
{
$บาร์คงที่ =<<ไม่มีอะไรที่นี่...
ฉลาก;
}

// คุณสมบัติคลาส/ค่าคงที่
คลาสฟู
{
const บาร์ =<<ตัวอย่างการใช้ค่าคงที่
ฟูบาร์;

สาธารณะ $baz =<<ตัวอย่างการใช้สนาม
ฟูบาร์;
}
?>

ใน PHP 5.3.0 คุณยังสามารถล้อมรอบตัวระบุ Heredoc ด้วยเครื่องหมายคำพูดคู่ได้:

โนว์ด็อก

Nowdoc จะเหมือนกันสำหรับสตริงที่มีเครื่องหมายคำพูดเดี่ยว ในขณะที่ Heredoc ใช้สำหรับสตริงที่มีเครื่องหมายคำพูดคู่ Nowdoc คล้ายกับ Heredoc แต่อยู่ข้างใน ไม่มีการทดแทน. การออกแบบนี้เหมาะสำหรับการฝังโค้ด PHP หรือบล็อกข้อความขนาดใหญ่อื่นๆ โดยไม่ต้องหลบหนี ในกรณีนี้จะคล้ายกับโครงสร้าง SGML เล็กน้อย โดยการประกาศบล็อกข้อความที่ไม่ได้ตั้งใจให้ประมวลผล

Nowdoc ถูกระบุด้วยลำดับเดียวกัน <<< ซึ่งใช้ใน heredoc แต่ตัวระบุต่อไปนี้อยู่ในเครื่องหมายคำพูดเดี่ยว เช่น <<<"EOT" . เงื่อนไขทั้งหมดที่ใช้กับตัวระบุ Heredoc ยังใช้กับ nowdoc ด้วย โดยเฉพาะเงื่อนไขที่ใช้กับตัวระบุการปิด

ตัวอย่าง #6 ตัวอย่าง Nowdoc

$str =<<<"EOD"
ข้อความตัวอย่าง
ทอดยาวหลายบรรทัด
ใช้ไวยากรณ์ nowdoc
อีโอดี;

/* ตัวอย่างที่ซับซ้อนยิ่งขึ้นพร้อมตัวแปร */
คลาสฟู
{
สาธารณะ $foo ;
สาธารณะ $บาร์ ;

ฟังก์ชั่นฟู()
{
$นี่ -> ฟู = "ฟู" ;
$นี่ -> bar = array("Bar1" , "Bar2" , "Bar3" );
}
}

$foo = ใหม่ foo();
$name = "ชื่อของฉัน" ;

เสียงสะท้อน<<<"EOT"
ฉันชื่อ "$ชื่อ" ฉันพิมพ์ $foo->foo
ตอนนี้ฉันพิมพ์ ($foo->bar)
สิ่งนี้ไม่ควรแสดงตัวพิมพ์ใหญ่ "A": \x41
อีโอที;
?>

ผลลัพธ์ของการรันตัวอย่างนี้:

ฉันชื่อ "$ชื่อ" ฉันพิมพ์ $foo->foo ตอนนี้ฉันพิมพ์ ($foo->bar) สิ่งนี้ไม่ควรแสดงตัวพิมพ์ใหญ่ "A": \x41

ความคิดเห็น:

ต่างจาก Heredoc ตรงที่ Nowdoc สามารถใช้ในบริบทใดก็ได้ที่มีข้อมูลคงที่ ตัวอย่างทั่วไปของการเริ่มต้นฟิลด์คลาสหรือค่าคงที่:

ตัวอย่าง #7 ตัวอย่างการใช้ข้อมูลคงที่

คลาสฟู(
สาธารณะ $bar =<<<"EOT"
บาร์
อีโอที;
}
?>

ความคิดเห็น:

เพิ่มการรองรับ nowdoc ใน PHP 5.3.0

การจัดการตัวแปร

หากระบุสตริงด้วยเครื่องหมายคำพูดคู่ หรือใช้ Heredoc ตัวแปรภายในจะถูกประมวลผล

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

ไวยากรณ์ที่ซับซ้อนสามารถระบุได้ด้วยเครื่องหมายปีกกาที่ล้อมรอบนิพจน์

ไวยากรณ์ง่ายๆ

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

$juice = "แอปเปิ้ล" ;

echo "เขาดื่มน้ำผลไม้ $ นิดหน่อย" . PHP_EOL ;
// ใช้งานไม่ได้ "s" เป็นอักขระที่ถูกต้องสำหรับชื่อตัวแปร
// แต่ตัวแปรของเราชื่อ $juice
echo "เขาดื่มน้ำผลไม้ที่ทำจากน้ำผลไม้ $" ;
?>

ผลลัพธ์ของการรันตัวอย่างนี้:

เขาดื่มน้ำแอปเปิ้ล เขาดื่มน้ำผลไม้ที่ทำจาก.

องค์ประกอบอาร์เรย์ ( อาร์เรย์) หรือคุณสมบัติของวัตถุ ( วัตถุ). ในดัชนีอาร์เรย์จะมีวงเล็บเหลี่ยมปิด ( ] ) เป็นจุดสิ้นสุดของคำจำกัดความดัชนี กฎเดียวกันนี้ใช้กับคุณสมบัติของวัตถุเช่นเดียวกับตัวแปรอย่างง่าย

ตัวอย่างที่ 8 ตัวอย่างไวยากรณ์อย่างง่าย

$juices = array("apple" , "orange" , "koolaid1" => "สีม่วง" );

echo "เขาดื่มน้ำผลไม้ $juices [ 0 ]" . PHP_EOL ;
echo "เขาดื่มน้ำผลไม้ $juices [1]" . PHP_EOL ;
echo "เขาดื่มน้ำผลไม้ $juices [ koolaid1 ] บ้าง" . PHP_EOL ;

คนในชั้นเรียน (
สาธารณะ $john = "จอห์น สมิธ" ;
สาธารณะ $jan = "เจน สมิธ" ;
สาธารณะ $robert = "โรเบิร์ตพอลเซ่น" ;

สาธารณะ $สมิธ = "สมิธ" ;
}

$people = คนใหม่();

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 " ; //จะไม่ทำงาน
?>

ผลลัพธ์ของการรันตัวอย่างนี้:

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

สำหรับสิ่งที่ซับซ้อนกว่านี้ ให้ใช้ไวยากรณ์ที่ซับซ้อน

ไวยากรณ์ที่ซับซ้อน (หยิก)

มันถูกเรียกว่าซับซ้อนไม่ใช่เพราะว่ามันยากที่จะเข้าใจ แต่เพราะมันทำให้สามารถใช้สำนวนที่ซับซ้อนได้

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

// แสดงข้อผิดพลาดทั้งหมด
error_reporting(E_ALL);

$great = "เยี่ยมมาก" ;

// ใช้งานไม่ได้ ผลลัพธ์: นี่คือ (เยี่ยมมาก)
echo "นี่คือ ( $great )" ;

// ใช้งานได้ ผลลัพธ์: เยี่ยมมาก
echo "นี่คือ ( $great ) " ;
echo "นี่คือ $( เยี่ยมมาก ) " ;

//ทำงาน
เสียงสะท้อน “จัตุรัสนี้กว้าง( $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 = "ฉันคือบาร์" ;
}

$foo = ใหม่ foo();
$บาร์ = "บาร์" ;
$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().

ความคิดเห็น: อักขระในสตริงสามารถเข้าถึงได้โดยใช้เครื่องหมายปีกกา เช่น $str(42)

ความสนใจ

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

ความสนใจ

สตริงใน PHP เป็นอาร์เรย์ภายในของไบต์ ด้วยเหตุนี้ การเข้าถึงหรือแก้ไขสตริงที่ออฟเซ็ตจึงไม่ปลอดภัยในการเข้ารหัสหลายไบต์ และควรทำด้วยสตริงในการเข้ารหัสไบต์เดียวเท่านั้น เช่น ISO-8859-1

ตัวอย่างที่ 9 ตัวอย่างสตริงบางส่วน

// รับอักขระตัวแรกของสตริง
$str = "นี่คือการทดสอบ" ;
$แรก = $str [ 0 ];

// รับอักขระตัวที่สามของสตริง
$สาม = $str [ 2 ];

// รับอักขระตัวสุดท้ายของสตริง
$str = "นี่ยังคงเป็นการทดสอบ" ;
$last = $str [ strlen ($str ) - 1 ];

// เปลี่ยนอักขระตัวสุดท้ายของบรรทัด
$str = "มองไปที่ทะเล" ;
$str [ strlen ($str )- 1 ] = "e" ;

?>

ตั้งแต่ PHP 5.4 เป็นต้นไป ค่าชดเชยในสตริงจะต้องระบุเป็นจำนวนเต็มหรือสตริงที่มีตัวเลข มิฉะนั้น จะมีการแจ้งเตือน ก่อนหน้านี้ชดเชยที่กำหนดโดยสตริงเช่น "ฟู"โดยไม่มีการแจ้งเตือนถูกแปลงเป็น 0 .

ตัวอย่าง #10 ความแตกต่างระหว่าง 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"]. ดูคำแนะนำด้านล่างเกี่ยวกับวิธีการแสดง/ดูเนื้อหาทั้งหมด

ออบเจ็กต์ใน PHP 4 จะถูกแปลงเป็นสตริงเสมอ "วัตถุ". หากคุณต้องการแสดงค่าของฟิลด์ของวัตถุ ( วัตถุ) เพื่อวัตถุประสงค์ในการแก้ไขข้อบกพร่อง โปรดอ่านต่อ หากคุณต้องการรับชื่อคลาสของอ็อบเจ็กต์ที่ต้องการ ให้ใช้ get_คลาส(). ตั้งแต่ PHP 5 วิธีการ __toString ก็มีให้บริการเช่นกัน

โมฆะจะถูกแปลงเป็นสตริงว่างเสมอ

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

ค่าส่วนใหญ่ใน PHP สามารถแปลงเป็นสตริงสำหรับจัดเก็บข้อมูลถาวรได้ วิธีการนี้เรียกว่าการทำให้เป็นอนุกรม และสามารถทำได้โดยใช้ฟังก์ชัน ทำให้เป็นอนุกรม(). นอกจากนี้ หากการติดตั้ง PHP ของคุณรองรับ WDDX การทำให้ซีเรียลไลซ์เป็นโครงสร้าง XML ก็สามารถทำได้เช่นกัน

การแปลงสตริงให้เป็นตัวเลข

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

หากสตริงไม่มีอักขระใดๆ ".", "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) . "
\n" ;
?>

อย่าคาดหวังว่าจะได้รับโค้ดของอักขระโดยการแปลงเป็นจำนวนเต็ม (ดังที่ทำเสร็จแล้ว เช่น ใน C) หากต้องการแปลงอักขระเป็นรหัส ASCII และย้อนกลับ ให้ใช้ฟังก์ชัน ลำดับ()และ ch().

รายละเอียดการใช้งานประเภทสตริง

ประเภทสตริง ( เชือก) ใน PHP ถูกนำมาใช้เป็นอาร์เรย์ของไบต์และจำนวนเต็มที่มีความยาวของบัฟเฟอร์ ไม่มีข้อมูลใด ๆ เกี่ยวกับวิธีการแปลงไบต์เหล่านี้เป็นอักขระ โดยปล่อยให้งานนี้ตกเป็นหน้าที่ของโปรแกรมเมอร์ ไม่มีข้อจำกัดเกี่ยวกับเนื้อหาของสตริง เช่น ไบต์ที่มีค่า 0 (ไบต์ "NUL") สามารถอยู่ที่ใดก็ได้ (อย่างไรก็ตาม โปรดทราบว่าฟังก์ชันบางอย่างตามที่ระบุไว้ในคู่มือนี้ ไม่ใช่ "ไบนารีที่ปลอดภัย" กล่าวคือ สามารถส่งสตริงไปยังไลบรารีที่ละเว้นข้อมูลหลังจาก NUL -byte)

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

เมื่อพิจารณาถึงข้อเท็จจริงที่ว่า PHP ไม่ได้กำหนดการเข้ารหัสเฉพาะสำหรับสตริง อาจมีคนถามว่าแล้วเข้ารหัสตัวอักษรของสตริงอย่างไร เช่น เส้น "á" เทียบเท่า "\xE1"(ISO-8859-1) "\xC3\xA1"(UTF-8, รูปแบบการทำให้เป็นมาตรฐาน C), "\x61\xCC\x81"(UTF-8, รูปแบบการทำให้เป็นมาตรฐาน D) หรือการเป็นตัวแทนอื่น ๆ ที่เป็นไปได้? คำตอบก็คือ สตริงจะถูกเข้ารหัสในลักษณะเดียวกับที่เขียนในไฟล์สคริปต์ ดังนั้น หากสคริปต์เขียนด้วยการเข้ารหัส ISO-8859-1 สตริงก็จะถูกเข้ารหัสด้วย ISO-8859-1 เป็นต้น อย่างไรก็ตาม กฎนี้ใช้ไม่ได้เมื่อเปิดใช้งานโหมด Zend Multibyte: ในกรณีนี้ สามารถเขียนสคริปต์ด้วยการเข้ารหัสใดๆ (ไม่ว่าจะระบุอย่างชัดเจนหรือกำหนดโดยอัตโนมัติ) จากนั้นแปลงเป็นการเข้ารหัสภายในเฉพาะ ซึ่งจะใช้ในภายหลังสำหรับ ตัวอักษรสตริง โปรดทราบว่าการเข้ารหัสสคริปต์ (หรือการเข้ารหัสภายในหากเปิดใช้งาน Zend Multibyte) มีข้อจำกัดบางประการ: การเข้ารหัสจะต้องเป็น superset ของ ASCII เกือบทุกครั้ง เช่น UTF-8 หรือ ISO-8859-1 โปรดทราบว่าการเข้ารหัสที่ขึ้นกับสถานะซึ่งสามารถใช้ค่าไบต์เดียวกันในสถานะกะเริ่มต้นและไม่ใช่เริ่มต้นอาจทำให้เกิดปัญหาได้

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

• ฟังก์ชันบางอย่างถือว่าสตริงถูกเข้ารหัสในการเข้ารหัสแบบไบต์เดี่ยวบางฟังก์ชัน แต่ไม่จำเป็นต้องตีความไบต์เป็นอักขระเฉพาะเพื่อให้ทำงานได้อย่างถูกต้อง หมวดหมู่นี้รวมถึง ตัวอย่างเช่น ซับสเตร(), สตรอส(), สเตรน()และ strcmp(). วิธีคิดอีกวิธีหนึ่งเกี่ยวกับฟังก์ชันเหล่านี้ก็คือ ทำงานบนบัฟเฟอร์หน่วยความจำ เช่น มันทำงานโดยตรงกับไบต์และออฟเซ็ต ชดเชย
• ฟังก์ชันอื่นๆ คาดว่าการเข้ารหัสจะถูกส่งผ่านเป็นพารามิเตอร์ อาจถือว่าการเข้ารหัสเริ่มต้นบางอย่างหากไม่ได้ระบุพารามิเตอร์การเข้ารหัส ฟังก์ชั่นนี้คือ
• สุดท้ายนี้ มีฟังก์ชันที่ถือว่าสตริงใช้การเข้ารหัสเฉพาะ ซึ่งปกติจะเป็น UTF-8 ฟังก์ชันส่วนใหญ่จากส่วนขยาย intl และ PCRE จะอยู่ที่นี่ (ในกรณีหลัง เฉพาะเมื่อระบุตัวแก้ไขเท่านั้น ยู). แม้ว่าสิ่งนี้จะทำโดยตั้งใจ แต่ฟังก์ชั่น utf8_decode()หมายถึงการเข้ารหัส UTF-8 และ utf8_encode()- ISO-8859-1.

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

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

เรามาดูความแตกต่างระหว่าง double quotes และ single quotes ใน PHP กัน และใช้ตัวอย่างเพื่อดูว่าควรใช้อันไหนเมื่อใด

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

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

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

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

นี่คือตัวอย่างการใช้เครื่องหมายคำพูดเดี่ยว:
// เอาท์พุต: สตริงอย่างง่าย
echo "สตริงธรรมดา";
// พิมพ์: ฉันอยู่ที่นี่
echo "ฉันอยู่ที่นี่";
// ผลลัพธ์: สิ่งนี้จะไม่แทรก: \n บรรทัดใหม่
echo "สิ่งนี้จะไม่แทรก:\nnewline";
// ผลลัพธ์: ตัวแปร $example จะไม่ถูกแทนที่เช่นกัน
echo "ตัวแปร $example จะไม่ถูกแทนที่เช่นกัน"; หากสตริงอยู่ในเครื่องหมายคำพูดคู่ (") PHP จะรับรู้ ปริมาณมากลำดับการควบคุมสำหรับอักขระพิเศษและยังทดแทนค่าของมันแทนชื่อตัวแปรในสตริง เช่นเดียวกับเครื่องหมายคำพูดเดี่ยว ในการใช้เครื่องหมายคำพูดคู่ภายในสตริงที่มีเครื่องหมายคำพูดคู่ จะต้องนำหน้าด้วยอักขระแบ็กสแลช (\)

นี่คือตัวอย่างการใช้เครื่องหมายคำพูดคู่:
// เอาท์พุต: สตริงอย่างง่าย
echo "สตริงธรรมดา";
// ผลลัพธ์: บริษัท "Snowdrop"
echo "บริษัท \"สโนว์ดรอป\"";
// ผลลัพธ์: สิ่งนี้จะนำไปสู่การขึ้นบรรทัดใหม่
echo "สิ่งนี้จะขึ้นบรรทัดใหม่ \n";
// ผลลัพธ์: ตัวแปรจะถูกแทนที่
$example = "จะถูกแทนที่";
echo "ตัวแปร $ ตัวอย่าง"; ควรจำไว้ว่าลำดับ "\n" ( บรรทัดใหม่), "\r" (การขึ้นบรรทัดใหม่) สำหรับข้อความธรรมดา ไม่ใช่ HTML ดังนั้นคุณจะไม่เห็นการเปลี่ยนแปลงในเบราว์เซอร์ (เฉพาะใน รหัสแหล่งที่มาหน้า)

เรามาดูกันว่าราคาเดี่ยวเร็วกว่าราคาคู่มากแค่ไหน สำหรับการวัด เราจะเขียนสคริปต์ทดสอบสั้นๆ และเราจะทราบทันทีว่าหากคุณทดสอบด้วยตัวเอง ผลลัพธ์ซึ่งขึ้นอยู่กับฮาร์ดแวร์ของพีซีหรือเซิร์ฟเวอร์ของคุณจะแตกต่างออกไป
// ส่งคืนการประทับเวลาที่จุดเริ่มต้นของการวนซ้ำ
$start = ไมโครไทม์(จริง);
// สร้างลูปสำหรับการวนซ้ำ 1 ล้านครั้ง
สำหรับ ($i = 0; $i< 1000000; $i++) {
$text = "นี่คือสตริงอักขระ";
}
// คำนวณเวลาที่ใช้
$time = (ไมโครไทม์(จริง) - $เริ่มต้น); ผลลัพธ์: 0.09 วินาที

หากเราแทนที่เครื่องหมายคำพูดเดี่ยวด้วยเครื่องหมายคำพูดคู่:
$text = "นี่คือสตริงอักขระ"; ผลลัพธ์จะเป็น 0.10 วินาที

อย่างที่คุณเห็น เมื่อใช้สตริงข้อความ เวลาดำเนินการต่างกันน้อยมาก และอาจกล่าวได้ว่าไม่มีเลยด้วยซ้ำ ความสนุกเริ่มต้นขึ้นเมื่อเราพยายามรวมสตริงและตัวแปรเข้าด้วยกัน
$text = "นี่คือสายอักขระ $i"; หรือ
$text = $i"นี่คือสตริงอักขระ"; ผลลัพธ์ประมาณ: 0.27 วินาที

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

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