ทำไมภาษาที่พิมพ์แบบไดนามิกไม่ให้นักพัฒนาระบุประเภท?


14

ภาษาที่พิมพ์แบบไดนามิกที่ฉันรู้ว่าไม่ให้นักพัฒนาระบุประเภทของตัวแปรหรืออย่างน้อยก็มีการสนับสนุนที่ จำกัด มากสำหรับสิ่งนั้น

ตัวอย่างเช่น JavaScript ไม่มีกลไกใด ๆ ในการบังคับใช้ตัวแปรประเภทต่างๆเมื่อสะดวกในการใช้งาน PHP ช่วยให้คุณระบุบางชนิดของการขัดแย้งวิธี แต่มีวิธีที่จะใช้ชนิดพื้นเมือง (ไม่int, stringฯลฯ ) สำหรับข้อโต้แย้งและมีวิธีการที่จะบังคับใช้สำหรับประเภทอื่นใดนอกเหนือจากการขัดแย้งใด

ในเวลาเดียวกันมันจะสะดวกที่จะมีทางเลือกที่จะระบุในบางกรณีประเภทของตัวแปรในภาษาที่พิมพ์แบบไดนามิกแทนการทำประเภทการตรวจสอบด้วยตนเอง

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


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

public function CreateProduct($name, $description, $price, $quantity)
{
    // Check the arguments.
    if (!is_string($name)) throw new Exception('The name argument is expected to be a string.');
    if (!is_string($description)) throw new Exception('The description argument is expected to be a string.');
    if (!is_float($price) || is_double($price)) throw new Exception('The price argument is expected to be a float or a double.');
    if (!is_int($quantity)) throw new Exception('The quantity argument is expected to be an integer.');

    if (!$name) throw new Exception('The name argument cannot be an empty string.');
    if ($price <= 0) throw new Exception('The price argument cannot be less or equal to zero.');
    if ($price < 0) throw new Exception('The price argument cannot be less than zero.');

    // We can finally begin to write the actual code.
    // TODO: Implement the method here.
}

ด้วยความพยายามบางอย่างนี้สามารถเขียนใหม่เป็น (ดูการเขียนโปรแกรมโดยสัญญาใน PHP ):

public function CreateProduct($name, $description, $price, $quantity)
{
    Component::CheckArguments(__FILE__, __LINE__, array(
        'name' => array('value' => $name, 'type' => VTYPE_STRING),
        'description' => array('value' => $description, 'type' => VTYPE_STRING),
        'price' => array('value' => $price, 'type' => VTYPE_FLOAT_OR_DOUBLE),
        'quantity' => array('value' => $quantity, 'type' => VTYPE_INT)
    ));

    if (!$name) throw new Exception('The name argument cannot be an empty string.');
    if ($price <= 0) throw new Exception('The price argument cannot be less or equal to zero.');
    if ($price < 0) throw new Exception('The price argument cannot be less than zero.');

    // We can finally begin to write the actual code.
    // TODO: Implement the method here.
}

แต่วิธีการเดียวกันนี้จะถูกเขียนดังนี้ถ้า PHP เลือกยอมรับชนิดเนทีฟสำหรับอาร์กิวเมนต์:

public function CreateProduct(string $name, string $description, double $price, int $quantity)
{
    // Check the arguments.
    if (!$name) throw new Exception('The name argument cannot be an empty string.');
    if ($price <= 0) throw new Exception('The price argument cannot be less or equal to zero.');
    if ($price < 0) throw new Exception('The price argument cannot be less than zero.');

    // We can finally begin to write the actual code.
    // TODO: Implement the method here.
}

อันไหนที่สั้นกว่าที่จะเขียน? อ่านอันไหนง่ายกว่ากัน?


1
คุณสามารถเลือกระบุประเภทในภาษาที่พิมพ์แบบไดนามิกบางอย่างเช่นใน Common Lisp
SK-logic

ค่อนข้างไม่กี่ภาษาพิมพ์แบบไดนามิกใช้เฝือกเพื่อบังคับชนิด ...
Trezoid

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

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

