React入門！！の前に知っておきたいNode.jsとJavaScriptの知識

## 対象読者とこの記事から何が得られるのか

そろそろReactの勉強をはじめてみたい、勉強したいと思っているけど、以下のようなことを考えて前に進めない方向けの記事です。

* JavaScriptの知識レベルはこれくらいで足るのか？
* 他に知っておくことはないのかな？

この記事を読むことでReact入門の前に知っておきたいNode.jsとJavaScriptの知識を得ることができると思います。

## Node.jsをざっと知る
### Node.jsを簡単に言うと

JavaScriptをブラウザではなくPythonやRubyなどと同じようにターミナル上で動かすことができるようにするための実行環境のことであり、バックエンド言語としてJavaScriptを使うことができ、ファイル操作などのOSの機能にアクセスできます。

公式ページだと以下のように記載されています。

>Node.js はスケーラブルなネットワークアプリケーションを構築するために設計された非同期型のイベント駆動の JavaScript 環境です。

Node.jsが注目を浴びたのはC10K問題の解決策である（イベント駆動により大量のリクエストを同時に処理できるスケーラビリティを備えている・ノンブロッキングI/Oモデルを採用しており、I/Oの処理を待たずに次の処理を始めることができるので、大量のデータ処理が可能）というのが理由です。またバックエンドも同じ言語（JavaScript）で書けたら効率的ではないかというのも理由の一つです。フロントエンド開発はJavaScriptほぼ一択ということもあり、こういう流れになったのではないかと思います。

### なぜReactアプリ開発でNode.jsが必要なのか

ではなぜバックエンド開発のために開発されたNode.jsがReactアプリ（フロントエンド）開発で必要になってきたのでしょうか。

Reactのような大規模なアプリケーションを開発するとなると、様々なパッケージが必要になり、そのパッケージたちが特定のバージョンで依存しあっています。Node.jsはそのパッケージのインストールと整合性の管理を解決するために必要であり、npm(Node Package Manager)がその解決を担っています。

もともとはバックエンド開発のためにnpmは使われるパッケージ管理システムであったが、フロントエンド用のパッケージを提供するのにも使われるようになり、最近では使用用途としてはフロントエンドのほうが多くなってきているそうです。

その他以下のような用途でも使われます。

* JavaScriptやCSSファイルをバンドルできる
* ブラウザ実行時にpolyfill※するのではなく 最初からコンパイルしておける
* ローカル環境で開発用のHTTPサーバを起動してアプリケーションを稼働させることができる
* ユニットテストやE2Eテストなどのテストを実行できる
* ローカル環境で構文解析等実行できる

※polyfillとは最近の機能をサポートしていない古いブラウザーで、その機能を使えるようにするためのコードです。

### Node.jsをインストール

公式サイトからインストールしたり、MacならHomebrew・Windowsならwingetなどでインストールできますが、プロジェクトごとに異なるバージョンの環境を共存させる必要があるので、バージョンマネージャー（nvmやnodenv）を使ってインストールしましょう。

### Node.jsでプロジェクト作成

作成したいディレクトリに移動してターミナルで以下コマンドでプロジェクトを作成できます。  
対話形式でプロジェクト名など聞かれますので、全て入力するとpackage.jsonが作成されます。

```
$ npm init
```

`-y`をつければ、全てデフォルトのままプロジェクト作成できます。

```
$ npm init -y
```
### npm-scripts

package.jsonのscriptsに記載されているコマンドを以下で実行できます。

```
$ npm run xxx
```

では試しにnpm-scriptsでプログラムを実行してみましょう。
まず`index.js`を作成する。

```js:index.js
console.log("Hello World!!");
```

package.jsonに`start`でのコマンドを追加する。
node.jsでは`node`+`ファイル名` でそのファイルのプログラムを実行できます。

```json
"scripts": {
  "start": "node index.js"
}
```

以下コマンドで実行する。

```
$ npm run start
```

以下出力されれば成功です。

```
Hello World!!
```

start,stop,restart,testの場合は`run`を省略して実行できます。

```
$ npm start
```

Reactアプリ開発ではcreate-react-appというコマンドで新規プロジェクトが作成できますが、こちらで作られたプロジェクトだと以下が記載されています。たとえば`npm run start`を実行すると`react-scripts start`が実行され、ローカル環境でReactアプリが起動できます。`react-scripts`はcreate-react-appで作られたプロジェクトの中でBabelやwebpackなどが裏で動かすことができます。

```json
"scripts": {
  "start": "react-scripts start",
  "build": "react-scripts build",
  "test": "react-scripts test",
  "eject": "react-scripts eject"
},
```

