recursal/MDN huggingface dataset:
Object.fromEntries()
====================

**`Object.fromEntries()`** メソッドは、キーと値の組み合わせのリストをオブジェクトに変換します。

試してみましょう
--------

構文
--
```

Object.fromEntries(iterable);
```

### 引数

`iterable`

反復処理プロトコルを実装している `Array` や `Map` やその他の反復処理可能なオブジェクトです。

### 返値

反復可能な項目から作成されたプロパティを持つ新しいオブジェクト。

説明
--

`Object.fromEntries()` メソッドは、キーと値のリストを取り、これらの項目から作成されたプロパティを持つ新しいオブジェクトを返します。引数の *iterable* は `@@iterator` メソッドを実装しており、オブジェクトのような二つの要素を持ち、最初の要素がプロパティキーとして使われる値であり、次の要素がプロパティのキーに関連付けられる値であるようなオブジェクトであることが求められます。

`Object.fromEntries()` は `Object.entries()` の逆の動作をします。

例
-

### Map から Object への変換

`Object.fromEntries` では、 `Map` を `Object` に変換することができます。


```js
const map = new Map([
  ["foo", "bar"],
  ["baz", 42],
]);
const obj = Object.fromEntries(map);
console.log(obj); // { foo: "bar", baz: 42 }
```

### Array から Object への変換

`Object.fromEntries` では、 `Array` を `Object` に変換することができます。


```js
const arr = [
  ["0", "a"],
  ["1", "b"],
  ["2", "c"],
];
const obj = Object.fromEntries(arr);
console.log(obj); // { 0: "a", 1: "b", 2: "c" }
```

### オブジェクトの変形

`Object.fromEntries`、逆のメソッド `Object.entries()`、配列操作メソッドを使用して、以下のようにオブジェクトを変形することができます。


```js
const object1 = { a: 1, b: 2, c: 3 };

const object2 = Object.fromEntries(
  Object.entries(object1).map(([key, val]) => [key, val \* 2]),
);

console.log(object2);
// { a: 2, b: 4, c: 6 }
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.fromentries |

ブラウザーの互換性
---------

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

関連情報
----

* `Object.entries()`
* `Object.keys()`
* `Object.values()`
* `Map.prototype.entries()`
* `Map.prototype.keys()`
* `Map.prototype.values()`
Object.prototype.\_\_lookupSetter\_\_()
=======================================

**非推奨:** この機能は非推奨になりました。まだ対応しているブラウザーがあるかもしれませんが、すでに関連するウェブ標準から削除されているか、削除の手続き中であるか、互換性のためだけに残されている可能性があります。使用を避け、できれば既存のコードは更新してください。このページの下部にある互換性一覧表を見て判断してください。この機能は突然動作しなくなる可能性があることに注意してください。

**`__lookupSetter__`** メソッドは、指定されたプロパティに結びつけられているセッター関数を返します。

構文
--


```js
\_\_lookupSetter\_\_(sprop);
```

### 引数

`sprop`

セッター関数を返すプロパティの名前を表す文字列です。

### 返値

指定されたプロパティへのセッターとしてバインドされている関数です。

解説
--

オブジェクトのプロパティに対してセッター関数が定義されていても、そのプロパティを通してセッター関数への参照を得ることはできません。そのプロパティは、セッター関数の返値を参照するからです。 `__lookupSetter__` を使うことで、セッター関数への参照を得ることができます。

これは標準化された `Object.getOwnPropertyDescriptor()` を使用する方法で行うことが可能になりました。

例
-

### プロパティセッターを取得するための標準準拠の方法と標準外の方法


```js
var obj = {
  set foo(value) {
    this.bar = value;
  },
};

// 標準外かつ非推奨の方法
obj.\_\_lookupSetter\_\_("foo");
// (function(value) { this.bar = value; })

// 標準準拠の方法
Object.getOwnPropertyDescriptor(obj, "foo").set;
// (function(value) { this.bar = value; })
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.prototype.\_\_lookupSetter\_\_ |

ブラウザーの互換性
---------

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

関連情報
----

