path: root/files/uk/web/javascript/reference/functions/index.html

---
title: Functions
slug: Web/JavaScript/Reference/Functions
translation_of: Web/JavaScript/Reference/Functions
---
<div>AEA{{jsSidebar("Functions")}}</div>

<p>Загалом функція - це "підпрограма", що може бути <em>викликана </em>за допомогою зовнішнього (або внутрішнього у випадку рекурсії) коду. Так само, як і програма, функція складається з послідовності інструкцій, що називаються <em>тілом функції. </em>Функція приймає <em>значення</em> і вертає також <em>значення</em>.<br>
 <br>
 В JavaScript, функції - це об'єкти першого класу (first-class objects). Вони можуть мати <em>властивості</em> (properties) та <em>методи</em> (methods) так само, як і будь-які інші об'єкти. Вирізняє їх від інших об'єктів те, як вони викликаються. Загалом, функції є функціональними об'єктами (<code><a href="/uk/docs/JavaScript/Reference/Global_Objects/Function">Function</a></code> objects).<br>
 <br>
 Додаткові приклади і пояснення, див. також на <a href="/uk/docs/Web/JavaScript/Guide/Functions">JavaScript guide about functions</a>.</p>

<h2 id="Опис">Опис</h2>

<p>Кожна функція в JavaScript є об'єктом. Перегляньте {{jsxref("Function")}}, для отримання інформації про властивості та методи, об'єктів функцій.</p>

<p>Функції не те ж саме, що й процедури. Функція завжди повертає значення, а процедура може не завжди повертати значення.</p>

