function Hello()
{
    alert("caller is " + Hello.caller);
}

Обратите внимание, что эта функция - нестандартный, от Function.caller:

Non-standard
This feature is non-standard and is not on a standards track. Do not use it on production sites facing the Web: it will not work for every user. There may also be large incompatibilities between implementations and the behavior may change in the future.

Ниже приводится старый ответ 2008 года, который больше не поддерживается в современном Javascript:

function Hello()
{
    alert("caller is " + arguments.callee.caller.toString());
}

Безопаснее использовать *arguments.callee.caller, так как arguments.caller - это устарел ...

Попробуйте получить доступ к этому:

arguments.callee.caller.name

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

Подведем итоги (и сделаем это яснее) ...

этот код:

function Hello() {
    alert("caller is " + arguments.callee.caller.toString());
}

эквивалентно этому:

function Hello() {
    alert("caller is " + Hello.caller.toString());
}

Очевидно, что первый бит более переносимый, поскольку вы можете изменить имя функции, скажем, с «Hello» на «Ciao», и при этом заставить все это работать.

В последнем случае, если вы решите реорганизовать имя вызываемой функции (Hello), вам придется изменить все ее вхождения :(

Трассировки стека

Вы можете найти всю трассировку стека, используя код браузера. Хорошая вещь - кто-то уже сделал это; вот код проекта на GitHub.

Но не все новости хороши:

1. Получить трассировку стека очень медленно, поэтому будьте осторожны (подробнее см. это).

2. Вам нужно будет определить имена функций, чтобы трассировка стека была удобочитаемой. Потому что, если у вас есть такой код:

   var Klass = function kls() {
      this.Hello = function() { alert(printStackTrace().join('\n\n')); };
   }
   new Klass().Hello();
   

   Google Chrome предупредит ... kls.Hello ( ..., но большинство браузеров ожидают имени функции сразу после ключевого слова function и будут рассматривать его как анонимную функцию. Даже Chrome не сможет использовать имя Klass, если вы не дадите функции имя kls.

   И, кстати, вы можете передать функции printStackTrace опцию {guess: true}, но я не нашел никаких реальных улучшений, сделав это.

3. Не все браузеры предоставляют одинаковую информацию. То есть параметры, столбец кода и т. д.

Имя функции вызывающего абонента

Кстати, если вам нужно только имя вызывающей функции (в большинстве браузеров, но не в IE), вы можете использовать:

arguments.callee.caller.name

Но учтите, что это имя будет после ключевого слова function. Я не нашел способа (даже в Google Chrome) получить больше, не получив кода всей функции.

Код функции вызывающего абонента

И резюмируя остальные лучшие ответы (Пабло Кабрера, Нурдин и Грег Хьюджилл). Единственная кроссбраузерная и действительно безопасная вещь, которую вы можете использовать:

arguments.callee.caller.toString();

Что покажет код вызывающей функции. К сожалению, для меня этого недостаточно, и поэтому я даю вам советы по StackTrace и имени вызывающей функции (хотя они не являются кроссбраузерными).

Вы можете получить полную трассировку стека:

arguments.callee.caller
arguments.callee.caller.caller
arguments.callee.caller.caller.caller

Пока вызывающий абонент не будет null.

Примечание: это вызывает бесконечный цикл рекурсивных функций.

Если вам нужно просто имя функции, а не код, и вам нужно решение, не зависящее от браузера, используйте следующее:

var callerFunction = arguments.callee.caller.toString().match(/function ([^\(]+)/)[1];

Обратите внимание, что приведенное выше вернет ошибку, если нет вызывающей функции, поскольку в массиве нет элемента [1]. Чтобы обойти эту проблему, используйте следующее:

var callerFunction = (arguments.callee.caller.toString().match(/function ([^\(]+)/) === null) ? 'Document Object Model': arguments.callee.caller.toString().match(/function ([^\(]+)/)[1], arguments.callee.toString().match(/function ([^\(]+)/)[1]);

Я хотел добавить сюда свою скрипку:

http://jsfiddle.net/bladnman/EhUm3/

Я тестировал это хром, сафари и IE (10 и 8). Работает отлично. Важна только одна функция, поэтому, если вас пугает большая рабочий пример, прочтите ниже.

Примечание: В этой скрипке есть изрядное количество моего собственного "шаблона". Вы можете удалить все это и использовать сплит, если хотите. Это просто сверхбезопасный набор функций, на которые я привык полагаться.

Там также есть шаблон "JSFiddle", который я использую для многих скрипок, чтобы просто быстро возиться.

Здесь все, кроме functionname, отделено от caller.toString() с помощью RegEx.

<!DOCTYPE html>
<meta charset = "UTF-8">
<title>Show the callers name</title><!-- This validates as html5! -->
<script>
main();
function main() { Hello(); }
function Hello(){
  var name = Hello.caller.toString().replace(/\s\([^#]+$|^[^\s]+\s/g,'');
  name = name.replace(/\s/g,'');
  if ( typeof window[name] !== 'function' )
    alert ("sorry, the type of "+name+" is "+ typeof window[name]);
  else
    alert ("The name of the "+typeof window[name]+" that called is "+name);
}
</script>

Попробуйте следующий код:

function getStackTrace(){
  var f = arguments.callee;
  var ret = [];
  var item = {};
  var iter = 0;

  while ( f = f.caller ){
      // Initialize
    item = {
      name: f.name || null,
      args: [], // Empty array = no arguments passed
      callback: f
    };

      // Function arguments
    if ( f.arguments ){
      for ( iter = 0; iter<f.arguments.length; iter++ ){
        item.args[iter] = f.arguments[iter];
      }
    } else {
      item.args = null; // null = argument listing not supported
    }

    ret.push( item );
  }
  return ret;
}

У меня работал в Firefox-21 и Chromium-25.

Похоже, что это вполне решенный вопрос, но недавно я обнаружил, что вызываемый абонент не допускается в "строгом режиме", поэтому для собственного использования я написал класс, который будет получать путь, откуда он вызывается. Это часть небольшой вспомогательной библиотеки, и если вы хотите использовать автономный код, измените смещение, используемое для возврата трассировки стека вызывающего (используйте 1 вместо 2)

function ScriptPath() {
  var scriptPath = '';
  try {
    //Throw an error to generate a stack trace
    throw new Error();
  }
  catch(e) {
    //Split the stack trace into each line
    var stackLines = e.stack.split('\n');
    var callerIndex = 0;
    //Now walk though each line until we find a path reference
    for(var i in stackLines){
      if (!stackLines[i].match(/http[s]?:///)) continue;
      //We skipped all the lines with out an http so we now have a script reference
      //This one is the class constructor, the next is the getScriptPath() call
      //The one after that is the user code requesting the path info (so offset by 2)
      callerIndex = Number(i) + 2;
      break;
    }
    //Now parse the string for each section we want to return
    pathParts = stackLines[callerIndex].match(/((http[s]?://.+/)([^/]+\.js)):/);
  }

  this.fullPath = function() {
    return pathParts[1];
  };

  this.path = function() {
    return pathParts[2];
  };

  this.file = function() {
    return pathParts[3];
  };

  this.fileNoExt = function() {
    var parts = this.file().split('.');
    parts.length = parts.length != 1 ? parts.length - 1 : 1;
    return parts.join('.');
  };
}

Просто хочу сообщить вам, что на PhoneGap / Androidname, похоже, не работает. Но arguments.callee.caller.toString() сделает свое дело.

Я знаю, что вы упомянули «в Javascript», но если целью является отладка, я думаю, что проще просто использовать инструменты разработчика вашего браузера. Вот как это выглядит в Chrome: Просто перетащите отладчик туда, где вы хотите исследовать стек.

Обычно я использую (new Error()).stack в Chrome. Приятно то, что это также дает вам номера строк, в которых вызывающий вызывает функцию. Обратной стороной является то, что он ограничивает длину стека до 10, поэтому я и пришел на эту страницу в первую очередь.

(Я использую это для сбора стеков вызовов в низкоуровневом конструкторе во время выполнения, для просмотра и отладки позже, поэтому установка точки останова бесполезна, поскольку она будет достигнута тысячи раз)

Вы можете использовать Function.Caller для получения вызывающей функции. Старый метод с использованием argument.caller считается устаревшим.

Следующий код иллюстрирует его использование:

function Hello() { return Hello.caller;}

Hello2 = function NamedFunc() { return NamedFunc.caller; };

function main()
{
   Hello();  //both return main()
   Hello2();
}

Примечания об устаревшем аргументе. Вызывающий: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/arguments/caller

Имейте в виду, что Function.caller нестандартен: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/caller

Если вам действительно нужна функциональность по какой-то причине и вы хотите, чтобы она была кросс-браузерной, не беспокоилась о строгих правилах и была совместима с пересылкой, то передайте эту ссылку:

function main()
{
   Hello(this);
}

function Hello(caller)
{
    // caller will be the object that called Hello. boom like that... 
    // you can add an undefined check code if the function Hello 
    // will be called without parameters from somewhere else
}

Если вы не собираетесь запускать его в IE <11, то console.trace () подойдет.

function main() {
    Hello();
}

function Hello() {
    console.trace()
}

main()
// Hello @ VM261:9
// main @ VM261:4

Другой способ решить эту проблему - просто передать имя вызывающей функции в качестве параметра.

Например:

function reformatString(string, callerName) {

    if (callerName === "uid") {
        string = string.toUpperCase();
    }

    return string;
}

Теперь вы можете вызвать функцию следующим образом:

function uid(){
    var myString = "apples";

    reformatString(myString, function.name);
}

В моем примере используется жестко закодированная проверка имени функции, но вы можете легко использовать оператор switch или другую логику, чтобы делать там то, что вы хотите.

Насколько я знаю, у нас есть 2 способа сделать это из таких источников, как этот:

1. arguments.caller

   function whoCalled()
   {
       if (arguments.caller == null)
          console.info('I was called from the global scope.');
       else
          console.info(arguments.caller + ' called me!');
   }
   

2. Function.caller

   function myFunc()
   {
      if (myFunc.caller == null) {
         return 'The function was called from the top!';
      }
      else
      {
         return 'This function\'s caller was ' + myFunc.caller;
       }
   }
   

Думаю, у тебя есть ответ :).

Я пытаюсь ответить как на вопрос, так и на текущую награду с помощью этого вопроса.

Награда требует, чтобы вызывающий абонент был получен в режиме строгий, и единственный способ, которым я могу это сделать, - это обратиться к функции, объявленной вне строгого режима.

Например, следующее нестандартно, но было протестировано с предыдущими (29.03.2016) и текущей (1 августа 2018) версиями Chrome, Edge и Firefox.

function caller()
{
   return caller.caller.caller;
}

'use strict';
function main()
{
   // Original question:
   Hello();
   // Bounty question:
   (function() { console.info('Anonymous function called by ' + caller().name); })();
}

function Hello()
{
   // How do you find out the caller function is 'main'?
   console.info('Hello called by ' + caller().name);
}

main();

вот функция для получить полную трассировку стека:

function stacktrace() {
var f = stacktrace;
var stack = 'Stack trace:';
while (f) {
  stack += '\n' + f.name;
  f = f.caller;
}
return stack;
}

Почему все вышеперечисленные решения выглядят как ракетостроение. Между тем, это не должно быть сложнее этого фрагмента. Все кредиты этому парню

Как узнать функцию вызывающего абонента в JavaScript?

var stackTrace = function() {

    var calls = [];
    var caller = arguments.callee.caller;

    for (var k = 0; k < 10; k++) {
        if (caller) {
            calls.push(caller);
            caller = caller.caller;
        }
    }

    return calls;
};

// when I call this inside specific method I see list of references to source method, obviously, I can add toString() to each call to see only function's content
// [function(), function(data), function(res), function(l), function(a, c), x(a, b, c, d), function(c, e)]

Я думаю, что следующий фрагмент кода может быть полезен:

window.fnPureLog = function(sStatement, anyVariable) {
    if (arguments.length < 1) { 
        throw new Error('Arguments sStatement and anyVariable are expected'); 
    }
    if (typeof sStatement !== 'string') { 
        throw new Error('The type of sStatement is not match, please use string');
    }
    var oCallStackTrack = new Error();
    console.info(oCallStackTrack.stack.replace('Error', 'Call Stack:'), '\n' + sStatement + ':', anyVariable);
}

Выполните код:

window.fnPureLog = function(sStatement, anyVariable) {
    if (arguments.length < 1) { 
        throw new Error('Arguments sStatement and anyVariable are expected'); 
    }
    if (typeof sStatement !== 'string') { 
        throw new Error('The type of sStatement is not match, please use string');
    }
    var oCallStackTrack = new Error();
    console.info(oCallStackTrack.stack.replace('Error', 'Call Stack:'), '\n' + sStatement + ':', anyVariable);
}

function fnBsnCallStack1() {
    fnPureLog('Stock Count', 100)
}

function fnBsnCallStack2() {
    fnBsnCallStack1()
}

fnBsnCallStack2();

Журнал выглядит так:

Call Stack:
    at window.fnPureLog (<anonymous>:8:27)
    at fnBsnCallStack1 (<anonymous>:13:5)
    at fnBsnCallStack2 (<anonymous>:17:5)
    at <anonymous>:20:1 
Stock Count: 100

Оба ответ Хейстюарта и JiarongWu ответ упомянули, что объект Error имеет доступ к stack.

Вот пример:

function main() {
  Hello();
}

function Hello() {
  var stack = new Error().stack;
  // N.B. stack === "Error\n  at Hello ...\n  at main ... \n...."
  var m = stack.match(/.*?Hello.*?\n(.*?)\n/);
  if (m) {
    var caller_name = m[1];
    console.info("Caller is:", caller_name)
  }
}

main();

В разных браузерах стек отображается в разных строковых форматах:

Safari  : Caller is: main@https://stacksnippets.net/js:14:8
Firefox : Caller is: main@https://stacksnippets.net/js:14:3
Chrome  : Caller is:     at main (https://stacksnippets.net/js:14:3)
IE Edge : Caller is:    at main (https://stacksnippets.net/js:14:3)
IE      : Caller is:    at main (https://stacksnippets.net/js:14:3)

Большинство браузеров устанавливают стек с var stack = (new Error()).stack. В Internet Explorer стек будет неопределенным - для получения стека необходимо создать реальное исключение.

Вывод: с помощью stack в объекте Error можно определить, что «основной» - это вызывающий «Hello». Фактически, это будет работать в тех случаях, когда подход callee / caller не работает. Он также покажет вам контекст, то есть исходный файл и номер строки. Однако необходимы усилия, чтобы сделать решение кроссплатформенным.

Я бы сделал это:

function Hello() {
  console.trace();
}

Обновление 2018

caller запрещен в строгом режиме. Вот альтернатива с использованием (нестандартного) Стек Error.

Следующая функция, похоже, выполняет свою работу в Firefox 52 и Chrome 61-71, хотя ее реализация делает много предположений о формате ведения журнала двух браузеров и ее следует использовать с осторожностью, учитывая, что она генерирует исключение и, возможно, выполняет два регулярных выражения. сопоставления перед выполнением.

'use strict';
const fnNameMatcher = /([^(]+)@|at ([^(]+) \(/;

function fnName(str) {
  const regexResult = fnNameMatcher.exec(str);
  return regexResult[1] || regexResult[2];
}

function log(...messages) {
  const logLines = (new Error().stack).split('\n');
  const callerName = fnName(logLines[1]);

  if (callerName !== null) {
    if (callerName !== 'log') {
      console.info(callerName, 'called log with:', ...messages);
    } else {
      console.info(fnName(logLines[2]), 'called log with:', ...messages);
    }
  } else {
    console.info(...messages);
  }
}

function foo() {
  log('hi', 'there');
}

(function main() {
  foo();
}());

Просто запишите свой стек ошибок в консоль. Затем вы можете узнать, как вас зовут

const hello = () => {
  console.info(new Error('I was called').stack)
}

const sello = () => {
  hello()
}

sello()

Поскольку ни один из предыдущих ответов не работает так, как я искал (получение только последнего вызывающего функцию, а не функцию в виде строки или стека вызовов), я публикую свое решение здесь для таких, как я, и надеюсь, что это сработает для них:

function getCallerName(func)
{
  if (!func) return "anonymous";
  let caller = func.caller;
  if (!caller) return "anonymous";
  caller = caller.toString();
  if (!caller.trim().startsWith("function")) return "anonymous";
  return caller.substring(0, caller.indexOf("(")).replace("function","");
}


//  Example of how to use "getCallerName" function

function Hello(){
console.info("ex1  =>  " + getCallerName(Hello));
}

function Main(){
Hello();

// another example
console.info("ex3  =>  " + getCallerName(Main));
}

Main();

И в ES6, и в строгом режиме используйте следующее, чтобы получить функцию вызывающего абонента

console.info((new Error()).stack.split("\n")[2].trim().split(" ")[1])

Обратите внимание, что приведенная выше строка вызовет исключение, если нет вызывающей стороны или нет предыдущего стека. Используйте соответственно.

Чтобы получить вызываемого (текущее имя функции), используйте:

console.info((new Error()).stack.split("\n")[1].trim().split(" ")[1]) 

Обратите внимание, что вы не можете использовать Function.caller в Node.js, вместо этого используйте пакет идентификатор вызывающего абонента. Например:

var callerId = require('caller-id');

function foo() {
    bar();
}
function bar() {
    var caller = callerId.getData();
    /*
    caller = {
        typeName: 'Object',
        functionName: 'foo',
        filePath: '/path/of/this/file.js',
        lineNumber: 5,
        topLevelFlag: true,
        nativeFlag: false,
        evalFlag: false
    }
    */
}

У меня отлично работает, и вы можете выбрать, на сколько вы хотите вернуться в функциях:

function getCaller(functionBack= 0) {
    const back = functionBack * 2;
    const stack = new Error().stack.split('at ');
    const stackIndex = stack[3 + back].includes('C:') ? (3 + back) : (4 + back);
    const isAsync = stack[stackIndex].includes('async');
    let result;
    if (isAsync)
      result = stack[stackIndex].split(' ')[1].split(' ')[0];
    else
      result = stack[stackIndex].split(' ')[0];
    return result;
}