การพิมพ์ทางสถิติ โปรแกรมการศึกษาเกี่ยวกับการพิมพ์ในภาษาโปรแกรม ดูว่า "การพิมพ์ที่หนักแน่น" ในพจนานุกรมอื่น ๆ คืออะไร

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

ไม่ต้องกังวล ฉันรู้ว่าทั้งหมดนี้ฟังดูน่าสับสน ดังนั้นเรามาเริ่มกันที่พื้นฐานกันก่อน “การจับคู่ประเภท” คืออะไร และประเภทคืออะไร

พิมพ์

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

ความเข้าใจผิดที่พบบ่อย

เรื่องที่ 1: การพิมพ์แบบคงที่/ไดนามิก == การพิมพ์มาก/น้อย

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

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

เอ็กซ์ = 1 + "2"

เรามักจะเชื่อมโยงภาษาที่พิมพ์แบบคงที่เช่น Java และ C# กับการพิมพ์ที่เข้มงวด (ซึ่งก็คือ) เนื่องจากประเภทข้อมูลได้รับการตั้งค่าอย่างชัดเจนเมื่อมีการเตรียมใช้งานตัวแปร - ดังในตัวอย่าง Java นี้:

String foo = new String("สวัสดีชาวโลก");

อย่างไรก็ตาม Ruby, Python และ JavaScript (ที่พิมพ์แบบไดนามิกทั้งหมด) จะถูกพิมพ์อย่างเข้มงวดเช่นกัน แม้ว่านักพัฒนาจะไม่จำเป็นต้องระบุประเภทของตัวแปรเมื่อประกาศ ลองดูตัวอย่างเดียวกัน แต่เขียนด้วยภาษา Ruby:

ฟู = "สวัสดีชาวโลก"

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

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

$foo = "x"; $ฟู = $ฟู + 2; // ไม่ใช่ข้อผิดพลาด echo $foo; // 2

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

ตำนานได้ถูกทำลายลงแล้ว

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

เรื่องที่ 2: การพิมพ์แบบคงที่/ไดนามิก == ภาษาที่คอมไพล์/ตีความ

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

เมื่อเราพูดถึงการพิมพ์ภาษา เราจะพูดถึงภาษาโดยรวม ตัวอย่างเช่น ไม่สำคัญว่าคุณใช้ Java เวอร์ชันใด - Java นั้นจะพิมพ์แบบคงที่เสมอ สิ่งนี้แตกต่างจากกรณีที่รวบรวมหรือตีความภาษา เนื่องจากในกรณีนี้ เรากำลังพูดถึงการนำภาษาไปใช้โดยเฉพาะ ตามทฤษฎีแล้ว ภาษาใดๆ ก็ตามสามารถรวบรวมหรือตีความได้ การใช้งานภาษา Java ที่ได้รับความนิยมมากที่สุดใช้การคอมไพล์เป็น bytecode ซึ่งถูกตีความโดย JVM - แต่มีการใช้งานภาษาอื่น ๆ ที่คอมไพล์โดยตรงกับรหัสเครื่องหรือถูกตีความตามที่เป็นอยู่

หากยังไม่ชัดเจน แนะนำให้อ่านชุดนี้ครับ

บทสรุป

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

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

เพื่ออธิบายเทคโนโลยีที่แตกต่างกันอย่างสิ้นเชิงสองเทคโนโลยีให้ง่ายที่สุดเท่าที่จะเป็นไปได้ เรามาเริ่มกันตั้งแต่ต้นเลย สิ่งแรกที่โปรแกรมเมอร์พบเมื่อเขียนโค้ดคือการประกาศตัวแปร คุณอาจสังเกตเห็นว่า ตัวอย่างเช่น ในภาษาการเขียนโปรแกรม C++ คุณต้องระบุประเภทของตัวแปร นั่นคือ หากคุณประกาศตัวแปร x คุณจะต้องเพิ่ม int - สำหรับจัดเก็บข้อมูลจำนวนเต็ม, float - สำหรับจัดเก็บข้อมูลจุดลอยตัว, char - สำหรับข้อมูลอักขระ และประเภทอื่นๆ ที่มีอยู่ ดังนั้น C++ จึงใช้การพิมพ์แบบคงที่ เช่นเดียวกับ C รุ่นก่อน

