javascriptを関数型で書く

## 概要

- javascriptを関数型で記述し、堅牢性・生産性を検証する
- クライアントサイドに絞ったテストのコード化の手法を説明する

参考：　　

- [JavaScript関数型プログラミング 複雑性を抑える発想と実践法を学ぶ [ISBN-13: 978-4295001133]](https://www.amazon.co.jp/dp/4295001139)　　
- [JavaScript Ninjaの極意 [ISBN-13: 978-4798128450]](https://www.amazon.co.jp/dp/4798128457)  
- [関数型プログラミングJavaScriptについて](https://qiita.com/sunnymerryAce/items/c7f4e2e8d3f0c7562ccb)
- [JavaScript関数型プログラミング Ch.1 関数型で思考する](https://wand-ta.hatenablog.com/entry/2019/01/06/230659)
- [JavaScript関数型プログラミング Ch.2 関数型言語としてのJavaScript](https://wand-ta.hatenablog.com/entry/2019/01/07/235438)
- [JavaScript関数型プログラミング Ch.3 データ構造の数を減らし、操作の数を増やす](https://wand-ta.hatenablog.com/entry/2019/01/08/124640)
- [JavaScript関数型プログラミング Ch.4 モジュール化によるコードの再利用](https://wand-ta.hatenablog.com/entry/2019/01/21/073936)
- [JavaScript関数型プログラミング Ch.5 複雑性を抑えるデザインパターン](https://wand-ta.hatenablog.com/entry/2019/01/22/090040)
- [JavaScript関数型プログラミング Ch.6 関数型コードのテスト](https://wand-ta.hatenablog.com/entry/2019/01/23/193340)
- [JavaScript関数型プログラミング Ch.7 関数型コードの最適化](https://wand-ta.hatenablog.com/entry/2019/01/24/210516)
- [JavaScript関数型プログラミング Ch.8 非同期イベント/データのための関数型手法](https://wand-ta.hatenablog.com/entry/2019/01/25/221140)

## メリット / デメリット

### メリット

- **コンテキストによりコロコロ変わるthisを極力使わないで済む**
- 関数チェーンの導入により、同期/非同期を *あまり* 意識しないでよい
- 予期せぬ挙動（副作用）を減少できる
- モジュール性の向上、関数の再利用促進が期待できる
- テストのコード化が容易となる
- 他の言語にも関数型の概念は取り入れられている　その理解の助けとなる  
    [CakePHP Collection型](https://book.cakephp.org/3/ja/core-libraries/collections.html)

### デメリット

- ES6サポート前提である
- リソース効率が命令型と比べ悪い
- 学習コストがかかる

## 用語・Tips

### 宣言型

- データがどのように処理されているか明示しない = 制御フローを関数に移譲する
- 反意語：**命令型**

```javascript
// 命令型
let array = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
for (let i = 0; i< array.length; i++) {  // どのように実行すべきか細かく指示
  array[i] = array[i] ** 2;
}
array;  // -> [0, 1, 2, 9, 16, 25, 36, 49, 64, 81]
```

```javascript
// 宣言型
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9].map(num => num ** 2) // map関数に制御フローの一部(ループ制御)を移譲
// -> [0, 1, 2, 9, 16, 25, 36, 49, 64, 81]
```

- 制御フローを関数化することにより、制御フロー自身の再利用が可能

```javascript
// 命令型
let array = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
let new_array = [];
for (let i = 0; i< array.length; i++) {
  array[i] = array[i] ** 2;
}
for (let j = 0; j< array.length; j++) {  // 制御フロー自身は再利用できない
    array[j] = array[j] ** 3;
}
array;  // -> [0, 1, 64, 729, 4096, 15625, 46656, 117649, 262144, 531441]
```

```javascript
// 宣言型
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  .map(num => num ** 2)
  .map(num => num ** 3) // 制御フロー自身を再利用する
// -> [0, 1, 64, 729, 4096, 15625, 46656, 117649, 262144, 531441]
```

### 純粋

- [副作用](#副作用)と[状態変化を伴わない](#不変性)状態
- 関数型プログラミングの努力目標

### 不変性

- 状態 ( = データ ) を変えない
    - スコープ外の値を変えない
    - 引数の値を変えない
- プリミティブ型が理想
- const宣言より確実に[オブジェクト型を変えない手法](#レンズ)をとる

### 副作用

- 副作用の例)
    - **this**
    - スコープ外の変数・プロパティ・データ構造(DOM含む)を変更する
    - ユーザー入力を処理する
    - 例外を外部に投げる
    - 画面表示・ログ出力
    - クッキーの読み書き・サーバへの問い合わせ

- 副作用を**全て排除するわけではない**  
    ⇒ [純粋](#純粋)な部分とそうでない部分を分離する  
    ⇒ [関数型での例外処理](#関数型での例外処理)

### 参照透過性

- 入力値のみに戻り値が左右される
- コードでのテストがやりやすくなる
- モックやスタブで置き換えやすくなる

```javascript
// 参照透過性なし
function getDay() {
  let today = new Date();  // 実行日によって変わるため、参照透過性は失われる
  return today.getDate();
}
```

```javascript
// 参照透過性あり
function getDay(today) {
  return today.getDate();
}
```

### 関数

- javascriptでは関数もオブジェクト
- 「関数は単一の機能を持つべき」
- 小さく分解することで
    - より再利用しやすく
    - より信頼性を高く
    - より簡単に理解

- 戻り値必須(void不可)

#### 純粋関数

- [副作用](#副作用)と[状態変化を伴わない](#不変性)関数
- 隠された値には依存しない  
    ＝ **引数省略不可**  
    ＝ 暗黙的なメンバ変数使用不可  
    ＝ グローバル変数不可  
- 外部スコープの値には依存しない
- 外部スコープの値を変更しない

#### 高階関数

- 関数を引数にとる関数
- javascriptの言語仕様上、関数全てにあてはまる

#### 関数チェーン

- 必要になったとき初めて実行される = 遅延評価(必要呼び) ⇒ 同期/非同期関係なし
- 入出力のオブジェクトに注意する
  
```javascript
funcA().funcB().funcC().funcD() ...
// ≒ funcA() | funcB() | funcC() | funcD() | ...  シェルでのイメージ
```

#### レンズ

- 別名：関数参照
- 参照元のオブジェクトを、setterの部分だけを変えてコピーできる
- コピー時は動的に加えたプロパティも適用される

参考：  
[超強力な関数型プログラミング用ライブラリ Ramda.js を学ぼう #2 - lens でオブジェクト操作も思いのまま](https://tech.recruit-mp.co.jp/front-end/post-16290/)
[Ramda.jsのLensとは？](http://jsstudy.hatenablog.com/entry/What-is-Lens-in-Ramda_js)

#### 関数合成

- 関数を組み合わせて、別の機能を持つ高階関数を作り上げる
- 関数チェーンより入出力のオブジェクトの制限は緩い
    - 接続される関数同士において、引数の個数が同一で、引数の型に互換性があればよい
- 入出力の型に気をつける
- Ramdaライブラリの機能を使う

```javascript
const hoge = func(funcA, funcB, funcC, funD);
// = funcA | funcB | funcC | funcD Shellでのイメージ
let fuga = hoge('piyo'); // -> funcの戻り値
```

```javascript
const trim = (str) => str.trim();
const normalize = (str) => str.replace(/\-/g, '');
const addExtention = (str) => str + '.jpg';
const createFileName = R.pipe(trim, normalize, addExtention);
// ≒ addExtention(normalize(trim()))
// ≒ trim() | normalize() | addExtention()  Shellでのイメージ
console.log(createFileName('44-44- 44 '));  //-> 4444 44.jpg
```

#### カリー化

- 引数を省略できない関数型プログラミングにおいて、引数を減らしたり、引数の数を揃えるためのテクニック
- 濫用するとメモリの多用につながる

参考：
[関数をcurry化して処理を先送り](https://www.wakuwakubank.com/posts/308-javascript-curry/)

```javascript
const print = (a, b, c, d) => `${a}_${b}_${c}_${d}`
const curriedPrint = R.curry(print);  // カリー化
const complementedPrint = curriedPrint('aaa', 'bbb');

console.log(complementedPrint('ccc', 'ddd'));  // -> aaa_bbb_ccc_ddd
```

#### 部分適用

- 引数を省略できない関数型プログラミングにおいて、引数を減らしたり、引数の数を揃えるためのテクニック
- 挙動が[カリー化](#カリー化)と異なる

```javascript
// カリー化
const print = (a, b, c, d) => `${a}_${b}_${c}_${d}`
const curriedPrint = R.curry(print);  // カリー化
const complementedPrint = curriedPrint('aaa', 'bbb');
console.log(complementedPrint('ccc'));  // -> 再度カリー化関数が作られる

// 部分適用
const partialPrint =_.partial(print, 'aaa', 'bbb');
console.log(partialPrint('ccc'));  // -> aaa_bbb_ccc_undefined

```

### コンピネータ

- 制御文を関数にすることで、制御文を含んだ形での関数合成を可能にする

- pipe
    - 関数合成
- compose
    - 関数合成 (pipeとは因数の順序が逆)

```javascript
R.pipe(funcA, funcB, funcC, funcD) == R.compose(funcD, funcC, funcB, funcA)
```

- identify
    - 与えられた入力値と同じ値を返す

- tap
  - 関数実行と同時に、与えられた入力値を返すので、void型関数・非同期処理を呼び出す起点に使える
  
```javascript
const writeTxt = function (path, context) {
  // バイナリデータを作ります。
  let blob = new Blob([context], {type: "text/plain;charset=utf-8"});

  // IEか他ブラウザかの判定
  if(window.navigator.msSaveBlob)
  {
    // IEなら独自関数を使います。
    window.navigator.msSaveBlob(blob, path);
  } else {
    // それ以外はaタグを利用してイベントを発火させます
    let a = document.createElement("a");
    a.href = URL.createObjectURL(blob);
    a.target = '_blank';
    a.download = path;
    a.click();
  }
}

const partialLogging1 =　R.tap(_.partial(writeTxt, 'log1.txt'));
const partialLogging2 = R.tap(_.partial(writeTxt, 'log2.txt'));
const cangeCase = (str) =>  str + ' → B';

const hogePipe = R.pipe(partialLogging1, cangeCase, partialLogging2);
hogePipe('ケースA');　  // log1.txt -> ケースA
                       // log2.txt -> ケースA → B
```

参考：  
[JavaScriptだけでファイルの保存機能を実装する](https://blog.fagai.net/2014/08/09/javascript-only-save/)

- alternation
    - if - else文

```javascript
function thenFnc(val){
  console.log(`then: ${val} > 10`);
}
function elseFnc(val){
  console.log(`else: ${val} <= 10`);
}
const CurriedAlt = R.curry(
  (thenFnc,　elseFnc, val) => {
    if (val > 10) {
      thenFnc(val);
    }else{
      elseFnc(val);
    }
  }
);
const logging = R.tap(console.log);
const partialAlt = R.pipe(logging, CurriedAlt(thenFnc,　elseFnc));
partialAlt(9);  // -> 9
                // -> else: 9 <= 10
```

- sequence
    - = Array.forEach関数
    - _.mapとは違い、値は返さない

- fork
    - 結果を統合する
    - ≒ join関数・concat関数

```javascript
function FncA(val){
  return [`${val}_A1`, `${val}_A2`];
}
function FncB(val){
  return [`${val}_B1`, `${val}_B2`];
}
function FncC(val){
  return [`${val}_C1`, `${val}_C2`];
}
const CurriedFork = R.curry((FncA, FncB, FncC, val) => FncA(val).concat(FncB(val), FncC(val)));
const logging = R.tap(console.log);

const partialFork = R.pipe(logging, CurriedFork(FncA, FncB, FncC));
console.log(partialFork('Array'));  // -> Array
                                    // -> ["Array_A1", "Array_A2", "Array_B1", "Array_B2", "Array_C1", "Array_C2"]
```

### 関数型での例外処理

- try-catchの問題点
    - 例外処理を含んだ形での関数チェーン化・関数合成が困難となる
    - 例外により、関数の出口(戻り値の種類)が増えてしまう
    - 意図しない副作用の原因となる
    - 局所性の原則（エラー回復コードはエラー原因の関数呼び出しの近くにあるべき）に反しやすい
    - 複数エラー条件に対応しようとすると、try-catch構文が入れ子になってしまい、扱いづらい

⇒ [純粋](#純粋)な部分とそうでない部分に分離する

参考：
[JavaScript関数型プログラミング Ch.5 複雑性を抑えるデザインパターン](https://wand-ta.hatenablog.com/entry/2019/01/22/090040)

#### モナド

- 関数型プログラミングにおいてのデザインパターン
- モナドはあくまで総称
- [関数合成](#関数合成)に挟み込むことで、堅牢性を上げている

パターン：  
- Maybeモナド
  - 期待する値か否かで戻り値のオブジェクトごと分ける = [純粋](#純粋)な部分とそうでない部分に分離する
  - 関数チェーンを壊さずにエラー処理を実装することが可能
- Eitherモナド
- IOモナド

参考：
[30分でわかるJavaScriptプログラマのためのモナド入門](https://kentutorialbook.github.io/30minLearningJavaScriptMonad/)
[モナドはポケモン。数学が出てこないモナド入門](https://qiita.com/hiruberuto/items/8bbc0343bf794c368287)

### 非同期処理

- [Promise](https://azu.github.io/promises-book/#introduction)を有効活用する
- 時間的な依存関係のグループを作る ⇒ 時間的結束

### リアクティブプログラミング

- 動的な値の変更を伝播させるデータフロー指向のプログラミングパラダイム
- RxJSやらCycle.jsやらVue.js(部分的)やら
- 今回は触れない

参考：
[リアクティブプログラミングへの理解がイマイチだったのでまとめてみた](https://system.blog.uuum.jp/entry/%E3%83%AA%E3%82%A2%E3%82%AF%E3%83%86%E3%82%A3%E3%83%96%E3%83%97%E3%83%AD%E3%82%B0%E3%83%A9%E3%83%9F%E3%83%B3%E3%82%B0%E3%81%B8%E3%81%AE%E7%90%86%E8%A7%A3%E3%81%8C%E3%82%A4%E3%83%9E%E3%82%A4%E3%83%81%E3%81%A0%E3%81%A3)

## コーディング

### ライブラリの準備

- 使用ライブラリ
    - [lodash](https://lodash.com/)
    - [Ramda](https://ramdajs.com/)

```Shell
cd {インストールディレクトリ}
npm i lodash
npm i ramda
```

```html
    <script src="{インストールディレクトリ}/node_modules/lodash/lodash.js"></script>     <!-- _で呼び出し可能-->
    <script src="{インストールディレクトリ}/node_modules/ramda/dist/ramda.js"></script>  <!-- Rで呼び出し可能-->
```

## テスト

- 使用ライブラリ
    - [Mocha](https://mochajs.org/)
    - [Chai](https://www.chaijs.com/)

```Shell
cd {インストールディレクトリ}
npm i mocha
npm i chai
```

```html
<head>
    <link rel="stylesheet" type="text/css" href="./test_js/node_modules/mocha/mocha.css">
    <script src="{インストールディレクトリ}/node_modules/mocha/mocha.js"></script>
    <script src="{インストールディレクトリ}/node_modules/chai/chai.js"></script>
</head>
    <body>
        <!-- テスト結果表示エリア -->
        <div id="mocha"></div>

        <!-- Mocha設定 -->
        <script class="mocha-init">
          mocha.setup('bdd');  // BDD用にセットアップする (describeとかitが使えるようになる)
          mocha.checkLeaks();  // テスト実行中にグローバル変数が追加されたらエラー終了させる
        </script>

        <script src="./js/Sample_curry.js"></script>　<!-- テスト対象js -->
        <script src="./test_js/Test_Sample_curry.js"></script> <!-- テストケースjs -->

        <!-- テスト実行 -->
        <script class="mocha-exec">
          mocha.run();
        </script>
    </body>
```

```javascript
// Sample_curry.js
const print = (a, b, c) => `${a}_${b}_${c}`

// e.g.) 1. curry化されてない関数
R.tap(console.log, 'e.g.) 1. Not To curry ----')
console.log(print(1, 2))

// e.g.) 2. curry化
R.tap(console.log, 'e.g.) 2. To curry ----')
const curriedPrint = R.curry(print);
const f2 = curriedPrint('aaa', 'bbb');
console.log(f2('ccc', 'ddd'));

// e.g.) 2'. curry化
R.tap(console.log, 'e.g.) 2. To curry ----')
const curriedPrint2 = R.curryN(3, print);
const f2_2 = curriedPrint2('aaa', 'bbb');
console.log(f2_2('ccc'));

```

```javascript
// Test_Sample_curry.js
const expect = chai.expect;
const assert = chai.assert;  // chaiとmochaはグローバルに読み込み済み
describe('Carry化 テスト', () => {
	it('curry化 (R.curry)', () => {
		assert.equal(f2('ccc'), 'aaa_bbb_ccc');
    });
    
    it('curry化 (R.curryN)', () => {
		expect(f2_2('ccc')).to.equal('ddd_aaa_bbb'); // わざと失敗させている
	});
});
```

結果  

![test_result.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/609106/e6b24a36-54fd-b38b-0a51-b35c67e267b3.png)

参考：  
・[MochaとChaiでなんでもテスト ～ブラウザ用JavaScript編～](https://note.kiriukun.com/entry/testing-with-mocha-and-chai---browser-javascript)

## 評価

以下の処理を行うプログラムで比較する

1. JSONを取得しnames属性(配列)を取得
2. nullチェックを実施
3. name属性の記号を取り除く
4. name属性の先頭を大文字化
5. name属性の重複除去
6. 5件以内なら、mdのテーブルとして追記、log.mdファイルとして出力
7. コンソールに出力

### コード

```javascript
// コード1: プロミス、Maybeモナド、関数チェーン、カリー化使用
class Maybe {
  static just(obj) {
    return new Just(obj);
  }
  static nothing(){
    return new Nothing();
  }

  // fromNulllable:: Object -> Maybe
  static fromNulllable(obj) {
    if ((obj.names == null) || (!obj.names[Symbol.iterator])) {  // 2
      return Maybe.nothing();
    } else {
      return Maybe.just(obj);
    }
  }
}

// 想定内の値の場合のクラス
class Just extends Maybe {
  constructor(obj) {
    super();
    this._obj = obj;
  }
  get value() {
    return this._obj;
  }
}

// 想定外の値の場合のクラス
class Nothing extends Maybe {
  get value() {
    return {names: []};
  }
}

// writeTxt:: str, str -> void
function writeTxt(path, context) {
  let blob = new Blob([context], {type: "text/plain;charset=utf-8"});

  // IEか他ブラウザかの判定
  if(window.navigator.msSaveBlob)
  {
    // IEなら独自関数を使います。
    window.navigator.msSaveBlob(blob, path);
  } else {
    // それ以外はaタグを利用してイベントを発火させます
    let a = document.createElement("a");
    a.href = URL.createObjectURL(blob);
    a.target = '_blank';
    a.download = path;
    a.click();
  }
}

// writeMd:: str -> str , str -> writeTxt -> void
const writeMd = R.tap(_.partial(writeTxt, 'log.md'));

// logConsole:: str -> str
const logConsole = R.tap(console.log);

// thenFnc::array -> void
function thenFnc(array) {
  const md_contents = '| Phonetic Code |\n| *---* |\n'
    + '| ' + _(array).reduce((total,val) => total + ' |\n| '+ val) + ' |'
  const logging = R.pipe(writeMd, logConsole);
  logging(md_contents);  // 7
  return;
}

// elseFnc:: array -> void
function elseFnc(array) {
  console.log('[error] 0 Items OR Over 5 Items!');
  return;
}

const isValid = (val) => !_.isUndefined(val) && !_.isNull(val) && (val !='');

// CurriedAlt:: Maybe -> array -> void
const CurriedAlt = R.curry((thenFnc, elseFnc, maybe) => {
  const array = _.chain(maybe.value.names)
    .filter(isValid)
    .map((obj) => obj.toString().replace(/\-/, ''))  // 3
    .map(_.startCase)  // 4
    .uniq()  // 5
    .value();
  if ((array.length > 0) && (array.length <= 5)) { // 6
    thenFnc(array);
  } else {
    elseFnc(array);
  }
});

const toMd = R.pipe(Maybe.fromNulllable, CurriedAlt(thenFnc, elseFnc));

Promise.resolve($.getJSON('./tmp/sample.json')).then((data) => {  // 1
  toMd(data);
}).catch((e) => console.log(e));
```

```javascript
// コード2: プロミス、Maybeモナド、関数チェーン使用
class Maybe {
  static just(obj) {
    return new Just(obj);
  }
  static nothing(){
    return new Nothing();
  }

  // fromNulllable:: Object -> Maybe
  static fromNulllable(obj) {
    if ((obj.names == null) || (!obj.names[Symbol.iterator])) {  // 2
      return Maybe.nothing();
    } else {
      return Maybe.just(obj);
    }
  }
}

// 想定内の値の場合のクラス
class Just extends Maybe {
  constructor(obj) {
    super();
    this._obj = obj;
  }
  get value() {
    return this._obj;
  }
}

// 想定外の値の場合のクラス
class Nothing extends Maybe {
  get value() {
    return {names: []};
  }
}

// writeMd:: str , str -> void
function writeMd(path, context) {
  let blob = new Blob([context], {type: "text/plain;charset=utf-8"});

  // IEか他ブラウザかの判定
  if(window.navigator.msSaveBlob)
  {
    // IEなら独自関数を使います。
    window.navigator.msSaveBlob(blob, path);
  } else {
    // それ以外はaタグを利用してイベントを発火させます
    let a = document.createElement("a");
    a.href = URL.createObjectURL(blob);
    a.target = '_blank';
    a.download = path;
    a.click();
  }
}


// thenFnc::array -> void
function thenFnc(array) {
  const md_contents = '| Phonetic Code |\n| *---* |\n'
    + '| ' + _(array).reduce((total,val) => total + ' |\n| ' + val) + ' |'
  writeMd('log.md', md_contents);
  console.log(md_contents);  // 7
  return;
}

// elseFnc:: array -> void
function elseFnc(array) {
  console.log('[error] 0 Items OR Over 5 Items!');
  return;
}

// alt:: Maybe -> array -> void
const alt = (maybe) => {
  const array = _.chain(maybe.value.names)
    .filter(isValid)
    .map((obj) => obj.toString().replace(/\-/, ''))  // 3
    .map(_.startCase)  // 4
    .uniq()  // 5
    .value();
  if ((array.length > 0) && (array.length <= 5)) {  // 6
    thenFnc(array);
  } else {
    elseFnc(array);
  }
};

const toMd = (obj) => alt(Maybe.fromNulllable(obj));

const isValid = (val) => !_.isUndefined(val) && !_.isNull(val) && (val !='');

Promise.resolve($.getJSON('./tmp/sample.json')).then((data) => {  // 1
  toMd(data);
}).catch((e) => console.log(e));
```

```javascript
// コード3: プロミス、Maybeモナド、関数チェーン不使用
// writeMd:: str , str -> void
function writeMd(path, context) {
  let blob = new Blob([context], {type: "text/plain;charset=utf-8"});

  // IEか他ブラウザかの判定
  if(window.navigator.msSaveBlob)
  {
    // IEなら独自関数を使います。
    window.navigator.msSaveBlob(blob, path);
  } else {
    // それ以外はaタグを利用してイベントを発火させます
    let a = document.createElement("a");
    a.href = URL.createObjectURL(blob);
    a.target = '_blank';
    a.download = path;
    a.click();
  }
}


// thenFnc::array -> void
function thenFnc(array) {
  let md_contents = '| Phonetic Code |\n| *---* |\n'
  
  for (const val of array) {
    md_contents += `| ${val} |\n`;
  }

  writeMd('log.md', md_contents);
  console.log(md_contents);  // 7
  return;
}

// elseFnc:: () -> void
function elseFnc() {
  console.log('[error] 0 Items OR Over 5 Items!');
  return;
}

// toMd:: obj -> void
const toMd = (obj) => {
  try {
    let array = [];
    for (let i = 0; i < obj.names.length; i++) {
      let n = obj.names[i];
      if (n !== undefined && n !== null && n !== '' ) { // 2
        n = n.toString().replace(/\-/, '');  // 3
        n = n.substr(0, 1).toUpperCase() + n.substr(1);  // 4
        if (array.indexOf(n) == -1) {  // 5
          array.push(n);
        }
      }
    }
    if ((array.length > 0) && (array.length <= 5)) {  // 6
      thenFnc(array);
    } else {
      elseFnc();
    }
  } catch (e) {  // 2
    elseFnc();
  }
}

try {
  $.getJSON('./tmp/sample.json', (data) => {  // 1
    toMd(data);
  });
} catch(e){
  console.log(e);
}
```

### 結果

|     |  文字数 |  メモリ使用量  |
| ---- | ----: | ----: |
|  コード1  |  2257  |  46236 KB  |
|  コード2  |  2018  |  45200 KB  |
|  コード3  |  1504  |  44376 KB  |

## 結論

- javascriptは「命令型だけ」、「関数型だけ」と、片方のみサポートしているわけではない  
    うまく組み合わせると、堅牢性の高いコードの作成が可能である
    - 命令型でも、コード2のように不変性・参照透過性を意識するようにするとよい
    - コード3ではどうしても変数をlet宣言しなければならず、その分堅牢性が劣ると考える
- ループが絡む場合、関数チェーンの方がコードの見通しが良い
    - コード3ではnullチェック処理がぱっと見では何をしているかわからなかった
- コード1ではUnixのようなパイプ処理が可能なことが魅力だが、コード量・メモリ使用量ともに増えている
    - AWS Lambdaのようにメモリ使用量が費用に直結する場合は注意が必要である