diff options
Diffstat (limited to 'files/ru/web/javascript/reference/global_objects/function')
14 files changed, 2121 insertions, 0 deletions
diff --git a/files/ru/web/javascript/reference/global_objects/function/apply/index.html b/files/ru/web/javascript/reference/global_objects/function/apply/index.html new file mode 100644 index 0000000000..538c25a654 --- /dev/null +++ b/files/ru/web/javascript/reference/global_objects/function/apply/index.html @@ -0,0 +1,252 @@ +--- +title: Function.prototype.apply() +slug: Web/JavaScript/Reference/Global_Objects/Function/apply +tags: + - Function + - JavaScript + - Method + - Reference + - Référence(2) +translation_of: Web/JavaScript/Reference/Global_Objects/Function/apply +--- +<div>{{JSRef("Global_Objects", "Function")}}</div> + +<h2 id="Summary" name="Summary">Общие сведения</h2> + +<p>Метод <strong><code>apply()</code></strong> вызывает функцию с указанным значением <code>this</code> и аргументами, предоставленными в виде массива (либо <a href="/ru/docs/Web/JavaScript/Guide/Predefined_Core_Objects#Working_with_Array-like_objects">массивоподобного объекта</a>).</p> + +<div class="note"> +<p><strong>Примечание:</strong> хотя синтаксис этой функции практически полностью идентичен функции {{jsxref("Function.prototype.call()", "call()")}}, фундаментальное различие между ними заключается в том, что функция <code>call()</code> принимает список аргументов, в то время как функция <code>apply()</code> принимает единичный массив аргументов.</p> +</div> + +<h2 id="Syntax" name="Syntax">Синтаксис</h2> + +<pre class="syntaxbox"><code><var>fun</var>.apply(<var>thisArg</var>, [<var>argsArray</var>])</code></pre> + +<h3 id="Parameters" name="Parameters">Параметры</h3> + +<dl> + <dt><code>thisArg</code></dt> + <dd>Опциональный параметр. Значение <code>this</code>, предоставляемое для вызова функции <em><code>fun</code></em>. Обратите внимание, что <code>this</code> может не быть реальным значением, видимым этим методом: если метод является функцией в {{jsxref("Functions_and_function_scope/Strict_mode", "нестрогом режиме", "", 1)}}, значения {{jsxref("Global_Objects/null", "null")}} и {{jsxref("Global_Objects/undefined", "undefined")}} будут заменены глобальным объектом, а примитивные значения будут упакованы в объекты.</dd> + <dt><code>argsArray</code></dt> + <dd>Опциональный параметр. Массивоподобный объект, определяющий аргументы, с которыми функция <em><code>fun</code></em> должна быть вызвана, либо {{jsxref("Global_Objects/null", "null")}} или {{jsxref("Global_Objects/undefined", "undefined")}}, если в функцию не надо передавать аргументы. Начиная с ECMAScript 5 эти аргументы могут быть обобщёнными массивоподобными объектами, а не только массивом. Смотрите ниже информацию по {{anch("Browser_compatibility", "совместимости с браузерами")}}.</dd> +</dl> + +<h2 id="Description" name="Description">Описание</h2> + +<p>Вы можете присваивать различные объекты <code>this</code> при вызове существующей функции. <code>this</code> ссылается на текущий объект, вызывающий объект. С помощью <code>apply()</code> вы можете написать метод один раз, а затем наследовать его в других объектах без необходимости переписывать метод для каждого нового объекта.</p> + +<p>Метод <code>apply</code> очень похож на метод {{jsxref("Function.prototype.call()", "call()")}}, за исключением поддерживаемого типа аргументов. Вы можете использовать массив аргументов вместо набора именованных параметров. Вместе с <code>apply</code> вы можете использовать литерал массива, например, <code><em>fun</em>.apply(this, ['есть', 'бананы'])</code>, либо объект {{jsxref("Global_Objects/Array", "Array")}}, например, <code><em>fun</em>.apply(this, new Array('есть', 'бананы'))</code>.</p> + +<p>Также вы можете использовать в качестве параметра <code>argsArray</code> псевдомассив {{jsxref("Functions_and_function_scope/arguments", "arguments")}}. <code>arguments</code> является локальной переменной функции. Он может использоваться для всех неопределённых аргументов вызываемого объекта. Таким образом, вы не обязаны знать, сколько и какие аргументы требует вызываемый объект при использовании метода <code>apply()</code>. Вы можете использовать псевдомассив <code>arguments</code> для передачи всех аргументов в вызываемый объект. Вызываемый объект самостоятельно разберётся с обработкой аргументов.</p> + +<p>Начиная с 5-го издания ECMAScript, вы также можете использовать любой вид массивоподобного объекта, что на практике означает, что он должен иметь свойство <code>length</code> и целочисленные свойства в диапазоне <code>(0...length)</code>. В качестве примера, теперь вы можете использовать {{domxref("NodeList")}} или свой собственный объект вида <code>{ 'length': 2, '0': 'есть', '1': 'бананы' }</code>.</p> + +<p>{{note("Большинство браузеров, включая Chrome 14 и Internet Explorer 9, всё ещё не принимают массивоподобные объекты и будут выбрасывать исключение.")}}</p> + +<h2 id="Examples" name="Examples">Примеры</h2> + +<h3 id="Example_Using_apply_to_chain_constructors" name="Example:_Using_apply_to_chain_constructors">Пример: использование <code>apply()</code> для связи конструкторов объекта в цепочку</h3> + +<p>Вы можете использовать метод <code>apply()</code> для объединения в цепочку {{jsxref("Operators/new", "конструкторов", "", 1)}} объекта, как в Java. В следующем примере мы создадим в объекте {{jsxref("Global_Objects/Function", "Function")}} глобальный метод <code>construct()</code>, который позволит нам использовать массивоподобные объекты с конструктором вместо списка аргументов.</p> + +<pre class="brush: js">Function.prototype.construct = function (aArgs) { + var oNew = Object.create(this.prototype); + this.apply(oNew, aArgs); + return oNew; +}; +</pre> + +<div class="note"> +<p><strong>Примечание:</strong> метод {{jsxref("Object.create()")}}, использованный в этом примере, относительно новый. В качестве альтернативного способа можно рассмотреть возможность использования замыкания:</p> + +<pre class="brush: js">Function.prototype.construct = function(aArgs) { + var fConstructor = this, fNewConstr = function() { fConstructor.apply(this, aArgs); }; + fNewConstr.prototype = fConstructor.prototype; + return new fNewConstr(); +}; +</pre> +</div> + +<p>Пример использования:</p> + +<pre class="brush: js">function MyConstructor() { + for (var nProp = 0; nProp < arguments.length; nProp++) { + this['property' + nProp] = arguments[nProp]; + } +} + +var myArray = [4, 'Привет, мир!', false]; +var myInstance = MyConstructor.construct(myArray); + +alert(myInstance.property1); // выведет 'Привет, мир!' +alert(myInstance instanceof MyConstructor); // выведет 'true' +alert(myInstance.constructor); // выведет 'MyConstructor' +</pre> + +<div class="note"> +<p><strong>Примечание:</strong> этот неродной метод <code>Function.construct()</code> не будет работать с некоторыми родными конструкторами (вроде конструктора {{jsxref("Global_Objects/Date", "Date")}}, к примеру). В этих случаях вы можете использовать метод {{jsxref("Function.prototype.bind()")}} (например, представьте, что вы имеете следующий массив, который можно использовать с конструктором {{jsxref("Global_Objects/Date", "Date")}}: <code>[2012, 11, 4]</code>; в этом случае вы напишите что-то вроде: <code>new (Function.prototype.bind.apply(Date, [null].concat([2012, 11, 4])))()</code> — так или иначе, это не самый изящный способ и, вероятно, его не стоит использовать в рабочем окружении).</p> +</div> + +<h3 id="Example_Using_apply_and_built-in_functions" name="Example:_Using_apply_and_built-in_functions">Пример: использование <code>apply()</code> и встроенных функций</h3> + +<p>Умное использование метода <code>apply()</code> позволяет вам использовать встроенные функции для некоторых задач, для которых в противном случае пришлось бы писать цикл по массиву значений. В качестве примера давайте используем {{jsxref("Math.max()")}}/{{jsxref("Math.min()")}} для нахождения максимального/минимального значения в массиве.</p> + +<pre class="brush: js">/* мин/макс числа в массиве */ +var numbers = [5, 6, 2, 3, 7]; + +/* используем apply к Math.min/Math.max */ +var max = Math.max.apply(null, numbers); /* Это эквивалентно Math.max(numbers[0], ...) + или Math.max(5, 6, ...) */ +var min = Math.min.apply(null, numbers); + +/* сравним с простым алгоритмом с циклом */ +max = -Infinity, min = +Infinity; + +for (var i = 0; i < numbers.length; i++) { + if (numbers[i] > max) { + max = numbers[i]; + } + if (numbers[i] < min) { + min = numbers[i]; + } +} +</pre> + +<p>Но будьте осторожны: при использовании метода <code>apply()</code> таким образом вы рискуете выйти за пределы ограничения на количество аргументов в движке JavaScript. Последствия применения функции с очень большим количеством аргументов (думается, больше десяти тысяч аргументов) различаются от движка к движку (JavaScriptCore имеет жёстко зашитое <a class="link-https" href="https://bugs.webkit.org/show_bug.cgi?id=80797">ограничение на количество аргументов в 65536</a>), поскольку этот предел (на самом деле, это природа поведения любого чрезвычайно огромного стека) не определён. Некоторые движки будут выкидывать исключение. Хуже того, другие просто отбрасывают реально переданные функции аргументы сверх лимита. (Для иллюстрации последнего случая: если такой движок имеет ограничение в четыре элемента [реальное ограничение, конечно же, гораздо выше], это выглядело бы так, как если бы в примере выше в метод <code>apply()</code> были переданы аргументы <code>5, 6, 2, 3</code>, а не весь массив.) Если ваш масив значений может вырасти до десятков тысяч, используйте смешанный подход: применяйте вашу функцию к порциям массива:</p> + +<pre class="brush: js">function minOfArray(arr) { + var min = Infinity; + var QUANTUM = 32768; + + for (var i = 0, len = arr.length; i < len; i += QUANTUM) { + var submin = Math.min.apply(null, arr.slice(i, Math.min(i + QUANTUM, len))); + min = Math.min(submin, min); + } + + return min; +} + +var min = minOfArray([5, 6, 2, 3, 7]); +</pre> + +<h3 id="Example_Using_apply_in_monkey-patching" name="Example:_Using_apply_in_monkey-patching">Пример: использование <code>apply()</code> в «monkey-патчинге»</h3> + +<p>Метод <code>apply()</code> может быть лучшим вариантом для «monkey-патчинга» встроенных в Firefox функций, либо JS библиотек. Пусть у вас есть функция <code>someobject.foo()</code>, вы можете изменить её таким немного хакерским способом:</p> + +<pre class="brush: js">var originalfoo = someobject.foo; +someobject.foo = function() { + // Делаем что-то до вызова функции + console.log(arguments); + // Вызываем функцию так, как будто бы она была вызвана обычным образом: + originalfoo.apply(this, arguments); + // Делаем что-то после вызова функции. +} +</pre> + +<p>Этот метод особенно удобен, когда вам нужно отладить события, либо интерфейс с чем-то, что не имеет API, вроде различных событий <code>.on([event]...</code>, например, тех что используются в <a href="/ru/docs/Tools/Page_Inspector#Developer_API">Инспекторе инструментов разработчика</a>).</p> + +<h2 id="Specifications" name="Specifications">Спецификации</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Спецификация</th> + <th scope="col">Статус</th> + <th scope="col">Комментарии</th> + </tr> + <tr> + <td>ECMAScript 3-е издание.</td> + <td>Стандарт</td> + <td>Изначальное определение. Реализована в JavaScript 1.3.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.3.4.3', 'Function.prototype.apply')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-function.prototype.apply', 'Function.prototype.apply')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Возможность</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Базовая поддержка</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + <tr> + <td>Обобщённые массивоподобные объекты ES 5.1, вроде {{jsxref("Functions_and_function_scope/arguments", "arguments")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatGeckoDesktop("2.0")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Возможность</th> + <th>Android</th> + <th>Chrome для Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Базовая поддержка</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + <tr> + <td>Обобщённые массивоподобные объекты ES 5.1, вроде {{jsxref("Functions_and_function_scope/arguments", "arguments")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatGeckoMobile("2.0")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Смотрите также</h2> + +<ul> + <li>объект {{jsxref("Functions_and_function_scope/arguments", "arguments")}}</li> + <li>{{jsxref("Function.prototype.bind()")}}</li> + <li>{{jsxref("Function.prototype.call()")}}</li> + <li>{{jsxref("Functions_and_function_scope", "Функции и их область видимости", "", 1)}}</li> +</ul> diff --git a/files/ru/web/javascript/reference/global_objects/function/arguments/index.html b/files/ru/web/javascript/reference/global_objects/function/arguments/index.html new file mode 100644 index 0000000000..7b089887c4 --- /dev/null +++ b/files/ru/web/javascript/reference/global_objects/function/arguments/index.html @@ -0,0 +1,116 @@ +--- +title: Function.arguments +slug: Web/JavaScript/Reference/Global_Objects/Function/arguments +tags: + - Deprecated + - Function + - JavaScript + - Property + - arguments +translation_of: Web/JavaScript/Reference/Global_Objects/Function/arguments +--- +<div> + {{JSRef("Global_Objects", "Function")}} {{deprecated_header}}</div> +<h2 id="Summary" name="Summary">Сводка</h2> +<p>Свойство <code><strong><em>function</em>.arguments</strong></code> ссылалось на массивоподобный объект, соответствующий аргументам, переданным в функцию. Используйте вместо него простую переменную {{jsxref("Functions_and_function_scope/arguments", "arguments")}}.</p> +<h2 id="Description" name="Description">Описание</h2> +<p>Синтаксис <code><em>function</em>.arguments</code> устарел. Рекомендуемым способом доступа к объекту {{jsxref("Functions_and_function_scope/arguments", "arguments")}}, доступному внутри функций, являеся простая ссылка на переменную {{jsxref("Functions_and_function_scope/arguments", "arguments")}}.</p> +<p>В случае рекурсии, то есть, если функция <code>f</code> несколько раз появляется в стеке вызовов, значение <code>f.arguments</code> представляет аргументы, соответствующие самому последнему вызову функции.</p> +<h2 id="Examples" name="Examples">Примеры</h2> +<pre class="brush: js">function f(n) { g(n - 1); } + +function g(n) { + console.log('до: ' + g.arguments[0]); + if (n > 0) { f(n); } + console.log('после: ' + g.arguments[0]); +} + +f(2); + + +// Вывод + +// до: 1 +// до: 0 +// после: 0 +// после: 1 +</pre> +<h2 id="Specifications" name="Specifications">Спецификации</h2> +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Спецификация</th> + <th scope="col">Статус</th> + <th scope="col">Комментарии</th> + </tr> + <tr> + <td>ECMAScript 1-е издание.</td> + <td>Стандарт</td> + <td>Изначальное определение. Реализована в JavaScript 1.0. Устарело в связи с объектом {{jsxref("Functions_and_function_scope/arguments", "arguments")}}</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-10.6', 'объект arguments')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Объект {{jsxref("Functions_and_function_scope/arguments", "arguments")}}</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-arguments-object', 'объект arguments')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Объект {{jsxref("Functions_and_function_scope/arguments", "arguments")}}</td> + </tr> + </tbody> +</table> +<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2> +<div> + {{CompatibilityTable}}</div> +<div id="compat-desktop"> + <table class="compat-table"> + <tbody> + <tr> + <th>Возможность</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Базовая поддержка</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> + </table> +</div> +<div id="compat-mobile"> + <table class="compat-table"> + <tbody> + <tr> + <th>Возможность</th> + <th>Android</th> + <th>Chrome для Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Базовая поддержка</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> + </table> +</div> +<h2 id="See_also" name="See_also">Смотрите также</h2> +<ul> + <li>объект {{jsxref("Functions_and_function_scope/arguments", "arguments")}}</li> + <li>{{jsxref("Functions_and_function_scope", "Функции и их область видимости", "", 1)}}</li> +</ul> diff --git a/files/ru/web/javascript/reference/global_objects/function/arity/index.html b/files/ru/web/javascript/reference/global_objects/function/arity/index.html new file mode 100644 index 0000000000..8bcd00363b --- /dev/null +++ b/files/ru/web/javascript/reference/global_objects/function/arity/index.html @@ -0,0 +1,30 @@ +--- +title: Function.arity +slug: Web/JavaScript/Reference/Global_Objects/Function/arity +tags: + - Function + - JavaScript + - Obsolete + - Property + - Unimplemented +translation_of: Archive/Web/JavaScript/Function.arity +--- +<div>{{JSRef}}{{Obsolete_Header}}</div> + +<p class="note">Свойство <code><strong>arity</strong></code> использовалось для возврата количества ожидаемых функцией аргументов, однако, оно больше не существует и было заменено свойством {{JSxRef("Function.prototype.length")}}.</p> + +<h2 id="Specifications" name="Specifications">Спецификации</h2> + +<p>Реализовано в JavaScript 1.2. Устарело в JavaScript 1.4.</p> + +<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2> + +<div class="hidden">Таблица совместимости на данной странице составлена из структурированных данных. Чтобы поучаствовать в работе над данными, пожалуйста, обратитесь к репозиторию <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> и отправьте нам запрос на включение изменений.</div> + +<p>{{Compat("javascript.builtins.Function.arity")}}</p> + +<h2 id="See_also" name="See_also">Смотрите также</h2> + +<ul> + <li>{{JSxRef("Function.prototype.length")}}</li> +</ul> diff --git a/files/ru/web/javascript/reference/global_objects/function/bind/index.html b/files/ru/web/javascript/reference/global_objects/function/bind/index.html new file mode 100644 index 0000000000..325c24fa0b --- /dev/null +++ b/files/ru/web/javascript/reference/global_objects/function/bind/index.html @@ -0,0 +1,311 @@ +--- +title: Function.prototype.bind() +slug: Web/JavaScript/Reference/Global_Objects/Function/bind +tags: + - ECMAScript5 + - ECMAScript6 + - Function + - JavaScript + - Method + - Reference + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Function/bind +--- +<div>{{JSRef("Global_Objects", "Function")}}</div> + +<h2 id="Summary" name="Summary">Сводка</h2> + +<p>Метод <code><strong>bind()</strong></code> создаёт новую функцию, которая при вызове устанавливает в качестве контекста выполнения <code>this</code> предоставленное значение. В метод также передаётся набор аргументов, которые будут установлены перед переданными в привязанную функцию аргументами при её вызове.</p> + +<h2 id="Syntax" name="Syntax">Синтаксис</h2> + +<pre class="syntaxbox"><code><var>fun</var>.bind(<var>thisArg</var>[, <var>arg1</var>[, <var>arg2</var>[, ...]]])</code></pre> + +<h3 id="Parameters" name="Parameters">Параметры</h3> + +<dl> + <dt><code>thisArg</code></dt> + <dd>Значение, передаваемое в качестве <code>this</code> в целевую функцию при вызове привязанной функции. Значение игнорируется, если привязанная функция конструируется с помощью оператора {{jsxref("Operators/new", "new")}}.</dd> + <dt><code>arg1, arg2, ...</code></dt> + <dd>Аргументы целевой функции, передаваемые перед аргументами привязанной функции при вызове целевой функции.</dd> +</dl> + +<h2 id="Description" name="Description">Описание</h2> + +<p>Метод <code>bind()</code> создаёт новую "<strong>привязанную функцию</strong>" (<strong>ПФ</strong>). <strong>ПФ</strong> <span class="translation-chunk">- это "необычный </span> <span class="translation-chunk">функциональный объект" ( термин из </span> <strong>ECMAScript 6</strong> <span class="translation-chunk"> ), который является оберткой над исходным </span> <span class="translation-chunk">функциональным объектом. Вызов </span> <strong>ПФ</strong> <span class="translation-chunk"> приводит к исполнению кода обернутой функции.</span></p> + +<p><strong>ПФ</strong> <span class="translation-chunk"> имеет следующие внутренние ( скрытые ) свойства:</span></p> + +<ul> + <li><span class="translation-chunk"><strong>[[BoundTargetFunction]]</strong> - оборачиваемый (целевой ) </span> <span class="translation-chunk">функциональный </span><span class="translation-chunk">объект</span></li> + <li><span class="translation-chunk"><strong>[[BoundThis]]</strong> - значение, которое всегда передается в качестве значения <strong>this </strong>при вызове обернутой функции.</span></li> + <li><span class="translation-chunk"><strong>[[BoundArguments]] </strong>- список значений, элементы которого используются в качестве первого аргумента при вызове оборачиваемой функции.</span></li> + <li><strong><span class="translation-chunk">[[</span>Call</strong><span class="translation-chunk"><strong>]] </strong>- внутренний метод. Выполняет код (функциональное выражение), связанный с функциональным объектом. </span></li> +</ul> + +<p><span class="translation-chunk">Когда <strong>ПФ </strong>вызывается, исполняется ее внутренний метод </span> <strong>[[Call]]</strong> <span class="translation-chunk"> со следующими аргументами </span> <strong>Call(<em>target</em>, <em>boundThis</em>, <em>args</em>).</strong></p> + +<ul> + <li><strong><em>target</em></strong> <span class="translation-chunk"> - <strong>[[BoundTargetFunction]]</strong>;</span></li> + <li><span class="translation-chunk"><em><strong>boundThis </strong></em></span><em><strong> <span class="translation-chunk"> </span> </strong></em><span class="translation-chunk"><em><strong> </strong></em>- </span><strong> </strong><span class="translation-chunk"><strong>[[BoundThis]]</strong>;</span></li> + <li><em><strong>args </strong></em> - <strong> <span class="translation-chunk">[[BoundArguments]].</span></strong></li> +</ul> + +<p>Привязанная функция также может быть сконструирована с помощью оператора {{jsxref("Operators/new", "new")}}: это работает так, как если бы вместо неё конструировалась целевая функция. Предоставляемое значение <code>this</code> в этом случае игнорируется, хотя ведущие аргументы всё ещё передаются в эмулируемую функцию.</p> + +<h2 id="Examples" name="Examples">Примеры</h2> + +<h3 id="Example:_Creating_a_bound_function" name="Example:_Creating_a_bound_function">Пример: создание привязанной функции</h3> + +<p>Простейшим способом использования <code>bind()</code> является создание функции, которая, вне зависимости от способа её вызова, вызывается с определённым значением <code>this</code>. Обычным заблуждением для новичков в JavaScript является извлечение метода из объекта с целью его дальнейшего вызова в качестве функции и ожидание того, что он будет использовать оригинальный объект в качестве своего значения <code>this</code> (например, такое может случиться при использовании метода как функции обратного вызова). Однако, без специальной обработки, оригинальный объект зачастую теряется. Создание привязанной функции из функции, использующей оригинальный объект, изящно решает эту проблему:</p> + +<pre class="brush: js">this.x = 9; +var module = { + x: 81, + getX: function() { return this.x; } +}; + +module.getX(); // 81 + +var getX = module.getX; +getX(); // 9, поскольку в этом случае this ссылается на глобальный объект + +// создаём новую функцию с this, привязанным к module +var boundGetX = getX.bind(module); +boundGetX(); // 81 +</pre> + +<h3 id="Example:_Partial_Functions" name="Example:_Partial_Functions">Пример: частичные функции</h3> + +<p>Следующим простейшим способом использования <code>bind()</code> является создание функции с предопределёнными аргументами. Эти аргументы (если они есть) передаются после значения <code>this</code> и вставляются перед аргументами, передаваемыми в целевую функцию при вызове привязанной функции.</p> + +<pre class="brush: js">function list() { + return Array.prototype.slice.call(arguments); +} + +var list1 = list(1, 2, 3); // [1, 2, 3] + +// Создаём функцию с предустановленным ведущим аргументом +var leadingThirtysevenList = list.bind(undefined, 37); + +var list2 = leadingThirtysevenList(); // [37] +var list3 = leadingThirtysevenList(1, 2, 3); // [37, 1, 2, 3] +</pre> + +<h3 id="Example:_With_setTimeout" name="Example:_With_setTimeout">Пример: с <code>setTimeout</code></h3> + +<p>По умолчанию, внутри {{domxref("window.setTimeout()")}} контекст <code>this</code> устанавливается в объект {{domxref("window")}} (или <code>global</code>). При работе с методами класса, требующими <code>this</code> для ссылки на экземпляры класса, вы можете явно привязать <code>this</code> к функции обратного вызова для сохранения экземпляра.</p> + +<pre class="brush: js">function LateBloomer() { + this.petalCount = Math.ceil(Math.random() * 12) + 1; +} + +// Объявляем цветение с задержкой в 1 секунду +LateBloomer.prototype.bloom = function() { + window.setTimeout(this.declare.bind(this), 1000); +}; + +LateBloomer.prototype.declare = function() { + console.log('Я прекрасный цветок с ' + + this.petalCount + ' лепестками!'); +}; +</pre> + +<h3 id="Example:_Bound_functions_used_as_constructors" name="Example:_Bound_functions_used_as_constructors">Пример: привязывание функций, используемых в качестве конструкторов</h3> + +<div class="warning"> +<p><strong>Предупреждение:</strong> этот раздел демонстрирует возможности JavaScript и документирует некоторые граничные случаи использования метода <code>bind()</code>. Показанные ниже методы не являются лучшей практикой и, вероятно, их не следует использовать в рабочем окружении.</p> +</div> + +<p>Привязанные функции автоматически подходят для использования вместе с оператором {{jsxref("Operators/new", "new")}} для конструирования новых экземпляров, создаваемых целевой функцией. Когда привязанная функция используется для конструирования значения, предоставляемое значение <code>this</code> игнорируется. Однако, предоставляемые аргументы всё так же вставляются перед аргументами конструктора:</p> + +<pre class="brush: js">function Point(x, y) { + this.x = x; + this.y = y; +} + +Point.prototype.toString = function() { + return this.x + ',' + this.y; +}; + +var p = new Point(1, 2); +p.toString(); // '1,2' + + +var emptyObj = {}; +var YAxisPoint = Point.bind(emptyObj, 0/*x*/); +// не поддерживается полифиллом, приведённым ниже, +// но отлично работает с родным bind: +var YAxisPoint = Point.bind(null, 0/*x*/); + +var axisPoint = new YAxisPoint(5); +axisPoint.toString(); // '0,5' + +axisPoint instanceof Point; // true +axisPoint instanceof YAxisPoint; // true +new Point(17, 42) instanceof YAxisPoint; // true +</pre> + +<p>Обратите внимание, что вам не нужно делать ничего особенного для создания привязанной функции, используемой с оператором {{jsxref("Operators/new", "new")}}. В итоге, для создания явно вызываемой привязанной функции, вам тоже не нужно делать ничего особенного, даже если вам требуется, чтобы привязанная функция вызывалась только с помощью оператора {{jsxref("Operators/new", "new")}}.</p> + +<pre class="brush: js">// Пример может быть запущен прямо в вашей консоли JavaScript +// ...продолжение примера выше + +// Всё ещё можно вызывать как нормальную функцию +// (хотя обычно это не предполагается) +YAxisPoint(13); + +emptyObj.x + ',' + emptyObj.y; +// > '0,13' +</pre> + +<p>Если вы хотите поддерживать использование привязанной функции только с помощью оператора {{jsxref("Operators/new", "new")}}, либо только с помощью прямого вызова, целевая функция должна предусматривать такие ограничения.</p> + +<h3 id="Example:_Creating_shortcuts" name="Example:_Creating_shortcuts">Пример: создание сокращений</h3> + +<p>Метод <code>bind()</code> также полезен в случаях, если вы хотите создать сокращение для функции, требующей определёное значение <code>this</code>.</p> + +<p>Возьмём, например, метод {{jsxref("Array.prototype.slice")}}, который вы можете использовать для преобразования массивоподобного объекта в настоящий массив. Вы можете создать подобное сокращение:</p> + +<pre class="brush: js">var slice = Array.prototype.slice; + +// ... + +slice.call(arguments); +</pre> + +<p>С помощью метода <code>bind()</code>, это сокращение может быть упрощено. В следующем куске кода <code>slice</code> является функцией, привязанной к функции {{jsxref("Function.prototype.call()", "call()")}} объекта {{jsxref("Function.prototype")}}, со значением <code>this</code>, установленным в функцию {{jsxref("Array.prototype.slice()", "slice()")}} объекта {{jsxref("Array.prototype")}}. Это означает, что дополнительный вызов <code>call()</code> может быть устранён:</p> + +<pre class="brush: js">// Тоже самое, что и slice в предыдущем примере +var unboundSlice = Array.prototype.slice; +var slice = Function.prototype.call.bind(unboundSlice); + +// ... + +slice(arguments); +</pre> + +<h2 id="Polyfill" name="Polyfill">Полифилл</h2> + +<p>Функция <code>bind</code> является дополнением к стандарту ECMA-262 5-го издания; поэтому она может присутствовать не во всех браузерах. Вы можете частично обойти это ограничение, вставив следующий код в начало ваших скриптов, он позволяет использовать большую часть возможностей <code>bind()</code> в реализациях, не имеющих его родной поддержки.</p> + +<pre class="brush: js">if (!Function.prototype.bind) { + Function.prototype.bind = function(oThis) { + if (typeof this !== 'function') { + // ближайший аналог внутренней функции + // IsCallable в ECMAScript 5 + throw new TypeError('Function.prototype.bind - what is trying to be bound is not callable'); + } + + var aArgs = Array.prototype.slice.call(arguments, 1), + fToBind = this, + fNOP = function() {}, + fBound = function() { + return fToBind.apply(this instanceof fNOP && oThis + ? this + : oThis, + aArgs.concat(Array.prototype.slice.call(arguments))); + }; + + fNOP.prototype = this.prototype; + fBound.prototype = new fNOP(); + + return fBound; + }; +} +</pre> + +<p>Некоторые из многих отличий (так же могут быть и другие, данный список далеко не исчерпывающий) между этой реализацией и реализацией по умолчанию:</p> + +<ul> + <li>Частичная реализация предполагает, что методы {{jsxref("Array.prototype.slice()")}}, {{jsxref("Array.prototype.concat()")}}, {{jsxref("Function.prototype.call()")}} и {{jsxref("Function.prototype.apply()")}} являются встроенными, имеют своё первоначальное значение.</li> + <li>Частичная реализация создаёт функции, не имеющие неизменяемых свойств «отравленной пилюли» — {{jsxref("Function.caller", "caller")}} и <code>arguments</code> — которые выбрасывают исключение {{jsxref("Global_Objects/TypeError", "TypeError")}} при попытке получить, установить или удалить эти свойства. (Такие свойства могут быть добавлены, если реализация поддерживает {{jsxref("Object.defineProperty")}}, либо частично реализованы [без поведения исключение-при-попытке-удаления], если реализация поддерживает расширения {{jsxref("Object.defineGetter", "__defineGetter__")}} и {{jsxref("Object.defineSetter", "__defineSetter__")}}.)</li> + <li>Частичная реализация создаёт функции, имеющие свойство <code>prototype</code>. (Правильная привязанная функция его не имеет.)</li> + <li>Частичная реализация создаёт привязанные функции, чьё свойство {{jsxref("Function.length", "length")}} не соответствует с определением в ECMA-262; оно равно 0, в то время, как полная реализация, в зависимости от значения свойства <code>length</code> целевой функции и количества предопределённых аргументов, может вернуть значение, отличное от нуля.</li> +</ul> + +<p>Если вы решили использовать частичную реализацию, <strong>не рассчитывайте на корректную работу в тех случаях, когда реализация отклоняется от спецификации ECMA-262 5-го издания!</strong> Однако, в определённых случаях (и, возможно, с дополнительными модификациями для отдельных нужд), применение данной частичной реализации может быть вполне оправданным до тех пор, пока <code>bind()</code> не станет широко реализован в соответствии со спецификацией.</p> + +<h2 id="Specifications" name="Specifications">Спецификации</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Спецификация</th> + <th scope="col">Статус</th> + <th scope="col">Комментарии</th> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.3.4.5', 'Function.prototype.bind')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Изначальное определение. Реализована в JavaScript 1.8.5.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-function.prototype.bind', 'Function.prototype.bind')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Возможность</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Базовая поддержка</td> + <td>{{CompatChrome("7")}}</td> + <td>{{CompatGeckoDesktop("2")}}</td> + <td>{{CompatIE("9")}}</td> + <td>{{CompatOpera("11.60")}}</td> + <td>{{CompatSafari("5.1.4")}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Возможность</th> + <th>Android</th> + <th>Chrome для Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Базовая поддержка</td> + <td>{{CompatAndroid("4.0")}}</td> + <td>{{CompatChrome("0.16")}}</td> + <td>{{CompatGeckoMobile("2")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatOperaMobile("11.50")}}</td> + <td>{{CompatSafari("6.0")}}</td> + </tr> + </tbody> +</table> +</div> + +<p>На основе <a href="http://kangax.github.com/es5-compat-table/">таблицы совместимости Kangax</a>.</p> + +<h2 id="See_also" name="See_also">Смотрите также</h2> + +<ul> + <li>{{jsxref("Function.prototype.apply()")}}</li> + <li>{{jsxref("Function.prototype.call()")}}</li> + <li>{{jsxref("Functions_and_function_scope", "Функции и их область видимости", "", 1)}}</li> +</ul> diff --git a/files/ru/web/javascript/reference/global_objects/function/call/index.html b/files/ru/web/javascript/reference/global_objects/function/call/index.html new file mode 100644 index 0000000000..500c4af182 --- /dev/null +++ b/files/ru/web/javascript/reference/global_objects/function/call/index.html @@ -0,0 +1,175 @@ +--- +title: Function.prototype.call() +slug: Web/JavaScript/Reference/Global_Objects/Function/call +tags: + - Function + - JavaScript + - Method +translation_of: Web/JavaScript/Reference/Global_Objects/Function/call +--- +<div>{{JSRef("Global_Objects", "Function")}}</div> + +<h2 id="Summary" name="Summary">Сводка</h2> + +<p>Метод <code><strong>call()</strong></code> вызывает функцию с указанным значением <code>this</code> и индивидуально предоставленными аргументами.</p> + +<div class="note"> +<p><strong>Примечание:</strong> хотя синтаксис этой функции практически полностью идентичен функции {{jsxref("Function.prototype.apply", "apply()")}}, фундаментальное различие между ними заключается в том, что функция <code>call()</code> принимает <strong>список аргументов</strong>, в то время, как функция <code>apply()</code> <strong>- одиночный массив аргументов</strong>.</p> +</div> + +<h2 id="Syntax" name="Syntax">Синтаксис</h2> + +<pre class="syntaxbox"><code><var>fun</var>.call(<var>thisArg</var>[, <var>arg1</var>[, <var>arg2</var>[, ...]]])</code></pre> + +<h3 id="Parameters" name="Parameters">Параметры</h3> + +<dl> + <dt><code>thisArg</code></dt> + <dd>Значение <code>this</code>, предоставляемое для вызова функции <em><code>fun</code></em>. Обратите внимание, что <code>this</code> может не быть реальным значением, видимым этим методом: если метод является функцией в {{jsxref("Functions_and_function_scope/Strict_mode", "нестрогом режиме", "", 1)}}, значения {{jsxref("Global_Objects/null", "null")}} и {{jsxref("Global_Objects/undefined", "undefined")}} будут заменены глобальным объектом, а примитивные значения будут упакованы в объекты.</dd> + <dt><code>arg1, arg2, ...</code></dt> + <dd>Аргументы для объекта.</dd> +</dl> + +<h2 id="Description" name="Description">Описание</h2> + +<p>Вы можете присваивать различные объекты <code>this</code> при вызове существующей функции. <code>this</code> ссылается на текущий объект, вызвавший объект. С помощью <code>call</code> вы можете написать метод один раз, а затем наследовать его в других объектах, без необходимости переписывать метод для каждого нового объекта.</p> + +<h2 id="Examples" name="Examples">Примеры</h2> + +<h3 id="Example_Using_call_to_chain_constructors_for_an_object" name="Example:_Using_call_to_chain_constructors_for_an_object">Пример: использование <code>call</code> для связи конструкторов объекта в цепочку</h3> + +<p>Вы можете использовать метод <code>call</code> для объединения в цепочку {{jsxref("Operators/new", "конструкторов", "", 1)}} объекта, как в Java. В следующем примере для объекта продукта <code>Product</code> объявлен конструктор с двумя параметрами, названием <code>name</code> и ценой <code>price</code>. Продукт инициализирует свойства <code>name</code> и <code>price</code>, а специализированные функции определяют ещё категорию <code>category</code>.</p> + +<pre class="brush: js">function Product(name, price) { + this.name = name; + this.price = price; + + if (price < 0) { + throw RangeError('Нельзя создать продукт ' + + this.name + ' с отрицательной ценой'); + } +} + +function Food(name, price) { + Product.call(this, name, price); + this.category = 'еда'; +} + +Food.prototype = Object.create(Product.prototype); + +function Toy(name, price) { + Product.call(this, name, price); + this.category = 'игрушка'; +} + +Toy.prototype = Object.create(Product.prototype); + +var cheese = new Food('фета', 5); +var fun = new Toy('робот', 40); +</pre> + +<h3 id="Example_Using_call_to_invoke_an_anonymous_function" name="Example:_Using_call_to_invoke_an_anonymous_function">Пример: использование <code>call</code> для вызова анонимной функции</h3> + +<p>В этом чисто искусственном примере, мы создаём анонимную функцию и используем <code>call</code> для вызова её на каждом элементе массива. Главная задача анонимной функции здесь — добавить функцию печати в каждый объект, способную напечатать правильный индекс объекта в массиве. Передача объекта в качестве значения <code>this</code> не является острой необходимостью, но мы делаем это в целях объяснения.</p> + +<pre class="brush: js">var animals = [ + { species: 'Лев', name: 'Король' }, + { species: 'Кит', name: 'Фэйл' } +]; + +for (var i = 0; i < animals.length; i++) { + (function(i) { + this.print = function() { + console.log('#' + i + ' ' + this.species + + ': ' + this.name); + } + this.print(); + }).call(animals[i], i); +} +</pre> + +<h2 id="Specifications" name="Specifications">Спецификации</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Спецификация</th> + <th scope="col">Статус</th> + <th scope="col">Комментарии</th> + </tr> + <tr> + <td>ECMAScript 3-е издание.</td> + <td>Стандарт</td> + <td>Изначальное определение. Реализована в JavaScript 1.3.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.3.4.4', 'Function.prototype.call')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-function.prototype.call', 'Function.prototype.call')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Возможность</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Базовая поддержка</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Возможность</th> + <th>Android</th> + <th>Chrome для Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Базовая поддержка</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Смотрите также</h2> + +<ul> + <li>{{jsxref("Function.prototype.bind()")}}</li> + <li>{{jsxref("Function.prototype.apply()")}}</li> +</ul> diff --git a/files/ru/web/javascript/reference/global_objects/function/caller/index.html b/files/ru/web/javascript/reference/global_objects/function/caller/index.html new file mode 100644 index 0000000000..4055eaf092 --- /dev/null +++ b/files/ru/web/javascript/reference/global_objects/function/caller/index.html @@ -0,0 +1,131 @@ +--- +title: Function.caller +slug: Web/JavaScript/Reference/Global_Objects/Function/caller +tags: + - Function + - JavaScript + - Non-standard + - Property +translation_of: Web/JavaScript/Reference/Global_Objects/Function/caller +--- +<div>{{JSRef("Global_Objects", "Function")}} {{non-standard_header}}</div> + +<h2 id="Summary" name="Summary">Сводка</h2> + +<p>Свойство <code><strong><em>function</em>.caller</strong></code> возвращает функцию, которая вызвала указанную функцию.</p> + +<h2 id="Description" name="Description">Описание</h2> + +<p>Если функция <code>f</code> была вызвана из кода самого верхнего уровня, значение <code>f.caller</code> будет равно {{jsxref("Global_Objects/null", "null")}}, в противном случае значение будет равно функции, вызвавшей <code>f</code>.</p> + +<p>Это свойство пришло на замену удалённого свойства {{jsxref("Functions_and_function_scope/arguments/caller", "arguments.caller")}} объекта {{jsxref("Functions_and_function_scope/arguments", "arguments")}}.</p> + +<p>Специальное свойство <code>__caller__</code>, возвращающее объект активации вызывающей функции и, таким образом, позволяющее восстанавливать стек вызовов, было удалено по соображениям безопасности.</p> + +<h3 id="Notes" name="Notes">Примечания</h3> + +<p>Обратите внимание, что в случае рекурсии, вы не сможете воссоздать стек вызовов, используя это свойство. Пусть у нас есть функции:</p> + +<pre class="brush: js">function f(n) { g(n - 1); } +function g(n) { if (n > 0) { f(n); } else { stop(); } } +f(2); +</pre> + +<p>В момент вызова функции <code>stop()</code>, стек вызовов имеет следующий вид:</p> + +<pre class="eval">f(2) -> g(2) -> f(2) -> g(1) -> f(1) -> g(0) -> stop() +</pre> + +<p>Следующее условие верно:</p> + +<pre class="eval">stop.caller === g && f.caller === g && g.caller === f +</pre> + +<p>так что если вы попытаетесь оттрассировать стек в функции <code>stop()</code> подобным образом:</p> + +<pre class="brush: js">var f = stop; +var stack = 'Трассировка стека:'; +while (f) { + stack += '\n' + f.name; + f = f.caller; +} +</pre> + +<p>то этот цикл никогда не остановится.</p> + +<h2 id="Examples" name="Examples">Примеры</h2> + +<h3 id="Example:_Checking_the_value_of_a_function.27s_caller_property" name="Example:_Checking_the_value_of_a_function.27s_caller_property">Пример: проверка значения свойства <code>caller</code> функции</h3> + +<p>Следующий код проверяет значение свойства <code>caller</code> функции.</p> + +<pre class="brush: js">function myFunc() { + if (myFunc.caller == null) { + return 'Эта функция была вызвана из верхнего уровня!'; + } else { + return 'Эта функция была вызвана из ' + myFunc.caller; + } +} +</pre> + +<h2 id="Specifications" name="Specifications">Спецификации</h2> + +<p>Не является частью какой-либо спецификации. Реализована в JavaScript 1.5.</p> + +<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Возможность</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Базовая поддержка</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoDesktop("1.0")}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Возможность</th> + <th>Android</th> + <th>Chrome для Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Базовая поддержка</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoMobile("1.0")}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Смотрите также</h2> + +<ul> + <li>Ошибка реализации в SpiderMonkey: {{bug(65683)}}</li> +</ul> diff --git a/files/ru/web/javascript/reference/global_objects/function/displayname/index.html b/files/ru/web/javascript/reference/global_objects/function/displayname/index.html new file mode 100644 index 0000000000..11bae88221 --- /dev/null +++ b/files/ru/web/javascript/reference/global_objects/function/displayname/index.html @@ -0,0 +1,111 @@ +--- +title: Function.displayName +slug: Web/JavaScript/Reference/Global_Objects/Function/displayName +tags: + - Function + - JavaScript + - Non-standard + - Property +translation_of: Web/JavaScript/Reference/Global_Objects/Function/displayName +--- +<div> + {{JSRef("Global_Objects", "Function")}} {{Non-standard_header}}</div> +<h2 id="Summary" name="Summary">Сводка</h2> +<p>Свойство <code><strong><em>function</em>.displayName</strong></code> возвращает отображаемое имя функции.</p> +<h2 id="Description" name="Description">Описание</h2> +<p>Если оно определено, свойство <code>displayName</code> возвращает отображаемое имя функции:</p> +<pre class="brush: js">function doSomething() {} + +alert(doSomething.displayName); // "undefined" + +var popup = function(content) { alert(content); }; + +popup.displayName = 'Показать всплывающее окно'; + +alert(popup.displayName); // "Показать всплывающее окно" +</pre> +<p>Вы можете определить функцию с отображаемым именем в {{jsxref("Functions_and_function_scope", "выражении функции", "", 1)}}:</p> +<pre class="brush: js">var object = { + someMethod: function() {} +}; + +object.someMethod.displayName = 'someMethod'; + +alert(object.someMethod.displayName); // выведет "someMethod" + +try { someMethod } catch(e) { alert(e); } +// ReferenceError: someMethod is not defined +</pre> +<p>Вы можете динамически изменять свойство <code>displayName</code> функции:</p> +<pre class="brush: js">var object = { + // анонимная функция + someMethod: function(value) { + this.displayName = 'someMethod (' + value + ')'; + } +}; + +alert(object.someMethod.displayName); // "undefined" + +object.someMethod('123') +alert(object.someMethod.displayName); // "someMethod (123)" +</pre> +<h2 id="Examples" name="Examples">Примеры</h2> +<p>Обычно оно используется консолью и профилировщиком, как обёртка над {{jsxref("Function.name", "func.name")}} для отображения имени функции.</p> +<p>Введя следующий пример в консоль, вы должны увидеть что-то вроде "<code>function Моя функция()</code>":</p> +<pre class="brush: js">var a = function() {}; +a.displayName = 'Моя функция'; + +a +</pre> +<h2 id="Specifications" name="Specifications">Спецификации</h2> +<p>Не является частью какой-либо спецификации.</p> +<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2> +<div> + {{CompatibilityTable}}</div> +<div id="compat-desktop"> + <table class="compat-table"> + <tbody> + <tr> + <th>Возможность</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Базовая поддержка</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatGeckoDesktop(13)}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> + </table> +</div> +<div id="compat-mobile"> + <table class="compat-table"> + <tbody> + <tr> + <th>Возможность</th> + <th>Android</th> + <th>Chrome для Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Базовая поддержка</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> + </table> +</div> +<p> </p> diff --git a/files/ru/web/javascript/reference/global_objects/function/index.html b/files/ru/web/javascript/reference/global_objects/function/index.html new file mode 100644 index 0000000000..63d7e776c0 --- /dev/null +++ b/files/ru/web/javascript/reference/global_objects/function/index.html @@ -0,0 +1,200 @@ +--- +title: Function +slug: Web/JavaScript/Reference/Global_Objects/Function +tags: + - JavaScript + - Конструктор + - Функция +translation_of: Web/JavaScript/Reference/Global_Objects/Function +--- +<div>{{JSRef("Global_Objects", "Function")}}</div> + +<p>{{JSRef}}</p> + +<p><strong><code>Function</code> constructor</strong> создает новый объект <code>Function</code>. Вызов <code>constructor</code> создает функцию динамически, но страдает от проблем безопасности и аналогичных (но гораздо менее значительных) проблем производительности {{jsxref("eval")}}. Однако, в отличие от eval, конструктор функций создает функции, которые выполняются только в глобальной области..</p> + +<p>{{EmbedInteractiveExample("pages/js/function-constructor.html")}}</p> + +<div class="hidden"> +<p>Источник для этого интерактивного примера хранится в репозитории GitHub. Если вы хотите внести свой вклад в проект interactive examples, пожалуйста, клонируйте <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> and send us a pull request.</p> +</div> + +<p>Каждая функция JavaScript на самом деле является объектом функции. Это можно увидеть с помощью кода <code>(function(){}).constructor === Function</code> которая возвращает true.</p> + +<h2 id="Syntax" name="Syntax">Синтаксис</h2> + +<pre class="syntaxbox"><code>new Function([<var>arg1</var>[, <var>arg2</var>[, ...<var>argN</var>]],] <var>functionBody</var>)</code></pre> + +<h3 id="Parameters" name="Parameters">Параметры</h3> + +<dl> + <dt><code>arg1, arg2, ... arg<em>N</em></code></dt> + <dd>Имена, используемые функцией в качестве имён формальных аргументов. Каждое имя должно быть строкой, представляющий допустимый идентификатор JavaScript, либо списком таких строк, разделённых запятой; например "<code>x</code>", "<code>theValue</code>" или "<code>a,b</code>".</dd> + <dt><code>functionBody</code></dt> + <dd>Строка, содержащая инструкции JavaScript, составляющие определение функции.</dd> +</dl> + +<h2 id="Description" name="Description">Описание</h2> + +<p>Объекты <code>Function</code>, созданные констуктором <code>Function</code>, разбираются при создании функции. Это менее эффективно определения функции при помощи <a href="/ru/docs/Web/JavaScript/Reference/Operators/function">выражения <code>function</code></a> или <a href="/ru/docs/Web/JavaScript/Reference/Statements/function">инструкции <code>function</code></a> и вызова её внутри вашего кода, поскольку такие функции разбираются вместе с остальным кодом.</p> + +<p>Все аргументы, переданные в функцию, трактуются как имена идентификаторов параметров создаваемой функции, и имеют тот же порядок следования, что и при их передаче в конструктор функции.</p> + +<div class="note"> +<p><strong>Примечание:</strong> функции, созданные конструктором <code>Function</code>, не создают замыканий на их контексты создания; они всегда создаются в глобальной области видимости. При их вызове, они получат доступ только к своим локальным переменным и переменным из глобальной области видимости, но не к переменным в той области видимости, в которой вызывался конструктор <code>Function</code>. Это поведение отличается от поведения при использовании функции {{jsxref("Global_Objects/eval", "eval")}} с кодом создания функции.</p> +</div> + +<p>Вызов констуктора <code>Function</code> как функции (без использования оператора <code>new</code>) имеет тот же самый эффект, что и вызов его как констуктора.</p> + +<h2 id="Properties_and_Methods_of_Function" name="Properties_and_Methods_of_Function">Свойства и методы объекта <code>Function</code></h2> + +<p>Глобальный объект <code>Function</code> не имеет собственных методов или свойств, однако, поскольку он сам является функцией, он наследует некоторые методы и свойства через цепочку прототипов объекта {{jsxref("Function.prototype")}}.</p> + +<h2 id="Function_prototype_object" name="Function_prototype_object">Прототип объекта <code>Function</code></h2> + +<h3 id="Properties" name="Properties">Свойства</h3> + +<div>{{page('/ru/docs/Web/JavaScript/Reference/Global_Objects/Function/prototype', 'Properties')}}</div> + +<h3 id="Methods" name="Methods">Методы</h3> + +<div>{{page('/ru/docs/Web/JavaScript/Reference/Global_Objects/Function/prototype', 'Methods')}}</div> + +<h2 id="Function_instances" name="Function_instances">Экземпляры объекта <code>Function</code></h2> + +<p>Экземпляры объекта <code>Function</code> наследуют методы и свойства из объекта {{jsxref("Function.prototype")}}. Как и со всеми другими конструкторами, вы можете изменить объект прототипа констуктора для применения изменений ко всем экземплярам объекта <code>Function</code>.</p> + +<h2 id="Examples" name="Examples">Примеры</h2> + +<h3 id="Example_Specifying_arguments_with_the_Function_constructor" name="Example:_Specifying_arguments_with_the_Function_constructor">Пример: указание аргументов в конструкторе <code>Function</code></h3> + +<p>Следующий код создаёт объект <code>Function</code>, который принимает два аргумента.</p> + +<pre class="brush: js">// Пример может быть запущен непосредственно в вашей консоли JavaScript + +// Создаём функцию, принимающую два аргумента, и возвращающую их сумму +var adder = new Function('a', 'b', 'return a + b'); + +// Вызываем функцию +adder(2, 6); +// > 8 +</pre> + +<p>Аргуметы "<code>a</code>" и "<code>b</code>" являются именами формальных аргументов, которые используются в теле функции, "<code>return a + b</code>".</p> + +<h3 id="Example_A_recursive_shortcut_to_massively_modify_the_DOM" name="Example:_A_recursive_shortcut_to_massively_modify_the_DOM">Пример: рекурсивное сокращение для массового изменения DOM</h3> + +<p>Создание функции через конструктор <code>Function</code> - это один из способов динамического создания из функции неизвестного количества новых объектов с некоторым выполняемым кодом в глобальной области видимости. Следующий пример (a рекурсивное сокращение для массового изменения DOM) был бы невозможен без вызова конструктора <code>Function</code> для каждого нового запроса, если вы хотите избежать использования замыканий.</p> + +<pre class="brush: html"><!doctype html> +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /> +<title>Пример MDN - рекурсивное сокращение для массового изменения DOM</title> +<script type="text/javascript"> +var domQuery = (function() { + var aDOMFunc = [ + Element.prototype.removeAttribute, + Element.prototype.setAttribute, + CSSStyleDeclaration.prototype.removeProperty, + CSSStyleDeclaration.prototype.setProperty + ]; + + function setSomething(bStyle, sProp, sVal) { + var bSet = Boolean(sVal), fAction = aDOMFunc[bSet | bStyle << 1], + aArgs = Array.prototype.slice.call(arguments, 1, bSet ? 3 : 2), + aNodeList = bStyle ? this.cssNodes : this.nodes; + + if (bSet && bStyle) { aArgs.push(''); } + for ( + var nItem = 0, nLen = this.nodes.length; + nItem < nLen; + fAction.apply(aNodeList[nItem++], aArgs) + ); + this.follow = setSomething.caller; + return this; + } + + function setStyles(sProp, sVal) { return setSomething.call(this, true, sProp, sVal); } + function setAttribs(sProp, sVal) { return setSomething.call(this, false, sProp, sVal); } + function getSelectors() { return this.selectors; }; + function getNodes() { return this.nodes; }; + + return (function(sSelectors) { + var oQuery = new Function('return arguments.callee.follow.apply(arguments.callee, arguments);'); + oQuery.selectors = sSelectors; + oQuery.nodes = document.querySelectorAll(sSelectors); + oQuery.cssNodes = Array.prototype.map.call(oQuery.nodes, function(oInlineCSS) { return oInlineCSS.style; }); + oQuery.attributes = setAttribs; + oQuery.inlineStyle = setStyles; + oQuery.follow = getNodes; + oQuery.toString = getSelectors; + oQuery.valueOf = getNodes; + return oQuery; + }); +})(); +</script> +</head> + +<body> + +<div class="testClass">Lorem ipsum</div> +<p>Некоторый текст</p> +<div class="testClass">dolor sit amet</div> + +<script type="text/javascript"> +domQuery('.testClass') + .attributes('lang', 'en')('title', 'Risus abundat in ore stultorum') + .inlineStyle('background-color', 'black')('color', 'white')('width', '100px')('height', '50px'); +</script> +</body> + +</html> +</pre> + +<h2 id="Specifications" name="Specifications">Спецификации</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Спецификация</th> + <th scope="col">Статус</th> + <th scope="col">Комментарии</th> + </tr> + <tr> + <td>ECMAScript 1-е издание.</td> + <td>Стандарт</td> + <td>Изначальное определение. Реализована в JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.3', 'Function')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-function-objects', 'Function')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2> + +<div class="hidden"> +<p>The compatibility table on this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> +</div> + +<p>{{Compat("javascript.builtins.Function")}}</p> + +<h2 id="See_also" name="See_also">Смотрите также</h2> + +<ul> + <li>{{jsxref("Functions_and_function_scope", "Функции и их область видимости", "", 1)}}</li> + <li>{{jsxref("Function")}}</li> + <li>{{jsxref("Statements/function", "инструкция function", "", 1)}}</li> + <li>{{jsxref("Operators/function", "выражение function", "", 1)}}</li> + <li>{{jsxref("Statements/function*", "инструкция function*", "", 1)}}</li> + <li>{{jsxref("Operators/function*", "выражение function*", "", 1)}}</li> + <li>{{jsxref("GeneratorFunction")}}</li> +</ul> diff --git a/files/ru/web/javascript/reference/global_objects/function/isgenerator/index.html b/files/ru/web/javascript/reference/global_objects/function/isgenerator/index.html new file mode 100644 index 0000000000..e3a972e9e2 --- /dev/null +++ b/files/ru/web/javascript/reference/global_objects/function/isgenerator/index.html @@ -0,0 +1,83 @@ +--- +title: Function.prototype.isGenerator() +slug: Web/JavaScript/Reference/Global_Objects/Function/isGenerator +tags: + - Function + - JavaScript + - Method + - Non-standard +translation_of: Archive/Web/JavaScript/Function.isGenerator +--- +<div> + {{JSRef("Global_Objects", "Function")}} {{non-standard_header}}</div> +<h2 id="Summary" name="Summary">Сводка</h2> +<p>Метод <code><strong>isGenerator()</strong></code> определяет, является ли функция <a href="/ru/docs/Web/JavaScript/Guide/Iterators_and_Generators#Generators.3A_a_better_way_to_build_Iterators">генератором</a>.</p> +<h2 id="Syntax" name="Syntax">Синтаксис</h2> +<pre class="syntaxbox"><code><var>fun</var>.isGenerator()</code></pre> +<h2 id="Description" name="Description">Описание</h2> +<p>Метод <code>isGenerator()</code> определяет, является ли функция <em><code>fun</code></em> <a href="/ru/docs/Web/JavaScript/Guide/Iterators_and_Generators#Generators.3A_a_better_way_to_build_Iterators">генератором</a>. Он является частью раннего предложения Harmony, но не был включён в спецификацию ECMAScript 6.</p> +<h2 id="Examples" name="Examples">Примеры</h2> +<pre class="brush: js">function f() {} + +function g() { + yield 42; +} + +console.log('f.isGenerator() = ' + f.isGenerator()); // f.isGenerator() = false +console.log('g.isGenerator() = ' + g.isGenerator()); // g.isGenerator() = true +</pre> +<h2 id="Specifications" name="Specifications">Спецификации</h2> +<p>Не является частью какой-либо спецификации. Реализована в JavaScript 1.8.6.</p> +<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2> +<div> + {{CompatibilityTable}}</div> +<div id="compat-desktop"> + <table class="compat-table"> + <tbody> + <tr> + <th>Возможность</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Базовая поддержка</td> + <td>{{CompatNo}}</td> + <td>{{CompatGeckoDesktop("5.0")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> + </table> +</div> +<div id="compat-mobile"> + <table class="compat-table"> + <tbody> + <tr> + <th>Возможность</th> + <th>Android</th> + <th>Chrome для Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Базовая поддержка</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatGeckoMobile("5.0")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> + </table> +</div> +<h2 id="See_also" name="See_also">Смотрите также</h2> +<ul> + <li><a href="/ru/docs/Web/JavaScript/Guide/Iterators_and_Generators">Итераторы и генераторы</a></li> +</ul> diff --git a/files/ru/web/javascript/reference/global_objects/function/length/index.html b/files/ru/web/javascript/reference/global_objects/function/length/index.html new file mode 100644 index 0000000000..e65e361f17 --- /dev/null +++ b/files/ru/web/javascript/reference/global_objects/function/length/index.html @@ -0,0 +1,145 @@ +--- +title: Function.length +slug: Web/JavaScript/Reference/Global_Objects/Function/length +tags: + - Function + - JavaScript + - Property + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Function/length +--- +<div>{{JSRef("Global_Objects", "Function")}}</div> + +<h2 id="Summary" name="Summary">Сводка</h2> +<p>Свойство <code><strong>length</strong></code> определяет количество аргументов, ожидаемых функцией.</p> + +<div>{{js_property_attributes(0, 0, 1)}}</div> + +<h2 id="Description" name="Description">Описание</h2> +<p>Свойство <code>length</code> является свойством объекта функции и указывает, сколько аргументов ожидает функция, то есть, количество формальных параметров. Это количество не включает {{jsxref("rest_parameters", "остаточные параметры", "", 1)}}. В отличие от него, свойство {{jsxref("Functions_and_function_scope/arguments/length", "arguments.length")}} является локальным для функции и предоставляет количество аргументов, реально переданных в функцию.</p> + +<h3 id="Data_property_of_the_Function_constructor" name="Data_property_of_the_Function_constructor">Свойство данных конструктора <code>Function</code></h3> +<p>Конструктор {{jsxref("Global_Objects/Function", "Function")}} сам является объектом {{jsxref("Global_Objects/Function", "Function")}}. Его свойство данных <code>length</code> имеет значение 1. Атрибуты свойства: записываемое: <code>false</code>, перечисляемое: <code>false</code>, настраиваемое: <code>true</code>.</p> + +<h3 id="Property_of_the_Function_prototype_object" name="Property_of_the_Function_prototype_object">Свойство объекта прототипа <code>Function</code></h3> +<p>Свойство <code>length</code> объекта прототипа {{jsxref("Global_Objects/Function", "Function")}} имеет значение 0.</p> + +<h2 id="Examples" name="Examples">Примеры</h2> +<pre class="brush: js">console.log(Function.length); /* 1 */ + +console.log((function() {}).length); /* 0 */ +console.log((function(a) {}).length); /* 1 */ +console.log((function(a, b) {}).length); /* 2 и так далее */ +console.log((function(...args) {}).length); /* 0, остаточные параметры не считаются */ +</pre> + +<h2 id="Specifications" name="Specifications">Спецификации</h2> +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Спецификация</th> + <th scope="col">Статус</th> + <th scope="col">Комментарии</th> + </tr> + <tr> + <td>ECMAScript 1-е издание.</td> + <td>Стандарт</td> + <td>Изначальное определение. Реализована в JavaScript 1.1.</td> + </tr> + <tr> + <td> + Свойство <code>length</code> конструктора {{jsxref("Global_Objects/Function", "Function")}}:<br> + {{SpecName('ES5.1', '#sec-15.3.3.2', 'Function.length')}}<br> + Свойство <code>length</code> объекта прототипа {{jsxref("Global_Objects/Function", "Function")}}:<br> + {{SpecName('ES5.1', '#sec-properties-of-the-function-prototype-object', 'Function.length')}}<br> + Свойство <code>length</code> экземпляров объекта {{jsxref("Global_Objects/Function", "Function")}}:<br> + {{SpecName('ES5.1', '#sec-15.3.5.1', 'Function.length')}} + </td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td> + Свойство <code>length</code> конструктора {{jsxref("Global_Objects/Function", "Function")}}:<br> + {{SpecName('ES6', '#sec-function.length', 'Function.length')}}<br> + Свойство <code>length</code> объекта прототипа {{jsxref("Global_Objects/Function", "Function")}}:<br> + {{SpecName('ES6', '#sec-15.3.4', 'Function.length')}}<br> + Свойство <code>length</code> экземпляров объекта {{jsxref("Global_Objects/Function", "Function")}}:<br> + {{SpecName('ES6', '#sec-function-instances-length', 'Function.length')}}<br> + </td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2> +<div>{{CompatibilityTable}}</div> +<div id="compat-desktop"> + <table class="compat-table"> + <tbody> + <tr> + <th>Возможность</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Базовая поддержка</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + <tr> + <td>Поддержка настраиваемости</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatGeckoDesktop(37)}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> + </table> +</div> +<div id="compat-mobile"> + <table class="compat-table"> + <tbody> + <tr> + <th>Возможность</th> + <th>Android</th> + <th>Chrome для Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Базовая поддержка</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + <tr> + <td>Поддержка настраиваемости</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatGeckoMobile(37)}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> + </table> +</div> + +<h2 id="See_also" name="See_also">Смотрите также</h2> +<ul> + <li>{{jsxref("Global_Objects/Function", "Function")}}</li> +</ul> diff --git a/files/ru/web/javascript/reference/global_objects/function/name/index.html b/files/ru/web/javascript/reference/global_objects/function/name/index.html new file mode 100644 index 0000000000..212b9cb735 --- /dev/null +++ b/files/ru/web/javascript/reference/global_objects/function/name/index.html @@ -0,0 +1,219 @@ +--- +title: Function.name +slug: Web/JavaScript/Reference/Global_Objects/Function/name +tags: + - ECMAScript6 + - Function + - JavaScript + - Property + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Function/name +--- +<p>{{JSRef}}</p> + +<p>Read-only свойство <code><strong>name</strong></code> глобального объекта {{jsxref("Function")}} и его <a href="/ru/docs/Web/JavaScript/Reference/Global_Objects/Function#Function_instances">экзепляров</a> содержит название функции созданное во время определения функции или присваивания ссылки на функцию переменной, свойству, аргументу и т. п. Для анонимных функций это свойство может иметь значение <code>"anonymous"</code> или пустую строку <code>""</code>.</p> + +<p>{{EmbedInteractiveExample("pages/js/function-name.html")}}</p> + +<p>Интерактивные примеры размещены в GitHub репозитории. Если вы хотите добавить свои примеры, то клонируйте <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> и пришлите пулл реквест.</p> + +<p>{{js_property_attributes(0,0,1)}}<br> + </p> + +<div class="blockIndicator note"> +<p>Заметьте, что в нестандартном, pre-ES2015 релизе <code>configurable</code> свойство было <code>false</code></p> +</div> + +<h2 id="Summary" name="Summary">Примеры</h2> + +<h3 id="Имя_объявленной_функции">Имя объявленной функции</h3> + +<p>Свойство <code>name</code> возвращает имя функции, либо пустую строку для анонимных функций:</p> + +<pre class="brush: js">function doSomething() {} + +alert(doSomething.name); // выведет "doSomething" +</pre> + +<h3 id="Имя_функции-конструктора">Имя функции-конструктора</h3> + +<p>Функции, созданные синтаксисом <code>new Function(...)</code> или просто <code>Function(...)</code> создают {{jsxref("Function")}} и имеют name "anonymous":</p> + +<pre class="brush: js"><code>(new Function).name; // "anonymous"</code> +</pre> + +<h3 id="Предполагаемые_имена_функций">Предполагаемые имена функций</h3> + +<p>Переменные и методы могут предположить название анонимной функции из ее синтаксической позиции (new in ECMAScript 2015).</p> + +<pre class="brush: js">var f = function() {}; +var object = { + someMethod: function() {} +}; + +<code>console.log(f.name); // "f" +console.log(object.someMethod.name); // "someMethod"</code></pre> + +<p>Вы можете определить функцию с именем в {{jsxref("Operators/Function", "function expression", "", 1)}}:</p> + +<pre class="brush: js">var object = { + someMethod: function object_someMethod() {} +}; +console.log(object.someMethod.name); // выведет "object_someMethod" + +try { object_someMethod } catch(e) { console.log(e); } +// ReferenceError: object_someMethod is not defined +</pre> + +<p>Вы не можете изменить имя функции, это свойство только для чтения:</p> + +<pre class="brush: js">var object = { + // анонимная функция + someMethod: function() {} +}; + +object.someMethod.name = 'otherMethod'; +alert(object.someMethod.name); //someMethod + +</pre> + +<p>Для изменения name можно использовать {{jsxref("Object.defineProperty()")}}.</p> + +<h3 id="Сокращенные_имена_методов">Сокращенные имена методов</h3> + +<pre class="brush: js"><code>var o = { + foo(){} +}; +o.foo.name; // "foo";</code></pre> + +<h3 id="Имена_функций_после_байндинга">Имена функций после байндинга</h3> + +<p>{{jsxref("Function.bind()")}} производит функцию, получающую имя "bound и название самой функции.</p> + +<pre class="brush: js"><code>function foo() {}; +foo.bind({}).name; // "bound foo"</code> +</pre> + +<h3 id="Имена_функций_для_getters_и_setters">Имена функций для getters и setters</h3> + +<p>Когда используются <code><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/get">get</a></code> и <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/set">set</a>, "get" и "set" появятся в имени функции.</p> + +<pre><code>let o = { + get foo(){}, + set foo(x){} +}; + +var descriptor = Object.getOwnPropertyDescriptor(o, "foo"); +descriptor.get.name; // "get foo" +descriptor.set.name; // "set foo";</code></pre> + +<h3 id="Имена_функций-классов">Имена функций-классов</h3> + +<p>Можно использовать <code>obj.constructor.name</code> чтобы проверить "class" объекта (читайте предупреждение ниже):</p> + +<pre><code>function Foo() {} // ES2015 Syntax: class Foo {} + +var fooInstance = new Foo(); +console.log(fooInstance.constructor.name); // logs "Foo"</code> +</pre> + +<div class="blockIndicator warning"> +<p><strong>Warning:</strong> Интерпретатор объявит встроенное <code>Function.name</code> свойство только если функция не имеет своего собственного свойства <em>name</em> (см. <a href="https://www.ecma-international.org/ecma-262/6.0/#sec-setfunctionname">9.2.11 of the ECMAScript2015 Language Specification</a>). Однако, в ES2015 статичные методы перезаписывают OwnProperty конструкторов класса-функции (ECMAScript2015, <a href="https://www.ecma-international.org/ecma-262/6.0/#sec-runtime-semantics-classdefinitionevaluation">14.5.14.21.b</a> + <a href="https://www.ecma-international.org/ecma-262/6.0/#sec-object-initializer-runtime-semantics-propertydefinitionevaluation">12.2.6.9</a>).</p> +</div> + +<p>Таким образом, нельзя получить доступ к <code>name</code> любого класса со статичным свойством <code>name():</code></p> + +<pre class="brush: js"><code>class Foo { + constructor() {} + static name() {} +} +</code></pre> + +<p>Со <code>static name()</code> методом <code>Foo.name</code> больше не содержит название класса, но отсылает к функции <code>name()</code>. Приведенное выше определение класса в ES2015 будет вести себя в Chrome и Firefx как в ES5:</p> + +<pre><code>function Foo() {} +Object.defineProperty(Foo, 'name', { writable: true }); +Foo.name = function() {};</code></pre> + +<p>Пытаясь получить доступ к <code>fooInstance</code> с помощью <code>fooInstance.constructor.name</code> не даст название класса, но выведет метод <code>name()</code>. Пример:</p> + +<pre><code>let fooInstance = new Foo(); +console.log(fooInstance.constructor.name); // logs function name()</code></pre> + +<p>Из ES5 syntax примера также видно, что в Chrome или Firefox статичное определение <code>Foo.name</code> становится <em>записываемым (writable)</em>. Встроенное определение в отсутствии кастомного статичного метода<em>доступно только для чтения</em>:</p> + +<pre><code>Foo.name = 'Hello'; +console.log(Foo.name); // logs "Hello" if class Foo has a static name() property but "Foo" if not.</code></pre> + +<p>Следовательно не ожидайте, что <code>Function.name</code> свойство будет всегда содержать имя класса.</p> + +<h3 id="Имена_функций-символов">Имена функций-символов</h3> + +<p>Если у {{jsxref("Symbol")}} объявляется имя, то название метода - это имя квадратных скобках.</p> + +<pre class="brush: js"><code>let sym1 = Symbol("foo"); +let sym2 = Symbol(); +let o = { + [sym1]: function(){}, + [sym2]: function(){} +}; + +o[sym1].name; // "[foo]" +o[sym2].name; // ""</code> +</pre> + +<h2 id="JavaScript_минифицированный">JavaScript минифицированный</h2> + +<div class="blockIndicator warning"> +<p><strong>Warning:</strong> Будьте осторожны, используя <code>Function.name</code> и изменения source кода с помощью JavaScript compressors (minifiers) или обфускаторов. Эти инструменты часто используются, как встроенные в JavaScript build pipeline, чтобы сократить размер билда перед деплоем в production. Такие трансформации часто изменяют имена функций.</p> +</div> + +<p>Такой source code:</p> + +<pre><code>function Foo() {}; +let foo = new Foo(); + +if (foo.constructor.name === 'Foo') { + console.log("'foo' is an instance of 'Foo'"); +} else { + console.log('Oops!'); +}</code></pre> + +<p>может быть сжат в:</p> + +<pre><code>function a() {}; +let b = new a(); +if (b.constructor.name === 'Foo') { + console.log("'foo' is an instance of 'Foo'"); +} else { + console.log('Oops!'); +}</code></pre> + +<p>В несжатой версии код выполняется ожидаемо <code>"'foo' is an instance of 'Foo'"</code>. В то время, как в сжатой версии он ведет себя иначе. Если вы полагаетесь на <code>Function.name</code>, как в примере, то убедитесь, что pipeline не меняет код или не ожидайте от функции определенного имени.</p> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col"> + <p>Спецификация</p> + </th> + <th scope="col">Статус</th> + <th scope="col">Комментарии</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-name', 'name')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Изначальное определение.</td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2> + +<div class="hidden"> +<p>The compatibility table on this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p> +</div> + +<p>{{Compat("javascript.builtins.Function.name")}}</p> + +<div id="compat-mobile"></div> diff --git a/files/ru/web/javascript/reference/global_objects/function/prototype/index.html b/files/ru/web/javascript/reference/global_objects/function/prototype/index.html new file mode 100644 index 0000000000..66a3ecc18e --- /dev/null +++ b/files/ru/web/javascript/reference/global_objects/function/prototype/index.html @@ -0,0 +1,151 @@ +--- +title: Function.prototype +slug: Web/JavaScript/Reference/Global_Objects/Function/prototype +tags: + - Function + - JavaScript + - Property + - Prototype + - Reference + - Référence(2) +translation_of: Web/JavaScript/Reference/Global_Objects/Function +--- +<div>{{JSRef("Global_Objects", "Function")}}</div> + +<h2 id="Summary" name="Summary">Сводка</h2> + +<p>Свойство <code><strong>Function.prototype</strong></code> представляет прототип объекта {{jsxref("Global_Objects/Function", "Function")}}.</p> + +<h2 id="Description" name="Description">Описание</h2> + +<p>Объекты {{jsxref("Global_Objects/Function", "Function")}} наследуются от <code>Function.prototype</code>. Объект <code>Function.prototype</code> не может быть изменён.</p> + +<h2 id="Properties" name="Properties">Свойства</h2> + +<dl> + <dt>{{jsxref("Function.arguments")}} {{deprecated_inline}}</dt> + <dd>Массив, соответствующий аргументам, переданным в функцию. Это устаревшее свойство {{jsxref("Global_Objects/Function", "Function")}}, используйте вместо него объект {{jsxref("Functions_and_function_scope/arguments", "arguments")}}, доступный внутри функции.</dd> + <dt><s class="obsoleteElement">{{jsxref("Function.arity")}} {{obsolete_inline}}</s></dt> + <dd><s class="obsoleteElement">Использовалось для определения количества аргументов, ожидаемых функцией, но было удалено. Вместо него используйте свойство {{jsxref("Function.length", "length")}}.</s></dd> + <dt>{{jsxref("Function.caller")}} {{non-standard_inline}}</dt> + <dd>Определяет функцию, вызвавшую текущую выполняющуюся функцию.</dd> + <dt>{{jsxref("Function.length")}}</dt> + <dd>Определяет количество аргументов, ожидаемых функцией.</dd> + <dt>{{jsxref("Function.name")}} {{non-standard_inline}}</dt> + <dd>Имя функции.</dd> + <dt>{{jsxref("Function.displayName")}} {{non-standard_inline}}</dt> + <dd>Отображаемое имя функции.</dd> + <dt><code>Function.prototype.constructor</code></dt> + <dd>Определяет функцию, создающую прототип объекта. Смотрите документацию по {{jsxref("Object.prototype.constructor")}}.</dd> +</dl> + +<h2 id="Methods" name="Methods">Методы</h2> + +<dl> + <dt>{{jsxref("Function.prototype.apply()")}}</dt> + <dd>Вызывает функцию и устанавливает <strong><code>this </code></strong>в контекст предоставленного значения; аргументы передаются объектом {{jsxref("Global_Objects/Array", "Array")}}.</dd> + <dt>{{jsxref("Function.prototype.bind()")}}</dt> + <dd>Создаёт новую функцию, которая, при вызове, самостоятельно вызывает эту функцию в контексте предоставленного значения, с данной последовательностью аргументов, предшествующих любым аргументам, переданным в новую функцию при её вызове. Устанавливает <strong><code>this </code></strong>в контекст предоставленного значения.</dd> + <dt>{{jsxref("Function.prototype.call()")}}</dt> + <dd>Вызывает (выполняет) функцию и устанавливает <strong><code>this </code></strong>в контекст предоставленного значения; аргументы передаются как есть.</dd> + <dt>{{jsxref("Function.prototype.isGenerator()")}} {{non-standard_inline}}</dt> + <dd>Возвращает <code>true</code>, если функция является <a href="/ru/docs/Web/JavaScript/Guide/Iterators_and_Generators">генератором</a>; в противном случае возвращает <code>false</code>.</dd> + <dt>{{jsxref("Function.prototype.toSource()")}} {{non-standard_inline}}</dt> + <dd>Возвращает строку, представляющую исходный код функции. Переопределяет метод {{jsxref("Object.prototype.toSource")}}.</dd> + <dt>{{jsxref("Function.prototype.toString()")}}</dt> + <dd>Возвращает строку, представляющую исходный код функции. Переопределяет метод {{jsxref("Object.prototype.toString")}}.</dd> +</dl> + +<h2 id="Specifications" name="Specifications">Спецификации</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Спецификация</th> + <th scope="col">Статус</th> + <th scope="col">Комментарии</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Изначальное определение. Реализована в JavaScript 1.1.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.3.3.1', 'Function.prototype')}}<br> + Для экземпляров объекта {{jsxref("Global_Objects/Function", "Function")}}:<br> + {{SpecName('ES5.1', '#sec-15.3.5.2', 'Function.prototype')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-function.prototype', 'Function.prototype')}}<br> + Для экземпляров объекта {{jsxref("Global_Objects/Function", "Function")}}:<br> + {{SpecName('ES6', '#sec-function-instances-prototype', 'Function.prototype')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-function-instances-prototype', 'Function.prototype')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Возможность</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Базовая поддержка</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Возможность</th> + <th>Android</th> + <th>Chrome для Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Базовая поддержка</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Смотрите также</h2> + +<ul> + <li>{{jsxref("Global_Objects/Function", "Function")}}</li> +</ul> diff --git a/files/ru/web/javascript/reference/global_objects/function/tosource/index.html b/files/ru/web/javascript/reference/global_objects/function/tosource/index.html new file mode 100644 index 0000000000..335967947b --- /dev/null +++ b/files/ru/web/javascript/reference/global_objects/function/tosource/index.html @@ -0,0 +1,87 @@ +--- +title: Function.prototype.toSource() +slug: Web/JavaScript/Reference/Global_Objects/Function/toSource +tags: + - Function + - JavaScript + - Method + - Non-standard +translation_of: Web/JavaScript/Reference/Global_Objects/Function/toSource +--- +<div> + {{JSRef("Global_Objects", "Function")}} {{non-standard_header}}</div> +<h2 id="Summary" name="Summary">Сводка</h2> +<p>Метод <code><strong>toSource()</strong></code> возвращает строку, представляющую исходный код объекта.</p> +<h2 id="Syntax" name="Syntax">Синтаксис</h2> +<pre class="syntaxbox"><code><var>function</var>.toSource(); +Function.toSource(); +</code></pre> +<h3 id="Parameters" name="Parameters">Параметры</h3> +<p>Нет.</p> +<h2 id="Description" name="Description">Описание</h2> +<p>Метод <code>toSource</code> возвращает следующие значения:</p> +<ul> + <li>Для встроенного объекта {{jsxref("Global_Objects/Function", "Function")}} метод <code>toSource</code> возвращает следующую строку, указывающую, что исходный код недоступен: + <pre class="brush: js">function Function() { + [native code] +} +</pre> + </li> + <li>Для пользовательских функций, метод <code>toSource</code> возвращает исходный код JavaScript, определяющий объект как строку.</li> +</ul> +<p>Этот метод обычно вызывается внутренними механизмаим движка JavaScript, а не явно в коде. Вы можете вызвать <code>toSource</code> во время отладки для изучения содержимого объекта.</p> +<h2 id="Specifications" name="Specifications">Спецификации</h2> +<p>Не является частью какого-либо стандарта. Реализована в JavaScript 1.3.</p> +<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2> +<div> + {{CompatibilityTable}}</div> +<div id="compat-desktop"> + <table class="compat-table"> + <tbody> + <tr> + <th>Возможность</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Базовая поддержка</td> + <td>{{CompatNo}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> + </table> +</div> +<div id="compat-mobile"> + <table class="compat-table"> + <tbody> + <tr> + <th>Возможность</th> + <th>Android</th> + <th>Chrome для Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Базовая поддержка</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> + </table> +</div> +<h2 id="See_also" name="See_also">Смотрите также</h2> +<ul> + <li>{{jsxref("Object.prototype.toSource()")}}</li> +</ul> diff --git a/files/ru/web/javascript/reference/global_objects/function/tostring/index.html b/files/ru/web/javascript/reference/global_objects/function/tostring/index.html new file mode 100644 index 0000000000..70b6522ebe --- /dev/null +++ b/files/ru/web/javascript/reference/global_objects/function/tostring/index.html @@ -0,0 +1,110 @@ +--- +title: Function.prototype.toString() +slug: Web/JavaScript/Reference/Global_Objects/Function/toString +tags: + - Function + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Function/toString +--- +<div>{{JSRef("Global_Objects", "Function")}}</div> + +<h2 id="Summary" name="Summary">Сводка</h2> +<p>Метод <code><strong>toString()</strong></code> возвращает строку, представляющую исходный код функции.</p> + +<h2 id="Syntax" name="Syntax">Синтаксис</h2> +<pre class="syntaxbox"><code><var>function</var>.toString(indentation)</code></pre> + +<h3 id="Parameters" name="Parameters">Параметры</h3> +<dl> + <dt><code>indentation</code> {{non-standard_inline}} {{obsolete_inline(17)}}</dt> + <dd>Количество пробелов для отступов в строковом представлении исходного кода. Если параметр меньше или равен <code>-1</code>, большинство ненужных пробелов будет удалено.</dd> +</dl> + +<h2 id="Description" name="Description">Описание</h2> +<p>Объект {{jsxref("Global_Objects/Function", "Function")}} переопределяет метод {{jsxref("Object.prototype.toString", "toString")}}, унаследованный из объекта {{jsxref("Global_Objects/Object", "Object")}}; он не наследует метод {{jsxref("Object.prototype.toString")}}. Для объектов {{jsxref("Global_Objects/Function", "Function")}} метод <code>toString</code> возвращает строку, представляющую объект в форме объявления функции. То есть, метод <code>toString</code> декомпилирует функцию и возвращает строку, включающую ключевое слово <code>function</code>, список аргументов, фигурные скобки и исходный код тела функции.</p> +<p>JavaScript вызывает метод <code>toString</code> автоматически в случае, когда объект {{jsxref("Global_Objects/Function", "Function")}} представляется в качестве текстового значения, то есть, когда функция соединяется со строкой.</p> + +<h2 id="Specifications" name="Specifications">Спецификации</h2> +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Спецификация</th> + <th scope="col">Статус</th> + <th scope="col">Комментарии</th> + </tr> + <tr> + <td>ECMAScript 1-е издание.</td> + <td>Стандарт</td> + <td>Изначальное определение. Реализована в JavaScript 1.1.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.3.4.2', 'Function.prototype.toString')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-function.prototype.tostring', 'Function.prototype.toString')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility" name="Browser_compatibility">Совместимость с браузерами</h2> +<div>{{CompatibilityTable}}</div> +<div id="compat-desktop"> + <table class="compat-table"> + <tbody> + <tr> + <th>Возможность</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Базовая поддержка</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> + </table> +</div> +<div id="compat-mobile"> + <table class="compat-table"> + <tbody> + <tr> + <th>Возможность</th> + <th>Android</th> + <th>Chrome для Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Базовая поддержка</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> + </table> +</div> + +<h3 id="Gecko-specific_notes" name="Gecko-specific_notes">Особый случай с Gecko</h3> +<p>Начиная с Gecko 17.0 {{geckoRelease("17")}}, метод <code>Function.prototype.toString()</code> реализован с сохранением исходного кода функции. Декомпилятор был удалён, так что параметр <code>indentation</code> больше не требуется. Смотрите {{bug("761723")}} для подробностей.</p> + +<h2 id="See_also" name="See_also">Смотрите также</h2> +<ul> + <li>{{jsxref("Object.prototype.toString()")}}</li> +</ul> |