1
Groovy เป็นอีกตัวอย่างหนึ่งของภาษาที่พิมพ์แบบไดนามิกที่อนุญาตให้ระบุชนิด
Eric Wilson

คำตอบ:


17

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

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

ในการแสดงข้อมูลประเภทคุณต้องมีส่วนหนึ่งของภาษาที่ไม่สามารถเรียบง่ายเกินไป ในไม่ช้าคุณจะพบว่าข้อมูลเช่นintนั้นไม่เพียงพอ คุณจะต้องการอะไรบางอย่างList<Pair<Int, String>>แล้วประเภทพารามิเตอร์ ฯลฯ มันอาจทำให้เกิดความสับสนมากพอแม้ในกรณีที่ค่อนข้างง่ายของ Java

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

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

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


1
+1 แต่การทดสอบสามารถแสดงได้ว่าข้อผิดพลาดไม่ได้เกิดขึ้นในบางสถานการณ์ พวกเขากำลังทดแทนที่ดีสำหรับการพิสูจน์ว่าข้อผิดพลาด (ประเภท) เป็นไปไม่ได้
Ingo

1
@Ingo: แน่นอน แต่ภาษาไดนามิกนั้นยอดเยี่ยมสำหรับการแก้ไขและสร้างต้นแบบอย่างรวดเร็วซึ่งคุณแสดงความคิดที่ค่อนข้างง่ายอย่างรวดเร็ว หากคุณต้องการรหัสการผลิตที่สามารถกันกระสุนได้คุณสามารถเปลี่ยนเป็นภาษาแบบคงที่ได้หลังจากนั้นเมื่อคุณแยกส่วนประกอบหลักที่เสถียรแล้ว
9000

1
@ 9000 ฉันไม่สงสัยเลยว่าพวกเขายอดเยี่ยม ต้องการเพียงเพื่อชี้ให้เห็นว่าการเขียน 3 หรือ 4 ทดสอบง่อยไม่ได้และไม่สามารถสร้างความมั่นใจความปลอดภัยประเภท
Ingo

2
@ 9000 จริงและข่าวร้ายก็คือถึงตอนนั้นมันเป็นไปไม่ได้เลย แม้แต่รหัส Haskell หรือ Agda ก็ขึ้นอยู่กับสมมติฐานเช่นว่าไลบรารีที่ใช้ในรันไทม์นั้นถูกต้อง ดังที่กล่าวไว้ในโครงการที่มี 1,000 LOC แผ่กระจายไปทั่วไฟล์ซอร์สโค้ดหลายโหลมันยอดเยี่ยมมากเมื่อคุณสามารถเปลี่ยนแปลงบางอย่างและคุณรู้ว่าคอมไพเลอร์จะชี้ไปที่ทุกบรรทัดที่การเปลี่ยนแปลงมีผลกระทบ
Ingo

4
การทดสอบที่เขียนไม่ดีไม่สามารถใช้แทนการตรวจสอบชนิดสแตติกได้ การทดสอบที่เขียนเป็นอย่างดีนั้นไม่ใช่การแทนที่สำหรับการตรวจสอบประเภทคงที่: มันดีกว่า
Rein Henrichs

8

ในภาษาแบบไดนามิกส่วนใหญ่อย่างน้อยคุณสามารถทดสอบชนิดของวัตถุหรือค่าแบบไดนามิก

และยังมีประเภทรองแบบคงที่ตัวตรวจสอบและ / หรือตัวบังคับสำหรับภาษาแบบไดนามิกบางอย่างเช่น

และ Perl 6 จะสนับสนุนระบบประเภทที่เป็นทางเลือก พร้อมการพิมพ์แบบสแตติก


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

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


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

4
"คนทั่วไปใช้ภาษาแบบไดนามิกเพราะพิมพ์แบบไดนามิก" : ใช้ JavaScript เพราะเป็นภาษาเดียวที่เบราว์เซอร์ส่วนใหญ่รองรับ PHP ใช้เพราะเป็นที่นิยม
Arseni Mourzenko

2

จาวาสคริปต์ได้วางแผนที่จะรวมการพิมพ์แบบคงที่บางตัวเลือกและดูเหมือนว่าภาษาแบบไดนามิกสำหรับผู้ใหญ่จำนวนมากกำลังมุ่งหน้าไปทางนั้น -

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