* `Object.prototype.__lookupSetter__` のポリフィルは `core-js` で利用できます
* `Object.prototype.__lookupGetter__()`
* `set` 演算子
* `Object.getOwnPropertyDescriptor()` と
 `Object.getPrototypeOf()`
* `Object.prototype.__defineGetter__()`
* `Object.prototype.__defineSetter__()`
* JavaScript ガイド: ゲッターとセッターの定義
Object.prototype.toLocaleString()
=================================

**`toLocaleString()`** メソッドは、オブジェクトを表す文字列を返します。このメソッドは、ロケール固有の目的のために派生オブジェクトによって上書きするためのものです。

試してみましょう
--------

構文
--
```

obj.toLocaleString()
```

### 返値

オブジェクトを表現する文字列です。

解説
--

`Object` の `toLocaleString` は `toString()` を呼び出した結果を返します。

この関数は、すべての人が使うわけではありませんが、オブジェクトに汎用的な `toLocaleString` メソッドを与えるために提供されています。以下のリストを参照してください。

### toLocaleString を上書きしているオブジェクト

* `Array`: `Array.prototype.toLocaleString()`
* `Number`: `Number.prototype.toLocaleString()`
* `Date`: `Date.prototype.toLocaleString()`
* `TypedArray`: `TypedArray.prototype.toLocaleString()`
* `BigInt`: `BigInt.prototype.toLocaleString()`
例
-

### Array における toLocaleString() の上書き

`Array` オブジェクトでは、 `toLocaleString()` を使用して配列の値を文字列として表示したり、オプションでロケール固有の識別子 (通貨記号など) を付加して表示したりすることができます。

例を示します。


```js
const testArray = [4, 7, 10];

let euroPrices = testArray.toLocaleString("fr", {
  style: "currency",
  currency: "EUR",
});
// "4,00 €,7,00 €,10,00 €"
```

### Date における toLocaleString() の上書き

`Date` オブジェクトでは、 `toLocaleString()` を使用して、特定のロケールに適した日付表示を出力します。

例を示します。


```js
const testDate = new Date(Date.now());
// "Date Fri May 29 2020 18:04:24 GMT+0100 (British Summer Time)"

let deDate = testDate.toLocaleString("de");
// "29.5.2020, 18:04:24"

var frDate = testDate.toLocaleString("fr");
//"29/05/2020 à 18:04:24"
```

### Number における toLocaleString() の上書き

`Number` オブジェクトでは、 `toLocaleString()` を使用して、特定のロケールに適した数値表示、例えば正しい区切り文字を使って出力します。

例を示します。


```js
const testNumber = 2901234564;
// "2901234564"

let deNumber = testNumber.toLocaleString("de");
// "2.901.234.564"

let frNumber = testNumber.toLocaleString("fr");
// "2 901 234 564"
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.prototype.tolocalestring |

ブラウザーの互換性
---------

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

関連情報
----

* `Object.prototype.toString()`
Object.prototype.\_\_defineSetter\_\_()
=======================================

**警告:** この機能は非推奨となり、オブジェクト初期化子の構文または `Object.defineProperty()` API を使用してセッターを定義する方法で置き換えられました。

ただし、ウェブ上では広く実装され利用されているため、ブラウザーが実装をやめる可能性は極めて低いと考えられます。

**`__defineSetter__`** メソッドは、オブジェクトのプロパティと関数を結び付け、そのプロパティを設定しようとすると呼び出されるようにします。

構文
--


```js
\_\_defineSetter\_\_(prop, fun);
```

### 引数

`prop`

関数と結びつけられたプロパティの名前を表す文字列です。

`fun`

プロパティへ値を設定しようとしたときに呼び出される関数です。この関数は以下の形式をとります。


```js
function(val) { . . . }
```


`val`

`prop` へ代入しようとする値を保持する変数の別名です。


### 返値

`undefined` です。

解説
--

`__defineSetter__` メソッドにより、既存のオブジェクトにセッターを定義することができます。

例
-

### 標準外かつ非推奨の方法


```js
var o = {};
o.\_\_defineSetter\_\_("value", function (val) {
  this.anotherValue = val;
});
o.value = 5;
console.log(o.value); // undefined
console.log(o.anotherValue); // 5
```

### 標準準拠の方法


```js
// set 演算子の使用
var o = {
  set value(val) {
    this.anotherValue = val;
  },
};
o.value = 5;
console.log(o.value); // undefined
console.log(o.anotherValue); // 5

