การเขียนโปรแกรมเชิงขั้นตอนคืออะไร? มันแตกต่างจาก OOP อย่างไร? มันเหมือนกับการเขียนโปรแกรมฟังก์ชั่น?

ฉันกำลังเขียนโปรแกรมในJavaในรูปแบบ object-oriented (OO) OOP มาถึงฉันอย่างสังหรณ์ใจ แต่ฉันมีความรู้น้อยมากเกี่ยวกับการเขียนโปรแกรมชนิดอื่น

การเขียนโปรแกรมเชิงขั้นตอนคืออะไร? มันแตกต่างจาก OOP อย่างไร? มันเป็นสิ่งเดียวกับการเขียนโปรแกรมฟังก์ชั่น ?

ฉันเคยคิดว่าการเขียนโปรแกรมทั้งหมดที่ไม่ใช่ OO นั้นเป็นขั้นตอน แต่ฉันเริ่มคิดว่ามันไม่เป็นความจริง

Wikipedia มีคำอธิบายที่ดีสำหรับคำเหล่านี้ นี่คือบทสรุป:

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

• การเขียนโปรแกรมเชิงตรงข้ามของการเขียนโปรแกรมที่จำเป็น - มันระบุสิ่งที่จะคำนวณมากกว่าวิธี (เช่น SQL, regexes)

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

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

• การเขียนโปรแกรมเชิงวัตถุเน้นการใช้วัตถุ / ส่วนต่อประสานเพื่อให้ได้นามธรรมและต้นแบบ

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

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

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

นอกจากนี้ผู้คนมักจะโยนสลับกันไปตามความจำเป็น / กระบวนการแทนกันบางครั้งตัดกับ OOP (หมายถึงรหัส abstraction-less code, โดยทั่วไป C) และบางครั้งก็แตกต่างกับการเขียนโปรแกรมการทำงาน การเขียนโปรแกรมแบบโครงสร้างคำได้ส่วนใหญ่หลุดจากการใช้งานเท่าที่ฉันสามารถบอกได้ (น่าจะเป็นเพราะ ณ จุดนี้คนส่วนใหญ่ใช้เพื่อรับที่ goto และกลมกลืนถือว่าเป็นอันตราย)

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

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

ขั้นพื้นฐานเป็นขั้นตอน

อย่างที่คนอื่น ๆ พูดกันมันเป็นกลไกสำหรับการจัดโครงสร้างโปรแกรมในลักษณะต่อเนื่อง

• ก่อนอื่นฉันต้อง x
• ประการที่สองฉันทำ y
• ประการที่สามฉันทำ Z

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

กระบวนทัศน์ไม่ได้กำหนดสิ่งที่คุณทำจะเป็นหรือลักษณะของสิ่งที่ผ่านไป

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

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

วิธีคิดอย่างหนึ่งคือขอบเขตข้อมูล

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

ในภาษาเชิงวัตถุคุณเพิ่มบริบทการกำหนดขอบเขตใหม่ให้เป็นของวัตถุที่ใช้งานในปัจจุบันซึ่งเป็นมุมฉากข้างต้น

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

ขั้นตอนการเขียนโปรแกรมไม่ใช่โปรแกรมที่ใช้งานได้แน่นอน

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

โปรแกรมการทำงานจะได้รับการพูดAคือ 3 และBเป็นแล้วปล่อยให้ร่างคอมพิวเตอร์วิธีการคำนวณA + 1 Bเมื่อคุณกำหนดAแล้วมันควรจะไม่เปลี่ยนรูป (ไม่เปลี่ยนแปลง) ฟังก์ชั่นยังช่วยให้คุณทำสิ่งต่าง ๆ เช่นผ่านฟังก์ชั่นไปรอบ ๆ เป็นค่าชั้นหนึ่ง (ฟังก์ชั่นสามารถใช้ฟังก์ชั่นเป็นอาร์กิวเมนต์)

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

OOP ไม่ได้เป็นเพียงแค่รูปแบบการเขียนโปรแกรมขั้นตอนที่ละเอียดอ่อนอีกต่อไป หลักฐานการอ้างสิทธิ์นั้นคือโปรแกรมเมอร์ C # / Java หลายคนมักจะ "ทำอะไรบางอย่าง" และชอบวิธีการเช่น:

void doThisAndThat(....) { ... do something ... }

ดังนั้นโปรแกรมที่ประกอบด้วยกลุ่มของวิธีการโมฆะ (เดิมเรียกว่าขั้นตอน (sic!)) และรหัสเช่น:

doThis();
if (state is that) doSomethingElse();
doThat();

เป็นโปรแกรมขั้นตอนที่สมบูรณ์แบบ