วิธีรับชื่อฟังก์ชั่นจากภายในฟังก์ชั่นนั้น?

ฉันจะเข้าถึงชื่อฟังก์ชันจากภายในฟังก์ชันนั้นได้อย่างไร

// parasitic inheritance
var ns.parent.child = function() {
  var parent = new ns.parent();
  parent.newFunc = function() {

  }
  return parent;
}

var ns.parent = function() {
  // at this point, i want to know who the child is that called the parent
  // ie
}

var obj = new ns.parent.child();

ใน ES5 สิ่งที่ดีที่สุดที่ควรทำคือ:

function functionName(fun) {
  var ret = fun.toString();
  ret = ret.substr('function '.length);
  ret = ret.substr(0, ret.indexOf('('));
  return ret;
}

การใช้Function.callerไม่ได้มาตรฐาน Function.callerและarguments.calleeทั้งคู่ถูกห้ามในโหมดเข้มงวด

แก้ไข: คำตอบจาก regex ของ nus ด้านล่างบรรลุสิ่งเดียวกัน แต่มีประสิทธิภาพที่ดีกว่า!

ใน ES6 คุณสามารถใช้งานmyFunction.nameได้

หมายเหตุ: ระวังว่า JS minifiers บางตัวอาจทิ้งชื่อฟังก์ชันเพื่อบีบอัดให้ดีขึ้น คุณอาจต้องปรับการตั้งค่าเพื่อหลีกเลี่ยงปัญหานั้น

ES6 (แรงบันดาลใจจากคำตอบของ sendy halim ด้านล่าง):

myFunction.name

ชี้แจง MDN ตั้งแต่ปี 2015 ใช้งานได้ใน nodejs และเบราว์เซอร์หลักทั้งหมดยกเว้น IE

หมายเหตุ: ในฟังก์ชั่นที่ถูกผูกไว้สิ่งนี้จะให้ " bound <originalName>" คุณจะต้องตัด "ผูกพัน" ถ้าคุณต้องการได้รับชื่อเดิม

ES5 (แรงบันดาลใจจากคำตอบของ Vlad):

หากคุณมีการอ้างอิงถึงฟังก์ชั่นคุณสามารถทำ:

