มรดกต้นแบบแตกต่างจากมรดกดั้งเดิมอย่างไร

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

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

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

โพสต์บล็อกล่าสุดเกี่ยวกับ JS OO

ฉันเชื่อว่าสิ่งที่คุณเปรียบเทียบคือการจำลอง OO แบบดั้งเดิมใน JavaScriptและOO แบบคลาสสิกและแน่นอนว่าคุณไม่สามารถเห็นความแตกต่างได้

คำเตือน:แทนที่การอ้างอิงทั้งหมดเพื่อ "prototypal OO" ด้วย "prototypal OO ใน JavaScript" ฉันไม่รู้ลักษณะเฉพาะของตนเองหรือการนำไปใช้อย่างอื่น

อย่างไรก็ตามต้นแบบ OO นั้นแตกต่างกัน ด้วยต้นแบบที่คุณมีเพียงวัตถุและคุณสามารถฉีดวัตถุเข้าไปในห่วงโซ่ต้นแบบวัตถุอื่น ๆ เมื่อใดก็ตามที่คุณเข้าถึงคุณสมบัติบนวัตถุที่คุณค้นหาวัตถุนั้นและวัตถุใด ๆ ในห่วงโซ่ต้นแบบ

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

อย่างไรก็ตามมันมีความหลากหลาย

ตัวอย่างเช่น

var Dog = {
  walk: function() { console.log("walks"); }
}

var d = Object.create(Dog);
d.walk();

เห็นdได้ชัดว่ามีการเข้าถึงวิธีการDog.walkและสิ่งนี้จัดแสดงความแตกต่าง

ดังนั้นจริงมีความแตกต่างใหญ่ คุณมีความหลากหลาย

อย่างไรก็ตามตามที่กล่าวไว้ถ้าคุณต้องการที่จะทำเช่นนั้น (ฉันไม่รู้ว่าทำไมคุณจะทำ) คุณสามารถเลียนแบบ OO แบบดั้งเดิมใน JavaScriptและเข้าถึงการห่อหุ้มและการสืบทอด (จำกัด )

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

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

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

ครั้งแรก: ส่วนใหญ่แล้วคุณจะใช้วัตถุไม่ได้กำหนดและการใช้วัตถุเหมือนกันภายใต้กระบวนทัศน์ทั้งสอง

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

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

ประการที่สี่: ความแตกต่างในทางปฏิบัติมีขนาดเล็กในขณะที่ปัญหาในทางปฏิบัติของการลืมที่จะใช้newมีขนาดใหญ่กว่ามาก - นั่นคือคุณมีแนวโน้มที่จะได้รับผลกระทบจากการขาดหายไปและnewคุณจะได้รับผลกระทบจากความแตกต่างระหว่างต้นแบบ .

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

Prototypal ที่สืบทอดใน JavaScript นั้นแตกต่างจากคลาสด้วยวิธีการสำคัญเหล่านี้:

คอนสตรัคเตอร์เป็นเพียงฟังก์ชั่นที่คุณสามารถโทรได้โดยไม่ต้องnew:

function Circle (r, x, y) { 
  //stuff here
}
Var c = new Circle();
Circle.call(c, x, y, z); //This works and you can do it over and over again.

ไม่มีตัวแปรหรือวิธีส่วนตัวที่ดีที่สุดที่คุณสามารถทำได้:

function Circle (r, x, y) {
  var color = 'red';
  function drawCircle () {
    //some code here with x, y and r
  }
  drawCircle();
  this.setX = function (x_) {
    x = x_;
    drawCircle();
  }

}
Circle.prototype.getX = function () {
   //Can't access x!
}

ในตัวอย่างก่อนหน้านี้คุณไม่สามารถขยายคลาสได้อย่างมีความหมายหากคุณใช้ตัวแปรและวิธีการส่วนตัวปลอมและนอกจากนี้วิธีสาธารณะใด ๆ ที่คุณประกาศจะถูกสร้างขึ้นใหม่ทุกครั้งที่มีการสร้างอินสแตนซ์ใหม่