ทำไมคุณสมบัติ arguments.callee.caller เลิกใช้ใน JavaScript

เหตุใดarguments.callee.callerคุณสมบัติจึงเลิกใช้ใน JavaScript

มีการเพิ่มและเลิกใช้แล้วใน JavaScript แต่ถูกตัดออกทั้งหมดโดย ECMAScript เบราว์เซอร์บางตัว (Mozilla, IE) รองรับเสมอและไม่มีแผนใด ๆ บนแผนที่เพื่อลบการสนับสนุน อื่น ๆ (Safari, Opera) ได้นำการสนับสนุนมาใช้ แต่การสนับสนุนเบราว์เซอร์รุ่นเก่านั้นไม่น่าเชื่อถือ

มีเหตุผลที่ดีที่จะใช้ฟังก์ชั่นที่มีค่านี้ในบริเวณขอบรกหรือไม่?

(หรือสลับกันมีวิธีที่ดีกว่าในการจับที่จับบนฟังก์ชั่นการโทรหรือไม่)

JavaScript เวอร์ชันก่อนหน้านี้ไม่อนุญาตการแสดงออกของฟังก์ชั่นที่มีชื่อและเนื่องจากว่าเราไม่สามารถสร้างนิพจน์ฟังก์ชันแบบเรียกซ้ำ:

 // This snippet will work:
 function factorial(n) {
     return (!(n>1))? 1 : factorial(n-1)*n;
 }
 [1,2,3,4,5].map(factorial);


 // But this snippet will not:
 [1,2,3,4,5].map(function(n) {
     return (!(n>1))? 1 : /* what goes here? */ (n-1)*n;
 });

ในการหลีกเลี่ยงสิ่งนี้arguments.calleeถูกเพิ่มเข้ามาเพื่อให้เราทำ:

 [1,2,3,4,5].map(function(n) {
     return (!(n>1))? 1 : arguments.callee(n-1)*n;
 });

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

var global = this;
var sillyFunction = function (recursed) {
    if (!recursed)
        return arguments.callee(true);
    if (this !== global)
        alert("This is: " + this);
    else
        alert("This is the global");
}
sillyFunction();

อย่างไรก็ตาม EcmaScript 3 สามารถแก้ไขปัญหาเหล่านี้ได้ด้วยการอนุญาตให้นิพจน์ฟังก์ชันที่ระบุชื่อเช่น:

 [1,2,3,4,5].map(function factorial(n) {
     return (!(n>1))? 1 : factorial(n-1)*n;
 });

สิ่งนี้มีประโยชน์มากมาย:

• ฟังก์ชั่นนี้สามารถเรียกได้ว่าเหมือนกับฟังก์ชั่นอื่น ๆ จากข้างในโค้ดของคุณ

• มันไม่สร้างมลภาวะเนมสเปซ

• ค่าของthisจะไม่เปลี่ยนแปลง

• มันมีประสิทธิภาพมากกว่า (การเข้าถึงอ็อบเจกต์อาร์กิวเมนต์มีราคาแพง)

อ๊ะ

เพิ่งตระหนักว่านอกเหนือไปจากทุกสิ่งทุกอย่างคำถามที่เกี่ยวกับหรือมากขึ้นโดยเฉพาะarguments.callee.callerFunction.caller

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

เช่น. หากเราไม่สามารถรับประกันได้ว่าฟังก์ชั่นfจะไม่เรียกฟังก์ชั่นที่ไม่รู้จักนั้นจะไม่สามารถอินไลน์fได้ โดยทั่วไปหมายความว่าไซต์การโทรใด ๆ ที่อาจไม่สามารถ inlinable เก็บสะสมยามจำนวนมากได้:

 function f(a, b, c, d, e) { return a ? b * c : d * e; }

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

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

arguments.callee.callerจะไม่เลิกแม้ว่ามันจะทำให้การใช้งานของคุณสมบัติ ( จะให้การอ้างอิงฟังก์ชันปัจจุบัน)Function.callerarguments.callee

• Function.callerแม้ว่าจะไม่ได้มาตรฐานตาม ECMA3 จะดำเนินการในเบราว์เซอร์ที่สำคัญทั้งหมดในปัจจุบัน
• arguments.caller จะเลิกในความโปรดปรานของและไม่ได้มีการดำเนินการในเบราว์เซอร์ที่สำคัญบางอย่างในปัจจุบัน (เช่น Firefox 3)Function.caller

ดังนั้นสถานการณ์ที่น้อยกว่าเหมาะ แต่ถ้าคุณต้องการที่จะเข้าถึงฟังก์ชั่นการโทรใน Javascript เบราว์เซอร์ที่สำคัญทั้งหมดคุณสามารถใช้คุณสมบัติการเข้าถึงทั้งโดยตรงบนอ้างอิงฟังก์ชั่นที่มีชื่อหรือจากภายในฟังก์ชั่นที่ไม่ระบุชื่อผ่านคุณสมบัติFunction.callerarguments.callee

มันจะดีกว่าที่จะใช้ฟังก์ชั่นที่มีชื่อกว่า arguments.callee:

 function foo () {
     ... foo() ...
 }

ดีกว่า

 function () {
     ... arguments.callee() ...
 }

ฟังก์ชั่นที่มีชื่อจะมีการเข้าถึงผู้โทรผ่านคุณสมบัติผู้โทร :

 function foo () {
     alert(foo.caller);
 }

ซึ่งดีกว่า

 function foo () {
     alert(arguments.callee.caller);
 }

เลิกเป็นเพราะ ECMAScript ปัจจุบันหลักการออกแบบ

เพียงแค่นามสกุล ค่าของ "this" เปลี่ยนแปลงระหว่างการเรียกซ้ำ ในตัวอย่าง (แก้ไข) ต่อไปนี้แฟกทอเรียลจะได้รับวัตถุ {foo: true}

[1,2,3,4,5].map(function factorial(n) {
  console.log(this);
  return (!(n>1))? 1 : factorial(n-1)*n;
},     {foo:true}     );

แฟกทอเรียลที่เรียกว่าครั้งแรกรับวัตถุ แต่นี่ไม่เป็นความจริงสำหรับการโทรซ้ำ