【JavaScript】10種類の文字だけでフィボナッチ数を計算する関数を書いてみた

初めまして。
まずは本題。
n番目のフィボナッチ数を計算する関数です。

```javascript:Fibonacci.js
const getFibonacci = (_=>((_=[__=>([_=>_,()=>(_[!-[]-(-!-[])][__]=_[-[]](__-!-[])-(-_[-[]](__-!-[]-!-[])))][-(-(_[!-[]-(-!-[])][__]===[][[]]))](),_[!-[]-(-!-[])][__]),__=>((_[!-[]-(-!-[])]=[-[],-(-!-[])]),_[-[]](__))]),_[-(-!-[])]))();
```

関数の記述には`(_,)=>!-[]`の10種類の文字しか使っていません。
どうしてもソース全文でそれらだけにしたければ、
スペース詰めて関数名変えて宣言とセミコロン省いて
`_=(_=> 〜 )()`みたいにすればいいと思います。

`getFibonacci(50)`とか計算すると、
そこそこの速さで`12586269025`と出てくるので合ってそうです
（動作検証はChromeでしかしてませんが）。

#何これ？
そのままだと中身見放題のJavaScriptの難読化の方法を考えていて、
「もっと文字の種類を減らせるのでは？」と思ったので、
手動でも難読化できそうなフィボナッチ数列でやってみました。

#よくわからない解説
このままだと難読化したソースを紹介してるだけになってしまうので、
解説をつけてみます。

##1. とりあえず改行とインデント
上のソースだと横に長すぎてふざけてるのかってレベルなので
改行とインデントを入れてみます。

```javascript:Fibonacci1.js
const getFibonacci = (_=>(
  (_=
    [
      __=>(
        [
          _=>_,
          ()=>(_[!-[]-(-!-[])][__]=_[-[]](__-!-[])-(-_[-[]](__-!-[]-!-[])))
        ][-(-(_[!-[]-(-!-[])][__]===[][[]]))](),
        _[!-[]-(-!-[])][__]
      ),
      __=>(
        (_[!-[]-(-!-[])]=[-[],-(-!-[])]),_[-[]](__)
      )
    ]
  ),
  _[-(-!-[])]
))();

```
はい、馬鹿にしてんのかって感じですね。
##2. みんな大好き`+[]`と`+!+[]`
JavaScriptは特定の演算をした時に型変換されるので
`+[]` → `+0` → `0`
`+!+[]` → `+!0` → `+true` → `+1` → `1`
のように`+![]`だけで0や1を表現できます。

巷でよく見かける（？）のは上記の`+`を使った書き方ですが、
`-[]` → `-0` → `0`
`-(-!-[])` → `-(-!0)` → `-(-true)` → `-(-1)` → `1`
という感じに`-`を用いても同じことができます。

これを踏まえてさっきのソースを見ると、
`-[]`や`-(-!-[])`と言ったパターンがたくさんあるので
0と1に置き換えてやると、次のようになります。

```javascript:Fibonacci2.js
const getFibonacci = (_=>(
  (_=
    [
      __=>(
        [
          _=>_,
          ()=>(_[2][__]=_[0](__-1)-(-_[0](__-2)))
        ][-(-(_[2][__]===undefined))](),
        _[2][__]
      ),
      __=>(
        (_[2]=[0,1]),_[0](__)
      )
    ]
  ),
  _[1]
))();
```
`2`になってるところは`true+true`等の結果です。
他にも`[][[]]`が`undefined`になっていますが、
これは空の行列`[]`の`''`というプロパティを見に行って
そんなのは定義されていないので`undefined`値が返ってきます。

文字や数字が現れてきましたが、
まだまだ読みやすいコードとは言えませんね。

##3. そもそも変数名が悪い
変な記号がかなり減ったところで、
`_`とか`__`なんていうふざけた名前の変数をなんとかしましょう。
あと`this`なんて影も形もないので、
アロー関数も普通のfunctionに置き換えて問題ないでしょう。

```javascript:Fibonacci3-0.js
const getFibonacci = (function(a){
  return (
  (a=
    [
      function(b){
        return (
        [
          function(x){return x},
          function(){
            return(a[2][b]=a[0](b-1)-(-a[0](b-2)))
          }
        ][-(-(a[2][b]===undefined))](),
        a[2][b]
      )},
      function(b){
        return (
          (a[2]=[0,1]),a[0](b)
        )
      }
    ]
  ),
  a[1]
)
})();
```
少しインデントを変えています。
やっとJavaScriptっぽくなってきました。
`b-1`と`b-2`が近くにあるあたりに少しフィボナッチ感も漂い出しました。


全体で5つの関数がありますが、そのうち3つの関数で、
`return`のあとに`,`があって、何が返り値なのかわかりづらいです。
Minifier等を使うとよく見かける表現ですが、
読みづらいのでついでに変えておきましょう。

