<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Kazunori  Kamiya on Medium]]></title>
        <description><![CDATA[Stories by Kazunori  Kamiya on Medium]]></description>
        <link>https://medium.com/@kazunorikamiya?source=rss-e42be372267d------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*6npWXmAR0rO3GayK.</url>
            <title>Stories by Kazunori  Kamiya on Medium</title>
            <link>https://medium.com/@kazunorikamiya?source=rss-e42be372267d------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 11:33:03 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@kazunorikamiya/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Googleフォームのメール通知を指定したアドレスに送る方法(Google Apps Script使用)]]></title>
            <link>https://medium.com/@kazunorikamiya/google%E3%83%95%E3%82%A9%E3%83%BC%E3%83%A0%E3%81%AE%E3%83%A1%E3%83%BC%E3%83%AB%E9%80%9A%E7%9F%A5%E3%82%92%E6%8C%87%E5%AE%9A%E3%81%97%E3%81%9F%E3%82%A2%E3%83%89%E3%83%AC%E3%82%B9%E3%81%AB%E9%80%81%E3%82%8B%E6%96%B9%E6%B3%95-google-apps-script%E4%BD%BF%E7%94%A8-4b58f2049bd9?source=rss-e42be372267d------2</link>
            <guid isPermaLink="false">https://medium.com/p/4b58f2049bd9</guid>
            <category><![CDATA[google]]></category>
            <category><![CDATA[google-apps-script]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[google-forms]]></category>
            <category><![CDATA[gas]]></category>
            <dc:creator><![CDATA[Kazunori  Kamiya]]></dc:creator>
            <pubDate>Thu, 14 Mar 2019 02:15:23 GMT</pubDate>
            <atom:updated>2020-05-06T08:52:59.929Z</atom:updated>
            <content:encoded><![CDATA[<p>＊2019年12月追記</p><p>こんにちは、<a href="https://www.vacancorp.com/"><strong>株式会社バカン</strong></a>の神谷です。この記事は、<a href="https://qiita.com/advent-calendar/2019/vacan"><strong>バカン (Vacan) Advent Calendar 2019</strong></a>の5日目(12/5)の投稿です。今回は、Googleフォームをより便利に使う方法を1つご紹介したいと思います。</p><p>とある日に仕事で、Googleフォームで回答が来た際に、メール通知を特定のアドレスに送りたいと言われました。</p><p>調べていたら、Google Apps Script(以下、GAS)を利用すれば凄く簡単に可能だとわかったので、備忘録も兼ねて残しておきます。</p><p>適当にフォームを作ったら、まず右上の点が3つ並んだところをクリックして、スクリプトエディタを開いてください(赤枠で囲ったところです)。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/362/1*CNoCp0HOBoWi_4QW8p2Bzg.png" /></figure><p>そうするとエディタが開くので、そこに以下のスクリプトをコピペしてください。</p><pre>function sendform(e){<br>  var items = e.response.getItemResponses();<br>  var msg = &#39;&#39;;<br>  for (var i = 0; i &lt; items.length; i++) {<br>    var item = items[i];<br>    var q = item.getItem().getTitle();<br>    var a = item.getResponse();<br>    msg += q + &#39;: &#39; + a + &#39;\n\n&#39;;<br>  }<br>  GmailApp.sendEmail(&#39;送りたいメールアドレス&#39;, &#39;返信メールのタイトル&#39;, msg);<br>}</pre><p>「送りたいメールアドレス」のところは、カンマ区切りで幾つでもメールアドレスを指定することができます（’aaa@gmail.com, bbb@gmail.com’のように、’’内にカンマ区切りで書き込んでください）。</p><p>「返信メールのタイトル」も、自由に変えることができるので、皆さんのお好きなようになさってください</p><p>これだけでフォームの質問タイトルや回答が全て通知メールに出力されるので、非常に便利です。</p><p>それ以外は基本的にこのスクリプトをいじる必要はなく、あとは上のスクリプトが実行されるようにするためのトリガーの設定です。トリガーの設定を忘れると、フォームが送信されても通知が来ないのでご注意を。</p><p>トリガーの設定は、エディタ画面から、編集→現在のプロジェクトのトリガー、の順にクリックすれば今書いているスクリプトを実行するためのトリガー設定画面に遷移します(下記参照)。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/299/1*7sFobkj5ASgXaVk1LEK8cw.png" /></figure><p>そこから具体的なトリガーの設定については、以下のスクショを参考にしてみてください。特別難しいことはなく、実行する関数(今回はsendForm)を選び、いつ実行されるかを選ぶだけです。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/747/1*oEb0fB-BS1WgptwvtLcC2w.png" /></figure><p>こうすれば、フォーム送信時に指定したアドレスに質問と回答内容が飛んできます。ちょっとしたことで色々便利になるGAS、もっと深く勉強してみます。</p><h3>参考</h3><h4><a href="http://libro.tuyano.com/index3?id=1184003&amp;page=5">FormAppによるフォームの集計と作成 (5/5)</a></h4><h4>最後に</h4><p>バカンでは、一緒に働く仲間を積極的に募集しています。興味のある方は、バカンの<a href="https://www.wantedly.com/companies/vacancorp/projects">Wantedly</a>をチェックしてみてください。</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4b58f2049bd9" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[npmの使い方について]]></title>
            <link>https://medium.com/@kazunorikamiya/npm%E3%81%AE%E4%BD%BF%E3%81%84%E6%96%B9%E3%81%AB%E3%81%A4%E3%81%84%E3%81%A6-9f4d04d3c80b?source=rss-e42be372267d------2</link>
            <guid isPermaLink="false">https://medium.com/p/9f4d04d3c80b</guid>
            <category><![CDATA[node]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[npm]]></category>
            <category><![CDATA[nodejs]]></category>
            <dc:creator><![CDATA[Kazunori  Kamiya]]></dc:creator>
            <pubDate>Fri, 17 Nov 2017 01:06:23 GMT</pubDate>
            <atom:updated>2017-11-20T03:14:01.660Z</atom:updated>
            <content:encoded><![CDATA[<p>ここでは、以下の記事を元にnpmの使い方について解説していきます。</p><p><a href="https://www.sitepoint.com/beginners-guide-node-package-manager/">A Beginner&#39;s Guide to npm - the Node Package Manager - SitePoint</a></p><p>一部省略していますが、その点についてはご理解ください。</p><h3>Installing Node.js</h3><p><a href="https://nodejs.org/en/download/">このページか</a>ら、必要なバージョンのものをインストールしてください。<br>Linuxの場合はパッケージマネージャーを使ってインストールすることも可能で、その方法については<a href="https://nodejs.org/en/download/package-manager/">ここ</a>を見てください。</p><p>インストールが済んだら、どこにインストールされたのかとバージョンの確認をしてみましょう。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DYskDR2dxwPc44OCXXl_EA.gif" /></figure><p>インストールがきちんと完了したことを確認するには、NodeのREPLを実行してみるのがオススメです。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CaGjSiFcJ6s6wr5p2EVFDg.gif" /></figure><p>Node.jsの方が問題なくできているなら、今度はnpmの方も確認してみましょう。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*F_I-VxGawlfn7ASYjTRcaQ.gif" /></figure><h3>Node Packaged Modules</h3><p>npmは、ローカルあるいはグローバルモードでパッケージをインストールすることができます。<br>ローカルモードでは、現在使用しているディレクトリの親のところのnode_modulesフォルダにパッケージをインストールします。<br>この場所は、カレントユーザーによって所有されています。<br>グローバルパッケージは、{prefix}/lib/node_modules/というルート({prefix}は大抵/usr/か/usr/localのどちらか)が所持しているところにインストールされます。<br>これは、グローバルモードでパッケージをインストールするにはsudoを使う必要があるということで、このことによりセキュリティ問題と同じような第三者の依存性を解決している時にパーミッションエラーを引き起こします。<br>そのため、これを変更する必要があります。</p><h3>Changing the Location of Global Packages</h3><p>まず、npm configの出力がどうなるか見てみましょう。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fN8YSRdGx72pwVAwmnHfYg.gif" /></figure><p>これはインストールに関する情報を示してくれるもので、続いて現在のグローバルロケーションを知っておくことが重要になります。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FtHlJ2tkuZVWyFw4ypTxZQ.gif" /></figure><p>これこそが我々が変更したい接頭辞で、ホームディレクトリにグローバルパッケージをインストールすることについても同様です。<br>これを実行するには、ホームフォルダに新しくディレクトリを作成する必要があります。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zlcCCzTJUnSe5vW-z6aAtQ.gif" /></figure><p>この変更を行うことで、グローバルノードパッケージがインストールされる場所を変えることができました。<br>これはまた、.npmrcファイルをホームディレクトリに作成しています。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tuYwUZn2tzB1GyiyUsbjgg.gif" /></figure><p>まだルートが所持している場所にあるnpmがありますが、我々が有利に扱える場所にグローバルパッケージのロケーションを変更しました。<br>ここでもう一度npmをインストールする必要があるのですが、今回は新たにユーザーが保持している場所で行います。<br>これにより、最新バージョンのnpmをインストールすることも可能です。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*05Wv_PCPQp4ULs-V3e8-oA.gif" /></figure><p>最後に、.node_modules_global/binを$PATHの環境変数に加える必要があり、そうすることでコマンドラインからグローバルパッケージを実行できるようになります。<br>また、以下の行を.profileか.bash_profileもしくは.bashrcに加えて、ターミナルを再起動してください。</p><pre>export PATH=&quot;$HOME/.node_modules_global/bin:$PATH&quot;</pre><p>ここまでくれば、.node_modules_global/binが最初に見つかってnpmの正しいバージョンが使えるようになっているはずです。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*scbaHuMzyCcSYArfAGfKxg.gif" /></figure><h3>Installing Packages in Global Mode</h3><p>グローバルモードでは、最初はnpmパッケージ自身1つしかインストールできません。<br>そのため、それを変更して<a href="https://www.npmjs.com/package/uglify-js">UglifyJS</a>をインストールしましょう。<br> — globalというフラッグを使いますが、それは-gと省略可能です。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XSWFGl08dQskNrE852AHjQ.gif" /></figure><p>上の画像を見ると追加でパッケージがインストールされていますが、これはUglifyJSの依存性になります。</p><h3>Listing Global Packages</h3><p>npm listコマンドを使うと、インストールしたグローバルパッケージをリスト化できます。</p><pre>$ npm list --global<br>home/sitepoint/.node_modules_global/lib<br>├─┬ npm@5.0.2<br>│ ├── abbrev@1.1.0<br>│ ├── ansi-regex@2.1.1<br>│ ├── ansicolors@0.3.2<br>│ ├── ansistyles@0.1.3<br>....................<br>└─┬ uglify-js@3.0.15<br>  ├─┬ commander@2.9.0<br>  │ └── graceful-readlink@1.0.1<br>  └── source-map@0.5.6</pre><p>ただこれは非常に長ったらしいので、 — depth=0というオプションを使いましょう。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*t8FvCNZNtJUJ0KTGdeyGbQ.gif" /></figure><p>こうすることで、インストールしたパッケージとその情報だけを表示することができます。</p><p>グローバルモードでインストールしたパッケージは全てコマンドラインから使用可能で、例えばUglifyパッケージを使ってexample.jsをexample.min.jsに小さくするには以下のようにします。</p><pre>$ uglifyjs example.js -o example.min.js</pre><h3>Installing Packages in Local Mode</h3><p>ローカルでパッケージをインストールするには、通常package.jsonファイルを使用します。<br>実際にやってみましょう。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*u09W0cEzz9XYhRrnwYO8KA.gif" /></figure><p>Enterキーを押していき、最後にyesと打つことでpackage.jsonプロジェクトのルート部分でpackage.jsonファイルが作成されます。</p><p>注意：package.jsonファイルをササっと生成するには、npm init — yというコマンドを使ってみてください。</p><p>では、次に<a href="http://underscorejs.org/">Underscore</a>をインストールしてみましょう。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*n-37iA28TiS9qvSSMOM1dQ.gif" /></figure><p>ここで、ロックファイルが生成されたことに注意してください。<br>後ほど、この場所にまた戻ってきます。</p><p>ここでpackage.jsonファイルを確認すると、dependenciesフィールドが追加されたことが確認できるはずです。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/746/1*94FRiltzRCyTSUmhSCUboQ.gif" /></figure><h3>Managing Dependencies with package.json</h3><p>ここまでで、アンダースコアのv1.8.3がインストールされたことが確認できたと思います。</p><p>プロジェクトのルートのところでtest.jsファイルを作成し、以下のものをそのファイルに追加してみてください。</p><pre>const _ = require(&#39;underscore&#39;);<br>console.log(_.range(5));</pre><p>更にnode test.jsでそのファイルを実行して、[0, 1, 2, 3, 4]という結果が出力されることを確認してください。</p><h3>Uninstalling Local Packages</h3><p>npmはパッケージマネージャーなので、パッケージを消去することもできます。<br>現在のアンダースコアのパッケージに問題があると仮定して、それを消去して1つ古いバージョンのものをインストールしてみましょう。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*riNBLxSHli3OqvvxymezHA.gif" /></figure><h3>Installing a Specific Version of a Package</h3><p>では、続いて必要なバージョンのアンダースコアをインストールしましょう。<br>@を使うことで、バージョンを指定することができます。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7w4zkZq0ci_4SaGR6eR8Mw.gif" /></figure><h3>Updating a Package</h3><p>アンダースコアのパッケージにおいて、アップデートが可能かどうかチェックしてみましょう。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QN5uLoT0o6kDQBQ6vh7maA.gif" /></figure><h3>Searching for Packages</h3><p>このチュートリアルでは、mkdirコマンドを何回か使っています。<br>同じことができるノードパッケージがあるかどうか、npm searchを使って探してみましょう。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RhJ7bS7it4yRATp0nZd5VA.gif" /></figure><p><a href="https://www.npmjs.com/package/mkdirp">mkdirp</a>というものがあるので、インストールしましょう。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xGEnBp1broxt1WyYmRmq2A.gif" /></figure><p>続いてmkdir.jsというファイルを作成して、以下のコードを貼り付けてください。</p><pre>const mkdirp = require(&#39;mkdirp&#39;);<br>mkdirp(&#39;foo&#39;, function (err) {<br>  if (err) console.error(err)<br>  else console.log(&#39;Directory created!&#39;)<br>});</pre><p>そしてそれを、ターミナルから実行しましょう。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9aP1LrxzFXcxWpOfn--Atg.gif" /></figure><h3>Re-installing Project Dependencies</h3><p>まず最初に、もう1つパッケージをインストールしましょう。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*z_w2X6o6ujB_HxGaS8Mdhw.gif" /></figure><p>package.jsonをチェックしてみましょう。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XBA0GPFfUquTjuAru-qftw.gif" /></figure><p>ここで、依存性が自動でアップデートされたことに注意してください。<br>以前のバージョンのnpmでは、package.json内の依存性を保存するのにnpm install request — saveというコマンドを実行する必要がありました。<br>package.json内にそれを保存せずパッケージをインストールしたい場合は、 — no-saveという引数を使えばいいです。</p><p>ここでプロジェクトのソースコードを別のマシンにコピーしたと仮定して、依存性をインストールするとします。<br>node_modulesフォルダをまず削除して、続いてnpm installを実行しましょう。</p><pre>$ rm -R node-modules<br>$ npm list<br>project@1.0.0 /home/sitepoint/project<br>├── UNMET DEPENDENCY mkdirp@^0.5.1<br>├── UNMET DEPENDENCY request@^2.81.0<br>└── UNMET DEPENDENCY underscore@^1.8.2<br><br>npm ERR! missing: mkdirp@^0.5.1, required by project@1.0.0<br>npm ERR! missing: request@^2.81.0, required by project@1.0.0<br>npm ERR! missing: underscore@^1.8.2, required by project@1.0.0<br><br>$ npm install<br>added 57 packages in 1.595s</pre><p>node_modulesフォルダを見れば、これらが再生成されたことが確認できるはずです。<br>こうして、他者と簡単にコードをシェアすることができます。</p><h3>Managing the Cache</h3><p>npmでパッケージをインストールした場合それはコピーなので、次回それをインストールする場合は、ネットワークに繋ぐ必要はありません。<br>コピーは、ホームパス内の.npmディレクトリで見つかります。</p><pre>$ ls ~/.npm<br>anonymous-cli-metrics.json  _cacache  _locks  npm  registry.npmjs.org</pre><p>このディレクトリには古いパッケージが何度も溜められていくので、時折クリーンアップしてあげると効果的です。<br>npmのバージョン5以降は、 — forceのオプションが必須になりました。</p><pre>npm cache clean --force</pre><p>システム上にクリーンアップしたい多数のノードプロジェクトがある場合は、ワークスペースから全てのnode_moduleフォルダを消すこともできます。</p><pre>find . -name &quot;node_modules&quot; -type d -exec rm -rf &#39;{}&#39; +</pre><h3>Aliases</h3><p>ここまでやってきてわかるように、npmコマンドには色々な実行方法があります。<br>下に、よく使われるものをリストアップしました。</p><ul><li>npm i &lt;package&gt; – ローカルパッケージをインストール</li><li>npm i -g &lt;package&gt; – グローバルパッケージをインストール</li><li>npm un &lt;package&gt; – ローカルパッケージをアンインストール</li><li>npm up – npmでパッケージをアップデート</li><li>npm t – テストを実行</li><li>npm ls – インストールされたモジュールをリスト化</li><li>npm ll or npm la – モジュールをリスト化すると同時に、追加できるパッケージ情報を表示</li></ul><p>以下のようにすれば、一度に複数のパッケージをインストールできます。</p><pre>$ npm i express momemt lodash mongoose body-parser webpack</pre><p>npm helpコマンドを使えば、もっと色々なコマンドについて知ることができます。<br><a href="https://www.sitepoint.com/10-npm-tips-and-tricks/">この記事</a>を読めば、もっと詳しく知ることもできるでしょう。</p><h3>Version Managers</h3><p>同じマシンで、Node.jsの多数のバージョンを管理できるツールがあり、その1つが<a href="https://github.com/tj/n">n</a>で、<a href="https://github.com/creationix/nvm">nvm</a>というものもあります。<br>興味があれば、<a href="http://sitepoint.com/quick-tip-multiple-versions-node-nvm">この記事</a>をチェックしてみてください。</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9f4d04d3c80b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Chapter2. 値について]]></title>
            <link>https://medium.com/@kazunorikamiya/chapter2-%E5%80%A4%E3%81%AB%E3%81%A4%E3%81%84%E3%81%A6-6089f26e3e36?source=rss-e42be372267d------2</link>
            <guid isPermaLink="false">https://medium.com/p/6089f26e3e36</guid>
            <category><![CDATA[frontend-development]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[values]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Kazunori  Kamiya]]></dc:creator>
            <pubDate>Mon, 30 Oct 2017 16:04:12 GMT</pubDate>
            <atom:updated>2017-10-30T16:04:12.653Z</atom:updated>
            <content:encoded><![CDATA[<p>ここでは以下の記事を参考に、JavaScriptの値について書き進めていきます。<br>一部省略してありますが、ご了承ください。</p><p><a href="https://github.com/getify/You-Dont-Know-JS/blob/master/types%20%26%20grammar/ch2.md">getify/You-Dont-Know-JS</a></p><h3>Arrays</h3><p>JavaScriptにおける配列は単に値を含むコンテナのようなもので、文字列に数字やオブジェクト、更に別の配列さえも含むことができます。</p><pre>var a = [ 1, &quot;2&quot;, [3] ];<br><br>a.length;		// 3<br>a[0] === 1;		// true<br>a[2][0] === 3;	// true</pre><p>配列を作成するには、それを宣言して値を入れればいいです。</p><pre>var a = [ ];<br><br>a.length;	// 0<br><br>a[0] = 1;<br>a[1] = &quot;2&quot;;<br>a[2] = [ 3 ];<br><br>a.length;	// 3</pre><p>注意：配列においてdeleteを使ったとしても、仮に最後の要素を削除した場合でもlengthの値は変わらないことに注意してください。</p><p>また、まばらな配列の作成にも注意が必要です。(空っぽの要素などを入れること)</p><pre>var a = [ ];<br><br>a[0] = 1;<br>// no `a[1]` slot set here<br>a[2] = [ 3 ];<br><br>a[1];		// undefined<br><br>a.length;	// 3</pre><p>上の例において、空っぽのスロットは混乱しやすい部分でしょう。<br>a[1]はundefinedの値を保持しているように見えるものの、実際にa[1] = undefinedとなっている場合と全く同じ動作にはなりません。</p><p>配列は数の上ではインデックスがつけられているものの、面白いもので実は配列はオブジェクトでもあって、文字列のキーやプロパティをそこに加えることができます。(ただし、それは配列のlengthにはカウントされない)</p><pre>var a = [ ];<br><br>a[0] = 1;<br>a[&quot;foobar&quot;] = 2;<br><br>a.length;		// 1<br>a[&quot;foobar&quot;];	// 2<br>a.foobar;		// 2</pre><p>しかしながら、一般的に配列に文字列のキーやプロパティを加えるのはいいアイデアではなく、キーやプロパティに値を保持するにはobjectを使うべきです。</p><pre>var a = [ ];<br><br>a[&quot;13&quot;] = 42;<br><br>a.length; // 14</pre><h4>Array-Likes</h4><p>場合によっては、配列のような値を本物の配列に入れる必要が出てくる場合があるでしょう。</p><p>例えば、様々なDOMクエリオペレーションが本物の配列ではないけれどそれらしいDOM要素のリストを返却することができます。<br>もう1つのよく知られている例は、関数がリストとして引数にアクセスするために配列のような引数オブジェクトを晒すことです。</p><p>このような転換を行うよく知られた方法の1つが、値に対してslice(..)というユーティリティを取り入れることです。</p><pre>function foo() {<br>	var arr = Array.prototype.slice.call( arguments );<br>	arr.push( &quot;bam&quot; );<br>	console.log( arr );<br>}<br><br>foo( &quot;bar&quot;, &quot;baz&quot; ); // [&quot;bar&quot;,&quot;baz&quot;,&quot;bam&quot;]</pre><p>もしslice()が他のパラメーター無しで呼ばれた場合、そのパラメーターのデフォルト値にはその配列をコピーする効果があります。</p><p>ES6では、同じ効果を持つArray.from(..)というものがあります。</p><pre>...<br>var arr = Array.from( arguments );<br>...</pre><h4>Strings</h4><p>まず、以下の2つについて考えてみてください。</p><pre>var a = &quot;foo&quot;;<br>var b = [&quot;f&quot;,&quot;o&quot;,&quot;o&quot;];</pre><p>stringは配列に似たところがあり、例えばlengthプロパティやindexOf(..)メソッドにconcat(..)メソッドも保持しています。</p><pre>a.length;							// 3<br>b.length;							// 3<br><br>a.indexOf( &quot;o&quot; );					// 1<br>b.indexOf( &quot;o&quot; );					// 1<br><br>var c = a.concat( &quot;bar&quot; );			// &quot;foobar&quot;<br>var d = b.concat( [&quot;b&quot;,&quot;a&quot;,&quot;r&quot;] );	// [&quot;f&quot;,&quot;o&quot;,&quot;o&quot;,&quot;b&quot;,&quot;a&quot;,&quot;r&quot;]<br><br>a === c;							// false<br>b === d;							// false<br><br>a;									// &quot;foo&quot;<br>b;									// [&quot;f&quot;,&quot;o&quot;,&quot;o&quot;]</pre><p>これらが両方とも文字の配列のように思えますが、正確には違います。</p><pre>a[1] = &quot;O&quot;;<br>b[1] = &quot;O&quot;;<br><br>a; // &quot;foo&quot;<br>b; // [&quot;f&quot;,&quot;O&quot;,&quot;o&quot;]</pre><p>JavaScriptのstringは不変であり、一方で配列はとても変わりやすいです。<br>更に、a[1]というアクセスの仕方はJavaScriptでは無効です。<br>正しいアプローチ方法は、a.charAt(1)になります。</p><p>また、stringが不変であることの重要性は、stringのメソッドにそのコンテンツを適当に変えるためのものがないということで、それよりも新しいstringを生成して返すことになっています。<br>それに対して、配列のコンテンツを適当に変えるメソッドはたくさんあります。</p><pre>c = a.toUpperCase();<br>a === c;	// false<br>a;			// &quot;foo&quot;<br>c;			// &quot;FOO&quot;<br><br>b.push( &quot;!&quot; );<br>b;			// [&quot;f&quot;,&quot;O&quot;,&quot;o&quot;,&quot;!&quot;]</pre><p>また、配列のメソッドの多くは実際にはstringに対して使えないものの、それを扱う時に役立ちます。<br>ただ、この場合はstringに対して不変の配列メソッドを”借りる”と言った方がいいでしょう。</p><pre>a.join;			// undefined<br>a.map;			// undefined<br><br>var c = Array.prototype.join.call( a, &quot;-&quot; );<br>var d = Array.prototype.map.call( a, function(v){<br>	return v.toUpperCase() + &quot;.&quot;;<br>} ).join( &quot;&quot; );<br><br>c;				// &quot;f-o-o&quot;<br>d;				// &quot;F.O.O.&quot;</pre><p>もう1つ例を出すと、stringを反対にすることです。<br>配列には変化させるためにreverse()というメソッドがありますが、stringにはありません。</p><pre>a.reverse;		// undefined<br><br>b.reverse();	// [&quot;!&quot;,&quot;o&quot;,&quot;O&quot;,&quot;f&quot;]<br>b;				// [&quot;!&quot;,&quot;o&quot;,&quot;O&quot;,&quot;f&quot;]</pre><p>残念ながらこの”借りる”というやり方は配列のミューテーターではうまく動きませんが、なぜならstringは不変で適当に変えることはできないからです。</p><pre>Array.prototype.reverse.call( a );<br>// still returns a String object wrapper (see Chapter 3)<br>// for &quot;foo&quot; :(</pre><p>もう1つのワークアラウンドは、stringを配列に変換することで望み通りの操作を実行して、それからstringに戻すというやり方です。</p><pre>var c = a<br>	// split `a` into an array of characters<br>	.split( &quot;&quot; )<br>	// reverse the array of characters<br>	.reverse()<br>	// join the array of characters back to a string<br>	.join( &quot;&quot; );<br><br>c; // &quot;oof&quot;</pre><p>バカバカしく思えるかもしれませんが、単純なstringに対してはこのようにやります。</p><p>警告：このやり方は、アストラルシンボルや多バイトの文字を含む場合には使えません。この場合には、もっと高性能なライブラリが必要となります。(<a href="https://github.com/mathiasbynens/esrever">https://github.com/mathiasbynens/esrever</a>)</p><p>この問題に対する見方は、まだ他にもあります。<br>もしstringに関するタスクに取り組む場合にそれを文字の配列として扱えば、おそらくstringよりも単に配列として貯める方がいいでしょう。<br>いつもいつも、stringを配列に変換するために時間をロスしなくて済みます。<br>実際にいつでもstringの表現が必要な場合には、配列の文字に対してjoin(“”)を呼び出すことができます。</p><h4>Numbers</h4><h4>Numeric Syntax</h4><p>JavaScriptにおいては、一般的に数字のリテラルは10進法のリテラルで表現され、例えば以下のような感じです。</p><pre>var a = 42;<br>var b = 42.3;</pre><p>10進法の値において、先頭の0は任意のものとなります。</p><pre>var a = 42.0;<br>var b = 42.;</pre><p>同様に、値の最後においてドット(.)の後ろの0も任意のものとなります。</p><pre>var a = 42.0;<br>var b = 42.;</pre><p>警告：42. という書き方は有効ではあるものの、あまり一般的ではないため、混乱を避けるためにも使わない方がいいでしょう。</p><p>基本的には、numberというのは10進数で出力され、右端の0は省略されます。</p><pre>var a = 42.300;<br>var b = 42.0;<br><br>a; // 42.3<br>b; // 42</pre><p>デフォルトでは非常に大きいあるいは小さいnumberはべき指数の形で出力され、それはtoExponential()メソッドの出力と同じです。</p><pre>var a = 5E10;<br>a;					// 50000000000<br>a.toExponential();	// &quot;5e+10&quot;<br><br>var b = a * a;<br>b;					// 2.5e+21<br><br>var c = 1 / a;<br>c;					// 2e-11</pre><p>toFixed(..)メソッドは、値を表現する際に末端をどこまで表現するか指定することができます。</p><pre>var a = 42.59;<br><br>a.toFixed( 0 ); // &quot;43&quot;<br>a.toFixed( 1 ); // &quot;42.6&quot;<br>a.toFixed( 2 ); // &quot;42.59&quot;<br>a.toFixed( 3 ); // &quot;42.590&quot;<br>a.toFixed( 4 ); // &quot;42.5900&quot;</pre><p>この出力結果はnumberをstringで表したものであることに注意してほしく、また右端には実際にその値が保持しているものよりも多く0を表現することができます。</p><p>toPrecision(..)も似たようなもので、有効数字で何桁表現するのか指定することができます。</p><pre>var a = 42.59;<br><br>a.toPrecision( 1 ); // &quot;4e+1&quot;<br>a.toPrecision( 2 ); // &quot;43&quot;<br>a.toPrecision( 3 ); // &quot;42.6&quot;<br>a.toPrecision( 4 ); // &quot;42.59&quot;<br>a.toPrecision( 5 ); // &quot;42.590&quot;<br>a.toPrecision( 6 ); // &quot;42.5900&quot;</pre><p>これらのメソッドを使う際に値を含む変数である必要はなく、その数字に直接アクセスすることも可能です。<br>ただし、ドット(.)は有効な数字表現なのでまずnumberリテラルの一部と解釈されるため、使い方には注意してください。</p><pre>// invalid syntax:<br>42.toFixed( 3 );	// SyntaxError<br><br>// these are all valid:<br>(42).toFixed( 3 );	// &quot;42.000&quot;<br>0.42.toFixed( 3 );	// &quot;0.420&quot;<br>42..toFixed( 3 );	// &quot;42.000&quot;</pre><p>また、以下の書き方も技術的には有効です。</p><pre>42 .toFixed(3); // &quot;42.000&quot;</pre><p>しかしながら、これらは非常に紛らわしいコーディングスタイルなので、混乱を避けるためにも使わない方がいいでしょう。</p><p>numberはべき指数の形でも表現可能で、大きなnumberを扱う場合には一般的な手法です。</p><pre>var onethousand = 1E3;						// means 1 * 10^3<br>var onemilliononehundredthousand = 1.1E6;	// means 1.1 * 10^6</pre><p>numberリテラルは他の形でも表すことができ、例えば2進数に8進数や16進数があります。</p><p>現在のJavaScriptでは、以下のようになります。</p><pre>0xf3; // hexadecimal for: 243<br>0Xf3; // ditto<br><br>0363; // octal for: 243</pre><p>ノート：ES6のstrictモードでは、0363のような8進数の形は許容されません。strictモードでない場合は許容されますが、そもそもこのような形は将来的なことも考えて使うべきではないでしょう。</p><p>ES6では、新たに以下のような形も有効になりました。</p><pre>0o363;		// octal for: 243<br>0O363;		// ditto<br><br>0b11110011;	// binary for: 243<br>0B11110011; // ditto</pre><p>0O363のような形は使わない方がよく、基本的には小文字の0x、0b、0oを使う方がいいでしょう。</p><h4>Small Decimal Values</h4><p>二進法で浮動小数点数を使うことの最も面倒な副作用が、以下になります。</p><pre>0.1 + 0.2 === 0.3; // false</pre><p>数学的には正しいはずなのになぜfalseになるのかというと、二進数の浮動小数点数における0.1と0.2は正確ではないため、これらの足し算が行われた場合も0.3にはならないということです。<br>実際には0.30000000000000004と非常に近い値になるものの、この近いというのは見当はずれと同じです。</p><p>このままではnumberが全く使えないものに思えてしまいそうですが、勿論そんなことはありません。</p><p>この0.1 + 0.2と0.3のような比較をするには、何が必要となるでしょうか？</p><p>最も一般的な方法は、丸め誤差という比較の際に許容される非常に小さな値を使うことです。<br>これはしばしば計算機エプシロンとも呼ばれ、その値は2^-52 (2.220446049250313e-16)で、JavaScriptにおけるnumberの一種です。</p><p>ES6では、Number.EPSILONがその値を表すものとして既に定義されており、それを使うことが可能ですが、その定義に関しては注意してください。</p><pre>if (!Number.EPSILON) {<br>	Number.EPSILON = Math.pow(2,-52);<br>}</pre><p>このNumber.EPSILONを、2つのnumberが同じかどうか比較するのに用いることができます。(丸め誤差の許容できる範囲で)</p><pre>function numbersCloseEnoughToEqual(n1,n2) {<br>	return Math.abs( n1 - n2 ) &lt; Number.EPSILON;<br>}<br><br>var a = 0.1 + 0.2;<br>var b = 0.3;<br><br>numbersCloseEnoughToEqual( a, b );					// true<br>numbersCloseEnoughToEqual( 0.0000001, 0.0000002 );	// false</pre><p>浮動小数点数を含む最大の値は1.798e+308という非常に巨大なものであり、これはNumber.MAX_VALUEで事前に定義されています。<br>反対に小さい方は、Number.MIN_VALUEで5e-324と定義されており、負の値ではないもののゼロに非常に近いです。</p><h4>Safe Integer Ranges</h4><p>numberがどのように表現されるか見てきたところで、全ての整数のnumberには安全な値というものがあって、それは当然Number.MAX_VALUEよりも小さい値になります。</p><p>実際に安全に表すことのできる最も大きな整数とは、2⁵³ — 1でその値は9007199254740991になります。</p><p>この値も、ES6ではNumber.MAX_SAFE_INTEGERとして事前に定義されています。<br>その反対に、最小値である-9007199254740991もNumber.MIN_SAFE_INTEGERとして、同じく定義されています。</p><p>このような巨大な値を用いる場面としては、64-bitのIDをデータベースから引き出して扱う場合などがあります。<br>64-bitの数字は厳密にはnumberの型でないため、stringの型を使ってJavaScriptの中に保管しておかなければなりません。</p><p>こういった巨大なnumberを扱うことに関しては、ありがたいことにそんなに一般的ではありません。<br>しかしこのように非常に巨大な値を扱う必要が出てきた場合には、こういったものを使う必要が出てきます。<br>将来的にはおそらく、こういった大きな値もJavaScriptで公式にサポートされるようになるでしょう。</p><h4>Testing for Integers</h4><p>ある値が整数かどうかを確かめるには、Number.isInteger(..)というものを使うことができます。</p><pre>Number.isInteger( 42 );		// true<br>Number.isInteger( 42.000 );	// true<br>Number.isInteger( 42.3 );	// false</pre><p>Number.isInteger(..)は、ES6において以下のように定義されています。</p><pre>if (!Number.isInteger) {<br>	Number.isInteger = function(num) {<br>		return typeof num == &quot;number&quot; &amp;&amp; num % 1 == 0;<br>	};<br>}</pre><p>ある値が安全な整数かどうかを確かめるには、Number.isSafeInteger(..)というものを使いましょう。</p><pre>Number.isSafeInteger( Number.MAX_SAFE_INTEGER );	// true<br>Number.isSafeInteger( Math.pow( 2, 53 ) );			// false<br>Number.isSafeInteger( Math.pow( 2, 53 ) - 1 );		// true</pre><p>Number.isSafeInteger(..)は、ES6で以下のように定義されています。</p><pre>if (!Number.isSafeInteger) {<br>	Number.isSafeInteger = function(num) {<br>		return Number.isInteger( num ) &amp;&amp;<br>			Math.abs( num ) &lt;= Number.MAX_SAFE_INTEGER;<br>	};<br>}</pre><h4>32-bit (Signed) Integers</h4><p>64-bitの話を上でしましたが、中には32-bitのnumberに対してのみ定義されたオペレーションもあり、その場合のnumberの安全な範囲というのは64-bitに比べて小さくなります。</p><p>その範囲とは、Math.pow(-2,31)すなわち-2147483648からMath.pow(2,31)-1すなわち2147483647となります。</p><p>aというもののnumber値を32-bitのものにするには、a | 0というものを用います。</p><h3>Special Values</h3><p>JavaScriptには、開発者が注意すべき特別な値がいくつかあります。</p><h4>The Non-value Values</h4><p>undefinedという型には、undefinedという唯一の値と型しかありません。<br>同様にnullにもnullという唯一の値と型しかなく、この2つに関しては文字がそのまま型を値を表しています。</p><p>この2つは値が空っぽ、あるいは値がないという意味に捉えられがちで、開発者によってはニュアンスで区別しようとします。</p><ul><li>null とは空の値である</li><li>undefined とは値が失われているということである</li></ul><p>もしくは</p><ul><li>undefined はまだ値を保持していない</li><li>null には値が入っていない</li></ul><p>この2つのうち、nullは特殊なキーワードであって識別子ではないため、変数をアサインするような扱い方はできません。<br>しかしながら、undefinedは識別子となっています。</p><h4>void Operator</h4><p>undefinedという値を得るのには、もう1つvoidというオペレーターを使う方法があります。</p><p>voidを使うと、常にundefinedという値が描写されます。<br>これは既存の値を変更しているのではなく、何の値もそのオペレーターからは返って来ないことを保証しているだけです。</p><pre>var a = 42;<br><br>console.log( void a, a ); // undefined 42</pre><p>voidによる表現は、どんな形でも基本的に結果は同じです。<br>そのため、void 0やvoid 1とundefinedに特に実践的な違いはありません。</p><p>しかしvoidは数は少ないながらもそれが役立つ環境があり、ある表現が結果として何の値も保持していないことを保証する必要がある場合などに使えます。</p><pre>function doSomething() {<br>	// note: `APP.ready` is provided by our application<br>	if (!APP.ready) {<br>		// try again later<br>		return void setTimeout( doSomething, 100 );<br>	}<br><br>	var result;<br><br>	// do some other stuff<br>	return result;<br>}<br><br>// were we able to do it right away?<br>if (doSomething()) {<br>	// handle next tasks right away<br>}</pre><p>ここでsetTimeout(..)という関数は数値を返しますが、voidを使うことでその返却される値はif文に伴う偽陽性を与えません。</p><p>多くの開発者はこれらのアクションを分けたがり、以下のものは同じ働きをしますがvoidを含みません。</p><pre>if (!APP.ready) {<br>	// try again later<br>	setTimeout( doSomething, 100 );<br>	return;<br>}</pre><h4>Special Numbers</h4><p>numberには特別な値のものがいくつかあり、順番に見ていきましょう。</p><h4>The Not Number, Number</h4><p>NaNは”not a number&quot;のことを表しているものの、この表現は非常に頼りなくて誤解を生じやすいです。<br>“invalid number”や”failed number”、”bad number”と言ったほうがより正確でしょう。</p><pre>var a = 2 / &quot;foo&quot;;		// NaN<br><br>typeof a === &quot;number&quot;;	// true</pre><p>上の式を言い換えると、”the type of not-a-number is ‘number’!”と言っており、これでは混乱してしまいます。</p><p>NaNというのはnumberにおけるエラー状態を表す特別なものの一種で、これについてある値を持つ変数とテストしたい場合、nullやundefinedのようにNaN自身と直接比べることができると思うかもしれませんが、残念ながら違います。</p><pre>var a = 2 / &quot;foo&quot;;<br><br>a == NaN;	// false<br>a === NaN;	// false</pre><p>NaNは特殊なもので、他のNaNや自分自身とも決してイコールになりません。<br>NaNは単なる値を表しており、再帰性がないためNaN !== NaNとなるのです。</p><p>ではこのNaNと比較できないときにどうするかというと、以下のようにします。</p><pre>var a = 2 / &quot;foo&quot;;<br><br>isNaN( a ); // true</pre><p>isNaN(..)というものを使うことで、その値がNaNであるかどうかが判明します。</p><p>ただisNaN(..)には大きな欠点があって、これはNaNを文字どおりに捉えすぎようとしてしまいます。<br>どういう意味かというと、テストするものがnumberでないかnumberであることのうちどちらかを選ばなければならないということです。<br>ただ、このやり方は正確ではありません。</p><pre>var a = 2 / &quot;foo&quot;;<br>var b = &quot;foo&quot;;<br><br>a; // NaN<br>b; // &quot;foo&quot;<br><br>window.isNaN( a ); // true<br>window.isNaN( b ); // true -- ouch!</pre><p>明らかに”foo”はnumberではありませんが、同時にNaNという値でもありません。<br>このバグは、JavaScriptの初期から続いています。</p><p>ES6では、とうとうその代わりとなるNumber.isNaN(..)が加えられました。</p><pre>if (!Number.isNaN) {<br>	Number.isNaN = function(n) {<br>		return (<br>			typeof n === &quot;number&quot; &amp;&amp;<br>			window.isNaN( n )<br>		);<br>	};<br>}<br><br>var a = 2 / &quot;foo&quot;;<br>var b = &quot;foo&quot;;<br><br>Number.isNaN( a ); // true<br>Number.isNaN( b ); // false -- phew!</pre><p>また、NaNはそれ自身とも等しくないという特異な事実を利用して、Number.isNaN(..)を実行することができます。<br>NaNはどの言語においても単なる値で、他の全ての値はそれ自身に等しいです。</p><pre>if (!Number.isNaN) {<br>	Number.isNaN = function(n) {<br>		return n !== n;<br>	};<br>}</pre><h4>Infinities</h4><p>Cなどの言語ではゼロで割るような演算はコンパイルエラーとなりますが、JavaScriptにおいてはInfinity(Number.POSITIVE_INFINITY)というものがしっかり定義されています。</p><pre>var a = 1 / 0;	// Infinity<br>var b = -1 / 0;	// -Infinity</pre><p>上の例を見ればわかるように、負の値をゼロで割った場合は-Infinity(Number.NEGATIVE_INFINITY)という結果になります。</p><p>JavaScriptは限定的な数学表現を使っているため、純粋な数学と比べると足し算や引き算でさえも溢れさせることが可能に思え、そのような場合ではInfinityや-Infinityが得られます。</p><p>例えば、以下のようなものが例として挙げられます。</p><pre>var a = Number.MAX_VALUE;	// 1.7976931348623157e+308<br>a + a;						// Infinity<br>a + Math.pow( 2, 970 );		// Infinity<br>a + Math.pow( 2, 969 );		// 1.7976931348623157e+308</pre><p>上の記述を見ると、このような足し算の値は非常に巨大なものとなり、その場合にIEEE 754が最も近い整数値に値を丸め込むということをやります。<br>雑な分類となりますが、そのためNumber.MAX_VALUE + Math.pow( 2, 969 )はInfinityよりもNumber.MAX_VALUEに近いため切り捨てられ、一方でNumber.MAX_VALUE + Math.pow( 2, 970 )はinfinityに近いため切り上げられて、このような形になるのです。</p><h4>Zeros</h4><p>JavaScriptにおいては、普通のゼロと負のゼロ(-0)があります。<br>なぜ負のゼロが存在するのかを説明する前に、どのようにJavaScriptがそれを扱うのか見ていきましょう。</p><p>文字どおりに-0と書くのに加えて、負のゼロはとある数学の計算式からも生まれます。</p><pre>var a = 0 / -3; // -0<br>var b = 0 * -3; // -0</pre><p>足し算引き算では、負のゼロは生まれません。</p><p>また、負のゼロの文字列に変換しようとすると、それは常に”0”として表示されるでしょう。</p><pre>var a = 0 / -3;<br><br>// (some browser) consoles at least get it right<br>a;							// -0<br><br>// but the spec insists on lying to you!<br>a.toString();				// &quot;0&quot;<br>a + &quot;&quot;;						// &quot;0&quot;<br>String( a );				// &quot;0&quot;<br><br>// strangely, even JSON gets in on the deception<br>JSON.stringify( a );		// &quot;0&quot;</pre><p>面白いことに、この逆の操作(stringをnumberにすること)は嘘をつきません。</p><pre>+&quot;-0&quot;;				// -0<br>Number( &quot;-0&quot; );		// -0<br>JSON.parse( &quot;-0&quot; );	// -0</pre><p>また、負のゼロの文字列化がその本当の値を隠すために我々を欺こうとしているのに加えて、比較演算子もまた嘘つきのように見えます。</p><pre>var a = 0;<br>var b = 0 / -3;<br><br>a == b;		// true<br>-0 == 0;	// true<br><br>a === b;	// true<br>-0 === 0;	// true<br><br>0 &gt; -0;		// false<br>a &gt; b;		// false</pre><p>コードの中で-0と0と区別しようとする場合には、コンソールの出力に頼るだけではなく、もう少し利口になる必要があります。</p><pre>function isNegZero(n) {<br>	n = Number( n );<br>	return (n === 0) &amp;&amp; (1 / n === -Infinity);<br>}<br><br>isNegZero( -0 );		// true<br>isNegZero( 0 / -3 );	// true<br>isNegZero( 0 );			// false</pre><h4>Special Equality</h4><p>上でNaNと-0という2つの特殊な値について見てきましたが、ES6ではこれらに対して本当に等しいのか例外なくテストするために、Object.is(..)という機能が追加されました。</p><pre>var a = 2 / &quot;foo&quot;;<br>var b = -3 * 0;<br><br>Object.is( a, NaN );	// true<br>Object.is( b, -0 );		// true<br><br>Object.is( b, 0 );		// false</pre><p>pre-ES6には、Object.is(..)に対するとてもシンプルなポリフィルがあります。</p><pre>if (!Object.is) {<br>	Object.is = function(v1, v2) {<br>		// test for `-0`<br>		if (v1 === 0 &amp;&amp; v2 === 0) {<br>			return 1 / v1 === 1 / v2;<br>		}<br>		// test for `NaN`<br>		if (v1 !== v1) {<br>			return v2 !== v2;<br>		}<br>		// everything else<br>		return v1 === v2;<br>	};<br>}</pre><p>Object.is(..)は、==や==が使えるような場面では使わない方がよく、これらの特別な場合でのみ用いる方がいいでしょう。</p><h4>Value vs. Reference</h4><p>JavaScriptにおいて、ポインターというものはなくてリファレンスも他の多くの言語とは異なる動きをします。<br>JavaScriptのある1つの変数からもう1つの変数に対して、リファレンスを保持することはできません。</p><p>JavaScriptにおけるリファレンスは値を指し示し、それゆえリファレンスが10個あれば、それらはそれぞれ1つの値に対応する完全に別のものです。</p><p>まずは、下の例を見てみましょう。</p><pre>var a = 2;<br>var b = a; // `b` is always a copy of the value in `a`<br>b++;<br>a; // 2<br>b; // 3<br><br>var c = [1,2,3];<br>var d = c; // `d` is a reference to the shared `[1,2,3]` value<br>d.push( 4 );<br>c; // [1,2,3,4]<br>d; // [1,2,3,4]</pre><p>上の例において、aはまず2というその値のコピーを保持していて、bは更にそのもう1つのコピーとなります。<br>もしbに変更があった場合でも、aの値が変わることはありません。</p><p>しかしcとdは、[1,2,3]という同じ共有値に対する異なるリファレンスです。<br>ここで重要なのは、cとdのどちらもそれ自身の[1,2,3]という値を持っていない点であり、両方ともその値に対する同じ立場のリファレンスなのです。<br>そのため、どちらか一方に.push(4)という変更を加えようとした場合、それは1つの共有値に加えられるため、両方のリファレンスが新たに変更された[1,2,3,4]を参照するのようになるのです。</p><p>リファレンスは変数ではなくその値自身を指し示すため、他のリファレンスが示している部分を変更するために1つのリファレンスを使用することはできません。</p><pre>var a = [1,2,3];<br>var b = a;<br>a; // [1,2,3]<br>b; // [1,2,3]<br><br>// later<br>b = [4,5,6];<br>a; // [1,2,3]<br>b; // [4,5,6]</pre><p>b = [4,5,6]というアサインメントを作成したとき、まだ[1,2,3]を参照しているaに影響を与えることはありません。<br>もしそうしたい場合、bはその配列に対するリファレンスではなくてaに対するポインターである必要がありますが、それを実現する方法はJavaScriptにはありません。</p><p>このような混乱は、関数のパラメーターでよく起こります。</p><pre>function foo(x) {<br>	x.push( 4 );<br>	x; // [1,2,3,4]<br><br>	// later<br>	x = [4,5,6];<br>	x.push( 7 );<br>	x; // [4,5,6,7]<br>}<br><br>var a = [1,2,3];<br><br>foo( a );<br><br>a; // [1,2,3,4]  not  [4,5,6,7]</pre><p>aという引数に着目すると、まずこれがaというリファレンスのコピーをxにアサインします。<br>xとaは同じ[1,2,3]という値を示す、異なるリファレンスになります。<br>そして関数の中では、その値自身を変化させるpush(4)のためにそのリファレンスを使うことができます。<br>しかし x = [4,5,6]というアサインメントを作成したとき、最初のリファレンスであるaが示す値に影響を与える方法はなく、これはまだ新たに変更された[1,2,3,4]を示しています。</p><p>aが示すものを変更するために、xのリファレンスを使う方法はありません。<br>aとxが示す共有値のコンテンツだけを、我々は変更することができます。</p><p>aが[4,5,6,7]という値のコンテンツを持つように変更させるには、新たに配列を作成してアサインすることはできなくて、既存の配列の値を変更しなければなりません。</p><pre>function foo(x) {<br>	x.push( 4 );<br>	x; // [1,2,3,4]<br><br>	// later<br>	x.length = 0; // empty existing array in-place<br>	x.push( 4, 5, 6, 7 );<br>	x; // [4,5,6,7]<br>}<br><br>var a = [1,2,3];<br><br>foo( a );<br><br>a; // [4,5,6,7]  not  [1,2,3,4]</pre><p>見てわかるように、x.length = 0とx.push(4,5,6,7)は新たに配列を作成しているのではなく、既存の配列を変更してaというリファレンスが[4,5,6,7]という値を保持するようにしてあります。</p><p>配列のような色々な値が混ざったものを、値のコピーによって効果的に変更させる場合、手作業でそのコピーを作成する必要があり、そうなるとそのリファレンスは元々のものを示したりはしません。</p><pre>foo( a.slice() );</pre><p>slice(..)はデフォルトでパラメーターなしで、配列のコピーを新たに作成することができます。<br>そのため我々はコピーされた配列のリファレンスに対してのみ変更することが可能で、foo()はaのコンテンツに影響を与えることはありません。</p><p>逆のことをする場合、つまりある方法でスカラーのプリミティブ値を変更してリファレンスのようにその変更が見えるようにするとき、その値を値が混ざった別のもの(オブジェクトや配列など)にラップする必要があって、それはリファレンスのコピーから変更できます。</p><pre>function foo(wrapper) {<br>	wrapper.a = 42;<br>}<br><br>var obj = {<br>	a: 2<br>};<br><br>foo( obj );<br><br>obj.a; // 42</pre><p>ここでobjは、aというスカラープリミティブ値に対するラッパーとして働きます。<br>それがfoo()に渡されたとき、objリファレンスのコピーが変更されてwrapperというパラメーターにセットされます。<br>こうなると、共有されたオブジェクトにアクセスするためにwrapperリファレンスを使うことができ、そのプロパティを変更することも可能になります。</p><p>2のようなスカラープリミティブ値に対してリファレンスの変更をしたい場合に、こういったことが起きる可能性があり、その場合は値をNumberオブジェクトラッパーの中に入れることができます。</p><p>このNumberオブジェクトに対するリファレンスの真のコピーは関数に渡され、しかしあいにく共有されたオブジェクトに対するリファレンスを持つことは、共有されたプリミティブ値に変更を加える能力を与えてはくれません。</p><pre>function foo(x) {<br>	x = x + 1;<br>	x; // 3<br>}<br><br>var a = 2;<br>var b = new Number( a ); // or equivalently `Object(a)`<br><br>foo( b );<br>console.log( b ); // 2, not 3</pre><p>ここでの問題というのは、潜在的なスカラープリミティブ値が変化しないということです。<br>もしNumberオブジェクトが2というスカラープリミティブ値を保持していた場合、そのNumberオブジェクトが他の値を持つために変更されるという風にはできません。<br>異なる値を持つオブジェクトを含む、Numberオブジェクトを新たに作成する必要があります。</p><p>xがx + 1という形で表現されたとき、潜在的なスカラープリミティブ値である2がNumberオブジェクトから自動的に引き出され、そのためx = x + 1はxを共有されたリファレンスからNumberオブジェクトという微妙な変更をし、2 + 1という足し算の結果として3というスカラープリミティブ値を保持します。<br>それゆえ、外側のbはまだ2という値を保持する元々のNumberオブジェクトを参照しています。</p><p>Numberオブジェクトのトップにプロパティを加えることもでき、そのためそれらの追加されたプロパティを通してそれとなく情報を交換することができます。</p><p>Numberというラッパーオブジェクトをこのように使う代わりに、前のコードで扱った(obj)アプローチのようなマニュアルオブジェクトラッパーを使う方が恐らくベターでしょう。<br>これはNumberの使い道があまりないという意味ではなく、単に多くのケースでマニュアルオブジェクトラッパーを使うことが好まれるということです。</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6089f26e3e36" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[JavaScriptの型について]]></title>
            <link>https://medium.com/@kazunorikamiya/javascript%E3%81%AE%E5%9E%8B%E3%81%AB%E3%81%A4%E3%81%84%E3%81%A6-98e912eecad?source=rss-e42be372267d------2</link>
            <guid isPermaLink="false">https://medium.com/p/98e912eecad</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[frontend]]></category>
            <category><![CDATA[front-end-development]]></category>
            <category><![CDATA[type]]></category>
            <dc:creator><![CDATA[Kazunori  Kamiya]]></dc:creator>
            <pubDate>Wed, 25 Oct 2017 15:44:02 GMT</pubDate>
            <atom:updated>2017-10-25T15:44:02.362Z</atom:updated>
            <content:encoded><![CDATA[<p>ここでは、以下の記事を元にして進めていきます。</p><p><a href="https://github.com/getify/You-Dont-Know-JS/blob/master/types%20%26%20grammar/ch1.md">getify/You-Dont-Know-JS</a></p><p>途中いくつか、筆者が知っている部分は省いているのでご了承ください。</p><h3>Built-in Types</h3><p>JavaScriptには、元々備わっている型の種類が7つあります。</p><ul><li>null</li><li>undefined</li><li>boolean</li><li>number</li><li>string</li><li>object</li><li>symbol -- added in ES6!</li></ul><p>objectを除いたこれらの型は、プリミティブと呼ばれています。</p><p>typeofというオペレーターで与えられた変数の型を調べることができ、7つの型のうちどれか1つを返します。<br>驚くことに、リストアップした7つの型とちょうど1対1で紐付くわけではないのです。</p><pre>typeof undefined     === &quot;undefined&quot;; // true<br>typeof true          === &quot;boolean&quot;;   // true<br>typeof 42            === &quot;number&quot;;    // true<br>typeof &quot;42&quot;          === &quot;string&quot;;    // true<br>typeof { life: 42 }  === &quot;object&quot;;    // true<br><br>// added in ES6!<br>typeof Symbol()      === &quot;symbol&quot;;    // true</pre><p>これら6つの型はその型に一致する値を保持し、同じ名前の文字列を返却します。<br>Symbolは、ES6で新たに登場した型です。</p><p>お気付きのようにnullだけ上のリストから外していましたが、これはある意味特別のものでtypeofオペレーターと結合すると変な反応を見せます。</p><pre>typeof null === &quot;object&quot;; // true</pre><p>本来であれば”null”が返ってくるのが正しいんでしょうが、このバグには既存のWebコンテンツなどで複雑な要因が絡んでおり、下手に修正しようとするとより多くのバグを生み出す可能性が高く、修正される可能性はほぼないと見ていいでしょう。</p><p>nullという値のテストをしたい場合、状態の組み合わせが必要になります。</p><pre>var a = null;<br><br>(!a &amp;&amp; typeof a === &quot;object&quot;); // true</pre><p>nullはfalsy(false-like)という唯一のプリミティブな値で、typeofによるチェックからobjectを返却します。</p><p>それでは、typeofが返却することのできる7番目の文字列値は何になるでしょうか？</p><pre>typeof function a(){ /* .. */ } === &quot;function&quot;; // true</pre><p>functionが、JavaScriptにおいてトップレベルのビルトイン型だということは、容易に想像できるかもしれません。<br>しかしながら、specを読んでみると実際にはこれはobjectのサブタイプ(亜型)であるということに気づくはずで、functionは呼び出し可能なオブジェクトとして参照されており、内側に[[Call]]プロパティを含むオブジェクトはそれによって呼び出すことが可能です。</p><p>functionはobjectの一種だというのはとても便利な事実で、最も重要なのはプロパティを保持できるということです。</p><pre>function a(b,c) {<br>	/* .. */<br>}</pre><p>functionオブジェクトは、宣言されている仮引数の数を数えるためにlengthというプロパティを持っています。</p><pre>a.length; // 2</pre><p>ここではbとcという2つの仮引数を持つ関数を定義したので、そのlengthは2になります。</p><p>JavaScriptに元々ある配列については、どうなるでしょうか？</p><pre>typeof [1,2,3] === &quot;object&quot;; // true</pre><p>JavaScriptにおける配列は何も特別なものではなく、単なるオブジェクトです。</p><h3>Values as Types</h3><p>JavaScriptでは変数が型を持つのではなく、<strong>その値が型を持っています</strong>。<br>変数は、いつでもどんな値でも保持することができます。</p><p>変数に対してtypeofを使った場合、その変数の型が何なのか聞いているのではなく、代わりにその変数の値の型は何なのかを聞いていることになります。</p><pre>var a = 42;<br>typeof a; // &quot;number&quot;<br><br>a = true;<br>typeof a; // &quot;boolean&quot;</pre><p>typeofオペレーターは、常に文字列を返却します。<br>ちょっと、下の例を見てください。</p><pre>typeof typeof 42; // &quot;string&quot;</pre><p>最初のtypeof 42が”number”を返却し、更にtypeof “number”は”string”となります。</p><h3>undefined vs &quot;undeclared&quot;</h3><p>値を持たない変数というのは、実際にはundefinedな値を保持していることになります。<br>そのような変数に対してtypeofを用いると、”undefined”が返ってきます。</p><pre>var a;<br><br>typeof a; // &quot;undefined&quot;<br><br>var b = 42;<br>var c;<br><br>// later<br>b = c;<br><br>typeof b; // &quot;undefined&quot;<br>typeof c; // &quot;undefined&quot;</pre><p>多くの開発者は”undefined”と”undeclared.”という言葉を同義語あるいは類義語として捉えがちですが、JavaScriptにおいてはこの2つの概念は全く異なります。</p><p>”undefined”な変数はアクセス可能なスコープ内で宣言されているものの、たまたまその場合に値を保持していないだけです。<br>それに対して”undeclared”な変数は、そもそもアクセス可能なスコープ内で正式に宣言されていないものです。</p><p>ちょっと下の例を見てみてください。</p><pre>var a;<br><br>a; // undefined<br>b; // ReferenceError: b is not defined</pre><p>“undefined”と”is not defined”の違いがややこしいかもしれませんが、この2つは実はかなり異なるものなのです。<br>もしブラウザが、”b is not found”あるいは“b is not declared,”と言ってくれたら混乱する可能性も減るでしょうが。</p><p>実は、宣言されていない変数に関して更にもっと紛らわしい振る舞いをする特殊なものが、typeofにはあるんです。</p><pre>var a;<br><br>typeof a; // &quot;undefined&quot;<br><br>typeof b; // &quot;undefined&quot;</pre><p>typeofオペレーターが、”undeclared”な変数(もしくは“not defined”)に関してさえも“undefined”を返却しています。<br>このときbは宣言されていないにも関わらず、typeof bを実行した場合にエラーが出ないことに注意してください。<br>これはtypeofの振る舞いにおける、特殊なセーフティーガードなのです。</p><h3>typeof Undeclared</h3><p>それでもブラウザでJavaScriptを扱う際にはセーフティーガードは便利なもので、多くのスクリプトファイルが変数を共有のグローバル名前空間にロードすることができます。</p><p>ノート：多くの開発者がグローバル名前空間には全く変数が存在せず、全てがモジュールとプライベートもしくは隔てられた名前空間に含まれていると思っています。これは理論的には素晴らしいですが、実際にはありえません。幸いなことに、ES6ではモジュールに対して最上のサポートが追加され、そのことが結局はそれをより実践的にしてくれるでしょう。</p><p>簡単な例として、デバッグモードでDEBUGというグローバル変数を保持しているところを想像してみてください。<br>コンソールにログを吐き出すようなデバッグの実行前に、その変数が宣言されているかどうかチェックしてみたくなることでしょう。<br>トップレベルのグローバルなvar DEBUG = trueという宣言が”debug.js”ファイルのみに含まれており、開発やテストの際にブラウザにロードしますが、それはまだ制作途中です。</p><p>しかしながら、残りのアプリケーションのコードでグローバルなDEBUGという変数をチェックする際には気をつける必要があり、それはReferenceErrorを投げないようにすることです。<br>この場合に、typeofのセーフティーガードが役に立ちます。</p><pre>// oops, this would throw an error!<br>if (DEBUG) {<br>	console.log( &quot;Debugging is starting&quot; );<br>}<br><br>// this is a safe existence check<br>if (typeof DEBUG !== &quot;undefined&quot;) {<br>	console.log( &quot;Debugging is starting&quot; );<br>}</pre><p>この手のチェックは、ユーザー定義されているDEBUGのような変数を扱わない場合にも便利です。<br>ビルトインAPIの機能チェックをしている場合、エラーを投げずにチェックできることが非常に便利だと気づくでしょう。</p><pre>if (typeof atob === &quot;undefined&quot;) {<br>	atob = function() { /*..*/ };<br>}</pre><p>ノート：もしif文の中でvar atobの宣言を行った場合、たとえそのif文が通らなかったとしても、その宣言はスコープのトップまで釣り上げられます。(グローバルなatobが既に存在しているため) いくつかのブラウザとグローバルビルトイン変数(ホストオブジェクトと呼ばれます)のある特別ないくつかの型については、この重複した宣言はエラーを投げるでしょう。varを省略することで、こう言った宣言が釣り上げられることを防ぎます。</p><p>グローバル変数に対してtypeofのセーフティーガードを使わずこれらのチェックをするもう1つの方法は、全てのグローバル変数はグローバルオブジェクトのプロパティでもあると気づくことであり、ブラウザにおける基本的なそれはwindowオブジェクトになります。<br>そのため、上の方でやったチェックは以下のようにもできます。</p><pre>if (window.DEBUG) {<br>	// ..<br>}<br><br>if (!window.atob) {<br>	// ..<br>}</pre><p>宣言されていない変数を参照するのと違い、存在しないオブジェクトプロパティ(グローバルwindowオブジェクトでも)にアクセスしようとしてもReferenceErrorは投げられません。</p><p>その一方で、特に複数のJavaScript環境(ブラウザに限らず、例えばnode.jsなど)、すなわちグローバルオブジェクトが常にwindowとは呼ばれないところでコードを実行する必要がある場合は、windowリファレンスを伴うグローバル変数の手動での参照はある程度の開発者が避けようとするものです。</p><p>これらの事情は一般的ではないにも関わらず、技術的にはtypeofのセーフティーガードはグローバル変数を使っていない場合でも便利であり、ある程度の開発者はこのデザインアプローチを望ましくないと気づくでしょう。<br>他者にもコピペして使ってほしいと思うような有用な関数を想像してほしいのですが、そこでそれを含むプログラムが確かに定義された変数を保持しているかどうかチェックしたくなることでしょう。</p><pre>function doSomethingCool() {<br>	var helper =<br>		(typeof FeatureXYZ !== &quot;undefined&quot;) ?<br>		FeatureXYZ :<br>		function() { /*.. default feature ..*/ };<br><br>	var val = helper();<br>	// ..<br>}</pre><p>doSomethingCool()はFeatureXYZという変数に対してテストを行い、もし見つかればそれを使い、もし見つからなければそれ自身を使います。<br>つまり、もし誰かがその有益性をプログラムやモジュールに含めた場合、FeatureXYZを定義したかどうか安全にチェックすることができます。</p><pre>// an IIFE (see &quot;Immediately Invoked Function Expressions&quot;<br>// discussion in the *Scope &amp; Closures* title of this series)<br>(function(){<br>	function FeatureXYZ() { /*.. my XYZ feature ..*/ }<br><br>	// include `doSomethingCool(..)`<br>	function doSomethingCool() {<br>		var helper =<br>			(typeof FeatureXYZ !== &quot;undefined&quot;) ?<br>			FeatureXYZ :<br>			function() { /*.. default feature ..*/ };<br><br>		var val = helper();<br>		// ..<br>	}<br><br>	doSomethingCool();<br>})();</pre><p>ここでFeatureXYZはグローバル変数ではありませんが、我々は安全にチェックするためにtypeofのセーフティーガードをまだ使うことができます。<br>そして重要なのが、ここで我々がチェックをするために扱えるオブジェクトはなく、それゆえtypeofは非常に役に立つのです。</p><p>他の開発者は依存性注入というデザインパターンを好むでしょうが、これはdoSomethingCool()にFeatureXYZが周辺あるいは外で定義されているか案に調査させる代わりに、以下のようにはっきりと依存性をパスすることが必要となります。</p><pre>function doSomethingCool(FeatureXYZ) {<br>	var helper = FeatureXYZ ||<br>		function() { /*.. default feature ..*/ };<br><br>	var val = helper();<br>	// ..<br>}</pre><p>他にもこのような機能性デザインをする場合には多くのオプションがあり、どれが正解でどれが間違っているということはありません。<br>それぞれの一長一短があるものの、総体的にはtypeofという宣言されていないもののセーフティーガードがより多くのオプションを与えてくれます。</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=98e912eecad" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[JavaScriptの関数とブロックについて]]></title>
            <link>https://medium.com/@kazunorikamiya/javascript%E3%81%AE%E9%96%A2%E6%95%B0%E3%81%A8%E3%83%96%E3%83%AD%E3%83%83%E3%82%AF%E3%81%AB%E3%81%A4%E3%81%84%E3%81%A6-5198d72856fb?source=rss-e42be372267d------2</link>
            <guid isPermaLink="false">https://medium.com/p/5198d72856fb</guid>
            <category><![CDATA[function]]></category>
            <category><![CDATA[front-end-development]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[scopes]]></category>
            <dc:creator><![CDATA[Kazunori  Kamiya]]></dc:creator>
            <pubDate>Wed, 25 Oct 2017 03:56:49 GMT</pubDate>
            <atom:updated>2017-10-25T03:56:49.417Z</atom:updated>
            <content:encoded><![CDATA[<p>今回は、以下の記事を元に書き進めていきます。</p><p><a href="https://github.com/getify/You-Dont-Know-JS/blob/master/scope%20%26%20closures/ch3.md">getify/You-Dont-Know-JS</a></p><p>最初の初歩的な部分中心に、筆者が既に知っている部分は飛ばしているのでご了承ください。</p><h3>Chapter3: 関数とブロックスコープ</h3><h3>Functions As Scopes</h3><p>JavaScriptでは、変数や関数の宣言を効果的にその外側のスコープから内側のスコープに隠すことができます。</p><p>例えば、以下のような感じです。</p><pre>var a = 2;<br><br>function foo() { // &lt;-- insert this<br><br>	var a = 3;<br>	console.log( a ); // 3<br><br>} // &lt;-- and this<br>foo(); // &lt;-- and this<br><br>console.log( a ); // 2</pre><p>ただこのままでは少々問題があり、まず1つ目はfoo()という名前の関数を宣言しなければならないこと、つまりfooというもの自身が囲まれたスコープの邪魔をしてしまうのです。(この場合は、グローバルスコープ)<br>また、これではfoo()という関数を呼び出す際にその名前を明示してやる必要があり、そうすることでその中のコードが実行されます。</p><p>もし呼び出す際にその名前を必要としなければ、関数を自動的に実行することもできるでしょう。</p><p>幸いなことに、JavaScriptにはその解決方法があります。</p><pre>var a = 2;<br><br>(function foo(){ // &lt;-- insert this<br><br>	var a = 3;<br>	console.log( a ); // 3<br><br>})(); // &lt;-- and this<br><br>console.log( a ); // 2</pre><p>具体的にどうなっているのか、紐解いていきましょう。</p><p>まず最初に、関数の部分が(function…で始まっていることに注意してください。<br>小さな変更に思えるかもしれませんが、これは実際には非常に大きな変更となります。<br>関数を標準的な宣言として扱う代わりに、関数表現として扱います。</p><p>注意：関数の宣言と表現を見極める最も簡単な方法は、functionという単語の位置にあります。functionが先頭にきていればそれは関数の宣言、そうでなければ関数表現ということになります。</p><p>上の2つのコードを見比べると、まず1つ目の方ではfoo()が囲まれたスコープの中にあって、それを直接呼び出します。<br>そして2つ目の方ではfoo()は囲まれたスコープの中になく、その代わりに自身の関数の中に埋め込まれています。</p><p>言い換えれば、(function foo(){ .. })が意味するのは、fooという識別子は{ .. }が指し示すスコープ内でのみ見つけられるものであり、その外側のスコープ内では見つけられません。<br>fooという名前をそれ自身の中に隠すことで、無駄に他の囲まれたスコープの邪魔をしなくて済むようになります。</p><h4>Anonymous vs. Named</h4><p>皆さんは、下のようなコールバックパラメータとしての関数表現に親しみがあるかもしれません。</p><pre>setTimeout( function(){<br>	console.log(&quot;I waited 1 second!&quot;);<br>}, 1000 );</pre><p>これは<strong>無名関数</strong>と呼ばれており、なぜならfunction()…にはその名前を判断するための識別子がないからです。<br>関数表現は無名にすることもできますが、関数宣言ではその名前を省くことは不可で、JavaScriptの文法エラーになります。</p><p>無名関数は入力するのも簡単で、多くのツールやライブラリがこのやり方をサポートしていますが、いくつか考慮すべき点があります。</p><ol><li>無名関数は、スタックトレース内で表示するための有用な名前を持たず、デバッグがやりにくくなる。</li><li>名前がないため、その関数がそれ自身を参照しようとする場合に、残念ながら推奨されないものの、arguments.calleeというリファレンスが必要になる。セルフリファレンスが必要になるもう1つの例を挙げると、イベントハンドラー関数が始動後にそれ自身が解放される場合である。</li><li>無名関数で名前を省くことは、しばしばコードの可読性を高めることに繋がる。</li></ol><p><strong>インライン関数</strong>はとても強力且つ便利で、無名か名前ありかどうかというのはその価値を損ねることはありません。<br>関数に名前をつけることで、これら全ての欠点を非常に効果的に扱うことができますが、明確な欠点というものはありません。<br>常に関数に名前をつけることの最適な練習は、以下のような感じです。</p><pre>setTimeout( function timeoutHandler(){ // &lt;-- Look, I have a name!<br>	console.log( &quot;I waited 1 second!&quot; );<br>}, 1000 );</pre><h3>Invoking Function Expressions Immediately</h3><pre>var a = 2;<br><br>(function foo(){<br><br>	var a = 3;<br>	console.log( a ); // 3<br><br>})();<br><br>console.log( a ); // 2</pre><p>ここまで関数表現について()で括ることの長所を見てきましたが、次に(function foo(){ .. })()のように、最後に別の()を付け加えた関数を実行して見ましょう。<br>最初の()は関数表現のためのもので、2つ目の()は関数を実行するためのものです。</p><p>このパターンはとても一般的で、数年前にコミュニティーが<strong>IIFE</strong>という用語を使うことに同意しており、これはImmediately Invoked Function Expressionの略になっています。</p><p>勿論IIFEに必ずしも名前は必要ではなく、IIFEの最も一般的な使い方は無名関数です。<br>そしてあまり一般的ではないものの、IIFEで名前をつけることには無名関数をしのぐ前述の全ての利益があるため、それを適用してみることはいい練習になります。</p><pre>var a = 2;<br><br>(function IIFE(){<br><br>	var a = 3;<br>	console.log( a ); // 3<br><br>})();<br><br>console.log( a ); // 2</pre><p>伝統的なIIFEの形にはわずかにバリエーションがあり、比較的よく出てくるのが(function(){ .. }())になります。<br>何が違うのかよく見てみると、関数表現では2つ目の()が右側の1番外にありましたが、この場合では2つ目の()はその側の大きい()の内側に入っています。</p><p>この2つの形は機能性においては全く同じであり、<strong>自分が選んだ方が単純に文体がいいというだけです。</strong></p><p>IIFEのもう1つのバリエーションは、実はとても一般的なもので、単に関数を呼び出して引数の中を通っていくだけです。</p><p>例えば、以下のような感じです。</p><pre>var a = 2;<br><br>(function IIFE( global ){<br><br>	var a = 3;<br>	console.log( a ); // 3<br>	console.log( global.a ); // 2<br><br>})( window );<br><br>console.log( a ); // 2</pre><p>ここではwindowというオブジェクトリファレンスの中を通過しますが、globalという名前のパラメーターがあるため、グローバルvs非グローバルの明確な文体表現が存在します。<br>勿論、囲まれたスコープの中から通過したいものは何でもそうすることができ、それに合うパラメーターの名前を設定できます。<br>これが、最も文体的な選択だと思います。</p><p>このパターンのもう1つのアプリケーションが扱っている関係性として、デフォルトのundefined識別子がその値を間違って上書きしてしまい、予期せぬ結果を招いてしまうというのがあります。<br>undefinedという名前のパラメーターを作り、しかしその引数に対して何も与えないようにすることで、undefinedという識別子が実際にコードのブロックで未定義であるということを保証できます。</p><pre>undefined = true; // setting a land-mine for other code! avoid!<br><br>(function IIFE( undefined ){<br><br>	var a;<br>	if (a === undefined) {<br>		console.log( &quot;Undefined is safe here!&quot; );<br>	}<br><br>})();</pre><p>更にもう1つのIIFEのバリエーションは、実行する関数が与えられてその実行とパラメーターが通過した後に、物事の順番をひっくり返します。<br>このパターンはUMD (Universal Module Definition)プロジェクトで使われており、実際にはやや冗長ながらこっちの方がやや理解しやすいという人もいます。</p><pre>var a = 2;<br><br>(function IIFE( def ){<br>	def( window );<br>})(function def( global ){<br><br>	var a = 3;<br>	console.log( a ); // 3<br>	console.log( global.a ); // 2<br><br>});</pre><p>defという関数表現が後半の方で定義されており、それがdefという引数としてIIFEという前半の方で定義された関数に渡されています。<br>最終的に、defというパラメーター(関数)が呼び出されて、グローバルパラメーターとしてwindowの中を通っていくのです。</p><h4>try/catch</h4><p>殆ど知られていないことではありますが、実はES3におけるJavaScriptではtry/catchにおけるcatch節において変数宣言を明示しており、catchブロックに対してブロックスコープ化することができます。</p><p>例えば、以下のような感じです。</p><pre>try {<br>	undefined(); // illegal operation to force an exception!<br>}<br>catch (err) {<br>	console.log( err ); // works!<br>}<br><br>console.log( err ); // ReferenceError: `err` not found</pre><p>見てわかるようにerrはcatch節の中でのみ存在しているため、どこか別の場所でそれを参照しようとするとエラーになります。</p><p>注意：この動作は基本的なJSの環境において実際問題ないものであるものの(古いIEを除く)、多くのリンターでは同じスコープにcatch節が2つ以上あってそれぞれ同じ名前でエラーとなる変数が宣言されている場合には、まだ問題があるように思えます。これは実際には再定義を繰り返しているのではなく、変数はきちんとブロックスコープ化されているものの、リンターがしつこく文句を言っているように見えるだけです。</p><p>これらの無駄な警告を避けるには、例えばcatchにおける変数をerr1やerr2のように名前をつけていくといいです。<br>そうすれば、他の関数では重複する変数に対するチェックをしなくても済みます。</p><h4>let</h4><p>ES6では新たなキーワードであるletが登場し、それによりvarで変数を宣言する際に別のやり方ができるようになりました。</p><p>letは、それを含むどんなブロックのスコープに対しても({ .. }が一般的)、変数宣言を付け加えることができます。<br>別の言い方をすれば、letはどのスコープの変数宣言に対しても、暗にそれを乗っ取ることができるということです(その変数の再宣言が不可になる)。</p><pre>var foo = true;<br><br>if (foo) {<br>	let bar = foo * 2;<br>	bar = something( bar );<br>	console.log( bar );<br>}<br><br>console.log( bar ); // ReferenceError</pre><p>ブロックスコーピングに対して明確なブロックを作成することで、変数がどこに所属しているのかあるいはいないのか、より明らかにしやすくなります。<br>明確なブロックスコーピングのやり方は簡単で、他の言語においてもどのようにブロックスコーピングが動作するのかということに、よりフィットします。</p><pre>var foo = true;<br><br>if (foo) {<br>	{ // &lt;-- explicit block<br>		let bar = foo * 2;<br>		bar = something( bar );<br>		console.log( bar );<br>	}<br>}<br><br>console.log( bar ); // ReferenceError</pre><p>上のケースではif文の中に明示的なブロックを作成し、そのif文の場所や意味に影響を与えることなく、後にリファクタリングする際にブロック全体として移動させるのが簡単になります。</p><p>しかしながらletを伴う変数宣言では、ブロック内でその変数宣言が出てくるまで変数が存在していないことになってしまうのです。</p><pre>{<br>   console.log( bar ); // ReferenceError!<br>   let bar = 2;<br>}</pre><h4>garbage collection</h4><p>ブロックスコーピングが便利なことによるもう1つの利点は、メモリを回収するための閉鎖やゴミ回収に関連があります。<br>ここでは手短に書きますが、閉鎖機構については第5章で詳しく書きます。</p><pre>function process(data) {<br>	// do something interesting<br>}<br><br>var someReallyBigData = { .. };<br><br>process( someReallyBigData );<br><br>var btn = document.getElementById( &quot;my_button&quot; );<br><br>btn.addEventListener( &quot;click&quot;, function click(evt){<br>	console.log(&quot;button clicked&quot;);<br>}, /*capturingPhase=*/false );</pre><p>clickという関数のクリックハンドラーコールバックは、someReallyBigDataという変数を全く必要としません。<br>理論的に言うと、process(..)が実行された後、巨大なメモリーヘビーデータ構造がゴミ回収になるということです。<br>しかしながら、clickという関数がスコープ全体を越えて閉鎖部分を持っていても、JSエンジンはまだそのデータ構造をしっかり保っているように感じます。</p><p>ブロックスコーピングはこの問題を扱うことができ、エンジンに対してsomeReallyBigData周りのものを保つ必要がないことを明らかにしてくれます。</p><pre>function process(data) {<br>	// do something interesting<br>}<br><br>// anything declared inside this block can go away after!<br>{<br>	let someReallyBigData = { .. };<br><br>	process( someReallyBigData );<br>}<br><br>var btn = document.getElementById( &quot;my_button&quot; );<br><br>btn.addEventListener( &quot;click&quot;, function click(evt){<br>	console.log(&quot;button clicked&quot;);<br>}, /*capturingPhase=*/false );</pre><h4>let Loops</h4><p>ある特別なケースでは、forループに対してletが大きな役割を果たすことがあります。</p><pre>for (let i=0; i&lt;10; i++) {<br>	console.log( i );<br>}<br><br>console.log( i ); // ReferenceError</pre><p>forループのヘッダー内のletだけではiをそのボディの中身と結びつけることはできないものの、前のループの反復の最後の部分からの変数を当てはめることで、それぞれのループの反復に対して再度紐づけることができます。</p><p>繰り返しごとの紐付けの動作のもう1つの例が、以下になります。</p><pre>{<br>	let j;<br>	for (j=0; j&lt;10; j++) {<br>		let i = j; // re-bound for each iteration!<br>		console.log( i );<br>	}<br>}</pre><p>let宣言は、囲まれた関数のスコープ(もしくはグローバル)よりも任意のブロックに付随するため、既存のコードで関数スコープ化されたvar宣言があった場合、そのvarをletに置き換えることにはコードのリファクタリング時に更なる注意が必要となります。</p><pre>var foo = true, baz = 10;<br><br>if (foo) {<br>	var bar = 3;<br><br>	if (baz &gt; bar) {<br>		console.log( baz );<br>	}<br><br>	// ...<br>}</pre><p>このコードを簡単にリファクタリングすると、以下のようになります。</p><pre>var foo = true, baz = 10;<br><br>if (foo) {<br>	var bar = 3;<br><br>	// ...<br>}<br><br>if (baz &gt; bar) {<br>	console.log( baz );<br>}</pre><p>ただ、このようなブロックスコープ化された変数を伴う変更には十分注意してください。</p><pre>var foo = true, baz = 10;<br><br>if (foo) {<br>	let bar = 3;<br><br>	if (baz &gt; bar) { // &lt;-- don&#39;t forget `bar` when moving!<br>		console.log( baz );<br>	}<br>}</pre><h4>const</h4><p>let以外にES6ではconstというものも加わり、これも同じくブロックスコープ化された変数を作成できるものの、その変数の値は固定されます。<br>もしその変数の値を、後に変更しようとするとエラーになります。</p><pre>var foo = true;<br><br>if (foo) {<br>	var a = 2;<br>	const b = 3; // block-scoped to the containing `if`<br><br>	a = 3; // just fine!<br>	b = 4; // error!<br>}<br><br>console.log( a ); // 3<br>console.log( b ); // ReferenceError!</pre><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5198d72856fb" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[フロントエンド開発の概要について]]></title>
            <link>https://medium.com/@kazunorikamiya/%E3%83%95%E3%83%AD%E3%83%B3%E3%83%88%E3%82%A8%E3%83%B3%E3%83%89%E9%96%8B%E7%99%BA%E3%81%AE%E6%A6%82%E8%A6%81%E3%81%AB%E3%81%A4%E3%81%84%E3%81%A6-8d4b2a4d8422?source=rss-e42be372267d------2</link>
            <guid isPermaLink="false">https://medium.com/p/8d4b2a4d8422</guid>
            <category><![CDATA[react]]></category>
            <category><![CDATA[frontend]]></category>
            <category><![CDATA[css]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[front-end-development]]></category>
            <dc:creator><![CDATA[Kazunori  Kamiya]]></dc:creator>
            <pubDate>Tue, 17 Oct 2017 03:51:57 GMT</pubDate>
            <atom:updated>2019-12-05T07:36:44.431Z</atom:updated>
            <content:encoded><![CDATA[<p>ここでは、フロントエンド開発の概要について説明していきます。</p><p>＊元記事は<a href="https://medium.freecodecamp.org/grabs-front-end-guide-for-large-teams-484d4033cc41">こちら</a>です。(英語)</p><h3>この記事でカバーしているものについて</h3><ul><li>Single-page Apps (SPAs)</li><li>New-age JavaScript</li><li>User Interface</li><li>State Management</li><li>Coding with Style</li><li>Testing</li><li>Linting JavaScript</li><li>Linting CSS</li><li>Types</li><li>Build System</li><li>Package Management</li><li>Continuous Integration</li><li>Hosting</li><li>Deployment</li></ul><h3>Single-page Apps (SPAs)</h3><p>かつてはサーバーサイドレンダリングという、別のURLを開くごとにページをリフレッシュしてサーバーから新たなHTMLページを送る手法が主流でしたが、最近のSPAsではクライアントサイドレンダリングというものが主流になっています。<br>まずブラウザがサーバーから、最初のページとそれに伴ってアプリ全体に必要なスクリプトやスタイルシートをロードします。<br>そしてユーザーが別のページに遷移する場合に、ページはリフレッシュされません。<br>ページのURLが、<a href="https://developer.mozilla.org/en-US/docs/Web/API/History_API">HTML5 History API</a>を通じてアップデートされます。<br>新しいページに必要なデータは、サーバーへの<a href="https://developer.mozilla.org/en-US/docs/AJAX/Getting_Started">AJAX</a>リクエストを通してブラウザにより、大抵JSONフォーマットで引き出されます。<br>それからSPAはJavascriptを通してデータを用いて動的にページをアップデートしますが、それは既に最初のページでダウンロード済みです。<br>このモデルは、ネイティブモデルアプリの動作によく似ています。</p><p>この方法のメリットとしては、以下のようなものがあります。</p><ul><li>アプリのレスポンスが良くなり、ユーザーが全ページのリフレッシュによるページナビゲーション間の閃光を見なくても済む。</li><li>わずかなHTTPリクエストがサーバーに送られるだけで済み、それぞれのページのロードに同じアセットをもう一度ダウンロードしなくても済むようになる。</li><li>クライアントとサーバー間の関係に、明確な分類点ができる。どういうことかというと、サーバー側のコードを変更せずとも異なるプラットフォーム(モバイル、チャットボット、スマートウォッチなど)に対して容易に新たなクライアントを構築できる。APIの約定が破綻していない限りは、サーバーとクライアントのテクノロジースタックをそれぞれ独立した状態で変更できる。</li></ul><p>逆に、デメリットとしては以下のようなものがあります。</p><ul><li>多くのページに必要なフレームワーク、コード、アセットのローディングによっては、初期ページのロードが重くなる。</li><li>1つのエントリーリクエストに対する全てのリクエストを走らせるのと、クライアントサイドにそこから必要なものを持って行かせるために、サーバー側でもう1つステップが必要となる。</li><li>SPAsは内容を表現するためにJavascriptを頼っているが、全ての検索エンジンがクローリングの際にJavascriptを実行しているわけではなく、その場合は空っぽの中身を見る可能性がある。その場合は、アプリのSEOにおいて問題が起きてしまう。</li></ul><p>大きな開発チームになるほど、クライアントとサーバー間の明確な分類がある方が良く、その方がクライアント側とサーバー側のコードを別々に開発したりリリースできるからです。</p><h4>参考リンク</h4><ul><li><a href="http://stackoverflow.com/questions/21862054/single-page-app-advantages-and-disadvantages">Single Page App: advantages and disadvantages</a></li><li><a href="http://blog.isquaredsoftware.com/presentations/2016-10-revolution-of-web-dev/">The (R)Evolution of Web Development</a></li><li><a href="https://medium.freecodecamp.com/heres-why-client-side-rendering-won-46a349fadb52">Here’s Why Client Side Rendering Won</a></li></ul><h3>New-age JavaScript</h3><p>Javascriptは非常に多方面で役立つ言語で、<a href="https://nodejs.org/en/">Webサーバー</a>、<a href="https://facebook.github.io/react-native/">ネイティブモバイルアプリ</a>、<a href="https://electron.atom.io/">デスクトップアプリ</a>を構築するのに使うことができます。</p><p>ここ最近まで、全てのブラウザがES2015(ES6)の全ての仕様を実行できているわけではありませんでした。<br><a href="https://babeljs.io/">Babel</a>のようなツールのおかげで、開発者が彼らのアプリ内でES2015を書けるようになり、BabelがそれをES5にわかるようにしてブラウザで矛盾がないようにしました。</p><p>ES5とES2015の両方に慣れておくのは、とても大切なことです。<br>ES2015はまだ比較的新しく、多くのオープンソースコードやNode.jsアプリはまだES5で書かれています。<br>ブラウザコンソールでデバッグをしていると、ES2015のシンタックスが使えないかもしれません。<br>一方でこの文章内でも後に紹介する多くの新しめのライブラリは、ES2015で書かれています。</p><p>ES5とES2015の復習及び探求については、ある程度時間をかけてください。<br>ES2015にはやや重めの機能があって、“Arrows and Lexical This”、“Classes”, “Template Strings”、“Destructuring”、“Default/Rest/Spread operators”と“Importing and Exporting modules”がそれに当たります。</p><h4>参考リンク</h4><ul><li><a href="https://www.codecademy.com/learn/learn-javascript">Learn ES5 on Codecademy</a></li><li><a href="https://babeljs.io/learn-es2015/">Learn ES2015 on Babel</a></li><li><a href="http://es6katas.org/">ES6 Katas</a></li><li><a href="https://www.freecodecamp.com/">Free Code Camp</a></li><li><a href="https://github.com/getify/You-Dont-Know-JS">You Don’t Know JS</a> (Advanced content, optional for beginners)</li></ul><h3>User Interface — React</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/256/1*kY0fCoLv4oRw3CCQxtrdXA.png" /></figure><p>もし直近においてjavascriptのプロジェクトがフロントエンドエコシステムを採用していたら、それは<a href="https://facebook.github.io/react/">React</a>でしょう。<br>ReactはFacebookの人たちによって構築された、オープンソースのライブラリです。<br>Reactにおいて、開発者はWebインターフェースのためのコンポーネントを作成し、それらを組み合わせます。</p><p>Reactは、多くの革新的なアイデアをもたらすのと同時に、<a href="https://www.youtube.com/watch?v=DgVS-zXgMTk">最も効率のいい学習方法</a>について開発者たちに考えさせてくれました。<br>昔はHTML、Javascript、CSSを別々に学ぶのがいいと言われていましたが、Reactは全くの逆でHTMLと<a href="https://speakerdeck.com/vjeux/react-css-in-js">CSSをJavascript内で書く</a>ことを推奨しています。<br> Reactの特徴としては、以下のことが挙げられます。</p><ul><li>平叙的 — jQueryにおいては、アプリを次の状態にするのに開発者がDOMの一連の操作の流れについていく必要があったが、Reactにおいてはコンポーネント内の状態を変更するだけで、viewがその状態によって自分自身をアップデートしてくれる。また、render()メソッド内のmarkupを見ることで、コンポーネントがどのようになるか決めるのも簡単にできる。</li><li>機能的 —viewというのは、propsとstateの純粋な関数である。大抵のケースにおいて、Reactのコンポーネントはprops(外部パラメータ)とstate(内部データ)によって定義されている。同じpropsとstateにおいては、同じviewが生成される。 純粋な関数はテストが簡単で、関数のコンポーネントにおいても同様である。Reactにおけるテストは、コンポーネントのインターフェースがきちんと定義されているため簡単であり、異なるpropsとstateを供給することによってコンポーネントのテストが可能で、表示される出力の比較もできる。</li><li>メンテナンスが容易 — コンポーネントベースの流儀に沿ってviewを書くことで、その再利用性が高まる。コンポーネントのpropTypesを定義すると、Reactのコードをそのコンポーネントを使うには何が必要か明らかにしてくれる読み取り機としてセルフドキュメント化してくれる。また、viewとロジックはコンポーネントの中に一通り揃っており、他のコンポーネントに影響を与えたりあるいは受けるべきではない。同じpropsがコンポーネントに供給される限りは、大規模のリファクタリングにおいてコンポーネントを移し替えるのは簡単である。</li><li>ハイパフォーマンス — Reactは、メモリ内においてDOMの軽めの仮想表現をすることができる。Reactにおいては、実際のDOM自身ではなくてDOMのインメモリ表現のリレンダリングを参照している。コンポーネントの基礎となるデータに変更があった場合、新たな仮想表現が生成され、前のものと比較される。その違いが、実際のブラウザのDOMにパッチされる。</li><li>学習しやすい — ReactのAPIにおいて学ぶべきものの数はそれほど多くなく、頻繁に変更されることもあまりない。</li><li>開発者の経験 — Reactによる開発経験をより良くするためのツールは多くあり、<a href="https://github.com/facebook/react-devtools">React Developer Tools</a>はブラウザの拡張でそれによりコンポーネントやviewを精査したり、そのpropsやstateをいじったりすることができる。<a href="https://github.com/gaearon/react-hot-loader">Hot reloading</a>では、ブラウザをリフレッシュすることなくブラウザ内のコードを変更したりできる。ライブラリのアップデートがされた場合、Facebookは<a href="https://github.com/reactjs/react-codemod">codemod scripts</a>というコードを新たなAPIにマイグレートさせるものを供給してくれている。</li></ul><p>Reactが一体何でどんなことをしてくれるのかについては、<a href="https://facebook.github.io/react/tutorial/tutorial.html">チュートリアル</a>に従って◯✖️ゲームを作ってみることをオススメします。<br>より深く理解するには、<a href="https://github.com/ReactTraining/react-router/">React Router</a>による<a href="https://reacttraining.com/online/react-fundamentals">React Fundamentals</a>をチェックしてみてください。<br>Facebookによる<a href="https://github.com/facebookincubator/create-react-app">Create React App</a>は、新たなReactのプロジェクトを始めるのに非常にオススメです。</p><p>Reactはフレームワークではなくライブラリであり、view以下のレイヤー(アプリの状態)については扱いません。<br>これについては、また後ほど出てきます。</p><h4>参考リンク</h4><ul><li><a href="https://facebook.github.io/react/tutorial/tutorial.html">React Official Tutorial</a></li><li><a href="https://reacttraining.com/online/react-fundamentals">React Fundamentals</a></li><li><a href="https://hackernoon.com/simple-react-development-in-2017-113bd563691f">Simple React Development in 2017</a></li><li><a href="https://medium.com/@dan_abramov/smart-and-dumb-components-7ca2f9a7c7d0#.5iexphyg5">Presentational and Container Components</a></li></ul><h4>代替手段</h4><ul><li><a href="https://angular.io/">Angular</a></li><li><a href="https://www.emberjs.com/">Ember</a></li><li><a href="https://vuejs.org/">Vue</a></li><li><a href="https://cycle.js.org/">Cycle</a></li></ul><h3>State Management — Flux/Redux</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/256/1*kWUe0BGVZhbaL2_lR8p9iw.png" /></figure><p>アプリの規模が大きくなってくるとその構造が段々汚くなり、共通のデータをシェアしたりする必要が出てきますが、Reactにはそれに適した方法がありません。<br>Reactは単なるviewのlayerであり、モデルやコントローラーのようにアプリの他のレイヤーをどのように構築するか命令するものではないのです。<br>それを解決するためにFacebookが開発したのがFluxであり、一方向性のデータフローを用いることによって、Reactの構成可能なviewのコンポーネントをアプリのアーキテクチャーが補うことができます。<br>Fluxについて詳しく知るには、<a href="https://facebook.github.io/flux/docs/in-depth-overview.html">ここ</a>を見てください。<br>要約すると、Fluxの型には以下のような特徴があります。</p><ul><li>一方向性のデータフロー — アップデートの軌跡をより簡単に追えるように、そのアプリに予見できるようにする。</li><li>関係性の分割 — Fluxアーキテクチャーのそれぞれのパートには、明確な責任があって、尚且つしっかり分離されている。</li><li>平叙的なプログラミングと相性がいい — ストア側からviewに対して、状態間でどのように遷移するかを明示することなくアップデートを送ることができる。</li></ul><p>Flux自体はフレームワークではないものの、開発者はそのパターンのインプレメンテーションに追いついていく必要がありました。<br>そのため、新たに出てきたのが<a href="http://redux.js.org/">Redux</a>です。<br>Reduxは<a href="https://www.wikiwand.com/en/Command_pattern">Command pattern</a>と<a href="https://guide.elm-lang.org/architecture/">Elm architecture</a>というFluxからの概念を合体させ、事実上最近の国営のライブラリ開発者はReactと一緒に使っています。<br>そのコアとなる概念が、以下になります。</p><ul><li>アプリの<strong>状態</strong>が、1つの平易な古いJavaScriptのオブジェクト(POJO)によって描かれている。</li><li>状態を修正するために、<strong>アクション</strong>(POJO)を手早く済ませる。</li><li><strong>Reducer</strong>は純粋な関数で、新たな状態を生み出すのに現在の状態とアクションを必要とする。</li></ul><p>概念自体はシンプルですが、アプリに対して以下のことを可能にするのでとても強力なものと言えます。</p><ul><li>その状態をサーバー上で表現し、クライアント上で立ち上げる。</li><li>トレース、ログ、バックトラックがアプリ全体で変化する。</li><li>インプレメントを元通りにしたりやり直すのが機能的に簡単になる。</li></ul><p>Reduxの作者である<a href="https://github.com/gaearon">Dan Abramov</a>は、Reduxの<a href="https://egghead.io/courses/getting-started-with-redux">基礎的な部分</a>と<a href="https://egghead.io/courses/building-react-applications-with-idiomatic-redux">発展的な部分</a>のわかりやすい学習用ビデオチュートリアルを作成してくれています。<br> Reduxの学習に際しては、これらが非常に役立つはずです。</p><h4>ビューと状態の結合</h4><p>ReduxがReactと共に使われる必要の絶対性がない中で、お互いを上手く使い合わせることが強く推奨されています。<br> ReactとReduxには、共通する考えや特徴があるからです。</p><ul><li>機能的な構成パラダイム — Reactはビュー(純粋な関数)を構成する一方で、Reduxは純粋なリデューサー(純粋な関数)を構成する。出力は、入力群と同じ形だと予見できる。</li><li>推論するのが簡単 — ReactとReduxは、デバッグをシンプルにしてくれます。データフローが一方向性であるため、データフロー(サーバーのレスポンスやユーザーインプット)の追跡が簡単になり、どのレイヤーで問題が起きているのか決めるのが楽になる。</li><li>レイヤーの構造 — アプリのそれぞれのレイヤーにおいて、Fluxのアーキテクチャーは純粋な関数で明確な責任を持っている。それにより比較的、純粋な関数に対するテストを書くのが簡単になる。</li><li>開発者の経験 — アプリの開発中にデバッグと調査をするためのツール(例えば<a href="https://github.com/gaearon/redux-devtools">Redux DevTools</a>)を作成するには、多くの努力が必要となる。</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sZUmB_maFzubpc80T2oPtg.gif" /></figure><p>アプリでリモートのAPIリクエストを作成するような非同期の呼び出しを扱わなければならない場合、<a href="https://github.com/gaearon/redux-thunk">redux-thunk</a>と<a href="https://github.com/redux-saga/redux-saga">redux-saga</a>が解決するのに役立つでしょう。<br>ただこれは理解するのに時間がかかるので、必要になったらトライしてみることをオススメします。</p><p><a href="https://github.com/reactjs/react-redux">react-redux</a>がReduxに対するReactの公式のものとなり、学習も簡単です。</p><h4>参考リンク</h4><ul><li><a href="http://facebook.github.io/flux">Flux Homepage</a></li><li><a href="http://redux.js.org/">Redux Homepage</a></li><li><a href="https://egghead.io/courses/getting-started-with-redux">Egghead Course — Getting Started with Redux</a></li><li><a href="https://egghead.io/courses/building-react-applications-with-idiomatic-redux">Egghead Course — Build React Apps with Idiomatic Redux</a></li><li><a href="https://github.com/markerikson/react-redux-links">React Redux Links</a></li><li><a href="https://medium.com/@dan_abramov/you-might-not-need-redux-be46360cf367">You Might Not Need Redux</a></li></ul><h4>代替手段</h4><ul><li><a href="https://github.com/mobxjs/mobx">MobX</a></li></ul><h3>Coding with Style — CSS Modules</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/256/1*iK6CdRjDJ4mm5OuUHGJKOw.png" /></figure><p>CSSは、HTML要素をどのように見えるか表現するためのルールです。<br>いいCSSを書けるようになるまではかなりの時間や経験が必要で、とても大変です。<br>それゆえ、経験豊富なフロントエンド開発者たちが、<a href="https://smacss.com/">SMACSS</a>、<a href="http://getbem.com/">BEM</a>、<a href="http://suitcss.github.io/">SUIT CSS</a>などを使って複雑なプロジェクトに対してきちんと整備されたCSSを書いていけるようになるための、しっかりした方法論を作成してくれています。</p><p>かつてはJSの中でCSSを書くという共同で一致したアプローチはありませんでしたが、今では<a href="https://github.com/css-modules/css-modules">CSS Modules</a>というものに頼ることができます。<br> CSS Modulesは、CSSにおいて既存のCSSを改良してグローバル名前空間の問題を取り除こうとします。<br>これにより、デフォルトでローカルにあるスタイルをコンポーネントに要約することが可能になります。<br>CSS Modulesによって、巨大な開発チームでもアプリの一部分を上書きしたり矛盾を起こしたりすることなく、再利用できるCSSを書くことが可能になります。<br>ただCSS Modulesはブラウザが認識できる通常のグローバル名前空間的なCSSにもコンパイルされているので、通常のCSSがどのように動作するか学習するのは大切です。</p><p>もしCSSに対して全くのビギナーという場合は、<a href="https://www.codecademy.com/learn/learn-html-css">HTML &amp; CSS course</a>にトライしてみるといいでしょう。<br>次に<a href="http://sass-lang.com/">Sass preprocessor</a>というCSSを拡張したものについて書いてあるものを読んで、最後にCSS modulesについて学習しましょう。</p><h4>参考リンク</h4><ul><li><a href="https://www.codecademy.com/learn/learn-html-css">Learn HTML &amp; CSS course on Codecademy</a></li><li><a href="https://www.khanacademy.org/computing/computer-programming/html-css">Intro to HTML/CSS on Khan Academy</a></li><li><a href="https://smacss.com/">SMACSS</a></li><li><a href="http://getbem.com/introduction/">BEM</a></li><li><a href="http://suitcss.github.io/">SUIT CSS</a></li><li><a href="https://github.com/css-modules/css-modules">CSS Modules Specification</a></li><li><a href="http://sass-lang.com/">Sass Homepage</a></li><li><a href="https://medium.com/@yangshun/clearing-your-front-end-job-interview-html-706f8b2c7dca">Answers to Front End Job Interview Questions — HTML</a> ⭐</li><li><a href="https://medium.com/@yangshun/clearing-your-front-end-job-interview-css-95bdd82871f2">Answers to Front End Job Interview Questions — CSS</a> ⭐</li></ul><h4>代替手段</h4><ul><li><a href="https://github.com/cssinjs/jss">JSS</a></li><li><a href="https://github.com/styled-components/styled-components">Styled Components</a></li></ul><h3>Maintainability</h3><p>コードは書くよりも読まれることの方が多く、実際にチームが巨大化するほど多くのエンジニアがいくつものプロジェクトに跨って仕事をしています。<br>コードの読みやすさや保全性に安定性が、強く求められます。</p><h3>Testing — Jest + Enzyme</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/256/1*WaQxMEs4agipsVkTc3xBkw.png" /></figure><p><a href="http://facebook.github.io/jest/">Jest</a>は、テストのプロセスで余計な煩わしさを感じなくても済むようにFacebookが開発したテスト用ライブラリです。<br>JestはReactコンポーネントとReduxの状態から生成された出力を保存でき、それをシリアライズ化されたファイルとして保存することも可能で、そのため自分自身で手作業によって期待される出力に追いついていく必要はありません。<br>また、Jestは元々モッキングやアサーションにテストカバレッジが備わっています。<br>1つのライブラリで、それら全てをカバーすることが可能なのです。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*B-R6eB4Wm3vY3asKytyV1g.gif" /></figure><p><a href="http://airbnb.io/enzyme/">Enzyme</a>というAirbnbが開発したものを、Reactコンポーネントをテストする際に使うことが推奨されています。</p><p>JestとEnzymeを使えば、フロントエンドのテストを楽しく簡単に書くことができます。<br>JestとEnzymeのドキュメントは非常に簡潔に書かれているので、その2つについて学習したければそれを読むだけで十分です。</p><h4>参考リンク</h4><ul><li><a href="http://facebook.github.io/jest/">Jest Homepage</a></li><li><a href="https://auth0.com/blog/testing-react-applications-with-jest/">Testing React Applications with Jest</a></li><li><a href="http://airbnb.io/enzyme/">Enzyme Homepage</a></li><li><a href="https://medium.com/airbnb-engineering/enzyme-javascript-testing-utilities-for-react-a417e5e5090f">Enzyme: JavaScript Testing utilities for React</a></li></ul><h4>代替手段</h4><ul><li><a href="https://github.com/avajs/ava">AVA</a></li><li><a href="https://karma-runner.github.io/">Karma</a></li></ul><h3>Linting JavaScript — ESLint</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/256/1*vWalPJw7C2W1X_M3wXFAKQ.png" /></figure><p>Linterとは、静的にコードを分析して問題を発見するためのツールであり、同時に潜在的にバグや実行中のエラーを防ぐ、といったことを実施するコーディングスタイルです。<br><a href="http://eslint.org/">ESLint</a>は、JavaScriptコードのリンティングにおいて高い拡張性とカスタマイズ性を誇るツールです。<br>チームはそれぞれのカスタムルールを設定するために、リントのルールを作ることができます。<br>Grabにおいては、Airbnbの<a href="https://www.npmjs.com/package/eslint-config-airbnb">eslint-config-airbnb</a>のプリセットが使われ、それは<a href="https://github.com/airbnb/javascript">Airbnb JavaScript style guide</a>において既に共通の優れたコーディングスタイルとして形成されています。</p><p>もし新たなルールを作ろうという場合でなければ、ESLintについて特に学習することはありません。<br>エラーが表面化した場合に、Googleでオススメのスタイルを探せばいいということを認識しておいてください。</p><h4>参考リンク</h4><ul><li><a href="http://eslint.org/">ESLint Homepage</a></li><li><a href="https://github.com/airbnb/javascript">Airbnb JavaScript Style Guide</a></li></ul><h4>代替手段</h4><ul><li><a href="https://github.com/feross/standard">Standard</a></li><li><a href="http://jshint.com/">JSHint</a></li></ul><h3>Linting CSS — stylelint</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/200/1*SCX8UuazhAwzRiK5FAmYcg.png" /></figure><p>CSSの静的解析ツールを使うことで、CSSコードのクオリティとコーディングスタイルを維持することができます。<br>CSSのリンティングにおいては、stylelintというツールを使います。<br>ESLintのように、stylelintは基準寸法的なやり方でデザインされ、開発者はそのルールのオンオフを切り替えたり、そのためのカスタムプラグインを書くこともできます。<br>CSSに加え、stylelintはSCSSをパースすることが可能で、Lessに対する実験的な土台も持ちます。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PhHKu0CvyFNVrNYwcROw8w.png" /></figure><p>ESLintについて学んだことがあれば、stylelintも似たようなものなので簡単だと思います。<br>最近ではstylelintは、<a href="https://code.facebook.com/posts/879890885467584/improving-css-quality-at-facebook-and-beyond/">Facebook</a>や<a href="https://github.com/primer/stylelint-config-primer">Github</a>に<a href="https://github.com/WordPress-Coding-Standards/stylelint-config-wordpress">Wordpress</a>などの大きな企業で使われています。</p><p>実はstylelintには1つデメリットがあって、自動で修正してくれる機能は不完全で、限られた数のルールの中でしか修正できません。<br>ただこれは、時が経てば解決されるでしょう。</p><h4>参考リンク</h4><ul><li><a href="https://stylelint.io/">stylelint Homepage</a></li><li><a href="https://css-tricks.com/stylelint/">Lint your CSS with stylelint</a></li></ul><h4>代替手段</h4><ul><li><a href="https://github.com/sasstools/sass-lint">Sass Lint</a></li><li><a href="http://csslint.net/">CSS Lint</a></li></ul><h3>Types — Flow</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/200/1*G0TX5lzoWfqCajS3j6JXmw.png" /></figure><p>Typesはコード内のバグやエラーを素早く見つけるのに役立つのと、その可読性も高めてくれます。<br>プロジェクトチームに新たなメンバーが入ってきた場合にも、それぞれのオブジェクトがどんな変数を保持していて、それぞれの関数でどんなパラメータが返ってくるのか明らかにするのも簡単になります。</p><p>Typesをコードに加えることで多少最初は面倒になることもあるかと思いますが、複雑なプロジェクトになってくると何度も変更があってコードのメンテナビリティが大変になり、そういった意味ではtypesを入れておくことのメリットは大きいと思います。</p><p>実際にしばらく触っていなかったコードの修正が必要になったとき、typesのおかげで簡単にコードを理解できて修正した部分にも自信が持てました。</p><p>JavaScriptに対する静的なtypesにおいて、最も大きな2つのコンテンダーは<a href="https://flow.org/">Flow</a> (by Facebook)と<a href="https://www.typescriptlang.org/">TypeScript</a> (by Microsoft)です。<br>最近では、前者の方が使われることが多いと思います。<br>前者の方が学習曲線が緩やかで、既存のコードベースをFlowにマイグレートするのにも少ない労力で済みます。<br>Facebookによって開発されたので、FlowはReactのエコシステムとより良い相互作用を起こします。<br>Flowの作者の1人である<a href="https://twitter.com/thejameskyle">James Kyle</a>は、FlowとTypeScriptの<a href="http://thejameskyle.com/adopting-flow-and-typescript.html">比較記事</a>を書いています。</p><h4>参考リンク</h4><ul><li><a href="https://flow.org/">Flow Homepage</a></li><li><a href="https://github.com/niieani/typescript-vs-flowtype">TypeScript vs Flow</a></li></ul><h4>代替手段</h4><ul><li><a href="https://www.typescriptlang.org/">TypeScript</a></li></ul><h3>Build System — webpack</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/256/1*iwJQ_XHm4rtxfRfe0LvypQ.png" /></figure><p><a href="https://webpack.js.org/">webpack</a>はフロントエンドプロジェクトをコンパイルするモジュールバンドラーであり、その独立性を最後のバンドルに入れてユーザーに届けるためのものです。<br>大抵の場合、プロジェクトにおいてはwebpackの形が既に設定されていて、開発者がそれを変更することは滅多にありません。</p><p>webpackの学習には、<a href="https://survivejs.com/webpack/foreword/">webpack walkthrough</a>が最適でしょう。<br>まずはこれに従ってやってみて、カスタマイズが必要になった場合にドキュメントを参照するのがいいと思います。</p><h4>参考リンク</h4><ul><li><a href="https://webpack.js.org/">webpack Homepage</a></li><li><a href="https://survivejs.com/webpack/foreword/">SurviveJS — Webpack: From apprentice to master</a></li></ul><h4>代替手段</h4><ul><li><a href="https://rollupjs.org/">Rollup</a></li><li><a href="http://browserify.org/">Browserify</a></li></ul><h3>Package Management — Yarn</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*q35jJC6qcaRiKQUSZCYJiw.png" /></figure><p>node_modulesディレクトリの中を覗き見ると、大量のディレクトリがその中にあることに恐怖を覚えるかもしれません。<br>それぞれのbabelプラグインやlodash関数は、それ自身のパッケージです。<br>いくつものプロジェクトがあると、それぞれのプロジェクトでこれらのパッケージに重複が出てきてますが、大体は同じようなものになると思います。<br>新しいプロジェクトでnpm installを実行する度に、既に別のプロジェクトで存在しているにも関わらず、こういったパッケージが繰り返しダウンロードされることになってしまいます。</p><p>npm installを使った非決定的なパッケージのインストールには他にも問題があって、CIサーバーが全ての依存性をインストールする場合に互換性の破壊を含む細かいアップデートもちょいちょい存在するため、CIのビルドが失敗することがあります。<br>これはライブラリの作者が<a href="http://semver.org/">semver</a>に敬意を払い、エンジニアがAPIの約束事をきっちり守っていれば起こらないことでしょう。</p><p>これを解決するために、<a href="https://yarnpkg.com/">Yarn</a>というものがあります。<br>非決定的なパッケージのインストールにおける問題は、yarn.lockというファイルを通して扱い、これが全てのマシンに跨って全てのインストール結果がnode_modulesにおいて全て正確に同じファイル構造になることを保証してくれます。<br>Yarnはマシン内のグローバルcacheディレクトリを利用しており、パッケージをもう一度ダウンロードしなくても済む前にダウンロードしてくれます。<br>また、オフラインでの依存性のインストールも可能となります。</p><p>Yarnにおいて最も頻繁に使われるコマンドは、<a href="https://yarnpkg.com/en/docs/usage">ここ</a>でチェックできます。<br>Yarnの他の大抵のコマンドは、npmのものと似ており、代わりにnpmバージョンを使ってもいいでしょう。<br>お気に入りのコマンドはyarn upgrade-interactiveであり、これによって依存性をアップデートでき、モダンJavaScriptのプロジェクトが多くの依存性を必要としている場合には特に使えるものだと思います。</p><p>npm@5.0.0が<a href="https://github.com/npm/npm/releases/tag/v5.0.0">2017年5月にリリース</a>されましたが、Yarnが解決できるであろう多くの問題があるようなのでチェックしておきましょう。</p><h4>参考リンク</h4><ul><li><a href="https://yarnpkg.com/">Yarn Homepage</a></li><li><a href="https://code.facebook.com/posts/1840075619545360">Yarn: A new package manager for JavaScript</a></li></ul><h4>代替手段</h4><ul><li><a href="https://github.com/npm/npm/releases/tag/v5.0.0">Good old npm</a></li></ul><h3>Continuous Integration</h3><p>我々は、継続的インテグレーションパイプラインのために<a href="https://travis-ci.com/">Travis CI</a>というものを使います。<br>TravisはGitHub上で非常にポピュラーなCIであり、その<a href="https://docs.travis-ci.com/user/customizing-the-build#Build-Matrix">build matrix</a>的な特徴は多くのプロジェクトを含むリポジトリにとっては有用なものです。<br>以下のようなことをするために、Travisを設定します。</p><ul><li>プロジェクトに対してリンティングを実行する。</li><li>プロジェクトに対してユニットテストを実施する。</li><li>もしテストが成功した場合は</li><li>Jestによって生成されたテスト範囲を<a href="https://codecov.io/">Codecov</a>にアップロードする。</li><li>buildディレクトリでwebpackと共にプロダクションバンドルを生成。</li><li>&lt;hash&gt;.tarとしてtar buildディレクトリを、S3 bucketという他の全てのtarがビルドされている場所にアップロードする。</li><li>Slackに対して通知を送り、Travisのビルド結果を報告する。</li></ul><h4>参考リンク</h4><ul><li><a href="https://travis-ci.com/">Travis Homepage</a></li><li><a href="https://codecov.io/">Codecov Homepage</a></li></ul><h4>代替手段</h4><ul><li><a href="https://jenkins.io/">Jenkins</a></li><li><a href="https://circleci.com/">CircleCI</a></li></ul><h3>Hosting — Amazon S3</h3><p>慣例では、WebサーバーはWebページに対するリクエストを受け取ってサーバー上のコンテンツを引き出し、リクエストに対して動的なHTMLページを返却します。<br>以前に述べたようにこれがサーバーサイドレンダリングというもので、最近のWebアプリケーションではこの方法は使わず、Webサーバーは静的な資産ファイルを遅れば十分になっています。<br>NginxとApacheはオプションを可能にし、物事を始めたり実行するのに多くの形状は必要ありません。<br>注意すべきは、Webサーバーは1つのエントリーポイントに向けて全てのリクエストを設定しなければならないだろうということで、クライアントサイドのルーティンで引き継ぎます。<br>フロントエンドルーティンに対する流れは、以下のようになります。</p><ol><li>Webサーバーが、特定のルートに対するHTTPリクエストを受け取る。(例えば/users/john)</li><li>サーバーが受け取ったルートに関わらず、静的な資産ディレクトリからindex.htmlを抜き出す。</li><li>index.htmlは、クライアントサイドルーティンを扱うJavaScriptのフレームワーク/ライブラリの負荷を上昇させるスクリプトを含む。</li><li>クライアントサイドルーティンライブラリが現在のルートを読み、そのルートについてMVG(あるいは同等、関連のある)フレームワークに伝える。</li><li>MVC JavaScriptフレームワークがルートに基づく望ましいビューを引き出し、もし必要であればAPIからデータを呼び出す。例えばUsersControllerの負荷を上げることについて、ユーザーネームJohnというデータをJSONで抜き出し、ビューと結合してページ上で描写する。</li></ol><p>静的コンテンツの供給にぴったりな練習として、それをCDN上でキャッチングしたりプッティングしたりするというのがあります。<br><a href="https://aws.amazon.com/s3/">Amazon Simple Storage Service (S3)</a>をよく使いますが、これを使うと特別なルーティンの形を伴う我々自身のWebサーバーを持つ必要が無くなります。</p><p>S3上でよく出てくるWebアプリが、<a href="https://hub.grab.com/">Hub</a>になります。</p><h4>参考リンク</h4><ul><li><a href="https://aws.amazon.com/s3/">Amazon S3 Homepage</a></li><li><a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/WebsiteHosting.html">Hosting a Static Website on Amazon S3</a></li></ul><h4>代替手段</h4><ul><li><a href="https://cloud.google.com/storage/docs/hosting-static-website">Google Cloud Platform</a></li><li><a href="https://zeit.co/now">Now</a></li></ul><h3>Deployment</h3><p>ユーザーにプロダクトを届けるための最後のステップが、デプロイメントです。<br>我々は<a href="https://www.ansible.com/tower">Ansible Tower</a>という、ビルドしたものを簡単にデプロイすることができる強力な自動操作ソフトウェアを使います。</p><p>我々の全てのコミット、成功したビルドは、セントラルS3バケットにアップロードされます。<br>リリースのためにはsemverとリリースのために自動的に生成されたリリースノートのコマンドに従い、リリースするときには最新のコミットをつけるためのコマンドを実行してコードを対象の環境にプッシュしてやります。<br>Travisがそのタグづけされたコミット上でCIステップを実行し、tarファイル(1.0.1.tarのようなもの)と共に、ビルドのためにS3バケットにそのバージョンをアップロードするでしょう。</p><p>タワー上ではシンプルに.tarの名前を指定する必要があり、ホスティングバケットにデプロイしたらタワーは以下のことを実行します。</p><ol><li>望ましい.tarファイルをビルドS3バケットからダウンロードする。</li><li>指定された環境のために、コンテンツを引き出してコンフィギュレーションファイルの中で交換する。</li><li>ホスティングバケットにコンテンツをアップロードする。</li><li>Slackに通知を送り、デプロイメントの成功を知らせる。</li></ol><p>全てのプロセスは通常30秒以内に終わり、タワーを使うことでデプロイメントもロールバックも簡単にできます。<br>もしデプロイメントの失敗に気づいたら、前の状態のタグを探してそれをデプロイすればいいだけです。</p><h4>参考リンク</h4><ul><li><a href="https://www.ansible.com/tower">Ansible Tower Homepage</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8d4b2a4d8422" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Bundlerの使い方]]></title>
            <link>https://medium.com/@kazunorikamiya/bundler%E3%81%AE%E4%BD%BF%E3%81%84%E6%96%B9-3403ab27dc81?source=rss-e42be372267d------2</link>
            <guid isPermaLink="false">https://medium.com/p/3403ab27dc81</guid>
            <category><![CDATA[ruby]]></category>
            <category><![CDATA[libraries]]></category>
            <category><![CDATA[gem]]></category>
            <category><![CDATA[ruby-on-rails]]></category>
            <category><![CDATA[bundler]]></category>
            <dc:creator><![CDATA[Kazunori  Kamiya]]></dc:creator>
            <pubDate>Thu, 14 Sep 2017 14:13:29 GMT</pubDate>
            <atom:updated>2017-09-14T14:13:29.405Z</atom:updated>
            <content:encoded><![CDATA[<h3>・Bundlerとbundle initのインストール</h3><p>まず最初に、Bundlerをインストールする必要があります。</p><p>“gem install bundler”でBundlerをインストールでき、既にインストール済みであればアップデートすることもできます。<br>実行すると、大体下の画面のような感じになるはずです。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/848/1*yiN8cbQsNxwCzGDbtTrc_A.gif" /></figure><p>手動でBundlerを使い始めるために、”bundler_example”というフォルダを作成してみましょう。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/998/1*N7oT_cxxFKe7ka13-RiWxg.gif" /></figure><p>また、これを実行することで”bundler_example”の中に”Gemfile”が生成されます。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1002/1*nDpjnIjoH4Z5M9D8q4JhWg.gif" /></figure><h3>Gemfileの編集について</h3><p>自動生成されたGemfileは、source “https://rubygems.org&quot;から構成されています。<br>これはどういう意味かというと、Bundlerがgemを”https://rubygems.org”の中に探しに行くということです。<br>もし自分自身のRubyGemsサーバー、あるいは異なるサーバーを使いたい場合は、以下のように変更してください。</p><pre>source &quot;https://your_ruby_gem_server.url&quot;</pre><p>他にもいくつかgemのソースを持っていれば、ブロックあるいは”:source”を使うこともできます。</p><pre>source &quot;https://your_ruby_gem_server.url&quot; do<br>  <em># gems</em><br>end<br><br>gem &quot;my_gem&quot;, source: &quot;https://your_2_ruby_gem_server.url&quot;</pre><p>ブロック内のgemは、与えられたソースから回収されます。</p><p>“source”についてもっと知りたい場合は、<a href="http://bundler.io/man/gemfile.5.html#GLOBAL-SOURCES">ここ</a>を見るといいでしょう。</p><h3>Gemへの追加</h3><p>ここでは、いくつかの依存性をプロジェクトに追加してみましょう。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1002/1*nDpjnIjoH4Z5M9D8q4JhWg.gif" /></figure><p>上記のGemfileを使って、”bundler install”は”rails”gemの最新バージョンをインストールします。</p><p>特定のバージョンを指定したい場合は、以下のようにカンマの後にそのバージョンを指定すればいいです。</p><pre>gem &quot;rails&quot;, &quot;3.0.0&quot;</pre><p>あるいはシンタックスを用いて、以下のようにもできます。</p><pre>gem &quot;rails&quot;, &quot;~&gt; 4.0.0&quot; <em># which is same as gem &quot;rails&quot;, &quot;&gt;= 4.0.0&quot;, &quot;&lt; 4.1.0&quot; </em><br>gem &quot;nokogiri&quot;, &quot;&gt;= 1.4.2&quot;</pre><p>Gemfileにおけるgemについて詳しく知りたい場合は、<a href="http://bundler.io/man/gemfile.5.html#GEMS">このサイト</a>を見てください。</p><h3>Gemfileのシンタックスについてより深く</h3><p>Gemfileについてもっと詳しく知りたい場合は、<a href="http://bundler.io/man/gemfile.5.html">ここ</a>を見てください。</p><h3>Gemのインストールとbundleのインストール</h3><h4>開発について</h4><p>開発のためにgemをインストールするには、”bundle install”を実行すればよいです。<br>そうすると、以下の画面と似たようなものが出てくるはずです。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*IqIynzSMeeKq2QKF0gMxxg.gif" /></figure><p>また、そうすると<a href="http://bundler.io/man/bundle-install.1.html#THE-GEMFILE-LOCK">Gemfile.lock</a>というものが作成されます。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/974/1*3Dee0YJZX50SdZuZ4zQKyQ.gif" /></figure><p>Gemfile.lockに関しては、<a href="http://bundler.io/v1.15/guides/using_bundler_in_applications.html#gemfilelock">次の章</a>で見ていきます。</p><h4>デプロイについて</h4><p>デプロイするには、 <a href="http://bundler.io/man/bundle-install.1.html#DEPLOYMENT-MODE">— deployment</a>というオプションを使います。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/944/1*tGV1NBq1-Fa1FDKcCUN8wg.gif" /></figure><p>こうすることで、”./vendor/bundle”に関する全ての依存性をインストールすることができます。</p><p>また、このコマンドを実行するには、必要なものがいくつかあります。</p><ol><li>“Gemfile.lock”というファイルが必要である。</li><li>“Gemfile.lock”が最新化されること。</li></ol><p>“bundle install”というコマンドについてもっと詳しく知りたい場合は、<a href="http://bundler.io/man/bundle-install.1.html">ここ</a>をクリックしてください。</p><h3>Gemfile.lock</h3><p>Bundlerはこのファイルを、全てのgemの名前とバージョンを保存しておくために使用します。<br>もしアプリケーションがマシンから取り除かれたとしても、それはいつも使っているのと全く同じコードを保証してくれます。<br>初めてある特定のgemをインストールした後、Bundlerはそのバージョンを固定します。<br>それを更新するには、<a href="http://bundler.io/v1.15/guides/using_bundler_in_applications.html#updating-gems---bundle-outdated-and-bundle-update">bundler update</a>を使う、もしくはGemfile内のそのバージョンを変更する必要があります。</p><p>このファイルは、Bundlerのコマンド(bundle installやbundle updateなど)を使用した際に自動で生成され、バージョンコントロールの際にこれをチェックしてください。</p><p>前の章で見たGemfile.lockは、以下のようなものでした。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/974/1*3Dee0YJZX50SdZuZ4zQKyQ.gif" /></figure><p>これをもう少し噛み砕くと、以下のようになります。</p><ul><li>GEM</li><li>remote - gemのソースです。</li><li>specs - インストールされているgem(とそのバージョン)です。</li><li>PLATFORMS - アプリケーションで使われているプラットフォームです。(詳しくは<a href="http://bundler.io/man/gemfile.5.html#PLATFORMS">ここ</a>を見てください。)</li><li>DEPENDENCIES -Gemfileで定義されているgemです。</li><li>BUNDLED WITH - Gemfile.lockを変更するために最後に使われたBundlerのバージョンです。</li></ul><h3>コマンドの実行 — bundle exec</h3><p>まず最初に、例を見てみましょう。</p><pre>$ bundle exec rspec<br><br>$ bundle exec rails s</pre><p>こうすることで、現在のbundle環境におけるコマンド(ここでは”rspec”と”rails s”)を実行することが可能になり、Gemfile内の全てのgemで”require”を使うことで使用することができます。</p><p>“bundle exec”について詳しく知りたい場合は、<a href="http://bundler.io/man/bundle-exec.1.html">ここ</a>を見てください。</p><h3>Gemの更新 — bundle outdatedとbundle updated</h3><p>では、いくつかgemをアップデートしてみましょう。<br>“bundle outdated”を使えば、インストールされているgemの最新バージョンのリストを見ることができます。</p><pre>$ bundle outdated<br>Fetching gem metadata from https://rubygems.org/<br>Fetching version metadata from https://rubygems.org/<br>Fetching dependency metadata from https://rubygems.org/<br>Resolving dependencies.......<br><br>Outdated gems included in the bundle:<br>  * nokogiri (newest 1.6.8, installed 1.6.7.2) in group &quot;default&quot;</pre><p>“bundle outdated *gems”を使えば、gemを指定することもできます。</p><p>もしバージョンが1.6.7.2になっている”nokogiri”があったとして、どうすればそれをアップデートできるでしょうか？<br>“Gemfile.lock”で固定されているため、”bundle install”では新しいバージョンのものをインストールできません。<br>そのため、ここでは”bundle update”というコマンドを使います。</p><pre>$ bundle update<br>Fetching git://github.com/middleman/middleman-syntax.git<br>Fetching gem metadata from https://rubygems.org/<br>Fetching version metadata from https://rubygems.org/<br>Fetching dependency metadata from https://rubygems.org/<br>Resolving dependencies.....<br>Installing nokogiri 1.6.8 (was 1.6.7.2) with native extensions<br>Using i18n 0.7.0<br><br>... (and more)<br><br>Bundle updated!</pre><p>何も指定せずに”bundle update”と打った場合は、全てのgemを最新バージョンにアップデートします(Gemfileによって制止されています)。</p><p>特定のgemをアップデートするには、”bundle update *gems”を実行してください。</p><p>“bundle outdated”について詳しく知りたい場合は、<a href="http://bundler.io/bundle_outdated.html">このページ</a>を読んでみてください。<br>“bundle update”について詳しく知りたい場合は、<a href="http://bundler.io/man/bundle-update.1.html">このページ</a>を読んでみてください。</p><h3>オススメのワークフロー</h3><p>一般的に、bundlerによって管理されているアプリケーションを動かす場合、以下のコマンドについては知っておくべきでしょう。</p><p>・Bundlerを初期化するには</p><pre>$ bundle init</pre><p>・初めて”Gemfile”を作成した後には</p><pre>$ bundle install</pre><p>・”Gemfile.lock”の成果をバージョンコントロールに追加するには</p><pre>$ git add Gemfile.lock</pre><p>・このリポジトリをもう1つのデプロイマシンに反映させるには</p><pre>$ bundle install</pre><p>・このリポジトリをデプロイマシンに反映させるには</p><pre>$ bundle install --deployment</pre><p>・最新の依存性を”Gemfile”の変更後に反映させるには</p><pre>$ bundle install</pre><p>・アップデートしたgemfile.lockを確実にバージョンコントロールに反映させるには</p><pre>$ git add Gemfile.lock</pre><p>・”bundle install”が矛盾を訴えてくる場合、”Gemfile”内で変更したgemを手動でアップデートする必要があります。</p><pre>$ bundle update rails thin</pre><p>・Gemfile(5)内にリストアップされているgemとマッチする全てのgemを最新バージョンにアップデートするには</p><pre>$ bundle update</pre><h3>トラブルシューティング</h3><p>Bundlerを使っているプロジェクト内で”git bisect”を実行してください。<br><a href="http://bundler.io/git_bisect.html">Git Bisect Guide</a>を見るといいでしょう。</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3403ab27dc81" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[継承のMix-inについて]]></title>
            <link>https://medium.com/@kazunorikamiya/%E7%B6%99%E6%89%BF%E3%81%AEmix-in%E3%81%AB%E3%81%A4%E3%81%84%E3%81%A6-98c3c25e65dd?source=rss-e42be372267d------2</link>
            <guid isPermaLink="false">https://medium.com/p/98c3c25e65dd</guid>
            <category><![CDATA[composition]]></category>
            <category><![CDATA[class]]></category>
            <category><![CDATA[ruby]]></category>
            <category><![CDATA[inheritance]]></category>
            <category><![CDATA[macos]]></category>
            <dc:creator><![CDATA[Kazunori  Kamiya]]></dc:creator>
            <pubDate>Wed, 13 Sep 2017 12:57:40 GMT</pubDate>
            <atom:updated>2017-09-13T12:57:40.238Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>・Exercise44：継承とコンポジション</strong></p><p>おとぎ話において、邪悪な森というのはよく話に出てきます。<br>そこは大抵、主人公が足を踏み入れるべきではない場所ですが、悪党が出現するとその中に足を踏み入れざるを得ない状況になります。<br>物語に置ける主人公にとって、自分の命を危険にさらすようなシチュエーションというのは必須でしょう。</p><p>オブジェクト指向プログラミングにおいて、継承というのはこの邪悪の森のような厄介なものです。<br>この森はとても強大な力を持っていて、殆ど全てのプログラマーは足を踏み入れざるを得ない状況に陥ります。<br>ただその冒険の後に、森から出て二度と立ち入らなくて済むようになり、もう一度連れ込まれそうになった場合はそれを防ぐことができるでしょう。</p><p>継承というものを面白おかしく説明すると、上記のようになります。<br>継承のことを学習するに当たっては、以下のことを覚えておいてください。</p><p><strong>大抵の継承の使い方は簡略化あるいはコンポジションによって置き換えることができ、このエクササイズでそれを見ていきます。</strong></p><h3>継承とは何か？</h3><p>継承というのは、親クラスからその特徴を受け継いだクラスのことを指し示すのに使われます。<br>これは例えばclass Foo &lt; Barと書いた場合に起こり、Barクラスを継承するFooクラスを作成する、という意味になります。<br>こうする場合、プログラミング言語はFooのインスタンスにおけるアクションをBarのインスタンスにするかのように実行できます。<br>こうすることで、Barクラスの一般的な機能性をFooクラスで必要な場合に特殊化することができます。</p><p>このような種類の特殊化を実施する場合、親クラスと子クラスにおける相互作用には3つのものがあります。</p><ol><li>子クラスにおけるアクションは、親クラスのものを含む。</li><li>子クラスにおけるアクションは、親クラスのものをオーバーライドする。</li><li>子クラスにおけるアクションは、親クラスのものを変更する。</li></ol><p>次の章では、順番にこれらのデモンストレーションを、コードを交えながら見せていきます。</p><h4><strong>・継承を含む場合</strong></h4><p>最初に、親クラスでメソッドを定義して子クラスではそれを定義しないという、暗黙のアクションについて例をお見せします。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/968/1*G4IeLSf2VddKK73ZKsJSBg.gif" /></figure><p>Childクラスの中身は空っぽですが、Parentクラスからその振る舞いを全て受け継いでいます。<br>このコードを実行すると、以下のようになります。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/492/1*4irPviW9qNasz1E2bQPojA.gif" /></figure><p>15行目のson.implicit()を呼び出したところで、Childクラスでimplicitというメソッドが定義されていないにも関わらず、それが動くのはParentクラスで定義されているものを呼び出している、ということを理解してください。<br>ここで言いたいのは、メソッドを基本となるクラス(ここではParent)で定義しておけば、その全てのサブクラス(ここではChild)で自動的にそれを使用することができます。<br>たくさんのクラスにおいて繰り返しの処理が多い場合には、非常に有効な手段となるでしょう。</p><h4>・オーバーライドする</h4><p>暗黙のうちに実行されてしまうメソッドを含むことの問題は、子クラスで異なるアクションを実行したい場合です。<br>このケースでは、子クラスでメソッドをオーバーライドして、その機能性を事実上入れ替えます。<br>これを実行するには、Childクラスにて同じ名前でメソッドを定義し直せばいいです。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*eL-PGAsHxuJ-LWnV3GeZEg.gif" /></figure><p>この例では両方のクラスでoverrideというメソッドを定義していますが、さて実行時にどうなるか見てみましょう。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/590/1*N0KnSM0hxMdml2qPTijoGQ.gif" /></figure><p>ここからわかるように、14行目が実行されたときにはParent.overrideというメソッドが実行されまずが、これはdadという変数がParentのものだからです。<br>しかし、15行目が実行されたときにはChild.overrideのメッセージが表示されますが、これはsonがChildのインスタンスであり、Childがそのメソッドを定義し直すことでオーバーライドされたからです。</p><h4>・前後での変更</h4><p>3つ目は、Parentクラスのものが実行される前後で変更を加えたい場合にオーバーライドするという、特別なケースで継承を使うことです。<br>最初にちょうど前の例でやったようにメソッドをオーバーライドし、それからRubyに元々あるsuperというメソッドを使って、Parentクラスのメソッドを呼び出します。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IEaSg0ZHkfPe3C4mqS_khQ.gif" /></figure><p>重要なのは9行目から11行目で、Childクラスのその中ではson.altered()が呼び出された場合に以下のことを実行しています。</p><ol><li>Parent.alteredをChild.alteredでオーバーライドしているので、9行目の実行時にはその後のものが出力されます。</li><li>ここでは変化の前後を見たいので、9行目の後にsuperを用いることでParent.alteredのものを取得しています。</li><li>10行目でsuper()を呼び出していますが、これによってParentクラスのメソッドを呼び出すことができます。</li><li>このときにParent.alteredのメソッドが実行され、Parentクラスのメッセージが出力されます。</li><li>最後にParent.alteredからこういった返却があり、その後に続けてChild.alteredというメソッドが実行されてメッセージが出力されます。</li></ol><p>実行すると、以下のようになるはずです。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/656/1*zpFhxc_Wx5BJuMcDmvX5rA.gif" /></figure><h4>・上記の3つの組み合わせ</h4><p>これら3つのデモンストレーションを行うために、最初の継承のところで扱ったファイルからそれぞれの相互作用を含む、最終バージョンのファイルを作成しました。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*EP6vMi0eL6XCbWl34i7SEg.gif" /></figure><p>それぞれの行を見て、それがオーバーライドされるかどうかコメントを書いてみてください。<br>その後に実行して、それが合っているかどうか確認してみましょう。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/762/1*Z2Cnror0IC0GZiOYo93plg.gif" /></figure><h4>・initializeを伴うSuper()の使い方</h4><p>super()の最も一般的な使い方は、元となるクラスのinitializeメソッドの中です。<br>子クラスで何か実行する必要がある場合は大抵そこが唯一の場所であり、それから親クラスにおける初期化処理を完了させます。<br>下のコードは、Childクラスでその処理を実装した簡単な例です。</p><pre>class Child &lt; Parent<br>    def initialize(stuff)<br>        @stuff = stuff<br>        super()<br>    end<br>end</pre><p>これは上で出てきたChild.alteredの例と同じですが、ParentにParent.initializeを用いて初期化機能を持たせる前に、initializeにいくつか変数をセットした点だけが異なります。</p><h3>コンポジションについて</h3><p>継承は便利ですが、実はもう1つ同じことをする方法があって、それは暗黙の継承に頼るよりも他のクラスやモジュールを使うことです。<br>継承における3つの功績を見たときに、その3つのうち2つは機能性を置き換えるあるいは変更するために新たにコードを書くことを必要とします。<br>これは単純に、モジュール内のメソッドを呼び出すだけに置き換えることができます。<br>その例が、以下のコードになります。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CgIiSPx73C197XmvDzIl0A.gif" /></figure><p>このコードではParentクラスを使っていませんが、それは親子というのがis-aの関係ではないからです。<br>それはhas-aの関係であり、Child has-a Otherという関係性の下で動きます。<br>これを実行すると、以下のようになるはずです。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/706/1*w_yj7qHvpafsd3YAW60iCQ.gif" /></figure><p>ChildとOtherのコードの殆どは、同じことをするためのもので、書いてあることも同じだとわかると思います。<br>唯一違うところは、ある1つのアクションを実行するために、Child.implicitというメソッドを定義しなければならなかったことです。<br>それからOtherをクラスにする必要があるか自問し、other.rbというモジュールに作り変えることができるでしょうか？</p><p>Rubyにはもう1つ、モジュールを用いたコンポジションの方法があり、それはMix-inと呼ばれます。<br>単純にクラスに共通なメソッドを含むモジュールを作成し、requireを使うのと似たようにそれをクラスの中に含めるだけです。<br>下のコードは、モジュールとMix-inを用いた同じコンポジションの例です。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cbjTccK-A41Qll2nRTOPEQ.gif" /></figure><p>これは、前のコンポジションの例によく似ています。<br>Mix-inはもっと強力なもので、ここでは話題にしませんが高度な内容を含みます。</p><h3>継承とコンポジションそれぞれの使い方</h3><p>継承とコンポジションのどちらがいいかという質問は、再利用できるコードに関する問題を解こうとする試みになります。<br>重複を含むコードは非効率で汚いので、そんなものは誰も持ちたくないでしょう。<br>継承の場合は、基本となるクラスにそういった機能を組み込ませることによって、その問題を解決することができます。<br>コンポジションの場合は、モジュールと他のクラスのメソッドを呼び出す機能によってその問題を解決します。</p><p>両方の解決法が共に再利用できるコードに関する問題なら、どのシチュエーションでどちらの解決法を用いればいいのでしょうか？<br>これに対する答えはかなり主観的になってしまうものの、どんな場面でどちらを使うべきか、3つのガイドラインをお教えします。</p><ol><li>メタプログラミングという有効ながら非常に扱いの難しいものがあり、とにかくそれを避けましょう。もしそれに固執するのであれば、クラス階層についてしっかりと理解しておくのと、そこから来るものを決定するのに時間をかけてください。</li><li>モジュールにコードを詰め込むのにコンポジションを用いますが、これは多くの関連のない場所やシチュエーションで使われます。</li><li>継承を使うのは、1つの共通の概念の下で明らかな関連性のあるコードの集まりがある場合、あるいは使っている何かのせいでそうしなければならない場合です。</li></ol><p>ただ、あまりこのルールに縛られすぎないようにしてください。<br>オブジェクト指向プログラミングで覚えておいてほしいのは、それが社会の規則的なプログラマーによって作られたコードをパッケージ化したりシェアしたりするためのものだということです。<br>なぜならそれは社会的な規則であり、Ruby内で成文化されたものではありますが、一緒に働く人たちからもこれらのルールを避けるように言われるからです。<br>そういったケースでは、他の人たちがどのように仕事をしているか理解し、そのシチュエーションに適応できるようにしてください。</p><h4>学習ドリル</h4><p><a href="https://github.com/bbatsov/ruby-style-guide">https://github.com/bbatsov/ruby-style-guide</a>に飛んで、そこに書いてあることを自分のコードでも使ってみてください。<br>その中で書かれていることは、今まで学習したことと異なっている部分がいくつかあると思いますが、そこで薦められていることを理解して使えるようにならなければいけません。<br>このテキストの残りの部分では、それがよりコードを複雑化するかどうかによって、ガイドラインに従っていたりそうでなかったりします。<br>含蓄は自分自身の秘密あるいは独自のルールで人々に影響を与えるよりも重要なので、そうしてみるといいでしょう。</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=98c3c25e65dd" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[オブジェクト指向の設計について]]></title>
            <link>https://medium.com/@kazunorikamiya/%E3%82%AA%E3%83%96%E3%82%B8%E3%82%A7%E3%82%AF%E3%83%88%E6%8C%87%E5%90%91%E3%81%AE%E8%A8%AD%E8%A8%88%E3%81%AB%E3%81%A4%E3%81%84%E3%81%A6-b06b41e1d220?source=rss-e42be372267d------2</link>
            <guid isPermaLink="false">https://medium.com/p/b06b41e1d220</guid>
            <category><![CDATA[terminal]]></category>
            <category><![CDATA[macos]]></category>
            <category><![CDATA[ruby]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[oop]]></category>
            <dc:creator><![CDATA[Kazunori  Kamiya]]></dc:creator>
            <pubDate>Mon, 11 Sep 2017 13:54:40 GMT</pubDate>
            <atom:updated>2017-09-11T13:54:40.047Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>・Exercise43：基本的なオブジェクト指向の分析とデザイン</strong></p><p>ここでは、Rubyにおけるオブジェクト指向プログラミングの取り組み方のプロセスについて紹介していきます。<br>ここでいうプロセスというのは、順番に取り組むべきステップのことですが、何もかもそれに従う必要はありません。<br>様々なプログラミングにおける問題に対して有効ではありますが、これを万能だとは思わないでください。</p><p>具体的なプロセスは、以下のようになります。</p><ol><li>その問題に関することを書き出す。</li><li>1から鍵となる概念を抜き出し、それについて調べる。</li><li>その概念に関する、クラス階層とオブジェクトマップを作成する。</li><li>そのクラスをコードに書いて、テストとして実行してみる。</li><li>上記を繰り返して磨きをかけていく。</li></ol><p>このプロセスにおける上のやり方をトップダウンと言い、抽象的でモヤっとしたアイデアから始まって、少しずつそれを洗練してきちんと形にしコードを書くところまで進めることを言います。</p><p>まずその問題について書き出すところから始め、それについてできることを考えていきます。<br>恐らくその問題のことを描いたダイアグラムやある種のマップ、さらにあるいは自分自身に向けた一連のeメールを書くでしょう。<br>これによってその問題における鍵となる概念の表現方法がわかり、さらに既に自分がそれについて知っていることが明らかになります。</p><p>そこからこれらのノートや図などを一通り確認し、鍵となる部分を引き出します。<br>具体的には、次のようにやればいいです。<br>今までに書いた文章や図などを見直して名詞と動詞のリストを作成し、そこからそれらがどのように関連し合っているか書き出してみます。<br>これによって、次のステップにおけるクラスやオブジェクトにメソッドの名前のリストができてきます。</p><p>そして概念のリストからシンプルなアウトラインツリーを作成し、それらがクラスとしてどのように関連し合っているかわかります。<br>その名詞のリストに共通の親クラスがあるかどうか確認し、もしあればその名前は一体何なのか、この問いかけをそのクラス階層がシンプルなツリーかダイアグラムになるまで繰り返してみてください。<br>同様に動詞のリストにも取り組み、ツリーの中でそれぞれのクラスに当てはまるメソッドの名前を明らかにしていってください。</p><p>このクラス階層が明らかになったところで、クラスやメソッドの型となるものを入れた基本的なスケルトンコードを書いてみます。<br>そしてそのコードをテスト実行し、作成したクラスがきちんと意味を成して動いているかを確認します。<br>時々はテストを最初に行うこともありますが、それ以外は細かいテストをしてコードを書いてまたテストを行い、全てのものができるまでこれを繰り返します。</p><p>最後にこのプロセスを繰り返し、明確になるまでアイデアを洗練させていきます。<br>もし予期せぬところで詰まってしまった場合は、一旦立ち止まってその部分でプロセスをやり直してから次に進んでください。</p><p>次の章では、このプロセスを通してあるゲームエンジンのことを見ていきます。</p><h3>シンプルなゲームエンジンの分析</h3><p>ここで作りたいゲームは”Gothons from Planet Percal #25,”と呼ばれており、アドベンチャーゲームの1種です。</p><h4>その問題に関することを書き出す</h4><p>このゲームに関するパラグラフを、少々書き出してみます。</p><p>エイリアンが宇宙船に押し寄せ、私たちのヒーローはたくさんの部屋を通ってエイリアンを倒しつつ、下の星に向かう脱出ポッドに逃げ込むことができます。<br>このゲームは以前出てきたZorkに近いもので、あるいはテキストによるアウトプットと面白い死に方を伴うアドベンチャーゲームでもあります。<br>このゲームは、たくさんの部屋や場面を通り抜けるのにエンジンを必要とします。<br>それぞれの部屋に入ると、そこにしかない描写がなされ、次にどの部屋に進むべきかエンジンに伝わります。</p><p>この時点でゲームに関する考えとどのように操作するかがまとまったので、それぞれのシーンについて書き出してみます。</p><ol><li>Death・・・これはプレーヤーが死亡した場合のことで、何か面白いことが起きます。</li><li>Central Corridor・・・ゲームのスタート地点となる場所で、Gothonは既にここに立っており、プレーヤーは続ける前にいたずらをして彼を倒さなければなりません。</li><li>Laser Weapon Armory・・・ヒーローが脱出前に宇宙船を破壊するための中性子爆弾を取りに行く場所で、入るにはキーパッドの番号を当てる必要があります。</li><li>The Bridge・・・ヒーローが爆弾を置いた場所で、Gothonと戦うもう1つの場所でもあります。</li><li>Escape Pod・・・ヒーローが脱出するための場所ですが、その前にそれが本物かどうか見極めなければなりません。</li></ol><p>この時点でこれらのマップ、恐らくそれぞれの部屋について書いていきます。<br>それは問題を調べていくに連れて、頭に浮かんできたこと全てです。</p><h4>鍵となる概念を見抜きそれについて調査する</h4><p>さてこの時点で、いくつか名詞を抽出してそのクラス階層について調査するための情報が集まってきたと思います。<br>まず、全ての名詞を一覧にしてみます。</p><ul><li><strong>Alien</strong></li><li><strong>Player</strong></li><li><strong>Ship</strong></li><li><strong>Maze</strong></li><li><strong>Room</strong></li><li><strong>Scene</strong></li><li><strong>Gothon</strong></li><li><strong>Escape Pod</strong></li><li><strong>Planet</strong></li><li><strong>Map</strong></li><li><strong>Engine</strong></li><li><strong>Death</strong></li><li><strong>Central Corridor</strong></li><li><strong>Laser Weapon Armory</strong></li><li><strong>The Bridge</strong></li></ul><p>同様に動詞についても一覧を作成してメソッド名に相応しいものがないか見ていきたいところですが、この時点ではそれはスキップします。</p><p>この時点で、それぞれの考え方やその他わからないことがあれば調べるようにしてください。<br>例えば、似たようなゲームを少しやってみて、それらがどのようなものか頭に入れておくといいかもしれません。<br>どのように宇宙船がデザインされ、どのように爆弾は作動するのか、といったことも少しは知っておく必要があるでしょう。<br>技術的なところで言えば、ゲームの状態をどのようにデータベースに溜めておくかも少しは調べておく必要があると思います。<br>これらの調査が一通り済んだら、新たな情報に基づいてステップ1からやり直し、自分の考えを書き直して新しい概念を引き出すようにします。</p><h4>概念に対するクラス階層とオブジェクトマップの作成</h4><p>“何か他に似ているものはないか？”、加えて”別のものに対する本来の別の言葉はないか”と問いかけることにより、それをクラス階層に変換することができます。</p><p>まずすぐに”Room”と”Scene”は根本的には同じものであり、状況次第で変わるものだとわかるでしょう。<br>このゲームでは、”Scene”の方を用います。<br>それから全ての特定の部屋、例えば”Central Corridor”は根本的に”Scene”の1つだとわかります。<br>Deathも同様にSceneだとわかり、死の場面に出くわした場合に”Room”より”Scene”の方がより適切な言葉だと思わせてくれるものの、死の部屋というのも変な言い方です。<br>“Maze”と”Map”も基本的に同じであり、ここではより頻繁に使われている”Map”を用います。<br>戦うシステムを作りたくはないので、”Alien”と”Player”は後のために取っておきます。<br>“Planet”も何か特別なものではなく、同様に場面の1つに過ぎません。</p><p>ここまで考えたところで、以下のようなクラス階層が出来上がります。</p><pre>* Map<br>* Engine<br>* Scene<br>  * Death<br>  * Central Corridor<br>  * Laser Weapon Armory<br>  * The Bridge<br>  * Escape Pod</pre><p>ここからは、その描写における動詞に基づいてそれぞれどのようなアクションが必要なのか明らかにしていく必要があります。<br>例えば、エンジンを動かすための方法が必要な場面において、マップから”get the next scene”と”opening scene”を選び、そのシーンに”enter”することが必要となります。<br>このことを階層図に書き加えると、以下のようになります。</p><pre>* Map<br>  - next_scene<br>  - opening_scene<br>* Engine<br>  - play<br>* Scene<br>  - enter<br>  * Death<br>  * Central Corridor<br>  * Laser Weapon Armory<br>  * The Bridge<br>  * Escape Pod</pre><p>ここで”-enter”を”Scene”のすぐ下に置いたのは、その下にある全てのシーンはそれを受け継いでいて、後にそれを無効にしなければならないからです。</p><h4>クラスをコード化して実行テストをしてみる</h4><p>ここまででクラスのツリー構造といくつかメソッドが判明したので、テキストエディタにそれを書いていこうと思います。<br>上のツリー構造をコピペして、実際のクラスの形に直していくのがよくあるやり方の1つです。<br>下のコードが、実際どのようになるか最後に簡単なテストを含めて書いたコードです。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/942/1*HXjOaUGzAIXSRbqCm4halQ.gif" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/946/1*vjQqwX2KtpOAC2lrTN7rAA.gif" /></figure><p>このファイルでは、単に必要な階層を書き写したのと、末尾にこの基本構造できちんと動くか確かめるためのテストを少し加えただけです。<br>このエクササイズの後のセクションで、残りの部分を埋めてこのゲームがきちんと与えられた表現通りになるか見ていきます。</p><h4>繰り返して磨きをかけていく</h4><p>このプロセスにおける最後のステップは、whileループのような巨大なものではありません。<br>ただここまでの流れを、一度きりだとは思わないでください。<br>全てのプロセスを繰り返すよりも、後ろの方のステップで得た情報を元にコードに磨きをかけていきましょう。<br>時々ステップ3に着手したときにステップ1と2をもう少し勉強する必要となる場合がありますが、その場合はそこで立ち止まってそこを勉強すればいいです。<br>時々は鋭いインスピレーションを得て、最後のコード化するところまでアイデアが湧き出てくることもありますが、そこからまた前のステップに戻って全ての可能性を確認していく必要があると思います。</p><h3>トップダウンとボトムアップの比較</h3><p>トップダウンと呼ばれるプロセスは、最も抽象的な部分から始まり、そこから実際の履行まで進めていきます。<br>このテキスト内で何か問題を分析する場合に、このやり方を試して見て欲しいですが、もう1つプログラミングにおける問題を解決する場合にコードから始まって抽象的な部分へと向かうという考え方を覚えてほしいです。<br>これがボトムアップと呼ばれるもので、具体的には以下のようなステップで進めていきます。</p><ol><li>問題の一部分を取り上げる、例えばコードを少しだけ実行してみる。</li><li>そのコードを、上手くクラスを使ったり自動テストを取り入れるなどして、より綺麗に書き直していく。</li><li>そこで使っている鍵となる概念などを抜き出し、それについて調べる。</li><li>実際に何が起きているのか、きちんと記述してみる。</li><li>コードの練り直しに戻る。</li><li>コードの他に問題がある部分へ移り、上記のサイクルを繰り返す。</li></ol><p>このやり方は、全体のパズルのうち一部分がわかっている場合に有効ですが、全体に関してはまだ情報が不十分でしょう。<br>全体を小さなピースに分解して、コードと共に探っていくことで、問題を解決するまで問題にしっかりと向き合うことができるでしょう。</p><h3>“Gothons from Planet Percal #25”のコード</h3><p>ここからは最初の問題に対する答えを書いていきますが、ただ書き写すのはやめてください。<br>用意したスケルトンコードを元に、描写に基づいてきちんと動作するようになるか試してみてください。<br>自分なりの答えが用意できたら、ここの答えを見るようにしてください。</p><p>ここでは”ex43.rb”というファイルに、セクションごとに分けて書いていきます。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wSuskxPbXfDKe0GUjl6APw.gif" /></figure><p>スケルトンコードを見ればわかるように、基本となるクラスSceneを作り、そこには全てのシーンで共通となるものが入るでしょう。<br>これだけでは大した動きもないので、これを元にデモンストレーションを加えてみました。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vVURRnFLqrPPVEuag3UpGA.gif" /></figure><p>Engineクラスがあり、そこでどのように”Map.opening_scene”と”Map.next_scene”を使ったのか見てみてください。<br>このように書けたのは、Mapクラスを書く前にこの2つのメソッドを使うことを想定して、ちょっとしたプランニングを立てていたからです。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FycCDP7XDSJPYAffX5jVRA.gif" /></figure><p>最初のシーンはDeathと名付けられた奇妙なものですが、ここでは書けるであろう最もシンプルなシーンを表現しています。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*m9ofSr248XYwkSS8GeVl2w.gif" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5f4Jw9bUVj0Zbt1U_waoEQ.gif" /></figure><p>その後にCentralCorridorという、ゲームのスタート部分を作成しました。<br>ここではMapの前にゲームのシーンを作成していますが、これはシーンを後ほど参照する必要があるからです。<br>4行目で、dedentというメソッドをどのように使ったかにも注意してください。<br>後ほどそれを取り除いて、どうなるか見てみてください。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mdsQyUMAYE1JJ17bigt0rw.gif" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*c3j1xNwwunIrNM6OPK2G-w.gif" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DyeQg3y0P4fersoEfEHoQw.gif" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*a1f-_5Sn8u1r8l7ZlRS-ZA.gif" /></figure><p>ここで書いたのがゲームの残りのシーンです。</p><p>ついでに言いますが、ここで書いているコードはそのまま書き写すのではなく、自分で考えて少しずつ書いてみてください。<br>一応ここでは、考えた末の結果を書き記しています。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*H04NweWfzXUVNSglIz4m1g.gif" /></figure><p>ここで作成したMapクラスを見ると、それぞれのシーンが名前ごとにハッシュに入れられているのがわかり、それを”@@scene”として参照しています。<br>これにより、マップがシーンの後に来る理由が、ハッシュがシーンを参照しなくてはならないためとわかります。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/974/1*3QIE6ovWJA6YcHB40CPP4A.gif" /></figure><p>最後にMapを作成してコードを実行し、playを呼び出してゲームを実行する前にそのマップをEngineに渡しています。</p><h3>実行結果について</h3><p>しっかりとこのゲームの内容を理解して、まず自分自身で解くようにしてみてください。<br>もしわからなくなった場合はここに書いてあるコードを少しだけ読み、そこから自分で続きを解くようにしてみてください。</p><p>ゲームを実行すると、以下のようになります。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-aDROIuKzC9k4pH23t7wUQ.gif" /></figure><h4>学習ドリル</h4><ol><li>このゲームは暴力的で嫌う人も多いと思うので、好きなように変更してみてください。</li><li>このコードには、バグがあります。なぜ11回入力を間違えると、ドアがロックされるのでしょうか？</li><li>どのように次の部屋に進む動作が返却されているか説明してください。</li><li>チートコードを加えて、より難しい部屋を通り越せる用にしてみてください。1行に2つの言葉を足せば可能です。</li><li>描写と分析のところに戻って、英雄と彼が出会う様々なGothonsのための小さな戦闘シーンを作成してみてください。</li><li>これは実際には、有限状態機械と呼ばれるものの非常に小さなタイプです。それについて調べて、資料を読んでみてください。</li></ol><h4>学習ドリルの答え</h4><p>2. whileループの前に既に1度入力が実行されているので、ループも合わせると合計11回の入力が可能になっています。そこでguessesの初期値を1とすることで、ループの回数が9回になって合計10回入力できるようになります。</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b06b41e1d220" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[クラスとオブジェクトの違いについて]]></title>
            <link>https://medium.com/@kazunorikamiya/%E3%82%AF%E3%83%A9%E3%82%B9%E3%81%A8%E3%82%AA%E3%83%96%E3%82%B8%E3%82%A7%E3%82%AF%E3%83%88%E3%81%AE%E9%81%95%E3%81%84%E3%81%AB%E3%81%A4%E3%81%84%E3%81%A6-7c2f2439ddf8?source=rss-e42be372267d------2</link>
            <guid isPermaLink="false">https://medium.com/p/7c2f2439ddf8</guid>
            <category><![CDATA[class]]></category>
            <category><![CDATA[mac-os-x]]></category>
            <category><![CDATA[object-oriented]]></category>
            <category><![CDATA[macos]]></category>
            <category><![CDATA[ruby]]></category>
            <dc:creator><![CDATA[Kazunori  Kamiya]]></dc:creator>
            <pubDate>Thu, 07 Sep 2017 07:38:19 GMT</pubDate>
            <atom:updated>2017-09-07T07:38:19.869Z</atom:updated>
            <content:encoded><![CDATA[<p>・Exercise42：is-a、has-a、オブジェクト、クラス</p><p>クラスとオブジェクトの違いを理解しておくことは、とても重要です。<br>ここの難しいところは、クラスとオブジェクトには本質的な違いがないということです。<br>実際に、両方とも異なるポイントで同じことをするんです。<br>“Zen Koan”による、デモンストレーションをご紹介しましょう。</p><pre>What is the difference between a fish and a salmon?</pre><p>ここで一旦、この質問について考えてみてください。<br>私が言いたいのは、魚と鮭は異なるものですが、本質的には同じものではないかということです。<br>鮭は魚の種類の1つであるため、結局両者に違いはないと言えます。<br>しかし同時に、鮭は魚の中のある種類であるために、他の魚とは異なると言えます。<br>それゆえ、鮭はオヒョウの身ではありません。<br>従って、鮭と魚は同じで違うとも言えます。</p><p>この質問がややこしいのは、人が現実にこのように考えることはないからですが、直感的にこのことは理解していると思います。<br>鮭と魚の関連性はわかっているはずなので、両者の違いについては語る必要はありません。<br>鮭は魚の種類の1つであり、他にも様々な種類の魚がい流ということはわかっているはずです。</p><p>話をもう一歩進めてみましょう。<br>あなたは今、3匹のサーモンが入ったカゴを持っている状態で、それぞれにフランク・ジョー・メアリーという名前をつけたとします。<br>この状況で、以下の質問について考えてみてください。</p><pre>What is the difference between Mary and a salmon?</pre><p>これがくだらない質問だということはこちらもわかっていますが、魚と鮭の質問よりはいさかか簡単だと思います。<br>メアリーが鮭だということはわかっており、彼女が本当に鮭とは異なるものだということはありません。<br>彼女は単純に、鮭のインスタンスに過ぎないのです。<br>同様に、フランクとジョーもインスタンスです。<br>ここで何を言いたかったかというと、彼ら3匹の鮭は他の鮭から作られたということであり、鮭の属性のようなものを持つ現実のものであるということです。</p><p>プログラム的に話をすると、魚はクラスであり、同様に鮭もクラス、そしてメアリーはオブジェクトになります。<br>少し時間を使ってこの内容を噛み砕き、理解できたか確かめてください。</p><p>魚がクラスであるということは、それは現実のものでないということを意味するのですが、これは似たような属性をもののインスタンスに加えているということです。<br>ヒレがあるか、エラがあるか、水の中に住んでいるか、ここまで書かれればそれは恐らく魚のことでしょう。</p><p>ある博士が、”これは確かに大西洋鮭であり、鮭として知られているものだ”と言いました。<br>この教授はその魚のことを説明し、更に新たにより明確な特徴を持つ鮭というクラスを作り出しました。<br>長い鼻、赤みがかった身、大きい、海もしくは淡水に住んでいる、美味しい、ここまで聞けば恐らく鮭とわかるでしょう。</p><p>最後に、コックが博士の所に来てこう言いました。<br>“あなたが見ているこの鮭を私はメアリーと呼んでおり、これから素晴らしいソースと共に美味しいフィレを作るつもりです”と。<br>ここで、鮭のメアリーのインスタンスを得たことになり(それは同様に魚のインスタンスでもある)、現実の食べ物となってあなたのお腹を満たしてくれます。<br>それがすなわち、オブジェクトが生成されたということです。</p><p>ここまでであなたがわかっているのは、メアリーは鮭の一種でありそれは魚の一種でもある、つまりオブジェクトはクラスでありクラスはクラスであるということです。</p><h4>この考え方をコードの中で見るとどうなるか</h4><p>まず、何がクラスで何がオブジェクトなのか理解するための2つの特徴について紹介します。</p><p>まず、”is-a”と”has-a”という言葉について理解する必要があります。<br>前者についてはクラスの関係性によって互いに関連づけられているクラスとオブジェクトの話をしたとき、後者はお互い参照しているだけのクラスとオブジェクトの話のところで出て来ました。</p><p>続いて、下のコードを読んでコメント部分の##??を次の行がis-aなのかhas-aなのか、そしてどのような関係を表すのか書き換えてみてください。<br>最初の方で書き方の例を示しているので、残りのものも同様にやってみてください。</p><p>is-aは鮭と魚のような関係、has-sは鮭とエラのような関係だと覚えておいてください。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hf6DllV7mDhQTadlfoY01g.gif" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IZEnvBe3I34J4Mttp9iGoQ.gif" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*M2cE4R3nvS5CkIePeX6Lig.gif" /></figure><h4>学習ドリル</h4><ol><li>なぜRubyがこのようなオブジェクトクラスを入れたのか調べてみてください。</li><li>クラスをオブジェクトのように使うことは不可能でしょうか？</li><li>Animal、Fish、Personの3つのクラスに、何らかの関数を入れてみてください。そして、例えばDogクラスにおいて元のクラスの中にある関数がどのような動きをするか確かめてみてください。</li><li>他の人のコードとis-aとhas-aの関係性を見てみてください。</li><li>配列やハッシュのような新たな関係を作ってみてください。つまり、has-manyという関係性が生まれることになります。</li><li>is-manyのような関係性を持つものがあると思いますか？多重継承というものについて調べてみて、可能ならそれを避けるようにしてください。</li></ol><h4>学習ドリルの答え</h4><p>2. クラスはオブジェクトを継承したものなので、可能となります。全てのクラスはサブクラスのインスタンスであり、それはまたオブジェクトのサブクラスでもあります。</p><p>3. 適当に試してみました。スーパークラスのメソッドの呼び出しなどもやってみました。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xm4V_V7mqzGAKH7Loo5etA.gif" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DVrleXIIFs2uj8p4zahdxA.gif" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pi5aoWLAVAAinQ8yrWbpSQ.gif" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0FeHxhVHPnC6PC4NT-L_Ew.gif" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1016/1*9xFHQSiWchLR-DTg8AJpYQ.gif" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7c2f2439ddf8" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>