### Yarnとは

npmコマンドのFacebookによる改良版で記述が短い・実行が速いなどのメリットがある。
Yarnがグローバルインストールされていた場合はCreate React App使用時にyarnがデフォルトになるので、npmコマンドを使いたいなら`--use-npm`オプションを指定しましょう。

### Yarnのコマンド

* yarn (install) はプロジェクトのルートディレクトリに存在するpackage.jsonの内容を参照して、依存関係のあるパッケージをすべてインストールする
* yarn add xxx で指定したパッケージをインストールする 
* yarn remove xxx で指定したパッケージをアンインストールする 
* yarn upgrade xxx で指定したパッケージを最新バージョンに更新する 
* yarn info xxx で指定したパッケージの情報を表示する

上記の`npm run xxx`は以下コマンドで同じことができます。

```
yarn xxx
```

## JavaScriptをざっと知る
### 変数宣言について

* varは再宣言も再代入も可。スコープはブロックをすり抜ける。
* letは再代入のみ可。スコープはブロック内。
* constはどちらも不可。スコープはブロック内。

constを第一選択肢として、どうしても仕方ない場合のみletを使う。
varは使用しないようにしましょう。

```js
var name1 = "瀬戸熊";
name1 = "佐々木"      // 再代入可
var name1 = "滝沢"    // 再宣言可

let name2 = "瀬戸熊";
name2 = "佐々木"      // 再代入可
let name2 = "滝沢"    // 再宣言不可：'name2' has already been declared

const name3 = "瀬戸熊";
name3 = "佐々木"      // 再代入不可："name3" is read-only
const name3 = "滝沢"  // 再宣言不可：'name3' has already been declared
```

スコープに関してもvarを使うと以下のようになり、安全ではないのでletやconstを使うべきである。

```js
var name1 = "高宮";
if (true) {
  var name1 = "二階堂";
  var name2 = "魚谷";
  console.log(name1); // 二階堂
  console.log(name2); // 魚谷
}
console.log(name1); // 二階堂（ブロック内でも書き換え可能なので危険）
console.log(name2); // 魚谷（ブロック内で定義したものがブロック外でも参照できる）
```

letだとブロック内で書き換えや定義しても、ブロック外に影響を与えない。

```js
let name1 = "高宮";
if (true) {
  let name1 = "二階堂";
  let name2 = "魚谷";
  console.log(name1); // 二階堂
  console.log(name2); // 魚谷
}
console.log(name1); // 高宮
console.log(name2); // name2 is not defined
```

### データ型について

#### プリミティブ型

以下7種類ある。

* Boolean型
* Number型
* BigInt型
* String型
* Symbol型
* Null型
* Undefined型

#### falsyな値

MDNによると、falsyとは偽値 (falsy または falsey な値) は、 Boolean コンテキストに現れたときに偽とみなされる値です。

以下8種類あります。

* false
* 0
* -0
* 0n
* Nan
* ""（空文字）
* null
* undefined

以下はifブロックを実行しません。

```js
if (false){}
if (null){}
if (undefined){}
if (0){}
if (-0){}
if (0n){}
if (NaN){}
if (""){}
```



### 関数

#### 関数宣言文と関数式

定義の方法は関数宣言文による定義と関数式による定義があるがconstを使った`関数式`による定義が推奨されています。
無名関数は定義時に名前を与えられない関数のことで、関数式は変数に無名関数を入れているようなもの。
変数に関数式を代入することになるので、関数宣言文と違って先に定義しておかないと使えません。  

```js
// 関数宣言文による定義
function Introduce1(name) {
  return `私の名前は${name}です。`
} 
// 関数式による定義 
const Introduce2 = function (name) {
  return `私の名前は${name}です。`
};
```

#### アロー関数

アロー関数は引数が一つだと括弧の省略ができる。（推奨はされていないらしいが・・・）
また、retern文が1行だとreturnも省略できます。

```js
// アロー関数式
const Introduce3 = (name) => {
  return `私の名前は${name}です。`
};
// アロー関数式、さらに省略記法
const Introduce4 = name => `私の名前は${name}です。`;
```
#### デフォルト引数

デフォルト値が設定された引数は省略が可能。
以下の例では第二引数を省略すると`age`が18で代用される。

```js
const Introduce5 = (name, age = 18) => `私の名前は${name}です。${age}歳です。`;
console.log(Introduce5("白鳥", 32)); // 私の名前は白鳥です。32歳です。
console.log(Introduce5("松本")); // 私の名前は松本です。18歳です。
```
#### Rest Parameters

