雖然這篇scotch.io javascript鄉民發文沒有被收入到精華區：在scotch.io javascript這個話題中，我們另外找到其它相關的精選爆讚文章
在 scotch.io產品中有5篇Facebook貼文，粉絲數超過16萬的網紅โปรแกรมเมอร์ไทย Thai programmer，也在其Facebook貼文中提到， วันนี้คุณรู้จัก SOLID หลักการออกแบบโปรแกรมเชิงวัตถุ ที่ดีหรือยัง ว่าเป็นยังไง? . SOLID เป็นหลักการออกแบบการเขียนโปรแกรมเชิงวัตถุที่ดี (Object Orie...
scotch.io 在 โปรแกรมเมอร์ไทย Thai programmer Facebook 的最佳貼文
วันนี้คุณรู้จัก SOLID
หลักการออกแบบโปรแกรมเชิงวัตถุ ที่ดีหรือยัง ว่าเป็นยังไง?
.
SOLID เป็นหลักการออกแบบการเขียนโปรแกรมเชิงวัตถุที่ดี (Object Oriented Design) นำเสนอโดย Robert C. Martin (ลุง Bob. )
:
SOLID ไม่ได้หมายถึง "ของแข็ง"
แต่มันมาจากชื่อพยัญชนะแรกของ 5 คำต่อไปนี้
- Single-responsibility Principle
- Open-closed Principle
- Liskov substitution principle
- Interface segregation principle
- Dependency Inversion principle
:
รายละเอียดก็จะประมาณเนี่ย สรุปให้คร่าวๆ
👉 1) Single-responsibility Principle
หลักการนี้ จะให้คลาส 1 อัน รับผิดชอบงานเดียว
ถ้าอนาคตจะมี change เกิดขึ้น
ก็เปลี่ยนเฉพาะงานนี้งานเดียว ที่คลาสนี้ที่เดียวเท่านั้น
จะไม่มีการ change มากกว่า 2 งานภายในคลาสเดียวกันประมาณเนี่ย
มิฉะนั้นจะตีกันตายได้
:
👉 2) Open-closed Principle
หลักการนี้ อ็อบเจ็กต์ หรือพวก คลาส มอดูล ฟังก์ชั่น แพ็กเกจ ไลบรารี่
เมื่อสร้างแล้วก็ควรฟิกไว้ ไม่ควรแก้ไข (เพราะมันอาจเทสเรียบร้อยแล้ว)
ถ้ามี change เกิดขึ้นมา ก็ต้องเปิดโอกาสให้ขยายต่อเติมได้
โดยเราจะไม่ไปแตะต้องโค้ดที่เคยเขียนขึ้นมาเด็ดขาด
:
👉 3) Liskov substitution principle
มันพัฒนามาจากหลักการข้อ 2 อีกที กล่าวคือ
คลาสแม่ควรจะฟิกไว้ ไม่ควรแก้ไข ไม่ควร change อีกแล้ว
(เพราะอาจเทสเรียบร้อย หรือออกแบบมาเรียบร้อย)
ถ้าจะ change ก็ให้ไปลงที่คลาสลูกเลย
โดยให้สร้างคลาสลูก ที่ขยายมาจากคลาสแม่อีกที
.
สำหรับหลักการข้อ 3 นี้ คลาสลูกจะสามารถเสียบแทนที่คลาสแม่ได้
โดยจะไม่ไปแก้ไขหน้าที่ (functionality) ของโค้ดหลักทั้งหมด
:
👉 4) Interface segregation principle
การออกแบบ interface ที่ดี ควรมีเมธอดที่จำเป็นเท่านั้น
คลาสลูกที่มา implement ไม่ควรได้เมธอดที่ไม่จำเป็นเกินมา
.
กล่าวอีกนัยหนึ่งการออกแบบ interface ที่ดี
ไม่ควรให้ interface มันทำงานครอบจักราล
ไม่ต้องใจดี เผื่อเมธอดเกินมา
ให้มีพอเพียง พอดีกับคลาสลูกก็พอนะครัช
:
👉 5) Dependency Inversion principle
หลักการนี้จะกล่าวถึง
- High level classess (อาจมองว่าเป็นมอดูลที่มีแต่ business logic ที่ซับซ้อนก็ได้)
- กับ Low Level Classes (อาจมองว่าเป็นมอดูลที่มีแต่ logic พื้นฐาน ทำงานระดับล่างๆ)
.
ซึ่ง class ทั้งสองระดับดังกล่าว
เวลาจะติดต่อกัน ก็ให้ทำผ่านทาง Abstraction Layer เท่านั้น
ไม่ควรติดต่อกันตรงๆ โต้งๆ
.
Abstraction Layer ก็คิดง่ายๆ
มันก็คือ Interface หรือ abstraction class นั่นแหละ
คือมีแต่รายละเอียดให้รู้เฉยๆ ยังไม่มีส่วน implements
เพราะเดียวจะมีคลาสมา implements แล้วมา plugin เสียบเข้าภายหลัง
.
..เขียนเป็นภาพก็ประมาณเนี่ย
High Level Classes --> Abstraction Layer --> Low Level Classes
:
++++++++
สำหรับคอนเซปต์ SOLID อาจยากต่อการเข้าใจนิดหนึ่งนะ
มันต้องเห็นโค้ดตัวอย่างด้วย
ยิ่งถ้าใครไม่เชียวชาญการเขียนโปรแกรมเชิงวัตถุ (Object Oriented programming)
หรือไม่ได้ลงมือเขียนจริงๆ จังเท่าไร
ก็อาจสงสัยมีมันทำไม?
.
แต่ทว่าการเขียนโปรแกรมเชิงวัตถุ ถ้าออกแบบไม่ดีนี้ ....บอกตรงๆ
..โค้ดจะเละ เทอะทะ ใหญ่โต
..อ่านโค้ดก็ยาก ย๊าก คลาสเยอะแยะมากมาย
.
ยังไงอ่านเพิ่มเติม ดูโค้ดตัวอย่างที่ออกแบบตามหลัก SOLID
ตามลิงค์นี้เขียนดี
https://www.oodesign.com/design-principles.html
https://scotch.io/…/s-o-l-i-d-the-first-five-principles-of-…
.
😘 โชคดีทุกท่านครับ ไปแหละ
เขียนโดยโปรแกรมเมอร์ไทย thai programmer
scotch.io 在 โปรแกรมเมอร์ไทย Thai programmer Facebook 的精選貼文
วันนี้คุณรู้จัก SOLID
หลักการออกแบบโปรแกรมเชิงวัตถุ ที่ดีหรือยัง ว่าเป็นยังไง?
.
SOLID เป็นหลักการออกแบบการเขียนโปรแกรมเชิงวัตถุที่ดี (Object Oriented Design) นำเสนอโดย Robert C. Martin (ลุง Bob. )
:
SOLID ไม่ได้หมายถึง "ของแข็ง"
แต่มันมาจากชื่อพยัญชนะแรกของ 5 คำต่อไปนี้
- Single-responsibility Principle
- Open-closed Principle
- Liskov substitution principle
- Interface segregation principle
- Dependency Inversion principle
:
รายละเอียดก็จะประมาณเนี่ย สรุปให้คร่าวๆ
👉 1) Single-responsibility Principle
หลักการนี้ จะให้คลาส 1 อัน รับผิดชอบงานเดียว
ถ้าอนาคตจะมี change เกิดขึ้น
ก็เปลี่ยนเฉพาะงานนี้งานเดียว ที่คลาสนี้ที่เดียวเท่านั้น
จะไม่มีการ change มากกว่า 2 งานภายในคลาสเดียวกันประมาณเนี่ย
มิฉะนั้นจะตีกันตายได้
:
👉 2) Open-closed Principle
หลักการนี้ อ็อบเจ็กต์ หรือพวก คลาส มอดูล ฟังก์ชั่น แพ็กเกจ ไลบรารี่
เมื่อสร้างแล้วก็ควรฟิกไว้ ไม่ควรแก้ไข (เพราะมันอาจเทสเรียบร้อยแล้ว)
ถ้ามี change เกิดขึ้นมา ก็ต้องเปิดโอกาสให้ขยายต่อเติมได้
โดยเราจะไม่ไปแตะต้องโค้ดที่เคยเขียนขึ้นมาเด็ดขาด
:
👉 3) Liskov substitution principle
มันพัฒนามาจากหลักการข้อ 2 อีกที กล่าวคือ
คลาสแม่ควรจะฟิกไว้ ไม่ควรแก้ไข ไม่ควร change อีกแล้ว
(เพราะอาจเทสเรียบร้อย หรือออกแบบมาเรียบร้อย)
ถ้าจะ change ก็ให้ไปลงที่คลาสลูกเลย
โดยให้สร้างคลาสลูก ที่ขยายมาจากคลาสแม่อีกที
.
สำหรับหลักการข้อ 3 นี้ คลาสลูกจะสามารถเสียบแทนที่คลาสแม่ได้
โดยจะไม่ไปแก้ไขหน้าที่ (functionality) ของโค้ดหลักทั้งหมด
:
👉 4) Interface segregation principle
การออกแบบ interface ที่ดี ควรมีเมธอดที่จำเป็นเท่านั้น
คลาสลูกที่มา implement ไม่ควรได้เมธอดที่ไม่จำเป็นเกินมา
.
กล่าวอีกนัยหนึ่งการออกแบบ interface ที่ดี
ไม่ควรให้ interface มันทำงานครอบจักราล
ไม่ต้องใจดี เผื่อเมธอดเกินมา
ให้มีพอเพียง พอดีกับคลาสลูกก็พอนะครัช
:
👉 5) Dependency Inversion principle
หลักการนี้จะกล่าวถึง
- High level classess (อาจมองว่าเป็นมอดูลที่มีแต่ business logic ที่ซับซ้อนก็ได้)
- กับ Low Level Classes (อาจมองว่าเป็นมอดูลที่มีแต่ logic พื้นฐาน ทำงานระดับล่างๆ)
.
ซึ่ง class ทั้งสองระดับดังกล่าว
เวลาจะติดต่อกัน ก็ให้ทำผ่านทาง Abstraction Layer เท่านั้น
ไม่ควรติดต่อกันตรงๆ โต้งๆ
.
Abstraction Layer ก็คิดง่ายๆ
มันก็คือ Interface หรือ abstraction class นั่นแหละ
คือมีแต่รายละเอียดให้รู้เฉยๆ ยังไม่มีส่วน implements
เพราะเดียวจะมีคลาสมา implements แล้วมา plugin เสียบเข้าภายหลัง
.
..เขียนเป็นภาพก็ประมาณเนี่ย
High Level Classes --> Abstraction Layer --> Low Level Classes
:
++++++++
สำหรับคอนเซปต์ SOLID อาจยากต่อการเข้าใจนิดหนึ่งนะ
มันต้องเห็นโค้ดตัวอย่างด้วย
ยิ่งถ้าใครไม่เชียวชาญการเขียนโปรแกรมเชิงวัตถุ (Object Oriented programming)
หรือไม่ได้ลงมือเขียนจริงๆ จังเท่าไร
ก็อาจสงสัยมีมันทำไม?
.
แต่ทว่าการเขียนโปรแกรมเชิงวัตถุ ถ้าออกแบบไม่ดีนี้ ....บอกตรงๆ
..โค้ดจะเละ เทอะทะ ใหญ่โต
..อ่านโค้ดก็ยาก ย๊าก คลาสเยอะแยะมากมาย
.
ยังไงอ่านเพิ่มเติม ดูโค้ดตัวอย่างที่ออกแบบตามหลัก SOLID
ตามลิงค์นี้เขียนดี
https://www.oodesign.com/design-principles.html
https://scotch.io/…/s-o-l-i-d-the-first-five-principles-of-…
.
😘 โชคดีทุกท่านครับ ไปแหละ
เขียนโดยโปรแกรมเมอร์ไทย thai programmer
scotch.io 在 โปรแกรมเมอร์ไทย Thai programmer Facebook 的最佳貼文
วันนี้คุณรู้จัก SOLID
หลักการออกแบบโปรแกรมเชิงวัตถุ ที่ดีหรือยัง ว่าเป็นยังไง?
.
SOLID เป็นหลักการออกแบบการเขียนโปรแกรมเชิงวัตถุที่ดี (Object Oriented Design) นำเสนอโดย Robert C. Martin (ลุง Bob. )
:
SOLID ไม่ได้หมายถึง "ของแข็ง"
แต่มันมาจากชื่อพยัญชนะแรกของ 5 คำต่อไปนี้
- Single-responsibility Principle
- Open-closed Principle
- Liskov substitution principle
- Interface segregation principle
- Dependency Inversion principle
:
รายละเอียดก็จะประมาณเนี่ย สรุปให้คร่าวๆ
👉 1) Single-responsibility Principle
หลักการนี้ จะให้คลาส 1 อัน รับผิดชอบงานเดียว
ถ้าอนาคตจะมี change เกิดขึ้น
ก็เปลี่ยนเฉพาะงานนี้งานเดียว ที่คลาสนี้ที่เดียวเท่านั้น
จะไม่มีการ change มากกว่า 2 งานภายในคลาสเดียวกันประมาณเนี่ย
มิฉะนั้นจะตีกันตายได้
:
👉 2) Open-closed Principle
หลักการนี้ อ็อบเจ็กต์ หรือพวก คลาส มอดูล ฟังก์ชั่น แพ็กเกจ ไลบรารี่
เมื่อสร้างแล้วก็ควรฟิกไว้ ไม่ควรแก้ไข (เพราะมันอาจเทสเรียบร้อยแล้ว)
ถ้ามี change เกิดขึ้นมา ก็ต้องเปิดโอกาสให้ขยายต่อเติมได้
โดยเราจะไม่ไปแตะต้องโค้ดที่เคยเขียนขึ้นมาเด็ดขาด
:
👉 3) Liskov substitution principle
มันพัฒนามาจากหลักการข้อ 2 อีกที กล่าวคือ
คลาสแม่ควรจะฟิกไว้ ไม่ควรแก้ไข ไม่ควร change อีกแล้ว
(เพราะอาจเทสเรียบร้อย หรือออกแบบมาเรียบร้อย)
ถ้าจะ change ก็ให้ไปลงที่คลาสลูกเลย
โดยให้สร้างคลาสลูก ที่ขยายมาจากคลาสแม่อีกที
.
สำหรับหลักการข้อ 3 นี้ คลาสลูกจะสามารถเสียบแทนที่คลาสแม่ได้
โดยจะไม่ไปแก้ไขหน้าที่ (functionality) ของโค้ดหลักทั้งหมด
:
👉 4) Interface segregation principle
การออกแบบ interface ที่ดี ควรมีเมธอดที่จำเป็นเท่านั้น
คลาสลูกที่มา implement ไม่ควรได้เมธอดที่ไม่จำเป็นเกินมา
.
กล่าวอีกนัยหนึ่งการออกแบบ interface ที่ดี
ไม่ควรให้ interface มันทำงานครอบจักราล
ไม่ต้องใจดี เผื่อเมธอดเกินมา
ให้มีพอเพียง พอดีกับคลาสลูกก็พอนะครัช
:
👉 5) Dependency Inversion principle
หลักการนี้จะกล่าวถึง
- High level classess (อาจมองว่าเป็นมอดูลที่มีแต่ business logic ที่ซับซ้อนก็ได้)
- กับ Low Level Classes (อาจมองว่าเป็นมอดูลที่มีแต่ logic พื้นฐาน ทำงานระดับล่างๆ)
.
ซึ่ง class ทั้งสองระดับดังกล่าว
เวลาจะติดต่อกัน ก็ให้ทำผ่านทาง Abstraction Layer เท่านั้น
ไม่ควรติดต่อกันตรงๆ โต้งๆ
.
Abstraction Layer ก็คิดง่ายๆ
มันก็คือ Interface หรือ abstraction class นั่นแหละ
คือมีแต่รายละเอียดให้รู้เฉยๆ ยังไม่มีส่วน implements
เพราะเดียวจะมีคลาสมา implements แล้วมา plugin เสียบเข้าภายหลัง
.
..เขียนเป็นภาพก็ประมาณเนี่ย
High Level Classes --> Abstraction Layer --> Low Level Classes
:
++++++++
สำหรับคอนเซปต์ SOLID อาจยากต่อการเข้าใจนิดหนึ่งนะ
มันต้องเห็นโค้ดตัวอย่างด้วย
ยิ่งถ้าใครไม่เชียวชาญการเขียนโปรแกรมเชิงวัตถุ (Object Oriented programming)
หรือไม่ได้ลงมือเขียนจริงๆ จังเท่าไร
ก็อาจสงสัยมีมันทำไม?
.
แต่ทว่าการเขียนโปรแกรมเชิงวัตถุ ถ้าออกแบบไม่ดีนี้ ....บอกตรงๆ
..โค้ดจะเละ เทอะทะ ใหญ่โต
..อ่านโค้ดก็ยาก ย๊าก คลาสเยอะแยะมากมาย
.
ยังไงอ่านเพิ่มเติม ดูโค้ดตัวอย่างที่ออกแบบตามหลัก SOLID
ตามลิงค์นี้เขียนดี
https://www.oodesign.com/design-principles.html
https://scotch.io/…/s-o-l-i-d-the-first-five-principles-of-…
.
😘 โชคดีทุกท่านครับ ไปแหละ
เขียนโดยโปรแกรมเมอร์ไทย thai programmer