ไม่สามารถแก้ไขความลึกลับของฟังก์ชั่นใน Javascript ได้

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

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

สิ่งที่สับสนอย่างยิ่งคือถ้าฉันconsole.log(Function.prototype)พิมพ์ฟังก์ชั่น แต่เมื่อฉันพิมพ์console.log(Object.prototype)มันจะพิมพ์วัตถุ ทำไมFunction.prototypeฟังก์ชั่นเมื่อมันถูกหมายถึงเป็นวัตถุ?

นอกจากนี้ตามเอกสาร Mozilla ทุก javascript functionเป็นส่วนขยายของFunctionวัตถุ แต่เมื่อคุณconsole.log(Function.prototype.constructor)เป็นอีกฟังก์ชั่น ตอนนี้คุณจะใช้บางสิ่งเพื่อสร้างมันเองได้อย่างไร (Mind = blown)

สิ่งสุดท้ายFunction.prototypeคือฟังก์ชั่น แต่ฉันสามารถเข้าถึงconstructorฟังก์ชั่นที่ใช้Function.prototype.constructorหมายความว่าFunction.prototypeเป็นฟังก์ชั่นที่ส่งกลับprototypeวัตถุ

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

มันซับซ้อนมันง่ายต่อการเข้าใจผิดและหนังสือ Javascript มือใหม่มากมายหลายเล่มเข้าใจผิดดังนั้นอย่าเชื่อใจทุกสิ่งที่คุณอ่าน

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

เมื่อฉันอ่านว่าวัตถุในตัวทั้งหมดเช่น Array, String ฯลฯ เป็นส่วนขยาย (สืบทอด) จาก Object ฉันคิดว่า Object เป็นวัตถุแรกที่สร้างขึ้นในวัตถุที่สร้างขึ้นและส่วนที่เหลือของวัตถุสืบทอดมาจากมัน

เริ่มต้นด้วยการทิ้งทุกสิ่งที่คุณรู้เกี่ยวกับการสืบทอดตามระดับ JS ใช้การสืบทอดตามต้นแบบ

ถัดไปตรวจสอบให้แน่ใจว่าคุณมีคำจำกัดความที่ชัดเจนมากในหัวของความหมายของ "การสืบทอด" ผู้ใช้ภาษา OO เช่น C # หรือ Java หรือ C ++ คิดว่าการสืบทอดหมายถึงการพิมพ์ย่อย แต่การสืบทอดไม่ได้หมายถึงการพิมพ์ย่อย การสืบทอดหมายความว่าสมาชิกของสิ่งหนึ่งยังเป็นสมาชิกของอีกสิ่งหนึ่งด้วย มันไม่จำเป็นต้องหมายความว่ามีความสัมพันธ์ระหว่าง subtyping สิ่งเหล่านั้น! ความเข้าใจผิดมากมายในทฤษฎีประเภทเป็นผลมาจากคนไม่ทราบว่ามีความแตกต่าง

แต่มันก็ไม่สมเหตุสมผลเมื่อคุณรู้ว่า Object สามารถสร้างได้โดยฟังก์ชั่นเท่านั้น แต่ฟังก์ชั่นนั้นก็ไม่ได้มี แต่วัตถุของ Function

นี่เป็นเพียงแค่ความเท็จ วัตถุบางอย่างจะไม่ได้สร้างขึ้นโดยการเรียกฟังก์ชั่นบางอย่างnew F Fวัตถุบางอย่างถูกสร้างขึ้นโดยรันไทม์ของ JS ไม่มีอะไรเลย มีไข่ที่ไม่ได้ถูกวางโดยไก่ใด ๆ พวกเขาเพิ่งสร้างขึ้นโดยรันไทม์เมื่อมันเริ่มต้นขึ้น

สมมติว่ากฎคืออะไรและอาจช่วยได้