最後の引数に...を付けることで残りの引数を配列として受け取れる。

```js
const Names = (name1, name2, ...rest) => {
  console.log(name1);   // 瀬戸熊
  console.log(name2);   // 佐々木
  console.log(rest);    // ["滝沢","二階堂","高宮"]
};
Names('瀬戸熊', '佐々木', '滝沢', '二階堂', '高宮');
```
### Reactで開発する上で良く使う構文

#### プロパティ名のショートハンド

プロパティのキー名と値を同じにする。

```js
const name = "瀬戸熊";
const obj = { name };　　// = const obj = { name: name };
console.log(obj); // { name: "瀬戸熊" }
```

#### 分割代入

配列とオブジェクトの値を分割して代入する。

```js
const data = [180, 70]
const [height, weight] = data;
console.log(`私の身長は${height}cmで、体重は${weight}kgです。 `); // 私の身長は180cmで、体重は70kgです。

const user = { name: "瀬戸熊", age: 50 };
const { name, age } = user;
console.log(`私の名前は${name}です。${age}歳です。`); // 私の名前は瀬戸熊です。50歳です。
```

#### スプレッド構文

```js
const names1 = ["瀬戸熊", "佐々木", "滝沢"];
const names2 = [...names1, "二階堂", "高宮"];
console.log(names2); // [ "瀬戸熊","佐々木","滝沢","二階堂","高宮" ]

const users1 = { name: "瀬戸熊", age: 48, sex: "男" };
const users2 = { ...users1, group: "renmei", grade: "A1" };
console.log(users2); // { name: "瀬戸熊", age: 50, sex: "男", group: "renmei", grade: "A1" }
```
#### オブジェクトのコピー

分割代入を用いてオブジェクトをコピーできます。  
しかし、こちらはシャローコピーと言ってオブジェクトの深さが1段階までしか有効ではない。

オブジェクトの深さが2段階目の値を変更すると、コピー元の値まで変更されてしまう。

```js
const user1 = { name: "瀬戸熊", age: 50, sex: "男" };
const user2 = { ...user1 };
console.log(user2); // { name: "瀬戸熊", age: 50, sex: "男" }
console.log(user2 === users1); // false

const user3 = { name: "瀬戸熊", age: 50, sex: "男", group: { group: "連盟", grade: "A1" } };
const user4 = { ...user3 };
console.log(user4);  // user4:  { name: '瀬戸熊', age: 50, sex: '男', group: { group: '連盟', grade: 'A1' } }
user4.group.group = "協会";
console.log(user3);  //　user3:  { name: '瀬戸熊', age: 50, sex: '男', group: { group: '協会', grade: 'A1' } }
console.log(user4);  // user4:  { name: '瀬戸熊', age: 50, sex: '男', group: { group: '協会', grade: 'A1' } }
```

完全なコピー（ディープコピー）の方法はいくつかあるが、JSONパースを用いる方法は以下の通り。  
プロパティにDateオブジェクトや関数が入ってた場合はうまく動かないので注意。  

```js
const user3 = { name: "瀬戸熊", age: 50, sex: "男", group: { group: "連盟", grade: "A1" } };
const user4 = JSON.parse(JSON.stringify(user3));
console.log(user4);  // user4:  { name: '瀬戸熊', age: 50, sex: '男', group: { group: '連盟', grade: 'A1' } }
user4.group.group = "協会";
console.log(user3);  //　user3:  { name: '瀬戸熊', age: 50, sex: '男', group: { group: '連盟', grade: 'A1' } }
console.log(user4);  // user4:  { name: '瀬戸熊', age: 50, sex: '男', group: { group: '協会', grade: 'A1' } }
```

他にはLodashのcloneDeep()を使う方法などある。

#### ショートサーキット評価（短絡評価）  

* || は左辺がfalsyな値だと評価が右辺に渡される。  
* ?? は左辺がnullかundefinedだと評価が右辺に渡される。  
* && は左辺がtruthyな値だと評価が右辺に渡される

|| はちょっと前に賛否ありましたが、一応よくでてくるので記載しておきます・・・。

```js
const name1 = '瀬戸熊';
const name2 = '佐々木';

true && console.log(name1); // 瀬戸熊
false && console.log(name1); // 出力なし
true || console.log(name2); // 出力なし
false || console.log(name2); // 佐々木
null ?? console.log(name2); // 佐々木
undifined ?? console.log(name2); // 佐々木
```

### 配列・オブジェクトの処理

#### map,filter,find,findIndex,every,some