// Object.defineProperty の使用
var o = {};
Object.defineProperty(o, "value", {
  set: function (val) {
    this.anotherValue = val;
  },
});
o.value = 5;
console.log(o.value); // undefined
console.log(o.anotherValue); // 5
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.prototype.\_\_defineSetter\_\_ |

ブラウザーの互換性
---------

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

関連情報
----

* `Object.prototype.__defineSetter__` のポリフィルは `core-js` で利用できます。
* `Object.prototype.__defineGetter__()`
* `set` 演算子
* `Object.defineProperty()`
* `Object.prototype.__lookupGetter__()`
* `Object.prototype.__lookupSetter__()`
* JavaScript ガイド: ゲッターとセッターの定義
* [Blog Post] Deprecation of \_\_defineGetter\_\_ and \_\_defineSetter\_\_
* Firefox バグ 647423
Object() コンストラクター
=================

**`Object` コンストラクター**は、与えられた値のオブジェクトラッパーを生成します。

* その値が `null` または `undefined` である場合、空のオブジェクトを生成して返します。
* そうでない場合は、与えらえた値に対応する型のオブジェクトを返します。
* 値がすでにオブジェクトであった場合は、その値を返します。

コンストラクターではない場面で `Object` が呼び出された場合は、 `new Object()` と同様に動作します。

構文
--


```js
new Object();
new Object(value);
```

### 引数

`value`

任意の値。

例
-

### 新しい Object の生成


```js
let o = new Object();
o.foo = 42;

console.log(o);
// Object { foo: 42 }
```

### `undefined` や `null` 型を指定して `Object` を使用

以下の例は、空の `Object` オブジェクトを `o` に格納します。


```js
let o = new Object();
```



```js
let o = new Object(undefined);
```



```js
let o = new Object(null);
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-object-constructor |

ブラウザーの互換性
---------

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

関連情報
----

* オブジェクト初期化子
Int16Array() コンストラクター
=====================

**`Int16Array()`** は型付き配列のコンストラクターで、プラットフォームのバイト順による 2 の補数形式の 16 ビット符号付き整数値の配列を生成します。バイト順の制御が必要な場合は、代わりに `DataView` を使用してください。中身は `0` で初期化されます。生成されると、配列の中の要素はオブジェクトのメソッドを使用するか、配列の標準的な添字の構文を使用するか (すなわち、ブラケット構文を使用するか) して参照することができます。

構文
--
```

new Int16Array(); // new in ES2017
new Int16Array(length);
new Int16Array(typedArray);
new Int16Array(object);
new Int16Array(buffer [, byteOffset [, length]]);
```

### 引数

`length`

`length` 引数付きで呼び出されると、メモリ内に内部的な配列バッファーを作成し、大きさは `length` *を `BYTES_PER_ELEMENT`* で乗じたバイト数になり、ゼロになることもあります。

`typedArray`

`typedArray` 引数付きで呼び出されると、これはあらゆる型付き配列型 (例えば `Int32Array`) にすることができますが、 `typedArray` を新しい型付き配列にコピーします。 `typedArray` の中のそれぞれの値は、新しい配列にコピーされる前にコンストラクターの対応する型に変換されます。新しい型付き配列の長さは `typedArray` 引数の長さと同じになります。

`object`

`object` 引数付きで呼び出されると、あたかも `TypedArray.from()` メソッドであるかのように新しい型付き配列が生成されます。

`buffer`, `byteOffset`, `length`

`buffer` と、オプションで `byteOffset` と `length` 引数を指定して呼び出されると、指定された `ArrayBuffer` を表示する型付き配列ビューが生成されます。 `byteOffset` および `length` 引数は、型付き配列ビューが表示するメモリ範囲を指定する。 両方を省略した場合は `buffer` の全てを表示し、 `length` のみを省略した場合は `buffer` の残りを表示します。

例
-

### 様々な方法による Int16Array の生成


```js
// From a length
var int16 = new Int16Array(2);
int16[0] = 42;
console.log(int16[0]); // 42
console.log(int16.length); // 2
console.log(int16.BYTES\_PER\_ELEMENT); // 2