• ทุกอินสแตนซ์ของวัตถุมีวัตถุต้นแบบ
• nullในบางกรณีที่ต้นแบบสามารถ
• ถ้าคุณเข้าถึงสมาชิกบนอินสแตนซ์ของวัตถุและวัตถุนั้นไม่มีสมาชิกนั้นวัตถุจะเลื่อนไปที่ต้นแบบหรือหยุดหากต้นแบบนั้นเป็นโมฆะ
• prototypeสมาชิกของวัตถุที่เป็นปกติไม่ได้ต้นแบบของวัตถุ
• ค่อนข้างprototypeสมาชิกของฟังก์ชั่น F new F()วัตถุเป็นวัตถุที่จะกลายเป็นต้นแบบของวัตถุที่สร้างขึ้นโดย
• ในการใช้งานบางอย่างอินสแตนซ์รับ__proto__สมาชิกที่ให้ต้นแบบจริง ๆ (ตอนนี้เลิกใช้แล้วอย่าพึ่งมัน)
• วัตถุฟังก์ชั่นจะได้รับวัตถุเริ่มต้นใหม่ที่กำหนดให้prototypeเมื่อพวกเขาถูกสร้างขึ้น
• Function.prototypeต้นแบบของวัตถุฟังก์ชั่นเป็นของหลักสูตร

มาสรุปกันเถอะ

• ต้นแบบของObjectคือFunction.prototype
• Object.prototype เป็นวัตถุต้นแบบวัตถุ
• ต้นแบบของObject.prototypeคือnull
• ต้นกำเนิดของFunctionคือFunction.prototype- นี่เป็นหนึ่งในสถานการณ์ที่หายากซึ่งFunction.prototypeต้นแบบของFunction!
• Function.prototype เป็นวัตถุต้นแบบฟังก์ชั่น
• ต้นแบบของFunction.prototypeคือObject.prototype

สมมุติว่าเราสร้างฟังก์ชั่น Foo

• ต้นแบบของการมีFooFunction.prototype
• Foo.prototype เป็นวัตถุต้นแบบฟู
• ต้นแบบของการมีFoo.prototypeObject.prototype

สมมติว่าเราพูด new Foo()

• ต้นแบบของวัตถุใหม่คือ Foo.prototype

ตรวจสอบให้แน่ใจว่าเหมาะสม มาวาดกันเถอะ Ovals เป็นวัตถุวัตถุ ขอบมี__proto__ความหมายว่า "ต้นแบบของ" หรือprototypeความหมาย " prototypeคุณสมบัติของ"

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

ลองมาดูตัวอย่างที่ทดสอบความรู้ของคุณ

function Car(){ }
var honda = new Car();
print(honda instanceof Car);
print(honda.constructor == Car);

สิ่งที่พิมพ์นี้

แล้วมันinstanceofหมายความว่าอะไร? honda instanceof Carหมายความว่า " Car.prototypeเท่ากับวัตถุใด ๆ ในhondaโซ่ต้นแบบ"

ใช่แล้ว. hondaต้นแบบคือCar.prototypeดังนั้นเราก็เสร็จแล้ว สิ่งนี้พิมพ์จริง

แล้วอันที่สองล่ะ?

honda.constructorCar.prototypeไม่ได้อยู่ดังนั้นเราจึงปรึกษาต้นแบบซึ่งเป็น เมื่อCar.prototypeวัตถุถูกสร้างขึ้นมันจะได้รับคุณสมบัติโดยอัตโนมัติconstructorเท่ากับCarสิ่งนี้จึงเป็นจริง

แล้วเรื่องนี้ล่ะ

var Animal = new Object();
function Reptile(){ }
Reptile.prototype = Animal;
var lizard = new Reptile();
print(lizard instanceof Reptile);
print(lizard.constructor == Reptile);

โปรแกรมนี้พิมพ์อะไร

อีกครั้งlizard instanceof Reptileหมายถึง " Reptile.prototypeเท่ากับวัตถุใด ๆ ในlizardโซ่ต้นแบบ"

ใช่แล้ว. lizardต้นแบบคือReptile.prototypeดังนั้นเราก็เสร็จแล้ว สิ่งนี้พิมพ์จริง

ตอนนี้เกี่ยวกับ

print(lizard.constructor == Reptile);