```js
const dataset = [1, 2, 3, 4, 5, 6, 7, 8, 9];
console.log(dataset.map((data) => data * 3)); // [ 3, 6, 9, 12, 15, 18, 21, 24, 27 ]
console.log(dataset.filter((data) => data > 5)); // [ 6, 7, 8, 9 ]
console.log(dataset.find((data) => data > 5)); // 6
console.log(dataset.findIndex((data) => data > 5)); // 5
console.log(dataset.every((data) => data > 5)); // false
console.log(dataset.some((data) => data > 5)); // true
```

* map()：与えられた関数を配列のすべての要素に対して呼び出し、その結果からなる新しい配列を生成する。
* filter()：与えられた関数によって実装されたテストに合格したすべての配列からなる新しい配列を生成する。
* find()：提供されたテスト関数を満たす配列内の 最初の要素の値を返します。見つからなかった場合はundefinedを返す。
* findIndex()：配列内の指定されたテスト関数を満たす最初の要素の位置を返します。テスト関数を満たす要素がない場合を含め、それ以外の場合は-1 を返します。
* every()：配列内のすべての要素が指定された関数で実装されたテストに合格するかどうかを真偽値で返します。
* some()：配列の少なくとも一つの要素が、指定された関数で実装されたテストに合格するかどうかを真偽値で返します。

#### reduce,sort

* reduce():配列の各要素に対して (引数で与えられた) reducer関数を実行して、単一の出力値を生成します。
* sort(): 配列の要素をソートします。既定のソート順は昇順で、要素を文字列に変換してから、UTF-16コード単位の値の並びとして比較します。

```js
const dataset = [1, 2, 3, 4, 5, 6, 7, 8, 9];
console.log(dataset.reduce((a, b) => a + b)); // 45
console.log(dataset.sort((a, b) => a > b ? -1 : 1)); // [ 9, 8, 7, 6, 5, 4, 3, 2, 1 ]
```

#### forEach,for...of

* forEach():メソッドは与えられた関数を、配列の各要素に対して一度ずつ実行します。
* for...of:反復可能オブジェクトなどに対して、反復的な処理をするループを作成します。

本来なら使わないほうがいいが、どうしても使う場合はforEach推奨。

```js
const dataset = [1, 2, 3, 4, 5, 6, 7, 8, 9];
dataset.forEach((data) => {
  if (data % 2 === 0) {
    console.log(`${data}は偶数です。`);
  }
});
for (let data of dataset) {
  if (data % 2 === 0) {
    console.log(`${data}は偶数です`);
  }
}
```

#### includes

特定の要素が配列に含まれているかどうかを true または false で返します。

```js
const dataset = [1, 2, 3, 4, 5];
console.log(dataset.includes(1)); // true
console.log(dataset.includes(7)); // false
```

また、以下のような||演算子が繰り返し使われるコードを完結に書けます。

```js
if ( x === 'a' || x === 'b' || x === 'c' ) {
  console.log('ok')
}
if (['a', 'b', 'c'].includes(x)) {
  console.log('ok')
}
```
#### Object.keys,values,entries

* Object.keys():プロパティのキーのリストを配列で取得できる
* Object.values():プロパティ値のリストを配列で取得できる
* Object.entries():プロパティのキーと値が対になった2次元配列を取得できる

```js
const user = {
  id: 1,
  name: '瀬戸熊',
  age: 50,
};
console.log(Object.keys(user));
// [ 'id', 'name', 'age']

console.log(Object.values(user));
// [ 1, '瀬戸熊', 50 ]

console.log(Object.entries(user));
// [
//   [ 'id', 1 ],
//   [ 'name', '瀬戸熊' ],
//   [ 'age', 50 ],
// ]
```
### 非同期処理

#### Promise

PromiseはES2015から導入されたJavaScriptの組み込みオブジェクトで、非同期処理の最終的な完了処理 (もしくは失敗) およびその結果の値を表現するものであり、Promiseを使うことによって、非同期処理の完了を待って次の処理を行うというのがJavaScriptでも簡単（それ以前はコールバック関数で書くしかなかったので、連続して非同期処理を行う場合にコールバック地獄となる）にできるようになります。

以下例文

* 最初のresolve()に渡したものが.then()の引数のvalueになり、その.then()内でreturnしたものが次の.thenのvalueになる。
* reject()に渡したものが、errorとしてcatch()で受け取れる。
* finally()に渡された関数は必ず最後に実行される。(ES2018から)

