พิมพ์ตัวแปรการหล่อใน PHP, อะไรคือเหตุผลเชิงปฏิบัติสำหรับการทำเช่นนี้?

PHP เป็นส่วนใหญ่ของเราทราบว่ามีการพิมพ์ที่อ่อนแอ สำหรับคนที่ไม่ทำ PHP.net พูดว่า:

PHP ไม่ต้องการคำนิยามประเภทที่ชัดเจน (หรือสนับสนุน) ในการประกาศตัวแปร ชนิดของตัวแปรถูกกำหนดโดยบริบทที่ใช้ตัวแปรนั้น

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

$var = "10";
$value = 10 + $var;
var_dump($value); // int(20)

PHP ยังอนุญาตให้คุณสร้างตัวแปรอย่างชัดเจนเช่น:

$var = "10";
$value = 10 + $var;
$value = (string)$value;
var_dump($value); // string(2) "20"

ทั้งหมดนี้ยอดเยี่ยม ... แต่สำหรับชีวิตของฉันฉันไม่สามารถเข้าใจถึงเหตุผลที่ปฏิบัติได้สำหรับการทำเช่นนี้

ฉันไม่มีปัญหากับการพิมพ์ที่แข็งแกร่งในภาษาที่รองรับเช่น Java ไม่เป็นไรและฉันเข้าใจอย่างถ่องแท้ นอกจากนี้ฉันรู้และเข้าใจถึงประโยชน์ของการบอกกล่าวชนิดในพารามิเตอร์ฟังก์ชัน

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

$var = "10";
$value = (int)$var;
$value = $value . ' TaDa!';
var_dump($value); // string(8) "10 TaDa!"

ดังนั้นประเด็นคืออะไร

ลองดูตัวอย่างเชิงทฤษฎีเกี่ยวกับโลกที่ผู้ใช้กำหนดรูปแบบการพิมพ์ใน PHP :

1. คุณบังคับให้โยนตัวแปร$fooเป็น→int(int)$foo
2. $fooคุณพยายามที่จะเก็บค่าสตริงในตัวแปร
3. PHP พ่นข้อยกเว้น !! ←นั่นจะทำให้รู้สึก ทันใดนั้นมีเหตุผลสำหรับการคัดเลือกประเภทที่ผู้ใช้กำหนดอยู่!

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

// example 1
$foo = 0;
$foo = (string)$foo;
$foo = '# of Reasons for the programmer to type cast $foo as a string: ' . $foo;

// example 2
$foo = 0;
$foo = (int)$foo;
$foo = '# of Reasons for the programmer to type cast $foo as a string: ' . $foo;

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

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

Menu Item 1 .............. $ 4
Menu Item 2 .............. $ 7.5
Menu Item 3 .............. $ 3

วิธีที่ดีที่สุดที่ฉันพบว่าทำอย่างนั้นเพื่อเลือกตัวแปรเป็นทุ่น:

$price = '7.50'; // a string from the database layer.
echo 'Menu Item 2 .............. $ ' . (float)$price;

PHP จดจ้องกับเลขศูนย์ต่อท้ายของ float จากนั้น recasts ลอยเป็นสตริงสำหรับการต่อข้อมูล

ในภาษาที่มีการพิมพ์น้อยการหล่อแบบมีอยู่เพื่อลบความคลุมเครือในการดำเนินการที่พิมพ์เมื่อมิฉะนั้นคอมไพเลอร์ / ล่ามจะใช้คำสั่งหรือกฎอื่น ๆ เพื่อให้สันนิษฐานว่าการดำเนินการที่จะใช้

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

นี่คือกรณีเหล่านี้โดยใช้ JavaScript เป็นภาษาเปรียบเทียบ

การรวมสตริง

เห็นได้ชัดว่านี่ไม่ใช่ปัญหาใน PHP เพราะมีตัวดำเนินการต่อสตริงที่แยกกัน ( .) และการเพิ่ม ( +)

var a = 5;
var b = "10"
var incorrect = a + b; // "510"
var correct = a + Number(b); // 15

การเปรียบเทียบสตริง

บ่อยครั้งในระบบคอมพิวเตอร์ "5" มากกว่า "10" เพราะมันไม่ได้แปลความหมายเป็นตัวเลข ไม่เช่นนั้นใน PHP ซึ่งแม้ว่าทั้งสองจะเป็นสตริง แต่ก็ตระหนักได้ว่ามันเป็นตัวเลขและไม่จำเป็นต้องใช้ cast)