คุณอาจคิดว่าสิ่งนี้พิมพ์ออกมาได้จริงเนื่องจากlizardสร้างด้วยnew Reptileแต่คุณจะผิด เหตุผลมันออกมา

• ไม่lizardได้มีconstructorทรัพย์สิน? ไม่เลยเราดูต้นแบบ
• ต้นแบบของการlizardมีที่ซึ่งเป็นReptile.prototypeAnimal
• ไม่Animalได้มีconstructorทรัพย์สิน? ไม่เลยเราดูที่ต้นแบบ
• ต้นแบบของAnimalเป็นObject.prototypeและถูกสร้างขึ้นโดยรันไทม์และเท่ากับObject.prototype.constructorObject
• ดังนั้นสิ่งนี้จึงพิมพ์ผิด

เราควรจะพูดReptile.prototype.constructor = Reptile;ในจุดนั้น แต่เราจำไม่ได้!

ตรวจสอบให้แน่ใจว่าทั้งหมดเหมาะสมกับคุณ วาดกล่องและลูกศรบางส่วนหากยังคงสับสน

สิ่งที่สับสนอย่างยิ่งคือถ้าฉันconsole.log(Function.prototype)พิมพ์ฟังก์ชั่น แต่เมื่อฉันพิมพ์console.log(Object.prototype)มันจะพิมพ์วัตถุ ทำไมFunction.prototypeฟังก์ชั่นเมื่อมันถูกหมายถึงเป็นวัตถุ?

undefinedต้นแบบฟังก์ชั่นที่ถูกกำหนดให้เป็นหน้าที่ซึ่งเมื่อเรียกว่าผลตอบแทน เรารู้แล้วว่าFunction.prototypeมันFunctionเป็นต้นแบบที่แปลกพอสมควร ดังนั้นจึงFunction.prototype()เป็นเรื่องถูกกฎหมายและเมื่อคุณทำคุณจะได้รับundefinedกลับ ดังนั้นมันจึงเป็นฟังก์ชั่น

Objectต้นแบบไม่ได้มีคุณสมบัตินี้; มันไม่สามารถโทรออกได้ มันเป็นแค่วัตถุ

เมื่อคุณconsole.log(Function.prototype.constructor)เป็นอีกฟังก์ชั่น

Function.prototype.constructorเป็นเพียงFunctionชัดเจน และFunctionเป็นฟังก์ชั่น

ตอนนี้คุณจะใช้บางสิ่งเพื่อสร้างมันเองได้อย่างไร (Mind = blown)

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

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

การออกกำลังกายที่ดีก็คือการทำด้วยตัวเอง ที่นี่ฉันจะเริ่มต้นให้คุณออก เราจะใช้my__proto__เพื่อหมายถึง "วัตถุต้นแบบของ" และmyprototypeหมายถึง "คุณสมบัติต้นแบบของ"

var myobjectprototype = new Object();
var myfunctionprototype = new Object();
myfunctionprototype.my__proto__ = myobjectprototype;
var myobject = new Object();
myobject.myprototype = myobjectprototype;

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

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

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

คุณมีคำตอบที่ยอดเยี่ยมมากมาย แต่ฉันแค่ต้องการให้คำตอบสั้น ๆ และชัดเจนกับคำตอบของคุณเกี่ยวกับวิธีการทำงานทั้งหมดและคำตอบนั้นคือ:

มายากล!!!

จริงเหรอ

ผู้ที่ใช้เอ็นจินการเรียกใช้งาน ECMAScript จะต้องนำกฎของ ECMAScript ไปใช้แต่ไม่ปฏิบัติตามในการปฏิบัติ

ข้อมูลจำเพาะ ECMAScript บอกว่าการสืบทอดจาก B แต่ B เป็นตัวอย่างของ A? ไม่มีปัญหา! สร้าง A ตัวแรกด้วยตัวชี้ต้นแบบของNULLสร้าง B เป็นตัวอย่างของ A จากนั้นแก้ไขตัวชี้ต้นแบบของ A เพื่อชี้ไปที่ B หลังจากนั้น peasy ง่าย ๆ

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

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

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