การพิมพ์แบบคงที่ทำงานอย่างไร

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

ลองดูตัวอย่างเล็กๆ น้อยๆ เมื่อเริ่มต้นตัวแปร x (int x;) เราจะระบุตัวระบุ int - นี่เป็นคำย่อที่เก็บเฉพาะจำนวนเต็มในช่วงตั้งแต่ - 2,147,483,648 ถึง 2,147,483,647 ด้วยวิธีนี้คอมไพเลอร์รู้ว่ามันสามารถดำเนินการค่าทางคณิตศาสตร์ในสิ่งนี้ ตัวแปร - ผลรวม ผลต่าง การคูณ และการหาร แต่ตัวอย่างเช่น ฟังก์ชัน strcat() ซึ่งเชื่อมต่อค่าอักขระสองตัว ไม่สามารถใช้กับ x ได้ ท้ายที่สุดหากคุณลบข้อ จำกัด และพยายามเชื่อมต่อค่า int สองค่าโดยใช้วิธีสัญลักษณ์ก็จะเกิดข้อผิดพลาดขึ้น

เหตุใดจึงต้องมีภาษาที่พิมพ์แบบไดนามิก

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

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

พิมพ์แบบไหนดีกว่ากัน?

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

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

แบ่งเป็นประเภท "แข็งแกร่ง" และ "อ่อนแอ"

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

คุณสมบัติไดนามิก

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

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

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

สถาปัตยกรรมที่อยู่ติดกันเป็นไปได้หรือไม่?

ในขณะนี้ ยังไม่มีเทคโนโลยีที่เกี่ยวข้องที่สามารถรองรับการพิมพ์แบบคงที่และไดนามิกในภาษาการเขียนโปรแกรมไปพร้อมๆ กัน และเราก็บอกได้เลยว่าจะไม่ปรากฏอย่างแน่นอน เนื่องจากสถาปัตยกรรมที่แตกต่างกันในแนวคิดพื้นฐานและไม่สามารถใช้พร้อมกันได้

แต่อย่างไรก็ตาม ในบางภาษา คุณสามารถเปลี่ยนการพิมพ์ได้โดยใช้เฟรมเวิร์กเพิ่มเติม

• ในภาษาการเขียนโปรแกรม Delphi - ระบบย่อย Variant
• ในภาษาการเขียนโปรแกรม AliceML มีแพ็คเกจเพิ่มเติม
• ในภาษาการเขียนโปรแกรม Haskell - ไลบรารี Data.Dynamic

การพิมพ์ที่แข็งแกร่งจะดีกว่าการพิมพ์แบบไดนามิกเมื่อใด

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

ประโยชน์ของการพิมพ์แบบไดนามิก

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

เรียนรู้เพิ่มเติมเกี่ยวกับภาษาการเขียนโปรแกรมแบบคงที่

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

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

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

ข้อมูลเพิ่มเติมเกี่ยวกับภาษาโปรแกรมด้วยการพิมพ์แบบไดนามิก

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

• PHP เป็นภาษาสำหรับสร้างสคริปต์ มีการใช้กันอย่างแพร่หลายในการพัฒนาเว็บ โดยจัดให้มีการโต้ตอบกับฐานข้อมูลเพื่อสร้างเว็บเพจไดนามิกเชิงโต้ตอบ การพิมพ์แบบไดนามิกทำให้การทำงานกับฐานข้อมูลง่ายขึ้นมาก

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

ประเภทการพิมพ์แบบไดนามิก - ข้อเสีย

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

สรุป

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

การพิมพ์ - การกำหนดประเภทให้กับเอนทิตีข้อมูล

ประเภทข้อมูลดั้งเดิมที่พบบ่อยที่สุดคือ:

• ตัวเลข
• สัญลักษณ์
• ตรรกะ