// From an array
var arr = new Int16Array([21, 31]);
console.log(arr[1]); // 31

// From another TypedArray
var x = new Int16Array([21, 31]);
var y = new Int16Array(x);
console.log(y[0]); // 21

// From an ArrayBuffer
var buffer = new ArrayBuffer(8);
var z = new Int16Array(buffer, 0, 4);

// From an iterable
var iterable = (function\* () {
  yield\* [1, 2, 3];
})();
var int16 = new Int16Array(iterable);
// Int16Array[1, 2, 3]
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-typedarray-constructors |

ブラウザーの互換性
---------

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

### 互換性メモ

ECMAScript 2015 から、 `Int16Array` コンストラクターは構築に `new` 演算子が必要になりました。 `Int16Array` コンストラクターを `new` なしで関数として呼び出すと、 `TypeError` が発生するようになりました。


```js
var dv = Int16Array([1, 2, 3]);
// TypeError: calling a builtin Int16Array constructor
// without new is forbidden
```



```js
var dv = new Int16Array([1, 2, 3]);
```

関連情報
----

* JavaScript 型付き配列
* `ArrayBuffer`
* `DataView`
TypeError() コンストラクター
====================

**`TypeError()`** コンストラクターは、演算が実行できなくなった時の新しいエラーを生成します。特に値が期待された型ではなかった場合です (ただし、それに限りません)。

構文
--
```

new TypeError([message[, fileName[, lineNumber]]])
```

### 引数

`message` 省略可

人間が読むためのエラーの説明です。

`fileName` 省略可

例外が発生したコードを含むファイルの名前です。

`lineNumber` 省略可

例外が発生したコードの行番号です。

例
-

### TypeError の捕捉


```js
try {
  null.f();
} catch (e) {
  console.log(e instanceof TypeError); // true
  console.log(e.message); // "null has no properties"
  console.log(e.name); // "TypeError"
  console.log(e.fileName); // "Scratchpad/1"
  console.log(e.lineNumber); // 2
  console.log(e.columnNumber); // 2
  console.log(e.stack); // "@Scratchpad/2:2:3\n"
}
```

### TypeError の生成


```js
try {
  throw new TypeError("Hello", "someFile.js", 10);
} catch (e) {
  console.log(e instanceof TypeError); // true
  console.log(e.message); // "Hello"
  console.log(e.name); // "TypeError"
  console.log(e.fileName); // "someFile.js"
  console.log(e.lineNumber); // 10
  console.log(e.columnNumber); // 0
  console.log(e.stack); // "@Scratchpad/2:2:9\n"
}
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-nativeerror-constructors |

ブラウザーの互換性
---------

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

関連情報
----

* `Error`
Int8Array() コンストラクター
====================

**`Int8Array()`** は型付き配列のコンストラクターで、 2 の補数形式の 8 ビット符号付き整数値の型付き配列を生成します。中身は `0` で初期化されます。生成されると、配列の中の要素はオブジェクトのメソッドを使用するか、配列の標準的な添字の構文を使用するか (すなわち、ブラケット構文を使用するか) して参照することができます。

構文
--
```

