ECMAScript proposal updates @ 2020-07 の簡単な要約

# これは何

[ECMAScript proposal updates @ 2020-07 | ECMAScript Daily][ecmascript-2020-07-26] の簡単な要約です。次の JavaScript バージョンに加わる可能性のある新文法、新メソッド、新クラスがまとめられています。

正確・詳細な内容を知りたい方はリンク先をあたってください。そこまでするほどではないけどざっくり知りたい、という方向けです。

[ecmascript-2020-07-26]: https://ecmascript-daily.github.io/ecmascript/2020/07/26/ecmascript-proposal-update

### New Proposals

| Proposal                                                           | Stage |
| :----------------------------------------------------------------- | :---- |
| [Import Conditions][import-conditions]                             | 2     |
| [WeakRefs `cleanupSome`][weak-refs-cleanup-some]                   | 2     |
| JSON Modules - [Note][json-modules-note]                           | 2     |
| [await operations][await-operations]                               | 1     |
| [`Array.prototype.unique()`][array-prototype-unique]               | 1     |
| [ResizableArrayBuffer and GrowableSharedArrayBuffer][array-buffer] | 1     |

[import-conditions]: https://github.com/tc39/proposal-import-conditions
[weak-refs-cleanup-some]: https://github.com/codehag/proposal-cleanup-some
[json-modules-note]: https://github.com/tc39/proposal-import-assertions/issues/86
[await-operations]: https://github.com/Jack-Works/proposal-await.ops
[array-prototype-unique]: https://github.com/TechQuery/array-unique-proposal
[array-buffer]: https://github.com/syg/proposal-resizablearraybuffer

### Updated Proposals

| Proposal                                                       | From | To  |
| :------------------------------------------------------------- | :--- | :-- |
| [`Promise.any`][promise-any]                                   | 3    | 4   |
| [WeakRefs][weak-refs]                                          | 3    | 4   |
| [Logical Assignment Operators][logical-assignment-operators]   | 3    | 4   |
| [Numeric separators][numeric-separators]                       | 3    | 4   |
| [`.item()`][item]                                              | 1    | 2   |
| [Record & Tuple][record-and-tuple]                             | 1    | 2   |
| [JSON.parse source text access][json-parse-source-text-access] | 1    | 2   |

[promise-any]: https://github.com/tc39/proposal-promise-any
[weak-refs]: https://github.com/tc39/proposal-weakrefs
[logical-assignment-operators]: https://github.com/tc39/proposal-logical-assignment
[numeric-separators]: https://github.com/tc39/proposal-numeric-separator
[item]: https://github.com/tabatkins/proposal-item-method
[record-and-tuple]: https://github.com/tc39/proposal-record-tuple
[json-parse-source-text-access]: https://github.com/tc39/proposal-json-parse-with-source

# New Proposals

## [Import Conditions][import-conditions]

JSON modules の import にアサーションが書けるようになります。

```js
import json from "./foo.json" assert { type: "json" };
```

`foo.json` が実際は JSON ではなかったときに、意図しないスクリプトを実行してしまうセキュリティ問題を防ぐためのようです。ファイルタイプを表すため慣例的に拡張子が使われているものの、本来 Web は拡張子という概念のない世界だから MIME Type とのミスマッチを明示的にすべき、らしいです。

アプリコードを書くときには煩わしいので、Babel や TypeScript による自動付与、VS Code による補完がどうなるか気になります。

## [WeakRefs `cleanupSome`][weak-refs-cleanup-some]

WeakRefs がわかっていないのでわからない :innocent:

ガベージコレクションの話なので、よほど性能チューニングしたいときにしか使わなそう。

## JSON Modules - [Note][json-modules-note]

Import のアサーションと JSON modules の話は分けるべきでは？という議論。結論までちゃんと読んでないです。

## [await operations][await-operations]

`Promise.all()` などが書きやすくなります。

```js
// before
await Promise.all(users.map(async x => fetchProfile(x.id)));

// after
await.all users.map(async x => fetchProfile(x.id));
```

`all` のほか `race`, `allSettled`, `any` も。

## [`Array.prototype.unique()`][array-prototype-unique]

配列の重複を除くメソッドが使えるようになります。

```js
const data = [
  { id: 1, uid: 10000 },
  { id: 2, uid: 10000 },
  { id: 3, uid: 10001 },
];

data.unique("uid");
// [
//   { id: 2, uid: 10000 },
//   { id: 3, uid: 10001 }
// ]

data.unique(({ id, uid }) => `${id}-${uid}`);
// [
//   { id: 1, uid: 10000 },
//   { id: 2, uid: 10000 },
//   { id: 3, uid: 10001 }
// ]
```