```javascript:Fibonacci3-1.js
const getFibonacci = (function(a){
  a=[
    function(b){
      [
        function(x){return x},
        function(){
          return(a[2][b]=a[0](b-1)-(-a[0](b-2)))
        }
      ][-(-(a[2][b]===undefined))]();
      return a[2][b];
    },
    function(b){
      a[2]=[0,1];
      return a[0](b);
    }
  ];
  return a[1];
})();
```

##4. `a`の抹殺
ここまでくると、この関数がどういう構造なのか
わかりやすくなってきたんじゃないでしょうか。

中に2つの関数があって、それが`a`に配列として代入されています。
この`a`ですが、一番外側の無名関数の引数に見えて、
下を見ると関数の実行時には何も代入されておらず、
関数の一番初めに配列が代入されています。
グローバルスコープを汚さないための匠の暖かい心遣いですね。

とはいえ、2つの関数の定義を外に出してやれば
この`a`なんて必要なさそうな気がします。
`a[0]`と`a[1]`をそれぞれ`f0`と`f1`に置き換えてみましょう。

……と、その前に、
`a`は2つの要素しかない配列のはずが、よく見ると`a[2]`なんて奴がいます。
こいつは関数じゃなさそうなので`a2`と置き換えます。

```javascript:Fibonacci4.js
const getFibonacci = (function(){
    let f0 = function(b){
        [
            function(x){return x},
            function(){
                return(a2[b]=f0(b-1)-(-f0(b-2)))
            }
        ][-(-(a2[b]===undefined))]();
        return a2[b];
    };
    let f1 = function(b){
        a2=[0,1];
        return f0(b);
    };
    let a2;
    return f1;
})();
```
しれっとインデントをスペース4つに変えました。

見事に`a`の消去に成功しました。
`f0`や`f1`は再代入されていないようなので、
あとで変数宣言を`const`に変えておきます。

##5. 謎の空間
ただ、こうしてコードとして整ってくると、
`f0`の中に謎の空間があることに気づきます。

```javascript:謎の空間-0
[
    function(x){return x},
    function(){
        return(a2[b]=f0(b-1)-(-f0(b-2)))
    }
][-(-(a2[b]===undefined))]();
```
この部分ですね。

`-`が重なってるところや、余計な括弧を省いたりしても、

```javascript:謎の空間-1
[
    function(x){return x},
    function(){
        return a2[b]=f0(b-1)+f0(b-2);
    }
][+(a2[b]===undefined)]();
```
という風にしかならず、直感的に理解できるとは言い難いでしょう。

実はこの部分がこの関数の肝であり、
10種類の文字だけで記述するのに不可欠な要素なのです。

せっかくなので、要素を一つひとつ見ていきましょう。

###5.1. 配列の中身
```javascript:謎の空間の配列-0
[
    function(x){return x},
    function(){
        return a2[b]=f0(b-1)+f0(b-2);
    }
]
```
2つの関数が収まっていますね。
1つ目は代入された値をそのまま返す関数、
2つ目はフィボナッチっぽい関数です。

実はこれらの関数は、返り値がどこかに代入されることはないので、
`return`は不要だったりします。
そうなると1つ目の関数は何もしない関数になってしまい、

```javascript:謎の空間の配列-1
[
    function(){},
    function(){
        a2[b]=f0(b-1)+f0(b-2);
    }
]
```
というすっきりした感じになります。

###5.2. 配列のアドレス
`array[i]`の`i`の部分をなんて読んでいいかわからないので
とりあえずアドレスと読んでいます。

謎の空間でいうところの

```
+(a2[b]===undefined)
```
の部分です。

ここでは`a2[b]`を`undefined`と比較して、
その結果に+をつけています。
`+!+[]`や`+[]`と同じように、
頭に+をつけて真偽値を`1`と`0`に変換しているんですね。

したがって、`a2[b]`の値が`undefined`であれば、
`+(a2[b]===undefined)` → `+(true)` → `1`となり、
そうでなければ、
`+(a2[b]===undefined)` → `+(false)` → `0`となるわけなのです。

###5.3. 後ろの`()`
JavaScriptでは昔から、
>周りに`function`や`=>`がいない`()`を見たら
>何かの関数を実行していると思え！

とは言われてはいないと思いますが、
この場合はまさにそれですね。

配列の中の2つの関数から、
`a2[b]`の値によって片方を選んで、
そいつを実行しているわけです。

###5.4. 謎の空間の正体
謎の空間では、
`a2[b]`の値が`undefined`なら
配列の1番目の関数`function(){a2[b]=f0(b-1)+f0(b-2);}`を実行し
`a2[b]`の値が`undefined`でないなら
配列の0番目の関数`function(){}`を実行する（つまり何もしない）わけです。

とっくにお気づきかもしれませんが、
これは__条件分岐__、つまりはif文です。
謎の空間を冗長に書き直すと、

```javascript:謎の空間の正体-0
if(a2[b]===undefined){
    (function(){
        a2[b]=f0(b-1)+f0(b-2);
    })();
}else{
	(function(){})();
}
```
となり、余計な部分を省くと、