```js
const promise = new Promise((resolve, reject) => {
  if (isSuccess) {
    resolve('成功1');
  } else {
    reject(new Error('失敗'));
  }
});
promise.then((value) => {
    console.log(value);
    return '成功2';
  })
  .then((value) => {
    console.log(value);
  })
  .catch((error) => {
    console.error(error);
  })
  .finally(() => {
    console.log('完了');
  });
```

axiosを使ってAPIをたたいてみる
async/awaitを使わない場合

```js
const getUser = (userId) => {
  return new Promise(function (resolve, reject) {
    axios
      .get(`https://jsonplaceholder.typicode.com/users/${userId}`)
      .then((response) => resolve(response.data))
      .catch((error) => reject(error.response.status));
  });
};

getUser(1)
  .then((user) => {
    console.log(user);
  })
  .catch((error) => {
    console.log(error);
  })
  .finally(() => {
  });
```

async/awaitを使った場合

関数宣言時にasyncキーワードを付与するとその関数は、返される値がPromise.resolve()によってラップされたものになる。  
asyncをつけた非同期関数内では他の非同期関数をawaitをつけて呼び出すことができる。

```js
const getUser2 = async (userId) => {
  try {
    const response = await axios.get(
      `https://jsonplaceholder.typicode.com/users/${userId}`
    );
    return response.data;
  } catch (error) {
    throw error.response.status;
  }
};
const main = async () => {
  try {
    const user = await getUser2(1);
    console.log(user);
  } catch (error) {
    console.error(error);
  } finally {
  }
};
main();
```

### モジュール

#### 名前付きエクスポート

1ファイルでいくらでもエクスポートできる。

```js:src/export.js
const NAME = "瀬戸熊";
const AGE = 50;
const Introduce = (name) => `私の名前は${name}です`
export { NAME, AGE, Introduce };

or

export const NAME = "瀬戸熊";
export const AGE = 50;
export const Introduce = (name) => `私の名前は${name}です`
```

名前付きエクスポートの場合は{}をつけてインポートする

```js:src/inport.js
import { NAME, AGE, Introduce } from "./export"
```
#### デフォルトエクスポート

1ファイル1回までしかエクスポートできない

```js:src/export.js
export const NAME = "瀬戸熊";
export const AGE = 50;
const Introduce = (name) => `私の名前は${name}です`
export default Introduce;
```

デフォルトエクスポートの場合は{}はつけないでインポートする。名前も自由に命名できる。

```js:src/inport.js
import Introduce, { NAME, AGE } from "./export"
```

## まとめ

React入門の前に知っておきたいNode.jsとJavaScriptの知識を簡単にまとめました。  
今回記載した項目が大体頭に入っていれば、Reactに入門してもよいのではないかと思います。

このほかにもクラスやthisの扱いなど学ぶべきものはいっぱいありますが、Reactが関数コンポーネント主体になってきたのであまり使わない印象があるので、一旦は飛ばしてもよいかと思い省略しました。（理解はしておいたほうがいいですが）

あとTypeScriptはReactでの開発においてマストなものになりつつあるので、早めにTypeScriptでReactを書けるように学んでいったほうがいいと思います。

間違っていたり、これも理解しておくべきなどありましたら、指摘していただけると幸いです。

最後まで読んでいただきありがとうございました！！

## 参考

### MDN

[Polyfill (ポリフィル)](https://developer.mozilla.org/ja/docs/Glossary/Polyfill)
[Falsy (偽値)](https://developer.mozilla.org/ja/docs/Glossary/Falsy)
[Array.prototype.map()](https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Global_Objects/Array/map)
[Array.prototype.filter()](https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Global_Objects/Array/filter)
[Array.prototype.find()](https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Global_Objects/Array/find)
[Array.prototype.findIndex()](https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Global_Objects/Array/findIndex)
[Array.prototype.every()](https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Global_Objects/Array/every)
[Array.prototype.some()](https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Global_Objects/Array/some)
[Array.prototype.reduce()](https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce)
[Array.prototype.sort()](https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Global_Objects/Array/sort)
[Array.prototype.includes()](https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Global_Objects/Array/includes)
[Promise](https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Global_Objects/Promise)
### Qiita

[Node.jsとはなにか？なぜみんな使っているのか？](https://qiita.com/non_cal/items/a8fee0b7ad96e67713eb)
[Promiseの使い方、それに代わるasync/awaitの使い方](https://qiita.com/suin/items/97041d3e0691c12f4974)

### りあクト
[りあクト！ TypeScriptで始めるつらくないReact開発 第3.1版【Ⅰ. 言語・環境編】](https://techbookfest.org/product/5436045076201472?productVariantID=6240785991204864)