new Int8Array(); // new in ES2017
new Int8Array(length);
new Int8Array(typedArray);
new Int8Array(object);
new Int8Array(buffer [, byteOffset [, length]]);
```

### 引数

`length`

`length` 引数付きで呼び出されると、メモリ内に内部的な配列バッファーを作成し、大きさは `length` *を `BYTES_PER_ELEMENT`* で乗じたバイト数になり、ゼロになることもあります。

`typedArray`

`typedArray` 引数付きで呼び出されると、これはあらゆる型付き配列型 (例えば `Int32Array`) にすることができますが、 `typedArray` を新しい型付き配列にコピーします。 `typedArray` の中のそれぞれの値は、新しい配列にコピーされる前にコンストラクターの対応する型に変換されます。新しい型付き配列の長さは `typedArray` 引数の長さと同じになります。

`object`

`object` 引数付きで呼び出されると、あたかも `TypedArray.from()` メソッドであるかのように新しい型付き配列が生成されます。

`buffer`, `byteOffset`, `length`

`buffer` と、オプションで `byteOffset` と `length` 引数を指定して呼び出されると、指定された `ArrayBuffer` を表示する型付き配列ビューが生成されます。 `byteOffset` および `length` 引数は、型付き配列ビューが表示するメモリ範囲を指定する。 両方を省略した場合は `buffer` の全てを表示し、 `length` のみを省略した場合は `buffer` の残りを表示します。

例
-

### 様々な方法による Int8Array の生成


```js
// 長さの指定
var int8 = new Int8Array(2);
int8[0] = 42;
console.log(int8[0]); // 42
console.log(int8.length); // 2
console.log(int8.BYTES\_PER\_ELEMENT); // 1

// 配列から
var arr = new Int8Array([21, 31]);
console.log(arr[1]); // 31

// 他の型付き配列から
var x = new Int8Array([21, 31]);
var y = new Int8Array(x);
console.log(y[0]); // 21

// ArrayBuffer から
var buffer = new ArrayBuffer(8);
var z = new Int8Array(buffer, 1, 4);

// 反復可能オブジェクトから
var iterable = (function\* () {
  yield\* [1, 2, 3];
})();
var int8 = new Int8Array(iterable);
// Int8Array[1, 2, 3]
```

仕様書
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-typedarray-constructors |

ブラウザーの互換性
---------

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

### 互換性メモ

ECMAScript 2015 から、 `Int8Array` コンストラクターは構築に `new` 演算子が必要になりました。 `Int8Array` コンストラクターを `new` なしで関数として呼び出すと、 `TypeError` が発生するようになりました。


```js
var dv = Int8Array([1, 2, 3]);
// TypeError: calling a builtin Int8Array constructor
// without new is forbidden
```



```js
var dv = new Int8Array([1, 2, 3]);
```

関連情報
----

* JavaScript 型付き配列
* `ArrayBuffer`
* `DataView`
Math.LOG2E
==========

**`Math.LOG2E`** プロパティは 2 を底とした e の対数、約 1.442 を表します。


Math.LOG2E

=

log
2

(
e
)
≈
1.442

\mathtt{\mi{Math.LOG2E}} = \log\_2(e) \approx 1.442

試してみましょう
--------

| `Math.LOG2E` のプロパティ属性 |
| --- |
| 書込可能 | 不可 |
| 列挙可能 | 不可 |
| 設定可能 | 不可 |

解説
--

`LOG2E` は `Math` オブジェクトの静的プロパティなので、 `Math` オブジェクトを生成してプロパティとして使用するのではなく、常に `Math.LOG2E` として使用するようにしてください (`Math` はコンストラクターではありません)。

例
-

### Math.LOG2E の使用

以下の関数は、2 を底とした e の対数を返します。


```js
function getLog2e() {
  return Math.LOG2E;
}

getLog2e(); // 1.4426950408889634
```

仕様書
---

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

ブラウザーの互換性
---------

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

関連情報
----

* `Math.exp()`
* `Math.log()`
* `Math.log2()`
Math.sqrt()
===========

**`Math.sqrt()`** 関数は、ある数の平方根を返します。すなわち、



∀
x
≥
0
,

M
a
t
h
.
s
q
r
t
(
x
)

=

x

=
the unique

y
≥
0

such that

y
2

=
x

\forall x \geq 0, \mathtt{Math.sqrt(x)} = \sqrt{x} = \text{the unique} ; y \geq 0 ; \text{such that} ; y^2 = x

試してみましょう
--------

構文
--
```