console.log("5" > "10" ? "true" : "false"); // true

echo "5" > "10" ? "true" : "false";  // false!

ฟังก์ชั่นการพิมพ์ลายเซ็นต์

PHP ใช้การตรวจสอบชนิดกระดูกเปลือยบนฟังก์ชันของลายเซ็น แต่น่าเสียดายที่มันมีข้อบกพร่อง

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

function testprint(string $a) {
    echo $a;
}

$test = 5;
testprint((string)5); // "Catchable fatal error: Argument 1 passed to testprint()
                      //  must be an instance of string, string given" WTF?

และไม่เหมือนกับภาษาอื่น ๆ ที่ฉันรู้จักแม้ว่าคุณจะใช้ภาษาที่เข้าใจแล้วก็ตาม null จะไม่สามารถผ่านไปยังอาร์กิวเมนต์นั้นได้อีกต่อไป ( must be an instance of array, null given) โง่แค่ไหน

การตีความแบบบูล

[ แก้ไข ]: อันนี้ใหม่ ฉันคิดว่าอีกกรณีหนึ่งและตรรกะกลับเป็นจาก JavaScript อีกครั้ง

console.log("0" ? "true" : "false"); // True, as expected. Non-empty string.

echo "0" ? "true" : "false"; // False! This one probably causes a lot of bugs.

โดยสรุปแล้วสิ่งเดียวที่มีประโยชน์ที่ฉันคิดได้คือ ... (drumroll)

ตัดทอนประเภท

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

$val = "test";
$val2 = "10";
$intval = (int)$val; // 0
$intval2 = (int)$val2; // 10
$boolval = (bool)$intval // false
$boolval2 = (bool)$intval2 // true
$props = (array)$myobject // associative array of $myobject's properties

ฉันไม่สามารถเห็นสิ่งที่ upcasting (ประเภทที่ครอบคลุมค่ามากขึ้น) จะได้รับคุณจริง ๆ

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

คุณกำลังผสมแนวคิดประเภทที่อ่อนแอ / แข็งแกร่งและไดนามิก / คงที่

PHP มีจุดอ่อนและไดนามิก แต่ปัญหาของคุณอยู่ที่แนวคิดแบบไดนามิก นั่นหมายความว่าตัวแปรไม่มีประเภทค่าทำ

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

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

พิจารณา:

function get_by_id ($id) {
   $id = (int)$id;
   $q = "SELECT * FROM table WHERE id=$id LIMIT 1";
   ........
}

ถ้าฉันปล่อยให้บรรทัดแรก$idจะเป็นเวกเตอร์ง่าย ๆ สำหรับการฉีด SQL นักแสดงทำให้แน่ใจว่ามันเป็นจำนวนเต็มไม่เป็นอันตราย ความพยายามใด ๆ ที่จะแทรก SQL บางอันก็จะส่งผลให้แบบสอบถามid=0

ใช้ครั้งเดียวสำหรับการแคสติ้งประเภทใน PHP ที่ฉันได้พบ:

ฉันกำลังพัฒนาแอพ android ซึ่งทำให้การร้องขอ HTTP ไปยังสคริปต์ PHP บนเซิร์ฟเวอร์เพื่อดึงข้อมูลจากฐานข้อมูล สคริปต์เก็บข้อมูลในรูปแบบของวัตถุ PHP (หรืออาเรย์แบบเชื่อมโยง) และส่งคืนเป็นวัตถุ JSON ไปยังแอป ฉันจะได้รับสิ่งนี้:

{ "user" : { "id" : "1", "name" : "Bob" } }

แต่ด้วยการใช้ PHP ในการหล่อ(int)รหัสผู้ใช้เมื่อเก็บวัตถุ PHP ฉันได้รับสิ่งนี้กลับไปที่แอพแทน:

{ "user" : { "id" : 1, "name" : "Bob" } }

จากนั้นเมื่อมีการแยกวิเคราะห์วัตถุ JSON ในแอปมันจะช่วยฉันในการแยกวิเคราะห์ ID เป็นจำนวนเต็ม!

เห็นว่ามีประโยชน์มาก