หน้าที่หลักของระบบประเภทข้อมูล:

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

การจัดหมวดหมู่

การพิมพ์ภาษาโปรแกรมมีหลายประเภท แต่มีเพียง 3 ประเภทหลักเท่านั้น:

การพิมพ์แบบคงที่/ไดนามิก

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

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

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

การพิมพ์แบบไดนามิก

เลขนำโชค = 777; var siteName = "Tyapk"; // เราถือว่าตัวเลข เขียนสตริง var wrongNumber = "999";

การพิมพ์แบบคงที่

ให้ LuckyNumber: หมายเลข = 777; ให้ชื่อไซต์: string = "Tyapk"; // จะทำให้เกิดข้อผิดพลาด ให้ผิดหมายเลข: number = "999";

• คงที่: Java, C#, TypeScript
• ไดนามิก: Python, Ruby, JavaScript

การพิมพ์ที่ชัดเจน/โดยนัย

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

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

การพิมพ์โดยนัย

ให้ stringVar = "777" + 99; // รับ "77799"

การพิมพ์ที่ชัดเจน (ภาษาสมมติคล้ายกับ JS)

ให้ wrongStringVar = "777" + 99; // จะทำให้เกิดข้อผิดพลาด ให้ stringVar = "777" + String(99); // รับ "77799"

พิมพ์แรง/ไม่แรง

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

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

การพิมพ์ที่แข็งแกร่ง (ภาษาสมมติคล้ายกับ JS)

ให้ผิดหมายเลข = 777; wrongNumber = หมายเลขผิด + "99"; // เราได้รับข้อผิดพลาดว่ามีการเพิ่มสตริงลงในตัวแปรตัวเลข wrongNumber ให้ trueNumber = 777 + Number("99"); // ได้ 876

การพิมพ์ที่ไม่เข้มงวด (เหมือนใน js)

ให้ผิดหมายเลข = 777; wrongNumber = หมายเลขผิด + "99"; // ได้สตริง "77799"

• เข้มงวด: Java, Python, Haskell, Lisp
• ไม่จำกัด: C, JavaScript, Visual Basic, PHP

ทุกอย่างง่ายมาก มันเหมือนกับความแตกต่างระหว่างโรงแรมและอพาร์ตเมนต์ส่วนตัว

เฉพาะผู้ที่ลงทะเบียนที่นั่นเท่านั้นที่อาศัยอยู่ในอพาร์ตเมนต์ หากพูดว่าครอบครัว Sidorov อาศัยอยู่ในนั้นครอบครัว Pupkin ก็ไม่สามารถอยู่ที่นั่นตลอดชีวิตของเราได้ ในเวลาเดียวกัน Petya Sidorov สามารถอาศัยอยู่ในอพาร์ทเมนต์นี้ได้จากนั้น Grisha Sidorov ก็สามารถย้ายไปที่นั่นได้ (บางครั้งพวกเขาสามารถอาศัยอยู่ที่นั่นพร้อมกันได้ - นี่คืออาร์เรย์) นี่คือการพิมพ์แบบคงที่

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

หากเรากลับมาที่การเขียนโปรแกรมก็จะพบกรณีแรก (การพิมพ์แบบคงที่) เช่นภาษา C, C++, C#, Java และอื่น ๆ ก่อนที่คุณจะกำหนดค่าให้กับตัวแปรเป็นครั้งแรก คุณต้องบอกว่าคุณจะเก็บอะไรไว้ที่นั่น เช่น จำนวนเต็ม ตัวเลขทศนิยม สตริง ฯลฯ ( Sidorovs จะอาศัยอยู่ในอพาร์ตเมนต์นี้). ในทางกลับกัน การพิมพ์แบบไดนามิกไม่ต้องการสิ่งนี้ เมื่อคุณกำหนดค่า คุณจะกำหนดประเภทของตัวแปรไปพร้อมๆ กัน ( ตอนนี้ Vasya Pupkin จากครอบครัว Pupkin อาศัยอยู่ในห้องพักของโรงแรมแห่งนี้). พบได้ในภาษาต่างๆ เช่น PHP, Python และ JavaScript

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