Math.sqrt(x)
```

### 引数

`x`

数値です。

### 返値

与えられた数値の平方根です。数値が負の場合、 `NaN` を返します。

解説
--

`x` の値が負の数であった場合、 `Math.sqrt()` は `NaN` を返します。

`sqrt()` は `Math` の静的メソッドであるため、生成した `Math` オブジェクトのメソッドとしてではなく、常に `Math.sqrt()` として使用するようにしてください (`Math` はコンストラクターではありません)。

例
-

### Math.sqrt() の使用


```js
Math.sqrt(9); // 3
Math.sqrt(2); // 1.414213562373095

Math.sqrt(1); // 1
Math.sqrt(0); // 0
Math.sqrt(-1); // NaN
Math.sqrt(-0); // -0
```

仕様書
---

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

ブラウザーの互換性
---------

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

関連情報
----

* `Math.cbrt()`
* `Math.exp()`
* `Math.log()`
* `Math.pow()`
Math.min()
==========

**`Math.min()`** は静的関数で、引数で渡されたもののうち最小の値を返します。または引数のいずれかが数値以外で、数値に変換できない場合は `NaN` を返します。

試してみましょう
--------

構文
--
```

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

### 引数

`value1, value2, ...`

最小値が選択して返される 0 個以上の数値です。

### 返値

与えられた数のうちの最小の値です。1 つ以上の引数を数値に変換することができなかった場合は `NaN` を返します。引数が与えられなかった場合の結果は `Infinity` です。

解説
--

`min()` は `Math` の静的メソッドなので、常に `Math.min()` として使用し、自分で `Math` オブジェクトを生成してそのメソッドとして使用しないでください。 (`Math` にはコンストラクターがありません)。

引数が与えられなかった場合の結果は `Infinity` です。

1 つでも数値に変換できない引数が渡された場合、結果は `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()`** 関数は、入力引数として与えられた 0 個以上の数値のうち最大の数を返します。引数がなかった場合は -`Infinity` を返します。

試してみましょう
--------

構文
--


```js
Math.max()
Math.max(value0)
Math.max(value0, value1)
Math.max(value0, value1, /\* … ,\*/ valueN)
```

### 引数

`value1`, `value2`, … , `valueN`

最大値を選択して返すための、 0 個以上の数値です。

### 返値

与えられた数のうちの最大の値です。何れかの引数が `NaN` であるか、それに変換された場合は `NaN` を返します。引数が与えられなかった場合は -`Infinity` を返します。

解説
--

`max()` は `Math` の静的メソッドですので、生成した `Math` オブジェクトのメソッドとしてではなく、常に `Math.max()` として使用してください（`Math` はコンストラクターではありません）。

`Math.max.length` は 2 であり、最低でも 2 つの引数を処理するよう設計されていることを示唆しています。

例
-

### Math.max() の使用


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

### 配列の最大値の取得

`Array.prototype.reduce()` を使用して、数値の配列の中にある最大値の要素を、それぞれの値を比較して探し出すことができます。


```js
const arr = [1, 2, 3];
const max = arr.reduce((a, b) => Math.max(a, b), -Infinity);
```


次の関数では `Function.prototype.apply()` を使用して配列の最大値を取得します。 `getMaxOfArray([1, 2, 3])` は `Math.max(1, 2, 3)` と同等ですが、 `getMaxOfArray()` はプログラム的に構築された配列に使用することができます。これは比較的要素が少ない配列に対して使用してください。


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


新しいスプレッド構文で、 `apply` によって配列の最大値を得る方法をより短く書くことができます。


```js
const arr = [1, 2, 3];
const max = Math.max(...arr);
```


しかし、スプレッド構文の (`...`) と `apply` のどちらも、配列に膨大な要素があった場合は、配列の要素を関数の引数として渡そうとするため、失敗したり、誤った結果を返したりすることがあります。詳しくは apply を組み込み関数と共に利用するを参照してください。 `reduce` の方法はこの問題が発生しません。

仕様書
---

| 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.cosh()
===========

**`Math.cosh()`** 関数は、引数として与えた数の双曲線余弦 (ハイパーボリックコサイン) を返します。これは定数 e を使用して次のように表すことができます。


Math.cosh(x)