ตัวอย่างหนึ่งคือวัตถุที่มีวิธีการ __toString A: VS$str = $obj->__toString(); $str = (string) $obj;การพิมพ์ที่สองมีน้อยกว่ามากและสิ่งพิเศษคือเครื่องหมายวรรคตอนซึ่งใช้เวลาในการพิมพ์นานกว่า ฉันยังคิดว่ามันอ่านได้มากขึ้นแม้ว่าคนอื่นอาจไม่เห็นด้วย

อีกประการหนึ่งคือการทำให้อาร์เรย์เดียวองค์ประกอบ: VSarray($item); (array) $item;สิ่งนี้จะใส่ประเภทสเกลาร์ใด ๆ (จำนวนเต็มทรัพยากร ฯลฯ ) ไว้ในอาร์เรย์
ถ้า$itemเป็นวัตถุคุณสมบัติของมันจะกลายเป็นกุญแจไปสู่ค่าของมัน อย่างไรก็ตามฉันคิดว่าการแปลงอาเรย์เป็นออบเจ็กต์แปลกไปหน่อย: คุณสมบัติส่วนตัวและได้รับการป้องกันเป็นส่วนหนึ่งของอาเรย์และเปลี่ยนชื่อ ในการอ้างอิงเอกสาร PHP : ตัวแปรส่วนตัวมีชื่อคลาสต่อท้ายกับชื่อตัวแปร ตัวแปรที่ได้รับการป้องกันจะมีเครื่องหมาย '*' ต่อท้ายกับชื่อตัวแปร

การใช้งานอื่นคือการแปลงข้อมูล GET / POST เป็นประเภทที่เหมาะสมสำหรับฐานข้อมูล MySQL สามารถจัดการได้ด้วยตัวเอง แต่ฉันคิดว่าเซิร์ฟเวอร์ที่รองรับ ANSI มากกว่านั้นอาจปฏิเสธข้อมูล เหตุผลที่ฉันพูดถึงฐานข้อมูลก็คือในกรณีอื่น ๆ ส่วนใหญ่ข้อมูลจะมีการดำเนินการตามประเภทของมันในบางจุด (เช่น int / ลอยมักจะมีการคำนวณดำเนินการกับพวกเขา ฯลฯ )

สคริปต์นี้:

$tags = _GET['tags'];
foreach ($tags as $tag) {
    echo 'tag: ', $tag;
}

จะทำงานได้ดีscript.php?tags[]=oneแต่จะล้มเหลวscript.php?tags=oneเพราะ_GET['tags']ส่งคืนอาร์เรย์ในกรณีแรก แต่ไม่ใช่ในวินาที เนื่องจากสคริปต์ถูกเขียนขึ้นเพื่อคาดหวังอาร์เรย์ (และคุณมีการควบคุมสตริงข้อความค้นหาที่ส่งไปยังสคริปต์น้อยลง) ปัญหาสามารถแก้ไขได้โดยการส่งผลลัพธ์จาก_GET:

$tags = (array) _GET['tags'];
foreach ($tags as $tag) {
    echo 'tag: ', $tag;
}

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

$amount = (float) $_POST['amount'];

if( $amount > 0 ){
    $remoteService->doacalculationwithanumber( $amount );    
}

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

หนึ่ง "ใช้" ของ PHP re-casting ตัวแปร on-the-fly ที่ฉันเห็นใช้บ่อยคือเมื่อดึงข้อมูลจากแหล่งภายนอก (ผู้ใช้หรือฐานข้อมูลผู้ใช้) มันช่วยให้ coders (โปรดทราบว่าฉันไม่ได้พูดว่านักพัฒนา)ละเว้น (หรือไม่ได้เรียนรู้) ประเภทข้อมูลที่แตกต่างกันที่มีอยู่จากแหล่งที่แตกต่างกัน

หนึ่งรหัส(โปรดทราบว่าฉันไม่ได้พูดว่านักพัฒนา)ซึ่งมีรหัสที่ฉันได้รับและยังคงรักษาดูเหมือนว่าจะไม่ทราบว่ามีความแตกต่างระหว่างสตริง"20"ที่ส่งกลับใน$_GETตัวแปร super เพื่อระหว่างการดำเนินการจำนวนเต็ม20 + 20เมื่อเธอเพิ่ม ค่าในฐานข้อมูล เธอโชคดีที่ PHP ใช้.สำหรับการเรียงสตริงและไม่+เหมือนกับภาษาอื่น ๆ เพราะฉันเห็นโค้ดของเธอ "เพิ่ม" สองสตริง ( varcahrจาก MySQL และค่าจาก$_GET) และรับ int

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