ด้วยการพิมพ์แบบคงที่ คุณจะทราบประเภทของตัวแปรในขณะที่เขียนโปรแกรมและพัฒนาอัลกอริทึมอย่างแม่นยำและคำนึงถึงสิ่งนี้ด้วย เหล่านั้น. หากคุณบอกว่าตัวแปร G เป็นจำนวนเต็มสี่ไบต์ที่ไม่ได้ลงชื่อ ดังนั้นในอัลกอริทึมมันจะเป็นจำนวนเต็มสี่ไบต์ที่ไม่ได้ลงนามเสมอ (หากมีสิ่งใด คุณจะต้องแปลงมันอย่างชัดเจนหรือรู้ว่านักแปลแปลงมันในค่าใดค่าหนึ่งอย่างไร ช่วงของสถานการณ์ แต่ส่วนใหญ่หากมีประเภทไม่ตรงกันจะเป็นข้อผิดพลาดในอัลกอริทึมและอย่างน้อยคอมไพเลอร์จะเตือนคุณ) ด้วยรูปแบบคงที่คุณไม่สามารถใส่สตริง "Vasya the Fool" ลงในตัวเลขได้ และการตรวจสอบเพิ่มเติมก่อนที่จะใช้ตัวแปรเพื่อพิจารณาว่า "มีตัวเลขอยู่หรือไม่" คุณดำเนินการความถูกต้องของข้อมูลทั้งหมด ณ เวลาที่เข้าสู่โปรแกรมหรือตามที่กำหนดโดยอัลกอริทึมเอง

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

ข้อกำหนดเบื้องต้น

การพิมพ์ที่เข้มงวดหมายถึงการปฏิบัติตามเงื่อนไขบังคับต่อไปนี้:

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

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

การพิมพ์ในภาษาโปรแกรม

ลิงค์

ดูสิ่งนี้ด้วย

มูลนิธิวิกิมีเดีย 2010.

ดูว่า "การพิมพ์ที่หนักแน่น" ในพจนานุกรมอื่น ๆ คืออะไร:

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

การพิมพ์ข้อมูล ประเภทความปลอดภัย การอนุมานประเภท การพิมพ์แบบไดนามิก การพิมพ์แบบคงที่ การพิมพ์แบบเข้ม การพิมพ์แบบอ่อน การพิมพ์แบบเป็ด บทความหลัก: การพิมพ์แบบเข้ม การพิมพ์แบบไดนามิกเป็นเทคนิคที่ใช้กันอย่างแพร่หลาย... ... วิกิพีเดีย

การพิมพ์ข้อมูล ประเภทความปลอดภัย การอนุมานประเภท การพิมพ์แบบไดนามิก การพิมพ์แบบคงที่ การพิมพ์แบบเข้ม การพิมพ์แบบอ่อน การพิมพ์แบบเป็ด บทความหลัก: การพิมพ์แบบเข้ม การพิมพ์แบบคงที่เป็นเทคนิคที่ใช้กันอย่างแพร่หลาย... ... Wikipedia

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

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

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

- (พบคำว่าประเภทข้อมูลด้วย) เป็นแนวคิดพื้นฐานของทฤษฎีการเขียนโปรแกรม ประเภทข้อมูลกำหนดชุดของค่า ชุดของการดำเนินการที่สามารถนำไปใช้กับค่าดังกล่าว และอาจเป็นวิธีการใช้การจัดเก็บค่าและ... ... Wikipedia

ประเภทข้อมูล เนื้อหา 1 ประวัติ 2 คำจำกัดความ 3 ความจำเป็นในการใช้ประเภทข้อมูล ... Wikipedia

คำนี้มีความหมายอื่น ดูที่ ม.ล. (ความหมาย) ML Semantics: หลายกระบวนทัศน์: การทำงาน, ความจำเป็น, แบบแยกส่วน ปรากฏใน: 1973 ผู้แต่ง: Robin Milner และคณะ มหาวิทยาลัยเอดินบะระ ... Wikipedia