function functionName( func )
{
    // Match:
    // - ^          the beginning of the string
    // - function   the word 'function'
    // - \s+        at least some white space
    // - ([\w\$]+)  capture one or more valid JavaScript identifier characters
    // - \s*        optionally followed by white space (in theory there won't be any here,
    //              so if performance is an issue this can be omitted[1]
    // - \(         followed by an opening brace
    //
    var result = /^function\s+([\w\$]+)\s*\(/.exec( func.toString() )

    return  result  ?  result[ 1 ]  :  '' // for an anonymous function there won't be a match
}

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

[1] ฉันรวมมันไว้ที่นี่เพราะมันถูกกฎหมายและบ่อยครั้งที่เครื่องมือการเน้นไวยากรณ์ไม่เพียงพอที่จะคำนึงถึงช่องว่างสีขาวระหว่างชื่อฟังก์ชันและวงเล็บ ในทางกลับกันฉันไม่ได้ตระหนักถึงการใช้. toString () ใด ๆ ที่จะรวมพื้นที่สีขาวที่นี่ด้วยเหตุนี้คุณจึงสามารถละเว้นได้

ตามคำตอบของคำถามดั้งเดิมฉันจะทิ้งมรดกของกาฝากและไปหารูปแบบการออกแบบ OOP แบบดั้งเดิม ฉันเขียนTidBits.OoJsเพื่อเขียนรหัส OOP ใน JavaScript อย่างสะดวกสบายด้วยชุดคุณสมบัติที่เลียนแบบ C ++ (ยังไม่เสร็จสมบูรณ์ แต่ส่วนใหญ่)

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

ฉันอยากจะแนะนำให้หลีกเลี่ยงฟังก์ชั่นนิรนาม พวกเขาทำการดีบักและสร้างโปรไฟล์ PITA เพียงเพราะทุกอย่างแสดงเป็น "ฟังก์ชันที่ไม่ระบุชื่อ" และไม่มีประโยชน์สำหรับพวกเขาที่ฉันรู้

สิ่งที่คุณกำลังทำคือการกำหนดฟังก์ชั่นที่ไม่มีชื่อให้กับตัวแปร คุณอาจต้องใช้ชื่อฟังก์ชันนิพจน์แทน ( http://kangax.github.com/nfe/ )

var x = function x() {
    console.log( arguments.callee.name );
}
x();

อย่างไรก็ตามฉันไม่แน่ใจว่าจะใช้เบราว์เซอร์ข้ามเท่าใด มีปัญหากับ IE6 ที่ทำให้ชื่อฟังก์ชันของคุณรั่วไหลไปยังขอบเขตด้านนอก ยัง arguments.callee strict modeเป็นชนิดของการเลิกและจะส่งผลให้เกิดข้อผิดพลาดหากคุณกำลังใช้

ใด ๆ ที่constructorแสดงคุณสมบัติnameซึ่งเป็นชื่อฟังก์ชั่น คุณเข้าถึงconstructorอินสแตนซ์ (โดยใช้new) หรือprototype:

function Person() {
  console.log(this.constructor.name); //Person
}

var p = new Person();
console.log(p.constructor.name); //Person

console.log(Person.prototype.constructor.name);  //Person

ดูเหมือนสิ่งที่โง่ที่สุดที่ฉันเขียนในชีวิตของฉัน แต่มันตลก: D

function getName(d){
  const error = new Error();
  const firefoxMatch = (error.stack.split('\n')[0 + d].match(/^.*(?=@)/) || [])[0];
  const chromeMatch = ((((error.stack.split('at ') || [])[1 + d] || '').match(/(^|\.| <| )(.*[^(<])( \()/) || [])[2] || '').split('.').pop();
  const safariMatch = error.stack.split('\n')[0 + d];

  // firefoxMatch ? console.log('firefoxMatch', firefoxMatch) : void 0;
  // chromeMatch ? console.log('chromeMatch', chromeMatch) : void 0;
  // safariMatch ? console.log('safariMatch', safariMatch) : void 0;

  return firefoxMatch || chromeMatch || safariMatch;
}

d- ความลึกของกองซ้อน 0- คืนชื่อฟังก์ชั่นนี้1- ผู้ปกครอง ฯลฯ
[0 + d]- เพียงเพื่อความเข้าใจ - เกิดอะไรขึ้น
firefoxMatch- ใช้งานได้กับซาฟารี แต่ฉันมีเวลาน้อยมากในการทดสอบเพราะเจ้าของแม็คกลับมาหลังจากสูบบุหรี่และขับไล่ฉันออกไป: '(

การทดสอบ:

function limbo(){
  for(let i = 0; i < 4; i++){
    console.log(getName(i));
  }
}
function lust(){
  limbo();
}
function gluttony(){
  lust();
}

gluttony();

ผลลัพธ์:
Chrome:

Fitefox:

โซลูชันนี้สร้างเพื่อความสนุกเท่านั้น! อย่าใช้มันสำหรับโครงการจริง มันไม่ได้ขึ้นอยู่กับข้อกำหนดของ ES มันขึ้นอยู่กับการใช้งานเบราว์เซอร์เท่านั้น หลังจากการอัปเดต chrome / firefox / safari ครั้งถัดไปอาจทำให้เสีย
ยิ่งไปกว่านั้นไม่มีการประมวลผลข้อผิดพลาด (ฮ่า) - ถ้าdจะมากกว่าความยาวสแต็ค - คุณจะได้รับข้อผิดพลาด;
สำหรับรูปแบบ messaage ข้อผิดพลาดของ wrowsers อื่น ๆ - คุณจะได้รับข้อผิดพลาด
มันจะต้องใช้ได้กับคลาส ES6 ( .split('.').pop()) แต่คุณก็จะได้รับความผิดปกติ

สิ่งนี้อาจใช้ได้กับคุณ:

function foo() { bar(); }

function bar() { console.log(bar.caller.name); }

วิ่ง foo () จะส่งออก "foo" หรือไม่ได้กำหนดถ้าคุณโทรจากฟังก์ชั่นที่ไม่ระบุชื่อ

มันทำงานร่วมกับตัวสร้างเช่นกันในกรณีนี้มันจะเอาท์พุทชื่อของตัวสร้างการเรียก (เช่น "Foo")

ข้อมูลเพิ่มเติมที่นี่: https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Function/Caller

พวกเขาอ้างว่ามันไม่ได้มาตรฐาน แต่ก็สนับสนุนโดยเบราว์เซอร์ที่สำคัญทั้งหมด: Firefox, Safari, Chrome, Opera และ IE

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

ความคิดเห็นของคุณ:

// access fully qualified name (ie "my.namespace.myFunc")

อยู่ภายในฟังก์ชัน my.namespace.myFunc.getFn

สิ่งที่คุณสามารถทำได้คือส่งคืนตัวสร้างของวัตถุที่สร้างขึ้นใหม่

ดังนั้นคุณสามารถพูดได้

var obj = new my.namespace.myFunc();
console.info(obj.constructor); //my.namespace.myFunc

คุณสามารถใช้สิ่งนี้สำหรับเบราว์เซอร์ที่รองรับ Error.stack (อาจไม่เกือบทั้งหมด)

function WriteSomeShitOut(){ 
  var a = new Error().stack.match(/at (.*?) /);
  console.log(a[1]);
} 
WriteSomeShitOut();

แน่นอนว่านี่เป็นฟังก์ชั่นปัจจุบัน แต่คุณเข้าใจแล้ว

มีความสุขน้ำลายไหลในขณะที่คุณรหัส

คุณสามารถใช้nameคุณสมบัติเพื่อรับชื่อฟังก์ชันยกเว้นว่าคุณกำลังใช้ฟังก์ชันที่ไม่ระบุชื่อ

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

var Person = function Person () {
  this.someMethod = function () {};
};

Person.prototype.getSomeMethodName = function () {
  return this.someMethod.name;
};

var p = new Person();
// will return "", because someMethod is assigned with anonymous function
console.log(p.getSomeMethodName());

ตอนนี้ลองทำฟังก์ชั่นที่มีชื่อ

var Person = function Person () {
  this.someMethod = function someMethod() {};
};

ตอนนี้คุณสามารถใช้

// will return "someMethod"
p.getSomeMethodName()

คุณสามารถใช้ชื่อตัวสร้างเช่น:

{your_function}.prototype.constructor.name

รหัสนี้เพียงแค่ส่งกลับชื่อของวิธีการ

ในฐานะที่เป็นส่วนหนึ่งECMAScript 6คุณสามารถใช้วิธีFunction.name

function doSomething() {}

alert(doSomething.name); // alerts "doSomething"

คุณสามารถใช้Function.name :

ในการใช้งานจาวาสคริปต์ส่วนใหญ่เมื่อคุณมีการอ้างอิงคอนสตรัคเตอร์ในขอบเขตคุณสามารถรับชื่อสตริงจากคุณสมบัติชื่อ (เช่น Function.name หรือ Object.constructor.name

คุณสามารถใช้Function.callee :

พื้นเมืองarguments.callerวิธีการได้รับการคัดค้าน แต่เบราว์เซอร์ส่วนใหญ่สนับสนุนFunction.callerซึ่งจะกลับวัตถุกล่าวอ้างจริง (ร่างกายของรหัส): https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ ฟังก์ชั่น / โทร? redirectlocale = th & redirectslug = JavaScript% 2FReference% 2FGlobal_Objects% 2FFunction% 2Fcaller

คุณสามารถสร้างแผนที่แหล่งที่มา :

หากสิ่งที่คุณต้องการคือลายเซ็นของฟังก์ชั่นตัวอักษร ("ชื่อ" ของมัน) และไม่ใช่วัตถุเองคุณอาจต้องหันไปใช้สิ่งที่กำหนดเองมากกว่านี้เล็กน้อยเช่นการสร้างการอ้างอิงอาร์เรย์ของค่าสตริง API ที่คุณต้องการ เข้าถึงบ่อยครั้ง คุณสามารถแมปพวกเขาเข้าด้วยกันโดยใช้Object.keys()และชุดสตริงของคุณหรือดูที่ไลบรารีแผนที่ของ Mozilla บน GitHub สำหรับโครงการขนาดใหญ่: https://github.com/mozilla/source-map

ฉันรู้ว่านี่เป็นคำถามเก่า แต่เมื่อเร็ว ๆ นี้ฉันได้พบกับปัญหาที่คล้ายกันในขณะที่พยายามตกแต่งวิธีการของ React Component เพื่อใช้ในการดีบั๊ก อย่างที่ผู้คนพูดกันแล้วarguments.callerและarguments.calleeถูกห้ามในโหมดเข้มงวดซึ่งอาจเปิดใช้งานโดยค่าเริ่มต้นในการทำ React transpiling ของคุณ คุณสามารถปิดการใช้งานหรือฉันสามารถแฮ็คอื่นได้เพราะใน React ฟังก์ชันคลาสทั้งหมดถูกตั้งชื่อคุณสามารถทำสิ่งนี้ได้จริง:

Component.prototype.componentWillMount = function componentWillMount() {
    console.log('Callee name: ', this.__proto__.constructor.toString().substr(0,30));
...
}

สิ่งนี้ใช้ได้สำหรับฉัน

function AbstractDomainClass() {
    this.className = function() {
        if (!this.$className) {
            var className = this.constructor.toString();
            className = className.substr('function '.length);
            className = className.substr(0, className.indexOf('('));
            this.$className = className;
        }
        return this.$className;
    }
}

รหัสทดสอบ:

var obj = new AbstractDomainClass();
expect(obj.className()).toBe('AbstractDomainClass');

ฉันมีปัญหาที่คล้ายกันและฉันแก้ไขได้ดังนี้

Function.prototype.myname = function() {
   return this.toString()
       .substr( 0, this.toString().indexOf( "(" ) )
       .replace( "function ", "" ); 
}

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

<script language="javascript" TYPE="text/javascript">

    Function.prototype.myname = function() { 
        return this.toString()
            .substr( 0, this.toString().indexOf( "(" ) )
            .replace("function ", "" ); 
    }
    function call_this( _fn ) { document.write( _fn.myname() ); }
    function _yeaaahhh() { /* do something */ }
    call_this( _yeaaahhh ); 

</script>

ถ้าฉันเข้าใจสิ่งที่คุณต้องการจะทำนี่คือสิ่งที่ฉันทำในตัวสร้างฟังก์ชัน

if (!(this instanceof arguments.callee)) {
    throw "ReferenceError: " + arguments.callee.name + " is not defined";
}

สิ่งนี้จะทำงานใน ES5, ES6, เบราว์เซอร์ทั้งหมดและฟังก์ชั่นโหมดเข้มงวด

นี่คือลักษณะของฟังก์ชันที่มีชื่อ

(function myName() {
  console.log(new Error().stack.split(/\r\n|\r|\n/g)[1].trim());
})();

at myName (<anonymous>:2:15)

นี่คือลักษณะที่ปรากฏด้วยฟังก์ชันที่ไม่ระบุชื่อ

(() => {
  console.log(new Error().stack.split(/\r\n|\r|\n/g)[1].trim());
})();

at <anonymous>:2:15

ดูที่นี่: http://www.tek-tips.com/viewthread.cfm?qid=1209619

arguments.callee.toString();

น่าจะเหมาะกับความต้องการของคุณ

คุณสามารถใช้ Error.stack เพื่อติดตามชื่อฟังก์ชั่นและตำแหน่งที่แน่นอนของตำแหน่งที่คุณอยู่

ดูstacktrace.js

วิธีง่ายๆในการรับชื่อฟังก์ชั่นจากภายใน fuction ที่คุณกำลังเรียกใช้

function x(){alert(this.name)};x()