```javascript:謎の空間の正体-1
if(a2[b]===undefined){
    a2[b]=f0(b-1)+f0(b-2);
}
```
という何の変哲もないif文となってしまいました。

通常、if文を書こうと思うと`if`を使うか三項演算子`a?b:c`を使うわけです。
どちらを選んでも、`(_,)=>!-[]`以外の文字を2つ使う必要があります。
また、Minifierを使うとしばしば見られる表現ですが、`&&`を使って、

```javascript
a2[b]===undefined&&(a2[b]=f0(b-1)+f0(b-2))
```
のように書くこともできますが、それでも`&`が余計に必要です。

実は最初にこのコードを書いた時には`&`さんがいました。
1箇所だけにしかいないこいつを何とか排除したくて、
配列を使った方法を思いつき、
謎の空間が生まれ、
そのまま上がったテンションでこんな文章を書いているというわけなのでした。

##6. 最終形態
さて、ただのif文ごときに手間取ってしまいましたが、
おかげでただのJavaScriptのソースコードに見えるところまできました。

```javascript:Fibonacci6-0.js
const getFibonacci = (function(){
    const f0 = function(b){
        if(a2[b]===undefined){
            a2[b]=f0(b-1)+f0(b-2);
        }
        return a2[b];
    };
    const f1 = function(b){
        a2=[0,1];
        return f0(b);
    };
    let a2;
    return f1;
})();
```
あと残った謎は`a2`くらいでしょうか。

関数の流れを追ってみると、`getFibonacci(n)`を実行すると、
`f1`の初めで、`a2`に配列`[0,1]`が代入されています。
そして`f0`が呼ばれ、
`a2[b]`の値が`undefined`なら`f0(b-1)+f0(b-2)`を代入し、
最終的に`a2[b]`が返ってきます。

`f0(b-1)+f0(b-2)`の部分はフィボナッチ数の定義そのままです。
また、`f0(0)`は`a2=[0,1]`の0番目の要素なので0、
`f0(1)`は`a2=[0,1]`の1番目の要素なので1が返ってくるので、
計算すると、`0,1,1,2,3,5,8,13,...`という
フィボナッチ数列になります。

###6.1. メモ化

ここで、`a2[b]`に計算結果を代入しているのは、
同じ`n`に対して`f0(n)`を何度も計算しないで済むように、
1度計算した値を保存しておくメモ化というテクニックです。
`f1`でわざわざ初期化してるのは、計算時間を測定したかったんですかね。

フィボナッチ数列のように再帰的に計算する必要がある場合は、
劇的に速度が上がるみたいです。
一番初めに「そこそこの速さで」と書いたのはそれが理由ですね。
メモ化について詳しく書く気はないので、気になる方は調べてみてください。

###6.2. 元の状態と比較

さて、全ての謎が解けたところで、
冗長な部分を消したり体裁を整えたりすると、次のようになります。

```javascript:Fibonacci6-1.js
const getFibonacci = (function(){
    let memo;
    const f = function(n){
        if(memo[n]===undefined){
            memo[n] = f(n-1) + f(n-2);
        }
        return memo[n];
    };
    return function(n){
        memo = [0,1];
        return f(n);
    };
})();
```
うーん、ごく普通のフィボナッチ数を計算する関数ですね
（`undefined`周りが少し気になるかもしれませんが）。
最初の頃と比較してみましょう。

```javascript:Fibonacci1.js
const getFibonacci = (_=>(
  (_=
    [
      __=>(
        [
          _=>_,
          ()=>(_[!-[]-(-!-[])][__]=_[-[]](__-!-[])-(-_[-[]](__-!-[]-!-[])))
        ][-(-(_[!-[]-(-!-[])][__]===[][[]]))](),
        _[!-[]-(-!-[])][__]
      ),
      __=>(
        (_[!-[]-(-!-[])]=[-[],-(-!-[])]),_[-[]](__)
      )
    ]
  ),
  _[-(-!-[])]
))();

```

インデントの形は似ているような気がしないでもないですが、
こうして見るとまるで別物ですね。

# 最後に
今回、フィボナッチ数を計算する関数を
`(_,)=>!-[]`だけを使って書いてみましたが、
どんな関数でも書けるわけではないと思います。

ただ、いくつか記号を追加して、
`window`等のルートオブジェクトと`new`や`'SCgohm'`なんて文字列を用意すれば、
大抵のコードは今回のように難読化できる気がします。

手動でやると頭がおかしくなりかねないので、
自動で難読化するプログラムを書いてみてもいいんじゃないでしょうか。

特に使えるような内容ではありませんでしたが、
何かのヒントになれば幸いです。

#おまけ
<details><summary>`(_,)=>!-[]`</summary>
「どうして10種類の文字列が`(_,)=>!-[]`なんていう変な順番なんだ」と
気になった方がいるかもしれません。
大した理由ではありませんが、
JavaScriptとして実行してエラーにならない並びだったからです。
文法的に不正でないかは知りません。
他の並びはあと1種類しか思いつきませんでした。
</details>