現時点でも `[...new Set(array)]` によって配列の重複は除けますが、プリミティブ型でない値には使えません。その点を補います。

一方で、Record & Tuple によってオブジェクト的な値の同値性チェックが簡単になれば、プリミティブ型でない値にも使えるというメリットは薄まりそうです。メソッド名がわかりやすいので追加されること自体はよいことです。

## [ResizableArrayBuffer and GrowableSharedArrayBuffer][array-buffer]

ArrayBuffer の派生クラスが増えます。

```js
let rab = new ResizableArrayBuffer(1024, 1024 ** 2);
rab.resize(1024 * 2);
```

既存の ArrayBuffer は、領域を拡大するにはバッファーコピーが必要で非効率的だし、32-bit システムではアドレス空間のフラグメント化が生じるから、サイズ可変なこれらが欲しいとのこと。

あまり ArrayBuffer を使わないのでわかりませんが、動画のような巨大なバイナリ処理が効率化できるということでしょうか。

# Updated Proposals

## [`Promise.any`][promise-any]

複数の promise のうちの一つが解決するまで待つ promise を作れます。

```js
try {
  const first = await Promise.any(promises);
  // Any of the promises was fulfilled.
} catch (error) {
  // All of the promises were rejected.
}
```

`Promise.race([a, b, c])` は `a`, `b`, `c` のどれか一つが **解決 or 拒否（失敗）** すると解決 or 拒否します。`Promise.any([a, b, c])` は `a`, `c` が拒否しても `b` が **解決** するまで待って、`b` が解決したら解決、全部拒否したら拒否になります。

3 社の広告（接続先すべて別）のうちどれか一つを表示できればよい、といったケースで役に立ちそう？

## [WeakRefs][weak-refs]

わからない :innocent:

ガベージコレクション (GC) の話なので、よほど性能チューニングしたいときにしか使わなそう。iOS アプリなどと違って Web はページ単位のライフサイクルで、GC タイミングが多いはず（感覚です）。とはいえ Web の高機能化に伴って、明示的なメモリー管理も必要になるかもしれません。

## [Logical Assignment Operators][logical-assignment-operators]

論理演算子も代入書式が使えるようになります。

```js
opts.baz ??= "qux";

// eq
opts.baz ?? (opts.baz = "qux");
```

`i = i + 1` を `i += 1` と書くようなものです。デフォルトオプションを設定するのに役立ちそう。`||=`, `&&=`, `??=` の 3 種類あります。

TypeScript 4.0 Beta ですでに導入されているようです (https://devblogs.microsoft.com/typescript/announcing-typescript-4-0-beta/)

## [Numeric separators][numeric-separators]

数値の桁をアンダースコア `_` で区切れるようになります。

```js
101_475_938.38 === 101475938.38;
```

すでにこう書けます（Chrome 84 や Node 13）が、仕様として定まっていないところがあったということでしょうか。ちゃんと読んでいないです。

## [`.item()`][item]

N 番目の要素を取得するとき、負の値を指定できるようになります。

```js
["a", "b", "c"].item(-1) === "c";
```

Array, String, TypedArray にメソッドが追加されます。`[]` を使わないのは、それが配列インデックスだけでなくオブジェクトのプロパティを指定するときにも使われるためです。`arr[-1]` という書き方は現状可能ですが、`arr["-1"]` と書いたことになってしまいます。それらの区別をつけるため、明示的にメソッドを追加するようです。

## [Record & Tuple][record-and-tuple]

イミュータブルな構造体として Record と Tuple が使えるようになります。

```js
// Record
const doc = #{
  id: 123,
  title: "foo",
};

doc.title === "foo";

// Tuple
const m = #["x", "y", "z"];

m[1] === "y";
```

Record はオブジェクトのような構造体、Tuple は配列のような構造体です。TypeScript はすでに `as const` キーワードによってイミュータブルな構造体を表せますが、JS としても同様のことが可能になります。

一方 TypeScript でも実現できていない点として、同値性の評価があります。イミュータブルなので、中の構成が一緒なら同値であると評価するようです。

```js
// non-Record
assert({ x: 1, y: 2 } !== { x: 1, y: 2 });

// Record
assert(#{ x: 1, y: 2 } === #{ x: 1, y: 2 });
```

プリミティブ型のようにイミュータブルかつ比較も簡単な値に、オブジェクトと同じ情報量を持たせられるのは強力です。

## [JSON.parse source text access][json-parse-source-text-access]

`JSON.parse` のパーサーロジックを拡張できるようになります。

ちゃんと読んでいないです。