recursal/MDN huggingface dataset:
Math.clz32()
============

Сводка
------

Метод **`Math.clz32()`** возвращает количество ведущих нулевых битов в 32-битном двоичном представлении числа.

Синтаксис
---------
```

Math.clz32(x)
```

### Параметры

`x`

Число.

Описание
--------

Название `clz32` является сокращением для более длинного `CountLeadingZeroes32` (`ПосчтитатьВедущиеНули32`).

Если значение `x` не является числом, оно будет сначала преобразовано в число, а потом в 32-битное беззнаковое целое число.

Если преобразованное 32-битное беззнаковое целое число равно `0`, метод вернёт `32`, поскольку все биты в числе равны `0`.

Этот метод особенно полезен для систем, которые компилируются в JS, например, для Emscripten.

Примеры
-------

### Пример: использование метода `Math.clz32()`


```js
Math.clz32(1); // 31
Math.clz32(1000); // 22
Math.clz32(); // 32

[NaN, Infinity, -Infinity, 0, -0, null, undefined, "foo", {}, []].filter(
  function (n) {
    return Math.clz32(n) !== 32;
  },
); // []

Math.clz32(true); // 31
Math.clz32(3.5); // 30
```

Полифил
-------


```js
Math.clz32 =
  Math.clz32 ||
  function (value) {
    value = Number(value) >>> 0;
    return value !== 0
      ? 31 - Math.floor(Math.log(value + 0.5) / Math.log(2))
      : 32;
  };
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.clz32 |

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

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Смотрите также
--------------

* `Math`
Math.atan2()
============

Сводка
------

Метод **`Math.atan2()`** возвращает арктангенс от частного своих аргументов.

Синтаксис
---------
```

Math.atan2(y, x)
```

### Параметры

`y`

Первое число.

`x`

Второе число.

Описание
--------

Метод `Math.atan2()` возвращает числовое значение от -π до π, представляющее угол тета точки `(x, y)`. Это выраженный в радианах угол, отсчитываемый против часовой стрелки от положительного направления оси X до точки `(x, y)`. Обратите внимание, что первым в метод передаётся координата y, а только вторым — координата x.

В метод `Math.atan2()` аргументы `x` и `y` передаются по отдельности, в то время, как в метод `Math.atan()` передаётся отношение этих двух аргументов.

Поскольку метод `atan2()` является статическим методом объекта `Math`, вы всегда должны использовать его как `Math.atan2()`, а не пытаться вызывать метод на созданном экземпляре объекта `Math` (поскольку объект `Math` не является конструктором).

Примеры
-------

### Пример: использование метода `Math.atan2()`


```js
Math.atan2(90, 15); // 1.4056476493802699
Math.atan2(15, 90); // 0.16514867741462683

Math.atan2(±0, -0);               // ±PI.
Math.atan2(±0, +0);               // ±0.
Math.atan2(±0, -x);               // ±PI для x > 0.
Math.atan2(±0, x);                // ±0 для x > 0.
Math.atan2(-y, ±0);               // -PI/2 для y > 0.
Math.atan2(y, ±0);                // PI/2 для y > 0.
Math.atan2(±y, -Infinity);        // ±PI для конечного y > 0.
Math.atan2(±y, +Infinity);        // ±0 для конечного y > 0.
Math.atan2(±Infinity, x);         // ±PI/2 для конечного x.
Math.atan2(±Infinity, -Infinity); // ±3\*PI/4.
Math.atan2(±Infinity, +Infinity); // ±PI/4.
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.atan2 |

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

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Смотрите также
--------------

* `Math.acos()`
* `Math.asin()`
* `Math.atan()`
* `Math.cos()`
* `Math.sin()`
* `Math.tan()`
Math.abs()
==========

Сводка
------

Метод **`Math.abs()`** возвращает абсолютное значение числа. то есть



Math.abs
(
x
)

=

|
x
|

=