=

e
x

+

e

-
x

2

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

試してみましょう
--------

構文
--
```

Math.cosh(x)
```

### 引数

`x`

数値。

### 返値

指定された数値の双曲線余弦 (ハイパーボリックコサイン) です。

解説
--

`cosh()` は `Math` の静的メソッドであるため、生成した `Math` オブジェクトのメソッドとしてではなく、常に `Math.cosh()` として使用するようにしてください (`Math` はコンストラクターではありません)。

例
-

### Math.cosh() の使用


```js
Math.cosh(0); // 1
Math.cosh(1); // 1.5430806348152437
Math.cosh(-1); // 1.5430806348152437
```

ポリフィル
-----

これは `Math.exp()` 関数を使用して次のようにエミュレートできます。


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


または `Math.exp()` 関数を一度だけ呼び出すようにすると、次のようになります。


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

仕様書
---

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

ブラウザーの互換性
---------

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

関連情報
----

* `Math.acosh()`
* `Math.asinh()`
* `Math.atanh()`
* `Math.sinh()`
* `Math.tanh()`
Math.atan()
===========

**`Math.atan()`** 関数は、引数として与えた数値のアークタンジェントをラジアン単位で返します。



Math.atan
(
x
)

=
arctan
(
x
)
=
 the unique 

y
∊

[

-

π
2

;

π
2

]

such that

tan
(
y
)
=
x

\mathtt{\operatorname{Math.atan}(x)} = \arctan(x) = \text{ the unique } ; y \in \left[-\frac{\pi}{2}; \frac{\pi}{2}\right] , \text{such that} ; \tan(y) = x

試してみましょう
--------

構文
--
```

Math.atan(x)
```

### 引数

`x`

数値です。

### 返値

与えられた数値のアークタンジェント (ラジアン単位) です。

解説
--

`Math.atan()` メソッドは 


-

π
2

-\frac{\pi}{2}

 から 


π
2

\frac{\pi}{2}

 までのラジアンの数値を返します。

`atan()` は `Math` の静的メソッドであるため、生成した `Math` オブジェクトのメソッドとしてではなく、常に `Math.atan()` として使用するようにしてください (`Math` はコンストラクターではありません)。

例
-

### Math.atan() の使用


```js
Math.atan(1); // 0.7853981633974483
Math.atan(0); // 0
Math.atan(-0); // -0

Math.atan(Infinity); // 1.5707963267948966
Math.atan(-Infinity); // -1.5707963267948966

// The angle that the line [(0,0);(x,y)] forms with the x-axis in a Cartesian coordinate system
Math.atan(y / x);
```


様式上の理由から **±**`Infinity` の使用を避けたいと思うことがあるかもしれません。その場合、 `Math.atan2()` を第二引数を `0` としてを使うとよりよいかもしれません。

仕様書
---

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

ブラウザーの互換性
---------

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

関連情報
----

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

**`Math.cos()`** は静的関数で、指定された角度の余弦 (コサイン) を返します。ここで角度はラジアンで指定します。この値は 


length

adjacent


length

hypotenuse


 です。

試してみましょう
--------

構文
--
```

Math.cos(x)
```

### 引数

`x`

余弦を返すラジアンの角度。

### 返値

与えられた数値の余弦 (コサイン) です。

解説
--

`Math.cos()` メソッドはラジアンで指定された角度の余弦 (コサイン) を表す -1 から 1 までの範囲の数値を表します。

`cos()` は `Math` の静的メソッドであるため、生成した `Math` オブジェクトのメソッドとしてではなく、常に `Math.cos()` として使用するようにしてください (`Math` はコンストラクターではありません)。

例
-

### Math.cos() の使用


```js
Math.cos(0); // 1
Math.cos(1); // 0.5403023058681398

Math.cos(Math.PI); // -1
Math.cos(2 \* Math.PI); // 1
```

仕様書
---

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

ブラウザーの互換性
---------

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

関連情報
----

* `Math.acos()`
* `Math.asin()`
* `Math.atan()`
* `Math.atan2()`
* `Math.sin()`
* `Math.tan()`