ทำให้รู้สึกบางอย่างกับฉันเนื่องจากฉันมักจะพบว่ามีการตรวจสอบประเภทมากเกินไปในช่วงเริ่มต้นของโครงการน้อยเกินไปในตอนท้ายของเวลาชีวิตไม่ว่าฉันจะใช้ภาษาใด;)


ฉันไม่รู้เกี่ยวกับแผนเหล่านั้นที่จะรวมการพิมพ์สแตติกไว้ใน JavaScript แต่หวังว่าพวกเขาจะไม่โหดร้ายเหมือนใน ActiveScript เลวร้ายที่สุดของทั้ง JavaScript และ Java
Javier

มันมีการวางแผนสำหรับ JS 4 (หรือ ECMAscript 4) แต่รุ่นนั้นถูกทิ้งเนื่องจากการทะเลาะวิวาท ฉันแน่ใจว่าสิ่งที่คล้ายกันจะปรากฏขึ้นในอนาคตในบางภาษา (ในหลามคุณสามารถเรียงลำดับของการทำมันด้วยตกแต่ง, BTW.)
แม

1
มัณฑนากรเพิ่มการตรวจสอบประเภทแบบไดนามิกซึ่งเป็นประเภทของการยืนยัน คุณไม่สามารถตรวจสอบประเภทสแตติกที่ครอบคลุมใน Python ได้ยากอย่างไรก็ตามเนื่องจากภาษามีพลวัตสูง
9000

@ 9000: ถูกต้อง อย่างไรก็ตามฉันไม่คิดว่าการตรวจสอบประเภทแบบไดนามิกนั้นไม่ดี (แต่ฉันชอบการเปรียบเทียบแบบเป็ด ala JS4) โดยเฉพาะอย่างยิ่งเมื่อรวมกับการทดสอบหน่วย มาตรฐาน
Macke

แน่นอนมันไม่เลว! นี่ไม่ใช่เรื่องของคุณธรรม ณ จุดหนึ่งประเภทจะต้อง "ตรวจสอบ" ในทางใดทางหนึ่ง หากคุณเขียน * ((double *) 0x98765E) ใน C CPU จะทำและตรวจสอบว่า 0x98765E เป็นตัวชี้ไปยัง double อย่างแน่นอน
Ingo

2

วัตถุหลามทำมีประเภท

คุณระบุประเภทเมื่อคุณสร้างวัตถุ

ในเวลาเดียวกันมันจะสะดวกที่จะมีทางเลือกที่จะระบุในบางกรณีประเภทของตัวแปรในภาษาที่พิมพ์แบบไดนามิกแทนการทำประเภทการตรวจสอบด้วยตนเอง

ที่จริงแล้วการตรวจสอบชนิดด้วยตนเองใน Python มักจะเป็นการเสียเวลาและรหัส

เป็นวิธีปฏิบัติที่ไม่ดีในการเขียนรหัสตรวจสอบชนิดใน Python

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

TypeErrorคุณสามารถเขียนรหัสไม่มีโปรแกรมของคุณยังคงล้มเหลวด้วย

มีบางกรณีที่หายากมากเมื่อคุณต้องกำหนดประเภทของรันไทม์

ทำไมมีข้อ จำกัด ดังกล่าว

เนื่องจากไม่ใช่ "ข้อ จำกัด " คำถามจึงไม่ใช่คำถามจริง


2
"วัตถุ Python มีประเภท" - โอ้จริงเหรอ? เช่นเดียวกับวัตถุ Perl วัตถุ PHP และรายการข้อมูลอื่น ๆ ในโลก ความแตกต่างระหว่างการพิมพ์แบบคงที่และแบบไดนามิกนั้นก็ต่อเมื่อจะมีการตรวจสอบประเภทเช่นเมื่อข้อผิดพลาดประเภทรายการตัวเอง หากปรากฏเป็นข้อผิดพลาดของคอมไพเลอร์ก็จะพิมพ์แบบคงที่หากปรากฏเป็นข้อผิดพลาดรันไทม์ก็เป็นแบบไดนามิก
Ingo

