Функция: name

Свойство данных name экземпляра Function указывает имя функции, заданное при ее создании, или оно может быть либо anonymous, либо '' (пустая строка) для анонимно созданных функций.

Попробуйте

const func1 = function () {};

const object = {
  func2: function () {},
};

console.log(func1.name);
// Expected output: "func1"

console.log(object.func2.name);
// Expected output: "func2"

Значение

Строка.

Описание

Свойство name функции может использоваться для идентификации функции в инструментах отладки или сообщениях об ошибках. Оно не имеет семантического значения для самого языка.

Свойство name доступно только для чтения и не может быть изменено оператором присваивания:

function someFunction() {}

someFunction.name = "otherFunction";
console.log(someFunction.name); // someFunction

Чтобы изменить его, используйте Object.defineProperty().

Свойство name обычно выводится из того, как определяется функция. В следующих разделах мы опишем различные способы его вывода.

Объявление функции

Свойство name возвращает имя объявления функции.

function doSomething() {}
doSomething.name; // "doSomething"

Объявление функции с экспортом по умолчанию

Объявление export default экспортирует функцию как объявление, а не как выражение. Если объявление анонимное, имя будет "default".

// -- someModule.js --
export default function () {}

// -- main.js --
import someModule from "./someModule.js";

someModule.name; // "default"

Конструктор Function

Функции, созданные с помощью конструктора Function(), имеют имя "anonymous".

new Function().name; // "anonymous"

Функциональное выражение

Если функциональное выражение имеет имя, это имя используется как свойство name.

const someFunction = function someFunctionName() {};
someFunction.name; // "someFunctionName"

Анонимные функциональные выражения, созданные с использованием ключевого слова function или синтаксиса стрелочных функций, по умолчанию имеют "" (пустую строку) в качестве имени.

(function () {}).name; // ""
(() => {}).name; // ""

Однако такие случаи редки — обычно, чтобы вызвать функцию в другом месте, функциональное выражение связывается с идентификатором. Имя анонимного функционального выражения может быть выведено в определенных синтаксических контекстах, включая: объявление переменной, метод, инициализатор и значение по умолчанию.

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

function getFoo() {
  return () => {};
}
getFoo().name; // ""

Объявление переменной и метод

Переменные и методы могут выводить имя анонимной функции из ее синтаксической позиции.

const f = function () {};
const object = {
  someMethod: function () {},
};

console.log(f.name); // "f"
console.log(object.someMethod.name); // "someMethod"

То же самое относится и к присваиванию:

let f;
f = () => {};
f.name; // "f"

Инициализатор и значение по умолчанию

Функции в инициализаторах (значениях по умолчанию) деструктуризации, параметрах по умолчанию, полях классов и т. д. унаследуют имя связанного идентификатора как свое name.

const [f = () => {}] = [];
f.name; // "f"

const { someMethod: m = () => {} } = {};
m.name; // "m"

function foo(f = () => {}) {
  console.log(f.name);
}
foo(); // "f"

class Foo {
  static someMethod = () => {};
}
Foo.someMethod.name; // someMethod

Сокращенный метод

const o = {
  foo() {},
};
o.foo.name; // "foo";

Связанная функция

Function.prototype.bind() создает функцию, имя которой — "bound " плюс имя функции.

function foo() {}
foo.bind({}).name; // "bound foo"

Геттер и сеттер

При использовании get и set свойств доступа "get" или "set" будут присутствовать в имени функции.

const o = {
  get foo() {
    return 1;
  },
  set foo(x) {},
};

const descriptor = Object.getOwnPropertyDescriptor(o, "foo");
descriptor.get.name; // "get foo"
descriptor.set.name; // "set foo";

Класс

Имя класса следует тому же алгоритму, что и объявления функций и функциональные выражения.

class Foo {}
Foo.name; // "Foo"

Символ в качестве имени функции

Если Symbol используется в качестве имени функции, а символ имеет описание, имя метода — это описание в квадратных скобках.

const sym1 = Symbol("foo");
const sym2 = Symbol();

const o = {
  [sym1]() {},
  [sym2]() {},
};

o[sym1].name; // "[foo]"
o[sym2].name; // "[]"

Приватные поля и методы

Приватные поля и приватные методы имеют символ решетки (#) в составе своих имен.

class Foo {
  #field = () => {};
  #method() {}
  getNames() {
    console.log(this.#field.name);
    console.log(this.#method.name);
  }
}

new Foo().getNames();
// "#field"
// "#method"

Примеры

Определение имени конструктора объекта

Вы можете использовать obj.constructor.name для проверки "класса" объекта.

function Foo() {} // Or: class Foo {}

const fooInstance = new Foo();
console.log(fooInstance.constructor.name); // "Foo"

Однако, поскольку статические члены становятся собственными свойствами класса, мы не можем получить имя класса практически для любого класса со свойством статического метода name():

class Foo {
  constructor() {}
  static name() {}
}

С методом static name() Foo.name больше не содержит фактического имени класса, а является ссылкой на объект функции name(). Попытка получить класс fooInstance через fooInstance.constructor.name не даст нам имя класса, а вместо этого ссылку на статический метод класса. Пример:

const fooInstance = new Foo();
console.log(fooInstance.constructor.name); // ƒ name() {}

Из-за наличия статических полей name также может не быть функцией.

class Foo {
  static name = 123;
}
console.log(new Foo().constructor.name); // 123

Если у класса есть статическое свойство с именем name, оно также станет записываемым. Встроенное определение при отсутствии пользовательского статического определения является только для чтения:

Foo.name = "Hello";
console.log(Foo.name); // "Hello" if class Foo has a static "name" property, but "Foo" if not.

Следовательно, вы не можете полагаться на встроенное свойство name, что оно всегда содержит имя класса.

Компрессоры и минификаторы JavaScript

Исходный код, такой как:

function Foo() {}
const foo = new Foo();

if (foo.constructor.name === "Foo") {
  console.log("'foo' is an instance of 'Foo'");
} else {
  console.log("Oops!");
}

может быть сжат до:

function a() {}
const b = new a();
if (b.constructor.name === "Foo") {
  console.log("'foo' is an instance of 'Foo'");
} else {
  console.log("Oops!");
}

В несжатой версии программа попадает в ветку true и выводит "'foo' is an instance of 'Foo'", тогда как в сжатой версии она ведет себя иначе и попадает в ветку else. Если вы полагаетесь на свойство name, как в приведенном выше примере, убедитесь, что ваш конвейер сборки не изменяет имена функций, или не предполагайте, что функция имеет определенное имя.

Спецификации

Совместимость с браузерами

См. также

• Polyfill для Function: name в core-js
• es-shims polyfill Function.prototype.name
• Function