จากข้อกำหนด ECMA 1

ECMAScript ไม่มีคลาสที่เหมาะสมเช่นคลาส C ++, Smalltalk หรือ Java แต่สนับสนุนคอนสตรัคเตอร์ที่สร้างออบเจ็กต์โดยใช้รหัสที่จัดสรรหน่วยเก็บข้อมูลสำหรับออบเจ็กต์และเริ่มต้นทั้งหมดหรือบางส่วนโดยกำหนดค่าเริ่มต้นให้กับคุณสมบัติ ฟังก์ชั่นทั้งหมดรวมถึงตัวสร้างเป็นวัตถุ แต่ไม่ใช่ทุกสิ่งที่เป็นตัวสร้าง

ฉันไม่เห็นว่ามันจะชัดเจนขึ้นอีก !!! </sarcasm>

ยิ่งไปกว่านั้นเราเห็น:

Prototype A Prototype เป็นวัตถุที่ใช้สร้างโครงสร้างสถานะและการสืบทอดพฤติกรรมใน ECMAScript เมื่อตัวสร้างสร้างวัตถุวัตถุนั้นโดยปริยายอ้างอิงต้นแบบที่เกี่ยวข้องของตัวสร้างเพื่อวัตถุประสงค์ในการแก้ไขการอ้างอิงคุณสมบัติ ต้นแบบที่เกี่ยวข้องของคอนสตรัคสามารถอ้างอิงได้โดยนิพจน์โปรแกรม constructor.prototype และคุณสมบัติที่เพิ่มเข้ากับต้นแบบของออบเจ็กต์จะถูกแชร์ผ่านการสืบทอดโดยออบเจ็กต์ทั้งหมดที่แชร์ต้นแบบ

ดังนั้นเราจะเห็นได้ว่าต้นแบบเป็นวัตถุ แต่ไม่จำเป็นต้องเป็นฟังก์ชันวัตถุ

นอกจากนี้เรามี titbit ที่น่าสนใจนี้

http://www.ecma-international.org/ecma-262/8.0/index.html#sec-object-objects

ตัวสร้างวัตถุเป็นวัตถุที่อยู่ภายใน% Object% และค่าเริ่มต้นของคุณสมบัติวัตถุของวัตถุทั่วโลก

และ

ตัวสร้างฟังก์ชั่นเป็นวัตถุที่อยู่ภายใน% Function% และค่าเริ่มต้นของคุณสมบัติฟังก์ชั่นของวัตถุทั่วโลก

ประเภทต่อไปนี้ครอบคลุมทุกค่าใน JavaScript:

• boolean
• number
• undefined(ซึ่งรวมถึงค่าเดียวundefined)
• string
• symbol ("สิ่ง" ที่เป็นนามธรรมที่ไม่ซ้ำกันซึ่งถูกเปรียบเทียบโดยการอ้างอิง)
• object

วัตถุทุกอย่าง (เช่นทุกอย่าง) ใน JavaScript มีต้นแบบซึ่งเป็นวัตถุชนิดหนึ่ง

ต้นแบบที่มีฟังก์ชั่นที่ยังมีชนิดของวัตถุ1

วัตถุก็มีนวกรรมิกซึ่งเป็นฟังก์ชั่นดังนั้นจึงเป็นวัตถุประเภทหนึ่ง

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

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

ความคิดที่ดีที่สุดคือการใช้เครื่องมือที่มีให้ในภาษาและไม่ต้องคิดมากเกี่ยวกับวิธีการใช้

^{1 ฟังก์ชั่นค่อนข้างพิเศษเพราะสามารถเรียกได้และเป็นเพียงค่าเดียวที่สามารถมีข้อมูลทึบแสง (ร่างกายของพวกเขาและอาจปิด)}

^{2 จริง ๆ แล้วมันเป็นริบบิ้นที่ถูกทรมานและแตกแขนงไปทางด้านหลังมากกว่า แต่ "วงเวียน" ก็อยู่ใกล้พอ}