@Ingo: ขอบคุณสำหรับการชี้แจง ปัญหาคือวัตถุ C ++ และ Java สามารถส่งจากประเภทหนึ่งไปยังอีกประเภททำให้ชนิดของวัตถุค่อนข้างมืดและทำให้ "การตรวจสอบประเภท" ในคอมไพเลอร์เหล่านั้นค่อนข้างมืดมนเช่นกัน การตรวจสอบชนิดของ Python แม้ในเวลาใช้งานจะมืดมัวน้อยลง นอกจากนี้คำถามจะทำงานใกล้เคียงกับการบอกว่าภาษาที่พิมพ์แบบไดนามิกไม่มีประเภท ข่าวดีก็คือว่ามันไม่ได้ทำผิดพลาดทั่วไป
S.Lott

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

2

ส่วนใหญ่คุณไม่จำเป็นต้องอย่างน้อยก็ไม่ได้อยู่ในระดับรายละเอียดที่คุณแนะนำ ใน PHP ตัวดำเนินการที่คุณใช้ทำให้ชัดเจนอย่างสมบูรณ์ในสิ่งที่คุณคาดหวังว่าข้อโต้แย้งจะเป็น มันเป็นการดูแลการออกแบบเพียงเล็กน้อยแม้ว่า PHP จะส่งค่าของคุณถ้าเป็นไปได้แม้ว่าคุณจะส่งอาร์เรย์ไปยังการดำเนินการที่คาดว่าจะมีสตริงและเนื่องจากการส่งนั้นไม่ได้มีความหมายเสมอไปบางครั้งคุณก็ได้รับผลแปลก ๆ และนี่คือสิ่งที่การตรวจสอบประเภทเป็นประโยชน์) นอกเหนือจากนั้นมันไม่สำคัญว่าถ้าคุณเพิ่มจำนวนเต็ม1และ5หรือสตริง"1"และ"5"- ความจริงที่ว่าคุณกำลังใช้+โอเปอเรเตอร์จะส่งสัญญาณไปยัง PHP ที่คุณต้องการจัดการกับอาร์กิวเมนต์เนื่องจากตัวเลขและ PHP จะเชื่อฟัง สถานการณ์ที่น่าสนใจคือเมื่อคุณได้รับผลการสืบค้นจาก MySQL: ค่าตัวเลขจำนวนมากจะถูกส่งกลับเป็นสตริง แต่คุณจะไม่สังเกตเห็นเนื่องจาก PHP นั้นส่งให้คุณทุกครั้งที่คุณปฏิบัติต่อพวกเขาเป็นตัวเลข

Python ค่อนข้างเข้มงวดเกี่ยวกับประเภทของมัน แต่แตกต่างจาก PHP, Python มีข้อยกเว้นจากจุดเริ่มต้นและใช้มันอย่างสม่ำเสมอ กระบวนทัศน์ "ที่ง่ายต่อการขอการให้อภัยมากกว่าการอนุญาต" แนะนำให้เพียงดำเนินการโดยไม่ต้องตรวจสอบประเภทและพึ่งพาข้อยกเว้นที่เพิ่มขึ้นเมื่อประเภทไม่เหมาะสม ข้อเสียเพียงอย่างเดียวที่ฉันคิดได้ก็คือบางครั้งคุณจะพบว่าบางประเภทไม่ตรงกับที่คุณคาดหวัง แต่การหาเหตุผลอาจทำให้น่าเบื่อ

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


0

คุณอาจสนใจ Haskell - มันเป็นระบบประเภท infers ประเภทจากรหัสและคุณสามารถระบุประเภทเช่นกัน


5
Haskell เป็นภาษาที่ยอดเยี่ยม มันตรงกันข้ามกับภาษาแบบไดนามิก: คุณใช้เวลามากในการอธิบายประเภทและโดยปกติเมื่อคุณคิดว่าประเภทของคุณแล้วโปรแกรมจะทำงาน :)
9000

@ 9000: แน่นอน เมื่อรวบรวมแล้วจะใช้งานได้ตามปกติ :)
Macke

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

0