<p>Щоб повернути значення інше ніж default (за замовчуванням), функція мусить мати <code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/return">return</a></code> оператор, який визначає яке значення має бути повернуто. Функція без оператора return буде повертати значення, яке встановлене за замовчуванням(default).<br>
 <br>
 У випадку, коли конструктор (<a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/constructor">constructor</a>) викликається з оператором <code><a href="/en-US/docs/Web/JavaScript/Reference/Operators/new">new</a></code>, дефолтним значенням стає значення параметра <code>this</code>. Для всіх інших функцій значення, яке буде повертатися за замовчуванням буде {{jsxref("undefined")}}.</p>

<p>Параметри, що передаються при виклику функції, називаються<em>аргументами. </em>Аргументи передаються в функцію за <em>значенням</em>. При зміні значення аргументу, ця зміна жодним чином не відображається в глобальній області видимості або в функціі виклику.<br>
 <br>
 However, object references are values, too, and they are special: if the function changes the referred object's properties, that change is visible outside the function, as shown in the following example:</p>

<pre class="brush: js">/* Оголошення функції 'myFunc' */
function myFunc(theObject) {
   theObject.brand = "Toyota";
 }

 /*
  * Оголошення змінної 'mycar';
  * створення і ініціалізація нового об'єкту;
  * присвоєння об'єкту до 'mycar'
  */
 var mycar = {
   brand: "Honda",
   model: "Accord",
   year: 1998
 };

 /* Виведе 'Honda' */
 console.log(mycar.brand);

 /* Pass object reference to the function */
 myFunc(mycar);

 /*
  * Logs 'Toyota' as the value of the 'brand' property
  * of the object, as changed to by the function.
  */
 console.log(mycar.brand);
</pre>

<p>The <a href="/en-US/docs/Web/JavaScript/Reference/Operators/this"><code>this</code> keyword</a> does not refer to the currently executing function, so you must refer to <code>Function</code> objects by name, even within the function body.</p>

<h2 id="Оголошення_функцій">Оголошення функцій</h2>

<p>Є кілька способів оголошення функції:</p>

<h3 id="The_function_declaration_function_statement">The function declaration (<code>function</code> statement)</h3>

<p>Існує спеціальний синтаксис для оголошення функцій (докладніше див. <a href="/en-US/docs/Web/JavaScript/Reference/Statements/function">function statement</a>): </p>

<pre class="syntaxbox">function <em>name</em>([<em>param</em>[, <em>param</em>[, ... <em>param</em>]]]) {
   <em>statements</em>
}
</pre>

<dl>
 <dt><code>name</code></dt>
 <dd>Назва функціі.</dd>
</dl>

<dl>
 <dt><code>param</code></dt>
 <dd>Назва аргументу, що передається в функцію. Функція може приймати до 255 аргументів.</dd>
</dl>

<dl>
 <dt><code>statements</code></dt>
 <dd>Інструкціі, що складають тіло функціі.</dd>
</dl>

<h3 id="The_function_expression_function_expression">The function expression (<code>function</code> expression)</h3>

<p>Функціональний вираз схожиий на оголошення функції (function declaration) і має такий самий синтаксис (докладніше див. <a href="/en-US/docs/Web/JavaScript/Reference/Operators/function">function expression</a>):</p>

<pre class="syntaxbox">function [<em>name</em>]([<em>param</em>[, <em>param</em>[, ... <em>param</em>]]]) {
   <em>statements</em>
}
</pre>

<dl>
 <dt><code>name</code></dt>
 <dd>Назва функції. Може бути пропущена, тоді функція стане анонімною.</dd>
</dl>

<dl>
 <dt><code>param</code></dt>
 <dd>Назва аргументу, що передається в функцію. Функція може приймати до 255 аргументів.</dd>
 <dt><code>statements</code></dt>
 <dd>Інструкціі, що складають тіло функціі.</dd>
</dl>

<h3 id="The_generator_function_declaration_function*_statement">The generator function declaration (<code>function*</code> statement)</h3>

<div class="note">
<p><strong>Примітка:</strong>  Generator functions є<em> експериментальною технологією,</em> частиною ECMAScript 6 proposal,  і поки що не підтримуються всіма браузерами.</p>
</div>

<p>There is a special syntax for generator function declarations (see {{jsxref('Statements/function*', 'function* statement')}} for details):</p>

<pre class="syntaxbox">function* <em>name</em>([<em>param</em>[, <em>param</em>[, ... <em>param</em>]]]) {
   <em>statements</em>
}
</pre>

<dl>
 <dt><code>name</code></dt>
 <dd>Назва функції.</dd>
</dl>

<dl>
 <dt><code>param</code></dt>
 <dd>Назва аргументу, що передається в функцію. Функція може приймати до 255 аргументів.</dd>
</dl>

<dl>
 <dt><code>statements</code></dt>
 <dd>Інструкціі, що складають тіло функціі.</dd>
</dl>

<h3 id="The_generator_function_expression_function*_expression">The generator function expression (<code>function*</code> expression)</h3>

<div class="note">
<p><strong>Примітка:</strong>  Generator functions є<em> експериментальною технологією,</em> частиною ECMAScript 6 proposal,  і поки що не підтримуються всіма браузерами.</p>
</div>

<p>A generator function expression is similar to and has the same syntax as a generator function declaration (see {{jsxref('Operators/function*', 'function* expression')}} for details):</p>

<pre class="syntaxbox">function* [<em>name</em>]([<em>param</em>[, <em>param</em>[, ... <em>param</em>]]]) {
   <em>statements</em>
}
</pre>

<dl>
 <dt><code>name</code></dt>
 <dd>Назва функції. Може бути пропущена, тоді функція стане анонімною.</dd>
</dl>

<dl>
 <dt><code>param</code></dt>
 <dd>Назва аргументу, що передається в функцію. Функція може приймати до 255 аргументів.</dd>
 <dt><code>statements</code></dt>
 <dd>Інструкціі, що складають тіло функціі.</dd>
</dl>

<h3 id="The_arrow_function_expression_>">The arrow function expression (=&gt;)</h3>

<div class="note">
<p><strong>Примітка:</strong> Стрілочні функції (arrow function expressions) є<em> експериментальною технологією,</em> частиною ECMAScript 6 proposal,  і поки що не підтримуються всіма браузерами.</p>
</div>

<p>Стрілочні функції (arrow function expression) мають коротший синтаксис і лексично прив'язують значення <code>this</code> (докладніше див. <a href="/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions">arrow functions</a>):</p>

<pre class="syntaxbox">([param[, param]]) =&gt; {
   statements
}

param =&gt; expression
</pre>

<dl>
 <dt><code>param</code></dt>
 <dd>Назва аргументу. Якщо функція не має аргументів, це позначається скобками <code>()</code>. Якщо функція приймає тільки один аргумент, скобки можна опустити (як в <code>foo =&gt; 1</code>).</dd>
 <dt><code>statements or expression</code></dt>
 <dd>Декілька інструкції повинні бути в квадратних скобках. Якщо тіло функції містить тільки одну інструкцію, скобки можна опустити. Ця інструкція також є неявним зворотним значенням функції. </dd>
</dl>

<h3 id="The_Function_constructor">The <code>Function</code> constructor</h3>

<div class="note">
<p><strong>Примітка:</strong> Використання конструктора <code>Function</code> для створення  функцій не рекомендується, оскільки воно потребує перетворення тіла функції на строку. Це може перешкоджати деяким оптимізаціям  JS двіжка та створювати інші проблеми.</p>
</div>

<p class="syntaxbox">Як і всі інші об'єкти, об'єкти {{jsxref("Function")}} можна створювати за допомогою оператора  <code>new</code>:</p>

<pre class="syntaxbox">new Function (<em>arg1</em>, <em>arg2</em>, ... <em>argN</em>, <em>functionBody</em>)</pre>

<dl>
 <dt><code>arg1, arg2, ... arg<em>N</em></code></dt>
 <dd>Zero or more names to be used by the function as formal parameters. Each must be a proper JavaScript identifier.</dd>
</dl>

<dl>
 <dt><code>functionBody</code></dt>
 <dd>Cтрока, що містить інструкції, що складають тіло функції.</dd>
</dl>

<p>Invoking the <code>Function</code> constructor as a function (without using the <code>new</code> operator) has the same effect as invoking it as a constructor.</p>

<h3 id="The_GeneratorFunction_constructor">The <code>GeneratorFunction</code> constructor</h3>

<div class="note">
<p><strong>Note:</strong> <code>GeneratorFunction</code> не є глобальним об'єктом, але може бути отриманий з generator function instance (докладніше див. {{jsxref("GeneratorFunction")}}):</p>
</div>

<div class="note">
<p><strong>Примітка:</strong> Використання конструктора <code>GeneratorFunction</code> для створення  функцій не рекомендується, оскільки воно потребує перетворення тіла функції на строку. Це може перешкоджати деяким оптимізаціям  JS двіжка та створювати інші проблеми.</p>
</div>

<p>Як і всі інші об'єкти, об'єкти {{jsxref("GeneratorFunction")}}  можна створювати за допомогою оператора  <code>new</code>:</p>

<pre class="syntaxbox">new GeneratorFunction (<em>arg1</em>, <em>arg2</em>, ... <em>argN</em>, <em>functionBody</em>)
</pre>

<dl>
 <dt><code>arg1, arg2, ... arg<em>N</em></code></dt>
 <dd>Zero or more names to be used by the function as formal argument names. Each must be a string that conforms to the rules for a valid JavaScript identifier or a list of such strings separated with a comma; for example "<code>x</code>", "<code>theValue</code>", or "<code>a,b</code>".</dd>
</dl>

<dl>
 <dt><code>functionBody</code></dt>
 <dd>A string containing the JavaScript statements comprising the function definition.</dd>
</dl>

<p>Invoking the <code>Function</code> constructor as a function (without using the <code>new</code> operator) has the same effect as invoking it as a constructor.</p>

<h2 id="Параметри_функції">Параметри функції</h2>

<div class="note">
<p><strong>Примітка:</strong> Default and rest parameters є<em> експериментальною технологією,</em> частиною ECMAScript 6 proposal,  і поки що не підтримуються всіма браузерами.</p>
</div>

<h3 id="Default_parameters">Default parameters</h3>

<p>Default function parameters allow formal parameters to be initialized with default values if no value or <code>undefined</code> is passed. For more details, see<a href="/en-US/docs/Web/JavaScript/Reference/Functions/Default_parameters"> default parameters</a>.</p>

<h3 id="Rest_parameters">Rest parameters</h3>

<p>The rest parameter syntax allows to represent an indefinite number of arguments as an array. For more details, see <a href="/en-US/docs/Web/JavaScript/Reference/Functions/rest_parameters">rest parameters</a>.</p>

<h2 id="Обєкт_arguments">Об'єкт <code>arguments</code></h2>

<p>До аргументів функції можна звернутися всередині самої функції за допомогою об'єкта <code>arguments</code>. (Докладніше див. <a href="/en-US/docs/Web/JavaScript/Reference/Functions/arguments">arguments</a>)</p>

<ul>
 <li><code><a href="/en-US/docs/JavaScript/Reference/Functions_and_function_scope/arguments">arguments</a></code>: An array-like object containing the arguments passed to the currently executing function.</li>
 <li><code><a href="/en-US/docs/JavaScript/Reference/Functions_and_function_scope/arguments/callee">arguments.callee</a></code> {{Deprecated_inline}}: The currently executing function.</li>
 <li><code><a href="/en-US/docs/JavaScript/Reference/Functions_and_function_scope/arguments/caller">arguments.caller</a></code> {{Obsolete_inline}} : The function that invoked the currently executing function.</li>
 <li><code><a href="/en-US/docs/JavaScript/Reference/Functions_and_function_scope/arguments/length">arguments.length</a></code>: The number of arguments passed to the function.</li>
</ul>

<h2 id="Defining_method_functions">Defining method functions</h2>

<h3 id="Getter_and_setter_functions">Getter and setter functions</h3>

<p>You can define getters (accessor methods) and setters (mutator methods) on any standard built-in object or user-defined object that supports the addition of new properties. The syntax for defining getters and setters uses the object literal syntax.</p>

<dl>
 <dt><a href="/en-US/docs/Web/JavaScript/Reference/Functions/get">get</a></dt>
 <dd>
 <p>Binds an object property to a function that will be called when that property is looked up.</p>
 </dd>
 <dt><a href="/en-US/docs/Web/JavaScript/Reference/Functions/set">set</a></dt>
 <dd>Binds an object property to a function to be called when there is an attempt to set that property.</dd>
</dl>

<h3 id="Method_definition_syntax">Method definition syntax</h3>

<div class="note">
<p><strong>Note:</strong> <em>Method definitions are experimental technology,</em> part of the ECMAScript 6 proposal, and are not widely supported by browsers yet.</p>
</div>

<p>Starting with ECMAScript 6, you are able to define own methods in a shorter syntax, similar to the getters and setters. See <a href="/en-US/docs/Web/JavaScript/Reference/Functions/Method_definitions">method definitions</a> for more information.</p>

<pre class="brush: js">var obj = {
  foo() {},
  bar() {}
};</pre>

<h2 id="Function_constructor_vs._function_declaration_vs._function_expression"><code>Function</code> constructor vs. function declaration vs. function expression</h2>

<p>Compare the following:</p>

<p>A function defined with the <code>Function</code> constructor assigned to the variable <code>multiply:</code></p>

<pre class="brush: js">function multiply(x, y) {
   return x * y;
}
</pre>

<p>A <em>function expression</em> of an anonymous function assigned to the variable <code>multiply:</code></p>

<pre class="brush: js">var multiply = function(x, y) {
   return x * y;
};
</pre>

<p>A <em>function expression</em> of a function named <code>func_name</code> assigned to the variable <code>multiply:</code></p>

<pre class="brush: js">var multiply = function func_name(x, y) {
   return x * y;
};
</pre>

<h3 id="Відмінності">Відмінності</h3>

<p>All do approximately the same thing, with a few subtle differences:</p>

<p>There is a distinction between the function name and the variable the function is assigned to. The function name cannot be changed, while the variable the function is assigned to can be reassigned. The function name can be used only within the function's body. Attempting to use it outside the function's body results in an error (or <code>undefined</code> if the function name was previously declared via a <code>var</code> statement). For example:</p>

<pre class="brush: js">var y = function x() {};
alert(x); // throws an error
</pre>

<p>The function name also appears when the function is serialized via <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/toString"><code>Function</code>'s toString method</a>.</p>

<p>On the other hand, the variable the function is assigned to is limited only by its scope, which is guaranteed to include the scope where the function is declared in.</p>

<p>As the 4th example shows, the function name can be different from the variable the function is assigned to. They have no relation to each other.A function declaration also creates a variable with the same name as the function name. Thus, unlike those defined by function expressions, functions defined by function declarations can be accessed by their name in the scope they were defined in:</p>

<p>A function defined by '<code>new Function'</code> does not have a function name. However, in the <a href="/en-US/docs/Mozilla/Projects/SpiderMonkey">SpiderMonkey</a> JavaScript engine, the serialized form of the function shows as if it has the name "anonymous". For example, <code>alert(new Function())</code> outputs:</p>

<pre class="brush: js">function anonymous() {
}
</pre>

<p>Since the function actually does not have a name, <code>anonymous</code> is not a variable that can be accessed within the function. For example, the following would result in an error:</p>

<pre class="brush: js">var foo = new Function("alert(anonymous);");
foo();
</pre>

<p>Unlike functions defined by function expressions or by the <code>Function</code> constructor, a function defined by a function declaration can be used before the function declaration itself. For example:</p>

<pre class="brush: js">foo(); // alerts FOO!
function foo() {
   alert('FOO!');
}
</pre>

<p>A function defined by a function expression inherits the current scope. That is, the function forms a closure. On the other hand, a function defined by a <code>Function</code> constructor does not inherit any scope other than the global scope (which all functions inherit).</p>

<p>Functions defined by function expressions and function declarations are parsed only once, while those defined by the <code>Function</code> constructor are not. That is, the function body string passed to the <code>Function</code> constructor must be parsed each and every time the constructor is called. Although a function expression creates a closure every time, the function body is not reparsed, so function expressions are still faster than "<code>new Function(...)</code>". Therefore the <code>Function</code> constructor should generally be avoided whenever possible.</p>

<p>It should be noted, however, that function expressions and function declarations nested within the function generated by parsing a <code>Function constructor</code> 's string aren't parsed repeatedly. For example:</p>

<pre class="brush: js">var foo = (new Function("var bar = \'FOO!\';\nreturn(function() {\n\talert(bar);\n});"))();
foo(); // The segment "function() {\n\talert(bar);\n}" of the function body string is not re-parsed.</pre>

<p>A function declaration is very easily (and often unintentionally) turned into a function expression. A function declaration ceases to be one when it either:</p>

<ul>
 <li>becomes part of an expression</li>
 <li>is no longer a "source element" of a function or the script itself. A "source element" is a non-nested statement in the script or a function body:</li>
</ul>

<pre class="brush: js">var x = 0;               // source element
if (x == 0) {            // source element
   x = 10;               // not a source element
   function boo() {}     // not a source element
}
function foo() {         // source element
   var y = 20;           // source element
   function bar() {}     // source element
   while (y == 10) {     // source element
      function blah() {} // not a source element
      y++;               // not a source element
   }
}
</pre>

<h3 id="Приклади">Приклади</h3>

<pre class="brush: js">// function declaration
function foo() {}

// function expression
(function bar() {})

// function expression
x = function hello() {}


if (x) {
   // function expression
   function world() {}
}


// function declaration
function a() {
   // function declaration
   function b() {}
   if (0) {
      // function expression
      function c() {}
   }
}
</pre>

<h2 id="Conditionally_defining_a_function">Conditionally defining a function</h2>

<p>Functions can be conditionally defined using either //function statements// (an allowed extension to the <a href="http://www.ecma-international.org/publications/standards/Ecma-262.htm">ECMA-262 Edition 3</a> standard) or the <code>Function</code> constructor. Please note that such <a class="link-https" href="https://bugzilla.mozilla.org/show_bug.cgi?id=609832">function statements are no longer allowed in ES5 strict</a>. Additionally, this feature does not work consistently cross-browser, so you should not rely on it.</p>

<p>In the following script, the <code>zero</code> function is never defined and cannot be invoked, because '<code>if (0)</code>' evaluates its condition to false:</p>

<pre class="brush: js">if (0) {
   function zero() {
      document.writeln("This is zero.");
   }
}
</pre>

<p>If the script is changed so that the condition becomes '<code>if (1)</code>', function <code>zero</code> is defined.</p>

<p>Note: Although this kind of function looks like a function declaration, it is actually an expression (or statement), since it is nested within another statement. See differences between function declarations and function expressions.</p>

<p>Note: Some JavaScript engines, not including <a href="/en-US/docs/SpiderMonkey">SpiderMonkey</a>, incorrectly treat any function expression with a name as a function definition. This would lead to <code>zero</code> being defined, even with the always-false <code>if</code> condition. A safer way to define functions conditionally is to define the function anonymously and assign it to a variable:</p>

<pre class="brush: js">if (0) {
   var zero = function() {
      document.writeln("This is zero.");
   }
}
</pre>

<h2 id="Приклади_2">Приклади</h2>

<h3 id="Returning_a_formatted_number">Returning a formatted number</h3>

<p>The following function returns a string containing the formatted representation of a number padded with leading zeros.</p>

<pre class="brush: js">// This function returns a string padded with leading zeros
function padZeros(num, totalLen) {
   var numStr = num.toString();             // Initialize return value as string
   var numZeros = totalLen - numStr.length; // Calculate no. of zeros
   for (var i = 1; i &lt;= numZeros; i++) {
      numStr = "0" + numStr;
   }
   return numStr;
}
</pre>

<p>The following statements call the padZeros function.</p>

<pre class="brush: js">var result;
result = padZeros(42,4); // returns "0042"
result = padZeros(42,2); // returns "42"
result = padZeros(5,4);  // returns "0005"
</pre>

<h3 id="Determining_whether_a_function_exists">Determining whether a function exists</h3>

<p>You can determine whether a function exists by using the <code>typeof</code> operator. In the following example, a test is peformed to determine if the <code>window</code> object has a property called <code>noFunc</code> that is a function. If so, it is used; otherwise some other action is taken.</p>

<pre class="brush: js"> if ('function' == typeof window.noFunc) {
   // use noFunc()
 } else {
   // do something else
 }
</pre>

<p>Note that in the <code>if</code> test, a reference to <code>noFunc</code> is used—there are no brackets "()" after the function name so the actual function is not called.</p>

<h2 id="Специфікації">Специфікації</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>Initial definition. Implemented in JavaScript 1.0</td>
  </tr>
  <tr>
   <td>{{SpecName('ES5.1', '#sec-13', 'Function Definition')}}</td>
   <td>{{Spec2('ES5.1')}}</td>
   <td></td>
  </tr>
  <tr>
   <td>{{SpecName('ES6', '#sec-function-definitions', 'Function definitions')}}</td>
   <td>{{Spec2('ES6')}}</td>
   <td>New: Arrow functions, Generator functions, default parameters, rest parameters.</td>
  </tr>
  <tr>
   <td>{{SpecName('ESDraft', '#sec-function-definitions', 'Function definitions')}}</td>
   <td>{{Spec2('ESDraft')}}</td>
   <td></td>
  </tr>
 </tbody>
</table>

<h2 id="Сумісність_з_браузерами">Сумісність з браузерами</h2>

<p>{{CompatibilityTable}}</p>

<div id="compat-desktop">
<table class="compat-table">
 <tbody>
  <tr>
   <th>Feature</th>
   <th>Chrome</th>
   <th>Firefox (Gecko)</th>
   <th>Internet Explorer</th>
   <th>Opera</th>
   <th>Safari</th>
  </tr>
  <tr>
   <td>Basic support</td>
   <td>{{CompatVersionUnknown}}</td>
   <td>{{CompatVersionUnknown}}</td>
   <td>{{CompatVersionUnknown}}</td>
   <td>{{CompatVersionUnknown}}</td>
   <td>{{CompatVersionUnknown}}</td>
  </tr>
  <tr>
   <td>Generator function</td>
   <td>39</td>
   <td>{{CompatGeckoDesktop("26.0")}}</td>
   <td>{{CompatUnknown}}</td>
   <td>26</td>
   <td>{{CompatUnknown}}</td>
  </tr>
  <tr>
   <td>Arrow function</td>
   <td>{{CompatNo}}</td>
   <td>{{CompatGeckoDesktop("22.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>Feature</th>
   <th>Android</th>
   <th>Chrome for Android</th>
   <th>Firefox Mobile (Gecko)</th>
   <th>IE Mobile</th>
   <th>Opera Mobile</th>
   <th>Safari Mobile</th>
  </tr>
  <tr>
   <td>Basic support</td>
   <td>{{CompatVersionUnknown}}</td>
   <td>{{CompatVersionUnknown}}</td>
   <td>{{CompatVersionUnknown}}</td>
   <td>{{CompatVersionUnknown}}</td>
   <td>{{CompatVersionUnknown}}</td>
   <td>{{CompatVersionUnknown}}</td>
  </tr>
  <tr>
   <td>Generator function</td>
   <td>{{CompatUnknown}}</td>
   <td>39</td>
   <td>{{CompatGeckoMobile("26.0")}}</td>
   <td>{{CompatUnknown}}</td>
   <td>26</td>
   <td>{{CompatUnknown}}</td>
  </tr>
  <tr>
   <td>Arrow function</td>
   <td>{{CompatNo}}</td>
   <td>{{CompatNo}}</td>
   <td>{{CompatGeckoMobile("22.0")}}</td>
   <td>{{CompatNo}}</td>
   <td>{{CompatNo}}</td>
   <td>{{CompatNo}}</td>
  </tr>
 </tbody>
</table>
</div>

<h2 id="Також_див.">Також див.</h2>

<ul>
 <li>{{jsxref("Statements/function", "function statement")}}</li>
 <li>{{jsxref("Operators/function", "function expression")}}</li>
 <li>{{jsxref("Statements/function*", "function* statement")}}</li>
 <li>{{jsxref("Operators/function*", "function* expression")}}</li>
 <li>{{jsxref("Function")}}</li>
 <li>{{jsxref("GeneratorFunction")}}</li>
 <li>{{jsxref("Functions/Arrow_functions", "Arrow functions")}}</li>
 <li>{{jsxref("Functions/Default_parameters", "Default parameters")}}</li>
 <li>{{jsxref("Functions/rest_parameters", "Rest parameters")}}</li>
 <li>{{jsxref("Functions/arguments", "Arguments object")}}</li>
 <li>{{jsxref("Functions/get", "getter")}}</li>
 <li>{{jsxref("Functions/set", "setter")}}</li>
 <li>{{jsxref("Functions/Method_definitions", "Method definitions")}}</li>
 <li><a href="/en-US/docs/Web/JavaScript/Reference/Functions_and_function_scope" title="JavaScript/Reference/Functions_and_function_scope">Functions and function scope</a></li>
</ul>