{

x

if

x
≥
0

-
x

if

x
<
0


{\mathtt{\operatorname{Math.abs}(x)}} = {|x|} = \begin{cases} x & \text{if} \quad x \geq 0 \ x & \text{if} \quad x < 0 \end{cases}

Синтаксис
---------
```

Math.abs(x)
```

### Параметры

`x`

Число.

Описание
--------

Поскольку метод `abs()` является статическим методом объекта `Math`, вы всегда должны использовать его как `Math.abs()`, а не пытаться вызывать метод на созданном объекте `Math` (поскольку объект `Math` не является конструктором).

Примеры
-------

### Пример: поведение метода `Math.abs()`

Метод вернёт `NaN`, если в него передать нечисловую строку или значение `undefined`/ничего не передавать. Метод вернёт 0, если в него передать значение `null`.


```js
Math.abs("-1"); // 1
Math.abs(-2); // 2
Math.abs(null); // 0
Math.abs(""); // 0
Math.abs([]); // 0
Math.abs([2]); // 2
Math.abs([1, 2]); // NaN
Math.abs({}); // NaN
Math.abs("string"); // NaN
Math.abs(); // NaN
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.abs |

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

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Смотрите также
--------------

* `Math.ceil()`
* `Math.floor()`
* `Math.round()`
* `Math.sign()`
* `Math.trunc()`
Math.sinh()
===========

Сводка
------

Метод **`Math.sinh()`** возвращает гиперболический синус числа, который может быть выражен через число e:


Math.sinh(x)

=

e
x

-

e

-
x

2

\mathtt{\operatorname{Math.sinh(x)}} = \frac{e^x - e^{-x}}{2}

Синтаксис
---------
```

Math.sinh(x)
```

### Параметры

`x`

Число.

Описание
--------

Поскольку метод `sinh()` является статическим методом объекта `Math`, вы всегда должны использовать его как `Math.sinh()`, а не пытаться вызывать метод на созданном экземпляре объекта `Math` (поскольку объект `Math` не является конструктором).

Примеры
-------

### Пример: использование метода `Math.sinh()`


```js
Math.sinh(0); // 0
Math.sinh(1); // 1.1752011936438014
```

Полифил
-------

Этот метод может эмулироваться при помощи двух вызовов метода `Math.exp()`:


```js
Math.sinh =
  Math.sinh ||
  function (x) {
    return (Math.exp(x) - Math.exp(-x)) / 2;
  };
```


либо при помощи только одного вызова метода `Math.exp()`:


```js
Math.sinh =
  Math.sinh ||
  function (x) {
    var y = Math.exp(x);
    return (y - 1 / y) / 2;
  };
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.sinh |

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

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Смотрите также
--------------

* `Math.acosh()` 
Экспериментальная возможность
* `Math.asinh()` 
Экспериментальная возможность
* `Math.atanh()` 
Экспериментальная возможность
* `Math.cosh()` 
Экспериментальная возможность
* `Math.tanh()` 
Экспериментальная возможность
Math.min()
==========

Сводка
------

Метод **`Math.min()`** возвращает наименьшее из нуля или более чисел.

Синтаксис
---------
```

Math.min([value1[, value2[, ...]]])
```

### Параметры

`value1, value2, ...`

Числа.

Описание
--------

Поскольку метод `min()` является статическим методом объекта `Math`, вы всегда должны использовать его как `Math.min()`, а не пытаться вызывать метод на созданном экземпляре объекта `Math` (поскольку объект `Math` не является конструктором).

При вызове без аргументов результатом вызова будет значение `Infinity`.

Если хотя бы один из аргументов не может быть преобразован в число, результатом будет `NaN`.

Примеры
-------

### Пример: использование метода `Math.min()`

В этом примере ищется минимум из `x` и `y` и присваивается переменной `z`:


```js
var x = 10,
  y = -20;
var z = Math.min(x, y);
```

### Пример: обрезание значения при помощи метода `Math.min()`

Метод `Math.min()` часто используется для обрезания значения таким образом, чтобы оно всегда не превосходило некоторую границу. Например, такое условие


```js
var x = f(foo);

if (x > boundary) {
  x = boundary;
}
```


может быть переписано в виде


```js
var x = Math.min(f(foo), boundary);
```


Подобным образом может использоваться и метод `Math.max()` для обрезания значения по нижней границе.

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.min |

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

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Смотрите также
--------------

* `Math.max()`
Math.max()
==========

Сводка
------

Метод **`Math.max()`** возвращает наибольшее из нуля или более чисел.

Синтаксис
---------
```

Math.max([value1[, value2[, ...]]])
```

### Параметры

`value1, value2, ...`

Числа.

Описание
--------

Поскольку метод `max()` является статическим методом объекта `Math`, вы всегда должны использовать его как `Math.max()`, а не пытаться вызывать метод на созданном экземпляре объекта `Math` (поскольку объект `Math` не является конструктором).

При вызове без аргументов результатом вызова будет значение -`Infinity`.

Если хотя бы один из аргументов не может быть преобразован в число, результатом будет `NaN`.

Примеры
-------

### Пример: использование метода `Math.max()`


```js
Math.max(10, 20); // 20
Math.max(-10, -20); // -10
Math.max(-10, 20); // 20
```


#### Нахождение максимального элемента в массиве

Следующая функция использует метод `Function.prototype.apply()` для нахождения максимального элемента в числовом массиве. Вызов `getMaxOfArray([1, 2, 3])` эквивалентен вызову `Math.max(1, 2, 3)`, однако вы можете использовать функцию `getMaxOfArray()` вместе с программно сконструированными массивами любого размера. Рекомендуется использовать только в случае обработки массивов с небольшим количеством элементов.


```js
function getMaxOfArray(numArray) {
  return Math.max.apply(null, numArray);
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.max |

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

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Смотрите также
--------------

* `Math.min()`
Math.log2()
===========

Сводка
------

Метод **`Math.log2()`** возвращает двоичный (по основанию 2) логарифм числа, то есть



∀
x
>
0
,

Math.log2
(
x
)

=

log
2

(
x
)
=
уникальный

y

такой, что

2
y

=
x

\forall x > 0, \mathtt{\operatorname{Math.log2}(x)} = \log\_2(x) = \text{уникальный} ; y ; \text{такой, что} ; 2^y = x

Интерактивный пример
--------------------

Синтаксис
---------
```

Math.log2(x)
```

### Параметры

`x`

Число.

Описание
--------

Если значение `x` меньше 0, возвращаемое значение всегда будет равным `NaN`.

Поскольку метод `log2()` является статическим методом объекта `Math`, вы всегда должны использовать его как `Math.log2()`, а не пытаться вызывать метод на созданном экземпляре объекта `Math` (поскольку объект `Math` не является конструктором).

Примеры
-------

### Пример: использование метода `Math.log2()`


```js
Math.log2(3); // 1.584962500721156
Math.log2(2); // 1
Math.log2(1); // 0
Math.log2(0); // -Infinity
Math.log2(-2); // NaN
Math.log2(1024); // 10
```

Полифил
-------

Этот метод может эмулироваться следующим способом:


```js
Math.log2 =
  Math.log2 ||
  function (x) {
    return Math.log(x) / Math.LN2;
  };
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.log2 |

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

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Смотрите также
--------------

* `Math.exp()`
* `Math.log()`
* `Math.log10()`
* `Math.log1p()`
* `Math.pow()`
Math.floor()
============

Сводка
------

Метод **`Math.floor()`** - округление вниз. Округляет аргумент до ближайшего меньшего целого.

Синтаксис
---------
```

Math.floor(x)
```

### Параметры

`x`

Число.

Описание
--------

Поскольку метод `floor()` является статическим методом объекта `Math`, вы всегда должны использовать его как `Math.floor()`, а не пытаться вызывать метод на созданном экземпляре объекта `Math` (поскольку объект `Math` не является конструктором).

Примеры
-------

### Пример: использование метода `Math.floor()`


```js
Math.floor(45.95); // 45
Math.floor(-45.95); // -46
```

### Пример: корректировка округления десятичных дробей


```js
// Замыкание
(function () {
  /\*\*
 \* Корректировка округления десятичных дробей.
 \*
 \* @param {String} type Тип корректировки.
 \* @param {Number} value Число.
 \* @param {Integer} exp Показатель степени (десятичный логарифм основания корректировки).
 \* @returns {Number} Скорректированное значение.
 \*/
  function decimalAdjust(type, value, exp) {
    // Если степень не определена, либо равна нулю...
    if (typeof exp === "undefined" || +exp === 0) {
      return Math[type](value);
    }
    value = +value;
    exp = +exp;
    // Если значение не является числом, либо степень не является целым числом...
    if (isNaN(value) || !(typeof exp === "number" && exp % 1 === 0)) {
      return NaN;
    }
    // Сдвиг разрядов
    value = value.toString().split("e");
    value = Math[type](+(value[0] + "e" + (value[1] ? +value[1] - exp : -exp)));
    // Обратный сдвиг
    value = value.toString().split("e");
    return +(value[0] + "e" + (value[1] ? +value[1] + exp : exp));
  }

  // Десятичное округление к ближайшему
  if (!Math.round10) {
    Math.round10 = function (value, exp) {
      return decimalAdjust("round", value, exp);
    };
  }
  // Десятичное округление вниз
  if (!Math.floor10) {
    Math.floor10 = function (value, exp) {
      return decimalAdjust("floor", value, exp);
    };
  }
  // Десятичное округление вверх
  if (!Math.ceil10) {
    Math.ceil10 = function (value, exp) {
      return decimalAdjust("ceil", value, exp);
    };
  }
})();

// Округление к ближайшему
Math.round10(55.55, -1); // 55.6
Math.round10(55.549, -1); // 55.5
Math.round10(55, 1); // 60
Math.round10(54.9, 1); // 50
Math.round10(-55.55, -1); // -55.5
Math.round10(-55.551, -1); // -55.6
Math.round10(-55, 1); // -50
Math.round10(-55.1, 1); // -60
// Округление вниз
Math.floor10(55.59, -1); // 55.5
Math.floor10(59, 1); // 50
Math.floor10(-55.51, -1); // -55.6
Math.floor10(-51, 1); // -60
// Округление вверх
Math.ceil10(55.51, -1); // 55.6
Math.ceil10(51, 1); // 60
Math.ceil10(-55.59, -1); // -55.5
Math.ceil10(-59, 1); // -50
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.floor |

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

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Смотрите также
--------------

* `Math.abs()`
* `Math.ceil()`
* `Math.round()`
* `Math.sign()` 
Экспериментальная возможность
* `Math.trunc()` 
Экспериментальная возможность
Math.log1p()
============

Сводка
------

Метод **`Math.log1p()`** возвращает натуральный (по основанию `e`) логарифм 1 + числа, то есть



∀
x
>
-
1
,

Math.log1p
(
x
)

=
ln
(
1
+
x
)

\forall x > -1, \mathtt{\operatorname{Math.log1p}(x)} = \ln(1 + x)

Синтаксис
---------
```

Math.log1p(x)
```

### Параметры

`x`

Число.

Описание
--------

Если значение `x` меньше -1, возвращаемое значение всегда будет равным `NaN`.

Поскольку метод `log1p()` является статическим методом объекта `Math`, вы всегда должны использовать его как `Math.log1p()`, а не пытаться вызывать метод на созданном экземпляре объекта `Math` (поскольку объект `Math` не является конструктором).

Примеры
-------

### Пример: использование метода `Math.log1p()`


```js
Math.log1p(1); // 0.6931471805599453
Math.log1p(0); // 0
Math.log1p(-1); // -Infinity
Math.log1p(-2); // NaN
```

Полифил
-------

Этот метод может эмулироваться следующим способом:


```js
Math.log1p =
  Math.log1p ||
  function (x) {
    return Math.log(1 + x);
  };
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.log1p |

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

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Смотрите также
--------------

* `Math.exp()`
* `Math.log()`
* `Math.log10()` 
Экспериментальная возможность
* `Math.log2()` 
Экспериментальная возможность
* `Math.pow()`
Math.asinh()
============

Сводка
------

Метод **`Math.asinh()`** возвращает гиперболический арксинус числа, то есть



Math.asinh
(
x
)

=
arsinh
(
x
)
=
 уникальный 

y

такой, что

sinh
(
y
)
=
x

\mathtt{\operatorname{Math.asinh}(x)} = \operatorname{arsinh}(x) = \text{ уникальный } ; y ; \text{такой, что} ; \sinh(y) = x

Синтаксис
---------
```

Math.asinh(x)
```

### Параметры

`x`

Число.

Описание
--------

Поскольку метод `asinh()` является статическим методом объекта `Math`, вы всегда должны использовать его как `Math.asinh()`, а не пытаться вызывать метод на созданном экземпляре объекта `Math` (поскольку объект `Math` не является конструктором).

Примеры
-------

### Пример: использование метода `Math.asinh()`


```js
Math.asinh(1); // 0.881373587019543
Math.asinh(0); // 0
```

Полифил
-------

Мы имеем 


arsinh
(
x
)
=
ln

(

x
+

x
2

+
1

)

\operatorname {arsinh} (x) = \ln \left(x + \sqrt{x^{2} + 1} \right)

, так что этот метод может эмулироваться следующим образом:


```js
Math.asinh =
  Math.asinh ||
  function (x) {
    if (x === -Infinity) {
      return x;
    } else {
      return Math.log(x + Math.sqrt(x \* x + 1));
    }
  };
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.asinh |

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

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Смотрите также
--------------

* `Math.acosh()` 
Экспериментальная возможность
* `Math.atanh()` 
Экспериментальная возможность
* `Math.cosh()` 
Экспериментальная возможность
* `Math.sinh()` 
Экспериментальная возможность
* `Math.tanh()` 
Экспериментальная возможность
Math.tan()
==========

Сводка
------

Метод **`Math.tan()`** возвращает тангенс числа.

Синтаксис
---------
```

Math.tan(x)
```

### Параметры

`x`

Число, представляющее угол в радианах.

Описание
--------

Метод `Math.tan()` возвращает числовое значение, представляющее тангенс угла.

Поскольку метод `tan()` является статическим методом объекта `Math`, вы всегда должны использовать его как `Math.tan()`, а не пытаться вызывать метод на созданном экземпляре объекта `Math` (поскольку объект `Math` не является конструктором).

Примеры
-------

### Пример: использование метода `Math.tan()`


```js
Math.tan(1); // 1.5574077246549023
```


Поскольку метод `Math.tan()` принимает радианы, а чаще проще работать с градусами, следующая функция принимает значение в градусах, преобразует их в радианы и возвращает тангенс.


```js
function getTanDeg(deg) {
  var rad = (deg \* Math.PI) / 180;
  return Math.tan(rad);
}
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.tan |

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

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Смотрите также
--------------

* `Math.acos()`
* `Math.asin()`
* `Math.atan()`
* `Math.atan2()`
* `Math.cos()`
* `Math.sin()`
Math.sign()
===========

Сводка
------

Метод **`Math.sign()`** возвращает знак числа, указывающий на то, является ли число отрицательным, положительным или нулём.

Синтаксис
---------
```

Math.sign(x)
```

### Параметры

`x`

Число.

Описание
--------

Поскольку метод `sign()` является статическим методом объекта `Math`, вы всегда должны использовать его как `Math.sign()`, а не пытаться вызывать метод на созданном экземпляре объекта `Math` (поскольку объект `Math` не является конструктором).

Метод может вернуть одно из пяти значений: `1`, `-1`, `0`, `-0` и `NaN`, которые представляют, соответственно «положительное число», «отрицательное число», «положительный ноль», «отрицательный ноль» и `NaN`.

Обратите внимание, что аргумент, переданный в этот метод, будет неявно преобразован в число.

Примеры
-------

### Пример: использование метода `Math.sign()`


```js
Math.sign(3); // 1
Math.sign(-3); // -1
Math.sign("-3"); // -1
Math.sign(0); // 0
Math.sign(-0); // -0
Math.sign(NaN); // NaN
Math.sign("foo"); // NaN
Math.sign(); // NaN
```

Полифил
-------


```js
Math.sign =
  Math.sign ||
  function (x) {
    x = +x; // преобразуем в число
    if (x === 0 || isNaN(x)) {
      return x;
    }
    return x > 0 ? 1 : -1;
  };
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.sign |

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

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Смотрите также
--------------

* `Math.abs()`
* `Math.ceil()`
* `Math.floor()`
* `Math.round()`
* `Math.trunc()` 
Экспериментальная возможность
Math.PI
=======

Сводка
------

Свойство **`Math.PI`** представляет отношение длины окружности круга к его диаметру, приблизительно равное 3,14159:


Math.PI

=
π
≈
3,14159

\mathtt{\mi{Math.PI}} = \pi \approx 3,14159



| Атрибуты свойства `Math.PI` |
| --- |
| Записываемое | нет |
| Перечисляемое | нет |
| Настраиваемое | нет |

Описание
--------

Поскольку свойство `PI` является статическим свойством объекта `Math`, вы всегда должны использовать его как `Math.PI`, а не пытаться создавать экземпляр объекта `Math` и получать свойство от него (поскольку объект `Math` не является конструктором).

Примеры
-------

### Пример: использование свойства `Math.PI`

Следующая функция использует значение `Math.PI` для вычисления длины окружности по известному радиусу круга.


```js
function calculateCircumference(radius) {
  return 2 \* Math.PI \* radius;
}

calculateCircumference(1); // 6.283185307179586
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.pi |

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

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Смотрите также
--------------

* `Math`
Math.SQRT2
==========

Сводка
------

Свойство **`Math.SQRT2`** представляет квадратный корень из 2, приблизительно равный 1,414:


Math.SQRT2

=

2

≈
1,414

\mathtt{\mi{Math.SQRT2}} = \sqrt{2} \approx 1,414



| Атрибуты свойства `Math.SQRT2` |
| --- |
| Записываемое | нет |
| Перечисляемое | нет |
| Настраиваемое | нет |

Описание
--------

Поскольку свойство `SQRT2` является статическим свойством объекта `Math`, вы всегда должны использовать его как `Math.SQRT2`, а не пытаться создавать экземпляр объекта `Math` и получать свойство от него (поскольку объект `Math` не является конструктором).

Примеры
-------

### Пример: использование свойства `Math.SQRT2`

Следующая функция возвращает квадратный корень из двух:


```js
function getRoot2() {
  return Math.SQRT2;
}

getRoot2(); // 1.4142135623730951
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.sqrt2 |

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

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Смотрите также
--------------

* `Math.pow()`
* `Math.sqrt()`
Math.pow()
==========

Сводка
------

Метод **`Math.pow()`** возвращает `основание`, возведённое в степень `показатель`, то есть, значение выражения: **основаниепоказатель**.

Синтаксис
---------
```

Math.pow(base, exponent)
```

### Параметры

`base`

Основание степени.

`exponent`

Показатель степени, в которую возводится основание `base`.

Описание
--------

Поскольку метод `pow()` является статическим методом объекта `Math`, вы всегда должны использовать его как `Math.pow()`, а не пытаться вызывать метод на созданном экземпляре объекта `Math` (поскольку объект `Math` не является конструктором).

Примеры
-------

### Пример: использование метода `Math.pow()`


```js
Math.pow(7, 2); // 49
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.pow |

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

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Смотрите также
--------------

* `Math.cbrt()` 
Экспериментальная возможность
* `Math.exp()`
* `Math.log()`
* `Math.sqrt()`