ตามคำตอบอื่น ๆ ที่ได้กล่าวถึงมีสองวิธีในการพิมพ์เมื่อใช้ภาษาการเขียนโปรแกรม

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

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


0

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

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

และจะมีการพูดถึงมีภาษาแบบไดนามิกอื่น ๆ แม้ที่อนุญาตให้โปรแกรมเมอร์เพื่อระบุประเภท ตัวอย่างเช่นGroovyเป็นหนึ่งในภาษาไดนามิกที่มีชื่อเสียงที่ทำงานบน JVM และมันก็มีชื่อเสียงมากในช่วงไม่กี่วันที่ผ่านมา โปรดทราบว่าประสิทธิภาพของ Groovy นั้นเหมือนกับ Java

หวังว่ามันจะช่วยคุณ


-1

มันก็ไม่สมเหตุสมผลที่จะทำเช่นนั้น

ทำไม?

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


1
ทำไม? มันทำให้รู้สึกที่สมบูรณ์แบบในการบอกใบ้คอมไพเลอร์เกี่ยวกับประเภทที่คาดหวัง มันจะไม่ขัดแย้งกับข้อ จำกัด ของระบบประเภทใด ๆ
SK-logic

1
SK-logic: หากพิมพ์แบบไดนามิกหมายความว่าทุกฟังก์ชั่น / วิธี / การดำเนินการใช้วัตถุประเภท "ไดนามิก", "ใด ๆ " หรืออะไรก็ตามและส่งกลับ "ไดนามิก", "ใด ๆ " สิ่งใดก็ตามโดยทั่วไปไม่มีทางที่จะบอกได้ว่า จะเป็นจำนวนเต็มเสมอ ดังนั้นรหัสรันไทม์จะต้องตรวจสอบว่าไม่ใช่จำนวนเต็มเช่นเดียวกับประเภทเป็น "ไดนามิก" ในสถานที่แรก นี่เป็นเพียงสิ่งที่ระบบการพิมพ์แบบคงที่ไม่: มันทำให้มันเป็นไปได้ที่จะ Proove ว่าตัวแปรบางข้อมูลหรือวิธีการกลับมาจะมักจะมีบางประเภท
Ingo

@Ingo ไม่มีวิธี ดูว่ามีการนำไปใช้ใน Common LISP อย่างไร มันมีประโยชน์อย่างยิ่งสำหรับตัวแปรท้องถิ่น - คุณสามารถเพิ่มประสิทธิภาพได้อย่างมากโดยการแนะนำคำแนะนำการพิมพ์ทั้งหมด
SK-logic

@ SK-logic: บางทีคุณสามารถบอกได้ว่าเมื่อใดและตรวจพบข้อผิดพลาดประเภทใน CL ได้อย่างไร? อย่างไรก็ตาม @MainMa ได้สรุปสถานะที่ค่อนข้างเป็นอย่างดีในคำถามของเขา / เธอ: มันเป็นเพียงสิ่งที่เราคาดหวังได้จากภาษาพลวัต "ล้วนๆ"
Ingo

@Ingo อะไรทำให้คุณคิดว่าประเภทนั้นมีประโยชน์สำหรับการพิสูจน์ความถูกต้องแบบคงที่เท่านั้น? มันไม่เป็นความจริงสำหรับแม้แต่ภาษาอย่าง C ซึ่งคุณมีการคัดเลือกนักแสดงที่ไม่ได้เลือก คำอธิบายประกอบประเภทในภาษาแบบไดนามิกส่วนใหญ่มีประโยชน์เป็นคำแนะนำคอมไพเลอร์ที่ปรับปรุงประสิทธิภาพหรือระบุการแสดงตัวเลขที่เป็นรูปธรรม ฉันยอมรับว่าในกรณีส่วนใหญ่คำอธิบายประกอบไม่ควรเปลี่ยนซีแมนทิกส์ของรหัส
SK-logic

-1

ลองดูที่ Go บนพื้นผิวมันจะถูกพิมพ์แบบคงที่ แต่ประเภทเหล่านั้นอาจเป็นอินเตอร์เฟซที่เป็นแบบไดนามิกเป็นหลัก

โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.