【SQL グループ化】GROUP BY/HAVING句とWITH ROLLUP

2024-02-02T00:00:00+00:00
本記事では、SQLにおける、
グループ化について解説します。
データを集約し、特定の条件でフィルタリングする際に、
Group ByとHaving句というものを使用して、
グループ化をすることができます。
グループ化は、めちゃくちゃ使うというわけでもないのですが、
知っておくべき必須教養みたいな側面はあるので、
ぜひとも押さえておきたい知識です。
また、グループ化は、
基本的に集計関数といっしょに使うことが多いので、
集計関数をはじめとした様々な関数について詳しく知りたい方は、
こちらの記事</a>も併せて御覧ください
https://reisuta.com/distinct-order-by-function/
SQLのグループ化</h2>
早速本題に入りたいのですが、
環境構築については、
下記の記事</a>で紹介しているので、
こちらでDockerのMySQLコンテナが立ち上がっていると想定します。
[st-card myclass="st-no-shadow" id="2357" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]
今回はグループ化なので、
部署テーブルなどを作っおく必要があるので、
初期構築のスクリプト</a>については、
下記の記事を御覧ください。
[st-card myclass="st-no-shadow" id="2385" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]

GROUP BY</h3>
まず、Group Byについてです。
SQLの集計に際し、検索結果をグループごとのまとまりに分ける機能があり、
それが、Group Byにあたります。
例えば、単にSUM(salary)</code> とかとすると、すべての合計が算出されますが、これを例えば、Departmentの営業部だけの合計を算出したいなどというときに、 Group Byは使えます。
Group By句は、SQLにおけるデータ集約の基本て、 特定の列を基にして、データをグループ化し、 それぞれのグループに対して集計関数（例：SUM、AVG、COUNT）を適用したいときに 使用するでしょう。文法としては、下記のような感じで、 GROUP BYで指定する列とSELECTの最初の列が同様という感じです。
SELECT</span> 列1, 集計関数(列2)</span></span>
FROM</span> テーブル</span></span>
(</span>WHERE</span> 絞り込み条件)</span></span>
GROUP BY</span> 列1;</span></span></code></pre>
例えば、下記のようなテーブルがあったとします。</p>

ID</td> Department</td> salary</td></tr>
1</td> sales</td> 6000</td></tr>
2</td> sales</td> 3000</td></tr>
3</td> HR</td> 3000</td></tr>
</table>
</p>
このテーブルに対して、

Departmentごとの平均給与を計算するSQLは以下の通りです。</p>
SELECT</span> department, </span>AVG</span>(Salary) </span>AS</span> AverageSalary</span></span>
FROM</span> Employees</span></span>
GROUP BY</span> department;</span></span></code></pre>
</p>
この場合、salesが60000 + 30000 / 2 = 45000になり、</strong>

HRはそのまま60000になっているので、</strong>

確かに部署ごとの平均給与になっていますね。</strong></p>
最初のうちは、混乱するかもしれませんが、

要するに複数のレコードにおいて、

同じ値が出ることが想定されるカラム(上記でいうと部署のように)に対して、

全データにおいて、その値においてグループ化したいというときに使用できるのが、

Group byという感じです(余計わかりにくくなった...?)</p>
グループ化の流れとして、

例えば、Where句などもある場合は、

先にWhereによる絞り込みが行われてから、

その表に対して、グループ集計が行われます。</p>
そのため、集計し終わったものに対しての絞り込みは、

Whereが最初に絞り込みを行う関係上、

Whereでは行うことはできません。</strong></p>
そこで使用するのが、次に紹介する、

Having Byとなります。</p>
HAVING句</h3>
Having句は、Group Byによってグループ化されたデータに対するフィルタリングを行います。

Where句と似ていますが、Having句は集約関数と共に使用される点が異なります。</p>
SELECT</span> 列1, 集計関数(列2)</span></span>
FROM</span> テーブル</span></span>
GROUP BY</span> 列1</span></span>
HAVING</span> 集計関数(列2) 条件;</span></span></code></pre>
HAVING句にも、

Whereと同様に条件式を書くので、

使い方としては、ほぼ同様です。</p>
異なるのは、その実行タイミングという感じです。</strong></p>
平均給与が46000以上の部門だけを表示するSQLは以下の通りです。</p>
SELECT</span> Department, </span>AVG</span>(Salary) </span>AS</span> AverageSalary</span></span>
FROM</span> Employees</span></span>
GROUP BY</span> Department</span></span>
HAVING</span> AVG</span>(Salary) </span>></span> 46000</span>;</span></span></code></pre>
</p>
上記のクエリーでHavingの部分を省略すると、

sales | 45000の結果も取得されるので、

確かにHaving句で結果を絞っていることがわかると思います。</p>
ちなみに、このHavingとGroup byを踏まえて、

最終的なSELECT文をまとめると、

SELECT文は下記のような文法となります。</p>
select 列1</span></span>
from テーブル名</span></span>
(where 条件式)</span></span>
(group by グループ化列)</span></span>
(having 集計結果に対する条件式)</span></span>
(order by 並び替えたい列)</span></span></code></pre>Group ByとHaving句の組み合わせ</h4>
Group ByとHaving句を組み合わせることで、より複雑なデータ集約とフィルタリングが可能になります。

例えば、各部門で最高給与を得ている従業員の数をカウントするには以下のようにします。</p>
SELECT</span> Department, </span>MAX</span>(Salary) </span>AS</span> MaxSalary, </span>COUNT</span>(ID) </span>AS</span> NumberOfEmployees</span></span>
FROM</span> Employees</span></span>
GROUP BY</span> Department</span></span>
HAVING</span> COUNT</span>(ID) </span>></span> 1</span>;</span></span></code></pre>
</p>
一番上のクエリーの場合、

HAVING COUNT(ID) > 1</code> と条件を加えているため、

一人しかいないHRのデータは取得できていません。</p>
２つ目のクエリのように、

HAVING句をなくすと、

部署ごとの最高給与とそのレコード数を出すので、

HRの方は1、salesは2と出していますね。</p>
WITH ROLLUP 修飾子</h3>
MySQLにおいては、

グループ化について、

WITH ROLLUPというものが使えます。</p>
https://dev.mysql.com/doc/refman/8.0/ja/group-by-modifiers.html</a></p>
WITH ROLLUPは、MySQLでGROUP BY句と共に使用されるオプションで、</strong>

集約されたデータに加えて、合計値を計算するために使用されます。</strong></p>
階層的な集約結果を簡単に取得でき、データの概要を把握しやすくなります。</p>
WITH ROLLUPを使用すると、GROUP BYで指定された列の各組み合わせに対する集約結果に加えて、

それらの組み合わせの全体の合計を得ることができます。</p>
SELECT</span> Department, </span>sum</span>(Salary) </span>AS</span> AverageSalary </span>FROM</span> Employees </span>group by</span> department </span>with rollup</span>;</span></span></code></pre>
</p>
画像のように、with rollupを付け加えることで、

AverageSalaryの合計値を出すことができますね。</p>


【SQL基礎】DISTINCTやORDER BYなどの検索結果の加工と関数
2024-01-24T00:00:00+00:00
本記事では、検索結果の加工として使われる、

DISTINCT、ORDER BYなどを始め、

LENGTHやCOALESCEなどの様々な関数について

紹介します。</p>
前回の記事はこちら</a>です。

ハンズオンで試したい方は、前回の記事</a>と前々回の記事</a>で

DockerのSQLの環境構築を紹介しているので、

そちらを御覧ください。</p>
また、Youtube動画の方もあるので、

文字より動画の方が良いという方は、

こちらもご参考ください。


  </iframe>
</div>

https://reisuta.com/data-type-operator/</p>
SELECTにおける検索結果の加工</h2>
早速、検索した結果を加工するための文法として、

DISTINCT、ORDER BY、OFFSET-FETCHについて

取り上げます。</p>
特に、前2つはよく使うので、

覚えておくと便利かと思います。</p>
DISTINCT</h3>
SQLのDISTINCTは、クエリ結果から重複する行を除外し、</mark>

ユニークな行のみを取得するために使用されます。</mark></p>
データベース内の重複を排除し、

特定のカラムに存在する異なる値のセットを取得する際に特に便利です。</p>
SELECT DISTINCT文を使用して、重複を除去します。

一つ以上のカラムを指定することができ、指定されたカラムの組み合わせがユニークな行のみが選択されます。</p>
SELECT DISTINCT</span> salary </span>FROM</span> employees;</span></span></code></pre>
上記のクエリは、employeesテーブルのsalaryカラムから

重複する給料を除外したユニークなリストを取得します。</p>
SELECT DISTINCT name</span>, salary </span>FROM</span> employees;</span></span></code></pre>
こっちのクエリでは、employeesテーブルからsalaryとnameの組み合わせで

ユニークな行のみを取得します。</p>
そのため、先程のsalaryだけだと、</strong>

重複するものも、nameとの組み合わせで重複していない場合は、</strong>

取得できます。</strong></p>
</p>
ORDER BY</h3>
次に、SQLのORDER BYです。

こちらは、クエリ結果を特定のカラムまたは複数のカラムに基づいて並べ替えるために使用されます。</mark>

これにより、データを特定の順序（昇順や降順）で表示することが可能になります。</p>
ORDER BY句は、SELECT文の最後に配置し、

デフォルトでは昇順(1, 2, 3...)（ASC）で並び替えられますが、

降順(3, 2, 1...)（DESC）で並び替えることもできます。</p>
複数のカラムに基づいて並び替えることも可能です。</p>
SELECT * FROM</span> employees </span>ORDER BY</span> salary;</span></span></code></pre>
このクエリは、employeesテーブルのレコードを給与（salary）の昇順で並び替えて表示します。

つまり、一番給与が低い人が先頭に表示されます。</p>
SELECT * FROM</span> employees </span>ORDER BY</span> hiredate </span>DESC</span>;</span></span></code></pre>
こちらのクエリでは、employeesテーブルのレコードを雇用日（hiredate）の降順で並び替えます。

つまり、一番最近に入社した人が先頭に表示されますね。</p>
</p>
SELECT * FROM</span> employees </span>ORDER BY name</span>, salary </span>DESC</span>;</span></span></code></pre>
上記のクエリでは、employeesテーブルのレコードをまずnameの昇順(デフォルト)で並び替え、

次に給与（salary）の降順で並び替えて表示します。</p>
複数の列で並べ替える際は、最初に指定した列で並べ替えてから、

同じ値がある際に次の列の値で並べ替えられます。</strong></mark></p>
</p>
ORDER BYを使わないSelectにおいても、

なんとなく昇順で並び替えられたものが出力されていたかもしれませんが、

ORDER BYを使わないSELECTにおけるデータの並び順は、

保証されず、実質ランダムです。</p>
そのため、必ずこの並び順にしてほしいという場面では、

ORDER BYは必須になるでしょう</p>
OFFSET - FETCH</h3>
お次は、OFFSETです。

少しマイナーですね。</p>
それに加えて、DBMS製品によっては、

使えないこともあるので、

上2つに比べると、重要度は下がるかと思います。</p>
OFFSET-FETCH句は、SQLクエリの結果から特定の範囲の行だけを取得するために使用されます。</strong>

これは、大量のデータがある場合にページネーション（データの分割表示）などを行う際に特に便利です。</p>
OFFSET句は、スキップする行数を指定します。

FETCH句は、取得する行数を指定します。

OFFSET - FETCH句単体でも、多くのDBMS製品で使用できますが、

この句は通常、ORDER BY句と組み合わせて使用されます。</p>
SELECT * FROM</span> employees </span>ORDER BY name</span> OFFSET </span>2</span> ROWS FETCH NEXT</span> 1</span> ROWS</span> ONLY;</span></span></code></pre>
こんな感じのクエリーです。</p>
ただ、このクエリーはmysqlではサポートされていないので、

mysqlでは、LIMITという別のものを使用する必要があります。</p>
SELECT * FROM</span> employees </span>ORDER BY name LIMIT</span> 1</span> OFFSET </span>2</span>;</span></span></code></pre>
もしかすると、こちらの方がメジャーかもしれませんね。</p>
関数</h2>
さてお次は、SQLにおける、

関数について紹介します。</p>
関数自体はプログラミング言語でおなじみの概念ですし、

SQLにおいても基本的な概念は変わりません。</p>
本記事では、こうした関数の中で

良く使われるものをいくつか紹介します。</p>
そもそも、関数とは何かというと、</p>
与えられたもの(引数)を、特定の処理を行うことで、

別の値(戻り値)に変換してくれるものを良います。</strong></p>
関数自体の詳細な解説は、

こちらの記事</a>のほうがわかりやすいかもしれません。</p>
[st-card myclass="st-no-shadow" id="34" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
MySQLにおける組み込みの関数は、

かなりの種類があって、

すべてを紹介するのは難しいので、

著名で良く使いそうなものをご紹介します。</p>
より細かい関数については、

下記のドキュメントを御覧ください</p>
https://dev.mysql.com/doc/refman/8.0/ja/built-in-function-reference.html</a></p>
LENGTH</h3>
まず最初がLENGTHです。</p>
LENGTH関数は、文字列の長さをバイト数で返す関数です。</strong>

この関数は、データベース内で文字列データの処理において役に立ちます。</p>
基本的なLENGTH関数の構文は以下の通りです。

LENGTH(文字列)</code></p>
テーブルに保存する文字列のバイトサイズを確認し、特定のサイズを超えるデータの取り扱いを決定する際に使用したり、

特定のフィールドに保存されるデータの長さを制限する必要がある場合、LENGTH関数を用いてデータ長をチェックしたりします。</p>
SELECT LENGTH</span>(</span>'hello'</span>);</span></span></code></pre>
このクエリは、'hello'という文字列のバイトサイズを返します。</p>
注意点としては、文字数ではなく、

バイト数を返すので、マルチバイト文字(漢字とか平仮名など)が含まれている場合は、

複数のバイトとしてカウントします。</p>
'hello'のような英語の場合は、

通常バイト数は、文字数と思ってもらっても問題ないかと思います。</p>
SUBSTRING</h3>
SUBSTRING関数は、文字列関数の一つであり、

文字列の特定の部分を抽出するために使用されます</strong>。</p>
この関数は、データのフォーマットや

データの部分的な表示において役に立ちます。</p>
基本的なSUBSTRING関数の構文は以下の通りです。

SUBSTRING(文字列, 開始位置, [長さ])</code></p>
長い文字列から特定の部分だけを表示する必要がある場合、SUBSTRING関数を使用してその部分を抽出できるので、

ログファイルや大量のテキストデータから特定の情報を抽出する際にも使用されます。</p>
SELECT</span> SUBSTRING</span>(</span>'Hello World'</span>, </span>1</span>, </span>5</span>);</span></span></code></pre>
このクエリは、'Hello World'の最初の5文字、つまり'Hello'を返します。</p>
</p>
SELECT</span> SUBSTRING</span>(</span>'MySQL Database'</span>, </span>6</span>);</span></span></code></pre>
このクエリは、6番目の文字から始まる文字列、つまり'Database'を返します。</p>
CONCAT</h3>
CONCAT関数は、複数の文字列を結合するために使用されます。</strong></p>
この関数は、データの表示やデータベース内の情報の組み合わせにおいて有用です</p>
CONCAT関数は、二つ以上の文字列を結合して一つの文字列を作成し、

基本的なCONCAT関数の構文は以下の通りです。

CONCAT(文字列1, 文字列2, …, 文字列N)</code></p>
データのフォーマット変更やレポートの作成などで

使えそうですね。</p>
データベース内の情報を組み合わせて、動的にクエリを生成する際にも使用されます。</p>
SELECT</span> CONCAT</span>(</span>'Hello'</span>, </span>' '</span>, </span>'World'</span>);</span></span></code></pre>
このクエリは、'Hello'と'World'を結合して'Hello World'を返します。</p>
SELECT</span> CONCAT</span>(</span>name</span>, </span>' '</span>,salary ) </span>AS profile FROM</span> employees;</span></span></code></pre>
このクエリは、従業員テーブルの名前と給与の列を結合して、

簡単なprofileを表示します。</p>
</p>
ROUND/TRUNC</h3>
お次は、小数の丸め処理系です。</p>
ROUND関数とTRUNC関数は、数値の丸め処理を行うために使用される関数です。

これらの関数は、データの整形や計算において重要な役割を果たします。</p>
ROUND関数は、指定された小数点以下の桁数に基づいて数値を丸めます。</strong>

基本的なROUND関数の構文は以下の通りです。

ROUND(数値, 小数点以下の桁数)</code></p>
一方で、TRUNC関数（またはTRUNCATE関数）は、指定された小数点以下の桁数で数値を切り捨てます。</strong>

基本的なTRUNC関数の構文は以下の通りです。

TRUNCATE(数値, 小数点以下の桁数)</code></p>
会計や財務報告において、数値を特定の小数点以下の桁数で丸めるときに、

ROUND関数は使用されることが多いです。

データ分析やレポート作成などで、数値データをより整った形で表示したいときは、

TRUNC関数を使用することが多いかと思います。</p>
SELECT</span> ROUND</span>(</span>123</span>.</span>4567</span>, </span>2</span>);</span></span></code></pre>
このクエリは123.4567を小数点以下2桁で丸め、123.46を返します。</p>
SELECT TRUNCATE</span>(</span>123</span>.</span>4567</span>, </span>2</span>);</span></span></code></pre>
このクエリは123.4567を小数点以下2桁で切り捨て、123.45を返します。</p>
POWER</h3>
POWER関数も、数学関数の一つで、

ある数値を指定されたべき乗に上げるために使用されます。</strong></p>
使い方としては、第一引数を第二引数で指定されたべき乗に上げます。

基本的なPOWER関数の構文は以下の通りです。

POWER(基数, べき指数)</code></p>
複雑な計算処理やデータ分析において、

べき乗の計算を行う際に使用されるかと思います。</p>
SELECT</span> POWER</span>(</span>2</span>, </span>3</span>);</span></span></code></pre>
このクエリは、2の3乗、つまり8を返します。</p>
CURRENT_DATE/CURRENT_TIME/CURRENT_TIMESTAMP</h3>
お次は日付系の関数です。</p>
CURRENT_DATE, CURRENT_TIME, CURRENT_TIMESTAMPは、</strong>

現在の日付や時刻を取得するために使用される関数です。</strong></p>
これらの関数は、データのタイムスタンプ記録、スケジューリング、

レポート作成において役に立つかと思います。</p>
CURRENT_DATE関数は、現在の日付をYYYY-MM-DDの形式で返します。

データの日付単位でのフィルタリング、レポーティング、および日付に基づく計算に使用されます。</p>
CURRENT_TIME関数は、現在の時刻をHH:MM:SSの形式で返します。

時刻に基づいてデータを処理する場合や、レポートでの時間記録などに使用するかと思います。</p>
CURRENT_TIMESTAMP関数は、現在の日時をYYYY-MM-DD HH:MM:SSの形式で返します。

データのタイムスタンプ記録、日時に基づくトリガーやイベントのスケジューリングなどに使用されます。</p>
SELECT</span> CURRENT_DATE();</span></span></code></pre>
このクエリは現在の日付を返します。</p>
SELECT</span> CURRENT_TIME</span>();</span></span></code></pre>
このクエリは現在の時刻を返します。</p>
SELECT</span> CURRENT_TIMESTAMP</span>();</span></span></code></pre>
このクエリは現在の日時を返します。</p>
CAST</h3>
CAST関数は、あるデータ型を別のデータ型に変換するために使用される関数です。</strong></p>
データベースでのデータ操作において非常に重要な役割を果たします。

この関数を使用することで、文字列を数値に、数値を日付に、等々、

さまざまな形式のデータ型変換が可能になります。</p>
基本的なCAST関数の構文は以下の通りです。

CAST(変換したい値 AS 変換後のデータ型)</code></p>
用途としては、データ型の不一致を解消したり、

特定のフォーマットでデータを表示したい場合に使用されます。</p>
異なるデータ型を持つ列を比較する際や、結合する際に、データ型の不一致が問題になることがあるので、

CAST関数を使用してデータ型を揃えることで、これらの問題を解決できます。</p>
それ以外だと、 文字列型の数値を数値型に変換してから計算を行う必要がある場合など、

CAST関数が有効です。</p>
SELECT</span> CAST</span>(</span>'2024-01-01'</span> AS</span> DATE</span>);</span></span></code></pre>
このクエリは文字列 '2024-01-01' を日付型に変換します。</p>
</p>
COALESCE</h3>
COALESCE関数は、SQLで使用される関数の一つで、

引数リストの中から最初の非NULL値を返します。</strong></p>
この関数はNULL値を扱う際の便利なツールです。

すべての引数がNULLの場合、結果もNULLとなります。</strong></p>
これは、ややマイナーな気もしますが、

知っておくと結構便利な関数かと思います。</p>
基本的なCOALESCE関数の構文は以下の通りです。

COALESCE(値1, 値2, …, 値N)</code></p>
主にNULL値を扱う際に使用され、NULL値をデフォルト値や代替値に置き換えるのに役立ちます。</strong>

テーブルの列にNULL値が含まれている場合、COALESCE関数を使用して特定のデフォルト値を設定できます。</p>
計算や集計を行う際にNULL値を特定の数値に置き換える必要がある場合に便利です。</p>
SELECT</span> COALESCE</span>(</span>NULL</span>, </span>NULL</span>, </span>3</span>, </span>NULL</span>, </span>5</span>);</span></span></code></pre>
このクエリは3を返します（最初の非NULL値）</p>
SELECT</span> COALESCE</span>(bonus, performance, </span>'no-bonus'</span>) </span>FROM</span> employees; </span></span></code></pre>
bonus列がNULLの場合、performance列の値が使用されます。両列ともNULLの場合、'no-bonus'が表示されます。</p>
</p>
SELECT</span> SUM</span>(</span>COALESCE</span>(bonus, </span>0</span>)) </span>FROM</span> employees; </span></span></code></pre>
このクエリでは、bonus列がNULLの場合、0が使用され、bonusの合計が計算されます。</p>
</p>
SUM/MAX/MIN/AVG</h3>
お次は、集約関数系統です。</p>
SUM, MAX, MIN, AVGといった集約関数は、</strong>

データ分析やレポート作成において広く使用されます。</strong></p>
SUM関数は、指定された列の数値の合計を計算します。</strong>

合計売上、合計コスト、総ポイント数など、数値データの合計が必要な場合に使用されます。</p>
MAX関数は、指定された列の最大値を返します。</strong>

最高売上、最大温度、最高スコアなど、データセット内の最大値を見つける場合に使用されます。</p>
MIN関数は、指定された列の最小値を返します。</strong>

最低売上、最小温度、最低スコアなど、データセット内の最小値を見つける場合に使用されます。</p>
AVG関数は、指定された列の平均値を計算します。</strong>

平均売上、平均温度、平均評価など、数値データの平均が必要な場合に使用されます。</p>
SELECT</span> SUM</span>(bonus) </span>FROM</span> employees;</span></span></code></pre>
このクエリは、employeesテーブルのbonusの合計を計算します。</p>
SELECT</span> MAX</span>(bonus) </span>FROM</span> employees;</span></span></code></pre>
このクエリは、bonusの最高額を返します。</p>
SELECT</span> MIN</span>(bonus) </span>FROM</span> employees;</span></span></code></pre>
このクエリは、bonusの最低額を返します。</p>
SELECT</span> AVG</span>(bonus) </span>FROM</span> employees;</span></span></code></pre>
このクエリは、bonusの平均を計算します。

nullの値がある場合は、それを無視して計算するので、

160 / 3 = 53.33333333を返します。</p>
nullにデフォルト値を入れたい場合は、

先述した、COALESCEを使うのが良いでしょう。</p>
</p>
COUNT</h3>
COUNT関数も、集約関数の一つであり、

テーブル内の行数または特定の条件に一致する行数をカウントするために使用されます。</strong></p>
基本的なCOUNT関数の構文は以下の通りです。

COUNT(列名または*)</code></p>
SELECT</span> COUNT</span>(</span>*</span>) </span>FROM</span> employees;</span></span></code></pre>
このクエリはemployeesテーブルの全行数をカウントします。</p>
SELECT</span> COUNT</span>(</span>*</span>) </span>FROM</span> テーブル名 </span>WHERE</span> 条件;</span></span></code></pre>
特定の条件に一致する行数をカウントしたい場合は、

上記のようなクエリーにします。</p>


【SQLデータ型】Where句と条件式における演算子
2024-01-18T00:00:00+00:00
本記事では、

SQLにおけるデータ型とWhere句、

条件式、様々な演算子について解説します。</p>
SQLのdockerにおける環境構築、

4大命令の簡単な解説については、

前回のこちらの記事</a>や動画を御覧ください。</p>


  </iframe>
</div>
データ型</h2>
SQLにおけるデータ型は、データベース内の各列（カラム）に格納されるデータの種類を定義します。

このデータ型によって、例えば数値を管理するデータに

文字列などが混入することを防いで、データの安全性を保つことに寄与しています。</p>
データ型には、数値、文字列、日付などがあります。</p>
プログラミング言語の経験がある人は、

データ型と言われたら、ピンと来るかと思います。

基本的には、それらと似たような感じです。</p>
ただ、SQLは、他のプログラミング言語に比べても、

割とデータ型が細かい印象があります。</p>
TypeScriptとかに慣れていると、

データ型の多さに圧倒されるかもしれません。</p>
それに比べて、

各DBMS製品によっても、

微妙にデータ型が違ったりするので、

正直全部をご紹介するのは無理です笑</p>
それに、実際によく使うデータ型は、

割とパターンが決まっているので、

それらを押さえれば、意外と十分だったりします。</p>
どういうデータ型があるのか、

一覧で知りたいという場合は、

その都度、そのDBMS製品のドキュメントを確認する形で

問題ないと思います。</p>
本記事ではMySQLのデータ型を取り上げます。

細かいところは、他のDBMS製品と違ったりするかもしれませんが、

大枠は同じかと思います。</p>
https://dev.mysql.com/doc/refman/8.0/ja/data-types.html</a></p>
数値データ型</h3>
数値データの場合、大きく分けて、

整数型と小数点型があります。</p>
</p>
画像出典: MySQLの公式ドキュメント</em></p>
整数型だと、</p>

</blockquote>
INT：標準の整数型。</p>
SMALLINT：より小さな範囲の整数。</p>
TINYINT：非常に小さな整数。</p>
MEDIUMINT：中程度の範囲の整数。</p>
BIGINT：非常に大きな範囲の整数。</p>
などがあります。</p>
これらの型は、符号付き（負の値を含む）または符号なし（正の値のみ）で使用できます。

これに対して、浮動小数点型だと、</p>

</blockquote>
FLOAT：単精度浮動小数点数。

DOUBLE：倍精度浮動小数点数。</p>
などがあり、固定小数点型だと</p>

</blockquote>
DECIMAL：固定小数点数</p>
などがあります。</p>
固定小数点と浮動小数点の大まかな違いとしては、

その精度にあります。</strong></p>
金融データなど、固定の小数点精度が必要な場合は DECIMAL 型を使用します。

一方で、科学計算などのより広い範囲の数値で精度がそれほど重要でない場合は FLOAT または DOUBLEなど

が良かったりします。</p>
ただ、実際のところ、

この中でもよく使うのは、

INTやBIGINTが圧倒的に多く、

それ以外のデータ型も使わないわけではありませんが、

上記2つに比べると、遭遇シーンは下がると思うので、

基礎というレベルでは、そこまで全てを覚える必要性はあまりないかもしれません。</p>
文字列データ型</h3>
次に文字列データ型について紹介します。

有名どころとしては、</p>

</blockquote>
CHAR (固定長の文字列。CHAR(5)は、5文字の文字列を格納します。)

VARCHAR (可変長の文字列。VARCHAR(255)は、最大255文字の文字列を格納できます。)

TEXT型 (長い文字列用。TINYTEXT、MEDIUMTEXT、LONGTEXT：さまざまなサイズの非常に長い文字列用。)</p>
などがあります。

一応これ以外にも、BLOB型とかBINARY型とかありますが、

基礎のレベルじゃなくなるので割愛します。</p>
上記の3つの型については、

遭遇シーンが多いと思うので、

まずはこれらをおさえるだけでも十分だと思います。</p>
さて、固定長と可変長というキーワードがありますが、

これらの違いは何かというと、

データ型の領域を中身のサイズに合わせて調整するか、</mark>

しないかという感じです。</mark></p>
はい、これじゃ意味わからないですよね。

具体例として、

CHAR(10)とVARCHAR(10)があるとします。</p>
これはそれぞれ、10文字までのデータ型を格納することができます。</p>
違いは、例えば「test」などのように、

10文字に満たない文字を格納した場合です。</p>
固定長のCHARの場合は、

あらかじめ10文字文の領域を確保しているため、</mark>

「test」というデータが来たら、</mark>

10文字に満たない部分は、空白が追加されます。</mark>

すなわち、「test 」みたいなデータが入るイメージです。</mark></p>
これに対して、可変長のVARCHARの場合は、

データである「test」というサイズに合わせて、

データを格納するので、

「test」と空白は追加されず、そのままの長さで格納します。</mark></p>
これが固定長と可変長の違いです。</p>
まあでも、一般的には、

ここまで厳密な違いを考慮しているかというと微妙で、

小さい文字列データ型なら、CHAR、

普通ぐらいなら、VARCHAR、

長いテキストデータなら、TEXTという感じで、

分けていることが多い気がします。</p>
日時データ型</h3>
次に日時データ型です。

主なものとしては、</p>

</blockquote>
DATE：日付のみを格納（例: 2024-01-15）。

TIME：時間のみを格納。

DATETIME：日付と時刻を格納。

TIMESTAMP：UNIXタイムスタンプを格納。

YEAR：年を格納。</p>
などという感じです。</p>
正直、日時データ型だけで、

こんなにいろいろ種類があるのは、

あまりない気がします。</p>
これだけ色々あると、

もはや基礎と呼べるか怪しいですが、

日時データ型自体はよく出てくるので、

軽くご紹介しました。</p>
ここに関しては、

突き詰めると細かすぎるので、

詳細は、下記のドキュメントに譲ります。</p>
https://dev.mysql.com/doc/refman/8.0/ja/date-and-time-types.html</a></p>
データ型の選択について</h3>
適切なデータ型を選択することは、ストレージの効率、パフォーマンスの最適化、

およびデータの正確性を保証するために重要です。</p>
例えば、不必要に大きなデータ型を選択すると、

ストレージ領域の無駄遣いやパフォーマンスの低下を引き起こす可能性があります。</p>
一方で、データに合わない小さなデータ型を選択すると、データの切り捨てや精度の損失が発生する恐れがあります。

したがって、データの特性を理解し、それに応じて最も適切なデータ型を選択することが不可欠です。</p>
ストレージ効率として、 適切なデータ型を選択することで、データベースのストレージ使用量を最適化できます。

例えば、小さな整数を格納するために INT を使用するよりも TINYINT を使用する方が効率的です。</p>
先述しましたが、小数とかの場合は必要な精度を考慮することが重要で、

金融データなど正確な小数点以下の値が必要な場合、DECIMAL型の使用が良いのかと思います。</p>
Where句</h2>
Where句は、SQLクエリで特定の条件に一致する行を選択するために使用されます。

Whereを指定しないと、すべての行が対象になるので、

DELETEやUPDATEとかでは、ほぼ必須みたいなものになるかと思います。</strong></p>
データベースから特定のデータを抽出する際にWhere句は不可欠で、

条件に一致するデータのみを取得することで、効率的なデータ管理が可能になります。</p>
4大命令において、INSERTの場合は、

新規追加になるため、「どの行」を指定する必要がないので、

Where句は使用することができません。</p>
肝心のWhereの使い方としては、

後ろに条件式を記述し、絞り込みを行います。</p>
条件式</h3>
条件式は、主にWhere句内で使用され、特定の条件を指定するために用いられる式です。

文法は、Where 条件式</strong>という感じです。

条件式は、結果が真か偽になるものなので、

他のプログラミング言語における、booleanと思っていただければ、

問題ないかと思います。</p>
たとえば、hiredate > '2023-01-01'なら、問題ない一方、

hiredate + '2023-01-01'みたいなものは記述できません。</p>
他のプログラミング言語だと、

後者の場合でもboolean変換できますが、

SQLの場合、あくまで「どの行」を指定するための、

Where句なので、こういう変化球は使えないという感じですかね。</p>
SELECT * FROM</span> employees </span>WHERE</span> hiredate </span>></span> '2023-01-01'</span>;</span></span></code></pre>
このクエリは、2023年1月1日以降に雇用された従業員のデータを選択します。</p>
演算子</h3>
上記のクエリーで出てきた、

Where句内の、>のように、

条件式で使う演算子には様々なものがあります。</p>
比較演算子</h4>
まず>のような演算子は、

比較演算子といい、

下記のようなものがあります。</p>

</blockquote>
= (等しい)

< (左辺は右辺より小さい)</p>

(左辺は右辺より大きい)

<= (左辺は右辺の値以下)

= (左辺は右辺の値以上)

<> または != (左右の値が等しくない)</p>
</blockquote>
上5つは直感的だと思いますが、

<>や!=は見慣れないかもしれません。</p>
これらは等しくないことを表します。</p>
また、NULLのデータに対して、

=などの比較演算子では判断できないというのもあり、

NULLのデータを探したいときは、

IS NULLやIS NOT NULL演算子を使います</strong></mark></p>
さて、これらの=などの比較演算子以外のものとしては、

下記のようなものがあります。</p>

</blockquote>
LIKE (パターンマッチング、部分一致)

BETWEEN (範囲指定)

IN</p>
LIKE演算子</h4>
LIKE演算子の場合、

パターン文字というものを使うことができます。

これは、プログラミング言語でいう、

正規表現とかワイルドカードみたいなイメージです。</p>
%と_の2つがあり、

%は、任意の0文字以上の文字列を表し、

_は任意の一文字を表します。</strong></mark></p>
SELECT * FROM</span> employees </span>WHERE name LIKE</span> '%yamada%'</span>;</span></span></code></pre>
このクエリでは、パターン文字として、%を使っているので、

yamadaの前後に0文字以上の文字列があるものをSelectするという感じになります。

すなわち、名前に「yamada」という文字が含まれる従業員を選択します。</p>
ちなみに、yamada100%みたいな、

%自体が含まれる行を抽出したい場合は、

そのまま、LIKE '%yamada100%'みたいにすると、

最後の%がパターン文字として認識されてしまうので、

エスケープという作業をして上げる必要があります。</p>
SELECT * FROM</span> employees </span>WHERE name LIKE</span> '%yamada100$%'</span> ESCAPE </span>'$'</span>;</span></span></code></pre>
ここで出てきたESCAPE句というもので、指定した$という文字のあとは、

ただの文字として扱うことができるので、

上記のクエリーで元気100%の行を抽出することができます。</strong></p>
BETWEEN演算子</h4>
次にBETWEEN演算子についてです。

BETWEEN演算子は、間という意味の通り、

範囲指定したい際に使用します。</p>
文法的には、

BETWEEN 値1 AND 値2という感じで記述し、

値1以上かつ値2以下のとき、真となります。</strong></p>
SELECT * FROM</span> employees </span>WHERE</span> hiredate </span>BETWEEN</span> '2023-01-01'</span> AND</span> '2023-12-31'</span>;</span></span></code></pre>
このクエリは、2023年1月1日から2023年12月31日までの間に雇用された従業員を選択します。</p>
IN / NOT IN演算子</h4>
IN演算子は、指定されたリスト内にあるいずれかの値に一致する行を選択するために使用されます。

これは、複数の候補値の中から一致するものを見つける際に非常に便利です。</p>
SELECT * FROM</span> employees </span>WHERE</span> ID </span>IN</span> (</span>3</span>, </span>5</span>, </span>7</span>);</span></span></code></pre>
このクエリは、ID が3、5、7のいずれかである従業員を選択します。</p>
これに対して、NOT INは逆で、

指定されたリストに含まれないすべての行を選択するために使用されます。

これは、特定の値を除外したい場合に有用です。</p>
SELECT * FROM</span> employees </span>WHERE</span> ID </span>NOT IN</span> (</span>3</span>, </span>5</span>, </span>7</span>);</span></span></code></pre>
このクエリは、ID が3、5、7以外の従業員を選択します。</p>
論理演算子</h4>
Where句の条件式において、

複数の条件式を書きたい場合、

ANDやORのような論理演算子を使用することで

実現することができます。</p>
ANDは2つの条件式の両方が真のとき、真になり、

ORは2つの条件式のどちらかが真なら、真となります。</strong></p>
SELECT * FROM</span> employees </span>WHERE</span> hiredate </span>>=</span> '2023-01-01'</span> AND name LIKE</span> '%yamada%'</span>;</span></span></code></pre>
このクエリは、2023年1月1日以降に雇用され、名前に「山田」を含む従業員を選択します。</p>
また、NOT演算子というものもあり、

これを使うと、真偽値を反転させることができます。</p>
SELECT * FROM</span> employees </span>WHERE NOT</span> (salary </span>></span> 50000</span>);</span></span></code></pre>
このクエリは、給与が50,000より大きくない（つまり50,000以下の）従業員を選択します。</p>
集合演算子</h4>
SQLの集合演算子は、複数のクエリ結果セットを組み合わせたり、比較したりする際に使用されます。

主な集合演算子にはUNION、EXCEPT（またはMINUS）、INTERSECTがあります。</p>
UNIONの場合、</p>
SELECT</span> employee_id </span>FROM</span> sales_department</span></span>
UNION</span></span>
SELECT</span> employee_id </span>FROM</span> marketing_department;</span></span></code></pre>
のように使うことができます。</p>
UNION演算子は、二つのクエリ結果セットの全ての行を結合します。重複する行は一つにまとめられます。

平たく言うと、和集合になります。</strong>

このクエリは、販売部門とマーケティング部門の両方から従業員IDを取得し、重複する従業員IDは排除して結果を表示します。</p>
ただ、結合するクエリのカラム数とデータ型が一致していないと行けないので、

正直集合演算子を使う場面は限定的になるかと思います。</p>
上記のサンプルコードのように、

2つのテーブル構造がある程度似ていて、

抽出する際は、揃える必要があるので、

例えば、ほぼ同じデータ構造のテーブルが複数ある際の、

総合的な分析とかで使うのが一番使うシーンなのかなと思います。</p>
このUNIONに対して、

EXCEPTは差集合、INTERSECTは積集合という位置づけになります。</p>
集合の種類が変わるだけで、

文法的にはほぼ同様です。</p>
差集合の場合、最初のクエリの結果セットから、

二番目のクエリの結果セットに含まれる行を除外します</p>
積集合は、和集合と同じく、

SELECT文の順番はあまり関係なく、

共通行を取得してくれます。</p>
case演算子</h4>
SQLのCASE演算子は、条件に基づいて異なる値を返すために使用されます。

これは、条件分岐の機能をクエリに組み込む際に非常に便利です。</p>
まあ他のプログラミング言語における、

CASEと似ているといえば似てますかね。</p>
CASE文は、特定の条件に基づいて異なる結果を返す際に使用され、</mark>

WHEN-THEN句を使用して、特定の条件を指定し、それに対応する結果を定義します。</mark></p>
ELSE句を使用して、どのWHEN条件にも一致しない場合のデフォルト値を指定できます。

CASE文はSELECT、UPDATE、ORDER BYなどのさまざまな場所で使用できます。</p>
SELECT</span> id, </span>name</span></span>
       CASE</span> </span></span>
           WHEN</span> salary </span>></span> 50000</span> THEN</span> 'High salary'</span></span>
           WHEN</span> salary </span>></span> 30000</span> THEN</span> 'Medium salary'</span></span>
           ELSE</span> 'Low salary'</span></span>
       END as</span> SalaryCategory</span></span>
FROM</span> employees;</span></span></code></pre>
このクエリは、employeesテーブルの従業員ごとに給与カテゴリを判断し、それに応じたラベルを付けて表示します。</p>
UPDATEとかでの使用例としては、</p>
UPDATE</span> employees</span></span>
SET</span> bonus </span>= CASE</span> </span></span>
               WHEN</span> performance </span>=</span> 'Excellent'</span> THEN</span> 1000</span></span>
               WHEN</span> performance </span>=</span> 'Good'</span> THEN</span> 500</span></span>
               ELSE</span> 0</span></span>
            END</span>;</span></span></code></pre>
このクエリは、employeesテーブルの従業員のパフォーマンスに基づいてボーナス額を更新します。</p>
余談ですが、CASE演算子は、

実際のところ、たまに使用する程度ですが、

面接の技術テストとかで聞かれやすいトピックな気がしています。</p>
私はCASE演算子について即答できなかったので、

落とされるということを何度か経験しました(苦笑い)</p>
初期構築用SQLファイル</h2>
本記事と同じような状態で、

試す場合は、下記のsqlファイルを使うと

スムーズかと思います。</p>
CREATE DATABASE</span> testdb</span>;</span></span>
use</span> testdb;</span></span>
</span>
create table</span> employees</span> (id </span>INT</span> AUTO_INCREMENT </span>PRIMARY KEY</span>, </span>name</span> varchar</span>(</span>25</span>), salary </span>int</span>, bonus </span>int</span>, department </span>varchar</span>(</span>25</span>), performance </span>char</span>(</span>25</span>), hiredate </span>date</span>);</span></span>
</span>
insert into</span> employees (</span>name</span>, hiredate, salary, bonus, department, performance) </span>values</span> (</span>'yamada'</span>, </span>'2023-09-12'</span>, </span>'60000'</span>, </span>'30'</span>, </span>'sales'</span>, </span>'Good'</span>);</span></span>
insert into</span> employees (</span>name</span>, hiredate, salary, bonus, department, performance) </span>values</span> (</span>'satou'</span>, </span>'2023-04-12'</span>, </span>'30000'</span>, </span>'100'</span>, </span>'sales'</span>, </span>'Good'</span>);</span></span>
insert into</span> employees (</span>name</span>, hiredate, salary, bonus, department, performance) </span>values</span> (</span>'yamada100%'</span>, </span>'2024-09-12'</span>, </span>'60000'</span>, </span>'30'</span>, </span>'HR'</span>, </span>'Excellent'</span>);</span></span></code></pre>
このファイルを作成したら、

コンテナ立ち上げ時に、

docker cpをします。</p>
docker cp test.sql mysql-sample:/</span></span></code></pre>
これで、mysql-sampleコンテナの

ルートパスにファイルがコピーされました。</p>
あとは、docker exec -it mysql-sample /bin/bash</code>で

コンテナに入って、</p>
mysql -u root -p < test.sql</span></span></code></pre>
でファイルを実行することができます。</p>


  
  
    スッキリわかるSQL入門 第3版 ドリル256問付き! (スッキリわかる入門シリーズ)</p>
    

      Amazonで見る</a>
      楽天市場で見る</a>
    </div>
  </div>
</div>


  
  
    
  </div>
  
  
    失敗から学ぶRDBの正しい歩き方 Software Design plus</p>
    
      Amazonで見る</a>
      楽天市場で見る</a>
    </div>
  </div>
</div>


  
  
    
  </div>
  
  
    達人に学ぶDB設計 徹底指南書</p>
    
      Amazonで見る</a>
      楽天市場で見る</a>
    </div>
  </div>
</div>


  
  
    SQLアンチパターン</p>
    
      Amazonで見る</a>
      楽天市場で見る</a>
    </div>
  </div>
</div>


【Docker DBコンテナ構築】データベースの種類やSQLの概要解説
2024-01-11T00:00:00+00:00
データベース(DB)とは?</h2>
あまりに身近すぎて、

今更感がすごいですが、

改めてデータベースとは何でしょうか？</p>
データベースは、様々なデータを整理して格納するためのシステムですね。</mark>

割とそのまんまですね</p>
非エンジニアで、データベースが良くわからないという人でも、

よくドラマとかで、

「データベースから顧客情報から流出したぞ！」とか、

「A企業のデータベースを見れば極秘情報がわかるかも」みたいな、

ハッキングとかサスペンスとかがたまに出てくるので、

イメージ自体はわきやすいと思います。</p>
ただ、データを保存するだけなら、

別にメモ帳とかエクセルとかでも良いのではないか？

みたいな疑問ももしかしたら生じるかもしれません。</p>
もちろん、データの種類によっては、

エクセルとかで保存するケースもあると思いますし、

実際は、併用しているところも多い気がします。</p>
データベースの特徴として、

これから解説しますが、

SQLというデータベースを操作する言語が使えるということがあります。</strong></p>
このSQLを使うと、

大量のデータの検索や更新、削除などを容易に行うことができます。</p>
エクセルとかで大量のデータを扱う場合、

どうしても検索性や更新性が下がることがほとんどで、

特にデータを書き換えたりする必要がある場合、

エクセルだとかなり煩雑になるかもしれません。</p>
データベースの場合、データを書き換えるには、

Updateというsqlを使う必要があるため、

エクセルのように気軽に編集出来るわけではありません。

(エクセルであるある(?)な、あれ間違って編集しちまったよ現象は、

防げますね)</p>
そのため、データの堅牢性に貢献してくれます。</p>
また、データベースは、

プログラムからもアクセスしやすく、

バックエンド言語などを介して、

データベースを更新したりすることが多いと思います。</p>
これにより、大量のデータを効率的に管理し、必要に応じて迅速にアクセスできます。

データベースは、企業や組織が顧客情報、商品データ、取引記録などを保存するのに広く使用されています。</p>
あと、これは完全に推測ですが、

エクセルというアプリケーション自体、

内部的にはデータベースを使っているはずで、

エクセルのデータをエクセルを作っている開発元のDBに

データが格納されているという構造になっているかと思います。</p>
少なくともメモ帳とかに関しては、

データはDBに保存されているはずです。</p>
なので、DBとは、こうした身近に使っているアプリケーションの、

保存先と思っていただければ大丈夫です。</p>
データベースの種類</h3>
データベースには様々な種類があります。

主なものには、リレーショナルデータベース（RDBMS）、非リレーショナルデータベース（NoSQL）、

オブジェクト指向データベースなどがあります。</p>
この中でも著名なのが、リレーショナルデータベースで、</mark>

リレーショナルデータベースは、表形式でデータを整理し、</mark>

SQL（Structured Query Language）を使用してデータを操作します。</mark></p>
非リレーショナルデータベースは、柔軟なデータ構造を持ち、

ビッグデータやリアルタイム処理など、パフォーマンスが求められる要件に適していると思います。</p>
非リレーショナルデータベースについては、

これらの一種である、Redisの概要記事</a>で少し触れているので、

よろしければご参考ください</p>
[st-card myclass="st-no-shadow" id="1019" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
RDBMSの種類</h3>
さて、これらのデータベースの種類においても、

最も一般的なものとして、リレーショナルデータベースがあることは、

先述のとおりです。</p>
このリレーショナルデータベースにも色々種類があり、

有名どころを紹介します。</p>
MySQL</h4>
データベースといったら、これって言われるぐらい、

おそらく最も有名なRDBMSかと思います。</strong></p>
PHP環境下で使われることが多い印象がありますが、

普通にRailsとかでも使われるますし、

本当に幅広く使われている著名なデータベースです。</p>
MySQLは、その柔軟性、信頼性、効率性により、中小規模のアプリケーションに適しています。</p>
PostgreSQL</h4>
お次は、PostgreSQLで、

ポスグレ、ポストグレなどと呼ぶことが多い気がします。</p>
これは、私の印象ではRails環境で使うことが多いDBで、

MySQLと同じぐらい広く使われている、

こちらも著名なDBの一つです。</p>
高度な機能（ストアドプロシージャ、トリガー、ビューなど）を備えています。

大規模なデータベースシステムや複雑なクエリに適しており、

企業レベルのアプリケーションで広く採用されています。</p>
Oracle Database</h4>
これも有名ではありますが、

私は使ったことはありません。</p>
Oracle Databaseは、企業向けの高機能RDBMSです。

大規模なトランザクション処理、データウェアハウジング、高度なアナリティクス機能を提供します。

ライセンス費用がかかるため、主に大企業や金融機関で使用されます。</p>
Oracle DatabaseとMySQLとかとの最大の違いは、

こちらは商用製品だということです。</strong></p>
MySQLやPostgreSQLはOSSでしたが、

こちらは異なります。</p>
どちらも双方メリデメがあるので、

なんとも言えませんが、

最近の風潮としては、

OSSのDBのクオリティも十分高いことから、

MySQLやPostgreSQLの方が人気が高まっているような印象はあります。</p>
Microsoft SQL Server</h4>
こちらもOracleと同じく、

商用製品のDBです。</p>
Microsoft SQL Serverは、主にWindows環境で使用されるRDBMSです。

統合された環境、分析ツール、ビジネスインテリジェンス機能が特徴で、

中規模から大規模の企業向けのアプリケーションに適しています。</p>
SQLite</h4>
こちらはOSSです。</p>
SQLiteは、軽量で独立したデータベースエンジンです。

外部のサーバーを必要とせず、アプリケーションに組み込むことができます。

モバイルアプリケーションや組み込みシステムでの使用に適しています。</p>
RailsのデフォルトのDBでもあります。</p>
ただ、Rails環境で、

このDBをそのまま使用して本番環境を構築しているケースは、

私はまだ見たことがありません。</p>
MariaDB</h4>
MariaDBは、MySQLから派生したオープンソースのRDBMSです。

MySQLと互換性がありながら、より多くのストレージエンジンや新機能を提供します。

コミュニティ主導の開発が特徴で、透明性とイノベーションを重視しています。</p>
SQLとは?4大命令</h2>
さて、データベースの概要については、

触れたのでお次は、そんなデータベースの重要概念である、

SQLについて軽く触れます。</p>
これも現役エンジニアの方からすると、

常識すぎますが、SQL（Structured Query Language）は、

データベースでデータを操作するための標準的な言語です。</mark></p>
SQLを使用することで、データの検索、追加、更新、削除などが可能になります。

SQLはリレーショナルデータベース管理システムで広く使用されており、データベースの操作には不可欠なツールです。</p>
エンジニアの場合、

トレンドによっていろんな言語の文法を覚えたりみたいな、

学習コストがありますが、

SQLは、基本的にあまり文法が変わらず、

かといってDBは基本的にまだまだ使うことが多いソフトウェアなので、

一度身につけてしまうとずっと役に立つかなり学習のコスパがいいものでも有名です。</p>
よくベテランエンジニアの方が、

なにか一つだけ勉強するとしたらSQLをやるということもあるように、

一度身につけてしまえば、ずっと役に立ち、

フロントエンドのように陳腐化する可能性が小さいというのは大きな魅力ですよね。</p>
下記にて、SQLの基本文法を少しだけ紹介します。</p>
最後の章で、

dockerでのdbの環境構築手順について触れているので、</strong>

実際に手元で動かして確認したい方は、</strong>

そちらをやってからこちらに戻っていただけるとよいかと思います。</strong></p>
読むだけで十分な方は、

このまま進めてもらって大丈夫です。</p>
Select文</h3>
まず最初は、Select文です。</p>
SQLといったらSelectでしょって思い浮かべる方も多い、

おそらくいちばんメジャーなSQLの文法です。</p>
SELECT * FROM users;</span></span></code></pre>
このような文法です。</p>
これはusersテーブルの全ての列を取得します。</p>
取得する列を絞ることもできます。</p>
select name from users;</span></span></code></pre>
ちなみに、上記のように、

SELECTと大文字で書いても、</mark>

selectと書いてもどちらでも大丈夫です。</mark></p>
プロジェクトのルールなどに従うのが

いいでしょう。</p>
selectは、他の4大命令と違って、

db自体の内容を書き換えないため、

比較的安全な操作に該当するため、

使用シーンも多い印象です。</p>
データベースのデータを確認したいときに

使う構文ですね。</p>
文法的には、

select 列名 from テーブル名という感じになります。</strong></p>
update文</h3>
お次は、update文でして、

これはその名の通り、

データの更新を担当するsqlです。</p>
UPDATE users  SET name = 'tarou'  WHERE name = 'Alice';</span></span></code></pre>
これは、name列がAliceの行に対して、

name列をtarouに更新するという命令です。</p>
update文の基本文法としては、</p>
update テーブル名 set 列名1 = 値1, 列名2 = 値2 .... (where句)

という感じで、set句で更新する値を記載するという感じです。</p>
サンプルコードだと、whereという命令がありますが、

これは、テーブルのどの行かを特定するための

命令です。</p>
上記の場合、name列がAliceと指定しています。

where句自体は、select文など他の4大構文でも使います。</strong></p>
ちなみに、where句を省略すると、

全行をupdateかけることになってしまいます。</p>
善行にupdateをかけることは、

かなり少ないと思うので、

基本的にはwhere句は実質必須みたいなものに、

なるかもしれません。</p>
delete文</h3>
これは文字通り、削除の命令ですね。

これは、その性質上、かなり慎重に行わないと

大変なことになるやつなので、

そこまで使用シーンは多くないかもしれません。</p>
DELETE FROM users </span></span>
WHERE name = 'test';</span></span></code></pre>
これは、testという名前のデータを削除します。</p>
ちなみに、deleteにおいて

where句を指定しなかった場合、

全データを削除してしまうため、

基本的にはあまり使わないかと思います。</p>
insert文</h3>
次は、データの新規作成にあたる命令です。</p>
INSERT INTO users (name, email) VALUES ('Alice', 'alice@test.com');</span></span></code></pre>
これは、usersテーブルに、

nameがAlice、emailがalice@test.comので

データを作成してという命令ですね。</p>
INTOの後にテーブル名を指定して、

その後は、カッコで括って、

データを挿入する列を指定し、

最後は、values句似て、

その列に対応して、

挿入したいデータを指定するという文法です。</p>
dockerでdbコンテナを環境構築する</h2>
sqlを試すに際し、

dbの環境構築をする必要がありますが、

実際にローカル環境に構築するのは、

何かと煩雑なため、dockerのmysql</a>コンテナを使用して、

sqlを試してみます。</p>
dockerについて不安がある方は、

下記の記事や動画などをご参考ください。</p>
[st-card myclass="st-no-shadow" id="1208" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>


  </iframe>
</div>
MySQLコンテナの作成</h3>
MySQLのDockerイメージを使用してコンテナを作成します。ターミナルで以下のコマンドを実行します。</p>
docker run --name mysql-sample -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:latest</span></span></code></pre>
このコマンドは、最新のMySQLイメージを使用してmysql-sampleという名前のコンテナを作成し、

my-secret-pwをrootユーザーのパスワードとして設定します。</p>
コンテナが起動したら、MySQLコマンドラインツールを使用してデータベースに接続します。

コンテナに以下のコマンドを実行します。</p>
docker exec -it mysql-sample mysql -uroot -p</span></span></code></pre>
パスワードプロンプトが表示されたら、

ステップ2で設定したパスワード（この例ではmy-secret-pw）を入力します。</p>
データベースとテーブルの作成</h3>
次に、テスト用のデータベースとテーブルを作成します。

MySQLプロンプトで以下のコマンドを実行します。</p>
CREATE DATABASE testdb;</span></span>
USE testdb;</span></span>
CREATE TABLE users (id INT AUTO_INCREMENT PRIMARY KEY, name VARCHAR(255), email VARCHAR(255));</span></span></code></pre>
これでtestdbという名前のデータベースと、

usersというテーブルを作成しました。</p>
サンプルデータをテーブルに挿入します。</p>
INSERT INTO users (name, email) VALUES ('Alice', 'alice@example.com'), ('Bob', 'bob@example.com');</span></span></code></pre>
最後に、SELECT文を使用してデータを取得します。</p>
SELECT * FROM users;</span></span></code></pre>
このコマンドは、usersテーブルの全てのデータを取得します。</p>
</p>


【2024年最新版】2023年に読んだ技術書おすすめ18冊
2023-12-27T00:00:00+00:00
本記事では、私が今年(2023年)に読んだ技術書の中で、

これは良かったなっていうやつを紹介します。</p>
技術書は、星の数ほどあるので、

良いものを選ぶのは大変ですが、

良いものを見つけられれば、

それだけ学べることも多いので、

技術書のおすすめを知りたい方はぜひともご参考ください。</p>
プログラミング系</h2>
マスタリングLinuxシェルスクリプト</h3>


  
  
    
  </div>
  
  
    マスタリングLinuxシェルスクリプト 第2版 Linuxコマンド、bashスクリプト、シェルプログラミング実践入門 [ Mokhtar Ebrahim ]</p>
    
      Amazonで見る</a>
      楽天市場で見る</a>
    </div>
  </div>
</div>
この本は、シェルスクリプトをもっと実践的に使うための、

基本的なことを様々解説しています。</p>
基本的なシェルスクリプトの文法の解説から始まり、

awkや正規表現など、シェルに関連する様々なことについて、

広く解説しているので、このへんの技術が好きな人には、

面白い本だと思います。</p>
シェルスクリプトを使う上で大事なことや、</mark>

ポイントなどを、コンパクトにまとめてくれている良書なので、</mark>

個人的には定期的に再読したい本です。</mark></p>
主に、自分のシェルスクリプトの理解度を試すバロメーターとしても

いいかもしれません。</p>
本のレベルとしては、めちゃくちゃ高度というわけでもなく、

かといって初心者向けというわけでもないので、

標準といったところでしょうか。</p>
個人的には、こちらの記事</a>で紹介していた、

シェル・ワンライナー160本ノックの方が、

より応用的かと思ったので、

高度なシェルスクリプトを学びたい場合は、

こちらの本の方がいいかもしれません。</p>
こんな方におすすめ</p>

シェルスクリプトが好きな人</li>
シェルスクリプトのパワーをもっと活かしたい人</li>
シェルスクリプトに関連するawkや正規表現などについても知りたい人</li>
</ul>
[st-card myclass="st-no-shadow" id="1271" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>

1日1問、半年以内に習得　シェル・ワンライナー160本ノック Software Design plus</a>
手を動かしながら学ぶTypeScript</h3>


  
  
    
  </div>
  
  
    手を動かしながら学ぶ TypeScript [ 渡邊比呂樹 ]</p>
    
      Amazonで見る</a>
      楽天市場で見る</a>
    </div>
  </div>
</div>
これは、TypeScriptの本の中でも、

実際に何かを作るという作業に注力できるのは、

ただ文法を学ぶのではなく、実際に何かを作って学習したいという人に

おすすめの一冊です。</p>
本も、やや薄めで、TypeScriptについてコンパクトにまとめられているので、</mark>

速攻で学習したい人には結構良いなと感じました。</mark></p>
本のレベル的には、まるっきりの初心者向けというわけではないですが、

めちゃくちゃ難しいわけでもなく、JavaScriptの学習経験が少しでもある方なら、

多分読み進められるかと思います。</p>
TypeScriptを極めるってなると、この一冊だけでは足りませんが、

軽く概要をサクッと学びたいっていう場合は、

非常に効率的な本だと思うのでおすすめです。</p>
ちなみに、TypeScriptについては、

私も記事や動画を挙げているので、

よろしければご参考ください。</p>
[st-card myclass="st-no-shadow" id="23" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]


  </iframe>
</div>

こんな方におすすめ</p>

何かを作ってTypeScriptを学びたい人</li>
基本的なJavaScriptなら分かる人</li>
薄めの書籍でサクッと学びたい人</li>
</ul>
TypeScriptとReact/Next.jsで作る実践Webアプリケーション開発</h3>


  
  
    
  </div>
  
  
    TypeScriptとReact/Next.jsでつくる実践Webアプリケーション開発 [ 手島 拓也 ]</p>
    
      Amazonで見る</a>
      楽天市場で見る</a>
    </div>
  </div>
</div>
この本は、タイトルの通り、TypeScript + Next.jsという、

モダン技術スタックでのアプリケーション開発をハンズオンで解説してくれる本です。</p>
この技術スタックは、昨今では非常に良く使われているものかと思いますが、

その割にこの技術スタックでのハンズオン解説の書籍は意外と少ないので、

本書はそのジャンルの書籍として非常に有用だと思いました。</strong></p>
ただ、本のレベルとしてはやや中級向けで、

実践的な反面、解説があっさりしていたりする部分もあるので、

他の入門書とかでReactやTypeScriptの基本をおさえてから、

この本を読むと、かなり実践的な理解が得られると思うのでおすすめです。</p>
こんな方におすすめ</p>

Next.jsとTypeScriptというモダンフロントエンドの開発に興味がある人</li>
CSSやコンポネント設計などについてある程度知識がある人</li>
</ul>
Vue3フロントエンド開発の教科書</h3>


  
  
    
  </div>
  
  
    Vue 3　フロントエンド開発の教科書 [ WINGSプロジェクト　齊藤 新三 ]</p>
    
      Amazonで見る</a>
      楽天市場で見る</a>
    </div>
  </div>
</div>
この本は、タイトルの通り、

Vue3での開発に焦点をあてた本で、

Vue3の書籍はまだまだ少ないので、

非常に参考になりました。</p>
そして、Vue3というやや応用的なトピックにもかかわらず、</mark>

非常に解説がわかりやすかったのも印象的で、</mark>

初心者でも無理なく読み進められる平易さだと思うので、</mark>

そもそもVue.js自体が初心者という方にもおすすめできる書籍です。</mark></p>
Vue.jsは2系と3系、options apiとcomposition api(script setup lang="ts"構成か否か)というように、

書き方のパターンが多すぎて、幾分かカオスになっているのは否めないですが、

この本は、今後主流になるであろう、vue3 composition api script setup lang="ts"構成での

解説になっているので、内容自体も実践的なので、

非常におすすめです。</p>
実務でVue.jsを使う人は必読の一冊かと思います。</p>
こんな方におすすめ</p>

Vue3を学ぶがてらVue.jsの復習をしたい人</li>
サクッとVue3を学びたい人</li>
</ul>
またVue3については、

私の方でも記事や動画をアップロードしているので、

よろしければご参考ください。</p>
[st-card myclass="st-no-shadow" id="432" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]


  </iframe>
</div>
</p>
新・明解C++入門</h3>


  
  
    
  </div>
  
  
    新・明解C++入門 [ 柴田 望洋 ]</p>
    
      Amazonで見る</a>
      楽天市場で見る</a>
    </div>
  </div>
</div>
お、急にどうしたって感じの本と思われたかもしれませんが、

いきなりのC++です。</p>
C++は、プログラミング言語の中でも、

Rustとかと同じぐらい高難易度で有名なので、

学習コストが高いことで有名なのですが、

この本は、そんなC++についてかなりわかりやすく解説しており、</strong>

非常に勉強になったのでおすすめします。</strong></p>
普段、Web系の言語ばかり使っていると、

気付けない点とかをC++とか勉強していると、

認識できるので、自分のインデックスを広げるために、</mark>

定期的に普段馴染みがない言語とかを学ぶのも、</mark>

良いアプローチだと思います。</mark></p>
その際、もしC++を勉強するのであれば、

この本はおすすめです。</p>
ただ、ポインター以降の章は、

全体的に難易度が上がるので、

必要に応じて読み飛ばすとかでもいいかもしれません。</p>
こんな方におすすめ</p>

たまにはちょっと堅い言語も学びたいWeb系エンジニアの人</li>
普段同じような言語ばかりで刺激が欲しい人</li>
ポインターとかを再学習したい人</li>
</ul>
シリコンバレーPythonプロフェッショナル大全</h3>


  
  
    シリコンバレー一流プログラマーが教える　Pythonプロフェッショナル大全 [ 酒井　潤 ]</p>
    
      Amazonで見る</a>
      楽天市場で見る</a>
    </div>
  </div>
</div>
これは、Udemyでおなじみの酒井さんの書籍ですが、

さすがUdemy講師だけあって、めちゃくちゃわかりやすい解説だなと思いました。</p>
基本的なPythonの文法はこの一冊で網羅できると思いますし、

わかりやすいので、特に初心者におすすめしたい一冊だなと思いました。</mark></p>
ただ、良くも悪くもやや初心者向けなので、

すでに実務でPythonをゴリゴリ使っているとか、

Pythonの基礎文法は習得済みでもっと深いことを知りたいという方には、

マッチしないかもしれません。</p>
これからPythonを学ぼうと考えている方のはじめの一冊として、

ぜひともおすすめしたい本です。</p>
こんな方におすすめ</p>

これからPythonを学びたい人</li>
オライリーとかよりわかりやすい書籍がいい人</li>
</ul>
アーキテクチャ・思想・作法・ノウハウ系</h2>
世界一流エンジニアの思考法</h3>


  
  
    
  </div>
  
  
    世界一流エンジニアの思考法 ／ 文芸春秋</p>
    
      Amazonで見る</a>
      楽天市場で見る</a>
    </div>
  </div>
</div>
この本は、タイトルだけ見ると、

「自分で世界一流ってどんだけ自信過剰なんだ」って感じましたが、

違いました。</p>
この著者の周りのエンジニアという切り口で、

この著者自体は、終始謙った感じの文章で非常に好感が持てました。</p>
それでいて、エンジニアに大切なことは</mark>

しっかり教えてくれているので、</mark>

なんというか、良い意味で期待を裏切られました。</mark></p>
このような自己啓発系の本は、

大半が外れですが、これは当たりです。</p>
読んで損はしません。</p>
特に日本的な開発に対する、

著者の意見は個人的に同意できる部分がたくさんありました。</p>
正直、私はここに書かれていることは、

ある意味当たり前じゃんとも思いましたが、

このあたり前のことを、例えばXとかで投稿すると、

それは違うと、所謂日本的な価値観で否定してくる人が

多かった経験があるので、

私個人としては、この価値観を変えてくれる本として期待しています。</p>
こんな方におすすめ</p>

日本のソフトウェア開発の体制に違和感を感じる人</li>
一流エンジニアの思考を知りたい人</li>
</ul>
プロダクトマネージャーのしごと</h3>


  
  
    
  </div>
  
  
    プロダクトマネージャーのしごと 第2版 1日目から使える実践ガイド [ Matt LeMay ]</p>
    
      Amazonで見る</a>
      楽天市場で見る</a>
    </div>
  </div>
</div>
この本は、発売されたばっかりのときは、

売り切れになって即入荷待ちになったりと、

非常に人気が高い本だったのを覚えているのですが、

タイトルの通り、プロダクトマネージャーについての実践的な心構えみたいなことが

書かれています。</p>
技術書というよりは、全体的にビジネス書寄りではありますが、

プロダクトマネージャーに興味がある人にとっては、</mark>

ここまで詳細かつ実践的に書かれている本はあまりないと思うので、</mark>

必読の一冊かなと思いました。</mark></p>
技術志向が強めの方には、あまりマッチしないかもしれませんが、

技術だけでなく、長期的にプロダクトマネージャーなども視野に見据えている方には、

おすすめしたい本です。</p>
こんな方におすすめ</p>

プロダクトマネージャーに興味がある人全て</li>
開発だけでないプロダクトの成長などに興味がある人</li>
マネジメントのキャリアを目指している人</li>
</ul>
エンジニアリング組織論への招待　不確実性に向き合う思考と組織のリファクタリング</h3>


  
  
    
  </div>
  
  
    エンジニアリング組織論への招待 不確実性に向き合う思考と組織のリファクタリング [ 廣木大地 ]</p>
    
      Amazonで見る</a>
      楽天市場で見る</a>
    </div>
  </div>
</div>
この本は、エンジニアリングについて、

しっかりと定義し、そこから考察を深めていくタッチの本で、

ソフトウェア開発の不確実にどう向き合うかについて焦点を当てている本です。</p>
哲学書とかみたいに、用語の定義を考えたりする人には、

結構ハマるテイストだなと感じていて、

「えそこから厳密に定義するの？」みたいな丁寧な記法になっていて、

非常に論理的でした。</p>
それでいて、内容も組織のリファクタリングという身近な題材になっており、</mark>

エンジニアであれば一度は読んでおきたい良書だと思います。</mark></p>
 </mark></p>
特に組織マネジメントや、マネジメントに興味がある現役エンジニアや、</mark>

現役PMとかは必読といってもいいかもしれません。</mark></p>
エンジニアリングに関係ない記述も多少ありましたが、

それでも参考になります。</p>
スクラム、アジャイルとウォーターフォールの違い、それぞれの状態、

アジャイルは、開発手法ではなく、チームの状態、アジャイルへの

誤解など、アジャイルの記述も多いのが特徴的でした。</p>
最後の方では、マイクロサービスとモノリシックについても触れており、

全体的に、ビジネス書感もありますが、しっかりエンジニアリングの本であることに変わりはなく、

BizとDevの組織に思いをはせたいときに再読したいと私は思いました。</p>
こんな方におすすめ</p>

ソフトウェア開発が何なのか今一度考え直したい人</li>
組織マネジメントと開発、ソフトウェアのあり方を考えたい人</li>
全体的にエンジニアリングについてしっかり学びたい人</li>
</ul>
アジャイルサムライ　達人開発者への道</h3>


  
  
    
  </div>
  
  
    アジャイルサムライ 達人開発者への道 [ ジョナサン・ラスマセン ]</p>
    
      Amazonで見る</a>
      楽天市場で見る</a>
    </div>
  </div>
</div>
この本は、その名の通り、

アジャイル開発について詳細に解説している本です。</p>
アジャイル開発は、立場や主張とかによって、

微妙に意味が変わったりして、

「結局アジャイルってなんだっけ？」ってなるのは、

あるあるだと思うので、

まずはこの本で、基本的なアジャイルのスタンダートを作ってから</mark>

他の類書を読んで、自分なりに「結局アジャイルってこういうことだよね」って</mark>

落とし所を見つける、とっかかりの本として非常におすすめです。</mark></p>
アジャイルサムライとあるぐらいなので、

アジャイルだけかと思いきや、テスト駆動開発とか、

ソフトウェアプロジェクト全般に通ずる、

時間、予算、品質、スコープを荒ぶる四天王と定義していたりと、

ソフトウェアプロジェクトの開発全般についての理解を深めたいときにも、

ぜひとも読みたい一冊です。</p>
こんな方におすすめ</p>

アジャイルについて勉強したい人</li>
ソフトウェア開発全般について知識を深めたい人</li>
このようなソフトウェア開発の流儀のような本をまだ読んだことがない人全て</li>
</ul>
エッセンシャルスクラム</h3>


  
  
    
  </div>
  
  
    エッセンシャルスクラム アジャイル開発に関わるすべての人のための完全攻略ガ （Object　oriented　selection） [ ケネス・S．ラビン ]</p>
    
      Amazonで見る</a>
      楽天市場で見る</a>
    </div>
  </div>
</div>
シンプルに良書です。

仕事でスクラム開発をしている人、

スクラムを取り入れようと考えている人は、

一度は目を通してみることをおすすめします。</p>
スクラムは、アジャイル開発の手法の一つですが、

意外とそれぞれの工程に目的や思想がはっきりしていて、

しっかりインプットしていないと、その威力を活かしきれないのは

あるあるですよね。</p>
ただ、そうは言っても、結局スクラム開発ってどうしたらいいの？</mark>

ってなると思いますが、その疑問に答えてくれるのが</mark>

本書という感じです。</mark></p>
結構分厚いかつ、字も小さいので、

読了するのは大変ではありますが、

スクラムの力をしっかり発揮させようとなると、

本書は何度も読み返して実践していく価値があるように思えました。</p>
まさに、エッセンシャルスクラムですね。</p>
そのため、そこまで初心者向けの本でもないかもしれませんが、

個人的にはおすすめです。</p>
こんな方におすすめ</p>

スクラム開発に興味がある人、すでにスクラムを導入していてまだ本書を読んでいない全ての人</li>
アジャイル開発に興味がある人</li>
組織マネジメントやチームの開発パフォーマンスなどに課題があると感じている人</li>
</ul>
GitLabに学ぶ世界最先端のリモート組織のつくりかた</h3>


  
  
    
  </div>
  
  
    GitLabに学ぶ 世界最先端のリモート組織のつくりかた ドキュメントの活用でオフィスなしでも最大の成果を出すグローバル企業のしくみ [ 千田 和央 ]</p>
    
      Amazonで見る</a>
      楽天市場で見る</a>
    </div>
  </div>
</div>
昨今は、リモートワークの流れから、

オフィス回帰になってきたりと、

何かとリモートワークへの風当たりが強くなってきましたが、

この本は、そんな中リモートワークで生産性を高める組織について、</mark>

詳しく解説しています。</mark></p>
この本については、私自身非常に感銘を受けた一冊なので、

下記の記事や動画で詳細に解説しています。</p>
[st-card myclass="st-no-shadow" id="2280" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]


  </iframe>
</div>

私自身も、リモートワークの生産性自体については、

色々思うことがあったので、

上記の記事や動画で別途考察もしています。</p>
フルリモートに肯定の人、

否定の人、問わず読んでもらいたい本です。</p>
2024世界を変える100の技術</h3>


  
  
    
  </div>
  
  
    日経テクノロジー展望2024　世界を変える100の技術【電子書籍】</p>
    
      Amazonで見る</a>
      楽天市場で見る</a>
    </div>
  </div>
</div>
これは、正確にはビジネス書ではあるのですが、

個人的に結構面白かったのでご紹介します。</p>
普通のビジネスマン向けの書籍なので、

日頃から様々な技術に触れているエンジニアからすると、

「おん？、世界を変える技術？お前非エンジニアだろ？」みたいな

抵抗感を感じる方もいるかもしれません（というか私がそうでした)</p>
ただ、エンジニアといっても、

やはり自分の専門もあれば、

良く知らない分野ももちろんあるわけで、

特にこの本は、Web以外の先端技術にこういうものがあるんだっていうことを</strong>

知ることができたので、個人的には読んで良かったと思いました。</strong></p>
Web系のエンジニアというと、技術って言うと、

フレームワークだ、ライブラリだみたいな、

Githubのコードを想像してしまうと思いますが、

グリーンコンクリートみたいな、全く別分野の技術とかを</mark>

さらっと学べるので、エンジニアの最低限の嗜みとして</mark>

知っておきたい技術を拾えるので、</mark>

おすすめです。</mark></p>
なまじ技術職をやっていると、

逆に視野が狭くなってしまうこともあるかもしれないので、

こういうビジネス書であえて世間的な技術をキャッチアップするのも、

たまにはいいかもしれませんね。</p>
こんな方におすすめ</p>

世間的に勢いがある技術を広く浅くキャッチアップしたい人</li>
現役エンジニアこそ読んだほうがいいかもしれない</li>
</ul>
モノリスからマイクロサービスへ</h3>


  
  
    
  </div>
  
  
    モノリスからマイクロサービスへ モノリスを進化させる実践移行ガイド [ Sam Newman ]</p>
    
      Amazonで見る</a>
      楽天市場で見る</a>
    </div>
  </div>
</div>
この本は、はっきり言って、

結構難しいです。</p>
マイクロサービスというトピック自体高度ということも、

もちろんあるので、それが大きいかもしれません。</p>
ただ、内容自体は、非常に実践的で、

そもそもマイクロサービスに本当にするべきなのかという、</mark>

問題意識を掘り下げていて、</mark>

何でもかんでもマイクロサービスにするデメリットなどについて、</mark>

厳しく批評しており、こうしたアーキテクチャ選定などに、</mark>

興味がある人にはとてもおすすめの本です。</mark></p>
ある程度、マイクロサービスとは何かということや、

マイクロサービスの問題点とかを軽く知っておいた方が、

本書を読み進めやすいかもしれません。</p>
こんな方におすすめ</p>

マイクロサービスに興味がある人</li>
マイクロサービスには限界があると感じていて落とし所を模索している人</li>
モノリスとマイクロサービスの違いが知りたい人</li>
</ul>
AWS・インフラ系</h2>
AWSではじめるインフラ構築入門 安全で堅牢な本番環境の作り方</h3>


  
  
    
  </div>
  
  
    AWSではじめるインフラ構築入門 第2版 安全で堅牢な本番環境のつくり方 [ 中垣 健志 ]</p>
    
      Amazonで見る</a>
      楽天市場で見る</a>
    </div>
  </div>
</div>
この本は、これからAWSを本格的に学びたい人、

それも資格とかによる概念とかではなく、

ハンズオンで実際にAWSをどのようにして使っていくのかについての、

理解を深めたい人に特におすすめの本です。</p>
AWSの本は、いくつか読みましたが、</mark>

個人的にはこの本が一番わかりやすいかつ、</mark>

網羅性もあり、しっかり実践的だったので、</mark>

非常に良書だと思います。</mark></p>
クラウドプラクティショナーのようなAWSの資格の勉強も

良いのですが、それだけだと、「結局AWSってどうやって使うの？」って感じに

なりがちかもしれません。</p>
なので、実務でAWSを使う必要が出てきた人とかに、

特におすすめです。</p>
私ももし、今からAWSについて一から学習するとしたら、

この本を選ぶと思います。</p>
こんな方におすすめ</p>

AWSをとにかく使えるようになりたい人</li>
理論よりも先にハンズオンしてみたい人</li>
AWSの資格取得は面倒だと感じる人</li>
</ul>
基礎から学ぶサーバーレス開発</h3>


  
  
    
  </div>
  
  
    基礎から学ぶ サーバーレス開発 [ 青池利昭 ]</p>
    
      Amazonで見る</a>
      楽天市場で見る</a>
    </div>
  </div>
</div>
この本は、samやslsといったサーバーレスのフレームワークを使って、

lambdaなどのプログラムを実行する方法などについて解説してくれています。</p>
AWSを使って、ここまで色々できるのかということを知ることができるので、

自分のインデックスを広げるという意味では良いかと思います。</p>
一方で全体的に解説があっさりしており、肝心の部分は公式ドキュメントを

見て下さいという記述も多いため、ある程度プログラミング経験がある人向けかなと思いました。

また、ソースコードの詳しい解説も少なく、内容も割といろんなAWSサービスを

使うのでAWSについてもある程度知っている人向けの印象はありました。</p>
ただ、サーバーレスの活用例(在宅勤務システムとか)や、</strong>

請求の失敗談など、筆者の体験にもとづくエピソードもあり、</strong>

より具体的な活用などを知ることができるので、</strong>

サーバーレスを本格的に使用する方は、読んでおいた方が良いと思います。</strong></p>
こんな方におすすめ</p>

サーバーレスに興味がある人</li>
AWSやプログラミングの基本的な知識がある人</li>
</ul>
Kubernetes on AWSアプリケーションエンジニア本番環境へ備える</h3>


  
  
    
  </div>
  
  
    Kubernetes　on　AWS ～アプリケーションエンジニア　本番環境へ備える [ 会澤 康二 ]</p>
    
      Amazonで見る</a>
      楽天市場で見る</a>
    </div>
  </div>
</div>
この本は、その名の通り、Kubernetesの本なのですが、

副題にもあるようにインフラエンジニアというよりは、

アプリケーションエンジニア目線で書かれているのが特徴です。</p>
また、Kubernetesのハンズオンをしていく中で、</strong>

いろいろなAWSサービスを使っていくので、</strong>

シンプルにAWSの勉強にもなります。</strong></p>
ただ、そもそもKubernetesが応用的なトピックということに加え、

複数のAWSサービスを色々使うため、書籍の内容的には、

あまり初心者向けではないかもしません。</p>
また、監視やモニタリングといった、

実務の本番環境のインフラを想定した応用的な内容も扱っているため、

非常に実践的な反面、どうしても書籍のレベル感自体はそこそこ高いなという印象でした。

(特にこれらについての実務経験がないとピンとこない箇所も多いかもしれません)</p>
普段AWSをあまり使わない方や、

Kubernetesに馴染みがない場合は、

他の易しめの書籍をやってから本書をやったほうがより理解度が上がると思います。</p>
ただ、apiサーバー、フロントエンド、バッチアプリケーションなど、</mark>

アプリケーションエンジニアに身近なソフトウェアのデプロイ手法を学べるので、</mark>

個人的には良書だと思います。</mark></p>
ハンズオン自体は、そこまで多くもなく、

後半は解説がメインでしたが、

Kubernetesは料金的にも気軽にハンズオン出来るものでもないので、

これもある種ちょうどいい量かもしれません。</p>
Kubernetesはある種、

Dockerの応用のような側面もあったりするので、

Dockerの基本的な使い方にまだ不安がある人は、

そちらを先に勉強した方が理解度が上がるかと思います。</p>
Dockerについては、

私の方でも記事</a>や動画をアップロードしているので、

よろしければご参考ください。</p>
[st-card myclass="st-no-shadow" id="2186" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]


  </iframe>
</div>

こんな方におすすめ</p>

Kubernetesに興味がある人</li>
現役SREやインフラエンジニアの人、またはインフラに興味があるアプリケーションエンジニア</li>
AWSの基本的な知識がある人</li>
Dockerの基本的な知識がある人</li>
</ul>
Nginx実践入門</h3>


  
  
    
  </div>
  
  
    nginx実践入門 （WEB＋DB　press　plusシリーズ） [ 久保達彦 ]</p>
    
      Amazonで見る</a>
      楽天市場で見る</a>
    </div>
  </div>
</div>
Nginxって、実務で使う可能性が非常に高い技術なのにもかかわらず、

意外と技術書で探すと専門書が多くありません。</p>
Nginxは、個人的には公式ドキュメントが見やすいとは言い難いので、

本書のように改めて体系的にNginxを学習できるツールは貴重だと思います。</p>
特に、Luaで設定をいじれるというのは、

初耳でこの本で初めて知りました。</p>
他にも基本的なNginxの使い方や、</mark>

設定のパラメータなどについて詳しく解説しているので、</mark>

Nginxを使う機会がある方は読んでおいても損はないかと思います。</mark></p>
ちなみに、Nginxについては、

私も記事</a>や動画を作成しているので、

よろしければご参考ください。</p>
こんな方におすすめ</p>

Nginxの設定に不安が残る人</li>
実務などでNginxに触れる機会がある人</li>
</ul>
[st-card myclass="st-no-shadow" id="2075" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]


  </iframe>
</div>
</p>


【フルリモート vs 出社】エンジニアの働き方の理想を考える
2023-12-22T00:00:00+00:00
コロナ禍などで、

世間的に一気にリモートワークが浸透しましたが、

最近ではまた出社回帰の企業が増えてきました。</p>
特に巨大テック企業のGoogleやZoomなどが

出社回帰したことは大きく話題になりましたし、

これらの企業の影響力は大きいので、

リモートワークはオワコンとまことしやかに囁かれることも、

増えてきました。</p>
X(旧Twitter)やYouTubeとかはどうかというと、

フルリモートというと、

楽してるとか、絶対上手くいかないみたいな

巨大テック企業の出社回帰の減少も相まってか、

否定的な意見が多い印象です。</p>
X (Twitter) でポストを見る</a></p>
以上のことから、

世間的にはリモートワーク(特にフルリモート)について、

否定的に語られることが多いのですが、私はそうは思いません。</strong>

なぜなら、フルリモートには絶大なメリットがあるからです。</strong></mark></p>
たしかにフルリモート特有のデメリットや、

出社ならではのメリットもあります。

実際、それらについては私もその通りだと思いますし、

YouTubeとか Xの意見も、概ねこれらの考え方がメインなのかなと思っています、</p>
ただ、それでもフルリモートのデメリットは、

ある程度対策可能なのに対し、出社のデメリットは対策することが難しいです。</p>
そこで本記事では、フルリモートワークこそが</mark>

エンジニアの働き方として理想である理由や、</mark>

出社やハイブリッドワークのデメリット、</mark>

巨大テック企業が出社回帰したから、</mark>

それに安易に迎合するのは避けるべきということについて</mark>

解説したいと思います</mark></p>
私自身、前職でフル出社とハイブリッドワークを経験し、</strong>

現職ではフルリモートワークを経験しているため、</strong>

概ね全ての働き方を経験してきているため、</strong>

この題材については結構語れる要素があると思ったので、</strong>

本記事を作成しました。</strong></p>
ちなみに、下記の本はエンジニアの働き方を考えるうえで、

とても参考になるので、フルリモートワークとハイブリッドワークどちらがいいのかという

問題意識を持っている人は読んでみることをおすすめします。</p>


  
  
    
  </div>
  
  
    GitLabに学ぶ 世界最先端のリモート組織のつくりかた ドキュメントの活用でオフィスなしでも最大の成果を出すグローバル企業のしくみ [ 千田 和央 ]</p>
    
      Amazonで見る</a>
      楽天市場で見る</a>
    </div>
  </div>
</div>
また、こちらの記事</a>では、

上記の本以外でも、

プログラミング全般でおすすめの書籍を紹介しているので、

興味がある方はぜひともご参考ください</p>
エンジニアならフルリモートが理想</h2>
若干、偏っていることは百も承知なのですが、

個人的にはフルリモートにはメリットしかないと思います。

(もちろんデメリットがないというわけではないのですが、

それらのデメリットは対策可能という点で致命的ではないという意味で、

メリットしかないという意味です)</p>
パッと思いつくだけでもフルリモートには下記のメリットがあります</p>

</blockquote>
・働く場所を気にしなくていい

・テキストコミュニュケーションが増えるので、やり方次第で情報を資産化できる

・通勤時間を算出する必要がない

・体調が微妙だったり、どうしても外せない用事とかがあった際の融通を、つけやすい

・（フルフレックスなら働く時間も気にしなくていい。フルリモートの理想形はフルフレックスであるべきとも思います)</p>
というか、わざわざ私が言うまでもなく、

エンジニア目線であれば、一番働きやすいのって、

フルリモートの圧勝だと思います。</strong></p>
フルリモートのデメリットは、主に経営層から

語られることが多く、社員のパフォーマンスを懸念されることが多いです。</p>
フルリモートのデメリットは対策可能</h3>
さて、そんなフルリモートの懸念点(デメリット)ですが、

良く言われるのが、</p>

</blockquote>
・サボる社員がいるのではないか

・出社したほうが成果が出せる

・フルリモートの人の労務管理が難しい</p>
あたりですかね。

実際巨大テック企業の出社回帰もこのあたりが

理由だったかと思います。</p>
個人的にはフルリモートのデメリットは、

これら以外にあると感じており、

これらの社員のパフォーマンス懸念に関しては、

言うほど、致命的な損失はないと思います。</strong>

(労務管理については、サイレント残業が発生したりする場合がないわけではないので、

この３つの中では一番的を射たデメリットだとは思いますが)</p>
Googleとか、Zoomとかは必ずしもエンジニアだけではなく、

いろんな職種の人がいる、巨大企業なので、

実際のところは、エンジニアの働き方が、

フルリモートに向いていないからと言うより、

全社員を出社にしたほうが手っ取り早いみたいな側面もあったような気もしています。

(あとは、エンジニアだけリモートにするのは不公平だからという理由もあった気がします)</p>
つまり、エンジニア単体で考えると、

これらのデメリットってほとんど意味をなさないなと感じています。</p>
以下順番に解説します</p>
フルリモートはサボるのか？</h3>
よくある疑問として、フルリモートだとだらけるのではないかというのがあります。

だらけるのが心配だからフル出社にした方がいいという主張もたまに見かけます。</p>
ただ、これについては、

私からすると、自分からマネジメント能力がないと言っているようにしか聞こえません。</p>
確かにフルリモートというのは、基本的に個人の自主性に任せるので、その気になればサボることは可能です。</p>
しかし、そもそも論として、このサボるサボらないということ自体、馬鹿馬鹿しい議題です。</strong></p>
平たくいうと成果主義。

すなわち、その人がどれだけのアウトプットをしたかで判断し、途中経過は任せればいいのです。</p>
ぶっちゃけ、成果を適切にアウトプットしていれば、サボっていようが何しようがどうでもいいのです。

つまり時給でその人の労働を、図るという発想のままだと、フルリモートは実現できないでしょう。</strong></p>
サボるという思想自体も、その労働時間に対して仕事していない時間があると考えるから生まれるわけです。

それであれば、そもそも労働時間に対して仕事をしているという発想を改めるべきです。</strong></p>
もちろん、これは職種によっては馴染まないので、

エンジニアの場合の話です。</p>
裏を返せば、成果を出せないのであれば、

アウトプットを出せるまで、仕事をしなければならない時もあります。

なので、労働時間ではなく、その人の成果で判断すれば、フルリモートを実現するのは難しくないと思います。</p>
つまりフルリモートで、いわゆるサボりを行ったところで、最後に苦しむのは結局自分なので、必然的にサボらなくなります。</p>
それどころか、場合によっては出社しているときよりも、いわゆるサイレント残業が発生しがちな気もします。</p>
OSS開発はフルリモート</h4>
皆さんは、エンジニアのチームとして最高峰を考えると何を思い起こすでしょうか？</p>
もちろん、GAFAとかもありますが、

もっと身近でかつ高レベルなものとして、

OSS開発があります。</p>
これも多くの場合、フルリモートですよね。

そして、最高のプロダクトが作り出されています。</p>
それに加えて、OSSとかだと、時差が異なることもあるので、基本mtgとかもないでしょう。

完全にテキストチャットで行う非同期分散開発の究極系です。</p>
個人的にはこれこそあるべき姿なのかなと思っています。</p>
出社したほうが成果が出せる</h3>
もう一つよく聞くのが、

出社したほうがパフォーマンスが高いというのがあります。</p>
これについては、正直企業の業態とか

組織構造によるなと思っていて、

一概に全ての企業がそう断定できないとは思います。</strong></p>
というのも、基本的に出社したほうが効率が良い企業は、

mtgやディスカッションが比較的多かったり、

顧客とのコミュニケーションの重要性が相対的に高いパターンに

当てはまると思っていて、裏を返せば、

これらの特徴が弱ければ、

正直出社してようがリモートだろうが、

そんなに変わらないと私は考えます。</p>
しばしば、Googleとかの素晴らしい製品は、

同じ部屋で話し合って生まれたみたいなエピソードを聞くと、

出社こそ最高というふうに感じるかもしれませんが、

フルリモートで生み出されたOSSとかにも素晴らしい製品はいくらでもあるので、

出社だからこそ、最高の製品を作り出せて、リモートだと作り出せないなんていうことは

全くないと思います。</p>
なので、結局のところ、出社の方が成果を出せるというのは、

そういうケースもあるかもしれないけど、

どこまで確証があるのかはわからないふわっとしているものと

言わざるをえない気がします。</strong></p>
ハイブリッドワークが理想というのは嘘</h3>
このようにフルリモートがいいと言うと、

それなら、出社とフルリモートを合わせたハイブリッドこそ理想という意見も聞きます</p>
これについては、組織によって何が正解かはもちろん異なりますし、

ハイブリッドワークはフルリモートのデメリットをある種適切に解決している側面はあるので、

悪いアプローチとは私も思いません。</p>
ただ、私個人の意見としては、

ハイブリッドワークよりも、フルリモートの方がいいと考えます。</strong></p>
理由はシンプルで、

例えば週二回の出社日を、

リモートにしてしまったりした際に、

注意を受けやすかったり、

ひどい場合にはフル出社にすると切り替えたり、

基本的に出社の方がいいという風潮に陥りやすく、

結果的にリモートワークの人の立場が弱くなるからです。</strong></p>
もちろん、営業職などのように、

はっきりとこの日は出社しないとそもそも仕事にならないみたいな職種の場合はこの限りではありませんが、

少なくともエンジニアのように、出社するしないで、仕事の生産性が0か100かになるような世界線でない職種で、

きっちり出社したかどうかを管理するのは、はっきり言って馬鹿馬鹿しいと思います。</p>
</p>
逆に出社するメリットを考える</h3>
さてフルリモート賛美が続いたので、

少し出社のメリットも考えています。</p>
まず挙げられるのが、

信頼関係を構築しやすいという点です。

これは確かに一理あるでしょう。</p>
しかし、信頼関係を構築しやすいということは、

壊しやすいというのもあります。

出社は、リモートに比べ良くも悪くもコミュニュケーションが密になるので、

適切にコミュニュケーションが取れれば効果的に信頼関係を構築できる一方、やり方を間違えると、

逆に信頼をそこなってしまうこともあります。</p>
これはあくまで個人的な考えではありますが、

そもそも職場の信頼関係を築くことは、

高いパフォーマンスの仕事をすることに必須なのかという疑問があります。</p>
もちろん、信頼関係を構築できれば、

それだけ風通しもよくなり、

心理的安全性は高まりますから、

個人が自分の能力を発揮しやすくなります。</p>
ただ、信頼関係を構築しないと発揮できないかというとそんなことは決してないと思います。</p>
信頼関係構築の背後には、

仕事を楽しくして、人生を充実させたいのような、本来の仕事のパフォーマンスとは別の側面も含まれている気がしており、

信頼関係を構築したからといって、エンジニアなどは基本的に実力やスキルがモノをいうので、

パフォーマンスが低い人は低いままであることがほとんどです。</p>
つまり、これは、本来パフォーマンスが高いはずなのに、

コミュニュケーションの齟齬によって発揮できていない際に問題になることですが、

そのレベルのコミュニュケーションであれば、

フルリモートで十分達成できます。</p>
あと、出社のメリットとして語られがちな、

すぐにわからないことを聞けるという点ですが、

個人的にはこれは結構現場によって変わるよなという印象でして、

少なくとも私の場合では、このメリットは全くなかったと言っても良かったです。</p>
というのも、結局出社していて、隣に先輩エンジニアがいても、

mtgばっかりだったり、死ぬほど忙しそうで話しかけられる雰囲気じゃなかったりで、

結局chatで聞いた方が早いということがしばしばあったからです。</p>
それと、めちゃくちゃあるあるなのが、

新人は出社させられるけど、先輩はリモートだから、

結局コミュニケーションはchatになるっていう、

意味不明なシチュエーションもあります。</p>
結局のところ、出社の方が良いというのではなくて、

単にその人が出社のほうがあっているというケースがほとんどで、

働き方としては、出社じゃないとだめということは

基本ないのかなと思います。</p>
フルリモートにおける関係構築とデメリットについて</h2>
冒頭でフルリモートこそ最高みたいな論調で語ってしまいましたが、

正直、フルリモートにデメリットがないわけではありません。</p>
世間的には、フルリモートはサボるから良くないとか、

楽してるみたいな、パフォーマンス面を懸念するデメリットが多いですが、

個人的にはフルリモートのデメリットはそこではないと思います。</p>
フルリモートは病みやすい</h3>
フルリモートの最大のデメリット。

それは病みやすいということです。</p>
これって意外と語られることが少ないのですが、

正直フルリモートのデメリットはこれ以外には存在しないと、

私は思っています。</p>
フルリモートは、基本的に家で一人でずっと仕事をするので、

何もしないと、家に引きこもりがちになりますし、

職場とのコミュニケーションも、オンラインmtgしかないので、

どうしても希薄になります。</p>
そのため、人との交流が極度になくなってしまい、

精神を病みやすくなります。</p>
なので、本来フルリモートの対策としては、

この点に焦点を当てるべきなのですが、

これを解決しようとしている組織は、

まだそこまで多くない印象です。

(冒頭で紹介したGitlabとかはこの点についても

触れていたと思います。)</p>

GitLabに学ぶ 世界最先端のリモート組織のつくりかた ドキュメントの活用でオフィスなしでも最大の成果を出すグローバル企業のしくみ</a>
ただ、これについても

対策は可能だと思っていて、

私としては下記のような対策が有効だと思います

(この対策としてハイブリッドワークを取り入れるのは、

悪手とは言えないが、微妙に目的が変わってしまっている気がするので、

個人的には推奨できない)</p>

</blockquote>
・まず、今後同じチームで仕事をするであろうメンバーの初回顔合わせを行う

・いつでも飲みとかに誘えるような心理的安全性を作る</p>
このあたりかなと思います。

よくある、定期的に会う機会を設けるというのも、

悪くはないと思いますが、

会うのを目的にすると言うよりかは、

会いたくなったから会うということのほうが理想だと思うので、

いつでも気軽に誘える心理的安全性を築くっていうことが大事だと私は考えます。</p>
timesの使い方</h4>
フルリモートの場合、

timesも意外と重要だったりします。</p>
timesは平たく言うと、

chatツールにおける、

自分のTwitterのようなもので、

好きなことを呟ける部屋です。</p>
なので、このtimesで、

趣味の話とか好きなものとかを語っていると、

そのtimesを観た人で興味がある人と盛り上がったり出来るので、

フルリモート組織ならtimesの導入はメリットが大きいなという印象です。</p>
巨大テック企業の出社回帰について</h2>
さて、そうは言っても、

Googleとか、リモートワークの代名詞のZoomが

フルリモートをやめた時点で正解はわかりきっているんじゃないって感じる人も

多いかもしれません。</p>
私からすると、GoogleやZoomの組織構造やビジネス構造と、

他の多くの企業が一緒なわけはないので、

Googleとかが出社回帰したからそれに迎合するというのは、

あまりに軽率すぎないかとも感じますが、

確かにこれらの企業の影響力があるのは間違いありません。</p>
そこで、これらの企業の出社回帰についても

考察してみます。</p>
Googleの場合</h3>
まずGoogleです。</p>
下記の記事を見ると、

週３日の出社と、出社したかどうかの

チェックも行っているとのことで、

かなり厳しめの出社回帰だなと感じました。</p>
https://www.businessinsider.jp/post-272779</a></p>
同じ部屋で一緒に働くことがポジティブな変化ということが語られているように、

出社することによるパフォーマンスを重視しての、

決断なのかと思います。</p>
私個人の意見としては、

OSSとかもあるので、出社しないと、

ポジティブな変化が表れないとは全然思えないのですが、

Googleとかになると、規模や影響力なども、

普通の企業と大きく異なるので、世界1位を走るために、

微細なパフォーマンス向上でも見込めるならそうするべきだみたいな

考えもあるのかもしれませんし、それなら別に特段不思議な意思決定とも感じません。</p>
ただ、注意したいのは、

これはあくまでGoogleレベルの話だからそう言えるのであって、

他の多くの企業がGoogleと同じレベルなのかというと、

絶対そんなことはないのかなと思います。</p>
求めているものや背景、状況も全く違うので、

Googleがリモートワークをやめたから、

うちもリモートワークをやめるというのは

思考停止なのではと思ってしまいます。</p>
Googleの場合、

そもそもGAFAとして苛烈な競争にさらされ、

トップに君臨し続ける重圧があるため、

パフォーマンス向上にこだわるのはめちゃくちゃわかります。

そして、Googleのような巨大テック企業であれば、

週３日出社という強気な施策に出ても、

エンジニア採用に困ることはほぼないでしょう。</p>
こういう背景があるから、Googleは出社にしているだけなのかなと

私は考えます。</p>
なので、正直私からすると、

Googleのほうが特殊ケースで、

他の多くの企業は、やはりフルリモートのほうが

適しているのではないかなと思います。</p>
特に日本の多くの企業では、

エンジニア採用を不利にしてまで、

出社回帰をするメリットがあるのか疑問です。</p>
世界一位を維持するとかならたしかに

出社にして、最高パフォーマンスを追求するというのはわかりますが、

正直そのレベルではないなら、フルリモートで、

全然パフォーマンスは出せると思います。</p>
Zoomの場合</h3>
お次はZoomです。</p>
こちらは、下記の記事を見ると、

週二回出社を要請しているっぽいですね。</p>
https://www.nikkei.com/article/DGXZQOUC153QZ0V11C23A1000000/</a></p>
「リモートワークの代名詞のZoomが出社回帰。リモートオワコン」みたいな

ことがよく語られがちですが、

個人的には、これもGoogleのときと同じく、

思考停止の一種かなと思っています。</p>
私としては、ZoomもGoogleのときと同じく、

特殊ケースでしかないと思っていて、

別に特段の驚きはありません。</p>
その理由はシンプルで、

Zoomがリモートワークを推進する商売をしているから、

メインクライアントである、出社をしている顧客の立場とか、

出社からリモートに切り替えたいと考えている顧客の立場や課題を知るために、

自分たちもある程度は出社をしないとわからないからです。</p>
これは確かにその通りだなと感じており、

リモートを推進する会社だからこそ、

リモート以外を知る必要があるというのは、

全然不思議ではありません。</p>
ただ、Zoomのようにリモートワークの推進を商売にしている会社って、

どれだけあるのかっていうことを考えると、

これも特殊ケースだと思います。</p>
特殊ケースをみて、

リモートワークがオワコンと考えるのは、

早計なのかなと感じます。</p>
実際、Zoomってたしかに出社しているときにも使うことあるので、

そういうニーズを捉えるために、出社したほうがいいという判断は、

何ら不思議はないと思います。</p>
結論:フルリモートvs 出社</h2>
議論がやや錯綜したので、

最後に結論だけ言って、

締めます。</p>
この記事で私が最も伝えたかったのは、

フルリモートへの誤解と、巨大テック企業への迎合への違和感です。</p>
すなわち、

フルリモートが適しているかどうかは組織によって異なるし、

少なくともエンジニアにおいては、フルリモートでパフォーマンスを出せないこともないし、

巨大テック企業の特殊ケースを除けば、むしろフルリモートのほうがメリットが大きいことが

ほとんど。</strong></p>
ということが言いたかったのですが、

うまくまとまりませんでした。</p>
正直、フルリモートを実現するためには、

どうしてもメンバーの能力とかも関係してくるので、

すべての企業がフルリモートが適しているとは私は思いません。</p>
しかし、フルリモートという選択肢を最初から薙ぎ払ってしまうのはナンセンスだなとは

思っており、基本的に巨大テック企業のような例外を除き、

フルリモートを目指したほうがメンバーの能力、パフォーマンス双方ともに、

レベルが上がることがほとんどで、そもそもフルリモートって、

能力が高い人が多くないと成り立たないので、

組織の理想形として目指したい像ではあります。</p>
それを最初から薙ぎ払ってしまうのは、

自分から「私はマネジメント能力がありません」って言っているような

ものになりかねないので(フルリモートでも上手く回るけどあえて出社にしているとかなら、

良い選択だと思います)、個人的にはフルリモートこそが、

手っ取り早く組織のレベルを上げる働き方として優れているということを

本記事でお伝えしたかったです。</p>


【絶対に就職してはいけないブラック企業】駆け出しWeb系エンジニアへの罠
2023-12-16T00:00:00+00:00
以前、X(旧ツイッタ)の方で、

下記のような投稿を行いました。</p>
X (Twitter) でポストを見る</a></p>
想像以上に反響があったので、

本記事では、このツイートの詳細に

触れていこうと思います。</p>
なので、記事のジャンルとしては、

エッセイ・体験談のような形になります。</p>
下記のような人向けの記事です。</p>

</blockquote>
これからエンジニアを目指している人</p>
エンジニア就職する上で絶対に就職してはいけない企業がどういうものか知りたい人</p>
優良企業がどういう特徴か知りたい人</p>
おすすめの転職エージェントや転職サービスを知りたい人</p>
世にも奇妙なブラック企業の怪談を聞きたい人</p>
下記のような人には参考にならないか、

趣向がマッチしません</p>

</blockquote>
技術的な記事を求めている人(他の記事で上げているのでそちらをどうぞ)</p>
まあ基本は、

「世の中にはこんなやばい企業があるんだぜ」っていう

ちょっとした雑談チックな記事なので軽い気持ちで読んでください。</p>
ただ、それだけだとあまりに読者のみなさんへの

メリットがなさすぎるので、

一応本記事を読むメリットとして、</p>

</blockquote>
ブラック企業への解像度があがる</p>
エンジニア就職の温度感がわかる</p>
優良企業に就職するために何をすればいいのかわかる</p>
などはご提供出来ると思います。

ぜひともご参考ください。</p>
投稿した企業について</h2>
まずは、ツイートした企業の情報について改めて整理します。</p>

</blockquote>
3ヶ月ぐらいお試しで採用する</p>
3ヶ月後に本採用する保証はしない</p>
本採用の保証はしないが、基本うちに来ること前提的な口調</p>
お試し採用期間中は無給</strong></p>
もちろん毎日出社</p>
モダンな開発案件でゴリゴリ経験積める(らしい)</p>
まず、このあたりが基本情報です。</p>
いや基本情報ですでにお腹いっぱいって感じですね...</p>
特に、無給のインパクトがものすごいですよね。</strong>

これ作り話とかじゃなくて、本当にそう言われたんです...(どうか作り話であってくれ)</p>
この企業は、わたしが未経験でエンジニア就活しているときに、

カジュアル面談したのですが、

こんな感じの条件だったので、

わたしはお断りしました。</p>
ただ、このツイートが思いの外反響もあり、

実際にここでインターンとして働いていた経験がある方にも、

少しお話を伺いました。</p>
その追加情報をリストアップすると、</p>

</blockquote>
無給インターン生は多い時で8人ぐらいいたことも</p>
納期とかはめちゃくちゃ詰められる</p>
上層部は開発を軽んじている思想でエンジニアを大事にしない</p>
優秀なエンジニアもいるらしいが上の精神的なパワハラなどで疲弊している</p>
実は、これ以外にもかなりのびっくり情報があったのですが、

これ以上言うと、特定されかねないので伏せます。

平たく言うと、典型的なワンマン社長の企業で、

社員を奴隷のようにぐらいにしか思っていないんだろうなというのが、

めちゃくちゃわかりやすいところです。</p>
基本的に無給で分かる通り、お金にかなりケチなことは伺えました。

(無給はケチとかっていうレベルを通り越していますが...)</p>
この企業でも募集があった理由</h3>
これだけ聞くと、

「いや誰も応募しねえだろ」って思うかもしれませんが、

多いときで8人ぐらいのインターンがいたっていうぐらいなので、

結構人気な企業と言えなくもありません(この会社の規模を考えると)</p>
そう、この会社のやり方が汚いなと強く感じさせる特徴が

「実務経験を積める」という特徴です。</strong></p>
みな、これを求めて無給でも応募していたんだと思います。

実際、この企業は、開発の実務経験自体は、

割と本当に積めるみたいなので、

開発の実務経験を積むという目的にフォーカスするなら、

応募する人がいても不思議ではありません。</p>
実際に働いている人に聞いた感じも、

この点は嘘ではなかったようです。

(それもNext.jsのような人気のモダン技術で)</p>
しかし、私個人としては、

ある意味、未経験エンジニアの「実務経験がない」という弱みにつけ込んで、

人件費を抑えようとしている、非常に狡猾かつ残忍なやり方なので、

たとえ開発経験を積むことだけを考えても、

絶対に応募しては行けない企業だと思いました。</p>
ここの企業はWeb系Sierに該当しますが、

ここを受けるぐらいなら、研修もしっかりやってくれて、

もちろん、給料も出してくれるSESとかに行ったほうが、

10000倍良いかと思います。</p>
ともすると、Web系とか、

自社サービスみたいな言葉は、

キラキラしていて、それが一人歩きしているような気がしていますが、

そこしか見ていないと、こういう残忍企業に引っかかってしまうかもしれませんので、

注意してください。</p>
エンジニア就活の難易度は上がっている</h2>
正直、私が未経験だったときと比べて、

現在は未経験エンジニアの就活の難易度が上がっているのではという印象を受けます。</p>
具体的には、</p>

</blockquote>
ポートフォリアはあるのは当たり前</p>
未経験でもプログラミング全く触ったことないレベルの人は殆ど見かけない</p>
だからこそ、上記のような企業には注意が必要です。

上記の企業は、現在も普通に転職媒体とかで、

「未経験でも可」という謳い文句で募集しているので、

現在のような就活難易度が上がっている中だと、

以前よりも危険度が上がっている気がします。</strong></p>
私自身、未経験のときは

実務経験を積むということをめちゃくちゃ考えていたので、

気持ちはめちゃくちゃわかります。</p>
「プログラミングスクールは金かかるし、

たとえ無給でも、Reactとかの経験が積めるならいい」</p>
そう考えて、安易に応募するのはおすすめしません。

上記の企業とかは、無給という体質で分かるように、

基本的にかなりのモラハラ・パワハラ気質だそうです

(実際に同企業で働かれていた方にお聞きしました)</p>
最悪の場合、メンタルを壊したり、

体調を壊してしまう可能性も否定できません。

(基本的に無給だったら生活が苦しくなるのは当たり前なのですが、

この企業はそういうことを一ミリも配慮してくれないどころか、

かなりの労働を求めてくるようです...)</p>
そうなってしまうと、

なんのために実務経験を積んだのかも分からなくなります。</p>
それに、無給という場合だと、

そもそもお金をもらっていないので、

実務経験と呼べるかも怪しいという問題もあります。</p>
「Web系の実務経験が、未経験でも積める」という甘い誘いに

乗らないよう注意してください。</p>
いまエンジニアになるならどうしたらいいか</h3>
さて、それを踏まえ、

今からエンジニアになるにはどうすればいいのかというと、

一言でいうと、優良企業に就職することです。</p>
「いやそんなの当たり前じゃねえか」

って怒り狂わないでください。</p>
ここでの優良企業っていうのは、

Yahooとかリクルートみたいな就職難易度が高い、

誰もが知っている優良企業という意味ではないです。</p>
それは、未経験の人でも入りやすく、かつ、

未経験の人が入るからこそメリットが大きい企業全般のことです。</p>
正直、未経験の人が入りやすい企業は多くありません。

その中で比較的条件が良い企業を優良企業と私は考えて、

そこに就職するのが最も良いということです(結局当たり前の結論に戻ってきました)</p>
こういう企業に入るためにどういうことをしたらいいのかについては、

下記の記事</a>でも解説しているので、

ご参考ください。</p>
優良企業の条件</h3>
さて、そんな優良企業の具体的な条件ですが、

個人的には、下記のような企業かと思います。</p>

</blockquote>
面接官や社員の雰囲気に違和感を感じない</p>
オープンワークのスコアが3.0を下回っていない</p>
未経験の人がOKな理由がはっきりしている</p>
大量採用をしていない</p>
常に募集していない</p>
という感じです。</p>
これらに加えて、こういう企業にありがちな特徴としては、</p>

</blockquote>
Web系Sier スタートアップ　ベンチャー　中小</p>
自社サービス スタートアップ ベンチャー　中小</p>
元請けSier</p>
このような属性の企業が多い気はしています。

ただ、SESとかでもホワイトなところであれば、</strong>

上記の条件は普通にクリアしているはずなので、</strong>

そういうSESなら全然ありです。</strong></p>
逆にWeb系Sierとかでも、

上記の条件をクリアしていないとちょっと警戒したほうが良いです。</p>
ちなみに、すでに言いました、

ツイートのやばい企業は、

Web系Sierなので、属性だけ見ると、

良さげに見えます(それがまた、たちが悪い)</p>
未経験の人は、どういうわけか、

自社サービスとかWeb系に行きたがるような印象がありますが、

それ以外にも優良企業はたくさんあるので、</strong>

幅広く探したほうが良いのかなと思います。</strong></p>
上記に加えて、mustではないけど、

満たしていると更に高評価の条件は、</p>

</blockquote>
技術力が高いエンジニアがいる</p>
コードレビュー文化がある(あ、これは割とmustかも...)</p>
資格を評価してくれる(自社サービスとかは評価されないことがほとんどなので一概には言えない)</p>
いろんな業務を任せてくれる(裁量権が大きい的な？)</p>
私服OKとかリモートワーク可(これとその企業が柔軟な思考かってある程度比例する印象があるので、業種によってはできない場合もあるので、これも一概には言えない。少なくとも業種的にも業務的にもリモートワークとか私服OKのはずなのに、古くからの慣習で頑なに認めないような企業は風通しが悪いので避けたほうが無難かと思います)</p>
という感じですかね。</p>
ブラック企業の特徴</h3>
これに対して、未経験の人が遭遇しやすい

ブラック企業はどういう属性かと言うと、</p>

</blockquote>
開発ができますで釣るが、入社したら違う業務をやらされる</p>
ツイートの記事の無給のような、法律違反を平気でする企業</p>
残業がやたらと多い(月40時間を超える頻度が多すぎるなど)</p>
パワハラ・モラハラ体質の社員が多い</p>
敬語文化がない</p>
社長が非エンジニアだったりと、エンジニアへの理解がない(これだけだと必ずしもブラックではないが、これに加えて社長が横柄とかだと、ブラック企業になりやすい印象)</p>
基本的に社員のことを考えていない。採用リスクを負わない (例 未経験は無給で雇う。未経験は資格を２つ取ってからじゃないと採用しない。案件がないと給料を払わないなど。SESとかに多い印象です...)</p>
まあ、面接とかで違和感を感じたら、</strong>

そこには行かないほうが良いと思います。</strong></p>
特にSESとかは、ブラック企業が比較的多いので、

SESを受けるときはちょっと警戒するぐらいがちょうどいいかもしれません。

(ホワイトSESもあるので、SES自体が悪いということではありません)</p>
おすすめの転職エージェントや転職サービス</h2>
さて、ここまで優良企業、ブラック企業の特徴を解説しましたが、

結局どうやってそういう企業を探せばいいの？ってなると思うので、

おすすめの転職エージェントやサービスをいくつかご紹介します。</p>
基本的に、転職エージェントと提携しているっていうことは、

その企業はそこにコストを掛けられるっていうことでしょうから、

所謂、超零細ブラックみたいな企業は、転職エージェントを使うだけでも

避けられるかもしれません(絶対の保証はもちろんないのですが...)</p>
レバテックキャリア</h3>



  
</a>
まずは、有名どころのレバテックキャリアです。

私も実際に利用したことがあるので、

分かるのですが、ここはどちらかと言うと、

そこそこ経験がある人向けなのかなという印象です。</p>
実務1年ぐらいでも、紹介はしてくれると思いますが、

それだと、必ずしも良い案件を紹介してくれるか微妙な気がしたので、

実務3年ぐらいある人向けのエージェントかなという印象です。</p>
また、担当者によっては、高圧的な人もいて、

苦手という評判も聞きましたが、

私が使ったときは全然そんなことなく、

他のエージェントに比べても、

多めにフィードバックをしてくれて

結構参考になりました。</p>
履歴書や職務経歴書の添削はもちろん、

志望度が高い企業の面接は別途、

前日とかに、こういう質問にはこのように答えておいたほうが良いとか、

こういう人はお見送りになりやすいみたいな、

細かいポイントも教えてくれたので、

個人的には結構良かったなと思いました。</p>
複数使うエージェントの一つに組み入れても良いのではないでしょうか。</p>
クラウドリンク</h3>



  
</a>
次はクラウドリンクです。

レバテックキャリアに比べると、

やや知名度は劣るかもしれませんが、

こちらもおすすめです。</p>
こちらは特に自社開発系の企業に進みたい人に

マッチするかと思います。</p>
自社開発系の求人が多くある印象です。

一方で、未経験や微経験だと、

場合によっては求人を紹介してもらえないこともあるようなので、

経験者向けのエージェントといえるでしょう。</p>
自社開発系の企業に転職したい現役エンジニアの方にはおすすめです。</p>
一方で、自社開発に興味がない人には、

求人のほとんどが自社内開発系になるので、

他のエージェントを使用したほうが無難かと思います。</p>
Tech Stars Agent</h3>



  
</a>
エージェントと言うと、

広く浅くいろんな業界に強いみたいなタイプもありますが、

もちろん特化型もありまして、

こちらは、エンジニア特化型なので、

エンジニア転職しか興味ない人には、

強くおすすめできます。</p>
それも、より上のエンジニアを目指したい人にマッチするエージェントになるかと思うので、

技術志向が強い人にはマッチするかもしれません</p>
エンジニア転職についての専門的な知識を有し、

特化型ということもあり、より上のエンジニアを目指したい、

現役エンジニアの方には強くおすすめできます。

特にコンサルタントは、業界経験者や、

エンジニアの実務経験がある人だったりするので、

他のエージェントに比べ、圧倒的に話が通じやすいというのは

大きなメリットです。エンジニア特有の悩みとかも相談できると思います。</p>
また、ゲーム業界などにも強みがあるので、

そこらへんへの転職を狙っている人にもうってつけかもしれません。</p>
パッと聞いた感じ、

未経験お断りのような感じもしますが、

実際に使用したユーザーの評判とかを見ると、

未経験の人も結構利用しているようなので、

エンジニア転職を目指している人であれば、

情報収集がてら利用してみるのもいいのかもしれません。</p>
大手のエージェントに比べると、

やや求人数は劣るかもしれませんので、

レバテックキャリアなどと並行して使用するのがベストかもしれません。</p>
UZUZ（ウズウズ)</h3>



  
</a>
比較的経験者向けのエージェントが続きましたが、

こちらのUZUZは、20代ならOKという、

未経験やポテンシャル枠向けのエージェントです。</p>
現在フリーターとかの方でも、

エージェントがほしいという方に強くおすすめできます。</p>
特に未経験の就活は、苦戦しやすいので、

このようなエージェントを利用するだけで、

かなり情報量の意味でも有利になると思うので、

おすすめです。</p>
キッカケエージェント</h3>



  
</a>
こちらは、キャリア系インフルエンサーのモローさんで有名な

エージェントです。</p>
実際に私も利用したことがあるのですが、

ここは、他のエージェントとはちょっと特殊で、

少数の企業にアタックしていくような感じでした。</p>
なので、よくある、とりあえずたくさんいろんな企業に応募していくというスタイルではありません。

いろんな企業に応募してしまうと、鬼のようにお見送りになったり、

自分が行きたい企業とかがぼやけてしまいがちなので、

的確な戦略だなと思いました。</p>
また、こちらで紹介してもらった企業は、

基本的にBizの視点が要求されるなという印象で、

ただ技術力を伸ばしたいと言うよりも、

プロダクト開発の視点とかも養っていきたいような人に、

相性が良いエージェントだなと感じました。</p>
アクシスコンサルティング</h3>



  
</a>
アクシスコンサルティングは、ハイクラス向けのエージェントで、

コンサルとかを目指している方向けのエージェントです。</p>
エンジニアから、外資コンサルとかを見据えているような、

ハイクラス向けのエージェントとしておすすめです。</p>
特にアクシスコンサルティングは、

未経験からコンサルを目指したい人にもおすすめできる

エージェントで、キャリアアドバイザーも話しやすいという評判を

しばしば聞きますので、異業種からコンサルを目指したい人にはうってつけかもしれません。</p>
一方で、コンサルの面接で重要である、

フェルミ推定とかの対策は、場合によっては、

十分に行ってもらえない（というかやらなくても大丈夫と判断される)こともあるようなので、

これらの対策に不安がある場合は、別途申し出ると良いかと思います。</p>
エンジニアからコンサルに転職すると、

大幅に年収が上がることも少ないと思うので、

コンサルへの転職を見据えている方は、一度

話を聞いてみるだけでも良いかもしれません。</p>


【Dockerネットワーク入門】DNSサーバーによるコンテナ名通信の仕組み
2023-11-27T00:00:00+00:00
本記事では、

Dockerのネットワークについて解説します。</p>
Dockerのネットワークは、

やや高度な話題なので、

正直基礎と言えるか微妙ではありましたが、

実務に入ると高確率で使うことが多いので、

取り上げます。</p>
Dockerの基礎については、

ある程度知っていることを前提に解説しますので、

Dockerの基礎が不安な方は、

こちらの記事</a>などもご参考ください。</p>
https://reisuta.com/docker-basic/</p>
Dockerネットワークの種類</h2>
Dockerネットワークはコンテナ間の通信を管理し、

異なる環境や要件に応じて柔軟な設定を可能にします。</p>
以下では、主要なネットワークタイプの概要とその利用例、メリットとデメリットを説明します。</p>
docker network ls</h3>
現在利用可能なDockerネットワークの一覧を表示するには、docker network lsコマンドを使用します。

これにより、bridge、host、noneなどのデフォルトネットワークと、カスタムで作成されたネットワークが表示されます</strong></p>
docker network ls</span></span></code></pre>bridgeネットワーク</h3>
Dockerのデフォルトネットワークタイプです。

異なるコンテナが同じbridgeネットワークに属している場合、

互いに通信できます。</p>
メリットは、シンプルで理解しやすいことで、

後で詳しく触れますが、

コンテナ名での通信など、</mark>

異なるコンテナ間の分離を保ちつつ通信を許可してくれます。</mark></p>
デメリットは、パフォーマンスの観点から、

大規模なアプリケーションには適していない場合があるという感じでしょうか。

NATの処理が重くなってしまったり、多数のコンテナが同じbridgeネットワークを共有する場合は、

ネットワーク帯域幅が飽和する可能性があるので、

大規模アプリケーションとかだとこの点がネックになることはありえるかもしれないですね。</p>
ちなみに、ネットワーク帯域幅は、一定時間内にネットワークを介して送受信できるデータの量を指します。

通常はMbps（メガビット毎秒）やGbps（ギガビット毎秒）で測定されるやつですね。

よく光回線の速度とかで計測している、あれです。</p>
https://fast.com/ja/#</a></p>
brigeネットワークが、

パフォーマンスに影響が出ていないかを

ピンポイントで特定するのは、

高度なトピックだと思うので、

詳細には触れませんが、こういうときに使えるものとして、</p>
docker stats</span></span></code></pre>
コマンドなどがあります。</p>
https://docs.docker.jp/engine/reference/commandline/stats.html</a></p>
また、MacOS自体のネットワークを監視したいときは、

nettopなども使えるかもしれません。</p>
nettop</span></span></code></pre>
ただ、上記のようなパフォーマンス上の懸念がないとはいえ、

デフォルトのネットワークであり、

おそらく一番使用頻度は多いかなと思います。</p>
なんかdocker重いなっていうときに、

上記のbridgeネットワークの特徴を思い出して、

チューニングするのが良いかなと思います。</p>
hostネットワーク</h3>
Dockerのhostネットワークモードでは、コンテナがホストマシンのネットワークスタックを直接使用します。

これにより、コンテナはホストと同じIPアドレスとポートを共有し、ネットワークのオーバーヘッドを回避することができます。</p>
docker run -d --name nginx --network host nginx</span></span></code></pre>
このコマンドにより、nginxコンテナはホストマシンと同じネットワークスタックを使用します。

これにより、ホストマシン上で利用可能なポートはコンテナから直接アクセス可能になります。</mark></p>
bridgeネットワークでは、コンテナはホストから分離されたネットワークスタックを持ち、

NATを通じて外部ネットワークと通信します。一方、hostネットワークでは、この分離がありません。</p>
またNATによる処理がないため、

hostネットワークはbridgeネットワークよりも高いパフォーマンスを提供できることが多いかと思います。</p>
ただ、デメリットとしては、コンテナとホストのネットワーク分離がないため、

悪意のあるコンテナがホストシステムに影響を与えるリスクが高まることや、

ホストのポートを直接使用するため、ポートの競合が発生しがちということでしょうか。</p>
hostネットワークだと、docker psとかを使ったときに、

PORTSが空になっていることがほとんどだと思います。</p>
まあ正直、そんなに頻繁に使うたぐいのものではない気もします。

ホストマシンのポートをそのまま使えるっていうのは、

dockerの仮想化のメリットが薄まってしまう気もするなと

個人的には感じるので。</p>
</p>
noneネットワーク</h3>
このネットワークは、コンテナにネットワーキング機能を提供しません。

こうなると、それはネットワークなのかというツッコミはさておき、

ネットワークから分離されるのでセキュリティが向上するのがメリットです。</p>
デメリットとしては非常にわかりやすいですが、

他のコンテナやサービスと通信できなくなります。</strong></p>
Dockerのnoneネットワークは、コンテナにネットワークインターフェースを割り当てず、

ネットワークの分離を最大限に行う設定なので、

コンテナが外部ネットワークや他のコンテナと通信することを完全に防ぎます。</p>
なので、noneネットワークの指定と、

ネットワーク設定を何もしない場合とは異なります。</strong></p>
ネットワーク設定を何も指定しない場合、Dockerはデフォルトでbridgeネットワークを使用します。

これは、Dockerが提供する標準的なネットワークで、コンテナ間の通信を可能にし、

ホストマシンとの間にも仮想ネットワークブリッジを作成します。

したがって、ネットワーク設定を何もしない場合、コンテナは外部ネットワークや他のコンテナと通信できる状態になります。</p>
対照的に、noneネットワークを明示的に指定すると、コンテナはネットワークから完全に切り離されます。

この設定は、コンテナが外部と通信する必要がない、

またはネットワーク分離を最大限にしたい特定のセキュリティが求められる環境で有用です。

この状態では、コンテナは自身のプロセスやファイルシステムにアクセスできますが、

外部のネットワークリソースにはアクセスできません。</p>
要するに、普段何もネットワーク設定していなくとも、

bridgeが設定されていたが、noneをすると、

明示的にネットワークに接続できなくするという感じですかね。</p>
コンテナのIPアドレスを確認する方法</h2>
DockerコンテナのIPアドレスを確認するには、複数の方法があります。

以下では、各方法をサンプルコードと共に解説します。</p>
コンテナ内でipやifconfigコマンドを使う</h3>
コンテナ内部から直接、ipやifconfigコマンドを使用してIPアドレスを確認することができます。</p>
# コンテナに入る</span></span>
docker exec -it [コンテナ名] bash</span></span>
</span>
# コンテナ内でIPアドレスを確認</span></span>
ip addr</span></span>
# または</span></span>
ifconfig</span></span></code></pre>
ただ、この方法は、

コンテナの種類によっては、

そもそもipコマンドやifconfigコマンドがなかったりすることもあるので、

いつでも使えるかというと微妙ではあります。</p>
nginxコンテナとかでは使えませんでした。</p>
docker container inspect</h3>
docker container inspectでコンテナの詳細情報を調べることができます。

これのNetworkSettingsを確認すると、IPアドレスがわかります。</p>
docker container inspect [コンテナ名]</span></span></code></pre>
このコマンドは、JSON形式で多くの情報を出力します。

その中からネットワーク関連の情報を見つけることができます。</p>
formatオプションで特定の項目だけ取得する</h4>
docker container inspectの出力から特定の情報だけを取得するためには、--formatオプションを使用します。

これにより、必要な情報だけを簡単に取得できます。</p>
docker container inspect --format '{{/* .NetworkSettings.IPAddress */}}' [コンテナ名]</span></span></code></pre>
このコマンドは、指定されたコンテナのIPアドレスのみを出力します。

おそらく、このやり方が一番合理的なのかなとは個人的には思います。</p>
docker network inspect bridge</h3>
docker network inspectコマンドを使用して、

特定のネットワーク（この場合はbridge）に接続されているコンテナの情報を確認できます。</p>
docker network inspect bridge</span></span></code></pre>
このコマンドは、bridgeネットワークに接続されているすべてのコンテナの詳細情報を提供します。</p>
IPマスカレードについて</h3>
IPアドレスに関連して、

IPマスカレードという技術がありますが、

そもそもIPマスカレードってなんだっけって私は最初なりました。</p>
IPマスカレードは、DockerホストのIPアドレスを使用してコンテナからのアウトバウンド接続を可能にする</mark>

NAT（ネットワークアドレス変換）の一形態です。</mark>

これにより、コンテナはDockerホストのIPアドレスを使用して外部と通信できます。</p>
うん？どういうことって感じだと思うので、

IPマスカレードの例えを出してみます。</p>
アパートの部屋をコンテナとし、そこに一つの大きな郵便受けがあるとして、

それをDockerホストとします。</p>
アパートの部屋（コンテナ）から手紙（データパケット）を送るとき、

部屋から出た手紙はまずアパートの郵便受けに集められ、そこから外部の世界（インターネット）に送られます。

この手紙はアパートの住所（DockerホストのIPアドレス）でマークされます。

つまり、外部の世界では、この手紙がどの部屋から来たのかはわかりません。</p>
これに対して、手紙がアパートに戻ってくるときは、郵便受け（Dockerホスト）に届いた手紙は、

どの部屋（コンテナ）宛てであるかに基づいて適切な部屋に配達されます。</p>
このように、DockerのIPマスカレードは、

コンテナから外部への通信がDockerホストを介して行われることを意味します。

コンテナ自身のIPアドレスは外部には露見せず、外部から見るとすべての通信がDockerホストから来ているように見えることです。</p>
この設定は特にbridgeネットワークで重要であり、

コンテナがDockerホストを介して外部ネットワークと通信する際に用いられます。

このプロセスは自動的に行われるため、ユーザーが手動で設定する必要はありません。</p>
これらの方法を使用して、DockerコンテナのIPアドレスとネットワーク設定を効率的に確認し、管理することができます。

これにより、ネットワークのトラブルシューティングや構成の最適化が容易になります。</p>
NATって何だっけ？</h4>
そもそも、NATって何だっけ？

ネットワークまじよくわからん。</p>
っていう感じの人もいるかもしれないので、

一応補足します。(というか私が最初そうだった)</p>
NAT（ネットワークアドレス変換）は、インターネットネットワーキングの重要な概念で、

一つのネットワークアドレスを別のアドレスに変換する技術です。

この技術により、複数のデバイスが一つのIPアドレスを共有してインターネットにアクセスすることが可能になります。</p>
NATの基本的な役割は、プライベートIPアドレス（ローカルネットワーク内で使用されるアドレス）を</mark>

公共IPアドレス（インターネット上で一意のアドレス）に変換することです</mark>。

これにより、ネットワーク内の多くのデバイスが、一つの公共IPアドレスを共有してインターネットに接続できます。</p>
例えば、自宅やオフィスのルーターがNATを使用しています。

複数のコンピューター、スマートフォン、タブレットなどがローカルネットワークに接続されている場合、

これらのデバイスはプライベートIPアドレスを持ちます。</p>
インターネットにアクセスする際、ルーターがこれらのプライベートIPアドレスをルーター自身の公共IPアドレスに変換します。

インターネットから見ると、これらのリクエストはすべて同じ公共IPアドレスから来ているように見えます。</p>
IPアドレスでのコンテナ間の通信</h2>
Dockerコンテナ間でIPアドレスを用いた通信は、ネットワークの基本的な操作です。

ここでは、異なるNginxコンテナを2つ立てて、それらの間で通信する方法をサンプルコードを交えて解説します。</p>
ipコマンドでIPアドレスを確認</h3>
まず、2つのNginxコンテナを立てます。</p>
# Nginxコンテナ1の作成</span></span>
docker run -d --name nginx1 nginx</span></span>
</span>
# Nginxコンテナ2の作成</span></span>
docker run -d --name nginx2 nginx</span></span></code></pre>
次に、これらのコンテナのIPアドレスを確認します。

docker container inspectコマンドを使用して、各コンテナのIPアドレスを取得します。</p>
# Nginxコンテナ1のIPアドレスを取得</span></span>
docker container inspect -f '{{/*range .NetworkSettings.Networks*/}}{{/*.IPAddress*/}}{{/*end*/}}' nginx1</span></span>
</span>
# Nginxコンテナ2のIPアドレスを取得</span></span>
docker container inspect -f '{{/*range .NetworkSettings.Networks*/}}{{/*.IPAddress*/}}{{/*end*/}}' nginx2</span></span></code></pre>pingコマンドの基本的な使い方</h3>
IPアドレスでのコンテナ間での疎通に際し、

pingコマンドを使うのですが、意外とpingって、

使い方忘れがちな気がするので、おさらいも兼ねて、

軽く概要を説明しておきます。</p>
pingコマンドは、ネットワーク上の他のコンピューターやデバイスとの接続を確認するために使用されるコマンドです。

このコマンドは、インターネットプロトコル（IP）アドレスまたはホスト名を指定して、そのデバイスへの接続をテストします。</p>
よく使うオプションとしては、-c(回数)や-t(応答を待つ最大時間)などがあげられます</p>
ping -c 4 google.com # 4回送信する</span></span>
ping -t 10 google.com  # 10秒待つ</span></span></code></pre>自分のルーターにpingを送信する</h4>
pingの活用例として、

自分のルーターにpingを送って、

ネットワークの遅延(レイテンシ)を測定してみましょう。</p>
まず、macで自分のルーターのIPアドレスを調べるには、</p>
netstat -nr | grep default</span></span></code></pre>
を実行して表示されたIPアドレスです。</p>
早速おくります。</p>
ping ルーターのipアドレス</span></span></code></pre>
だいたい、1ms-30msぐらいなら、

良い応答時間かと思います。</p>
pingで疎通する</h3>
取得したIPアドレスを使用して、コンテナ間の疎通を確認します。

docker execコマンドを使用して、一方のコンテナから他方のコンテナへのpingテストを実行します。</p>
# Nginx1からNginx2へのpingテスト</span></span>
docker exec nginx1 ping -c 4 [Nginx2のIPアドレス]</span></span>
</span>
# Nginx2からNginx1へのpingテスト</span></span>
docker exec nginx2 ping -c 4 [Nginx1のIPアドレス]</span></span></code></pre>curlでコンテンツが取得できるか</h3>
最後に、curlコマンドを使用して、

一方のコンテナが他方のコンテナのWebサービス（Nginx）にアクセスできるかを確認します。</p>
# Nginx1からNginx2のWebページを取得</span></span>
docker exec nginx1 curl [Nginx2のIPアドレス]</span></span>
</span>
# Nginx2からNginx1のWebページを取得</span></span>
docker exec nginx2 curl [Nginx1のIPアドレス]</span></span></code></pre>コンテナ名でのコンテナ間通信</h2>
dockerでは、コンテナ間での通信を容易にするためにコンテナ名を利用できます。

ここでは、nginxコンテナを例に、コンテナ名を使用した通信方法とそれに関連するオプションについて説明します。</p>
linkオプション</h3>
linkオプションは、一方のコンテナを別のコンテナにリンクするために使用されます。

これにより、リンクされたコンテナは、他のコンテナの名前で通信できるようになります。</p>
# Nginxコンテナ1を作成</span></span>
docker run -d --name nginx1 nginx</span></span>
</span>
# Nginxコンテナ2を作成し、nginx1にリンクする</span></span>
docker run -d --name nginx2 --link nginx1 nginx</span></span></code></pre>/etc /hostsが書き換わる</h4>
linkオプションを使用すると、リンクされたコンテナの/etc/hostsファイルが自動的に更新され、

リンク先のコンテナ名とIPアドレスが追加されます。これにより、コンテナ名での通信が可能になります。</p>
docker network create</h3>
Dockerでは、カスタムネットワークを作成してコンテナ間の通信を管理することができます。

カスタムネットワーク内では、コンテナは互いの名前で直接通信できます。</strong></p>
# カスタムネットワークを作成</span></span>
docker network create my-network</span></span>
</span>
# Nginxコンテナをカスタムネットワークに接続</span></span>
docker run -d --name nginx1 --network my-network nginx</span></span>
docker run -d --name nginx2 --network my-network nginx</span></span></code></pre>
--network（または-net）オプションを使用して、コンテナが接続するネットワークを指定できます。

カスタムネットワークを使用すると、コンテナ名での通信が簡単になります。</p>
connectとdisconnectコマンド</h3>
既存のコンテナをネットワークに接続したり、

ネットワークから切断したりするためにdocker network connectおよびdocker network disconnectコマンドを使用できます。</p>
# コンテナをカスタムネットワークに接続</span></span>
docker network connect my-network nginx1</span></span>
</span>
# コンテナをネットワークから切断</span></span>
docker network disconnect my-network nginx1</span></span></code></pre>Dockerネットワークでのコンテナ名での通信の仕組み</h2>
Dockerネットワークでは、コンテナ間の通信にコンテナ名を使用することができることがわかりました。

この機能の背後には、Dockerの内部DNSサーバーと特定の設定ファイルが関与しています。</p>
DNSサーバーが使われている</h3>
Dockerでは、デフォルトで内部DNSサーバーが組み込まれており、これがコンテナ間の名前解決を担当します。

Dockerネットワーク内では、各コンテナはそのコンテナ名でアクセス可能です。

この内部DNSサーバーによって、コンテナ名が対応するIPアドレスに変換され、コンテナ間での通信が実現されます。</p>
Dockerのデフォルトの内部DNSサーバーを確認する方法は、

実際にコンテナ内でネットワーク関連の設定を調べることになります。

具体的には、コンテナ内の/etc/resolv.confファイルを確認することで、

どのDNSサーバーが使用されているかを見ることができます。</p>
/ etc/resolve.confとは</h3>
/etc/resolv.confは、UNIX系オペレーティングシステムにおいてDNSサーバーの設定を管理するファイルです。

Dockerコンテナ内でも、このファイルがDNS解決のための設定情報を持っています。

Dockerはコンテナを起動する際に、このファイルに適切なDNS設定を自動的に注入します。</p>
そもそもDNSってなんだっっけ？</h3>
DNS（ドメインネームシステム）は、

インターネット上のリソースに対応するIPアドレスを人間が読みやすいドメイン名（例：www.example.com）

に変換するためのシステムです。

DNSサーバーは、これらのドメイン名をIPアドレスに変換する役割を担っています。

このプロセスにより、ユーザーはウェブブラウザなどで直接IPアドレスを入力する代わりに、

覚えやすいドメイン名を使用してインターネット上のリソースにアクセスできます。</p>


  
  
    
  </div>
  
  
    さわって学ぶクラウドインフラ　docker基礎からのコンテナ構築【電子書籍】[ 大澤 文孝 ]</p>
    

      Amazonで見る</a>
      楽天市場で見る</a>
    </div>
  </div>
</div>


  
  
    
  </div>
  
  
    Docker実践ガイド第2版 コンテナ環境の構築・運用・活用 （impress　top　gear） [ 古賀政純 ]</p>
    
      Amazonで見る</a>
      楽天市場で見る</a>
    </div>
  </div>
</div>


【Nginx入門】Docker/NginxでのWebサーバー構築とSSL設定
2023-11-20T00:00:00+00:00
Webサーバーに対する知識は、

Webエンジニアの必須教養のはずですが、

意外と実務で触れる機会は少なかったりします。</p>
特にnginxなどは、

慣れていないとかなり戸惑うと思いますし、

苦手意識をいだきやすいかもしれません(私がそうでした。)</p>
しかし、なんだかんだで、

本番環境のWebサーバとして、</mark>

Nginxが使われている現場は多い印象</mark>があり、

場合によっては、非インフラエンジニアも、

このNginxの知識が必要になったりする場面もあるかと思います。</p>
そこで本記事では、

今更聞けないNginxの基礎から、SSL(自己署名証明書)設定をして、

Hello worldを表示するWebサーバー構築を行いたいと思います。</p>
Nginxは、インフラ設定をする際には、

かなりの確率で触ることになると思うので、

ぜひとも習熟したいところですよね。</p>
Nginxとは</h2>
Nginxは、高性能かつ軽量なウェブサーバーで、

特に大規模なウェブアプリケーションや高トラフィック環境での使用に適しています。</p>
その特徴の一つが、イベント駆動型アーキテクチャ</mark>です。</p>
Nginxのイベント駆動型アーキテクチャは、高性能かつ効率的なWebサーバーとしての性能を実現するための重要な要素です。

このアーキテクチャを理解するために、いくつかの基本的な概念を明確にする必要があります。</p>
イベント駆動型アーキテクチャ</h3>
Nginxの核心となるのは、イベント駆動型アーキテクチャです。

この設計により、Nginxは多数のリクエストを同時に効率的に処理できます。

従来のスレッドベースのアプローチと異なり、リソースの消費が少なく、スケーラビリティが高いのが特徴です。</p>
通常のプログラムは、main関数から開始され、特定の順序で関数が呼び出されます。

しかし、イベント駆動アーキテクチャでは、プログラムの主要な流れはイベント

（例えば、クライアントからの接続要求やファイルへのアクセス要求など）によって駆動されます。</p>
JavaScriptとかでのクリックイベントとかをイメージするとわかりやすいと思います。

JavaScriptでクリックすると、そのclickイベントによってコールバック関数が呼ばれると思いますが、

Nginxでもそういったアーキテクチャが採用されているという感じです。</p>
Nginxでのイベントは、

上記でも触れましたが、クライアントからの接続要求などがあたります。</p>
Nginxでは、これらのイベントが発生すると、

それに対応するコールバック関数（イベントリスナー）が呼び出されることによって処理が進行します。

これにより、非常に効率的でスケーラブルな処理が可能になります。</p>
ノンブロッキングI/O:</h4>
ブロッキングI/Oでは、ファイルやネットワークリソースへのアクセスが完了するまで

プログラムの実行が停止（ブロック）されます。</p>
これに対して、ノンブロッキングI/Oでは、リソースが利用可能になるまで待たずに、

即座にエラーを返すなどして、プログラムの実行を続けることができます。

Nginxでは、このノンブロッキングI/Oを利用することで、プログラムの並行性を高め、効率的なリソース利用が可能になります。</p>
I/Oとは？</h4>
そもそも、I/Oって何かっていうと、

I/O（Input/Output、入出力)のことで、

コンピューターや電子機器において、データや信号の入力と出力のプロセスを指しています。</p>
具体的には、コンピューターシステムが外部の装置や他のシステムからデータを受け取る（入力）ことと、

それらにデータを送る（出力）ことを意味します。</p>
I/Oとして同期I/Oと非同期I/Oの二つがあり、

同期I/O（ブロッキングI/O）は、

データの送受信が完了するまで他の処理は待機します。

I/O処理が始まると、他の処理は一時的に停止し、送受信が完了してから他の処理が再開されます。</p>
これに対して、非同期I/O（ノンブロッキングI/O）は、

データの送受信が完了するのを待たずに他の処理を進めることができます。

I/O処理と並行して他の処理を進めることができ、送受信が必要な処理にたどり着いた時点で、その完了を待ちます。</p>
Nginxの場合、ノンブロッキングI/Oとして、

即座にエラーを返してブロックされるのを防ぐため、

厳密には非同期I/OとノンブロッキングI/Oは、

同義ではないかなと思います。</p>
https://e-words.jp/w/I-O.html#:~:text=</a></p>
非同期I/Oは、データの入出力が可能になった時点で通知されるI/Oモデルです。

これにより、通知が来るまでアプリケーションは他の処理を進めることができます。

これに対して、ノンブロッキングI/Oでは、I/O対象のファイルディスクリプタが準備完了していない場合、

アプリケーションに即座にエラーが返されます。

https://ryuichi1208.hateblo.jp/entry/2020/02/19/215155#:~:text=</a></p>
これにより、プロセスがI/O操作の完了を待つことなく、他のタスクに切り替えられるということです。</p>
正直、この辺の厳密な違いは、かなり細かいかつ、

とりあえずNginxを使うレベルであれば、

不要な知識のような気もしますが念のため...</p>
まあ、何が言いたいかというと、

Nginxは、こういったノンブロッキングI/Oや非同期I/Oを採用しているので、</mark>

並行性が高く、効率的だということです。</mark></p>
マスタープロセスとワーカープロセスのマルチプロセス構成</h4>
Nginxは、一つのマスタープロセスと複数のワーカープロセスで構成されています。

マスタープロセスは設定の読み込みや全体の管理を担い、ワーカープロセスが実際のリクエストの処理を行います。

この構成により、複数のプロセスが並行して動作し、高いパフォーマンスと信頼性を実現します。</p>
これについては、

下記の記事がわかりやすかったです。</p>
https://qiita.com/kamihork/items/296ee689a8d48c2bebcd#%E3%83%97%E3%83%AD%E3%82%BB%E3%82%B9%E3%81%AE%E4%BB%95%E7%B5%84%E3%81%BF</a></p>
Nginx以外のWebサーバー</h3>
さて、ここまでNginxの特徴を見てきましたが、

抽象的な話が続いたので、結局Nginxってすごいの？ってなるかと思います。</p>
Webサーバとしては、

他にもApache、IIS、Lighttpdなどのウェブサーバーが存在します。</p>
試しに、有名なApacheと軽く比較考察してみます。</p>
Apacheのアーキテクチャとして、主に「Multi Processing Module (MPM)」が採用されています。

これは、Apacheの処理モデルを定義するもので、ApacheにはいくつかのMPMが存在します。

主要なMPMとして「prefork」「worker」「event」があります。</p>
例えば、Prefork MPMは、Apacheが古くから使用している方式で、

基本的には1つのプロセスが1つのスレッドを持つシングルスレッドプロセスモデルを採用しています。

この方式では、各httpdプロセスが1つのCPUコアを使用してリクエストを処理します。

トラフィックが増加すると、システムは新しいプロセスを生成（fork）してリクエストを処理します。</p>
他のWorker MPMでは、1つのプロセスが複数のスレッドを持つ「マルチスレッドプロセス」方式を採用しています。

これにより、より少ないプロセス数で多くのリクエストを同時に処理することが可能になります。</p>
本記事は、Apacheの記事ではないので、

Apacheの詳細はこれぐらいにしておきます。

MPMの解説は、下記の記事がわかりやすかったです。</p>
https://milestone-of-se.nesuke.com/sv-basic/linux-basic/apache-mpm-prefork-worker-event/</a></p>
Apacheと比較したNginxの強み</h4>
Nginxは、その高いパフォーマンス、低リソース消費、設定のしやすさにより、

多くの開発者に選ばれています。</p>
また、静的コンテンツの配信、ロードバランシング、キャッシュ機能、

リバースプロキシとしての使用など、様々な機能を提供します。</p>
Apacheの先述のアーキテクチャとNginxを比較すると、

Nginxのイベント駆動型およびノンブロッキングI/Oアーキテクチャが、</mark>

特に同時大量アクセスの処理において優れていることがわかります。</mark></p>
Prefork MPMのようなシングルスレッドプロセスモデルでは、

大量の同時リクエストに対応するために多くのプロセスを生成する必要があり、これはメモリとCPUリソースの大きな消費につながります。

一方で、Nginxのモデルでは、少数のワーカープロセスで多数の接続を非同期に処理することができ、

リソース消費を大幅に抑えることが可能です。</p>
その結果、Nginxは高トラフィックの環境においてApacheよりも高いスケーラビリティと効率を提供します。

また、静的コンテンツの配信においてもApacheより高速なレスポンスが期待できます。</p>
NginxとDockerでWEBサーバーを構築</h2>
Dockerを使わずに、

nginxのソースコードをダウンロードして、

zlibとか必要ライブラリをインストールして、

./configureして、

makeして、make installという、

あの例の儀式を行って環境構築するのも勉強になって、

それはそれでいいのですが、今回は大変なので

Dockerで済ませます...</p>
Dockerを利用することで、環境に依存せず、

一貫した方法でNginxサーバーを構築できますよね。</p>
DockerでNginxコンテナを作成する</h3>
以下は、Dockerを用いてNginxコンテナを作成し起動する基本的なコマンドです。

nginxのコンテナ</a>を引っ張って、立ち上げているだけですね。

(Dockerはインストールされているものとする)</p>
docker</span> pull nginx</span></span>
docker</span> run</span> --name</span> my-nginx</span> -p</span> 80:80</span> -d</span> nginx</span></span></code></pre>
というか、runの実行時に、

ローカルにnginxイメージがなければ、

取得してくれるので、ぶっちゃけ、</p>
docker run --name my-nginx -p 8080:80 -d nginx</span></span></code></pre>
だけでも大丈夫です。</p>
--name my-nginxは、起動するコンテナに「my-nginx」という名前を割り当てていて、

-p 8080:80は、ローカルマシンの8080ポートをコンテナの80ポートにマッピングしています。

つまり、ローカルマシンの8080ポートへのリクエストは、コンテナの80ポートに転送されるという感じです。</p>
-dはコンテナをデタッチモード（バックグラウンドモード）で実行し、

最後のnginxは、イメージの名前です。Docker Hubにあるnginx公式イメージですね。</p>
Dockerじゃなくて、

普通にnginxをインストールしたら、

systemctl start nginx的な感じで、

startさせる必要がありますが、

Dockerコンテナの場合、コンテナを起動すれば、

立ち上がっています。</p>
なので、この状態で、localhost:8080に

アクセスすれば、下記のようなページになっているはずです。</p>
</p>
ちなみに、Dockerの基本的な操作とか概念については、

こちらの記事</a>で解説しているので、

よろしければご参考ください。</p>

</blockquote>
hello world画面を表示する</h3>
さて、DockerでNginxを起動したので、簡単なHTMLページを表示する手順を説明します。

とりあえず、何でもいいのですが、適当なHTMLファイルを作ります。ローカルに保存して大丈夫です</p>
<!</span>DOCTYPE</span> html</span>></span></span>
<</span>html</span>></span></span>
<</span>head</span>></span></span>
  <</span>title</span>>Hello World</</span>title</span>></span></span>
</</span>head</span>></span></span>
<</span>body</span>></span></span>
  <</span>h1</span>>Hello World!</</span>h1</span>></span></span>
</</span>body</span>></span></span>
</</span>html</span>></span></span></code></pre>
さて、ローカルにこんな感じで、

適当なHTMLファイルを作ったら、

それをNginxコンテナに渡して上げる必要があるので、

ここではdocker cpを使います。</p>
docker cp index.html my-nginx:/usr/share/nginx/html/index.html</span></span></code></pre>
このコマンドは、index.htmlをmy-nginxコンテナの、

/usr/share/nginx/html/index.htmlにコピーするコマンドです。</p>
一応、これでもうHello Worldは表示されているはずです。</p>
</p>
ただ、なぜこのコマンドで表示されるのかが、

まだ不可解なので解説します。</p>
まず、Nginxの設定ファイルは、デフォルトだと、

/etc/nginx/nginx.confになります。</p>
このファイルの中身を見てみましょう。

まずコンテナに入りましょう。</p>
docker exec -it my-nginx /bin/bash</span></span></code></pre>
コンテナに入ったら、/etc/nginx/nginx.confを見てみましょう。</p>
user</span>  nginx</span>;</span></span>
worker_processes</span>  auto</span>;</span></span>
</span>
error_log</span>  /var/log/nginx/error.log notice</span>;</span></span>
pid</span>        /var/run/nginx.pid</span>;</span></span>
</span>
events</span> {</span></span>
    worker_connections</span>  1024</span>;</span></span>
}</span></span>
</span>
http</span> {</span></span>
    include</span>       /etc/nginx/mime.types</span>;</span></span>
    default_type</span>  application/octet-stream</span>;</span></span>
</span>
    log_format</span>  main  '$remote_addr - $remote_user [$time_local] "$request" '</span></span>
                      '$status $body_bytes_sent "$http_referer" '</span></span>
                      '"$http_user_agent" "$http_x_forwarded_for"'</span>;</span></span>
</span>
    access_log</span>  /var/log/nginx/access.log  main</span>;</span></span>
</span>
    sendfile</span>        on</span>;</span></span>
    #tcp_nopush     on;</span></span>
</span>
    keepalive_timeout</span>  65</span>;</span></span>
</span>
    #gzip  on;</span></span>
</span>
    include</span> /etc/nginx/conf.d/</span>*</span>.conf</span>;</span></span>
}</span></span></code></pre>
ここで注目したいのは、一番最後の、

include /etc/nginx/conf.d/*.confの部分ですね。</mark>

これは、conf.d以下の末尾が.confの設定を読み込むという記述です。</mark></p>
試しに、conf.d以下をlsしてみると、

default.confというファイルがあるはずです。

そこの設定が読み込まれているというわけです。</p>
server {</span></span>
    listen       80;</span></span>
    listen  [::]:80;</span></span>
    server_name  localhost;</span></span>
</span>
    #access_log  /var/log/nginx/host.access.log  main;</span></span>
</span>
    location / {</span></span>
        root   /usr/share/nginx/html;</span></span>
        index  index.html index.htm;</span></span>
    }</span></span>
</span>
    #error_page  404              /404.html;</span></span>
</span>
    # redirect server error pages to the static page /50x.html</span></span>
    #</span></span>
    error_page   500 502 503 504  /50x.html;</span></span>
    location = /50x.html {</span></span>
        root   /usr/share/nginx/html;</span></span>
    }</span></span>
</span>
以下省略</span></span>
  }</span></span></code></pre>
ここの設定を見ると、

root /usr/share/nginx/htmlという部分があると思います。</strong>

すなわち、ここで表示するhtmlのディレクトリを設定していたという感じです。</strong></p>
これにより、先程のdocker cpコマンドで

hello worldが表示されるようになったという感じです。</p>
ちなみに、docker cpのようなホストPCとコンテナのデータ共有(主にボリューム周り)

については、下記の記事</a>で詳しく解説しているので、

良ければご参考ください。</p>
[st-card myclass="st-no-shadow" id="2130" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
SSL設定</h2>
※書く順番を間違えてしまったのですが、

OS再起動が挟まるかもしれない関係で、先に最後のホストファイルの編集をやってから、</strong>

こちらのSSL設定をしたほうが、余計な修正が出なくていいかもしれません。</strong></p>
Nginxを使うときは、

SSLの設定をすることも多いと思うので、

それについても紹介します。</p>
ちなみにこのあとからは、

ポートが80ではなく、443になるので、

dockerのポートも変更しておきます。

(私はこれを忘れて結構はまりました)</p>
docker run --name my-nginx -p 443:443 -d nginx</span></span></code></pre>SSL証明書とは</h3>
SSL証明書は、ウェブサーバーの身元を認証し、データの暗号化を可能にするデジタル証明書です。

証明書は、信頼できる第三者機関（CA）によって発行されます。

開発環境やテスト環境なら、opensslで生成した自己署名証明書で良いかと思います。</p>
これは公的な認証局（CA）によって発行された証明書ではないため、

一般のウェブサイトでの使用には適していません。

ブラウザはこれらの証明書を信頼せず、訪問者にセキュリティ警告を表示します。</p>
なので、あくまで開発環境など向けにはなります。</p>
OpenSSLとは</h3>
OpenSSLは、主に暗号化およびセキュリティ関連の機能を提供するもので、

SSLおよびTLSプロトコルの実装で最も広く使用され、

インターネット上でのデータ通信のセキュリティを強化するために重要な役割を果たしています。</p>
主な機能としては、</p>
[st-mybox title="ポイント" webicon="st-svg-check-circle" color="#757575" bordercolor="#BDBDBD" bgcolor="#ffffff" borderwidth="2" borderradius="5" titleweight="bold" fontsize="" myclass="st-mybox-class" margin="25px 0 25px 0"]</p>

SSL/TLSプロトコルの実装</li>
暗号化アルゴリズムの提供</li>
デジタル証明書の管理</li>
暗号化キーの生成と管理</li>
</ul>
などがあげられます。</p>
一番、よく使うのが、

やはり本記事での使用のような、

SSL設定ですが、文書の暗号化とか、

SSHの鍵生成みたいな使い方もできるので、

割となんでもツールみたいな側面はあるかもしれません。</p>
OpenSSLでの自己署名証明書の生成</h3>
最初に秘密鍵を生成します。これはSSL証明書の暗号化と復号に使用されます。

下記のコマンドは、2048ビットのRSA秘密鍵を生成し、その鍵を "sample-nginx.key" という名前のファイルに保存します。

genrsaは、RSA秘密鍵を生成するという感じです。</p>
openssl genrsa -out sample-nginx.key 2048</span></span></code></pre>
次に、CSR（証明書署名リクエスト）の作成を行います。

CSRは、証明書の発行を認証局にリクエストする際に使用されるファイルです。

自己署名証明書の場合、このステップでは証明書の詳細（ドメイン名、組織名など）を含めます。</p>
openssl req -new -key sample-nginx.key -out sample-nginx.csr</span></span></code></pre>
既存の秘密鍵（ここでは「sample-nginx.key」というファイル）を基にして行われ、

生成されたCSRは「sample-nginx.csr」として保存されます。</p>
これを実行すると、色々聞かれますが、

開発環境なので、多少情報は適当でも大丈夫かと思います。</p>
Common Nameの部分は、

ドメイン名なので、ここだけちゃんと入力しましょう。</strong></p>
これらが終わったら、最後に自己署名証明書の作成します

秘密鍵とCSRを使用してSSL証明書を自己署名します。</p>
openssl x509 -req -days 365 -in sample-nginx.csr -signkey sample-nginx.key -out sample-nginx.crt</span></span></code></pre>
このコマンドは、証明書署名要求（CSR）から自己署名されたSSL/TLS証明書を生成します。

x509はX.509証明書を処理するためのオプションです。

X.509は、SSL/TLSなどで使用されるデジタル証明書の標準フォーマットです。</p>
-reqは、CSRから証明書を生成することを意味します。

-days 365は、証明書の有効期限を設定します。この例では、365日間となっています。</p>
-in sample-nginx.csrで、入力として使用するCSRファイルを指定します。

ここでは「sample-nginx.csr」というファイルです。</p>
-signkey sample-nginx.keyは、CSRに署名するために使用する秘密鍵を指定します。

この例では「sample-nginx.key」という秘密鍵を使用します。</p>
-out sample-nginx.crtで生成された証明書を保存するファイル名を指定します。

ここでは「sample-nginx.crt」という名前のファイルに保存されます。</p>
そうして、コマンドの結果は、自己署名されたSSL/TLS証明書です。

これで、sample-nginx.crt（自己署名証明書)とかが生成されているはずです。</p>
NginxでのSSL設定</h3>
次は、生成した、鍵と証明書をNginxコンテナに配置します。</p>
docker cp sample-nginx.crt my-nginx:/etc/ssl/certs/</span></span>
docker cp sample-nginx.key my-nginx:/etc/ssl/private/</span></span></code></pre>
次にコンテナのnginxの設定ファイルを編集する必要があるので、

もう一度コンテナに入ります。</p>
コンテナに入ったらVimで編集！って行きたいところなんですが、

ちょっと困ったことが。</p>
</p>
なに、まさかのviが使えんとは。</p>
さっきみたいに、ローカルでnginxの設定ファイルを使って、

docker cpするみたいな感じでもいいのですが、

やっぱvimmerとしてはvimが使えない環境は見過ごせない。</p>
ということでvimを使えるようにします。

コンテナの中で、</p>
apt</span> update</span> &&</span> apt</span> install</span> -y</span> vim</span></span></code></pre>
これでvimが使えるようになるはず。</p>
たまにnginxイメージとかのversionが古かったりすると、

apt updateが失敗するときもあるので、

その際は、下記の記事にようにしたら修正できました。</p>
https://qiita.com/teriyakisan/items/e5cf7d5228dc02500562</a></p>
さて、vimをインストールしたら、

/etc/nginx/conf.d/default.conを開いて、下記の内容に修正します。</p>
server {</span></span>
    listen 443 ssl;</span></span>
    server_name sample-nginx.com;</span></span>
</span>
    ssl_certificate /etc/ssl/certs/sample-nginx.crt;</span></span>
    ssl_certificate_key /etc/ssl/private/sample-nginx.key;</span></span>
</span>
    location / {</span></span>
        root /usr/share/nginx/html;</span></span>
        index index.html index.htm;</span></span>
    }</span></span>
}</span></span></code></pre>
これが何をしているか、

順に見ていきます。</p>
まず、serverブロックですが、

これはNginxの設定ファイルにおける基本的な構造であり、

ここに特定のサーバーに関する設定を記述します。</p>
ブロックっていうものが何かというと、</strong>

特定の設定ディレクティブのグループを囲むための構文要素でで、</strong>

これらを使用することで、Nginxの挙動を柔軟に制御し、</strong>

特定のコンテキストや条件に基づいてさまざまな設定を適用できます。</strong></p>
ブロックは波括弧（{}）で囲まれたセクションです。

ブロック内には複数のディレクティブが含まれることがあり、

入れ子にすることも可能です。</p>
たとえば、httpブロック内に複数のserverブロックを、

serverブロック内に複数のlocationブロックをというふうに。</p>
Nginxの主なブロックの種類</h4>
httpブロック</h5>
Webサーバー全体の設定を定義するためのブロックです。

ここには、リバースプロキシ設定、ロギング、MIMEタイプの定義など、

すべてのサーバーインスタンスに共通する設定が含まれます。</p>
serverブロック</h5>
個別のWebサーバーまたは仮想ホストの設定を行うブロックです。

ディレクティブでポートを指定し、server_nameでドメインを指定することで、

特定のホストやポートへのリクエストに応じた設定を行います。</p>
locationブロック</h5>
特定のURLパス（例：/images、/apiなど）に適用される設定を定義します。

これにより、異なるパスに異なる挙動（例えば、特定のパスへのアクセス制御やコンテンツの提供方法の変更）を設定できます。</p>
いわゆる、一般的なエンドポイントはこのブロックで指定します</p>
ifブロック</h5>
条件に基づいて設定を適用する場合に使用しますが、ifディレクティブは使用に注意が必要です。

なぜなら、特定の条件下でのみ実行される設定は、思わぬ挙動を引き起こすことがあるからです。</p>
upstreamブロック</h5>
ロードバランシングやリバースプロキシ設定で使用され、

複数のサーバーアドレスをグループ化して管理します。

RailsのPumaとかでのソケット通信などで使ったりしました。</p>
</p>
さて、少し脱線してしまいましたが、

先程のコードの説明に戻ります。</strong></p>
listen 443 sslはは、Nginxがリクエストを受け付けるポートを指定します。

ここでは443ポートを使用しており、これはHTTPS通信の標準ポートです。

sslキーワードは、このポートでSSL/TLSを使用することを指示します。</p>
server_name sample-nginx.comは、サーバーが応答すべきホスト名またはドメイン名を指定します。

この例ではsample-nginx.comが使われています。</p>
ssl_certificate と ssl_certificate_keyの２つは、

ssl_certificateディレクティブは、SSL証明書のファイルの場所を指定します。

ssl_certificate_keyディレクティブは、証明書に対応する秘密鍵のファイルの場所を指定します。

これらはサーバーの身元を確認し、クライアントとの安全な通信を確立するために必要です。</p>
rootディレクティブは、リクエストされたURIに対するファイルが保存されているサーバー上のディレクトリを指定します。

indexディレクティブは、ディレクトリインデックスとして使用されるファイル名を指定します。</p>
さて、これでsslの設定をしたので、

次はhostファイルの設定をします。</p>
ホストファイルの編集</h3>
本番環境とかであれば、

面倒なDNS設定が必要ですが、

開発環境なので、ホストファイルの編集だけで済ませてしまおうと思います。</p>
開発環境でsample-nginx.comというドメイン名でNginxの画面を表示するので、

ローカル環境のホストファイルを編集して、sample-nginx.comをローカルIPアドレス（通常は127.0.0.1）にマッピングすることで、

このドメイン名をローカルで解決できるようにしたいと思います。</p>
設定ファイルは、macやlinuxなら

/etc/hostsが該当します。</p>
ファイルの末尾に、以下を追加します。</p>
127.0.0.1    sample-nginx.com</span></span></code></pre>
このあと、OSの再起動またはブラウザの再起動が場合によっては必要かもしれません。</strong></p>
再起動後にhttps://sample-nginx.com/にアクセスして、

表示されればうまくいっています。

自己署名証明書なので、ブラウザから警告が出ていると思いますが。</p>
Nginxを更に極めるために</h2>
Nginxを更に極めるために、

下記のような書籍はおすすめです。</p>


  
  
    
  </div>
  
  
    nginx実践入門 WEB+DB PRESS plus</p>
    
      Amazonで見る</a>
      楽天市場で見る</a>
    </div>
  </div>
</div>


  
  
    
  </div>
  
  
    nginx実践ガイド impress top gearシリーズ</p>
    
      Amazonで見る</a>
      楽天市場で見る</a>
    </div>
  </div>
</div>
特に一冊目は、

公式ドキュメントではなかなかわかりにくいところも

広く解説しているので、おすすめです。</p>


【Docker volume/cp】ホストとコンテナのデータをマウントする
2023-11-17T00:00:00+00:00
Dockerを使用するにあたって、

必ず直面するものとして、ホスト(自分のローカルPC)と

コンテナのデータの共有及びそれらの永続化があると思います。</p>
本記事では、それを実現する、Dockerの重要概念である、

ボリュームとdocker cpなどの使用方法を主題にとりあげ、</mark>

ボリュームの共有方法のマウントの種類や、docker cpとの違いにも言及しつつ、</mark>

具体例としてMySQLコンテナを使ってみます。</mark></p>
本記事で得られるものとしては、</p>

</blockquote>

ボリュームマウントとバインドマウントの違い</li>
docker cpの使い方とマウントと比べたデメリット</li>
mysqlでのボリューム設定</li>
ボリュームマウントのバックアップ方法と復元方法</li>
docker desktop for macの特殊性</li>
</ul>
などがあります。</p>
ボリュームは、Dockerを使う上で重要ですので、

ぜひとも最後まで御覧くださいますと幸いです。</p>
docker cpコマンド</h2>
まず、ボリュームの前に、

docker cpコマンドについて触れていきます。</p>
docker cp コマンドは、

Dockerコンテナとホスト間でファイルやディレクトリをコピーする際に使用されます。</strong></p>
ホストは、自分のPCと思ってもらえれば大丈夫です。</p>
例えば、Vimや他のエディタがインストールされていないコンテナ内でファイルを編集したい場合、

その環境にVimとかをインストールするやり方と、

このdocker cpを使用してローカルマシンで編集したファイルを、

コンテナにコピーするやり方があります。</p>
docker</span> cp index.txt mycontainer:/tmp/html</span></span></code></pre>
このコードはindex.txtをローカルマシンから

mycontainerの指定されたディレクトリ(ここでは/tmp/html)にコピーします。</p>
Linuxにもcpコマンドがありますが、

これがホストマシンからコンテナの中に変わっただけで、

基本は似たような感じかと思います。</p>
これは、このあと紹介するvolumeを設定するまででもないような、

軽微な変更とかをサクッと適用したいときとかに便利です。</p>
pushdコマンド</h4>
やや脱線ですが、

pushdコマンドというものがあり、これを使うと、

ディレクトリのスタックに現在のディレクトリを保存し、

新しいディレクトリに移動する際に使用されます。</p>
これはcdコマンドとは異なり、popdを使って前のディレクトリに戻ることができます。</p>
pushd /path/to/newdirectory</span></span>
# 何らかの作業</span></span>
</span>
popd</span></span></code></pre>
このコマンドは新しいディレクトリに移動し、その後元のディレクトリに戻ります。</p>
ぶっちゃけ、zoxideみたいなチートコマンドもあるので、

これをピンポイントで使う機会はあまりないかもしれませんが、

docker cpとかをする際のディレクトリのパス指定に、

カレントディレクトリを変えたほうが便利な場合もあるかもしれませんので、

軽くこういうコマンドもあるんだなぐらいで押さえておくのがおすすめです。</p>
ちなみに、zoxideみたいな便利コマンドについては、

下記の記事</a>でご紹介しております。</p>

</blockquote>
docker cpで作成したデータが失われる場合</h3>
さて、こんな感じでdocker cpをしたデータですが、

永続化されるわけではありません。</p>
Dockerでは、コンテナ内のデータは

コンテナのライフサイクルに依存します。

コンテナのライフサイクルについては、

下記の記事</a>で少し言及しています。</p>
[st-card myclass="st-no-shadow" id="1208" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
さて、docker cpで作成したデータですが、</p>
[st-mybox title="ポイント" webicon="st-svg-check-circle" color="#FFD54F" bordercolor="#FFD54F" bgcolor="#FFFDE7" borderwidth="2" borderradius="5" titleweight="bold" fontsize="" myclass="st-mybox-class" margin="25px 0 25px 0"]</p>

コンテナを停止して再開した場合、データは保持されます。</li>
コンテナをrestartした場合も、基本的にはデータは保持されます。</li>
しかし、コンテナを破棄して再起動した場合、新しいコンテナIDが生成されるため、

以前のコンテナで作成されたデータは失われます。</strong></li>
</ul>
そのため、docker cpをするだけでは、

ファイルの内容を永続化するという観点では不十分です。</p>
そのため、このようにファイルの内容とかを永続化する際は、

Dockerのボリュームという概念を用います。</strong></p>
ボリュームには、大きく分けてボリュームマウントとバインドマウントを利用します。(これは後ほど詳しく解説します)

これにより、コンテナが削除されてもデータはホストシステム上に残すことができます。

コマンドの形式としては、</p>
docker</span> run</span> -v</span> /path/on/host:/path/in/container myimage</span></span></code></pre>
のような感じで、こちらはバインドマウントの場合です。</p>
このコードは、ホストの/path/on/hostをコンテナの/path/in/containerにマウントし、

コンテナのデータをホストの指定したディレクトリに永続化します。</p>
以下、ボリュームについて詳しく見ていきます。</p>
ボリュームとは</h2>
ボリュームは、コンテナ間でデータを共有し、永続化するためのメカニズムです。

これにより、コンテナが削除された後もデータを保持できます。</p>
先程の、docker cpでもホストとコンテナでデータを同期できる点で、

似てはいますが、下記の点で異なります。</p>

</blockquote>

リアルタイム動機(ボリュームは開発環境などでの編集がコンテナにも反映される。docker cpは実行時のみ)</li>
ボリュームマウントを使えば、複数の異なるコンテナ間でのボリュームの共有ができる</li>
</ul>
そのため、ユースケースとしては、

docker cpがログファイルなどの取り出しなどに使うのに対し、

開発環境などでの編集はバインドマウントなど用いられることが多いかと思います。</p>
マウントっていうのは、ストレージデバイスやファイルシステムをアクセス可能な形でシステムに取り付けることで、

Dockerでは、ボリュームをコンテナの特定のパスにマウントすることで、データをコンテナにアクセス可能にします。</strong>

これにより、コンテナが破棄されてもデータを保持することができます。</strong></p>
マウントの種類としてボリュームマウントとバインドマウントが有名です。</p>
バインドマウントとボリュームマウントの違い</h3>
バインドマウントは、ホストマシン上の任意のファイルやディレクトリをコンテナにマウントします。

これは開発環境でのファイルの共有に便利です。先述しましたが、

ホストとコンテナとの共有という意味では、docker cpと共通点がありますね。</p>
これに対して、ボリュームマウントは、Dockerが管理する特定の場所にデータを格納します。

これは、本番環境でのデータの永続化に適していて、docker volume createコマンドなどで、

ボリュームを作成します。</p>
実際にdocker composeなど、実務で使う頻度が多いマウントは、

どちらかというとボリュームマウントのような気がします。</p>
ボリュームマウントの利点</h3>
ボリュームマウントは、特にデータベースのデータなど、

継続的に更新されるデータの保持に有効です。</p>
これにより、コンテナが削除されてもデータは失われません。</p>
dockerには、こうしたvolumeを操作するコマンドがあります。</p>
docker volumeコマンド</h2>
docker volume コマンドは、

ボリュームの作成、管理、削除を行うために使用されます。</p>
先程ちらっと出てきたvolumeの作成には、createを使います。</p>
docker</span> volume create myvolume</span></span></code></pre>
このコマンドはmyvolumeという新しいボリュームを作成します。</p>
docker volume ls</h3>
docker volume ls コマンドを使用すると、現在存在するすべてのボリュームの一覧が表示されます。</p>
</p>
ここにDRIVERっていう項目があるかと思います。</p>
これは、データのストレージ方式を管理するためのプラグインです。

これにより、異なるタイプのストレージシステムに対応し、データを効率的に管理できるようになります。</p>
デフォルトは、localで、

これは、ローカルファイルシステムにデータを保存します。

他の種類として、overlayやaufsなどもありますが、

やや高度になるのと、あまりvolumeのdriverを設定することは、

そこまでない気がするので割愛します。</p>
ちなみに、ややこしいのですが、

dockerのストレージドライバーとは微妙に違う概念で、

あくまでvolumeの保存作成などの形式かと思います。</p>
ストレージドライバーについては、

下記の記事が詳しかったです。</p>
https://docs.docker.jp/storage/storagedriver/index.html</a></p>
--mountオプション</h3>
docker runとかで、

コンテナを起動する際、

volumeについてのオプションは、

-vで設定することが多いかもしれませんが、

これ以外に--mountオプションというものもあります。</p>
--mountオプションは、ボリュームマウントの詳細な設定を行う際に使用されます。

-vオプションと比較すると、--mountはより詳細な設定が可能です。</strong></p>
--mount type=TYPE,source=SOURCE,destination=DESTINATION</span></span></code></pre>
typeは、マウントのタイプを指定します。

通常はvolume（ボリュームマウント）、bind（ホストシステム上のファイルまたはディレクトリをコンテナにマウント）、

tmpfs（一時的なファイルストレージ）のいずれかを指定します。</p>
sourceは、マウントするソース（ボリューム名、ファイルまたはディレクトリのパス）を指定します。

typeがvolumeの場合、これはボリュームの名前です。

typeがbindの場合、これはホスト上のファイルまたはディレクトリの絶対パスです。</p>
destinationは、コンテナ内のマウントポイント（パス）を指定します。

例えば、myvolumeという名前のボリュームをコンテナの/appディレクトリにマウントする場合、

以下のようにdocker runコマンドに--mountオプションを追加します</p>
docker</span> run</span> --mount</span> type=volume,source=myvolume,destination=/app myimage</span></span></code></pre>
--mountのほうが、詳細にvolume設定したい際は、

適しているかもしれません。</p>
また-vでやった場合、

ボリュームマウントなのか、バインドマウントなのかわかりにくいという側面があるので、

可読性の観点でも、もしかすると--mountオプションの方がいいかもしれません。</p>
ちなみに、-vオプションは、

マウント元が / から始まる絶対パスのときは、

バインドマウント、そうでないときはボリュームマウントとなります。</p>
tmpfsマウント</h3>
今まで、ボリュームマウントとバインドマウントを中心に解説しましたが、

tmpfsマウントというものもあります。</p>
tmpfsマウントは、一時的なファイルストレージとして利用され、

コンテナの再起動時にはデータが失われます。これは、一時ファイルやキャッシュに適しています。</p>
基本的にはコンテナのライフサイクルに依存するので、

他のボリュームマウントとかみたいに、

データの永続化という点では向いていません。</p>
セッションデータなどの一時的なデータの保存が適している点で、

NoSQLとかに少し役割が似ているかもしれません。</p>
実際に、tmpfsマウントは、メモリ上でデータを処理するため、

ディスクベースのストレージよりも高速です。</p>
docker run -d --name tmpfs-container --tmpfs /tmpfs-dir:rw,size=100m myimage</span></span></code></pre>
このコマンドは、myimageを基にtmpfs-containerというコンテナを起動し、

その中に/tmpfs-dirというディレクトリをtmpfsマウントとして作成します。

ここで指定されたsize=100mは、tmpfsマウントに割り当てるメモリのサイズを指定しています。

rwは読み書き可能っていうことですね。</p>
中身は、コンテナの中に入って確認できる。

試しに何かフィアルを/tmpfs-dir配下で作ったあと、

restartをすると、

消えていることがわかると思います。</p>
正直、頻繁には使うものではない気もしますが、

マウントの種類としては覚えておくといいかもしれません。</p>
docker volume inspect</h3>
docker volume inspect コマンドは、特定のボリュームの詳細情報を提供します。</mark>

このコマンドは、ボリュームの設定や状態を確認するのに非常に便利です。</mark></p>
▒▓</span>    ~ docker volume inspect mysql-volume</span></span>
[</span></span>
    {</span></span>
        "CreatedAt"</span>: </span>"2023-11-17T07:09:35+09:00"</span>,</span></span>
        "Driver"</span>: </span>"local"</span>,</span></span>
        "Labels"</span>: null,</span></span>
        "Mountpoint"</span>: </span>"/var/lib/docker/volumes/mysql-volume/_data"</span>,</span></span>
        "Name"</span>: </span>"mysql-volume"</span>,</span></span>
        "Options"</span>: null,</span></span>
        "Scope"</span>: </span>"local"</span></span>
    }</span></span>
]</span></span></code></pre>
このコマンドはmysql-volume(後のハンズオンで作成するやつ)の詳細情報を表示します。

特に注目したいのが、Mountpointです。</strong></p>
ボリュームのデータが物理的に保存されているホストシステム上(自分のPC)のパスを示します。

この例では /var/lib/docker/volumes/mysql-volume/_data にデータが保存されています。

(後に少し触れますが、docker desttop for macとかだと、

ホストPCでこのパスを確認しても実体が存在しないかと思います。)</p>
MySqlコンテナを用いたボリュームマウント実装</h2>
ボリュームやマウントについて

大まかには紹介できたと思うので、

試しにmysqlコンテナを使って実装してみます。</p>
MySQLコンテナでデータベースのデータを永続化する手順は、

下記のような感じになるかと思います。</p>
[st-square-checkbox bgcolor="" bordercolor="" fontweight="" borderwidth="3"]</p>

マウントディレクトリの指定: /var/lib/mysql</li>
環境変数の設定: 例えばMYSQL_ROOT_PASSWORDを設定します。</li>
ボリュームの作成: docker volume createコマンドを使用してボリュームを作成します。</li>
</ul>
[/st-square-checkbox]</p>
これを踏まえて、コンテナを立ち上げてみます。

例によっていきなりrunで立ち上げるので、

pullとかは不要です。</p>
docker</span> run</span> -d \</span></span>
  -e</span> MYSQL_ROOT_PASSWORD=mypassword</span> \</span></span>
  -v</span> mysql-volume:/var/lib/mysql</span> \</span></span>
  mysql</span></span></code></pre>
早速、コンテナの中に入って見ましょう。</p>
docker exec -it コンテナID /bin/bash</span></span></code></pre>
コンテナの中で、mysql -pコマンドを実行します。</p>
mysql</span> -p</span></span></code></pre>
そうすると、パスワードを聞かれるので、

最初のrunで指定したパスワード入れます。</p>
mysqlに入れたら、DATABASEを作りましょう。</p>
CREATE</span> DATABASE volumetest</span>;</span></span></code></pre>
作成したら、テーブルの挿入からデータの作成まで次のような感じで行います。</p>
use</span> volumetest</span>;</span></span>
create</span> table blog</span> (id</span> INT NOT NULL AUTO_INCREMENT, title VARCHAR</span>(</span>50</span>)</span>, PRIMARY KEY</span>(</span>id</span>));</span></span>
insert</span> into blog</span> (title) values (</span>'test'</span>);</span></span></code></pre>
さて、データを挿入できたら、

中身を確認してみます。</p>
mysql</span>></span> select</span> *</span> from blog</span>;</span></span>
+----+-------+</span></span>
|</span> id</span> |</span> title</span> |</span></span>
+----+-------+</span></span>
|</span>  1</span> |</span> test</span>  |</span></span>
+----+-------+</span></span>
1</span> row in set</span> (0.00</span> sec</span>)</span></span></code></pre>
selectしてみると、こんな感じで

データを入れることができていることがわかります。</p>
用は済んだので、

ctrl + Dとかで抜けましょう。</p>
試しにstopとrmをして、

このmysqlコンテナを消してみましょう。</p>
docker stop コンテナID</span></span>
docker rm コンテナID</span></span></code></pre>
そして、もう一度立ち上げてみます。</p>
docker run -d \</span></span>
  -e MYSQL_ROOT_PASSWORD=mypassword \</span></span>
  -v mysql-volume:/var/lib/mysql \</span></span>
  mysql</span></span></code></pre>
先程と同じ作業をして、

このコンテナのmysqlでselect文を実行してみると、</p>
mysql</span>></span> select</span> *</span> from blog</span>;</span></span>
+----+-------+</span></span>
|</span> id</span> |</span> title</span> |</span></span>
+----+-------+</span></span>
|</span>  1</span> |</span> test</span>  |</span></span>
+----+-------+</span></span>
1</span> row in set</span> (0.00</span> sec</span>)</span></span></code></pre>
さっきと同じデータがあることがわかりますね。</strong>

ちなみに、コンテナIDが変わっていたかと思うので、</strong>

先程とは別のコンテナになります。</strong></p>
volumeを使うことで、

このようにデータの共有ができるということですね。</p>
ちなみに、最初に指定した、

volumeのマウントポイントですが、

docker desktop for macとかを使っていると、

これらが仮想化を使っている関係でファイルパスをホストPCから

直接見ることができません。</p>
これを見る方法としては、

nsenterというものを使うのですが、

docker入門の枠からは外れるので割愛します。</p>
ちなみに、nsenterで確認すると、

/var/lib/docker/volumes/mysql-volume/_data/volumetest/blob.ibdというファイルが作成されていることが

確認できました。</p>
ボリュームマウントのバックアップ方法</h2>
次にこうしたボリュームのバックアップについて解説します。</p>
Dockerでは、バックアップのために別のコンテナを使用することができます。

これにより、重要なデータを安全に保管し、必要に応じて復元することが可能になります。</p>
busyboxとtarを用いたmysql-volumeのバックアップ方法</h3>
すでに作成したmysql-volumeを試しにバックアップしてみましょう。</p>
データの整合性を保つ観点のため、

できれば、バックアップするボリュームを使用しているコンテナを停止しておきましょう。

これは docker stopでできます。</p>
次に、下記のようなコマンドを実行します。</p>
docker</span> run</span> --rm -v</span> mysql-volume:/src</span> -v</span> $(</span>pwd</span>)</span>:/backup busybox tar cvf /backup/backup.tar</span> -C</span> /src .</span></span></code></pre>
-v mysql-volume:/srcは、ボリュームマウントの指定です。

mysql-volume（バックアップしたい Docker ボリュームの名前）をコンテナ内の /src ディレクトリにマウントします。

これにより、コンテナ内からボリュームのデータにアクセスできるようになります。</p>
-v $(pwd):/backupは、これもボリュームマウントの指定ですが、

こちらはホストシステムの現在のディレクトリ（$(pwd) ）を、

コンテナ内の /backup ディレクトリにマウントします。バックアップデータはここに保存されます。</p>
busyboxは、多くの標準的な UNIX ユーティリティを含む軽量のイメージで、

ここでは tar コマンドの実行に使用されます。tarを実行したいだけなので、

ぶっちゃけ、busyboxじゃなくても、ubuntuでもcentosでも</strong>

tarが叩ければ何でもいいです。</strong></p>
tar cvf /backup/backup.tar -C /src . は、コンテナ内で実行されるコマンドです。

tar コマンドを使って /src（mysql-volume がマウントされたディレクトリ）の内容を、

/backup/backup.tar にアーカイブします。

-C /src オプションは tar に /src ディレクトリに移動してからアーカイブを作成するよう指示し、

. は現在のディレクトリ（ここでは /src）の全てのファイルとディレクトリを意味します。</p>
結果として、このコマンドは mysql-volume の内容をバックアップして、ホ

ストシステムの現在のディレクトリに backup.tar という名前のアーカイブファイルとして保存します。

バックアップが完了した後、使用したコンテナは自動的に削除されます。</p>
ただ、これはLinuxとかならうまくいくはずですが、

docker desktop for macのような仮想化を使った環境だと、

カレントディレクトリにファイルが作られない模様。</p>
先程のvolumeの中身にnsenterを使ったような、

別のアプローチが必要になるかもしれません。</p>
ただ、そもそもdocker desktop for macとかなら、

アプリの拡張機能とかで、GUIでバックアップ作成できるっぽいので、</strong>

そもそもコマンドでやる必要ないのかもしれません。</strong></p>
https://www.docker.com/ja-jp/blog/back-up-and-share-docker-volumes-with-this-extension/</a></p>
私は、docker desktop for macではなく、

OrbStackというものを使っているので、

もう少しコマンドでなんとかできないものか調査してみようと思います。</p>
ボリュームの復元(リストア)方法</h4>
ボリュームのデータを復元するには、

基本的に新しいvolumeを作成して、

先程のバックアップとパスが逆向きのtarコマンドを実行すれば復元できるはずです。</p>
新しいvolumeを作成するには、</p>
docker volume create new-volume-name</span></span></code></pre>
とします。</p>
次にバックアップファイルの配置です。

復元するバックアップファイル（例えばtarアーカイブ）が、

ホストシステム上のアクセス可能な場所にあることを確認します。

(docker desktop for macとかだとそもそもここがうまく行っていないので、

あくまでlinuxとかの話になります)</p>
そしたら、バックアップデータを新しく作成したボリュームに抽出します。

一時的なコンテナを作成し、バックアップファイルをマウントして、新しいボリュームにデータを抽出するコマンドを実行します</p>
docker run --rm -v new-volume-name:/target -v /path/to/backup:/backup busybox tar xvf /backup/backup.tar -C /target</span></span></code></pre>
新しいボリュームにデータが正しく復元されたことを確認します。

必要に応じて新しいボリュームを使用するコンテナを起動し、データを確認します。</p>
また復元の手段としては、volumes-fromなどもあります。</p>


  
  
    
  </div>
  
  
    さわって学ぶクラウドインフラ　docker基礎からのコンテナ構築</p>
    
      Amazonで見る</a>
      楽天市場で見る</a>
    </div>
  </div>
</div>


  
  
    
  </div>
  
  
    Docker実践ガイド 第2版 impress top gearシリーズ</p>
    
      Amazonで見る</a>
      楽天市場で見る</a>
    </div>
  </div>
</div>


【プログラマー不要論】ChatGPT GPTsとソフトウェアエンジニアの将来
2023-11-13T00:00:00+00:00
ChatGPTとは</h2>
まあめちゃくちゃ今更なので、

知っているよっていう人がほとんどだと思いますが、

ChatGPTは、OpenAIによって開発された、自然言語処理を行う高度なAIシステムのことです。</p>
https://chat.openai.com/auth/login</a></p>
ChatGPT自体はだいぶ前にかなり話題になっているので、

知らないっていう人はかなり少ないと思います。</p>
以前の私の記事でChatGPTのapiとずんだもんとVue.js</a>を使った、

ちょっとしたデモをあげているので興味がある人はどうぞ。</p>
[st-card myclass="st-no-shadow" id="519" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
かなり革新的なツールなので、

現在、話題になっている技術ですね。</p>
ChatGPT自体については、

私も下記のようなポストをしていたりと、

何かと気になってはいました。</p>
https://twitter.com/xileng4/status/1718125649301569792?s=20</p>
X (Twitter) でポストを見る</a></p>
ChatGPTは、何かと荒れやすい話題で、

エンジニアの中でも懐疑的な人と、

肯定的な人で結構二極化している印象があります。</p>
私は、上記のようなポストでも分かる通り、</strong>

どちらかというと懐疑的でした</strong></p>
ただ、今回のGPTsの報道を見て、

ちょっと考えを見直したというのはあります。(それでも全面肯定派ではありませんが)</p>
GPTsとは</h2>
さて、そんなChatGPTですが、

先日のテックカンファレンス(OpenAI DevDay)で、

GPTsなるものが発表された模様です。</p>
https://openai.com/blog/introducing-gpts</a></p>
これがかなり革命的で、

ものすごく話題になっています。</p>
以下、詳細に見ていきましょう。</p>
カスタムGPTが強力</h3>
GPTsは、めちゃくちゃ平たく言うと、

自分でカスタムGPTが作れる機能で、

有料会員だけが使える機能です。</p>
今までは、

「あなたはWebマーケの担当者とする。...」みたいに、

毎度毎度条件とかを詳細に指示する必要があって、

それを使いまわしたりとかがしづらかったと思うのですが、

このカスタムGPTで、それぞれのコンテキストで</mark>

詳細なGPTを作ることができるという感じです。</mark></p>
面白い例を見つけたので、

張っておきます</p>
https://note.com/hanagasa_manya/n/na3c75122463d</a></p>
これによって、

例えば、「記事生成bot」、

「おすすめタイトル提案bot」みたいに、

用途に応じて様々なカスタムGPTを使えるようになりました。</p>
そして、これだけではなく、

今後は、こうして個人が作成したカスタムGPTは、

市場(apple storeのようなものらしい)に公開して、

収益化とかもできるようになるんだとか。</p>
いやはや、色々新時代過ぎて、

なかなか脳みそがついていきません。</p>
GPT Builder</h3>
そして、今回、

GPT Builderなるものが搭載されました。</p>
これは、先程のカスタムGPTを

対話的に作成することができるものです。</p>
</p>
これによって、

ChatGPTの使い方がよくわからんって言う人でも、

対話的に「Web記事自動生成botみたいなの作って」みたいに、

気軽に入力して進めていくだけで、

カスタムGPTを作れてしまうという手軽さ。</p>
あまりに、手軽なので、

ノーコードでできてしまうと話題になっています。</p>
たしかに、botとかは、</mark>

ノーコードで作るのは難しかったので、</mark>

それがプログラミングなしで作れるという意味では、</mark>

ノーコードとも言えそうです。</mark></p>
ただ、外部APIとの連携とかは、

プログラミングの知識がある程度必要ですし、

ChatGPTが生成したコードとかは、

読める必要がある場面も出てくると思うので、

そういう意味では、あまり従来のChatGPTと変わらないのではという気もします。</p>
エンジニアの仕事の未来</h2>
さて、GPTsの台頭ですが、

これは今まで騒がれていた、

プログラマーは不要になるのでは？という議論を

彷彿とさせるものがあると感じました。</p>
実際どうなのでしょう。

もちろん、確定したことは何もわかりませんが、

私なりの見解をあげてみたいと思います。</p>
今すぐには仕事がなくならない</h3>
まず、現状だと、

「今すぐ」には仕事はなくならないと思います。</strong></p>
「今すぐ」を定義するのも正直難しいのですが、

少なくとも向こう2年ぐらいは...</p>
というのも、まだ現状のChatGPTだと、

正確性に欠けることが多く、

基本的に人の目でコードの正確さを判断する必要があるからです。</mark></p>
AIの進化により、一部の繰り返し作業は自動化される可能性がありますが、

創造性や複雑な問題解決を必要とする作業はエンジニアの手に残りそうな気がします。</p>
ただ、そうは言っても、

それもいつまでの話かは正直読めないぐらい、

進化が凄まじいなとは思うので、

動向は追っていく必要はあるかと思います。</p>
高度なスキルの重要性</h3>
AIの台頭により、高度な技術を要する作業の重要性が増している気がします。

具体的には、</p>

設計、アーキテクチャの検討、技術選定など</li>
アルゴリズム開発とか最適化</li>
機械学習とAIの研究開発</li>
ユーザーエクスペリエンス（UX）/ユーザーインターフェース（UI）設計</li>
セキュリティと暗号化</li>
プロジェクト管理とリード</li>
</ul>
平たく言うと、ただコードを書く、

コーダーみたいな人は、

淘汰される危険性が高いという感じかと思います。</p>
ChatGPTは、

AtCoderのABC、C問題ぐらいならパスできるようなコードを

即座に書いてしまいます。</p>
https://twitter.com/xileng4/status/1723330512692125756?s=20</p>
コーディング能力があるだけではだめで、

設計、アーキテクチャといった、

よりマクロな視点でシステム開発を捉えられる様になる必要がありそうです。</p>
所謂、エンジニアのキャリアとして、

技術のスペシャリストを目指すというキャリアよりは、

マネジメント能力がある方のキャリアを目指した方が、

安全性は高そうな気はします。</p>
本当に技術が好きで、それだけやっていきたいという人は、

ChatGPTに取って代わられる危険性がないわけじゃないので、

ChatGPTの台頭は、純粋にコーディングが好きな人にとっては、

正直あまり嬉しくないニュースかもしれませんね。</p>
ただ、本当にエンジニアが淘汰されるのかという点に関しては、

正直まだ懐疑的ではあります。</p>
というのも、上記を踏まえて高度なスキルを持ったエンジニアが、

一体どれぐらい市場にいるのかということを考えたら、

かなりの数のエンジニアが職を失うことになりそうです。</p>
それだけ雇用が失われて、

別の雇用があるのかというと、

エンジニアですら、雇用がなくなるようなころには、

他の職業も少なからず淘汰されている可能性が高いですから、

そもそも社会構造的に成り立つのか？みたいな疑問もあります。</p>
それと、現在PCが使える人使えない人みたいなIT格差があり、

地方とかでは未だに紙とかで在庫管理しているような企業もあったりすることを思うと、

個人的には情報格差の種類が増えていくというのが、

より現実的なような気もします。</p>
それと、そもそもAIは職を奪うのではなく、</strong>

人間の楽をするためのツールという捉え方もあるので、</strong>

心配するほど、人間の雇用は現象しないのかもしれません。</strong></p>
今後少子化で間違いなく労働人口自体は減るので、

むしろ、AIが補助をしてくれるぐらいで

ちょうどよくなるのかもしれません。</p>
それに我々が生きている間に、

完全プログラミング(人間不要ですべてAIがプログラミングする)の時代が

到来するかも未知数なので、

起きるかどうかもわからないことを考えても仕方ないっていうのもあります。</p>
AIを活用できるかも必須教養になりそう</h3>
最近というか、ちょっと前は、

プログラミングと英語が基礎教養になると騒がれていましたが、

今後はこれにAIが加わりそうな予感がしました。</p>
というのも、案外ChatGPTを適切に使うのは、

テクニックがいるからです。</p>
適切なプロンプトを読み込ませるための工夫や、</mark>

どういうことをChatGPTにやらせるかといったアイデアなど、</mark>

ChatGPTは便利ですが、それを活用し切るには、</mark>

そこそこのテクニックが必要そうです。</mark></p>
そのため、新しい職種としてプロンプトエンジニアなるものが、

期待されていますが、これに伴いAIは今後の必須教養になるのかもしれないなと思いました。</p>
英語が読めない人は、それだけアクセスできる情報が減るように、

AIが活用できないと、それだけ得られる利便性を失うという感じで、

格差が今後生まれてきそうな予感がしました。</p>
未経験からエンジニアへの道</h3>
これから未経験からエンジニアを目指す人は、

結構厳しくなりそうな予感が個人的にはしています。</p>
というのも、こうしたGPTツールがあれば、

未経験の人を一から育ててエンジニアを増やすよりも、

スキルがある人がGPTをうまく使って、

何人分ものバリューを出す方が現実的だからです。</p>
そういう意味で、スキルがないエンジニアは、

相対的に淘汰されやすくなるのかもしれません。</p>
また、淘汰されるかどうかの分岐点として、</strong>

今後ChatGPTを使いこなせるかもポイントにあるのかなと感じました。</strong></p>
最低限プロンプトエンジニアリングを学んで、

泥臭くではなく、極力効率よくコードを書いていく手法を身に着けていく必要がありそうです。

(コーディング自体が好きな人にとってはなんとも寂しい話ですが)</p>
ただ、そうは言っても、現状だと、

まだまだChatGPTがエンジニアを淘汰する水準には行っていません。</p>
30代ぐらいで未経験からエンジニアを目指す人々は、新しい技術を学び、適応することが重要かもしれません。</p>
エンジニアとして生き残るために</h2>
以上を踏まえて、

エンジニアとして生き残るには、

やや大変な時代に突入しそうだなとは思います。</p>
ただ、そう入っても、

ChatGPTによって、

未経験技術へのハードルはかなり下がったと思うので、

技術のキャッチアップ自体はしやすくなっていると思います。</p>
そのため、現在のような過渡度は、

いかにこうしたAIツールを使って、

差をつけるかで今後生き残れるかが変わってくるような気がしました。</p>
ただ、いつかChatGPTとかが、

すべてプログラミングしてくれるようになったら、

いよいよエンジニアは不要になるので、

その日になったら、今まで身につけてきたスキルが

役に立たなくなると思うと、少々やりきれない感はあります。</p>
ただ、そうなっている日には、

他の職業もそうなっていると思うので、

あまり将来の不安ばかり考えすぎずに、

ChatGPTの便利な部分を積極的に使っていくというのが、

AIとの良い付き合い方なのかもしれませんね。</p>


【コードレビューとは？怖い？】改めてやり方・目的を考察する
2023-11-05T00:00:00+00:00
エンジニアとして現場に出ると、

ほぼ100%、コードレビューというものに遭遇します。</p>
もう当たり前すぎて、

あまりコードレビューについて考えることは少ないかもしれません。</p>
本記事では、そんなコードレビューについて、

今一度初心に帰って、本質や目的、やり方などについて、

考察を深めてみようと思います。</strong></p>
コードレビューのやり方などは、

正解があるわけではないので、

あくまで私が考えるベストなやり方について、

本記事で紹介します。</p>
またそのやり方についても、

技術的なやり方というよりは、

こちらの記事</a>にあるようなメンタル・マインド面で重要なことに

フォーカスしています。</p>
ちなみに、コードレビューに関連して、

強強エンジニアとは何か？と考察した記事もあるので、

興味がある方は、こちら</a>もご覧ください。</p>
https://reisuta.com/strong-engineer/</p>
コードレビューとは？</h2>
コードレビューとは、

自分が書いたソースコードをプルリクエストとして、

出した際に、ベースブランチにmergeする前に、

他のエンジニアによる第三者チェックを挟むことで、

まずいコードや冗長なコードなどを議論するようなものです。</p>
まあ、平たく言うと、

第三者チェックとして、</mark>

他のエンジニアに自分の書いたコードを見てもらうことですね。</mark></p>
こういったレビュー自体は、

ソースコードに限らず、例えばドキュメントレビューとか、

文面レビューとか、色々あると思うので、

コードレビューは、それのソースコード版というだけなので、

概念自体はシンプルですかね。</p>
コンサルとかだとパワポレビューというものもあるらしいです。</p>
基本的にソフトウェア開発はチーム開発なので、

このようなコードレビューは、一般的には行われるのが普通ですね。</p>
個人開発とかだと、コードレビューはあまりないかもしれませんね。</p>
コードレビューは怖いもの？</h3>
さて、そんなコードレビューですが、

しばしば怖いものとして取り上げられることもあります。</p>
というのも、このコードレビューの際に、

「こんなコード書いて恥ずかしくないの？」というような

攻撃的なコメントをレビューワーがしてしまったり、

あまりに細かいコメントとかをしすぎたりして、

実装者が萎縮してしまう現象があるのが、

背景にあるのかと思います。</p>
まず、大前提としてコードレビュー自体は、

怖いものではありません。</strong></p>
言ってしまえば、コードレビューが怖いと思われるのは、

レビューワーのレビューの仕方が良くないのかなと個人的には思います。</p>
そのため、コードレビューが怖いものとして

現場で認識されるようになってしまった場合、

もうその現場でのコードレビュー文化は、

実質的には失敗していると個人的には考えます。</p>
ただ、ともすると、

スキルが高い人がもてはやされるのが、

良くも悪くもエンジニアですので、

スキルが高い人のコメントは、

攻撃的だろうとなんだろうと、

通ってしまいやすいという構造もあるかもしれません。</p>
</p>
コードレビューの様々な形態</h2>
さて、一口にコードレビューといっても、

様々なシチュエーションが考えられます。</p>
また、現場によっても、

どういう方針でコードレビューを採用するかは異なることが

多いでしょう。</p>
ここでは、コードレビューのいくつかのパターンを

あげていこうと思います。</p>
自分より上のエンジニアにレビューしてもらう(一般的なレビュー)</h3>
まず、よくあるのが、

自分よりベテランないし、スキルが高い、または役職が上の人などに、

レビューしてもらうパターンです。</p>
おそらくこれが最もよくあるパターンかと思います。</strong></p>
ただ、このパターンの場合、

力関係がはっきりしているため、

しばしば、前述の怖いコードレビューに陥りやすいという

デメリットがあります。</p>
自分より上のエンジニアに攻撃的なコメントをされてしまうと、

なかなか反論できないものかと思うので、

コードレビューとしては、かなりギスギスしたものになってしまう恐れがあります。</p>
一方で、コードレビューの質自体は、</mark>

自分より上の人の目を通してもらうことで、</mark>

ソースコードの品質担保という面ではメリットに働くでしょう。</mark></p>
また、スキルの観点では、自分では気づけない観点とかを指摘してもらえるので、

レビューのたびに強くなれるみたいなメリットはあるでしょう。</p>
総じていうと、ストレスは溜まるが、

スキルは上がるといったところでしょうか。</p>
自分と同等のエンジニアにレビューしてもらう(相互レビュー)</h3>
次に、自分と同階級のエンジニアにレビューしてもらう、

所謂相互レビューについてです。</p>
これは、私が勤めていた会社が採用している方針でした。

メリットは、互いにフラットなので、

コードレビューを通して、議論をしやすく、

風通しも良いという特徴があります。</p>
そのため、この場合はあまり怖いコードレビューには

なりにくいかと思います。</p>
デメリットとしては、

自分より上のエンジニアの場合の裏返しですが、

質の担保に若干の不安があるということですね。</p>
この場合は、ある程度自分でも、

そのままmergeしても大丈夫だなっていう状態の品質にしておかないと、

レビュー漏れが起きやすくなるので、品質担保の面では若干の不安が残りそうです。</p>
自分より下のエンジニアにレビューしてもらう(お手本を見せる)</h3>
これは正直そこまで一般的ではないのですが、

先述の相互レビューの文脈で、

「こういう感じで書いたから、参考にしてみてください」というように、

下のエンジニアにお手本を見せるという場合で使うものかと思います。</p>
まあ、これに関しては、そもそもコードレビューじゃねえよってなるかもしれませんが、

下のエンジニアが、コードレビューのフェーズを通して、

議論をすることができるという点ではコードレビューになるかと思います。</p>
メリットは、相互レビューのときとほぼ同様ですね。

デメリットは、品質担保の面では、実質的に

コードレビューなしというところでしょうか。というのも、

下のエンジニアには、上のエンジニアが書いたコードをレビューするのは、

現実的には難しいことが多いからです。</p>
コードレビューがない現場</h3>
そもそも、コードレビューがない現場もあります。</p>
これは、正直文化としては、よほどの事情がない限り、

成熟していないと言わざるを得ません。</p>
コードレビューをしないことによるデメリットは、

枚挙にいとまがありません。</p>

コードの品質を担保できない</li>
コードがどういう意図で追加したのかわからない</li>
簡単にベースブランチにmergeできてしまうのは保守性の面で厳しい</li>
エンジニアのスキルも上がりにくい</li>
チーム開発のメリットを活かせていない</li>
誰でも好き勝手にコードを書き換えられてしまう状況に近い</li>
</ul>
といったところでしょうか。(まだまだたくさんありそうですが)</p>
わかりやすい例としては、

今日入ったばかりの新人エンジニアが書いたソースコードを、

コードレビューなしで、そのままmasterにmergeしてしまい、

障害に繋がってしまったりなどでしょうか。</p>
もちろん、コードレビューをしたから、

障害を防げるというわけではないのですが、

そもそも最初からコードレビューをしないで障害が起きたのと、

コードレビューをして、障害が起きたのとでは意味が違います。</p>
コードレビューをしていたのであれば、

コードレビューの漏れを学習できるので、

後に活かすことができます。</p>
コードレビューをしないというのは、

よほどの特殊ケースを除いて、

チーム開発の破綻と言っても過言ではないかもしれません。</p>
コードレビューについて思うこと</h2>
さて、コードレビューの概要について、

大まかに述べてきました。</p>
ここで私なりに、コードレビューについて

思うことを縷縷述べていきたいと思います。</p>
コードレビューの目的</h3>
まず目的ですが、

これは正直チームによって変わるような気がします。</p>
ただ、コードレビューの目的として

よく取り上げられるものとしては、</p>

ソースコードの品質担保</li>
第三者チェック</li>
チーム開発の文化醸成</li>
コードレビューを通して現状のコードのissueを見つけたりと議論のプラットフォームとして機能させる</li>
</ul>
といったところでしょうか。</p>
なので、そのチームによって、

上記のどれを重視するかによって、

目的も変わるかと思います。</p>
一般的には第三者チェックが、

コードレビューの目的になることが多い気がします。</p>
コードレビューのコスト</h4>
コードレビューは、基本的には行うべきものですが、

少なからぬ工数がかかるのも事実です。</p>
というのも、基本的に、

自分のタスクを中断して、

他のエンジニアが書いたコードを見て、

検証するというのは、コード量にもよりますが、

それなりに工数がかかるものでしょう。</p>
その点を勘案して、

コードレビューの比重を落とすなどは、</mark>

チームによっては有り得る選択でしょう。</mark></p>
ただ、個人的には、

コードレビューをしやすいようにするというのも、

大事かと思っていて、

実装者が事前に「こういう観点で見てほしい」などと伝えておけば、

レビューワーも負担が減る思うので、

そういう気遣いで、コードレビューの工数は小さくできるような気もします。</p>
コードレビューでやってはいけないこと</h3>
コードレビューでやってはいけないことの最たるものは、

攻撃的なコメントです。</strong></p>
例えば、「なんでここのコードこんな汚いの？」みたいな、

直接的かつ、実装者を貶めるようなコメントは絶対にやってはいけません。</strong></p>
とはいっても、スキルが高いエンジニアの方に限って、

このようなコメントをしてしまっているケースは少なく有りません。</p>
スキルが高い人からすると、なぜこんなコードになるの？という

シンプルな疑問の発露なのかもしれませんが、

それを受け取る側からしたら、かなり威圧的に感じるはずです。</p>
それが結局のところ、コードレビューが怖いの原因になったりします。</p>
また、このような攻撃的なコメント以外にも、

決めつけのようなコメントも好ましくないなと個人的には思います。</p>
例えば、「ここはちょっとまずいですね。修正してください」のような、

まずいことが前提で話を進めてしまうのは、一方的なコミュニュケーションになりがちです。</p>
ただ、コードレビューの難しいところは、</mark>

まずいコードは確かに指摘する必要があるので、</mark>

まずいコードを見つけて、黙認するのもよくありません。</mark></p>
その場合は、「ここのコードはこういう風にしたらどうでしょうか？」と

あくまで提案スタイルでコメントするのが好ましいと思います。</strong>

その際、例示のコードも一緒に添えておくと親切かと思います。</p>
コードレビューは品質担保の側面ももちろんあるのですが、

それ以前に、コミュニュケーションの一種です。</strong></p>
コードレビューしていると、目の前のコードばかりを見てしまって、

忘れがちですが、向こうにはそのコードを実装してくれた人がいるということを

忘れてはなりません。</p>
基本的に、コードレビューは、実装者とのコミュニュケーションです。</strong>

一方的だったり、高圧的だと、円滑なコミュニュケーションになり得ないのは

言うまでもないかと思います。</p>
コードレビューのコミュニュケーションの側面を軽視しすぎた結果が、

コードレビューが怖いというイメージの醸成にもつながっているのかと思います。</strong></p>
それに、レビューワーと実装者のスキルレベルがよほど離れている場合を除いて、

基本的にそのコードについては、実装者が一番詳しいものです。</strong></p>
なので、そもそも実装者はコードレビューに対して、

異議があれば、「ここはそういう意図ではありません」という風に、

反論するのも全然ありです。</p>
基本的にコードレビューは、

先輩エンジニアが後輩のコードをレビューして

修正させるという一方通行のものではなく、

対話の場所ということは軽視すべきではないと思います。</p>
コードレビューのやり方</h3>
上記を踏まえて、

コードレビューのやり方ですが、

基本的には下記の点が重要だと思います。</p>

コメントは必ず敬語</li>
実装者へのリスペクトを忘れない</li>
良くないと思ったコードは提案形式でコメントする</li>
最終的に修正するかどうかは、よほどまずいコードとかじゃない限り実装者に任せる(修正を強制したり、指揮命令関係になるべきではない)</li>
まずいと思ったコードも、即座にまずいと決めつけるのではなく、そういうコードにした意図を聞く</li>
レビューワーは、質問や提案をしていくことで、実装者にまずい部分を気付かせるのが理想(直接ここがだめとは指摘しない)</li>
レビューワーは、実装者が考慮していなさそうな部分(実装者の苦手部分)とかでコードを見て、まずい部分を探す</li>
動作確認して問題ないか確認する</li>
良いと思ったコードは、褒める(ただ、これはレビューワーが実装者よりも先輩の場合。同階級だと下手に優劣の文脈が生じる可能性があるのでケースバイケース)</li>
</ul>
要するに、コードレビューは、

実装者とのコミュニュケーションで、

実装者へのリスペクトを忘れてはならないということが、

最も大切なことだと思います。</strong></p>
世間で強強と言われている人に限って、

自分がスキルが高い反面、

こういった基本的なことを軽視している印象があります。</p>
変数の命名、リーダブルコードとかでもわかりますが、

コードを書くことは、チーム開発で、

他のエンジニアがどう受け取るかということを汲み取る力は、

エンジニアの基本スキルです。</strong></mark></p>
世間で強強と言われていても、

こういったことを軽視するような人(所謂ブリリアントジャーク)は、

二流、三流と言わざるを得ません。</p>


【強強エンジニアになるための習慣】技術力を高める方法
2023-10-05T00:00:00+00:00
エンジニア界隈で、

しばしば「強強エンジニア」という

ワードを耳にします。</p>
スラングのようなものなので、

厳密な言葉というわけではありません。</p>
しかし、この「強強エンジニア」という言葉は、

一定の市民権を得ている、エンジニアのキャリアを考える上で、</strong>

そこそこ重要な言葉だとも思います。</strong></p>
そこで本記事では、この「強強エンジニア」というものに

焦点を当て、その意味から、

そうなるための具体的な施策を紹介します。</p>
強強エンジニアとは何か？</h2>
はじめに申し上げたように、

この言葉はスラングのようなものなので、

厳密な定義が存在するわけではなないと思います。</p>
そのため、人によって、

定義が微妙に異なるかと思いますが、

一般的には、技術力が高いエンジニア</strong>を

指す言葉だと思います。</p>
ただ、どの程度で技術力が高いのかというと、

難しい話題です。</p>
本記事では、下記のようなエンジニアを強強エンジニアと</strong>

定義します。</strong></p>

</blockquote>

強みがある技術についての弱いところと強いところを理解している(専門性)</li>
技術選定、コードレビューを行える(検証・査定能力)</li>
使ったことがない技術に対するキャッチアップや応用が利く(応用性)</li>
インフラ、ミドルウェアなどプログラミング言語以外についての知見が深い(専門性)</li>
自分が足りていない部分を理解している(マインド)</li>
アルゴリズムの理解やプログラミングスキルが高い(競技プログラミング・コーディングスキル)</li>
要件定義から保守運用まで一人で行おうと思えば行える(実務性)</li>
設計、アーキテクチャについての視点がある(専門性)</li>
</ul>
これら全てを満たしていないと強強エンジニアとして

認めないというわけではなく、これらの80%ぐらいを

満たしていれば強強エンジニアと十分言えると感じます。</p>
特に、専門性、検証・査定能力、応用性、実務性、コーディングスキルの5つの部分を

満たしていれば、かなりの強強エンジニアだと思います。</p>
具体的なイメージ像としては、

TypeScript/Next.jsのフロントの実装もでき、

GoやSQLなどのバックエンドもある程度でき、

AWSなどのインフラへの理解もある、フルスタックエンジニアっぽい

ベテランエンジニアとかがわかりやすいと思います。

(この場合、上記でいうと実務性が特に高い強強エンジニア)</p>
一般的な強強エンジニアというと、

このように、「この人に頼ればなんとかしてくれそう」みたいな

ものが多いと思いますが、個人的にはこれに限らず強強エンジニアは

存在すると思っています。</p>
ちなみに、個人的には、

このような強強エンジニア = フルスタックエンジニアという

認識ではおりません。</p>
フルスタックエンジニア</a>も、曖昧な言葉なので、

以前、下記の記事で考察しているので、

良ければご参考ください。</p>
[st-card myclass="st-no-shadow" id="817" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
以下、このようなエンジニアになるために必要な

習慣について考察します。</p>
強強エンジニアになるための習慣</h2>
専門性、検証・査定能力、応用性、実務性、コーディングスキル、マインドなどの、

部分ごとに役に立つであろう習慣を紹介します。</p>
まず、それぞれの抽象レベルでの話をしたあと、

具体的な実行策を紹介します。</p>
競技プログラミング</h3>
1つ目は、競技プログラミングです。

これは、コーディングスキルやマインド</strong>の面で

大きく役に立ちます。</p>
そのため、競技プログラミングだけやっていても、

上記であげた、実務性、専門性などの能力は伸ばしにくいので、

それらは他でカバーする必要があります。</p>
けれども、コーディングスキルという観点では、</strong>

最も寄与する習慣だと言っても過言ではないでしょう。</strong></p>
上記の実務性が強いエンジニアも、

この競技プログラミングとかでのコーディングスキル面で、

強強エンジニアかというと必ずしも断定はできないでしょう。</p>
人によっては、競技プログラミングは

意味ないと言う人もいるぐらいですからね。</p>
個人的には、</strong>

競技プログラミングはめちゃくちゃ役に立ちます。</strong></p>
基本的なプログラミングの思考能力や、

実装能力や競技プログラミングでかなり鍛えることができます。</p>
また、競技プログラミング界隈は、

自分より優秀な人がうんざりするくらいいるので、

自分より優秀な人が多くいる環境にいても、

めげずに励み続けるマインドを養うこともできます。</p>
たしかに、競技プログラミングが直接実務に役立つとは

言い難いですが、強強エンジニアになるための、

一つの習慣になることは間違いないです。</p>
AtCoder</h4>
具体的なアクションとして、

まずは、AtCoderでのACを

毎日必ず一つは狙うとか、

毎日CとかD問題とか、

何らかの問題を解くのがいいかと思います。</p>
似たようなものとして、

転職サイトのPaizaとかもありますが、

習慣という意味では、やはり王道ですが、

AtCoderが一番おすすめです。</p>
AtCoder Problemsのコンテストを毎日解いて、

毎日解説を読むという習慣を始めてみてはどうでしょう？</p>
https://kenkoooo.com/atcoder/#/table/</p>
</p>
個人開発</h3>
次は、個人開発です。

これは、かなり万能でして、

専門性、検証・査定能力、応用性、実務性、コーディングスキル、マインドのほぼすべてを</mark>

カバーすることができる無敵の習慣でしょう。</mark></p>
個人開発の最大のメリットは、

実務で補えない部分を自分でコントロールできるという点にあります。</p>
個人開発で収益化に成功すれば、

実務経験にカウントすることもできると思うので、

実務経験有りの技術を増やす手段としても有用だと思います。</p>
Next.js/Go/AWS/Docker/Kubernetes/Redisのようなポートフォリオを作る</h4>
個人開発者として大成するのが目的ではなく、

強強エンジニアになるための習慣という文脈では、

作りたいものではなく、使いたい技術ベースで開発をしていいと思います。</strong></p>
その際は、タイトルにあるような、

技術スタック例でアプリケーションを作成したりすれば、

かなり役に立つと思います。</p>
この際、どのような技術を選定して、

どういう技術構成にするか自ずと考えることになるので、

検証・査定能力も伸ばすことができますね。</p>
実務未経験技術の定期的なキャッチアップ</h3>
これは、主に、

応用性やマインドに効果的です。</p>
実務経験だけだと、しばしばずっと使っている技術に

慣れすぎてしまい、新鮮な気持ちを忘れてしまうこともあります。</p>
そのため、たまにはあまり使ったことがない技術を触るのも、

自分の中での技術のインデックスを増やすことができます。</p>
これは専門性をのばすというよりは、

自分の「詳しくは知らないけど、ちょっと触ったことがあるから、

なんとなくはわかる」という領域を増やす作業とも言えるでしょう。</p>
Rustを勉強してみる</h4>
Rust経験者の方は、

Haskellとか、Scalaとかでも

なんでもいいのですが、

とりあえず、自分が強い言語と真逆の性質を持つ言語</strong>

を学ぶことをおすすめします。</strong></p>
Railsエンジニアの人は、

静的系で、非Web系のC++とか

C#とか。</p>
JavaとかC++とかの人は、

逆にWeb系で動的言語の、

Rubyとか、Pythonとか。</p>
本記事を読んでいる方は、

Web系エンジニアの人が多いと思うので、

タイトルではRustとさせていただきました。</p>
VSCodeをやめる</h4>
VSCodeを使っている人は

多いと思うのですが、

一度、慣れ親しんだ開発環境から抜け出して、

違う環境で開発をするのも新しい発見とかあっておすすめです。</p>
Eclipseとか、Emacsでも、Vimでもなんでもいいと思います。</p>
本ブログでは、VimやNeovimについては、

割と多めに情報発信をしているので、

良ければご参考ください。</p>
[st-card myclass="st-no-shadow" id="133" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
逆にVimとかを使っている人は、

VSCodeとかもたまには使うのもいいと思います。</p>
OSS開発</h3>
OSS開発は、主に、

専門性、検証・査定能力に大きく寄与することが

期待されます。</p>
それ以外の部分にも寄与してくれると思いますが、

OSS開発は、基本的には難易度が高いコードを読むことになると思うので、

大抵の場合自分の強い技術を更に強くするために役立つ習慣と言えるでしょう。</p>
普段使っているライブラリのコードを読む</h4>
いきなりPRを出すのは、

ハードルが高いと思うので、

まずは、よく使っているライブラリとかの

コードを読む習慣をつけるのがおすすめです。</p>
Railsとかだと、

Gemとかがたくさんあって、

読みやすいものもたくさんあるので、

おすすめです。</p>
数学・CS</h3>
これは、応用性やコーディングスキルに間接的に

寄与すると思われます。</p>
新しい技術も根本的には古い技術と似ているところがあったりしますが、

そういう部分の理解は、こうした数学やCSの造詣があると、

スムーズな印象があります。</p>
数検準一級を取得する</h4>
理系の人は、不要なのですが、

文系エンジニアの方は、数検準一級を

取得してみるのも面白いのではないでしょうか？</p>
なんだかんだで数学の知識が必要になってくる場面も

たまにあるので、最低限の数学の知識はやはりほしいところです。</p>
数検準一級は、ちょうど高校卒業レベルぐらいなので、

レベル感もちょうどいいかと思います。</p>
UoPeopleや放送大学</h4>
CSの勉強手段として、

シンプルに大学に行くというのも、

有りだと思いますが、

社会人だとなかなか難しいですよね。</p>
そんな中、選択肢として出てくるのが、

オンラインの大学のUoPeopleとか放送大学です。</p>
特にUoPeopleは、CSの学位がもらえるので、

おすすめです。（私は挫折しました)</p>
学位とかより、シンプルに知識を身に着けたいという人は、

放送大学とか、JMOOCとかgaccoとかでも

いいと思います。</p>
https://www.jmooc.jp/</a></p>
https://gacco.org/</a></p>
Udemyとかでもいいと思いますが、

有料の割に、かならずしも質が高いかというと

微妙なので(主に専門性の深さの点で物足りなさを感じる)、

個人的には可もなく不可もなくという印象です。</p>
Udemyは実務未経験技術のキャッチアップという文脈では、

取っ掛かりとしては悪くないなと思います。</p>
おすすめしない習慣</h2>
上記で、強強エンジニアになるための、

習慣をざっと述べましたが、

それとは逆に、

強強エンジニアっぽくない習慣も少し紹介しようと思います。</p>
あくまで、私個人の意見ということと、

ここにあげる習慣が悪いというわけではなく、

こればっかりやるのは良くないという意味</strong>だということは

ご了承ください。</p>
公式ドキュメントよりもQiitaや個人の技術ブログとかを読む</h3>
技術ブログを運営している私としては、

あまり言いたくないことではありますが、

強強エンジニアの人って、そもそも</strong>

技術ブログとかQiitaをあまり見ていない印象があります。</strong></p>
なぜかというと、彼らは公式ドキュメントで足りているからです。</p>
公式ドキュメントは、正確性・網羅性などの、ほぼすべての点で、

個人のブログなどの情報よりも勝っています。</p>
そのため、まず公式ドキュメントを読むということは基本といえば

基本です。</p>
これを軽視して、公式ドキュメントを読む前に、

Qiitaとかを漁ってしまうのは、

あまり良い習慣とは言えないでしょう。</p>
Qiitaや個人のブログは、

使ったことがない技術に対するキャッチアップや応用が利く(応用性)の面で、

寄与するのに対し、公式ドキュメントは、

専門性に寄与すると言えるので、

Qiitaとかは、自分の技術のインデックスを増やす

ために活用するのがいいのかなと思います。</p>
プログラミング言語やFWの技術書ばかり読む</h3>
これも、決して悪いことではありません。</p>
むしろ、全然技術書を読まない人に比べると、

大変素晴らしいです。</p>
ですが、プログラミング言語の学習やFWの学習というのは、

煎じ詰めると、Qiitaの場合と同じく、

自分のインデックスを貼る作業に近く、

使える道具を増やすスキルになるので、

専門性を極める作業とは言い難いです。</p>
強強エンジニアは、基本的に高い専門性を持っているので、

色々な言語やFWを広く浅くやっていては、

専門性を身につけるのはどうしても遠回りになってしまいます。</p>
なので、これらの学習は、あくまで

インデックスを貼る作業と割り切って、

やるのがおすすめです。</p>
個人的には、こういった技術書よりも、

設計手法やアーキテクチャー、ミドルウェアとかの

技術書を読む方が、プログラミング言語に関わらず活かせる知見になるので、

使える領域が増えるのでおすすめです。</p>
ちなみに、おすすめの技術書</a>のついては、

下記の記事でも紹介しているので、

良ければご参考ください。</p>
[st-card myclass="st-no-shadow" id="1271" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
資格取得にこだわりすぎる</h3>
しばしば議題にのぼる、

資格論争ですが、

これも基本的には、

こだわりすぎる必要はないと私は考えます。</p>
もちろん、あるに越したことはありません。</p>
ただ、強強エンジニアになるための、

近道ではないかと思います。</p>
自分が勉強したい分野があり、

そのための手段としてついでに資格も取るというのが、

最も合理的かと思います。</p>
資格取得を目的にして、

闇雲に受験するのは、

おすすめしないです。</p>
副業ばかりで本業をおろそかにする</h3>
これもあるあるですね。</p>
副業が忙しくて、

本業の仕事を雑にしてしまうことです。</p>
これは、処世術としては、

悪くないのですが、

技術力を伸ばして、

強強エンジニアになるという点ではあまり得策ではありません。</p>
というのも、副業で得られる技術的知見と、

本業で得られる技術的知見とでは、やはり

本業の方が遥かに多いからです。

(もし本業のほうが少ないとしたら、

それはある意味で転職のサインかもしれません)</p>
転職の面接とかでも、

基本は本業でどのようなことをしてきたか聞かれます。</p>
本業でのらりくらりやっていただけでは、

良い回答はできないかもしれません。</p>
強強エンジニアと普通のエンジニアの違い</h2>
最後に、強強エンジニアと普通のエンジニアの違いとして

いくつか、独断と偏見で思いついたものを並べておきます。</p>

</td> 強強エンジニア</td> 普通のエンジニア</td></tr>
エラーへの捉え方</td> 話し相手。出てきくれて嬉しい</td> 面倒くさいから出てくんなよ</td></tr>
技術興味の領域</td> 設計・アーキテクチャ・ミドルウェアなどプログラミング言語によらない技術寄り</td> プログラミング言語、FWなど</td></tr>
技術への興味</td> 強い。土日も開発してる</td> 普通。土日はプログラミングしたくない</td></tr>
普段考えていること</td> 何らかのプログラミングのこと</td> プログラミング以外のこと</td></tr>
情報収集手段</td> 公式ドキュメント</td> Qiitaとか</td></tr>
使ったことない技術について</td> ワクワクする</td> キャッチアップ面倒くさい</td></tr>
自分の技術力について</td> まだまだ未熟と考える</td> そこそこ習得していると考える</td></tr>
</table>


【プログラミング】エンジニア実務経験の幻想について 年数偏重の歪み
2023-08-21T00:00:00+00:00

転職するにもどこも実務経験年数を募集要項にしているな</p>
</blockquote>

ぶっちゃけ自社サービス企業でまったり開発していただけだけど実務経験だけは5年だわ</p>
</blockquote>

副業とOSSコミットと、炎上案件乗り切ったけどまだ実務経験2年。でもそのへんの3 ~ 5年エンジニアに負けていないと思うんだけどな。</p>
</blockquote>
以前、下記のような投稿をしまして、

このテーマについて、もっと深掘りしてみたいという内容です。</p>
X (Twitter) でポストを見る</a></p>
現実問題としては、もちろん実務経験年数があるのが有利ですが、

果たして、この実務経験年数がどれぐらい信頼性があるのかは、

気になるところ。</p>
本記事では実務経験年数について、考察を深めたいと思います。</p>
Youtube動画でも取り上げた話題です。</p>


  </iframe>
</div>
エンジニア採用にまつわる実務経験について</h2>
実務経験とは？</h3>
まず、そもそも実務経験とは？って話ですが、

文字通りの意味で、エンジニアとしてお金をもらって従事した経験のことですね。</strong>

会社で働いたりとか、フリーランスで案件を行ったり、

個人開発アプリで収益化とかしたら実務経験といえるでしょう。</p>
また、収益化ではなくとも、

OSSに継続的なコントリビュートをすれば、</strong>

これも実務経験にカウントできるでしょう。</strong></p>
なぜなら、OSS開発は、基本的に高難易度のことが多く、

独力でOSSのコードを読んで、issueを把握して、プルリクエストを出して、

mergeされるという過程を要するため、

プログラミングスキルが高くないと努まりません。</p>
ただ、OSSとはいっても、私が適当に作ったクソアプリもジャンル上OSSになってしまうので、

基本は多くのエンジニアやユーザーなどに使われている大規模OSSであることが前提になります。</p>
Ruby界隈とかだと、Railsをはじめとする、有名なrspec, rubocop, kamainariのようなGemがわかりやすいと思います。</p>
基本的にこれらの経験が実務経験といえるでしょう。</p>
エンジニア採用での募集要項</h3>
さて、そんな実務経験ですが、Webエンジニアなどの場合、

就職などする場合、必ずといっていいほど実務経験が重視されます。</p>
中途採用の一般的なボーダーとしては、

実務経験3年を設けている企業が多い印象です。

(そして大抵の場合、言語やフレームワークごとに年数を設けています。)</p>
Webエンジニアをはじめとした、ソフトウェアエンジニアは、

高度な専門知識が要求される職業のため、

一定の実務経験を募集要項に求めるのは、

非常に合理的なやり方だと言えるでしょう。</mark></mark></mark></p>
しかし、個人的な印象としては、

あまりにこの実務経験を過信しすぎているような気もします。</p>
というのも、そもそもこの実務経験というものが、

よくよく考えると曖昧で、指している領域が広すぎるからです。</p>
例えば、冒頭の投稿がいい例です。</p>
X (Twitter) でポストを見る</a></p>
この場合、

前者のエンジニアは、実務経験こそ3年ありますが、

3年間、同じ言語やフレームワークなどを使い、

保守がメインで新規でゴリゴリ開発する機会はそこまで多くなかったとすると、

大抵の場合、後者のエンジニアのほうが、スキルとしては、優れている可能性が高いでしょう。</p>
それでも、多くの場合足切りにひっかるのは、

後者のエンジニアになってしまいます。</p>
このような業界の構造が、

歪に感じるのは私だけでしょうか？</p>
主に、下記の点でいびつさを感じます。</p>

</blockquote>

実務経験偏重すぎる</li>
早期離職がマイナスになる(これは確かに一般的にはマイナスでしょうが、エンジニアの場合必ずしもマイナスにならないと思います。)</li>
実務経験の中身で何をやってきたか、実務経験年数より軽視される。</li>
そもそも実務経験年数だけでプログラミングスキルレベルが図れるという前提のもとに動いている気がする</li>
</ul>
実務経験年数至上主義</h3>
基本的に、ITエンジニアの募集要項は、

実務経験3年や、5年といった年数ありきで、

採用が行われている印象があり、

この年数を満たしていないと足切りされることが多分にあります。(実体験)</p>
このやり方は、合理的だと感じる一方、

乱暴だとも感じます。</p>
上記のようなケースで正しい判断ができないからです。</p>
また、実務経験年数というものも、

ただ、だらだらとエンジニアとして過ごして年数を稼ぐことも可能な点で、

過信しすぎるのもどうなのかなと感じます。</p>
</p>
副業が可能な今では、１年でも３年に劣らない濃い経験を積んでいるエンジニアも多いと思うので、

経験年数を足切りにするのは、そういった優秀なエンジニアを落としてしまう可能性がある気がします。</p>
また、実務経験が少ない人のほうが、

若い人の方が多い分、新しい技術に積極的だったり、

柔軟だったり、勢いがあったりすることもあるので、

必ずしもデメリットになるとも限らないとも思います。</p>
これらの点で、実務経験年数だけを過信するのは、

合理的なのか疑問が残ります。</p>
エンジニアのキャリア</h2>
エンジニアをキャリアを考える点では、

様々な尺度があると思います。</p>
本記事では、主に早期退職や自社サービスキャリアについて

考察します。</p>
以前、こちらの記事</a>では、フルスタックエンジニアについて、

考察しました。エンジニアのキャリアという観点では、

こちらの尺度も考察しがいがある論点だと思うので、

興味がある方は、ご覧いただけますと幸いです。</p>

</blockquote>
エンジニアの早期離職</h3>
一般的に、キャリアにおいて、

早期離職は、企業側にとって

育成コストが無駄になったりと、

デメリットが大きい分、

早期離職するような人材は、採用しにくいというのはあると思いますし、

これ自体はそのとおりだと思います。</p>
ただ、エンジニアの場合、

色々なプロジェクトやシステムに触れた方が、

濃い経験が積めるのは確かなので、

エンジニアとしての成長を考えると、

どうしても早期離職して、色々なシステムに触れるという経験が必要になる気がします。</p>
Sierなどの受託開発の場合は、

転職しなくとも、様々なプロジェクトにふれることができるかもしれませんが、

それでも実際は、各Sierも自社の強み技術のようなものがあって、

案件も似たりよったりになりやすいということはあるので、

転職に比べると、全く別のシステムに触れられるという経験は積みにくいと思います。

（私が以前努めていたSierは、Railsに定評があったので、

ほぼ全ての案件がRailsでしたし、Railsデファクトの思想でプログラミングされていたので、

Rails界隈ではそこまで流行っていない、DDDのような設計手法などに疎かったり、遅れがちな印象は有りました)</p>
</p>
それに自社サービスだと、

転職をしないと、他のサービスを見る機会がOSSしかなくなるため、

なおさら、色々なシステムに触れる機会が少なくなってしまうでしょう。</p>
そのため、ぶっちゃけた話、エンジニアにとっては、

早期離職しないことのほうが、自身の技術力を停滞させてしまうかもしれないリスクを

抱えているとも捉えることができます。</p>
企業側にとっては、早期離職はリスクなのに対し、、

エンジニア側は、早期離職しないことのほうがリスクになりうるという点で、

双方が真逆のニーズになってしまっているという特徴はあると思います。</p>
なので、現状の策としては、

巷でよく言われているように、3 ~ 4年間ぐらい在籍して、

転職するのが一番賢い立ち回りのような気がします。</p>
様々なシステムをみて、技術力を高めるという点では、

フリーランスが一番適しているのかもしれません</p>
自社サービスキャリアの違和感</h3>
新卒で自社サービスの会社に就職して、

三年間ぐらいずっとエンジニアとして勤務した場合、

実務経験三年のエンジニアになります。</p>
なので、一般的な募集要項の足切りはだいたいクリアできるかと思います。

ただ、正直このパターンのエンジニアは、次のような懸念があるように思えます。</p>
[st-midasibox title="自社サービスエンジニアの懸念点" webicon="st-svg-exclamation-circle faa-flash animated" bordercolor="#f44336" color="" bgcolor="#ffebee" borderwidth="" borderradius="5" titleweight="bold" myclass=""]</p>

様々な案件、システムなどを経験していない</li>
使用技術が三年間同一または、似たりよったり</li>
企業にもよるが運用メインの場合は、プログラミングスキルが低いことが予想される</li>
良くも悪くもぬるま湯パターンが多い</li>
</ul>
もちろん、あくまで懸念なので、</strong>

これに当てはまらない優秀な自社サービス勤務のエンジニアもたくさんいると思います。</strong>

（それに自社サービスは、最初の時点で就職難易度が高いですし)</strong></p>
ただ、もしフロントエンジニアとかであれば、

自社サービス出身の人は、懸念点が多い気がします。</p>
というのも、自社の場合、

使用技術を簡単に変えることができないので、

何だかんだでレガシー技術をリファクタリングして運用していくことが必要になるため、

モダンフロントエンドにふれる機会がなかったりします。</p>
</p>
ただ、これは、フロントエンドエンジニアにとっては、

場合によっては致命傷になる気もするので、

自社サービスで3年間実務経験を積んだから、

足切りが突破しやすくなるというのは、

個人的にはかなり違和感があります。</p>
例えば、jQueryで運用されているレガシーシステムの自社フロントエンドエンジニアなどが

いい例かもしれません。</p>
三年間jQueryだけを使っていたフロントエンドエンジニアとなると、

現在ではかなり厳しい気がしますが、実務経験年数で言えば

3年なので、足切りは免れるでしょう。</p>
そうなると、実務経験年数は、

やはり信用ならないというのが無難な見方ではないでしょうか。</p>
それに自社サービスは、

コードがきれいなことも多く、

プロダクトとしては成熟していることが多いので、

スパゲッティコードへの免疫もつきにくい気もします。</p>
メンテンスしやすいコードの保守開発を3年間やったのと、

スパゲッティコードを1年間でなんとかメンテナンスできるレベルまで、

リファクタリングしたのとでは、圧倒的に後者のほうが高いスキルが要求されるのに、

前者のほうが転職市場では有利というのがやはり違和感があるところです。</p>
まだまだ少ないコーディングテスト</h3>
結局のところ、

無難にコーディングテストなどをするのが、

一番不公平がないように思いますが、

なんだかんだでまだまだ面接重視の企業が多い気もします。</p>
個人的には、コーディングテストはそこまで得意じゃないので、

これは嬉しいような気もしますが、

エンジニア採用の歪さという観点では、

コーディングテストをやらずに、実務経験年数で足切りをするのは、

かなり歪だと感じます。</p>
そういう意味では、私もどうせ落とされるなら、

コーディングテストで落とされたいと思います。</p>
エンジニアにとっての理想</h3>
ここからはあくまで私の理想でしかないですが、

エンジニアが継続的に技術を高めていくには、

下記に似た戦略を取る必要はあると思います。</p>
転職市場ではもてはやされる、自社サービス勤務のエンジニアは、

エンジニアとして成長できているかという観点で言えば、

必ずしもYesとは言えないでしょうから。</p>
さて、エンジニアにとっての理想ですが、</p>

</blockquote>

退職をしなくても様々な企業に在籍できること(現在での副業をもっと柔軟に適用されること)</li>
自社サービス勤務は、技術を高めるという観点では、3 ~ 5年で転職するのが良いということ</li>
実務経験年数ではなくて、何をやったかで技術力が評価されること</li>
</ul>
といった感じでしょうか。</p>
結論</h2>
結論、エンジニアの転職市場においては、</strong>

必ずしもスキルが評価されるとは限らないということです。</strong></p>
もし、ホワイトの企業でまったり経験を積める状態なのであれば、

焦らず、そこで窓際族として経験年数を増やして行ったほうが、

市場価値の高いエンジニアになれるということです(もちろん、これはものすごく歪ですが)</p>
エンジニアは、技術が好きで、休日も勉強している人が理想とかって言われがちですが、

このような業界構造だと、窓際族で実務経験年数だけ増やして行ったほうが得なので、

キャリアとしては、休日勉強するのはコスパが悪いということになりがちです。</p>
なので、私としては、このような歪な構造が撤廃されることを願っています。

私と同様に業界の歪だと感じた方は、X（旧ツイッター)やSNSなどでシェアしてくださいますと嬉しいです。</p>
Qiitaの方も見てくださいますと、

嬉しいです。</p>
https://qiita.com/reisuta</a></p>


【Dockerコマンド】よく使うものpull image run execなど
2023-08-11T00:00:00+00:00
Dockerを使うには、

Linuxと同様にいくつかの典型的なコマンドを使いこなす必要があります。</p>
ただ、種類が多いことから

「どれがどれだったっけ？」ってなることもしばしば。</p>
本記事では、とりあえずこれだけは知っておきたいDockerコマンドの紹介</strong>と解説</strong>をします。

忘れてしまったときなど本記事を見返せば、

思い出せるようにある種のチートシート的にも

構成していますので、ぜひご参考ください。</p>
また、本記事の内容は、

下記動画でも視聴できるので、

併せてご参考ください。</p>


  </iframe>
</div>
Dockerコマンドの基本構成</h2>
dockerのコマンドは、一般的には下記の書式に従って実行します。</p>
docker コマンド オプション</span></span></code></pre>
前回の記事</a>で、「Dockerとは？」というDockerの基礎について触れたもので、

runやstartなどが出てきたと思いますが、コマンドというのはこれらに該当します。</mark></p>
オプションというのは、docker runコマンドなどでいうと、</mark>

コンテナ名を指定する、--nameやポート番号を指定する-pなどが該当します。</mark></p>
[st-card myclass="st-no-shadow" id="1077" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
コンテナ起動から終了まで</h3>
コマンドの個別解説の前に、

コンテナの起動から終了までのライフサイクルをまとめます。</p>
例えば、前回の記事(上の参考リンクの記事です</a>)で登場した、

docker runコマンドは、pull、create、startの３つのコマンドをまとめて実行するコマンドでもあります。</p>
docker run -dit --name sample -p 8080:80 -v "$PWD":/usr/local/apache2/htdocs/ httpd:2.4</span></span></code></pre>
これは下記と同様です。</p>
docker pull httpd:2.4</span></span>
docker create --name sample -p 8080:80 -v "$PWD:/usr/local/apache2/htdocs/ httpd:2.4</span></span>
docker start sample</span></span></code></pre>
つまりdocker runコマンドの場合は、

ローカルにイメージがなければリポジトリが持ってきて、

作成、起動までやってくれるわけです。</p>
なので、リポジトリからイメージを持ってくるだけに留めたい場合は、

上記で使っているdocker pullコマンドを使用します。</p>
ローカルに何もイメージがない状態での

大まかなライフサイクルをまとめると、</p>
pull(リポジトリからイメージを取得) → 作成 → 起動 → 停止 → 削除</strong></p>
という風になるのが一般的かと思います。

（作成してimage削除とかもあったりするので、必ずしもこの限りではないですが、

大まかな流れとしては上記のような感じです)</p>
それでは次から、コマンドの個別解説に移りたいと思います。</p>
Dockerコマンド使い方</h2>
docker pull</h3>
docker pullコマンドは、docker hubなどのレジストリから、

イメージを取得するコマンドです。docker hubなどを見るとわかりやすいと思います。</p>
https://hub.docker.com/_/ubuntu</a></p>
ここで、下記のようなコマンドが記載されてあったと思います。</p>
docker pull ubuntu</span></span></code></pre>
これはまさにubuntuというイメージを取得するコマンドですね。</p>
イメージ名には、タグをつけることも可能です。</p>
タグというのは、そのイメージの分類名のようなものを指しており、

主にversionや安定版・開発版などを示したりするときに使われています。</strong></p>
これは例えばrubyイメージとかだとわかりやすいですね。</p>
https://hub.docker.com/_/ruby</a></p>
docker pull ruby:3.0</span></span></code></pre>
この場合は、rubyの3.0系を設定します。

dockerのメリットとして、このようにプログラミング言語などの

versionをコンテナごとに設定できるというのがあるので、

tag設定はこういうときに便利ですね。</p>
slimとalpine</h4>
rubyなどのプログラミング言語のイメージのタグには、

しばしば、こうしたslimやalpineというタグが存在します。</p>
おそらく、プログラミング言語間で大きな差異はないかと思いますが、

Rubyの場合で解説します。</p>
slimは、公式では次のように説明されています。</p>

This image does not contain the common packages contained in the default tag and only contains the minimal packages needed to run ruby. Unless you are working in an environment where only the ruby image will be deployed and you have space constraints, we highly recommend using the default image of this repository.</p>
https://hub.docker.com/_/ruby</p>
</blockquote>
最小限のパッケージしか入っていないので、

容量などの制約が大きいなどの事情がなければ、

そこまでおすすめはしないということですね。</p>
slimを使わずとも、defaultのtagsの方がすんなり環境構築できるかと思いますし、

ニーズがよくわからないときは、default(ruby:3.0みたいなもの)を使うことを

公式も推奨していました。</p>
なので、slimを使うのは軽量化したいというニーズがあることに加え、

自分で必要なパッケージとかを見極められる場合になると思うので、

割と上級者向けのタグですかね。</p>
これに対して、alpineについては、次のように説明されています。</p>

This image is based on the popular Alpine Linux project, available in the alpine official image. Alpine Linux is much smaller than most distribution base images (~5MB), and thus leads to much slimmer images in general.</p>
This variant is useful when final image size being as small as possible is your primary concern. The main caveat to note is that it does use musl libc instead of glibc and friends, so software will often run into issues depending on the depth of their libc requirements/assumptions. See this Hacker News comment thread for more discussion of the issues that might arise and some pro/con comparisons of using Alpine-based images.</p>
To minimize image size, it's uncommon for additional related tools (such as git or bash) to be included in Alpine-based images. Using this image as a base, add the things you need in your own Dockerfile (see the alpine image description for examples of how to install packages if you are unfamiliar).</p>
https://hub.docker.com/_/ruby</p>
</blockquote>
これも、軽量系のタグで、Alpine Linuxという軽量のOSをベースにしているものです。

なので、slimと同じく軽量化のニーズがある場合には有用かもしれませんが、

musl libcというのを使っているようなので、それ関係の要件や依存関係に引っかかったりする懸念が

あるようです。</p>
こちらは、そもそもベースが大きく異なるので、

思わぬエラーに遭遇しがちだと思うので、ある程度慣れている人向けの印象があります。</p>
alpineを普段から使っている方であれば、

slimよりもalpine系の方が良いかと思います。</p>
結論、軽量化したいニーズが強くなければ、

これらのタグは選択しなくて大丈夫です。</strong></p>
latestタグ</h4>
こちらのタグは最新版という意味で、

タグ名を省略したときは、latestタグが設定されたものとして扱われます。</strong></p>
開発環境などでは、最新版を使うことに問題はないでしょうが、

latestタグは頻繁に更新されるものなので、

本番環境などでタグを指定しなかったりするのは、

意図せずversionなどが変わってしまい、不具合の原因になるので、

避けるのが無難です。</p>
docker image</h3>
docker image系のコマンドは、

イメージの管理を行うコマンドです。

下位コマンドがいくつかあります。

よく使うのだけ紹介します。</p>
https://matsuand.github.io/docs.docker.jp.onthefly/engine/reference/commandline/image/</a></p>
docker image ls</h4>
これは、イメージの一覧を出力します。</p>
https://matsuand.github.io/docs.docker.jp.onthefly/engine/reference/commandline/image_ls/</a></p>
docker image prune</h4>
こちらは、使っていないイメージをまとめて削除してくれるコマンドです。</p>
https://matsuand.github.io/docs.docker.jp.onthefly/engine/reference/commandline/image_prune/</a></p>
オプションが色々あり、

何も設定しないと、確認のプロンプトが表示されます。</p>
docker image prune</span></span></code></pre>
</p>
プロンプトが不要であれば、

-fオプションで表示させずに実行できます。</p>
docker image prune -f</span></span></code></pre>
--fileterオプションを指定すると、

untilやlabelなどのフィルタリングを行うことができますが、

やや高度で細かいので、untilなどで、特定の時刻前に生成されたイメージを削除するfilterを紹介します。</p>
まず、--formatオプションを使って、

作成日時を表示します。</p>
--formatオプションは、

Go言語のテンプレートを使って、

色々操作できるオプションです。</p>
https://docs.docker.jp/config/formatting.html</a></p>
例えば下記で使われている、tableは、

表示するフィールドを指定します。</p>
docker images --format 'table {{/*.Repository*/}}\t{{/*.Tag*/}}\t{{/*.ID*/}}\t{{/*.CreatedAt*/}}\t{{/*.Size*/}}'</span></span></code></pre>
そして、ここで表示されたCreatedAtを元に、

いつ起点から削除したいか決めます。

2020-09-12T03:23:27以前のイメージを消したければ、</p>
docker image prune -a --force --filter "until=2020-09-12T03:23:27"</span></span></code></pre>
とする。</p>
シンプルに10日以上(240h)前のイメージを消したければ、</p>
docker image prune --filter "until=240h"</span></span></code></pre>
でも行えます。</p>
docker image inspect</h4>
これは、詳細情報を出力します。</p>
詳細情報を知りたいイメージを一つか複数指定します。</p>
docker image inspect vue-sigh-api vue-sigh-front</span></span></code></pre>
上記は、vue-sigh-apiというイメージとvue-sigh-frontというイメージの

詳細情報を出力します。</p>
docker image rm</h4>
こちらはシンプルに削除したいイメージを削除できるコマンドです。

inspectと同様で、一つか複数指定できます。</p>
docker run</h3>
こちらは、コンテナの作成から起動までやってくれる、

いわゆる全部のせコマンドなので、

docker createなどの単体作成コマンドよりも、

圧倒的に使用頻度が高いです。</p>
また、ローカルに存在しないイメージをrunした場合、

リモートから取得してくれるので、pullに相当することもやってくれるので、

まさに全部のせコマンドですね。</p>
</p>
-itオプション</h4>
runコマンドなので、よく見かける、

-itオプションですが、

これは、-iオプションと-tオプションを繋げて表現したものです。</strong></p>
ただ、そうはいっても、それぞれを単体で使うことは

あまりないので、実質-itオプションと思ってしまっても、

そこまで差し支えないと思います。</p>
ドキュメントでは、</p>

-it は疑似 TTY（pseudo-TTY）をコンテナの標準入力に接続するよう、 Docker に対して命令します。つまり、コンテナ内でインタラクティブな bash シェルを作成します。</p>
https://docs.docker.jp/engine/reference/commandline/run.html</p>
</blockquote>
と説明しています。</p>
要するに、-itオプションを指定することで、

dockerコンテナとhostのターミナルを繋げているようなイメージですね。</p>
-itオプションを指定しないと、

コンテナのシェルに接続できないので、

statusはextiedになります。</p>
ちなみに、-iと-tの違いについては、

下記の記事がわかりやすかったです。</p>
https://qiita.com/k_uchida_____/items/8ca31226bd6d10850791</a></p>
--rmオプション</h4>
こちらもよく使うオプションで、

runで起動するコンテナは一時的な用途が多いので、

使わなくなったら、--rmオプションをしないと、

どんどんコンテナが蓄積されていきます。</p>
なので、通常はこちらの--rmオプションを指定し、

コンテナを削除したくないときだけ、

オプションをつけないというふうにするといいと思います。</p>
コンテナでシェルを実行する</h2>
コンテナの中に入って、特定のコマンドを実行したりしたいとき、

そのコンテナに対して、シェルを実行して、コンテナの中に入ることがよくあります。

upしているコンテナに対して、</p>
docker</span> exec</span> -it</span> sample-container /bin/bash</span></span></code></pre>
Ctrl + p、Ctrl + qを続けて押すとでデタッチすることができます。

シェルを終了するには、exitと入力します。</p>
runでシェルを実行した場合、

exitを入力すると、コンテナも停止しますが、

execの場合、upのままです。</p>
基本的には、execですでに起動中のコンテナに対して、

実行することがほとんどかと思います。</p>
基本的に、docker runは、停止中のコンテナに実行して、

シェル終了時は、コンテナ終了するのに対して、

docker execは、実行中のコンテナに実行して、

シェル終了時は、コンテナは実行中のままという違いがあります。</strong></mark></p>
基本的に、Railsとかで開発をしている際に、

使いたいコマンドは、

このコンテナに対して実行するコマンドを使って実行するので、</p>
例えば、rails db:migrateとかは、

docker compose exec コンテナ名 rails db:migrateに変化します。</p>


【未経験からエンジニア】プログラミングスクールおすすめ5選
2023-07-29T00:00:00+00:00
エンジニアになるには？</h2>

エンジニア志望の人</p>
</blockquote>

エンジニアになるためにはプログラミングスクールに通ったほうがいいのだろうか</p>
</blockquote>
プログラミングは、専門性が高く自分一人で勉強するのが大変に感じることも多いですよね。</p>
そこで本記事では「おすすめのプログラミングスクール5選」を特徴と、

現役エンジニア目線で優れているなと思う点を詳しくご紹介します。</p>

[st-square-checkbox bgcolor="" bordercolor="" fontweight="" borderwidth="3"]</p>
</blockquote>

プログラミングの勉強法がわからない</li>
そもそもPCスキルに自信がない</li>
どうすればエンジニアになれるのかわからない</li>
良いプログラミングスクールを知りたい</li>
</ul>
[/st-square-checkbox]</p>
独学でエンジニアになれるか？</h2>
まず、良くある話題として、

プログラミングを独学で勉強するか否かですが、

結論、独学でもプログラミングは勉強できますし、</strong>

エンジニアになることも可能です。</strong></p>
ただ、独学の場合、

勉強や戦略の立て方、転職まで、

基本的に全て自分で考えて行い、

自分で行動するしかないので、大変なことは間違いありません。</p>
具体的に独学でプログラミングを勉強するには、

下記のようなハードルがあります。</p>

[st-square-checkbox bgcolor="" bordercolor="" fontweight="" borderwidth="3"]</p>
</blockquote>

勉強する分野が広い</li>
成果物を作る必要がある</li>
プログラミングで詰まった際に自分で解決するしかない</li>
勉強の方向性が正しいのかを確認する手段が少ない</li>
最低限のセキュリティを知っておく必要がある</li>
</ul>
[/st-square-checkbox]</p>
そのため、プログラミングスクールに通ったほうが、

最短ルートを行くことができるのは間違いないです。</p>
未経験からエンジニアになるために必要な勉強</h2>
さて、未経験からエンジニアになるために必要な勉強ですが、まずここでは、未経験の定義を、

「プログラミング以外のIT知識は最低限身についている(Googleのツールなどを問題なく使いこなせるなど)</mark>」

イメージ像としては、大学時代にPCで授業を受けたり、レポートや重要な情報をPCで管理するなど、

日常的に使いこなせている感じですかね。</p>
その場合、</p>

</blockquote>

HTML/CSSの基礎(フロント志望ならCSSはやや応用まで）</li>
Javascriptの基礎(フロント志望なら応用まで)</li>
バックエンド言語一つのやや応用まで(フロント志望なら基礎まで、あるいはやらなくてもOK）</li>
Linuxの基礎コマンド</li>
Dockerの基礎</li>
エディターを使いこなせる</li>
Gitの基礎</li>
SQLの基礎(バックエンド志望なら応用ぐらいまでやっておきたい）</li>
ターミナルを使いこなせる</li>
フレームワーク一つのやや応用まで</li>
</ul>
と言った感じです。</p>

</blockquote>
うげぇ、めちゃくちゃたくさんあるじゃん！</p>
って思った方がほとんどだと思いますが、

正直な話、かなり厳選してこれです</strong>...</p>
なので、ほんとうはもっとやっておいて欲しい分野もあります。

あくまで上記はマストで、これに加えてやっておくと好ましいものもあります。</p>
一応、当ブログでも上記については、

基本の記事やYouTube動画をあげていますので、

これらの基本を勉強するなら、参考になるかと思うので、

ご覧いただけると。</p>

[st-minihukidashi webicon="st-svg-check" fontsize="" fontweight="bold" bgcolor="#FFECB3" color="" margin="0 0 0 0" radius="30" position="" add_boxstyle=""]フロントエンド(TypeScript) [/st-div] ></p>
</blockquote>
[st-div class="" margin="0 0 -5px -5px" padding="0 0 0 0" add_style=""][st-minihukidashi webicon="st-svg-check" fontsize="" fontweight="bold" bgcolor="#FFECB3" color="" margin="0 0 0 0" radius="30" position="" add_boxstyle=""]バックエンド(Ruby) [/st-div] ></p>
[st-div class="" margin="0 0 -5px -5px" padding="0 0 0 0" add_style=""][st-minihukidashi webicon="st-svg-check" fontsize="" fontweight="bold" bgcolor="#FFECB3" color="" margin="0 0 0 0" radius="30" position="" add_boxstyle=""]Linux基礎コマンド [/st-div] ></p>
[st-div class="" margin="0 0 -5px -5px" padding="0 0 0 0" add_style=""][st-minihukidashi webicon="st-svg-check" fontsize="" fontweight="bold" bgcolor="#FFECB3" color="" margin="0 0 0 0" radius="30" position="" add_boxstyle=""]Docker基礎 [/st-div] ></p>
[st-div class="" margin="0 0 -5px -5px" padding="0 0 0 0" add_style=""][st-minihukidashi webicon="st-svg-check" fontsize="" fontweight="bold" bgcolor="#FFECB3" color="" margin="0 0 0 0" radius="30" position="" add_boxstyle=""]エディター(Vim) [/st-div] ></p>
[st-div class="" margin="0 0 -5px -5px" padding="0 0 0 0" add_style=""][st-minihukidashi webicon="st-svg-check" fontsize="" fontweight="bold" bgcolor="#FFECB3" color="" margin="0 0 0 0" radius="30" position="" add_boxstyle=""]Git基礎 [/st-div] ></p>
[st-div class="" margin="0 0 -5px -5px" padding="0 0 0 0" add_style=""][st-minihukidashi webicon="st-svg-check" fontsize="" fontweight="bold" bgcolor="#FFECB3" color="" margin="0 0 0 0" radius="30" position="" add_boxstyle=""]ターミナル(Tmux) [/st-div] ></p>
[st-div class="" margin="0 0 -5px -5px" padding="0 0 0 0" add_style=""][st-minihukidashi webicon="st-svg-check" fontsize="" fontweight="bold" bgcolor="#FFECB3" color="" margin="0 0 0 0" radius="30" position="" add_boxstyle=""]フロントエンドフレームワーク(Vue.js) [/st-div] ></p>
[st-div class="" margin="0 0 -5px -5px" padding="0 0 0 0" add_style=""][st-minihukidashi webicon="st-svg-check" fontsize="" fontweight="bold" bgcolor="#FFECB3" color="" margin="0 0 0 0" radius="30" position="" add_boxstyle=""]バックエンドフレームワーク(Ruby on Rails) [/st-div] ></p>
メモ</p>
※ 不足している分野は現在準備中です。今後の更新をお待ちいただけますと</p>
ちなみに、最低限のPCリテラシーが自信がない人の場合、

これに加えて、下記のようなことも勉強する必要があるかもしれません。</p>
[st-mybox title="必要なモノ" webicon="st-svg-file-text-o" color="#757575" bordercolor="#f3f3f3" bgcolor="" borderwidth="3" borderradius="5" titleweight="bold" title_bordercolor="#757575" fontsize="" myclass="st-mybox-class st-title-under st-list-circle" margin="25px 0 25px 0"]</p>

タッチタイピングの習得</li>
PCで情報を収集する習慣</li>
Excelやスプレッドシートなど、世間的にやや使いこなすのが難しいツールが最低限使用できる</li>
日常的に使うWeb/ITツールが豊富にある</li>
</ul>
のような状態を目指すと良いかと思います。</p>
意外と甘く見がちですが、

そもそもPCの基本的なスキルが身についていないという人も少なくありません。</strong></p>
こうしたスキルがないままプログラミングを始めても、

挫折率を高めてしまうので、上記のスキルも疎かにしないようにしましょう。</p>
とは言いつつもこのあたりは、

しっかりやれば意外とすぐにできるようになるので、過度な心配は無用です。</p>
独学でエンジニアになる難易度</h2>
上記のエンジニアのになるために必要な勉強をご覧になって</p>

</blockquote>
これぐらいなら楽勝だわ。</p>

楽勝とまでは行かないけど、しっかり勉強しておけば独学でも大丈夫そう</p>
</blockquote>
と感じた人は、

プログラミングスクールは不要です。</strong></p>
というのも、プログラミングスクールの立ち位置的には、

大学受験の予備校などと同じく、あくまでサポートをしてくれるということにあるので、

自分ですべて進めることができる人には不要です。</mark></p>
それに独学でエンジニアになった人のほうが、

すべて自分で何とかするしかない環境上、

自走力やエラー解決力が高い傾向にあるので、

実務に出てからもギャップが少なくできるというメリットがあります。</p>
それに面接などの際も、

独学だと面接官などにも、</p>

この人は独学でプログラミングを勉強しているのか。自走力がありそうで良さそうだな。</p>
</blockquote>
という印象を与えることができるかもしれません。</p>
そのため、独学でできるのであれば、</strong></mark>

そちらに越したことはないです。</strong></mark></p>
なので、本記事のプログラミングスクールへの回答としては、</p>

通わないで、エンジニアになれるのであればそちらに越したことはない</p>
</blockquote>
となります。</p>
ただ、そうはいっても

現実問題そう簡単にはいかないことが多いので、

プログラミングスクールが必要になってきたりします。</p>
実は、プログラミングの挫折率は、

約9割という統計も残っています。</p>
・挫折率の統計記事

https://prtimes.jp/main/html/rd/p/000000003.000047683.html</a></p>
ここからも分かる通り、

プログラミングの独学はかなり難易度が高いことがうかがえます。</strong></p>
例えるなら、大学受験の宅浪に近く、

できるのであれば、それでもいいけど、

本当にできるの？って首をかしげたくなるぐらい、

根気と精神力がいる選択かなと思います。</p>
未経験からエンジニアを目指す場合に、

必要な勉強量は、個人差はありますが、

およそ300時間ぐらいが目安とされています。</p>
これらを踏まえると、独学に次のような壁があるのがわかります。</p>

自力で300時間前後を勉強しなければ行けない壁</p>
</blockquote>

300時間で効率的に必要な勉強をinput/outputしなければならない壁</p>
</blockquote>

上記の知識をもとに自力で成果物を作らなければならない壁</p>
</blockquote>

成果物作成の際に、遭遇したエラーなどを自力で解決しなければならない壁</p>
</blockquote>

これらを踏まえて戦略的に転職活動で内定を取得しなければならない壁</p>
</blockquote>

全てにおいてモチベーションを管理し続ける徹底的な自己管理能力についての壁</p>
</blockquote>
という感じになるかと思います。</p>
これらをすべてを踏まえて、

独学でも大丈夫と思えた人は、

問題ありません！独学でいきましょう。</p>
ただ、多くの人はそういう心境にはならなかったかと思うので、

下記、プログラミングスクールについて紹介していきます。</p>
プログラミングスクールおすすめ</h2>
さて、独学の難易度が凄まじいことをご紹介しましたが、

プログラミングスクールに通うと、

独学時の壁の多くが、ぐっと楽になります。</strong></p>
そのため、未経験からエンジニアを目指すのであれば、

プログラミングスクールに通うのがおすすめではあります。</p>
おすすめのプログラミングスクールをいくつかご紹介します。</p>
DMM WEBCAMP</h3>



  
</a>
ポイント</p>

転職成功率は98%とかなり高い</li>
転職保証があるので、本気で転職したい人には特におすすめ</li>
卒業生限定コミュニティがある</li>
チーム開発やポートフォリオ作成がカリキュラムにある</li>
</ul>

</blockquote>

良くも悪くも万人向けなので、尖っているものを求めている人には物足りないかも</li>
</ul>
DMM WEBCAMPは業界内でも有名なプログラミングスクールで、

迷ったらここでOKとおすすめできるほど総合的に優れているプログラミングスクールだと感じます。</mark></p>
その分、裏を返せば、尖っているものはそこまで多くないので、

一般のプログラミングスクールとは一味違った体験を求めている人には不向きかもしれません。</p>
ただそれ以外は、ポートフォリオコードレビューや、チーム開発をはじめとして、</mark>

質はかなり実践的だと感じます。</mark></p>
また、DMM WEBCAMPは、給付金制度の対象でもあるので、

経済産業省・厚生労働省のお墨付きという点でもおすすめできます。</p>
「とにかくエンジニアになりたい！プログラミングスクールはどこでもいいよ」っていう人は、

ここが一番合うかもしれません。</p>



  
</a>
ウズウズカレッジ</h3>



  
</a>
ポイント</p>

就職定着率97%と高い</li>
プログラミングスクールでは珍しいJavaに特化している</li>
月額制サービスなので気軽に始めたりやめられる</li>
Javaシルバー相当の知識を身につけられる</li>
</ul>

</blockquote>

Javaはいきなりやると挫折する可能性がある</li>
eラーニングかつサブスク性で気軽な分、自走力もある程度必要</li>
</ul>
ウズウズカレッジは、Javaやネットワークなどが強い印象があり、

堅実なプログラミングスキルを学ぶことができるのが特徴です。</p>
しかし、Javaは未経験がいきなり学習する言語としては、

やや難易度が高いため、人によっては挫折してしまう可能性は否定できません。</p>
また、サブスクでeラーニングなので、申し込みの敷居は低い分、

ある程度自分で学習を進めて行かなければならないので、

自走力がある程度必要です。</p>
ただ、Javaは、静的型付け言語の代表選手であり、</mark>

王道言語の一つなので、Javaを習得することができるとかなり強みになると思います。</mark></p>
特にWebエンジニアは、静的型付け言語に苦手意識を持っている人が多いので、

最初にJavaでプログラミングの基礎を学習するのは大きな意味があると思いますし、

長期的に見ると、キャリアの強みになると思います。</p>
加えて、JavaはほかのPythonやRubyなどのWeb系言語に比べると、

未経験にはややとっつきにくい or 地味というイメージをもたれがちな言語なので、

ライバルがこれらに比べると少ないというメリットもあるかと思います。</p>
それに正直なところ、PythonやRubyなどに関しても、

入り口がとっつきやすいだけで、実務で深く学んでいくと、

結構難しい部分がたくさん出てくるので、結局最初に難しい部分に

直面するかどうかの違いだと思います。</p>
Javaの勉強はエンジニアにキャリアに大きくプラスに働くかと思うので、

他の未経験と差をつけたいという方にはとてもおすすめです。</mark></p>



  
</a>
TechAcademy</h3>



  
</a>



  
</a>
ポイント</p>

業界内でも有名で安心</li>
無料体験やカウンセリングなどが豊富にあるので、とりあえず話を聞くだけでもOK</li>
副業体験コースなどもあり、多彩なので幅広い人におすすめできる</li>
エンジニア転職保証コースは未経験から16週間でエンジニアとして就職するまでをサポートしてくれる神サービス</li>
講師の質が高い(全員実務3年以上の現役エンジニア)</li>
</ul>

</blockquote>

コースがたくさんあるので、どれが自分に適しているか判断する必要がある</li>
</ul>
TechAcademyは、業界内でもおそらく一番有名なので、

ご存知の方も多いかもしれませんが、それだけあって、

万人におすすめできる、様々なコースやサポートなどが手厚いのが特徴です。</p>
強いて難点を上げるとすれば、コースが色々ありすぎてどれにすればいいのか、

迷ってしまうということでしょうか。</p>
これに関しても、無料カウンセリングのときとかに、

聞けばいいかなと思うので大きなデメリットではないと思います。</p>
必ずしもエンジニア志望ではない人も、

web制作コースなどもあるので、様々なニーズに対応しています。</p>
もちろん、未経験からエンジニアを目指している人向けには、

エンジニア転職保証コースという、16週間でエンジニアとして就職するまでを徹底サポートしてくれるコースも</mark>

あるので、本気でエンジニアを目指したいという方には強くおすすめできます。</mark></p>



  
</a>
RUNTEQ</h3>



  
</a>
ポイント</p>

数あるプログラミングスクールの中でもガチ感がある</li>
プロダクト創造・企画といったマネジメントの視点があるスクールはかなり珍しい</li>
卒業生の就職先がWeb系の自社開発企業といった高難易度の企業に就職している</li>
卒業生のポートフォリオのクオリティーが未経験のレベルを超えている</li>
プログラミング言語以外の重要な技術もカリキュラムに含まれている</li>
</ul>

</blockquote>

実践的でレベルが高いので人によってはついていけない可能性がある</li>
基本的にRuby on Railsのエンジニアになることが前提</li>
</ul>
RUNTEQは、一言で言うなら、

一番現場感があるプログラミングスクールだと思います。</mark>

カリキュラムも、プログラミング言語はもちろん、

テストフレームワークの使い方、Docker、SQLなど、

未経験者が見逃しがちな技術についてもしっかり触れているのが、特徴です。</p>
そのため、全くのプログラミング未経験(前提知識0)の状態だと、

カリキュラムの内容についていけなくなるかもしれません。</p>
なので、最低限本で軽く読むや調べたりすると良いかなと思います。</p>
ちなみに、RUNTEQで取り扱っている技術は、

当ブログで扱っている技術と似ているものが多いので、

不安であれば、下記のような記事を読んでから受講すると前提知識の不安は無くせると思います。</p>

</blockquote>
[st-card myclass="st-no-shadow" id="692" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
[st-card myclass="st-no-shadow" id="179" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
[st-card myclass="st-no-shadow" id="1077" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
また、RUNTEQは、特化している分、

基本的にはRailsエンジニアになることを想定したカリキュラムになっているので、

Javaエンジニアとか、PHPエンジニアのようなものを考えている人には合わないかもしれません。</p>
とはいっても、実務に入ってしまえばプログラミング言語の違いは些細なものなので、

とりあえずエンジニアになってしまって、その後自分の使いたい言語の分野に転職するとかも可能なので、

個人的にはそこまで大きなデメリットではないかなと思っています。</p>
Railsは、初心者がWebのシステムを学ぶのには敷居が低く、情報量が多い上に、

それでいて技術としての深みもある、素晴らしいフレームワークなので、

初心者から上級者まで使っているWebフレームワークです。

(Railsの学習を通して、GitやSQL、Dockerなども自然と学ぶことができます)</p>
RUNTEQは、Railsだけではなく、こういった周辺技術もカリキュラムに含めているので、

いわゆるRailsしかできないエンジニアになることを防いでくれますし、

真に技術力があるエンジニア養成に寄与していると思います。</mark></p>
それに、テストフレームワークなどについては、独学ではまず

勉強しない気がしますが、実務に出たらこれは必須のスキルなので、

これをプログラミングスクールの学習のタイミングで学べるのは大変ありがたいですね。</p>
また、卒業生のポートフォリオのクオリティーがものすごく高く、

未経験者が作ったものとは思えないクオリティーです。</p>
RUNTEQは、Ruby on Railsを中心に、エンジニアが実務で必要なスキルを洗い出し、

それをカリキュラムに落とし込んでいるような印象を受けました。</p>
もちろん、転職保証なども手厚く、

卒業生も自社開発企業など、高難易度の企業に就職しているので、

その点でも安心ですね。</p>



  
</a>
RailsHack</h3>



  
</a>
ポイント</p>

圧倒的に安い(独学コースは21780円 2023年7月時点)</li>
動画学習なので場所にとらわれず学べる</li>
一度受講すれば、動画をずっと閲覧することができる</li>
パソコンすら触ったことがない人でも大丈夫</li>
簡単なWebアプリを作成できる</li>
</ul>
[st-mybox title="微妙な点" webicon="st-svg-exclamation-circle" color="#ef5350" bordercolor="#f3f3f3" bgcolor="#ffebee" borderwidth="" borderradius="5" titleweight="bold" title_bordercolor="#ef5350" fontsize="" myclass="st-mybox-class st-title-under" margin="25px 0 25px 0"]</p>

ある程度の自走力が必要</li>
やや使用技術が古い</li>
GitやSQLなどがカリキュラムに含まれていない</li>
</ul>
こちらは、上記の4つに比べると、

ややマイナーですが、圧倒的に安く、</mark>

Railsを中心としたプログラミング講座を提供しております。</mark></p>
しかし、動画教材なので、基本的には自分で進める必要があり、

ある程度の自走力が求められます。</p>
また、Bootstrap4やVagrantなどは、

やや使用技術としては古いかなと個人的には感じたので、

モダンな技術を使いたい人には合わないかもしれません。</p>
けれども、未経験の段階などでは、必ずしもモダンな技術を勉強したほうが良いとも限らないので、

Bootstrap4やVagrantのように、ある程度枯れた技術を勉強したほうが、

最新の情報に振り回されないので、学習しやすいかもしれません。</p>
それに、技術の流行り廃りは、常に起きていますが、

技術自体の内容が大幅に変わっていることはそこまで多くないため、

Bootstrap4やVagrantなどで、デザインフレームワークの基礎や、仮想化の基礎を学ぶのは、

有用だと思います。</p>
GitとSQLがカリキュラムに含まれていないのは、

ちょっと物足りないかなと思うので、これらについては、

本などで別途学習する必要があります。</p>
当ブログでもこれらについて</a>、

記事を上げているので、よければご参考ください。</p>
[st-card myclass="st-no-shadow" id="179" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
ただ、ここの強みは、他のプログラミングスクールは、たいてい最低限のPCリテラシーを求めることがほとんどなのに対し、

パソコンすら触ったことがない人でも大丈夫としているのが特徴です。</mark></p>
意外とありそうでない特徴なので、

本当にPCに苦手意識があるけど、エンジニアになりたいという人にはおすすめできます。</p>
それでいて、ベテラン講師にチャットやメールサポートもありますので、

スクールに費用をかけたくないという人には一番おすすめできます。</p>



  
</a>
[st-card myclass="st-no-shadow" id="1271" label="あわせて読みたい" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
[st-card myclass="st-no-shadow" id="817" label="あわせて読みたい" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>


【技術書マニア厳選】エンジニア必読、技術書おすすめ26選
2023-07-29T00:00:00+00:00
エンジニアにおすすめの技術書</h2>

これだけは読んでおきたい技術書ってどういうのがあるのだろう</p>
</blockquote>
書籍学習は、エンジニアの嗜みみたいなところがありますが、
良書というものは、意外とそこまで多くもありません。</p>
そこで本記事では「技術書マニアの筆者が厳選した技術書20選」を特徴と、 おすすめポイントなどを紹介します。</p>

[st-square-checkbox bgcolor="" bordercolor="" fontweight="" borderwidth="3"]
おすすめの技術書が知りたい
どういう本を読むべきなのかが知りたい
書籍学習で強強エンジニアになりたい
[/st-square-checkbox]</p>
</blockquote>
本記事のの内容は、下記の動画で
触れております。


  </iframe>
</div>
</p>
Web技術概要</h2>
Webを支える技術</h3>


  
  
    
  </div>
  
  
    Webを支える技術 HTTP、URI、HTML、そしてREST （WEB＋DB press plusシリーズ） [ 山本陽平 ]</p>
    

      Amazonで見る</a>
      楽天市場で見る</a>
    </div>
  </div>
</div>
一冊目は、「Webを支える技術」です。
こちらは、結構有名な本なのでご存知の方も多いでしょう。</p>
ちょっと古い本というのが難点ではありますが、
Web技術の概要を学ぶなら、真っ先に思いつくのはこの本ですね。</p>
Webの歴史や、REST、URI設計、HTTP、ステータスコード、リソース設計など、</p>
Railsとかを使っていると、出てくるWeb技術の基本をしっかり学ぶことができます。</p>
プログラミングを始めたてのときは、こういう本の重要性があまり感じ取れないかもしれませんが、
慣れてくると、こういう普遍的な本のありがたみが身にしみるようになります。</p>
まだ読んでいないという方は、必ず読んでほしいとおすすめできるぐらいの良書です。</p>
こんな方におすすめ</p>

基本的な技術書は読んだけどこの本はまだ読んでいない人</li>
Web技術の概要をもう一度おさらいしたい人</li>
Webに関わるエンジニアで、まだ読んでいない人</li>
</ul>
Web API The Good Parts</h3>


  
  
    
  </div>
  
  
    Web　API：The　Good　Parts [ 水野貴明 ]</p>
    
      Amazonで見る</a>
      楽天市場で見る</a>
    </div>
  </div>
</div>
こちらも定番ですが、オライリーのAPIの設計についての本です。
昨今は、プログラミングをするエンジニアであれば、
ほとんどのエンジニアがAPIに関わると思うので、
バックエンドエンジニア以外も読んでおいて損はないと思います。</p>
それとこの本は、そこそこの企業の面接とかだと、
読んでいるのが当たり前で話が進むので、
読んでいないとそれだけで出遅れるので、
まだ読んでいない人は、ぜひとも読みましょう。</p>
エンドポイントやレスポンスデータの設計など、</p>
意外と見落としがちなAPI設計の基本を学べます。</p>
こんな方におすすめ</p>

バックエンドエンジニアでまだ読んでいない人</li>
バックエンドエンジニア以外でもAPIに関わることが多い人</li>
自身のAPI設計に自信がない人</li>
</ul>
ソフトウェアアーキテクチャの基礎 エンジニアリングに基づく体系的アプローチ</h3>


  
  
    
  </div>
  
  
    ソフトウェアアーキテクチャの基礎 エンジニアリングに基づく体系的アプローチ [ Mark Richards ]</p>
    
      Amazonで見る</a>
      楽天市場で見る</a>
    </div>
  </div>
</div>
こちらは、アーキテクトを目指す人、現役アーキテクト向けの本ではあるのですが、</p>
ソフトウェア開発の本質や、様々なアーキテクチャーについても学べる</p>
ので、
手を動かすエンジニアにもおすすめできる本です。</p>
将来的にCTOを目指している人や、技術でマネジメントするような立ち位置を目指している人には、
刺さる本かと思います。</p>
やや分厚くて、読むのが一苦労ではありますが、
実務経験が2年以上ある方は、読んでみても良いのではないかと思います。</p>
こんな方におすすめ</p>

アーキテクチャーに興味がある人</li>
技術寄りのマネジメントに興味がある人</li>
実務経験が2年以上ある人</li>
</ul>
フロントエンド</h2>
JavaScript 第7版</h3>


  
  
    
  </div>
  
  
    JavaScript 第7版 [ David Flanagan ]</p>
    
      Amazonで見る</a>
      楽天市場で見る</a>
    </div>
  </div>
</div>
通称サイ本と呼ばれている、
JavaScriptの定番書籍です。</p>
JavaScriptの書籍はたくさんありますが、
どれも内容が基礎的だったりして、実務に堪えうるレベルのものはそこまで多くありません。</p>
それにJavaScriptの場合、</p>
MDN</p>
が最強すぎるため、
本などは不要と考えている方も多いかもしれません。</p>
そんな中でも、このサイ本はおすすめできます。</p>
このサイ本は、他の本に比べても実践的であり、応用レベルまでJavaScriptを学ぶことができるので、</p>
実務でJavaScriptを書いている人などには、ぜひとも読んでほしい本です。</p>
ただ、分厚いので、読むのはやや根気がいるかもしれません。</p>
こんな方におすすめ</p>

JavaScriptを実務で使っているエンジニアの人</li>
JavaScriptを強みにしていきたい人</li>
JavaScriptを体系的に学びたい人</li>
</ul>
プロを目指す人のためのTypeScript入門 安全なコードの書き方から高度な型の使い方まで</h3>


  
  
    
  </div>
  
  
    プロを目指す人のためのTypeScript入門　安全なコードの書き方から高度な型の使い方まで [ 鈴木 僚太 ]</p>
    
      Amazonで見る</a>
      楽天市場で見る</a>
    </div>
  </div>
</div>
こちら通称ベリー本と言われている、
TypeScriptの入門書です。</p>
非常にわかりやすいにもかかわらず、内容は実践的なので、</p>
筆者も何度も読んで参考にした本です。</p>
TypeScriptの学習をするのであれば、
第一におすすめしたい本です。</p>
昨今は、フロントエンドといえば、
TypeScriptという流れになってきているので、
遅かれ早かれ学ぶ必要は出てくる気はします。</p>
ちなみに、私のブログでも、</p>
TypeScriptの文法</p>
については、
いくつか取り上げているので、
よろしければご参考ください。</p>

</blockquote>
こんな方におすすめ</p>

TypeScriptを学習しようと思っている人</li>
フロントエンドを極めたいと思っている人</li>
</ul>
バックエンド</h2>
プロを目指す人のためのRuby入門 言語仕様からテスト駆動開発・デバッグ技法まで</h3>


  
  
    
  </div>
  
  
    プロを目指す人のためのRuby入門［改訂2版］　言語仕様からテスト駆動開発・デバッグ技法まで [ 伊藤 淳一 ]</p>
    
      Amazonで見る</a>
      楽天市場で見る</a>
    </div>
  </div>
</div>
こちらRuby界隈では非常に有名な書籍で、
通称チェリー本と呼ばれています。</p>
Rubyの基本はもちろん、</p>
ブロックや正規表現など、応用的なトピックも、</p>
サンプルを通じてわかりやすく解説されていて、</p>
Rubyの入門書の中では、最もおすすめできます。</p>
こんな方におすすめ</p>

Rubyをはじめから丁寧に学習したい人</li>
現役Rubyエンジニアだけど、もう一度基本から学び直したい人</li>
基礎だけでなく応用も学習したい人</li>
</ul>
オブジェクト指向設計実践ガイド Rubyでわかる進化しつづける柔軟なアプリケーション</h3>


  
  
    
  </div>
  
  
    オブジェクト指向設計実践ガイド Rubyでわかる進化しつづける柔軟なアプリケーショ [ サンディ・メッツ ]</p>
    
      Amazonで見る</a>
      楽天市場で見る</a>
    </div>
  </div>
</div>
この本は、他の書籍と比べると、
ややマイナーかもしれませんが、個人的には結構イチオシの技術書です。</p>
というのも、Rubyでオブジェクト指向の威力を体験できる本というのは、
私が知る限り、これしかないからです。</p>
オブジェクト指向設計の基本はもちろん、単一責任クラス、依存関係の認識、</p>
ダックタイピングなど、高度なプログラミング技法を学ぶことができます。</p>
そこそこ難しい本なので、初心者にはおすすめしにくいですが、
すでに結構Rubyを使っていて、さらなる高みを目指したい人、
元々Java出身の人がRubyを使う場合などに読むと、
Rubyとオブジェクト指向の関係性を掴むことができるので、
良いと思います。</p>
私のブログでも</p>
こちらの記事</p>
で、
似たようなことを取り上げていますので、
よろしければ、ご参考ください。</p>
こんな方におすすめ</p>

オブジェクト指向に基づいたコードを書けるようになりたい人</li>
Rubyを極めたい人</li>
変更に強いコードを書けるようにレベルアップしたい人</li>
</ul>
Ruby技術者認定試験合格教本</h3>


  
  
    
  </div>
  
  
    ［改訂2版］Ruby技術者認定試験合格教本（Silver/Gold対応）Ruby公式資格教科書【電子書籍】[ 牧俊男（著） ]</p>
    
      Amazonで見る</a>
      楽天市場で見る</a>
    </div>
  </div>
</div>
お次は、ちょっと変化球です。
Ruby Silver / Ruby Goldの参考書です。</p>
[st-cmemo webicon="st-svg-user" iconcolor="#42A5F5" bgcolor="#E3F2FD" color="#000000" iconsize="200"] いや、資格試験に興味ないわ</p>
って思った方も多いかもしれませんが、</p>
この本は、シンプルにRubyの技術書として見てもかなり優秀です。</p>
メソッドの基本、ブロックの基本など、
Rubyの癖がある部分と、強みなどをしっかり解説している本は、
意外とありそうでありません。</p>
Ruby自体を体系的に学ぶという観点でみれば、
この参考書が一番適しているかもしれません。</p>
実際、筆者もこの書籍でRuby Silverの勉強をさせられましたが
（会社から強制に受験させれれました...)、
Rubyに対する理解が深まったなと強く実感しています。</p>
資格試験は役に立たないと言われがちですが、</p>
この参考書を丹念に読み込んだおかげで、かなりRubyに対して、</p>
理解が深まったと思います。</p>
なので、別に試験を受けない人にもおすすめできます。</p>
こんな方におすすめ</p>

Rubyを体系的に学習したい人</li>
ついでに資格も取得したい人</li>
</ul>
メタプログラミングRuby</h3>


  
  
    
  </div>
  
  
    メタプログラミングRuby第2版 [ パオロ・ペロッタ ]</p>
    
      Amazonで見る</a>
      楽天市場で見る</a>
    </div>
  </div>
</div>
この本は、あまり有名じゃないかもしれませんが、
個人的にはかなりイチオシです。</p>
というのも、この本を読んで、</p>
私はRubyに対する印象が大きく変わりましたので、</p>
ある種のブレイクスルーになったなと思っております。</p>
元々私は、そこまでRubyという言語に愛着があったわけではなかったのですが、</p>
この本を読んでRubyの威力に魅了され、すごい言語だなと感動しました。</p>
なので、Rubyを極めたいと思っている人はもちろん、
どこかRubyは、他の言語より劣っているイメージを持っている方などには、
特に読んでもらいたい本です。</p>
こんな方におすすめ</p>

Rubyを極めたい人</li>
Rubyをイケてない言語だと思っている人</li>
</ul>
パーフェクト Ruby on Rails</h3>


  
  
    パーフェクト Ruby on Rails　【増補改訂版】 [ すがわらまさのり／前島真一 ]</p>
    
      Amazonで見る</a>
      楽天市場で見る</a>
    </div>
  </div>
</div>
Railsを学ぶとなったら、様々な手段がありますが、
やはり一度は書籍で体系的に学んでおきたいと思うところ。</p>
その書籍の中で、この本が個人的には一番オススメです。</p>
Rspecや、concern、Dockerでの環境構築など、</p>
実務に出たら当たり前に使うけど、意外と体系的に説明していない部分について、</p>
解説している本</p>
なので、既にRailsをある程度使っている人でも参考になる部分があるはずです。</p>
こんな方におすすめ</p>

Ruby on Railsを学習している人</li>
現役Railsエンジニアの人</li>
Ruby on Railsを学習したい人</li>
</ul>
入門Python3</h3>


  
  
    
  </div>
  
  
    入門Python3　第2版 [ Bill Lubanovic ]</p>
    
      Amazonで見る</a>
      楽天市場で見る</a>
    </div>
  </div>
</div>
Pythonの本は、星の数ほどありますが、
実務向けで実践的な本は正直あまりない印象です。</p>
Pythonは、どういうわけか初心者が好きな言語のようなので、
必然的に書籍も初心者向けのものが多くなっているのかもしれません。</p>
まあ、かくいう私も独学のときは、
初心者らしくPythonばかり勉強していましたので、気持ちはめちゃくちゃわかります。</p>
なので、それなりにPythonの本も読んで来ましたが、</p>
その中で、易しすぎず難しすぎずで、ちょうど良い難易度で、</p>
程よく実践的な書籍がこの本です。</p>
安心のオライリーですね。Pythonの本は、
難しいやつだと、機械学習とかコンピューターサイエンスが普通に出てくるので、
難しい本と易しい本の差が激しい気がします。</p>
そんな中、この本が最も万人におすすめできる技術書かなと思います。
ただ、既に実務でバリバリPythonを使っている人には物足りない気もするので、
やはり入門とタイトルにある通り、初級者向けかもしれません。</p>
こんな方におすすめ</p>

Pythonを学ぼうと思っている人</li>
既にPythonを学習しているけど、Pythonの実務経験がない人</li>
</ul>
気づけばプロ並みPHP</h3>


  
  
    
  </div>
  
  
    気づけばプロ並みPHP 改訂版ーーゼロから作れる人になる！ [ 谷藤賢一 ]</p>
    
      Amazonで見る</a>
      楽天市場で見る</a>
    </div>
  </div>
</div>
全体的に骨太な本が続いたので、
ちょっと休憩入れます。</p>
この本は、本記事で紹介している本の中で最も易しいです。</p>
なので、対象読者としては、他の技術書が難しすぎて挫折してしまった人です。</p>
主にプログラミング経験が少なかったり、実務未経験のエンジニア志望向けの人向けの本です。</p>
私も独学時代様々な技術書に手を出したのですが、
やはり実務未経験かつ、手探りでプログラミングを勉強しているので、
本格的な技術書は難しすぎて読めませんでした...</p>
そんな中、この本と出会って、初めて読了して、理解できたという感覚を味わうことが
できました。</p>
なので、</p>
この本は、昔の私のように、普通の技術書で挫折してしまって、</p>
どうしたらいいのかわからない人に送りたい本です。</p>
この本を挟めば、読めなかった技術書もだんだん理解できるようになっていきます。
作者の谷藤さんの語り口は、本当にわかりやすいので、
技術書へのとっつきにくさがだいぶ減ると思います。</p>
こんな方におすすめ</p>

実務未経験、プログラミング経験が少ない人</li>
他の技術書が難しすぎて挫折した経験がある人</li>
なんでもいいから、技術書を理解できるようになりたい</li>
</ul>
いきなりはじめるPHP ワクワク・ドキドキの入門教室</h3>


  
  
    
  </div>
  
  
    いきなりはじめるPHP ワクワク・ドキドキの入門教室 [ 谷藤賢一 ]</p>
    
      Amazonで見る</a>
      楽天市場で見る</a>
    </div>
  </div>
</div>

ここだけの話、「気づけばプロ並みPHP」でも難しくて挫折してしまった。もう向いていないのかな。</p>
</blockquote>
と思っている方も、

もしかしたらいるかもしれません。</p>
この本は、そんな人向けの本です。</p>
「気づけばプロ並みPHP」よりも更に易しい技術書です。

お恥ずかしい話、私も独学時代は、上記の「気づけばプロ並みPHP」はやや難しいと感じました...笑</p>
なので、先にこちらを読んでから、もう一度「気づけばプロ並みPHP」を読んで

理解できるようになりました。</p>
この本は、本当にわかりやすいかつ易しい技術書が良い人向けの本です。</mark></p>
こんな方におすすめ</p>

「気づけばプロ並みPHP」も難しいと感じた人</li>
PC操作からちょっと怪しい人</li>
</ul>
DB（データベース)・SQL</h2>
スッキリわかるSQL入門</h3>


  
  
    スッキリわかるSQL入門 第3版 ドリル256問付き！ （スッキリわかる入門シリーズ） [ 中山 清喬 ]</p>
    
      Amazonで見る</a>
      楽天市場で見る</a>
    </div>
  </div>
</div>
これも有名な本なので、
「知ってるよ！」っていう方がほとんどだと思いますが、
一応紹介しておきます。</p>
基本的なSQLの文法を学ぶなら、</p>
やはりこの本が一番おすすめですね。</p>
こんな方におすすめ</p>

初めから丁寧にSQLを学びたい人</li>
SQLを書けるようになりたい人</li>
SQLの復習がしたい現役エンジニア</li>
</ul>
達人に学ぶDB設計徹底指南書 初級者で終わりたくないあなたへ</h3>


  
  
    
  </div>
  
  
    達人に学ぶDB設計徹底指南書 初級者で終わりたくないあなたへ [ ミック ]</p>
    
      Amazonで見る</a>
      楽天市場で見る</a>
    </div>
  </div>
</div>
これも定番ですね。
DB設計の本って、そこまで多くないのですが、
その割に実務で求められる能力なので、
体系的に学べる本は非常にありがたいですね。</p>
この本は、バックエンドエンジニアなら必読ですね。</p>
まだ読んでいない人は、読みましょう。</p>
こんな方におすすめ</p>

DB設計の本を探している人</li>
DBエンジニア、バックエンドエンジニアでまだ読んでいない人</li>
</ul>
達人に学ぶSQL徹底指南書</h3>


  
  
    
  </div>
  
  
    達人に学ぶSQL徹底指南書 第2版 初級者で終わりたくないあなたへ （CodeZine BOOKS） [ ミック ]</p>
    
      Amazonで見る</a>
      楽天市場で見る</a>
    </div>
  </div>
</div>
これも有名かつ定番ですね。
もちろん、ぜひとも読んでおきたい本ですが、
個人的には、上記のDB設計のほうが優先度は高いかなと思います。</p>
あと、全体的にまあまあ応用なので、
さきに「 スッキリわかるSQL入門」などで、
基礎を学んでおく必要があります。</p>
最近は、ORMでDBを操作することがほとんどな気もするので、
ここまで高度なSQLが求められるかというと微妙なラインかなとも思います。</p>
なので、現役エンジニアの中でも、</p>
生のSQLを書く機会が多い人や、</p>
ORMでは表現できないクエリーを実現したい人などに刺さる本かなと思います。</p>
こんな方におすすめ</p>

生のSQLを書くことが多い現役エンジニア</li>
SQLを極めたい人</li>
DBエンジニアなど</li>
</ul>
SQLアンチパターン</h3>


  
  
    
  </div>
  
  
    SQLアンチパターン [ Bill Karwin ]</p>
    
      Amazonで見る</a>
      楽天市場で見る</a>
    </div>
  </div>
</div>
はい、またまた定番ですね！
（DB系は流行り廃りがあまりないので、
書籍も定番ばかりになってしまう...)</p>
これは、タイトルの通りアンチパターンを紹介している本で、</p>
DB設計に関わる人や、SQLを頻繁に書く人は、ぜひとも読んでおきたい本ですね。</p>
こんな方におすすめ</p>

基本は習得しているバックエンドエンジニア</li>
DB設計をする機会が多い人</li>
SQLを極めたい人</li>
</ul>
実践Redis入門 技術の仕組みから現場の活用まで</h3>


  
  
    
  </div>
  
  
    実践Redis入門 技術の仕組みから現場の活用まで [ 林 昌吾 ]</p>
    
      Amazonで見る</a>
      楽天市場で見る</a>
    </div>
  </div>
</div>
Redisは、最近結構使われている技術な割に、
書籍があまりないのですが、
この本は、そんなRedisについて詳しくとりあげた本です。</p>
「これでもか！」 ってぐらい、</p>
Redisについて特化して詳しく書かれているので、</p>
Redisに焦点を当てて学びたい人にはおすすめです。</p>
[st-card myclass="st-no-shadow" id="1019" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
こんな方におすすめ</p>

Redisを体系的に学びたい人</li>
Redisを実務で使っている人</li>
</ul>
Linux</h2>
Linux教科書 LPICレベル1 version5.0対応</h3>


  
  
    
  </div>
  
  
    Linux教科書 LPICレベル1 Version5.0対応 （EXAMPRESS） [ 中島 能和 ]</p>
    
      Amazonで見る</a>
      楽天市場で見る</a>
    </div>
  </div>
</div>
またまた変化球で恐縮ですが、
Linuxで一番オススメな書籍は、LPICレベル1という資格試験の教科書です。</p>
「また資格かよ」って感じだと思いますが、</p>
資格は受けなくていいから、この本は買ってほしいと思えるぐらいおすすめの本です。</p>
Linuxコマンドの基礎がこの一冊で学ぶことができます。
LPICレベル2などもありますが、</p>
実務で使うLinuxコマンドの7割以上は、このLPICレベル1でカバーされています。</p>
そして、解説も一つ一つ丁寧に行われているので、
わかりやすいです。</p>
筆者もたまに復習がてら開くことがあります。
こういう資格の本って意外と馬鹿にできなかったりするんですよね。</p>
こんな方におすすめ</p>

Linuxコマンドを1から体系的に学習したい人</li>
ついでにLPICレベル1も取得したい人</li>
</ul>
1日1問、半年以内に習得　シェル・ワンライナー160本ノック</h3>


  
  
    
  </div>
  
  
    1日1問、半年以内に習得　シェル・ワンライナー160本ノック [ 上田 隆一 ]</p>
    
      Amazonで見る</a>
      楽天市場で見る</a>
    </div>
  </div>
</div>
この本は、正確にはシェルワンライナーの本なので、
Linuxの本というわけではないのですが、
シェルワンライナーの学習を通して、自然とLinuxへの理解を深めることができます。</p>
それと、本のタイトル的にあまり実践的ではないような気もしますが、</p>
内容は結構高度で、いわゆるシェル芸というものを学ぶことができます。</p>
マストで学ばなければならない事項ではありませんが、
やっておくとエンジニアとしての幅をつけられるので、
個人的には結構おすすめです。</p>
こんな方におすすめ</p>

シェル芸に興味がある人</li>
ちょっとコアなコマンドを知りたい人</li>
普通の技術書が飽きた人</li>
</ul>
Git</h2>
独習Git</h3>


  
  
    
  </div>
  
  
    独習Git [ リック・ウマリ ]</p>
    
      Amazonで見る</a>
      楽天市場で見る</a>
    </div>
  </div>
</div>
こちらは、意外とみんな軽視しているGitについて、

詳しく解説した本です。</p>
Gitは、とりあえず使うレベルであれば、

専門書など読まなくてもいいのですが、

長くエンジニアを続けていくことを考えると、

どこかのタイミングで、こういった専門書を読んで、

体系的に学んだ方が良いなと思います。</p>
【Git/Githubを0から使えるレベルまで】概念と基本コマンド解説</a></p>
こんな方におすすめ</p>

Gitを体系的に学び直したい人</li>
Gitにいまいち自信がない人</li>
</ul>
Docker</h2>
さわって学ぶクラウドインフラ docker基礎からのコンテナ構築</h3>


  
  
    
  </div>
  
  
    さわって学ぶクラウドインフラ　docker基礎からのコンテナ構築 [ 大澤 文孝 ]</p>
    
      Amazonで見る</a>
      楽天市場で見る</a>
    </div>
  </div>
</div>
こちらは、Dockerの入門書で、

基礎から詳しく解説しているので、

これからDockerを学ぶ人には、おすすめです。</p>
ただ、既にまあまあdockerを使いこなしている人には、

やや物足りなく感じるかもしれません。</p>
こんな方におすすめ</p>

Dockerを基礎からわかりやすく学習したい人</li>
Dockerをとりあえず使えるようになりたい人</li>
</ul>
プログラミング作法・思想</h2>
リーダブルコード</h3>


  
  
    
  </div>
  
  
    リーダブルコード より良いコードを書くためのシンプルで実践的なテクニ （Theory　in　practice） [ ダスティン・ボズウェル ]</p>
    
      Amazonで見る</a>
      楽天市場で見る</a>
    </div>
  </div>
</div>
まあ、これはみなさんご存知ですよね。
というくらい有名かつ定番の本です。</p>
よく先輩エンジニアが後輩エンジニアにおすすめする本の筆頭が
この本ですね。</p>
まあ、たしかに多くの人に支持されているベストセラーだけあって、</p>
書いてあることは本質的なので、まだ読んでいない人は、</p>
読んだ方が良いかとも思います。</p>
ただ、個人的には書いてあることが、
当たり前すぎるなとは思います。</p>
とはいっても、その当たり前のことも、</p>
いつしか疎かにしていってしまうのが、</p>
人間なので、定期的に読み返して、</p>
「自分はエンジニアとして堕落していないか」と</p>
自問自答する本としては良いなと思います。</p>
こんな方におすすめ</p>

読んでいない人は読んだほうが良い気がします（熱烈信者から低評価をされないためにも)</li>
この手のプログラミング作法系の本をまだ読んだことがない人</li>
これからエンジニアになる人</li>
</ul>
プリンシプル オブ プログラミング 3年目までに身につけたい 一生役立つ101の原理原則</h3>


  
  
    
  </div>
  
  
    プリンシプル オブ プログラミング 3年目までに身につけたい 一生役立つ101の原理原則 3年目までに身につけたい　一生役立つ101の原理原則 [ 上田　勲 ]</p>
    
      Amazonで見る</a>
      楽天市場で見る</a>
    </div>
  </div>
</div>
プログラミング作法の本は、ともすると軽視されがちですが、
割りと重要ですよね。</p>
上記のリーダブルコードなどがこの手の本では有名ですが、</p>
個人的には、リーダブルコードより、こちらの方がおすすめです。</p>
こんな方におすすめ</p>

プログラミングの基本を身につけたい人</li>
リーダブルコードがピンと来なかった人</li>
</ul>
UNIXという考え方 その設計思想と哲学</h3>


  
  
    
  </div>
  
  
    UNIXという考え方 その設計思想と哲学 [ マイク・ギャンカーズ ]</p>
    
      Amazonで見る</a>
      楽天市場で見る</a>
    </div>
  </div>
</div>
個人的には、この手の思想本の中では、

これが一番好きです。</p>
この本で書かれているUNIX哲学や考え方は、

プログラミングにも役立つものも多いです。</p>
また、哲学や思想がきれいにまとまっていて、

見やすく、座右の銘のように参照できるので、

自身のエンジニアとしての心構えみたいなものに応用できるかなと思います。</p>
ただ、若干偏りがある本のような気もするので、

完全に鵜呑みにするというよりは、

こういう思想はたしかに役に立つなみたいな感じで読むと面白いと思います。</p>
そういう意味では、他の思想本を読んで、

ある程度一般的なプログラミング作法を理解している人向けかもしれません。</p>
こんな方におすすめ</p>

哲学や思想が好き</li>
UNIXが好き</li>
通常の作法本は飽きた</li>
</ul>
達人プログラマー（第2版） 熟達に向けたあなたの旅</h3>


  
  
    
  </div>
  
  
    達人プログラマー（第2版） 熟達に向けたあなたの旅 [ Andrew Hunt ]</p>
    
      Amazonで見る</a>
      楽天市場で見る</a>
    </div>
  </div>
</div>
個人的には、この手の思想本の中では、

この本が一番参考になるかつ、一番難しいなと感じました。</p>
その分、より実践的な内容を学ぶことができるので、

リーダブルコードとかは当たり前すぎるよっていう人などに

おすすめしたいです。</p>
こんな方におすすめ</p>

骨太な作法本を知りたい</li>
リーダブルコードは当たり前すぎる</li>
</ul>
技術書マニアイチオシの本(おわりに)</h2>
さて、長々と紹介してきましたが、
ここで紹介しようか迷った本もたくさんありました。</p>
ただ、それらの本は、内容が薄かったり、
ネットで調べたらすぐにわかるようなことをくどくどと書いていたりと、
書籍で読む必要性があまりないなと感じたものがほとんどだったので、
ここでは紹介しませんでした。</p>
そのため、</p>
本記事で紹介した技術書は、</p>
かなり厳選したつもりですので、</p>
ぜひともご参考にしていただけると嬉しいです。</p>
[st-card myclass="st-no-shadow" id="1139" label="あわせて読みたい" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>


Dockerとは何か？概要を完全解説 簡単なWebサーバー構築で基礎を学ぶ
2023-07-21T00:00:00+00:00
Dockerとは？</h2>
Dockerは、コンテナ型仮想環境を作成するソフトウェアの一種で、

隔離された実行環境を用意することが特徴です。</p>
https://aws.amazon.com/jp/docker/</a></p>
コンテナ型仮想環境を作成するソフトウェアは、

Docker以外にも色々あり、例えばPodmanなどがあります。</p>
https://podman.io/</a></p>
ただ、そんな中でもDockerの人気度は群を抜いており、</mark>

事実上のデファクトスタンダードになっているという感じですね。</mark></p>
Webの開発においても、

Dockerで環境構築することがほとんどで、

本ブログでもそのような記事</a>をいくつか公開しています。</p>
Dockerには、いくつかの用語が登場しますが、それぞれ解説します。</p>
コンテナとは？</h3>
コンテナとは、独立した実行環境のことを指します。

よく日常生活でもコンテナを見かけたりすると思いますが、

わりとあのイメージと類似しており、隔離された閉じられた空間という特徴があります。</p>
Dockerを使う際、Dockerをインストールしている、ホストOSに該当するPCとは、</mark>

異なる環境（異なるOSを入れたり)を立ち上げることができ、その環境が、</mark>

コンテナに該当します。</mark></p>
例えば、ホストOSがMac OSで、コンテナの中のOSがLinuxというように、

Dockerも仮想化の一種なので、コンテナという独自空間を使って、

仮想環境を構築するようなイメージです。</p>
ホストOS、すなわち普段使用しているPCの環境とは、

別の環境をコンテナによって手軽に構築できるので、

Dockerの大きな魅力ですね。</p>
そして、そうして構築されたDocker環境は、

基本的に他の人のPC上でも動作することが想定されています。</p>
なぜなら、コンテナはそれ自体独立しているので、

ホストOSのアプリケーションに依存して動くということが、

基本起こらないので、どのPCで実行しても動くことが想定されているという感じです。

(まれにカーネル周りで、違いが生じると動かなかったりする場合もあるので、

そういう場合は、それぞれの依存性を確認する必要があります。)</p>
そのため、Dockerはチーム開発での共通した環境構築をしやすいというメリットがあります。</strong></p>
イメージとは？</h3>
コンテナが独立した環境ということは既に紹介しましたが、

そうなると、コンテナごとに個別の環境を構築する手間が生じます。</p>
ただ、gitやcurlのように基本的にどのような環境においても、

インストールしておきたいソフトウェアが存在するため、いちいちこれらを

インストールするのは面倒です。</p>
そこで、予めこういった必要なソフトウェアなどをインストールしてある、</mark>

コンテナの元のようなものが存在しており、これのことをイメージといいます。</mark>

テンプレートみたいなものですね。</p>
このイメージは、Docker Hubというサイトで見ることができます。

下記は、Rubyのイメージです。</p>
https://hub.docker.com/_/ruby</a></p>
イメージには、オフィシャルイメージとそれ以外がありますが、

可能であれば、オフィシャルイメージを使いましょう。

こちらの方が、セキュリティアップデートが行われたりと、

メンテナンスが格段にしっかりしているかと思われるので。</p>
https://matsuand.github.io/docs.docker.jp.onthefly/docker-hub/official_images/</a></p>
Docker Engine</h3>
Docker Engineとはなにかというと、

ドキュメントに次のように定義されていました。</p>

軽量かつ強力なオープンソースによりコンテナ化（containerization）を行う技術。アプリケーションの構築とコンテナ化を行うワークフローを実現します。</p>
https://docs.docker.jp/engine/index.html</p>
</blockquote>
要は、Docker Engineによって、

コンテナとかを実行できるようになるという感じで、

このDocker Engineが入っているコンピューターを

Dockerホストと言ったりします。</p>
文字通り、エンジンのようなものと思っていただけたら問題ないかと思います。</p>
Docker Desktop</h2>
早速、Dockerの環境構築を行います。

Dockerを使用する際、このDocker Desktopというソフトウェアを使用すると、

簡単なので、こちらを使います。

(Docker Desktopを使わずにdocker engineやcliなどをインストールする方法も

ありますが、Docker Desktopをインストールしたほうが格段に簡単なので、こちらのほうがいいかと

思います。Docker DesktopにDocker Engineやcliなども含まれています。)</p>
https://www.docker.com/products/docker-desktop/</a></p>
https://docs.docker.jp/desktop/index.html</a></p>
それぞれのOSにあった、Docker Desktopをインストールしてください。

インストールできたら、Docker Desktopを起動しておいてください。</p>
DockerでWebサーバーを構築してみる</h2>
起動</h3>
さて、長々と解説が続いたので、

そろそろハンズオンに移りたいと思います。

手始めに、Apacheのイメージを使って構築してみたいと思います。</p>
Docker hubのイメージは、

こちらです。公式イメージです。</p>
https://hub.docker.com/_/httpd</a></p>
Dockerfileを使うやり方と使わないやり方がありますが、

今回は、Dockerfileなしの、下記のコマンドでさくっと起動してしまいます。

（実際の開発では99%Dockerfileを使うかと思うので、あくまでこれは簡易的な

デモンストレーションと思っていただければです)</p>
docker run -dit --name my-apache-app -p 8080:80 -v "$PWD":/usr/local/apache2/htdocs/ httpd:2.4</span></span></code></pre>
さて、こちらを実行したら、

もう立ち上がっているかと思います。プロセスを確認するには、</p>
docker ps</span></span></code></pre>
で確認できます。</p>
</p>
STATUSがUpと表示されているので、

稼働中です。</p>
さて、試しに

http://localhost:8080/を確認すると、

ファイルの一覧を確認できるはずです。</p>
私がホームディレクトリに設置したコールドリーディング用の

フォルダにアクセスしてみます。（各々の環境で試す場合は、

シンプルにlocalhost:8080でホームディレクトリが確認できます)</p>
表示されているのは、Dockerホストのカレントディレクトリですね。</p>
さて、このままだと見栄えが悪いので、

index.htmlを作成して、そちらが表示されるようにします。</p>
<</span>html</span>></span></span>
  <</span>body</span>></span></span>
    <</span>p</span>>hello docker</</span>p</span>></span></span>
  </</span>body</span>></span></span>
</</span>html</span>></span></span></code></pre>
こちらを保存したら、

今回は、http://localhost:8080を見てみます。</p>
</p>
index.htmlの内容が表示されていますね。</p>
停止</h3>
さて、コンテナを起動して

index.htmlの内容を表示できたので、

ものすごく簡単ではありますが、

一応Dockerを使って、Webサーバーを構築したかと思います。</p>
なので停止します。

停止のコマンドは、</p>
docker stop my-apache-app</span></span></code></pre>
my-apache-appは、runのときの--nameオプションで指定したコンテナ名ですね。

docker stopコマンドはコンテナ名のほかに、コンテナIDでも停止することができます。</p>
docker psコマンドを使うと、

プロセスが消えていることがわかると思います。</p>
ただ、docker psコマンドに-aオプションを付けると、

稼働中ではないすべてのコンテナを表示するので、

残っていることが確認できます。</p>
</p>
StatusはExitedに変わっていますね。</p>
再開</h3>
停止したコンテナを再び動かしてみます。</p>
docker start my-apache-app</span></span></code></pre>
docker psを見ると立ち上がっていることが確認できると思います。</p>
ちなみに、コンテナのログを確認したいときは、</p>
docker logs my-apache-app</span></span></code></pre>
でできます。</p>
破棄</h3>
先程、コンテナの停止を行いましたが、

停止してもコンテナは残り続けるので、

知らないうちに容量を圧迫しかねなかったりするので、

不要なら破棄しましょう</p>
コンテナの破棄は、</p>
docker rm my-apache-app</span></span></code></pre>
です。</p>
</p>
おっとエラーが出ました。

コンテナを削除するには、まずstopをする必要がありそうです。</p>
docker stop my-apache-app</span></span>
docker rm my-apache-app</span></span></code></pre>
これで削除できました。</p>
イメージの破棄</h3>
さて、コンテナは破棄しましたが、

イメージはまだ残っております。</p>
下記のコマンドでダウンロードしたイメージを確認できます。</p>
docker image ls</span></span></code></pre>
これも知らないうちに容量を圧迫しかねないので、

不要なら削除しましょう。</p>
docker image rm httpd:2.4</span></span>
または、</span></span>
docker rmi httpd:2.4</span></span></code></pre>
なお、Dockerを本格的に学ぶなら下記の書籍などがおすすめです。</p>


  
  
    
  </div>
  
  
    Docker実践ガイド第2版 コンテナ環境の構築・運用・活用 （impress　top　gear） [ 古賀政純 ]</p>
    

      Amazonで見る</a>
      楽天市場で見る</a>
    </div>
  </div>
</div>


  
  
    
  </div>
  
  
    さわって学ぶクラウドインフラ　docker基礎からのコンテナ構築 [ 大澤 文孝 ]</p>
    
      Amazonで見る</a>
      楽天市場で見る</a>
    </div>
  </div>
</div>


【Redis基礎】データ型のList型とHash型について
2023-07-20T00:00:00+00:00
前回の記事</a>の続きで、

本記事では、List型とHash型を取り上げようと思います。</p>
String型と同じく、これらのデータ型も重要なので、

しっかりマスターしてもらえると幸いです。

これらのデータ型は、たくさんのコマンドがあるので、

ある種のチートシート的にも使えるよう執筆しました。</p>
List型</h2>
List型はわりとそのまんまで、

RedisのString型のリストです。</p>
順序を保持して、値を保存します。</p>
試しに何か格納してみます。</p>
LPUSH sample_list 123 153 test</span></span>
LRANGE sample_list 0 -1</span></span></code></pre>
sample_listというキーに123、153、testを

格納し、LRANGEで0(最初から)から-1(リストの最後)を取得します。</p>
List型のコマンド</h2>
一覧は、下記のドキュメントに詳しく書かれております。</p>
https://redis.io/commands/?group=list</a></p>
LPOP</h3>
キーで指定したリストから、最初の要素を消して、

その値を返すコマンドです。</p>
LPOP sample_list</span></span>
LPOP sample_list 2</span></span></code></pre>
keyのあとに数値を指定すると、

その数まで削除します。</p>
LPUSH</h3>
こちらは、LPOPの逆で、

指定した値をすべて先頭に挿入します。</p>
LPUSH sample_list 123 153 test</span></span>
LPUSH sample_list testtest</span></span>
LRANGE sample_list 0 -1</span></span></code></pre>RPOPとRPUSH</h3>
これは、指定した値をそれぞれ

末尾に対して操作するLPOPとLPUSHに該当します。</p>
LINDEX</h3>
キーのリストの、指定したインデックスの位置にある要素を返します。

下記はindex 1の要素を返します。</p>
LINDEX sample_list 1</span></span></code></pre>LINSERT</h3>
こちらは、簡単な探索ができるようなコマンドで、

キーの直後(AFTER)または直前(BEFORE)に、

起点となる要素(下記の場合、153)の後(前)に

指定した要素(下記の場合、110)を挿入します。</p>
LINSERT sample_list BEFORE 153 110</span></span>
LRANGE sample_list 0 -1</span></span></code></pre>
pivot（検索する起点となる要素)がない場合、

-1を返します。</p>
redis-cli> LINSERT sample_list BEFORE not_found 110</span></span>
(integer) -1</span></span></code></pre>
そもそもkey自体が存在しない場合は、

0を返します。</p>
redis-cli> LINSERT sample_listee BEFORE 153 110</span></span>
(integer) 0</span></span></code></pre>LLEN</h3>
シンプルにリストの長さを返します。</p>
 LLEN sample_list</span></span></code></pre>LRANGE</h3>
こちらは、既に何回か使っているが、

List型における、事実上のKeysコマンドに相当するかと思われる。</p>
すべての要素を確認する場合は、

下記のようにする</p>
LRANGE sample_list 0 -1</span></span></code></pre>
始点は0から始まり、末尾は-1と表現できるので、

最初から最後まで取得するという意味になる。</p>
これ以外にも、文字通り範囲指定的な使い方もできて、

末尾から２つの要素を取得するなら、</p>
LRANGE sample_list -2 -1</span></span></code></pre>
最初から、3つの要素を取得するなら、</p>
LRANGE sample_list 0 2</span></span></code></pre>
といった感じだ。</p>
LSET</h3>
こちらは、LISTにおける、

SETコマンドのようなもので、

indexを指定して、その要素を更新する。</p>
LSET sample_list 0 first_test</span></span></code></pre>Hash型</h2>
Hash型は、List型の階層を深くしたような、

データ型で、フィールドと値を対として持つデータ型です。</p>
ちょうど、RubyのHashと似ているので、

イメージとしては、こんな感じですね。</p>
[st-card myclass="st-no-shadow" id="785" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
平たいイメージで言うと、

親キーと子キー(フィールド)と値があるような感じです。</p>
parent: (child1 => 'value1', child2 => 'value2')</span></span></code></pre>
上記のようなイメージです。</p>
実際にコマンドを使うと、</p>
HSET parent child1 value1 child2 value2</span></span>
HGET parent child2</span></span></code></pre>
このような感じですかね。</p>
</p>
Hash型のコマンド</h2>
ドキュメントは、下記です。</p>
https://redis.io/commands/?group=hash</a></p>
HDEL</h3>
こちらはシンプルに要素を削除する系のコマンドで、

キーとフィールドを指定する。</p>
HDEL parent child2</span></span></code></pre>HEXISTS</h3>
こちらはhash版のEXISTSコマンドに相当するものかと思われます。

フィールドが存在すれば1を、存在しなければ0を返します。</p>
redis-cli> HEXISTS parent child1</span></span>
(integer) 1</span></span>
redis-cli> HEXISTS parent child2</span></span>
(integer) 0</span></span></code></pre>HGET</h3>
先程も軽く使ったが、

指定したフィールドに関連づく値を返します。</p>
HGET parent child1</span></span></code></pre>HGETALL</h3>
これはListでいう、LRANGE、

汎用コマンドでいう、KEYSコマンドに近いもので、

キーで指定した、フィールドと値を返します。</p>
redis-cli> HSET parent child3 test</span></span>
(integer) 1</span></span>
redis-cli> HGETALL parent</span></span>
1) "child1"</span></span>
2) "value1"</span></span>
3) "child3"</span></span>
4) "test"</span></span></code></pre>HKEYS</h3>
こちらは、フィールドだけを返す、HGETALLのようなコマンド</p>
redis-cli> HKEYS parent</span></span>
1) "child1"</span></span>
2) "child3"</span></span></code></pre>HVALS</h3>
こちらは、フィールドの値だけを返す、HGETALLのようなコマンド</p>
redis-cli> HVALS parent</span></span>
1) "value11"</span></span>
2) "test"</span></span>
3) "value22"</span></span></code></pre>HLEN</h3>
フィールドの数を返します。</p>
HLEN parent</span></span></code></pre>HSET</h3>
キーで指定したハッシュについて、

フィールドと値のペアを挿入します。

先程も軽く使いましたね。

既にフィールドが存在する場合は、上書きとなります。</p>
HSET parent child1 value11 child2 value22</span></span></code></pre>HINCRBY</h3>
String型にも、INCRBYというコマンドがあったが、

そちらとほとんど同様。フィールドの値が数値のときのみ使えるコマンド。

キーやフィールドがない場合は、0基準で加算が行われる。</p>
[st-card myclass="st-no-shadow" id="1033" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
HINCRBY parent child7 3</span></span></code></pre>


【Redis基礎】Set型とSorted Set型
2023-07-20T00:00:00+00:00
前回の記事</a>の続きで、

本記事では、Set型とSorted Set型を取り上げようと思います。</p>
これらのデータ型もString型、List型、Hash型と同じく、

重要なのと、Sorted Set型については、

やや特徴が強いデータ型なので、こちらについても、

解説していきます。</p>
Set型</h2>
Set型は、RedisのString型の集合という点では、

List型と似ているのですが、

異なる点として、重複をゆるさない</strong>

という点と、順序を持たない</strong>という点です。</p>
例えば、List型だと重複を可能にし、順序を保持する。</p>
redis-cli> LPUSH same_list same same same</span></span>
(integer) 3</span></span>
redis-cli> LRANGE same_list 0 -1</span></span>
1) "same"</span></span>
2) "same"</span></span>
3) "same"</span></span>
redis-cli> LPUSH same_list first</span></span>
(integer) 4</span></span>
redis-cli> LRNAGE same_list 0 0</span></span>
1) "first"</span></span></code></pre>
これに対して、Set型の場合、

重複が起きない。また順序も保持していないので、

List型のように、何番目の値を取得するということもできない。</p>
redis-cli> SADD same_set same same same</span></span>
(integer) 1</span></span>
redis-cli> SMEMBERS same_set</span></span>
1) "same"</span></span>
redis-cli> SADD set_list 1 2 3 4 123 test</span></span>
(integer) 6</span></span>
redis-cli> SMEMBERS set_list</span></span>
1) "1"</span></span>
2) "4"</span></span>
3) "3"</span></span>
4) "123"</span></span>
5) "2"</span></span>
6) "test"</span></span></code></pre>Set型のコマンド</h2>
コマンド一覧は、下記のドキュメントにあります。</p>
https://redis.io/commands/?group=set</a></p>
SADD</h3>
こちらは既に使いましたが、

指定した集合に対して、任意の数の値を追加します。</p>
SADD set_list 1 2 1 test</span></span></code></pre>SCARD</h3>
集合に保存されている値の数を返します。</p>
SCARD set_list</span></span></code></pre>SISMEMBER</h3>
指定した集合について、値が集合に含まれているかを返します。

含まれている場合は1を、含まれていない場合は0を返します。</p>
redis-cli> SISMEMBER set_list test12</span></span>
(integer) 0</span></span>
redis-cli> SISMEMBER set_list test</span></span>
(integer) 1</span></span></code></pre>SMEMBERS</h3>
これも先程やりましたが、

指定した集合について、すべての値を返します。</p>
SMEMBERS set_list</span></span></code></pre>SPOP</h3>
指定した集合について、ランダムに値を返して、

その値を集合から削除します。</p>
redis-cli> SPOP set_list</span></span>
"2"</span></span>
redis-cli> SPOP set_list</span></span>
"test"</span></span>
redis-cli> SPOP set_list</span></span>
"1"</span></span>
redis-cli> SPOP set_list</span></span>
(nil)</span></span>
redis-cli> SMEMBERS set_list</span></span>
(empty array)</span></span></code></pre>SREM</h3>
こちらも削除系で、

指定した任意の値を削除します。</p>
SREM set_list 123 test</span></span></code></pre>SDIFF</h3>
複数の集合について、最初の集合から、それに続く集合の

差から生じる集合を返します。</p>
redis-cli> SMEMBERS set_list</span></span>
1) "1"</span></span>
2) "4"</span></span>
3) "3"</span></span>
4) "2"</span></span>
redis-cli> SMEMBERS set_list2</span></span>
1) "1"</span></span>
2) "3"</span></span>
3) "5"</span></span>
4) "32"</span></span>
redis-cli> SDIFF set_list set_list2</span></span>
1) "2"</span></span>
2) "4"</span></span>
redis-cli> SDIFF set_list2 set_list</span></span>
1) "5"</span></span>
2) "32"</span></span></code></pre>SINTER</h3>
指定された複数の集合の共通となる値の集合を返します。</p>
 SINTER set_list set_list2</span></span></code></pre>SUNION</h3>
指定した集合に含まれるすべての値の集合を重複を除いて返します。</p>
 SUNION set_list set_list2</span></span></code></pre>
</p>
Sorted Set型</h2>
Sorted Setは順序のあるSetのような感じで、

重複が許されない集合です。</p>
特徴的なのは、スコアをもたせることができる点です。

ゲームなどのスコアの集計に便利なデータ型ですね。</p>
イメージとしては、</p>
sorted_set_list → 0.value2:500, 1.value3:200, 2.value:100</span></span></code></pre>
のような感じです。</p>
Hashとやや似ている気もしますが、

異なるのは、Hashは順序を持たないので、

ランキング集計とかにはSorted Setのほうが向いているということです。</p>
HashとSetのいいとこ取りをしたようなデータ型ですね。</p>
使用例としては下記のような感じです。</p>
redis-cli> ZADD sorted_set_list 100 value1</span></span>
(integer) 1</span></span>
redis-cli> ZADD sorted_set_list 500 value2</span></span>
(integer) 1</span></span>
redis-cli> ZADD sorted_set_list 200 value3</span></span>
(integer) 1</span></span>
redis-cli> ZREVRANGE sorted_set_list 0 -1</span></span>
1) "value2"</span></span>
2) "value3"</span></span>
3) "value1"</span></span>
redis-cli> ZREVRANGE sorted_set_list 0 -1 WITHSCORES</span></span>
1) "value2"</span></span>
2) "500"</span></span>
3) "value3"</span></span>
4) "200"</span></span>
5) "value1"</span></span>
6) "100"</span></span></code></pre>
以下、コマンドについて解説します。</p>
Sorted Set型のコマンド</h2>
ドキュメントはこちら。

今までよりもコマンド多めですね。</p>
https://redis.io/commands/?group=sorted-set</a></p>
ZADD</h3>
こちらすでに登場しているが、

スコアと値を集合に追加します。</p>
ZADD test_list 20 value</span></span></code></pre>ZCARD</h3>
キーで指定した集合について、

値の数を返します。</p>
ZCARD test_list</span></span></code></pre>ZRANK</h3>
集合について、指定した値のスコアの低い順での順位を返します。

順位は0から始まるので、最も低い場合は、0となる</p>
ZRANK test_list value3</span></span></code></pre>ZREVRANK</h3>
こちらは、ZRANKの高い順version。</p>
ZREVRANK test_list value3</span></span></code></pre>ZREM</h3>
集合について、指定した値を削除します。</p>
ZREM test_list value2</span></span></code></pre>ZMSCORE</h3>
集合について、指定した一つ以上の値のスコアを返します。</p>
ZMSCORE test_list value1 value3</span></span></code></pre>ZRANGE</h3>
集合について、指定された範囲の要素を返します。

デフォルトだと、低い順です。</p>
ZRANGE test_list 0 -1</span></span></code></pre>
REVオプションでスコアが高い順になります。</p>
ZRANGE test_list 0 -1 WITHSCORES REV</span></span></code></pre>
スコアの数値で絞り込みすることも可能で、

例えば、スコアが0 < score 10の場合は、</p>
ZADD test_list 10 value10</span></span>
ZADD test_list 0 value0</span></span>
ZADD test_list 4 value4</span></span>
ZADD test_list 9 value9</span></span>
ZRANGE test_list (0 (10 BYSCORE WITHSCORES</span></span></code></pre>
スコアが 0 <= score < 10なら</p>
ZRANGE test_list 0 (10 BYSCORE WITHSCORES</span></span></code></pre>


【Redis基礎】汎用コマンドとString型について対応するコマンド
2023-07-18T00:00:00+00:00
本記事では、Redisのデータ型のString型と、

データ型に関わらない、汎用コマンドを解説します。</p>
前回の記事では、Redis自体がどういうものなのかについて、

解説したので、本記事では汎用コマンドや、データ型の一つである、

String型を取り上げます。</p>
Redisのデータ型</h2>
前回のRedisの概要解説の記事</a>で、

RedisがKVSタイプのインメモリデータベースである旨を解説しました。</p>

</blockquote>
ただ、KVSとはいっても、

Redisには多様なデータ型があるので、

通常のKVSよりも柔軟性が高いという特徴があります。</p>
その中でも代表的なのが、</p>
[st-mybox title="ポイント" webicon="st-svg-check-circle" color="#FFD54F" bordercolor="#FFD54F" bgcolor="#FFFDE7" borderwidth="2" borderradius="5" titleweight="bold" fontsize="" myclass="st-mybox-class" margin="25px 0 25px 0"]</p>

Strings</li>
Lists</li>
Sets</li>
Hashes</li>
Sorted sets</li>
</ul>
あたりでしょうか。

（これ以外にもあります。)</p>
本記事ではそんなRedisのデータ型の中でも

特に使用頻度が高いであろうString型について取り上げます。</p>
Redisの汎用コマンド</h2>
String型の紹介の前に、

型に関わらず使用する汎用コマンドを一部紹介します。</p>
KEYS</h3>
Redisでキーの一覧を取得したいときは、</p>
KEYS *</span></span></code></pre>
というふうにすると、すべてのキーを取得できます。</p>

はワイルドカードで、全てという意味ですね。</li>
</ul>
しかし、KEYSコマンドは、

実行時間がかかるので本番環境とかではあまり使わない方が良いとされています。</p>
ドキュメントには以下のようなコマンド例が紹介されていますね。</p>
redis> MSET firstname Jack lastname Stuntman age 35</span></span>
"OK"</span></span>
redis> KEYS *name*</span></span></code></pre>
https://redis.io/commands/keys/</a></p>
EXISTS</h3>
キーが存在するかどうかの確認は、</p>
EXISTS X</span></span></code></pre>
というふうにします。

この場合、Xがキー名にあたります。</p>
存在する場合は、1を返し、

存在しない場合は、0を返します。</p>
キーを複数設定することも可能で、

その場合は、マッチした数を返します。</p>
TYPE</h3>
データ型を確認する際は、</p>
TYPE X</span></span></code></pre>
というふうにします。

返り値としては、stringやhashなどというように、

データ型が返されます。</p>
DEL</h3>
削除は、</p>
DEL X</span></span></code></pre>
というふうに行い、

返り値は、削除したキーの数になります。</p>
</p>
String型</h2>
プログラミング的に考えると、Stringというと、

文字列がぱっと思い浮かびますが、

RedisにおけるString型は文字列に限らず、

整数、小数、バイナリーデータなどもこのStringに該当します。</p>
いわゆるKVSに相当するデータ型といえるだろう。</p>
String型に対応するコマンド</h3>
String型の対応するコマンド一覧は、

こちらに書かれております。</p>
https://redis.io/commands/?group=string</a></p>
この中から一部抜粋します。</p>
GETとSET</h3>
前回の記事でも少しだけ触れましたが、

値の取得はGETで行います。</p>
GET X</span></span></code></pre>
これに対して、値の保存は、SETで行います。</p>
SET X user</span></span></code></pre>MGETとMSET</h3>
こちらは、GETとSETの複数設定バージョンです。</p>
 MSET user1 tarou user2 hanako</span></span>
 MGET user1 user2</span></span></code></pre>GETRANGEとSETRANGE</h3>
こちらは、挿入・取得する位置などを指定できるGETとSETです。</p>
SET test testtarou</span></span>
GET test # testtarouが返される</span></span>
GETRANGE test 0 3 # testが返される</span></span>
SETRANGE test 0 first</span></span>
GET test # firstarouが返される</span></span></code></pre>
https://redis.io/commands/setrange/</a></p>
APPEND</h3>
既に存在するキーに対して、末尾に引数の内容を追加します。</p>
SET user yamada</span></span>
APPEND user syoutarou</span></span></code></pre>
ちなみに、キーが存在しない場合は、

新しく作成します。</p>
STRLEN</h3>
こちらは、キーの値の長さを返します。</p>
STRLEN user</span></span></code></pre>INCR</h3>
String型には数値を入れることもできるので、

数値増加のコマンド(INCR)などを使用することもできます。</p>
SET COUNT 100</span></span>
INCR COUNT # INCRは1だけ増加させる</span></span>
GET COUNT # 101が返される</span></span></code></pre>
INCRコマンドは、値が数値のときのみ使えます。</p>
INCRBY</h3>
こちらは、増加させる値を指定できるINCRのような感じです。</p>
SET COUNT 100</span></span>
INCRBY COUNT 102 # 102増加させる</span></span>
GET COUNT # 202が返される</span></span></code></pre>DECRとDECRBY</h3>
こちらは、数値を減少させるバージョンのINCRとINCRBYに該当します。</p>
SETコマンドのオプション</h3>
SETコマンドには、豊富なオプションが用意されています。

その中から一部紹介します。</p>
https://redis.io/commands/set/</a></p>
EX</h4>
EXオプションは、TTL(Time To Live)、すなわち失効時間を設定することができます。</p>
SET anotherkey "will expire in a ten second" EX 10</span></span>
GET anotherkey # 10秒後に行うと、nilになる。</span></span></code></pre>
ちなみにTTLコマンドでキーの残りのTTLを確認できます。</p>
NX</h4>
NXオプションは、キーが存在しない場合に値を設定します。</p>
SET user yamada</span></span>
SET user tarou NX</span></span>
GET user # yamadaが返される</span></span>
SET user tanaka</span></span>
GET user # tanakaが返される</span></span></code></pre>


【Redis基礎】Redisとは何か？Redisの基本を解説
2023-07-17T00:00:00+00:00
本記事では、Redisの概要について解説します。

Redisは、最近のモダンなWebシステムでは使われることが増えてきた、

NoSQLの一種です。</p>
Redisの知識は、インフラの知識にも、

バックエンドの知識にもなるので、

近年重要度が高まっている気がします。</p>
そこで本記事では、Redisの基本について解説します。</p>
Redisとは？</h2>
Redisとは、インメモリのデータストラクチャーと定義されることが多く、

KVSなどが特徴に挙げられます。</p>
https://redis.io/docs/about/</a></p>
といっても、正直ピンとこないと思います（私がそうだった)</p>
インメモリ？KVS？うん？結局どういうことって感じでした。</p>
Redisとは、ざっくり定義するとDBの一種です。</strong></p>
そのため、何らかのデータを格納したい際に使われるものに

変わりはありません。</p>
ただとはいっても、普通のDB(mysqlのような)とは、

確かに異なる特徴があって、それがRedisについての理解をややこしくしている気がします。</p>
インメモリとは？</h3>
Redisの定義に登場する、インメモリデータベースについてですが、

これは、割りとそのまんまでして、

メモリにデータを格納するから、このように呼ばれているのかと思います。

(オンメモリと呼ばれることもあります。)</p>
データをディスクや SSD に保存するわけではないので、障害やシャットダウンなどによって、

データが容易に失われてしまうリスクがありつつも、ディスクアクセスがなくなったことで、

応答時間を短くすることができ、パフォーマンスが向上するというメリットがあります。</strong></p>
https://aws.amazon.com/jp/nosql/in-memory/</a></p>
つまり、インメモリデータベースのRedisは、

DBに変わりはないけど、メモリにデータを格納する、

堅牢性よりもパフォーマンス重視のDBということが伺えますね。</p>
KVSとは？</h3>
KVSとは、Key-Value Storeの略称で、

RDBのようにテーブル構造でデータを格納するのではなく、

user: '山田太郎'</code>のようにRubyのハッシュっぽい形式でデータを格納するスタイルのことです。</p>
KeyとValueを格納するシンプルな形式で、

プログラミングでもお馴染みの形式ですね。(JSのオブジェクト</a>やRubyのHashなど</a>)</p>
[st-card myclass="st-no-shadow" id="785" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
[st-card myclass="st-no-shadow" id="25" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
なので、RDBのようにSQLを使わない、NoSQLで見かけるデータ構造ですね。</p>
NoSQLってなんだっけ？</h3>
NoSQLは、Not only SQLの略称で、

SQLを使わずにデータを保存するデータベースのことを指します。</p>
すなわち、RDBと同じく、

種類の名称なので、NoSQLというDBが存在するわけではなく、

様々なNoSQLが存在します。(RedisもNoSQLです)</strong></p>
基本的にこれらのNoSQLは、

そのパフォーマンス性が重視されて、

技術選定されることが多いかと思います。

(多いユースケースとしては、RDBとの併用で、

RDBのインデックスやチューニングではパフォーマンスに

限界がある部分にNoSQLを用いるなど。NoSQLだけが用いられることは

かなり稀(というか私はあまり見たことがない構成です))</p>
そのため、NoSQLは、いわゆるDBとはちょっと特徴が異なるものと言えそうですね。</p>
結局Redisとは？</h3>
上記を踏まえると、</p>
Redisは、KVSタイプのインメモリデータベース(NoSQL)

といったふうに定義することができそうですね。

(※Redisの場合、豊富なデータ型があるので、

単なるKVSよりも柔軟という特徴がありますが)</p>
</p>
Redisのユースケース</h2>
Redisは、RDBに比べて、

パフォーマンスを重視したものなので、

必然的にパフォーマンスが必要な処理に採用されることがほとんどです。</p>
具体的には、高頻度にデータが書き換わってしまい、

いちいち、ディスクアクセスしていたら、処理が追いつかないようなものに、

採用されているかと思います。</p>
例えば、</p>

セッション情報</li>
リアルタイム性が高い処理全般</li>
キャッシュ</li>
</ul>
などでしょうか。</p>
https://aws.amazon.com/jp/nosql/in-memory/</a></p>
Redisのインストール</h2>
ドキュメントを参考に、macでの環境構築を紹介していきます。</p>
https://redis.io/docs/getting-started/installation/install-redis-on-mac-os/</a></p>
まずは、Homebrewでインストールします。</p>
brew</span> install redis</span></span></code></pre>
インストールしたら、動かしてみます。</p>
redis-server</span></span></code></pre>
サーバーに入るには、</p>
redis-cli</span></span></code></pre>
という感じです。</p>
redis-cliでデータを保存して取り出してみる</h3>
SETコマンドで値を保存します。</p>
SET user yamada</span></span></code></pre>
そして、GETコマンドでキーから値を取得します。</p>
GET user</span></span></code></pre>
これで値を取得することができます。</p>


【Rubyブロック】yieldとProcオブジェクト
2023-06-04T00:00:00+00:00
Rubyの文法の中で、

やはり避けては通れないぐらい重要な概念として、

ブロックがあります。</p>
このブロックは、ものすごくよく使いますし、

重要な概念ですが、

その奥深いところは、結構難しいかなと思います。</p>
本記事は、Ruby基礎編と言っていながら、

その点やや応用編になるかと思います。</p>
ブロックについて、詳しく知らなくてもいい。

とりあえず、どんな感じなのか、ざっと理解できれば十分という方は、

こちらの記事</a>を御覧ください。</p>
本記事では、ブロックについて、

詳細に解説します。</p>
また、下記の動画でRuby全般の文法について、

一通り解説しているので、よろしければご参考ください。</p>


  </iframe>
</div>
ブロックとは？</h2>
ブロックの概要については、

既に下記の記事で解説していますが、</p>

</blockquote>
ブロックは、簡単に言えば、

do~endとか{}とかの塊を指しており、

処理の塊みたいなものです。</p>
処理のかたまりといえば、

関数とかが想起されますが、

Rubyにはすべてがオブジェクト</a>という思想があるため、

この処理のかたまり（すなわちブロック）もオブジェクトとして語られます。

(後に解説するProcオブジェクト)</p>
本記事では、こうしたRubyのブロック周りについて触れていきますが、

まず、yieldというメソッドについて言及します。</p>
yield</h3>
Rubyのメソッドには、

引数としてブロックを渡すことができます。</p>
試しにメソッド呼び出しを、

ブロック付きで呼び出してみるとします。</p>
def</span> say</span></span>
  puts</span> 'hello world'</span></span>
  yield</span></span>
end</span></span>
</span>
say </span>do</span></span>
  puts</span> 'ブロックで呼ばれました'</span></span>
end</span></span></code></pre>
say do ~ endの部分が、

sayメソッドの呼び出しで、

引数にdo ~ endのブロックを渡していますね。</p>
さて、ここで、sayメソッドの方に、

yieldという記法が出現していますが、

これはブロックを実行するメソッドです。</strong></mark></p>
上記の場合、say doという感じで、

ブロックとしてメソッドが実行されているので、

メソッドの内部でyieldとされた場合、ブロック内の、

puts 'ブロックが呼ばれました'が実行されます。</strong></p>
そのため、ブロックなしでメソッドを呼んでいて、

yieldが使われているとエラーになります。</p>
def</span> say</span></span>
  puts</span> 'hello world'</span></span>
  yield</span></span>
end</span></span>
</span>
say </span>#  `say': no block given (yield) (LocalJumpError)となる</span></span></code></pre>
以上のように、

yieldは、ブロックを呼ぶときに

使うメソッドですね。</p>
https://docs.ruby-lang.org/ja/latest/doc/spec=2fcall.html#yield</a></p>
なので、ブロックが渡されているのかどうかを

メソッド内で条件分岐したい場合は、block_given?を使うといいかもしれません。</p>
def</span> say</span></span>
  puts</span> 'hello world'</span></span>
</span>
  if block_given?</span></span>
    yield</span></span>
  end</span></span>
</span>
  puts</span> 'hello2 world'</span></span>
end</span></span>
</span>
say </span>do</span></span>
  puts</span> 'ブロックが呼ばれました'</span></span>
end</span></span>
</span>
say </span># メソッド内でblock_given?で分岐しているのでエラーにならない</span></span></code></pre>
また、yieldに引数を渡すこともできます。</p>
def</span> say</span></span>
  initial_number</span> = yield</span> 1111</span> # ①</span></span>
  puts</span> initial_number </span># 2222と返す ④</span></span>
end</span></span>
</span>
say </span>do</span> |value|</span></span>
  puts</span> value </span># 1111と返す ②</span></span>
  value</span> =</span> value </span>*</span> 2</span> # ③</span></span>
end</span></span></code></pre>
ややこしいですが、

まず最初の二行目のyieldでブロック先に飛びます。</p>
コメントで①とか番号振ってありますが、

その順番で処理が実行されています。</p>
最初はyieldの引数の1111がそのままputsされ、

valueの中身を二倍します。</p>
これで引数の中身が書き換わったので、

initial_numberの中身が2222となって出力されています。</p>
ブロックを引数として明示的に受け取る</h3>
ブロックを引数として明示的に受け取ることもでき、

その場合、&という記法を使います。</p>
この明示的というキーワードですが、

さっきのコードも、

do ~ endがメソッドの引数とみなせますよね。</p>
ただ、上記の場合、明示的とは言いにくいと思います。</p>
これに対して、明示的にブロックが引数であることを

強調した書き方が&という記法にあたります。</strong></mark></p>
呼び出すときにはcallで記載しています。</p>
def</span> say</span>(</span>&</span>args</span>)</span></span>
  initial_number</span> =</span> args.</span>call</span> 1111</span> # ①</span></span>
  puts</span> initial_number </span># 2222と返す ④</span></span>
end</span></span>
</span>
say </span>do</span> |value|</span></span>
  puts</span> value </span># 1111と返す ②</span></span>
  value</span> =</span> value </span>*</span> 2</span> # ③</span></span>
end</span></span></code></pre>Procクラス</h2>
RubyにはProcクラスというものがあり、

これはブロックをオブジェクト化したものです。</p>
https://docs.ruby-lang.org/ja/latest/class/Proc.html</a></p>
value</span> =</span> Proc</span>.</span>new</span> {</span> 'hello world'</span> }</span></span>
puts</span> value.</span>call</span></span></code></pre>
Proc.newという形で作成でき、

中身のブロックを呼び出すときは、

callを使用します。</p>
Procと似たようなものとして、

procメソッドやラムダというものがあります。</p>
# value = Proc.new { 'hello world' }</span></span>
value0</span> =</span> proc</span>{</span> 'hello'</span> }</span></span>
# ラムダ</span></span>
value1</span> =</span> -></span> {</span> 'hello world'</span> }</span> # 引数がある場合 "-> (a, b) { a * b }"のようにする。(a, b)の()は省略可</span></span>
value2</span> =</span> lambda</span> { |a| a </span>*</span> 2</span> }</span></span>
puts</span> value0.</span>call</span></span>
puts</span> value1.</span>call</span></span>
puts</span> value2.</span>call</span>(</span>10</span>)</span></span></code></pre>
どれも挙動としては似ているのですが、

ラムダとProc.newの違いとして有名なのが、

引数の扱い</strong>です。</p>
# Proc.newの場合</span></span>
value</span> =</span> Proc</span>.</span>new</span> { |a, b, c| a.</span>to_i</span> +</span> b.</span>to_i</span> +</span> c.</span>to_i</span> }</span> # nil.to_iを0にするため</span></span>
puts</span> value.</span>call</span>(</span>1</span>,</span> 2</span>)</span> # 引数が1つ足りない</span></span>
puts</span> value.</span>call</span>(</span>1</span>,</span> 2</span>,</span> 3</span>,</span> 4</span>,</span> 5</span>)</span> # 引数が2つ多い</span></span>
# 上記2つは、呼び出せる</span></span>
</span>
# ラムダの場合</span></span>
value1</span> =</span> -></span> a, b, c { a.</span>to_i</span> +</span> b.</span>to_i</span> +</span> c.</span>to_i</span> }</span></span>
# puts value1.call(1, 2) # wrong number of arguments (given 2, expected 3)</span></span>
puts</span> value1.</span>call</span>(</span>1</span>,</span> 2</span>,</span> 3</span>)</span> # 正常</span></span>
# puts value1.call(1, 2, 3, 4, 5) # wrong number of arguments (given 5, expected 3)</span></span>
</span>
# 引数の数が合わないとArgumentErrorが起きる</span></span></code></pre>
これ以外にも、ジャンプ構文内での挙動の違いなどあるのですが、

細かいので引数の扱いが異なるっていうことだけおさえておけば

十分かなと思います。</p>
</p>
&:upcaseの本当の意味</h3>
以前の記事</a>で、&:メソッドの記法について、

少し解説しましたが、どういう仕組みでこうなっているかは触れませんでした。</p>
[st-card myclass="st-no-shadow" id="724" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
ここでこの記法の意味について解説します。</p>
まず、この記法のみそは、to_procメソッドにあります。</p>
https://docs.ruby-lang.org/ja/latest/method/Symbol/i/to_proc.html</a></p>
https://docs.ruby-lang.org/ja/latest/method/Method/i/to_proc.html</a></p>
value</span> =</span> Proc</span>.</span>new</span> { |a, b| a </span>+</span> b }</span></span>
puts</span> value.</span>to_proc</span> # #<Proc:0x00007faf9b91f210 index3.rb:1>みたいに返る</span></span></code></pre>
上記のようにprocオブジェクトを返すメソッドです。</p>
これがシンボルの場合、少し変わった挙動をします。</p>
value</span> =</span> :to_s</span>.</span>to_proc</span></span>
puts</span> value </span># #<Proc:0x00007f796288b4a8(&:to_s)></span></span>
ans</span> =</span> value.</span>call</span>(</span>1</span>)</span></span>
puts</span> ans.</span>class</span> # 1.to_s.classと同じ挙動</span></span></code></pre>
上記は、to_procでシンボルをProcオブジェクトにして、

それに対して、引数を一つ渡してcallしています。</p>
その際、1つ目の引数をレシーバーにして、

元のシンボル名と同名のメソッドを実行します。</strong></p>
すなわち、1つ目の引数、1に対して、

元のシンボル名、to_sと同名のto_sメソッドを実行するので、

1.to_sと同様の挙動になるということです。</strong></mark></p>
さて、ここで下記のコードをもう一度見てみましょう。</p>
[</span>1</span>,</span> 2</span>,</span> 3</span>,</span> 4</span>].</span>map</span>(</span>&</span>:to_s</span>)</span></span></code></pre>
意味としては、1とかの数字をstringにするという感じですが、

どういう仕組でこうなるのかというと、</p>
[st-flexbox url="" rel="nofollow" target="" webicon="" title="実行順序" width="" height="" color="#fff" fontsize="200" radius="0" shadow="#424242" bordercolor="#ccc" borderwidth="1" bgcolor="#ccc" backgroud_image="" blur="on" left="" margin_bottom="0" myclass=""]</p>

&はブロックを引数として受け取るので、:to_sというシンボルをブロック引数として受け取る</strong></li>
&でto_procメソッドが呼ばれて、:to_sシンボルはProcオブジェクトになる</strong></li>
mapによって、1とか2のような数字が第一引数としてProcオブジェクトに渡される。</strong></li>
引数（この場合1とか2)に対して、元のシンボル名と同じto_sメソッドが実行される</strong></li>
mapによって実行されたものが新しい配列に格納される</strong></li>
</ol>
という流れによって、

[1, 2, 3, 4]の配列が、すべてStringにした

新しい配列が作成されます。</p>
ブロックの活用例</h3>
試しにブロックを使って、

ちょっと複雑なコードを書いてみます。</p>
def</span> calc</span>(</span>value</span>,</span> &</span>block</span>)</span></span>
  if block_given?</span></span>
    value.</span>each</span>(</span>&</span>block)</span></span>
  else</span></span>
    value.</span>each</span> do</span> |f|</span></span>
      puts</span> f </span>*</span> 2</span></span>
    end</span></span>
  end</span></span>
end</span></span>
</span>
kakeru_3</span> =</span> Proc</span>.</span>new</span> { |a|</span> puts</span> a </span>*</span> 3</span> }</span></span>
kakeru_2_tasu_3</span> =</span> Proc</span>.</span>new</span> { |a|</span> puts</span> a </span>*</span> 2</span> +</span> 3</span> }</span></span>
</span>
calc</span>([</span>10</span>,</span> 20</span>,</span> 30</span>],</span> &</span>kakeru_3)</span></span>
calc</span>([</span>10</span>,</span> 20</span>,</span> 30</span>],</span> &</span>kakeru_2_tasu_3)</span></span>
calc</span>([</span>10</span>,</span> 20</span>,</span> 30</span>])</span></span></code></pre>
このように、ブロック引数に対して、eachを呼び出すとかすれば、

メソッドの汎用性を高められるでしょう。

(railsのコードとかでは、こういう記法がバシバシ使われている気がする)</p>
つまり、メソッドを呼び出したら画一的に似たようなブロックが実行されるのではなく、

メソッド呼び出し時に、どういうブロックを実行させるかを選択させるようなイメージです。</p>
正直、こういうコードを書くのはめちゃくちゃ難易度が高いと思います。

（上記のコードはただのサンプルで汚いのはお許しを、

あくまでイメージを共有したかっただけですので)</p>
自由自在に、こうしたブロック引数に処理をさせたりして、

結合度が弱い汎用性が高いコードを書けるように慣れれば、

もうかなりのRails上級者といえるでしょう。</p>


【オブジェクト指向入門】Rubyのclass定義方法から継承まで
2023-06-03T00:00:00+00:00
本記事では、オブジェクト指向については、解説します。</p>
オブジェクト指向は、プログラミングの伝統的かつ王道の手法なので、

ぜひとも理解しておきたい概念の一つです。</p>
動画は下記をご参考ください。</p>


  </iframe>
</div>
オブジェクト指向とは？</h2>
オブジェクト指向とは、</mark>

プログラムをオブジェクトとして構築し、</mark>

それらのオブジェクトが相互に作用することによって機能を実現するプログラミング手法のことです。</mark></p>
イメージとしては、学校の先生が生徒(オブジェクト)一人ひとりに

逐一指示を出すのではなく、廊下の張り紙とか校則とかで、

生徒一人ひとりに、行動してもらうという感じです。</p>
これの何がいいかって、先生が逐一指示を出す（すなわち、逐一条件分岐とか

色々コードを書く）とどこかで破綻すると思いますが、

生徒自身（オブジェクト）に振る舞い（メソッド)をもたせることで、

勝手に動いてもらう感じです。</p>
そもそも、システムとは、完成しないものと捉えることもできます。</strong>

そのため、何らかの変更が生じるのは避けられないでしょう。</p>
そんな中、そうした変更に対する影響範囲を小さくしたり、

再利用性を高めたりするための一つの手段が、

オブジェクト指向に該当するともいえるでしょう。</p>
すなわち、変更に強いコードを書くための

手段の一つがオブジェクト指向ともいえるでしょう。</p>
オブジェクト指向は、やや難しいかつ、奥が深い概念なので、

最初はピンとこないかもしれませんが、

要は変更に強い効率的なコーディング手法の一つ</strong>と思ってもらえれば問題ないです。</p>
ユーザーの要求</h3>
一般に、ソフトウェア開発においては、

ユーザーが存在し、その要求を満たすために、

開発することが求められるでしょう。</p>
例えば、受託開発が最もわかりやすいと思いますが、

「こういうものを作ってくれ」と要求されると思います。</p>
たいてい、こういった要求は、不完全で、

流動的なのが開発者の悩みの種です。</p>
オブジェクト指向は、変更に強いプログラミング手法なので、

このような流動的で不完全な要求に対する処世術のような側面もあるのかもしれません。</p>
オブジェクト指向言語の代表選手である、

JavaがSierに多いというのも、この辺の事情も

関係しているのかもしれませんね。</p>
裏を返せば、要求も変わらず、

未来においても、仕様が変わらないシステムであれば、

オブジェクト指向など不要なのです。（そんなシステムがあればの話ですが）</p>
さて、抽象的な話はこれぐらいにして、

早速どういうふうに書いていくのか解説していきます。</p>
本記事ではRubyの場合で解説します。

Ruby自体の解説や文法などの解説は、

こちらの記事</a>で行っているので、

併せてご参考ください。</p>
クラスとは？</h2>
クラスは、オブジェクト指向における設計図の役割</strong>を示すものです。</p>
これだけだと、ピンとこないかもしれませんが、

クラスは、例えるなら学校のクラス名簿みたいなもので、

抽象化された名前のリストでしかなく、

インスタンス化された（いわゆる名簿に載っているその人）

具象物に会うことができないですよね。</p>
その点、クラスというものは抽象的で、

具象化（インスタンス化）に対応するものといった感じです。

（余計分かりにくくなったかな...)</p>
具体例としては、設計図の方が的をいているので、

その例でイメージがつけばそれでOKです。</p>
設計図と言われてもピンとこない場合は、

始業式の学校のクラス名簿を想起して、名前のリスト（抽象物）でしかなく、

それぞれの名前の人にこれから会っていくんだな（インスタンス化）みたいな感じで、

考えるとわかりやすいかも？です。</p>
オブジェクト・インスタンス・レシーバー</h3>
オブジェクトは、クラスをもとに作られた具象物のようなものです。

クラス名簿がクラスなら、生徒がオブジェクトにあたりますね。

インスタンスやレシーバーも似たようなもので、ほとんど別名みたいなものです。</p>
インスタンスは、クラスをインスタンス化すると言ったりするので、

その文脈だと、オブジェクトというよりインスタンスと呼ばれることが多い気がします。</p>
レシーバーは、受け取る人という意味があるので、

メソッドが呼び出される側というニュアンスでオブジェクトのことを、

レシーバーといったりします。</p>
それぞれ、指しているものは似たようなものですが、</strong>

関係性の中で、どの関係を重視しているかによって、</strong>

呼び方が変わっているような感じですかね。</strong></p>
とはいっても、混乱するし、細かい言葉遊びの域のような気もするので、

どれも似たようなものを言っているんだな〜で良いと思います。</p>
メソッド</h3>
これは、オブジェクトの振る舞いを表します。

先程のクラス名簿で考えると、実際の生徒が歩いたり、

授業中に寝たりみたいな振る舞いはメソッドに当たりますね。</p>
クラスの実装</h2>
Rubyにおいて、クラス定義は、</p>
class</span> </span>StudentMember</span></span>
end</span></span></code></pre>
みたいな感じで定義します。</p>
StudentMemberというのがクラス名です。</mark>

（先程のクラス名簿に寄せました、冗長ですね）</p>
クラス名は、大文字で始めます。

キャメルケースとかパスカルケースで書くのが通例なので、

Student_Memberとかじゃなくて、

StudnetMemberですね。</p>
StudentMemberだと冗長なので、

以下、Studentにします。</p>
クラスをインスタンス化する場合は、</p>
Student</span>.</span>new</span></span></code></pre>
でできます。</p>
このnewメソッドを呼び出した際、

インスタンスの初期化に当たるので、

initializeメソッドが定義されている場合、

そこが呼ばれます。</p>
class</span> </span>Student</span></span>
  def</span> initialize</span></span>
    puts</span> '今日から入学しました'</span></span>
  end</span></span>
end</span></span>
</span>
Student</span>.</span>new</span></span>
# 今日から入学しましたと表示される</span></span></code></pre>
initializeメソッドに引数をつけると、

newする際に、その引数を渡す必要があります。</p>
class</span> </span>Student</span></span>
  def</span> initialize</span>(</span>name</span>,</span> attendance_number</span>)</span></span>
    puts</span> "今日から入学しました、出席番号</span>#{</span>attendance_number</span>}</span>番の</span>#{</span>name</span>}</span>です"</span></span>
  end</span></span>
end</span></span>
</span>
Student</span>.</span>new</span>(</span>'斎藤太郎'</span>,</span> 12</span>)</span></span>
# 今日から入学しました、出席番号12番の斎藤太郎です</span></span></code></pre>インスタンスメソッド</h3>
インスタンスメソッドとは、クラス構文の内部で定義されたメソッドで、

インスタンスに対して、呼び出すメソッドです。</p>
class</span> </span>Student</span></span>
  def</span> initialize</span>(</span>name</span>,</span> attendance_number</span>)</span></span>
    puts</span> "今日から入学しました、出席番号</span>#{</span>attendance_number</span>}</span>番の</span>#{</span>name</span>}</span>です"</span></span>
  end</span></span>
</span>
  def</span> walk</span></span>
    puts</span> '今日は1キロ歩いたぜ'</span></span>
  end</span></span>
end</span></span>
</span>
student</span> =</span> Student</span>.</span>new</span>(</span>'斎藤太郎'</span>,</span> 12</span>) </span></span>
# このstudent変数がStundentクラスのインスタンス。</span></span>
# インスタンス自体は #<Student:0x00007fa3e211e620>みたいな感じ</span></span>
</span>
student.</span>walk</span></span></code></pre>インスタンス変数</h3>
インスタンス変数は、クラス内部で使用する、

同じインスタンスの内部で共有される変数のことです。</p>
Rubyでは@ 変数みたいな記法で定義します。</p>
class</span> </span>Student</span></span>
  def</span> initialize</span>(</span>name</span>,</span> attendance_number</span>)</span></span>
    @name</span> =</span> name </span># 引数のnameを@nameというインスタンス変数に格納する</span></span>
    @attendance_number</span> =</span> attendance_number</span></span>
  end</span></span>
</span>
  def</span> introduce</span></span>
    puts</span> "</span>#{</span>@name</span>}</span>と申します。出席番号</span>#{</span>@attendance_number</span>}</span>番です"</span></span>
  end</span></span>
end</span></span>
</span>
student1</span> =</span> Student</span>.</span>new</span>(</span>'斎藤太郎'</span>,</span> 12</span>)</span></span>
student2</span> =</span> Student</span>.</span>new</span>(</span>'佐藤桃子'</span>,</span> 24</span>)</span></span>
student1.</span>introduce</span> # 斎藤太郎と申します。出席番号12番です</span></span>
student2.</span>introduce</span> # 佐藤桃子と申します。出席番号24番です</span></span></code></pre>
インスタンス変数の注意点としては、

作成または代入前にいきなり使用してもエラーにならず、nilを返すという点です。</strong></p>
そのため、バグを発見しにくくなるときがあります。</p>
class</span> </span>Student</span></span>
  def</span> initialize</span>(</span>name</span>,</span> attendance_number</span>)</span></span>
    @name</span> =</span> name </span># 引数のnameを@nameというインスタンス変数に格納する</span></span>
    @attendance_number</span> =</span> attendance_number</span></span>
  end</span></span>
</span>
  def</span> introduce</span></span>
    puts</span> "</span>#{</span>@nane</span>}</span>と申します。出席番号</span>#{</span>@attendance_number</span>}</span>番です"</span> #typoしてみた</span></span>
    puts</span> @nana.</span>nil?</span> # いきなり使ってもnilと返るだけでエラーにならず</span></span>
  end</span></span>
end</span></span>
</span>
student1</span> =</span> Student</span>.</span>new</span>(</span>'斎藤太郎'</span>,</span> 12</span>)</span></span>
student1.</span>introduce</span> # と申します。出席番号12番です。</span></span>
# あれ、名前が表示されていないぞ？</span></span></code></pre>アクセサメソッド</h3>
また、インスタンス変数は、クラス外部からは参照できません。</p>
class</span> </span>Student</span></span>
  def</span> initialize</span>(</span>name</span>,</span> attendance_number</span>)</span></span>
    @name</span> =</span> name </span># 引数のnameを@nameというインスタンス変数に格納する</span></span>
    @attendance_number</span> =</span> attendance_number</span></span>
  end</span></span>
</span>
  def</span> introduce</span></span>
    puts</span> "</span>#{</span>@name</span>}</span>と申します。出席番号</span>#{</span>@attendance_number</span>}</span>番です"</span></span>
  end</span></span>
end</span></span>
</span>
student1</span> =</span> Student</span>.</span>new</span>(</span>'斎藤太郎'</span>,</span> 12</span>)</span></span>
student1.</span>introduce</span></span>
</span>
# よっしゃさっき@nameに値を格納したはずだから取得してみよう</span></span>
puts</span> @name</span> # nilが返るだけ</span></span>
# とやっても取れない</span></span></code></pre>ゲッター</h4>
インスタンス変数の値を取得した場合は、

それ用のメソッドを作る必要があります。</p>
class</span> </span>Student</span></span>
  def</span> initialize</span>(</span>name</span>,</span> attendance_number</span>)</span></span>
    @name</span> =</span> name </span># 引数のnameを@nameというインスタンス変数に格納する</span></span>
    @attendance_number</span> =</span> attendance_number</span></span>
  end</span></span>
</span>
  def</span> introduce</span></span>
    puts</span> "</span>#{</span>@name</span>}</span>と申します。出席番号</span>#{</span>@attendance_number</span>}</span>番です"</span></span>
  end</span></span>
</span>
  def</span> name</span> # こいつ</span></span>
    @name</span></span>
  end</span></span>
end</span></span>
</span>
student1</span> =</span> Student</span>.</span>new</span>(</span>'斎藤太郎'</span>,</span> 12</span>)</span></span>
puts</span> student1.</span>name</span></span></code></pre>
これのように値を取得するメソッドをゲッターメソッドといいます。</p>
セッター</h4>
インスタンス変数の値を変更したい場合は、

=で終わるメソッドを定義して実現します。</p>
class</span> </span>Student</span></span>
  def</span> initialize</span>(</span>name</span>,</span> attendance_number</span>)</span></span>
    @name</span> =</span> name </span># 引数のnameを@nameというインスタンス変数に格納する</span></span>
    @attendance_number</span> =</span> attendance_number</span></span>
  end</span></span>
</span>
  def</span> introduce</span></span>
    puts</span> "</span>#{</span>@name</span>}</span>と申します。出席番号</span>#{</span>@attendance_number</span>}</span>番です"</span></span>
  end</span></span>
</span>
  def</span> name</span></span>
    @name</span></span>
  end</span></span>
</span>
  def</span> name=</span>(</span>val</span>)</span></span>
    @name</span> =</span> val</span></span>
  end</span></span>
end</span></span>
</span>
student1</span> =</span> Student</span>.</span>new</span>(</span>'斎藤太郎'</span>,</span> 12</span>)</span></span>
puts</span> student1.</span>name</span></span>
student1.</span>name</span> =</span> '仮面ライダー'</span></span>
puts</span> student1.</span>name</span></span></code></pre>
これ紛らわしいですが、

student1.name = '仮面ライダー'の部分は、

代入ではなく、name=メソッドの呼び出しになっています。</p>
これのように、値を書き込むメソッドをセッターメソッドといいます。</p>
attr_accessor</h4>
上記のようなセッターやゲッターの記述は、

Rubyではattr_accessorという記法で省略することができます。</strong></p>
class</span> </span>Student</span></span>
  attr_accessor</span> :name</span></span>
</span>
  def</span> initialize</span>(</span>name</span>,</span> attendance_number</span>)</span></span>
    @name</span> =</span> name </span># 引数のnameを@nameというインスタンス変数に格納する</span></span>
    @attendance_number</span> =</span> attendance_number</span></span>
  end</span></span>
</span>
  def</span> introduce</span></span>
    puts</span> "</span>#{</span>@name</span>}</span>と申します。出席番号</span>#{</span>@attendance_number</span>}</span>番です"</span></span>
  end</span></span>
</span>
  # attr_accessorで下記の2つのメソッドを定義する必要がなくなる</span></span>
  # def name</span></span>
  #   @name</span></span>
  # end</span></span>
</span>
  # def name=(val)</span></span>
  #   @name = val</span></span>
  # end</span></span>
end</span></span>
</span>
student1</span> =</span> Student</span>.</span>new</span>(</span>'斎藤太郎'</span>,</span> 12</span>)</span></span>
puts</span> student1.</span>name</span></span>
student1.</span>name</span> =</span> '仮面ライダー'</span></span>
puts</span> student1.</span>name</span></span></code></pre>
読み取りだけにしたい場合は、

attr_readerを、</p>
書き込みだけにしたい場合は、

attr_writerを使うこともできます。</p>
</p>
クラスメソッド</h3>
上記は、クラス構文の内部で定義されるインスタンスメソッドが中心だったのに対し、

クラス自体に定義するクラスメソッドというものもあります。</p>
記法としては、</p>
class</span> </span>Student</span></span>
  attr_accessor</span> :name</span></span>
</span>
  def</span> initialize</span>(</span>name</span>,</span> attendance_number</span>)</span></span>
    @name</span> =</span> name </span># 引数のnameを@nameというインスタンス変数に格納する</span></span>
    @attendance_number</span> =</span> attendance_number</span></span>
  end</span></span>
</span>
  def</span> introduce</span></span>
    puts</span> "</span>#{</span>@name</span>}</span>と申します。出席番号</span>#{</span>@attendance_number</span>}</span>番です"</span></span>
  end</span></span>
</span>
  def</span> self.study</span></span>
    puts</span> "学生の本分は勉強にあります"</span></span>
  end</span></span>
end</span></span>
</span>
Student</span>.</span>study</span> # 学生の本分は勉強にあります</span></span></code></pre>
という記法と、</p>
class</span> </span>Student</span></span>
  attr_accessor</span> :name</span></span>
</span>
  def</span> initialize</span>(</span>name</span>,</span> attendance_number</span>)</span></span>
    @name</span> =</span> name </span># 引数のnameを@nameというインスタンス変数に格納する</span></span>
    @attendance_number</span> =</span> attendance_number</span></span>
  end</span></span>
</span>
  def</span> introduce</span></span>
    puts</span> "</span>#{</span>@name</span>}</span>と申します。出席番号</span>#{</span>@attendance_number</span>}</span>番です"</span></span>
  end</span></span>
</span>
  # def self.study</span></span>
  #   puts "学生の本分は勉強にあります"</span></span>
  # end</span></span>
  </span></span>
  class</span> <<</span> self</span></span>
    def</span> study</span></span>
      puts</span> "学生の本分は勉強にあります"</span></span>
    end</span></span>
  end</span></span>
end</span></span>
</span>
Student</span>.</span>study</span> # 学生の本分は勉強にあります</span></span></code></pre>
という2つの記法があります。</p>
クラスメソッド自体、インスタンスメソッドに比べると、

やや使用頻度が低いので、一概にどちらの記法が良いということはないと思いますが、

前者の方が比較的よく見かける気がします。</p>
後者の記法は、クラスメソッドを大量に定義する場合は、

何度もselfを書く必要がなくなるので良いでしょう。</p>
classにおける定数と変数</h3>
定数は、大文字で始まる、慣習的に大文字やアンダースコアで構成されるものですが、

変数と違い、定数はインスタンスメソッドやクラスメソッドなどの中からも、

参照することができます。</p>
class</span> </span>Student</span></span>
  attr_accessor</span> :name</span></span>
  PRICE</span> =</span> "定数の値段です100"</span></span>
  price</span> =</span> "変数の値段です300"</span></span>
  # ここは両方問題ない</span></span>
  puts</span> PRICE </span></span>
  puts</span> price</span></span>
</span>
  def</span> initialize</span>(</span>name</span>,</span> attendance_number</span>)</span></span>
    @name</span> =</span> name </span># 引数のnameを@nameというインスタンス変数に格納する</span></span>
    @attendance_number</span> =</span> attendance_number</span></span>
    puts</span> price </span>#  undefined local variable or method `price' for #<Student:0x00007f909891c528> (NameError)になる</span></span>
    puts</span> PRICE</span> # 問題なく出力される</span></span>
  end</span></span>
end</span></span>
</span>
Student</span>.</span>new</span>(</span>'斎藤'</span>,</span> 1</span>)</span></span></code></pre>
細かい変数と定数の違いは、

下記のドキュメントに詳しくあるので、

参考ください。</p>
https://docs.ruby-lang.org/ja/latest/doc/spec=2fvariables.html</a></p>
また下記の記事でも軽く触れています。</p>

</blockquote>
なお、定数は、クラスの外部から参照することもできます。</p>
class</span> </span>Student</span></span>
  attr_accessor</span> :name</span></span>
  PRICE</span> =</span> "定数の値段です100"</span></span>
</span>
  def</span> initialize</span>(</span>name</span>,</span> attendance_number</span>)</span></span>
    @name</span> =</span> name </span># 引数のnameを@nameというインスタンス変数に格納する</span></span>
    @attendance_number</span> =</span> attendance_number</span></span>
  end</span></span>
end</span></span>
</span>
Student</span>.</span>new</span>(</span>'斎藤'</span>,</span> 1</span>)</span></span>
# 定数はクラスの外部から取得することもできる</span></span>
puts</span> Student</span>::</span>PRICE</span></span></code></pre>メソッドの可視性</h2>
さて、いろんなメソッドを見てみましたが、

これ以外にも、可視性という観点でメソッドを分類することができます。</p>
すなわち、</p>
[st-mybox title="ポイント" webicon="st-svg-check-circle" color="#757575" bordercolor="#BDBDBD" bgcolor="#ffffff" borderwidth="2" borderradius="5" titleweight="bold" fontsize="" myclass="st-mybox-class" margin="25px 0 25px 0"]</p>

public</li>
private</li>
protected</li>
</ul>
のどれかという問題にあたります。

※ protectedは使用頻度が2つに比べてガクッと下がる上に、privateとの違いが、

ややこしいので本記事ではprotectedの解説は割愛します。</p>
publicメソッド</h3>
publicメソッドは、クラスの外部からも呼び出せるもので、

何も指定しなかったら、デフォルトでこのpublicメソッドになります。</p>
class</span> </span>Student</span></span>
  def</span> initialize</span>(</span>name</span>,</span> attendance_number</span>)</span></span>
    puts</span> "今日から入学しました、出席番号</span>#{</span>attendance_number</span>}</span>番の</span>#{</span>name</span>}</span>です"</span></span>
  end</span></span>
</span>
  def</span> walk</span></span>
    puts</span> '今日は1キロ歩いたぜ'</span></span>
  end</span></span>
end</span></span>
</span>
student</span> =</span> Student</span>.</span>new</span>(</span>'斎藤太郎'</span>,</span> 12</span>) </span></span>
# publicメソッドはクラスの外部からも呼び出せる</span></span>
student.</span>walk</span></span></code></pre>privateメソッド</h3>
上記の、publicメソッドに対して、

privateメソッドとは、クラスの外部から呼び出せず、

内部でのみ使えるメソッドに該当します。</p>
class</span> </span>Student</span></span>
  def</span> initialize</span>(</span>name</span>,</span> attendance_number</span>)</span></span>
    puts</span> "今日から入学しました、出席番号</span>#{</span>attendance_number</span>}</span>番の</span>#{</span>name</span>}</span>です"</span></span>
  end</span></span>
</span>
  def</span> run</span></span>
    walk </span># ここはクラス内部だから呼び出せる</span></span>
    puts</span> '少し歩いたから走るか'</span></span>
  end</span></span>
</span>
  private</span> # ここから下はprivateメソッドになる</span></span>
</span>
  def</span> walk</span></span>
    puts</span> '今日は1キロ歩いたぜ'</span></span>
  end</span></span>
end</span></span>
</span>
student</span> =</span> Student</span>.</span>new</span>(</span>'斎藤太郎'</span>,</span> 12</span>) </span></span>
student.</span>run</span></span>
# ここはクラス外部だからエラーになる</span></span>
student.</span>walk</span> # private method `walk' called for #<Student:0x00007fdf9b91d570> (NoMethodError)となる</span></span></code></pre>継承</h2>
継承とは、既にあるクラスの内容をもとにして、</mark>

別のクラスを作ることで、文字通り既存クラスを継承した、</mark>

新しいクラスを定義することです。</mark></p>
class</span> </span>Student</span></span>
  attr_accessor</span> :name</span></span>
</span>
  def</span> initialize</span>(</span>name</span>,</span> attendance_number</span>)</span></span>
    @name</span> =</span> name </span># 引数のnameを@nameというインスタンス変数に格納する</span></span>
    @attendance_number</span> =</span> attendance_number</span></span>
  end</span></span>
</span>
  def</span> introduce</span></span>
    puts</span> "</span>#{</span>@name</span>}</span>と申します。出席番号は</span>#{</span>@attendance_number</span>}</span>です"</span></span>
  end</span></span>
end</span></span>
</span>
class</span> </span>LiteratureStudent</span> <</span> </span>Student</span></span>
  def</span> initialize</span>(</span>name</span>,</span> attendance_number</span>,</span> favorite_book</span>,</span> favorite_author</span>)</span></span>
    # @name = name # これは親クラスにも存在している</span></span>
    super</span>(name, attendance_number)</span></span>
    @favorite_book</span> =</span> favorite_book</span></span>
    @favorite_author</span> =</span> favorite_author</span></span>
  end</span></span>
</span>
  def</span> introduce</span></span>
    super</span></span>
    puts</span> "愛読書は</span>#{</span>@favorite_book</span>}</span>で、好きな作家は</span>#{</span>@favorite_author</span>}</span>です"</span></span>
  end</span></span>
end</span></span>
</span>
literature_student</span> =</span> LiteratureStudent</span>.</span>new</span>(</span>'太宰'</span>,</span> 5</span>,</span> '「心」'</span>,</span> '夏目漱石'</span>)</span></span>
puts</span> literature_student.</span>name</span> # 親クラスでattr_accessorでnameが定義されているので、子クラスで定義しなくても呼び出せる</span></span>
literature_student.</span>introduce</span></span></code></pre>
上記の場合、LiteratureStudentというものが、

Studentクラスを継承した新しいクラスに該当します。</p>
この場合、Studentクラスは、LiteratureStudentクラスの**スーパークラス（親クラス)と言います。

逆にLiteratureStudentクラスは、Studentクラスの</strong>サブクラス（子クラス）**と言います。</p>
継承は、スーパークラスの機能を引き継ぐものであるため、

基本的には、サブクラスはスーパークラスの一種というように、

包含関係であることが理想です。</p>
文学部の学生は、学生という概念の一種と言えそうなので、

とりあえず、継承関係にはありそうですね。</p>
以前の記事</a>で、

すべてがオブジェクトということについて解説したように、

Rubyの場合、継承関係の頂点にBasicObjectというものが存在します。</p>
そのため、文字列とか数値とか当たり前に使っているものも、

実はこうしたものを継承したオブジェクトに過ぎないということがわかります。</p>
ちなみに、class Userのようにただのクラス定義は、

デフォルトでObjectクラスを継承しています。</p>
スーパークラスのメソッドを呼ぶ</h3>
先程の、継承したクラスをもう一度見てみます。</p>
class Student</span></span>
  attr_accessor :name</span></span>
</span>
  def initialize(name, attendance_number)</span></span>
    @name = name # 引数のnameを@nameというインスタンス変数に格納する</span></span>
    @attendance_number = attendance_number</span></span>
  end</span></span>
</span>
  def introduce</span></span>
    puts "#{@name}と申します。出席番号は#{@attendance_number}です"</span></span>
  end</span></span>
end</span></span>
</span>
class LiteratureStudent < Student</span></span>
  def initialize(name, attendance_number, favorite_book, favorite_author)</span></span>
    # @name = name # これは親クラスにも存在している</span></span>
    super(name, attendance_number)</span></span>
    @favorite_book = favorite_book</span></span>
    @favorite_author = favorite_author</span></span>
  end</span></span>
</span>
  def introduce # オーバーライド</span></span>
    super</span></span>
    puts "愛読書は#{@favorite_book}で、好きな作家は#{@favorite_author}です"</span></span>
  end</span></span>
end</span></span>
</span>
literature_student = LiteratureStudent.new('太宰', 5, '「心」', '夏目漱石')</span></span>
puts literature_student.name # 親クラスでattr_accessorでnameが定義されているので、子クラスで定義しなくても呼び出せる</span></span>
literature_student.introduce</span></span></code></pre>
ここで、superという記法に注目します。

これで親クラスの同名メソッドを呼び出します。</p>
なお、上記のコードでいうと、

introduceメソッドの内容が、

子クラスの場合で変わっていると思いますが、

このように同名メソッドを子クラスの方で上書きすることをオーバーライド</strong>と言います。</p>


【Vim/NeoVimマクロ】作成/保存/追記/定義/格納場所など使用例も解説
2023-05-27T00:00:00+00:00
本記事では、Vimのマクロについて解説します。</p>
マクロは、Vimの機能の中でも、

応用的なトピックだと思いますが、

使いこなせると便利なので、本記事で作成、保存、定義、

格納場所といった基本事項を解説します。</p>
Vimの基本を学習したい方は、

こちらの記事</a>を先に御覧ください。</p>
本記事の内容は、下記の動画でも

ご紹介しているので、動画でハンズオンしたい方は、

ご参考ください。</p>


  </iframe>
</div>
マクロとは？</h2>
Vimのマクロとは、</mark>

一連の作業とかを保存して、</mark>

効率化したいときに使える、</mark>

自動化処理の方法です。</mark></p>
レコーディングといったりすることもあります。</p>
qキー押して、

任意のレジスタを指定すると、

マクロの記録を開始し、

recording @ eみたいな感じで表示されます。</strong></p>
</p>
例えば、

aレジスタにマクロを記録したいときは、

ノーマルモードでqaとすればレコーディング開始となります。</strong></mark></p>
終了するときは、もう一度qキーを押します。</p>
マクロは、レジスタに保存される</strong>ので、

名前付きレジスタになにか格納していたとき、

同じレジスタを指定するとマクロで上書きされてしまいます。</p>
なので、レジスタ周りで衝突しないよう注意する必要があります。</p>
レジスタって何？っていう人は

こちらの記事</a>で解説しているので、

ご参考ください。</p>

</blockquote>
マクロの実行</h2>
マクロを実行するときは、

@ {register}でできます。</strong></mark></p>
 </mark></p>
@@ だと直前に呼び出されたマクロを実行できます。</strong></mark></p>
試しにちょっとしたマクロを作成してみます。

次のようなコードが合ったとします。</p>
Plug 'Shougo/vimproc.vim', {'do' : 'make'} </span></span>
Plug 'https://github.com/ycm-core/YouCompleteMe'</span></span>
Plug 'vim-test/vim-test'</span></span>
Plug 'https://github.com/vim-scripts/ScrollColors'</span></span>
Plug 'kyazdani42/blue-moon'Plug 'https://github.com/AlessandroYorba/Breve.git'</span></span></code></pre>
このファイルで、Plugのあとに、,を入力するマクロを作成してみようと思います。</p>
下記のような手順です。</p>
[st-mybox title="順序" webicon="st-svg-check-circle" color="#757575" bordercolor="#BDBDBD" bgcolor="#ffffff" borderwidth="2" borderradius="5" titleweight="bold" fontsize="" myclass="st-mybox-class" margin="25px 0 25px 0"]</p>

まず、一番上の行にカーソルをおいて、qqとかでレコーディング開始。</strong></li>
0で先頭にカーソルを持っていき、</strong></li>
fgで直近のgにカーソルを持っていき、</strong></li>
aでインサートに入り、,を入力しesc。</strong></li>
最後にjで下の行に移動し、qを押しレコーディング終了。</strong></li>
</ol>
qq 0fga, <esc> j qという流れになります。</p>
マクロを並列に実行する</h3>
通常どおり、マクロを@ qとかで

実行すると、直列で実行され途中でエラーがあれば止まってしまいます。</p>
例えば、</p>
Plug 'Shougo/vimproc.vim', {'do' : 'make'} </span></span>
Plug 'https://github.com/ycm-core/YouCompleteMe'</span></span>
Plug 'vim-test/vim-test'</span></span>
" 邪魔するぜーーー</span></span>
Plug 'https://github.com/vim-scripts/ScrollColors'</span></span>
Plug 'kyazdani42/blue-moon'Plug 'https://github.com/AlessandroYorba/Breve.git'</span></span></code></pre>
こんな感じで、規則性に合わないコードが途中に混ざると、

上記のマクロの場合、fgのところで

gが見つからず、そこで処理が止まります。</p>
こういった問題を回避するには、

並列に実行する方法があります。</strong></p>
マクロの内容は、

qq 0fga, <esc> q

と、jで下の行に進む以外は同じです。</p>
その後に、Vで行をヴィジュアルモードで選択して、</p>
:'<,'>normal @@</span></span></code></pre>
でマクロを実行します。</p>
こうすると、並列に実行されるため、

こける行があっても、他の行は正常に実行されます。</p>
これはそれぞれの呼び出しが独立しているからです。</p>
マクロの追記</h3>
マクロを記録する際、

「jするの忘れた！」ってなった際、

また、1からqqなんてすると、

以前のマクロは上書きされてしまいます。</p>
その場合は、マクロに追記すると良いと思います。</p>
追記する際は、qQとレジスタを大文字にすれば大丈夫です。</p>
マクロ使用例</h2>
以下、マクロの使用例をご紹介します。

後半では、マクロの編集とinit.vimへの定義方法などについても

言及します。</p>
Rubyファイル</h3>
1つ目の例として、

Rubyファイルでのマクロを取り上げます。</p>
例えば次のようなファイルがあるとします。</p>
class</span> </span>Test</span></span>
end</span></span></code></pre>
これを次のような感じにしたいとします。</p>
Module Api</span></span>
 class</span> </span>Test</span></span>
 end</span></span>
end</span></span></code></pre>
RailsのAPIモードとかでおなじみのネームスペースです。</p>
これは、マクロの手順としては、</p>

</blockquote>
1、ggで先頭行に移動

2、Oで上の行にinsertモード

3、module Apiと入力して<esc>

4、jで下の行に移動して、>Gで末尾の行までインデントを一段深くする

5、Gで末尾にカーソルを移動し、oで下の行にinsertモード

6、endと入力して<esc>で<<でインデントを戻す</p>
このような感じになります。

Railsをよく使う人は、

このようなマクロをinit.vimに保存する(後述)のも面白いかもしれません。</p>
インクリメント系</h3>
次は、インクリメンタル系をご紹介します。</p>
こんなファイルがあるとします。</p>
今日はいい天気</span></span>
昨日はまずまず</span></span>
一昨日は普通</span></span>
明日はおそらくいい天気</span></span>
去年の今日はどんな天気？</span></span></code></pre>
このファイルを、</p>
1) 今日はいい天気</span></span>
2) 昨日はまずまず</span></span>
3) 一昨日は普通</span></span>
4) 明日はおそらくいい天気</span></span>
5) 去年の今日はどんな天気？</span></span></code></pre>
みたいにインクリメントした(数字）を入れたいとします。</p>
こうしたマクロを作るには、</p>

</blockquote>
1、:let i=1で変数iの初期値を1に設定する

2、qaでレジスタaにマクロを記録開始

3、Iで先頭にカーソル持ってきてinsertモード

4、<C-r>=i<CR><esc>でExpressionoモードを交えつつ、変数iの値を挿入して ) でエスケープ

5、:let i += 1でインクリメントk

6、qで記録終了</p>
実行する際は、こちらの場合は、

並列にマクロを実行します。</p>
こういうインクリメンタルも、

地味に使う時があったりするので、

覚えておくと便利かもしれません。</p>
マクロの編集</h3>
次にマクロの編集についてふれます。</p>
まず、マクロもレジスタに保存されています。</p>
試しに、aレジスタの内容を

末尾に貼り付けてみます。

Gで末尾の行に移動して、</p>
:put a</span></span></code></pre>
でレジスタの内容を貼り付けます。</p>
そして、貼り付けられたものを

編集して、aレジスタに保存し直すには、

"add</strong>でできます。</p>
この操作自体は

aレジスタにddで格納しているだけなので、

マクロもレジスタも関係ありません。</p>
マクロといっても、

要はレジスタに格納されている、

一連の操作みたいな感じだということがわかります。</p>
マクロの編集はこのようにして、

行うこともできます。</p>
マクロの定義</h3>
最後にinit.vimでのマクロ定義に言及します。</p>
頻繁に使うマクロとかは、

毎度毎度レコーディングするのも面倒なので、

init.vimとか.vimrcに定義してしまうと楽だと思います。</p>
コード例としては、</p>
let @q = ';;a;' " これは行末にセミコロンを入れるマクロで、qレジスタに定義している。</span></span></code></pre>
のような感じです。</p>
これでvimを開いた段階で、

すでにqレジスタにこのマクロが定義されている状態になります。</p>
よろしければ、Qiitaの方もご覧いただけますと幸いです。</p>
https://qiita.com/reisuta</a></p>


【保存必須】Vimレジスタ完全解説 これだけは知っておきたい10種類のレジスタ
2023-05-26T00:00:00+00:00
最近では、Neovimのプラグインが優秀すぎて、

素のVimの機能を使用しなくても、

十分便利に使うことがなってきたかもしれません。</p>
しかし、プラグインを使わずとも、

Vimには、便利な機能がたくさんあり、</strong>

それらを使いこなしてこそ、</strong>

真のVimmerであり、Vim教徒です。</strong></p>
本記事では、そんなVimの機能の中でも

やや応用的でありながら、絶対に外すことはできない、

レジスタについて完全解説します。</p>
本記事の動画は、下記になります。</strong>

やや抽象的な説明が多いので、</strong>

動画でのハンズオンのほうがわかりやすいかもしれません。</strong></p>


  </iframe>
</div>
レジスタとは？</h2>
レジスタとは、

Vim独自のクリップボードのようなもの</strong>で、

ヤンク(yy)や削除(dd)とかしたものを、

このレジスタという領域に格納しています。</p>
https://vim-jp.org/vimdoc-ja/usr_10.html</a></p>
ヤンクや削除といった、

Vimの基本コマンドを復習したい方は、

こちらの記事</a>をご参考ください。</p>
[st-card myclass="st-no-shadow" id="11" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
さて、レジスタの中身を確認するには、</p>
:reg</span></span></code></pre>
で確認できます。</p>
</p>
実行すると、こんな感じで、

現在のレジスタに格納されている一覧</strong>を確認することができます。</p>
Nameという列に、

0とか1のような数字から、

aとかjみたいなアルファベット、

%や:のような記号が存在します。</p>
これらは、レジスタの名称なのですが、

それぞれ異なる役割を持っています。</p>
これらについて順に解説していきます。</p>
レジスタの種類</h2>
以下、順番にそれぞれのレジスタの名称と、

役割について解説していきます。</p>
無名レジスタ ("")</h3>
無名レジスタとは何でしょうか？</p>
これは、平たく言うと

デフォルトのレジスタのような感じです。</mark></p>


無名レジスタ "" quote_quote</em> quotequote</em>

このレジスタには、コマンド "d", "c", "s", "x" 等で削除されたテキストや、"y" 等

のコピーコマンドでコピーされたテキストが蓄えられる。特定のレジスタが指定されて

いてもいなくても関係ない (例えば "xdd でもこれが使われる)。つまり無名レジスタ

は最後に使われたレジスタを指していると考えられる。よって、大文字レジスタを使っ

て名前つきレジスタにテキストを追加したときも、無名レジスタの中身は、その名前つ

きレジスタと同じになる。

例外はレジスタ '_' である。"_dd は、削除されたテキストをどのレジスタにも蓄え

ない。

無名レジスタの中身は、レジスタを指定しない貼り付けコマンド (p や P) で使うこと

ができる。加えて、このレジスタは '"' という名前で使うことができる。これは、使

うときには二重引用符 '"' を 2 個打ち込むということである。レジスタ "" に対する

書き込みはレジスタ "0 にも書き込むことになる。

{Vi ではレジスタの内容はファイルを変更するときに失われ、'"' もない}</li>
</ol>
vim help (:h "")</p>
</blockquote>
つまり、何も考えず、

ヤンクとかコピーとか削除をしていると、

この無名レジスタに格納されて、

貼り付けの際も、単にpとかで行うと、

この無名レジスタの内容が貼り付けられるということです。</strong></mark></p>
そしてこの後、順に解説しますが、

aとかの名前付きレジスタを指定して、

そこにヤンクとかをしても、

この無名レジスタにも同じものがヤンクされます。</p>
ちなみに、削除・ヤンク・プットは、

レジスタを指定して実行することができます。</p>
"{register}</span></span>
・名前付きレジスタ(a)からpを実行したい場合</span></span>
"ap</span></span>
・無名レジスタ("")からpを実行したい場合</span></span>
p または ""p</span></span>
→ レジスタを指定しないと無名レジスタが使われる。</span></span></code></pre>
すなわち、"と押した後に、

register名を指定すると、

そのレジスタの内容を、ヤンクなりできるという感じです。</p>
ヤンクレジスタ（"0)</h3>
yコマンドを使うと、

無名レジスタに加えて、

ヤンクレジスタにもコピーされます。</p>
ヤンクレジスタは、0のことです。</strong></p>
このレジスタは、dとかxのようなコマンドを使っても、

書き変わらないので、ヤンクしたものを貼り付けるために、

ddしたら、レジスタが上書きされちまった問題を

防ぐことができます。</p>
番号付きレジスタ ("1 ~ "9)</h3>
こちらは、削除とか変更をした際に、

1から順番に9までのレジスタにその内容が格納されていく。</p>
ヤンクレジスタに対する、削除レジスタみたいな感じです。</p>
名前付きレジスタ("a ~ "z "A ~ "Z)</h3>
これらのレジスタは、ユーザーが自由に使えるレジスタにあたります。</strong>

なにかをレジスタに格納したいとき、

番号付きレジスタとかに入れてしまうと、

ddとかを繰り返すうちに消えてしまうおそれがあるが、

名前付きレジスタは、指定しない限りは書き換わりません。</p>
小文字と大文字の違いは、

小文字指定の場合、すでに格納されている内容が消えるのに対し、</mark>

大文字指定の場合、すでに格納されている内容への追記になります。</mark></p>
小削除用レジスタ ("-)</h3>
これはあまり聞かないレジスタかもしれません。

（それにあまり使う機会も多くないかなと思います。）</p>
helpでは、</p>


小削除用レジスタ "- quote_-</em> quote-</em>

このレジスタには、範囲が1行以下の削除コマンドで削除されたテキストが蓄えられる。

ただし、コマンドに ["x] で別のレジスタ名を指定したときはこれには蓄えられない。</li>
</ol>
vim help (:h "-)</p>
</blockquote>
となっています。</p>
helpでは、１行以下となっているので、

ddで削除した場合も格納されるとおもいきや、

格納されませんでした（筆者環境の場合)</p>
ビジュアルモードとかで、単語単位の削除で、

明示的にレジスタを指定しなかった場合に、

このレジスタに格納されます。</p>
読み取り専用レジスタ (": ". "% )</h3>
":</h4>
一番最近に実行されたコマンドラインが、

格納されるレジスタです。</p>
実行したいときは、コマンドラインモードで、

@ :で実行できます。</strong></p>
".</h4>
こちらは、最後に挿入されたテキストが、

格納されるレジスタです。</p>
"%</h4>
カレントファイル名が、

格納されるレジスタです。</p>
ブラックホールレジスタ("_)</h3>
消去専用レジスタのことです。</p>
vimではddとかをしても、

事実上は、削除ではなくカットにあたり、

番号付きレジスタとかに格納されるが、

このレジスタを指定することで文字通りの削除になります。</p>
システムクリップボードレジスタ("+)</h3>
システムのクリップボードのレジスタは+にあります。</p>
X11ウインドウシステムには、プライマリと呼ばれるクリップボードがあるらしく、

＊がそのレジスタにあたります。</p>
windowsやmacでは、これはないので、

+も*もほとんど同じようなものといった感じかなと思います。</p>
Vimのhelpでは、選択範囲レジスタとなっており、

難しく書かれているが、要はクリップボードの内容が、

格納されているレジスタで、環境とかOSによって、

+とか*になったりする感じと思っていただければ大丈夫です。</p>
最終検索パターン用レジスタ ("/ )</h3>
これは割りとそのまんまで、

最後に/ とかで検索したパターンの内容が、

格納されるレジスタです。</p>
コマンドで検索することができ、

例えばこれでhlsearchのハイライトを変えることができます。</p>
:let @/ = "Plug"</span></span></code></pre>
この場合、Plugというワードでハイライトします。</p>
まあそんなに使う機会はないかもしれませんが。</p>
Expressionレジスタ("=)</h3>
これは、insertモードで<C-r>=を実行して、

電卓のように、計算式を入力できます。</p>
ここまで来ると、レジスタというより電卓に近い気もします。</p>
コマンドラインモードで、<C-r>=を実行しても、

このモードに入ることは可能です。</p>
round(150.123)みたいに、

関数のようなものを使うことも可能です。</p>
いやでも、いつ使うねんっていうぐらい、

使い所が難しいレジスタのような気もします。</p>
こいつを使いこなせるようになったら、

結構なVim職人かなと思います。</p>
よく使うレジスタ</h2>
以上、vimのレジスタについて紹介しました。

平たく言えば、レジスタとは、

複数種類のクリップボードみたいな感じですね</strong></p>
本来なら一つしかないクリップボードが、

たくさんあるなんて、やっぱりVimってすごいですね。</p>
Vimのhelpでは、

代替ファイルレジスタというものもありましたが、

ニッチすぎるかつ、一生使わなくてもおかしくないので、

取りあげませんでした。</p>
今回挙げた中でも、

一番使うのは、やはり無名レジスタで、

あとは番号付きレジスタや名前付きレジスタでしょうか。</strong></p>
レジスタを的確に使いこなせるようになると、

一気にVimmerとしてのレベルが上がるので、

ぜひともマスターしていただけると。</p>
[st-card myclass="st-no-shadow" id="873" label="あわせて読みたい" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>


【凡才エンジニアの処世術】フルスタックエンジニアの本当の意味
2023-05-17T00:00:00+00:00
エンジニア界隈では、

しばしばフルスタックエンジニアという言葉を耳にします。</p>
しかし、このフルスタックエンジニアとは何なのでしょうか？</p>
「フロントもバックエンドもモバイルもインフラも全てできる人？」

「フロントとバックエンドができる人？」

「そもそもできるってどの程度のレベル？」</p>
など色々突っ込みどころがある言葉かなと思います。</p>
そのため、このフルスタックエンジニアという言葉自体が

気に食わないという現役エンジニアも多いかもしれません。</p>
本記事では、このフルスタックエンジニアについて、

私が考えるフルスタックエンジニアについて、

述べていきたいと思います。</p>
本記事の動画バージョンは、

下記になります。</p>


  </iframe>
</div>
フルスタックエンジニアとは？</h2>
フルスタックエンジニアとは一般的には、

その名の通り、開発におけるすべてのスキルを

備えているとされるエンジニアです。</strong></p>
ふわっとした言葉なので、

人によって定義は微妙に変わりますが、

フロントエンドとバックエンドの両方</strong>ができるというのが最低条件でしょう。

（これらに加えて、インフラやiOS, Android開発も含めて

フルスタックエンジニアと定義する人もいる)</p>
本記事では、わかりやすさのため、

フロントエンドとバックエンド、インフラができるエンジニアを

フルスタックエンジニアと定義します。</strong></p>
さて、もしかするとお気づきかもしれませんが、

上記の定義にはすでに欠陥</strong>があります。</p>
すなわち、「できる」ってどの程度か？

フロントエンドってどこまでを指すか？

バックエンドってどこまでを指すか？

インフラってどこまでを指すか？</p>
という冒頭でも触れた問題です。</p>
フルスタックエンジニアは、

大抵の場合、意味がふわっとしがちな言葉なので、

とにかく「広い分野ができる」エンジニアとして認識されています。</p>
フルスタックと専業</h2>
フルスタックエンジニアは、キラキラしたイメージがあるので、

単にバックエンドだけできるや、フロントエンドだけできるよりも

良いように思えるかもしれません。</p>
実際、良い悪いの問題で考えると、

良いと思います。</strong></p>
広い分野の知識があることは、

武器になることも多いでしょう。</p>
それに対して、専門のエンジニアは、

その分野の知識しかないので、

フルスタックエンジニアよりは、

融通が効かなかったりします。</p>
</p>
しかし、エンジニアとしてのスキルレベルが高いという

観点ではフルスタックエンジニアは、

専門エンジニアに劣ることがほとんどです。</strong></mark></p>
（もちろん、ごく少数のフルスタックですべてのスキルレベルが高い

化け物もいるかもしれませんが)</p>
それに既に少しだけ触れましたが、

このフルスタックエンジニアという言葉自体を嫌っている人も

少なくない印象です。

(この点について、面白い掲示板</a>を見つけたので掲載しておきます。)</p>
まあ、フルスタックエンジニアという言葉から出る全能感に対して、

実態は中途半端なエンジニアであることから生じる乖離が、

口さきだけの印象を与えているのが原因な気はしておりますが。</p>
フルスタックエンジニアのスキルが低いことの卑近な例だと、

色々な案件を広く浅くやっているエンジニアなどがわかりやすいと思います。</p>
例えばSESなどで、2ヶ月間Javaの案件に入るも、

3ヶ月目からは、3ヶ月間、Reactの案件に入り、

その後は、Swiftの案件に2ヶ月入ったり、

その後は、AWSの案件に入ったりと、

プロジェクトを転々としているケースがあるとします。</p>
この場合、実務経験がある技術領域だけでいえば、

フロント、バックエンド、モバイル、インフラ全てになるので、

領域的にはフルスタックエンジニアです。</p>
しかし、お察しの通り、

上記のエンジニアの技術レベルが高いかと考えると、

かなり微妙だと思います。</p>
結局どれも身になっていないのではないかという

不安を感じますよね。</p>
もちろん、これは極端な例ではありますが、

フルスタックエンジニアとして、専門性を高めていくには、

それぞれの技術領域でそれぞれ3年以上の実務経験を積んでいかなければ

ならないことを考えると、最低でも9年以上の実務経験があるエンジニアに

なるので、市場にはかなり少ないことがわかります。

(ちなみに、実務経験という尺度自体も多分に曖昧かつ広範な領域を含んだ言葉なので、

個人的には信ぴょう性があるのか疑問があります。この点については、

こちらの記事</a>で詳しく考察しています。)</p>
そのため、フルスタックエンジニアは、

化け物クラスの例で考えると、

いるかどうかの幻の存在に近いので、

普段フルスタックエンジニアと言っているのは、

大抵の場合、それぞれを浅く広くやっているエンジニアがほとんどだと思います。</p>
そう考えると、巷でフルスタックエンジニアと

言われている人が、技術力が高いかどうかは

疑問が残るところです。</p>
もう少し深ぼっていくために、

以下、それぞれのスキルスタックを大雑把にまとめてみます。</p>
フロントエンドエンジニア専業</h3>
フロントエンド専門の人が求められる技術スタックを

羅列してみます。</p>

</blockquote>

JavaScript / TypeScriptに対する深い知識</strong></li>
node_modulesなど、JSのエコシステムについての深い理解</li>
JavaScriptのライブラリについての知識</li>
JSフレームワーク一つ以上に対する深い知識</li>
最新トレンドを継続的にキャッチアップしていく素養</li>
CSSの深い知識</li>
UI/UXに対する知見</li>
Webデザインのスキルもあるといい（場合によっては必須)</li>
APIとの接続に対する知識</li>
バックエンドに対する最低限の理解</li>
</ul>
フロントエンドエンジニアの場合、

とにかく、JavaScriptとTypeScriptへの深い理解、

フレームワークに対する深い知識が求められます。</strong></p>
それと、node_modulesなどを初めとした、

JSのライブラリ周りのエコシステムについて、

深い理解が求められます。</p>
専業の場合、これらのスキルに相当自信があるのはもちろん、

場合によっては、他の自信があるフロントエンドエンジニアと

差別化できるぐらいのレベルが必要です。</p>
バックエンドエンジニア専業</h3>
これに対して、バックエンド専門の場合、</p>

</blockquote>

バックエンド言語最低１つに対する深い知識(できれば静的型付け)</li>
DBに対する深い知識</li>
APIの深い理解</li>
アルゴリズムやCSの知見</li>
パフォーマンスに対する知見</li>
セキュリティーへの知見</li>
最低限のインフラ知識</li>
最低限のJavaScript / TypeScript</li>
</ul>
バックエンドの場合、

とにかく、DBやAPIの処理などの、

細かいパフォーマンスやセキュリティー要件などが

シビアに見られます。</p>
そのため、これらに対する相当深い知識が求められます。</p>
というか、ある一定以上のレベルは、

専門性が高すぎてセンスや才能が必要な領域とすら思えます。</p>
理系でCS専攻という、

いわゆるエリートはバックエンド専業だったりすることが

多い気がするので、基本的にバックエンド専業を目指す場合、

こうしたエリート達と遜色ないレベルに達する必要があります。</p>
またバックエンドは、プロダクトによって難易度がまちまちで、

アルゴリズム系が複雑にからむプロダクトのバックエンド専業は、</mark>

特にレベルが高い印象があります。</mark></p>
総じて、下記のようなプロダクトのバックエンド専業をしている

エンジニアは相当高いスキルでしょう。</p>

</blockquote>

銀行 (セキュリティー要件が厳しく、障害が一大問題になるので、止めないためにできることを考慮したりなど、バックエンドやインフラ領域において高いスキルが求められる)</li>
仮想通貨系 (これも銀行と同様だが、こちらはそれに比べてブロックチェーンなど最新技術の動向への知見も

必須だったり、複雑なアルゴリズムが必要だったりと、総じてレベルが高い）</li>
ユーザー数が多いプロダクト（トラフィックが多いので、インフラやバックエンドのクエリー制御など、

考慮することが多い）</li>
リアルタイム性が強いプロダクト（ちょっとした時間のずれとかが障害につながるので、処理の正確さ、効率の良さなど、チューニングが難しい印象。)</li>
</ul>
</p>
このへんは、私の印象なので「違うよ！」って言う部分もあるかもしれませんが、

概ねこのような感じだと思います。

(難易度が高い理由そこじゃないよっていうのはあるかもしれないですが、

難易度が高いっていうことは間違ってないと思います。）</p>
これに対して、バックエンドの難易度が低いのは、</p>

</blockquote>

ユーザー数が少ない (処理とかインフラ構成がガバガバでもなんとかなる）</li>
処理が単純または、バグによる損失が小さい</li>
お金が関わらない</li>
</ul>
このあたりでしょうか。

もちろん、バックエンド専業であれば、必ずしも難易度が低いわけでもないと思いますが、

少なくとも上記よりは難易度は低いでしょう。</p>
そう考えると、銀行系は、上記の難易度が高い4項目をすべて備えているので、

やはりえぐいですね。</p>
すでに銀行系でバックエンド専業でやられている方は尊敬します。</p>
バックエンド専業の場合、こうしたレベルと戦う土俵に上がらなければなりません。</p>
フルスタックエンジニア</h3>
最後にフルスタックエンジニアはどうかというと、</p>

</blockquote>

バックエンド言語最低一つが、最低限実装できる</li>
フロントエンドの実装が最低限行える。</li>
インフラの知識が最低限ある。</li>
</ul>
おや、フロントエンドやバックエンド専業に比べて、

求められる要件のレベルが下がったような。</p>
フルスタックエンジニアは、領域の広さが売りですので、

深さは専業よりは求められません。</strong></p>
フロントエンドは、JS周りのエコシステムや、

複雑に入りくんだnode_modulesの構造などは、

ふんわり理解でもとりあえず大丈夫で、

バックエンドは、アルゴリズムやCSの知識とかはなくても、

なんとかなるっていうレベルといったところでしょうか。</p>
とりあえず、フロント、バックエンド問わず、

タスクに着手できればいいっていう感じですかね。</p>
そのため、浅く広くのスキルスタックでもいいというのが、

フルスタックエンジニアの特徴です。</p>
（もちろん、広く深くというフルスタックエンジニアもいるにはいるでしょうが、

ごく少数なので、そういうケースはカウントしないでおきます。それに大抵の場合、

広く深くのフルスタックエンジニアは、どこかの専門が強いのが第一条件で、

他の分野の知見もあるというパターンなので、厳密にはフルスタックエンジニアというより、

専業エンジニアで異分野も強いっていうパターンだと思います。)</p>
フルスタックエンジニアは凡人の処世術</h2>
フロントエンドの専業や、

バックエンドの専業は、

求められるレベルがすごく高いです。</strong></p>
</p>
そのため、この領域はだれでも目指せるものではありません。</strong>

何年も経験を積むか、経験が少ないならもともとセンスがある才能豊かな人が、

目指せる領域かもしれません。</p>
たまに、未経験や駆け出しエンジニアで、

バックエンドやフロントエンド志望という方がいます。</p>
バックエンドやフロントエンドしかやらないということは、

求められるレベルも数段高いということです。</p>
未経験や駆け出しエンジニアの段階で、

そのレベルを目指すのは至難の技です。</p>
初期の段階であちこち手を出すのは

中途半端ということなのかもしれませんが、

未経験や駆け出しの時点で、スキルは大抵中途半端です。</p>
だったら、中途半端らしく、

色々つまみ食いするのが良いのではと思います。</p>
フルスタックエンジニアは、

名前はかっこよくて、

なんともすごい人感がありますが、

実際は、専業エンジニアになれないだけです。</strong></p>
専業エンジニアになれないから、

相互のスキルを補完しあって、

ごまかしているのです。</p>
しかし、これは悪いことではありません。</strong>

経験が浅い段階では、むしろ

このようにフルスタックエンジニアを目指すほうが理想です。</p>
なぜなら、誰にでも再現性がある程度あるから</strong>。</p>
</p>
フルスタックエンジニアは、

専業に比べ、ごまかしがききます。</strong>

それに、専業の場合に突き当たる、

レベルが高い壁は、フルスタックエンジニアの場合は、

中途半端でも割と見逃してもらえます。</p>
なので、努力で目指せるものだと思います。</p>
例えば、フロントエンド専業の人が、

JSの非同期処理を理解していなかったら、

は？って感じですが、

フルスタックエンジニアなら、まだ多めに見てもらえることが多いです。（多分）</p>
バックエンド専業の人が、

DB設計やクエリーのチューニングができなかったら、

は？って感じですが、

フルスタックエンジニアなら、多めに見てもらえることが多いです。（多分）</p>
もちろん、何もかもできないのは問題ですが、

一つできないところがあっても、

ほかでカバーしやすいということです。</strong></p>
例えば、ややフロントが強いフルスタックエンジニアの人であれば、

DB設計とかはちょっと苦手だけど、その分TypeScriptとかReactは

得意だからそのへんでカバーできたり、</p>
バックエンドがやや強いフルスタックエンジニアであれば、

JSの非同期処理の理解が甘くても、DB設計とかで

カバーできたりといった感じです。</p>
専業の場合は、こうはいきません。

というかこのレベルだったら専業を名乗れません。</p>
キャリア初期でフルスタックエンジニアを目指すメリット</h3>
フルスタックエンジニアの最大の強みは、

領域の広さです。</p>
これは、ベテランの場合だと専門性の浅さから、

デメリットになりがちですが、

20代などのキャリア初期であれば、

メリットに働くことが多いです。</strong></p>
例えば、</p>

</blockquote>

色々な領域を知ることができるので、技術同士の関係性がわかる</li>
自分の向いていそうな分野を見定められる</li>
高い壁や専門性の高いものはフルスタックであることでごまかせる</li>
フルスタックエンジニアから専業を目指すこともできる</li>
その気になれば、どの専業も狙える</li>
</ul>
フルスタックエンジニアは、

一言で言うなら、

まだ飛び立つ先が決まっていないワタリドリみたいなもので、

いつでも方向転換できる状態です。</p>
</p>
この柔軟性が最大の強みです。</strong>

なので、キャリア初期は

積極的にフルスタックエンジニアを目指すべきです。</p>
規模が小さいアプリならフルスタックエンジニアの方が強い</h3>
基本的に、専業エンジニアの方が、

フルスタックエンジニアよりも重宝されるまたは、

レベルが高いことがほとんどですが、

スタートアップや中小のように、

そもそものアプリケーションの規模が小さい場合は別です。</strong></p>
この場合、フロント、バックエンドという風に

分業が敷かれていないことも多いので、

一人で様々な領域ができるフルスタックエンジニアは重宝されます。</p>
一つ一つのスキルが中途半端でも、

とにかく色々できるっていうのが重宝されます。</strong></p>
シンプルに人手が足りていないのと、

エンジニア採用に余力がないので、

既にいるエンジニアで回していくしかなく、

そんなとき、一人で複数分野できる人は、

重宝されるという感じですね。</p>
冷静に考えて、バックエンド専門とか、

フロントエンド専門とかのようなエンジニアがおける企業は、

エンジニア採用に余力がある大企業になると思うので、

なんだかんだで、一人で複数分野やるというケースは

多い気がします。</p>
また、個人開発とかにおいても、

両方できたほうが便利だと思います。</p>
大抵の人はいきなり専業エンジニアになれない</h3>
そして、未経験や最初のうちは、

よほど優秀だとか、CS専攻とかではない限り、

大抵これぐらいの中小やスタートアップの企業に

エンジニアとして滑り込むことがほとんどだと思います。</p>
そのため、ぶっちゃけた話、

フルスタックエンジニアになりたくなくても、

最初のうちはフルスタックエンジニアにならざるを得ないと思います。</p>
私がまさにそうでした笑</p>
基本的に未経験や駆け出しの段階で優秀な人って、

パターンが決まっています。</p>

</blockquote>

未経験といいつつ、実はインターンとかでゴリゴリ開発していた</li>
実務は未経験だけどCS系専攻で、それ系の研究をしてた</li>
実務は未経験だけど、競プロとかが好きかつ成績も出している</li>
</ul>
まあ、悲しいですけどこれが現実ですね。。。</p>
</p>
このパターンの優秀な人達は、

いきなり大企業で専業エンジニアのキャリアを進むこともあると思います。</p>
ただ、先述のようにこれはかなり例外的かつ、

優秀な人の場合です。</p>
彼らの場合、すでに自分の中で強い部分ができているんですよね。

なので、そもそもまだ自分の中に強い部分ができていない場合は、

それを醸成しなければなりません。</strong></p>
その第一段階として、

まずは色々見てみたくなりますよね。</p>
そのフェーズがフルスタックエンジニアです。</strong></p>
フルスタックエンジニアが優秀というのは、

大抵の場合幻想です。</p>
ソフトウェアの複雑さと大きさは指数関数的に

増加していきますので、そこに対してどう向き合うかという問題は、

相当専門性が高い領域です。</p>
そのため、一人の人でフルスタックに文字通り

専業レベルでカバーするのは、無理なのでは？と感じます。</p>
そのため、フルスタックエンジニアは、

実質は中途半端なエンジニアでしかないでしょう。</p>
もちろん、フルスタックエンジニアで、

すべてのレベルが高いという10年、20年レベルの

エンジニアもいるかもしれません。</p>
しかし、それもフルスタックエンジニアのキャリアではなく、

専業のキャリアを選んでいたとしたら、

その分野については、遥かに高いスキルになっていたことが想像できるかと思います。</p>
そう考えると、フルスタックエンジニアは、

やはり相対的には一つ一つのスキルレベルは低くならざるを得ない、

キャリアなのかなとも感じます。</p>
多くのフルスタックエンジニアはすごくない</h3>
以上、フルスタックエンジニアは、

総合的に領域が広いことが売りの中途半端なエンジニアです。</p>
しかし、これは悪いことではなく、

柔軟性が高いことです。</p>
それに今まで専業の人のレベルが高いという話をしましたが、

世の中、専業だけどレベルが低い人も少なくありません。</strong></p>
正直、エンジニアのレベルは企業によっても変わってきます。</p>
なので、フルスタックエンジニアだけど、

専業の人よりも相対的にできるという場面もあるかもしれません。</p>
まあそういう場面がある時点で、

そのチームのエンジニアのレベルがしれているっていうのもあるのですが、

レベルが高いエンジニアの方が圧倒的に少ないので、

そういうチームに入ることも多いでしょう。</p>
なので、中途半端といっても、

なんだかんだで差別化しやすいのも魅力の一つです。</strong></p>
なので最初のうちはフルスタックエンジニアとして、

様々な領域を吸収しつつ、自分の中で極めたい分野が見つかったら、

そっちの専業エンジニアを目指すのが一番いいと思います。</p>
つまり、フルスタックエンジニアとは、</p>
凡人がキャリア初期に通過する、

強い専業エンジニアになるための処世術であり、

ステップとも言えるかもしれません。</strong></p>


【Rubyループ処理】 配列each/map/forやスコープ
2023-05-03T00:00:00+00:00
本記事では、Rubyの配列とループ処理を扱います。</p>
Rubyには、ブロックという特徴的な文法があり、

ループ処理もそれに関連してか、

他のプログラミング言語よりもメソッドがたくさんあります。</p>
本記事ではそんなループ処理や配列について扱います。</p>
下記の動画でRubyの文法全般について、</strong>

動画一本で解説しているので、</strong>

良ければご参考ください。</strong></p>


  </iframe>
</div>
配列</h2>
まずは、配列からご紹介します。</p>
配列は、他のプログラミング言語にも大抵ある、

複数のデータを格納できるオブジェクトやデータ構造</strong>にあたります。</p>
以前紹介したTypeScriptの記事でも、

配列は出てきましたが、大まかには、

そこまで大差ないので、そちらも参考にするとわかりやすいかもしれません。

（参考記事)</a></p>
記法としてはシンプルで、

基本は他のプログラミング言語と大差ありません</p>
irb</span>(main):</span>003</span>:</span>0</span>></span> arr </span>=</span> [</span>1</span>,</span>2</span>,</span>3</span>]</span></span>
=> [</span>1</span>,</span> 2</span>,</span> 3</span>]</span></span>
irb</span>(main):</span>004</span>:</span>0</span>></span> arr[</span>1</span>]</span></span>
=></span> 2</span></span>
irb</span>(main):</span>005</span>:</span>0</span>></span> arr[</span>0</span>]</span></span>
=></span> 1</span></span></code></pre>
添字は0スタートで、

arr[0]で配列の最初の要素を取得しています。</p>
負の数を指定することもできて、

その場合、後ろから数えます。</p>
irb</span>(main):</span>006</span>:</span>0</span>></span> arr[</span>-</span>1</span>]</span></span>
=></span> 3</span></span></code></pre>
存在しない要素を指定してもエラーにはなりませんが、</strong>

存在しない要素に指定して値を代入した場合、負の数を添え字にしたときだけ、</strong>

エラーが起きます。</strong></p>
そして、正の数を添え字にして、存在しない要素に値を代入した場合、

問題なく代入できるが、指定した添え字と配列の最後の要素数に開きがある場合、</strong>

間の部分はすべてnilで埋め尽くされます。</strong></p>
irb</span>(main):</span>014</span>:</span>0</span>></span> arr</span></span>
=> [</span>2</span>,</span> 3</span>,</span> 4</span>,</span> 5</span>,</span> 10</span>]</span></span>
irb</span>(main):</span>015</span>:</span>0</span>></span> arr[</span>-</span>10</span>]</span> #存在しないのでnil</span></span>
=></span> nil</span></span>
irb</span>(main):</span>016</span>:</span>0</span>></span> arr[</span>10</span>]</span> #存在しないのでnil</span></span>
=></span> nil</span></span>
irb</span>(main):</span>017</span>:</span>0</span>></span> arr[</span>10</span>]</span> =</span> 10</span> </span></span>
=></span> 10</span></span>
irb</span>(main):</span>018</span>:</span>0</span>></span> arr </span>#arr[10]に代入した際、その間はnilで埋められる</span></span>
=> [</span>2</span>,</span> 3</span>,</span> 4</span>,</span> 5</span>,</span> 10</span>,</span> nil</span>,</span> nil</span>,</span> nil</span>,</span> nil</span>,</span> nil</span>,</span> 10</span>]</span></span>
irb</span>(main):</span>021</span>:</span>0</span>></span> arr[</span>-</span>30</span>]</span> =</span> 10</span> #添え字が正ならエラーにならないが負ならエラー</span></span>
Traceback (most recent call last):</span></span>
        4</span>: from </span>/</span>Users</span>/</span>reisuta</span>/</span>.</span>rbenv</span>/</span>versions</span>/</span>2.7</span>.</span>7</span>/</span>bin</span>/</span>irb:23:in</span> `<main>'</span></span>
        3: from /Users/reisuta/.rbenv/versions/2.7.7/bin/irb:23:in `</span>load</span>'</span></span>
        2: from /Users/reisuta/.rbenv/versions/2.7.7/lib/ruby/gems/2.7.0/gems/irb-1.2.6/exe/irb:11:in `<top (required)>'</span></span>
        1</span>: from (irb):</span>21</span></span>
IndexError (index </span>-</span>30</span> too small </span>for</span> array;</span> minimum:</span> -</span>11</span>)</span></span></code></pre>
他のプログラミング言語とかだと、

存在しない要素を添え字にしたら、

エラーになったり、代入したりできなかったりするので、

このあたりは、例外をあまり出さない自由なRubyらしさを感じますね。</p>
Rubyの場合、他のプログラミング言語とかで

例外をはきそうなことをしても、

問題なかったりするので、どういうときにエラーが起きるのかを、

把握しておく必要があるというのが、

自由なRubyの難しさだなと感じます。</p>
<<で要素を追加する</h3>
配列に要素を追加したいときは、<<を使います。</strong></p>
他のプログラミング言語ではあまり見られないRubyっぽい記法として

<<で配列の最後に要素を追加するんですね。</p>
irb</span>(main):</span>006</span>:</span>0</span>></span> arr </span><<</span> 19</span></span>
=> [</span>1</span>,</span> 2</span>,</span> 3</span>,</span> 19</span>]</span></span>
irb</span>(main):</span>007</span>:</span>0</span>></span> arr</span></span>
=> [</span>1</span>,</span> 2</span>,</span> 3</span>,</span> 19</span>]</span></span></code></pre>
ちなみに、pushメソッドや上記で紹介した直接添え字を指定しても、

要素の追加は可能です。</p>
irb</span>(main):</span>024</span>:</span>0</span>></span> arr </span>=</span> [</span>1</span>,</span>2</span>,</span>3</span>]</span></span>
=> [</span>1</span>,</span> 2</span>,</span> 3</span>]</span></span>
irb</span>(main):</span>025</span>:</span>0</span>></span> arr.</span>push</span>(</span>4</span>)</span></span>
=> [</span>1</span>,</span> 2</span>,</span> 3</span>,</span> 4</span>]</span></span>
irb</span>(main):</span>026</span>:</span>0</span>></span> arr[</span>5</span>]</span> =</span> 5</span></span>
=></span> 5</span></span>
irb</span>(main):</span>027</span>:</span>0</span>></span> arr</span></span>
=> [</span>1</span>,</span> 2</span>,</span> 3</span>,</span> 4</span>,</span> nil</span>,</span> 5</span>]</span></span></code></pre>
ちなみに要素の変更も追加と同じように

値を代入してできます。</p>
Rubyの特徴として、

同じことをする方法が複数存在するというのがあります。</p>
たとえば、上記だと << とpushメソッドなどですね。

これ以外にも、Rubyにはaliasメソッドというものもあるので、

どれを使えば、迷いがちなのが、

他のプログラミング言語ではあまり起きない特徴なような気がしています。</p>
全く同じ効果のメソッドであれば、

どちらを使ってもいいのですが、

微妙に効果が違うメソッドの場合は、

条件によって使い分ける必要があるのが、

Rubyですね。</p>
添え字に範囲を指定する</h3>
Rubyの便利なところとして、

範囲指定というものがあります。</p>
まあ、他のプログラミング言語にもありますが、

Rubyは結構直感的に範囲指定できる印象があります。</p>
通常、arr[1]みたいな感じで、

要素を取得すると思いますが、

Rubyは、配列の範囲を指定して取得することがしやすいです。</p>
irb</span>(main):</span>010</span>:</span>0</span>></span> arr </span>=</span> [</span>2</span>,</span>3</span>,</span>4</span>,</span>5</span>,</span>10</span>]</span></span>
=> [</span>2</span>,</span> 3</span>,</span> 4</span>,</span> 5</span>,</span> 10</span>]</span></span>
irb</span>(main):</span>011</span>:</span>0</span>></span> arr</span></span>
=> [</span>2</span>,</span> 3</span>,</span> 4</span>,</span> 5</span>,</span> 10</span>]</span></span>
irb</span>(main):</span>012</span>:</span>0</span>></span> arr[</span>1</span>..</span>3</span>]</span></span>
=> [</span>3</span>,</span> 4</span>,</span> 5</span>]</span></span></code></pre>
arr[1..3]みたいにすると、

1から3の要素を取得してくれるので、

配列の順番でいうと、2番目から4番目の要素を取得できます。</p>
ちなみに、1..3自体は、

範囲オブジェクトというもので、</mark>

配列特有の記法ではなく、</mark>

オブジェクト</mark>です。</p>
これがRubyの面白いところですね。</p>
気軽に範囲をオブジェクトにして、

渡すことができるのは、

Ruby以外の言語ではそこまでし易いわけでは無い気がするので、

これはRubyの良いところだと思います。</p>
https://docs.ruby-lang.org/ja/latest/class/Range.html</a></p>
ループ処理</h2>
さて、次はループ処理について、

解説します。</p>
Rubyにはループ処理をするための、

記法が実にたくさんあります。</p>
その中でもブロックeachなどは、</mark>

一番良く使います。</mark></p>
ブロックについては、奥が深いかつ、

Rubyの根幹にかかわる、

大事な文法概念なので、

下記の記事でRubyのブロックについて、

詳細解説しています。</p>
本記事でもブロックについて、

軽く触れはしますが、

詳細は下記の記事に譲ります。</p>
[st-card myclass="st-no-shadow" id="979" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
また、ブロック以外にも、

ループ関連は色々あるのでとりあげます。</p>
ブロック</h3>
ブロックは、初めてRubyを学習したときに、

一番良くわからない概念の一つだと思います。</p>
そして、Rubyでは必ず使う重要なものでもあるので、

Rubyの習熟度はブロックへの理解度といっても過言ではないぐらい、

Rubyを使うなら重要です。</p>
ブロックは奥が深いので、

本記事では本当にかいつまんで簡単な解説にとどめます。

( 詳細記事はこちら</a> )</p>
とりあえず、ブロックは一旦

do~endとか{}とかの塊</strong>と思っていただいて大丈夫です。</p>
本記事は、Ruby基礎編なので、

ブロックは、上記のものと一旦思っておいてください。</p>
説明するより、コードを見たほうがはやいと思うので、

コードを載せます。</p>
[</span>1</span>,</span>2</span>,</span>3</span>].</span>each</span> do</span> |f|</span></span>
  puts</span> f</span></span>
end</span></span></code></pre>
こんな感じです。</p>
{}で短く書くこともできます。</p>
[</span>1</span>,</span>2</span>,</span>3</span>].</span>each</span> { |f|</span> puts</span> f }</span></span></code></pre>
上記を見ると、確かにdo~endの塊があり、

中にputs fがありますね。</p>
2つ目の省略記法だと、

{}の中に、同じくputs fがありますね。</p>
平たく言えば、

ブロックとはこの部分のことです。</p>
ブロックは多くの場合、

eachメソッドと一緒に使われることが多いです。</p>
以下詳細に解説します。</p>
each</h3>
ブロックと一緒に使われることが多いものとして、

このeachメソッドがあります。</p>
Array#each (Ruby 3.2 リファレンスマニュアル) (ruby-lang.org)</a></p>

各要素に対してブロックを評価します。</p>
ブロックが与えられなかった場合は、自身と each から生成した Enumerator オブジェクトを返します。</p>
Ruby 3.2 リファレンスマニュアル</p>
</blockquote>
上記のコードの場合、

各要素とは、[1,2,3]で

ブロックは、do |f| puts f endの部分を指します。</p>
すなわち、eachとは、

要素を取り出してブロックにわたすメソッドです。</p>
これが事実上、他の言語でいう、

for文のような機能に相当しているという感じです。</p>
下記の記事で、

Rubyの特徴として

「すべてがオブジェクトである」ということを

紹介しました。</p>
[st-card myclass="st-no-shadow" id="692" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
このeachとブロックの機能も、

ある意味この特徴と接点があるように思えます。</p>
他の言語でいう、for文とかは、

オブジェクトに対して呼び出すのではなく、

関数のような感じで、引数にオブジェクトに相当するものなどを

持っていくという構文ですが、

Rubyの場合、すべてがオブジェクトなので、

このオブジェクトからメソッドを呼び出すというかたち</strong>で、

eachとブロックを使った構文のほうが、この思想に近い書き方にあたるでしょう。</p>
もちろん、これは単なる私の感想なので、

こういう理由でブロックやeachが尊ばれているわけでもないとは思いますが、

他のプログラミング言語ではあまり登場しないブロックやeachのような記法も、

「すべてがオブジェクトである」起点から考えたら、結構素直な記法に

見えてこないでしょうか？</p>
map</h3>
each以外にもブロックと

一緒に使われることが多いメソッドとして

mapもあります。</p>
mapは、各要素にブロックを適用し、

新しい配列を作成するメソッドです。</p>
Enumerable#collect (Ruby 3.2 リファレンスマニュアル) (ruby-lang.org)</a></p>
[</span>1</span>,</span>2</span>,</span>3</span>].</span>map</span> { |f|</span> puts</span> f </span>*</span> 10</span> }</span></span>
p</span> [</span>1</span>,</span>2</span>,</span>3</span>].</span>map</span> { |f| f </span>*</span> 10</span> }</span></span></code></pre>
これの実行結果は、

10, 20, 30と10倍したものが出力されます。</p>
これもよく使うので、

ぜひとも使いこなせるようになりたいですね。</p>
&:メソッド</h4>
上記のmapメソッドのように

ブロックを使うものの場合、

簡潔に書く記法があります。</p>
p</span> [</span>1</span>,</span>2</span>,</span>3</span>].</span>map</span>(</span>&</span>:odd?</span>)</span> # [true, false, true]と出力される</span></span>
# p [1,2,3].map { |f| f.odd? }の省略形</span></span></code></pre>
ブロックパラメーター（|f|）が一つだけで、

メソッド(odd?）に引数がなくて、

ブロック内でブロックパラメーター（|f|）に対してメソッド(odd?)を1回呼び出す以外の処理がないとき、

&:メソッド名</strong>という省略形を使用できます。</p>
これは、最初にRubyを勉強しているときに遭遇すると

「なんじゃこりゃ？」ってなる記法の定番ですね。</p>
Rubyには、省略記法がたくさんあるので、

これのように省略が原型をとどめていなかったりするものもあるので、

混乱しないよう気をつけたいですね。</p>
for</h3>
ブロック周りのループ処理に触れたので、

お次は、forに移りたいと思います。</p>
他のプログラミング言語ではめちゃくちゃよく使う、

あのforです。</p>
しかし、カルチャーショック。

Rubyではまず使わないです。</strong></p>
記法としては、</p>
for</span> i </span>in</span> (</span>1</span>..</span>10</span>)</span></span>
  puts</span> i</span></span>
end</span></span></code></pre>$ ruby index.rb</span></span>
1</span></span>
2</span></span>
3</span></span>
4</span></span>
5</span></span>
6</span></span>
7</span></span>
8</span></span>
9</span></span>
10</span></span></code></pre>
こんな感じですね。</p>
Pythonそっくりの記法ですね。

簡潔でわかりやすくて美しいなと

個人的には感じます。</p>
ただ、先述のように、

Rubyにおいて、forはほとんど使われません。</p>
Rubyにおいて、なぜforが使われないのか、

詳しい理由はわかりませんが、

Rubyではeachやブロックを使った繰り返し処理がデファクトで、

forを使うシーンがほぼありませんし使う必要性もあまりありません。</p>
あと、Rubyでforを使うと、

「こいつeachとかブロック知らないんか？」みたいな顔されるので、

よほどの理由がない限りforを使うのは避けた方が無難だと思います。</p>
なんというか慣習なんですかね。</p>
PythonからRubyに来た人は、

forの文法がめちゃくちゃ似ているので、

forを使いたくなると思いますけど、

ぐっとこらえてeachとブロック覚えましょう。</p>
すべてがオブジェクトの思想のRubyにとっては、

forは、一ミリもその思想を表現していないので、

Rubyらしい記法という点では、

ブロックとeachになってくるというのは、

確かにという感じですね。</p>
while</h3>
お次は、whileです。</p>
これは、他のプログラミング言語にもある、

お決まりのwhileでして、

Rubyも比較的似たような感じです。</p>
a</span> =</span> 5</span></span>
while</span> a </span><</span> 10</span></span>
  puts</span> '10以下です'</span></span>
  a</span> +=</span> 1</span></span>
end</span></span></code></pre>ruby index.rb</span></span>
10以下です</span></span>
10以下です</span></span>
10以下です</span></span>
10以下です</span></span>
10以下です</span></span></code></pre>
whileはforよりは、

使うシーンはあるような気がしますが、

それでもあまり使っているところを見たことがありません。</p>
Rubyは、eachとブロックで、

ループ処理は、大抵こなせてしまうんですよね。</p>
until</h3>
until文は、ちょっと珍しいかもしれません。</p>
until文は、whileの逆で、

条件が偽である限り繰り返す処理です。</p>
こういった構文がない言語もあると思うので、

やや珍しいかもしれないですね。</p>
Rubyの場合、ifの逆のような

unlessのような構文があったりと、

逆の文法があったりするので、

どちらを使うか迷いがちですが、

基本は条件が真のときに実行する、

ifとかwhileを優先して使うでいいと思います</strong>。

(whileに関しては、eachとブロックの方を優先して使うべきだと思いますが）</p>
untilとかが乱立していると、

混乱しがちな気がります。</p>
a</span> =</span> 1</span></span>
until</span> a </span>></span> 10</span></span>
  puts</span> '10以下です'</span></span>
  a</span> +=</span> 1</span></span>
end</span></span></code></pre>
Rubyでは、ブロックやeachが主流なのと、

untilよりもwhileのほうがいいのと、

という二重の理由で、

untilを使うのはよほどのことが無い限りほとんど無い気がします。</p>
それにuntilは、unlessよりも、

脳内の切り替えリソースを消費する気がするので、

読みやすいコードとしては微妙な気がします。</p>
times</h3>
最後にtimesです。</p>
これは、意外と使う時あります</p>
timesは、指定回数処理を繰り返したいときとかに使いやすいです。

記法としては、</p>
10</span>.</span>times</span> do</span> |f|</span></span>
  puts</span> f</span></span>
end</span></span></code></pre>$ ruby index.rb</span></span>
0</span></span>
1</span></span>
2</span></span>
3</span></span>
4</span></span>
5</span></span>
6</span></span>
7</span></span>
8</span></span>
9</span></span></code></pre>
のような感じですね。</p>
Railsのタスクとかで、

timesを使うと楽な場面があったりするので、

for/while/untilとかよりは、確実に

使用頻度が高いと思います。</p>
timesは、範囲オブジェクトとか</mark>

数値オブジェクトに対して呼び出すので、</mark>

本質的にはeachと変わらないので、</mark>

「すべてがオブジェクト」の思想には</mark>

適っています。</mark></p>
それでも、使用頻度としては

eachやmapのほうが多いですが。</p>
timesは、たまに使う場面があったりしますが、

あまりスマートな書き方とはみなされなかったりするので、

乱発は控えておいた方が無難です。</p>
スコープ</h2>
ブロックや変数とかを学ぶと、

必ずつきまとう概念にスコープというものがあります。</p>
これは、ブロックやfor文の中などで定義した変数が、</mark>

その外でも有効なのかといった、</mark>

変数の有効範囲のことをいいます。</mark></p>
スコープは、プログラミング言語によって微妙に異なるので、

ある意味スコープの違いを知ることがプログラミング言語の学習みたいな

側面もあったりするぐらい、スコープを知っておくことは重要です。</p>
まず、ブロックの場合、</p>
[</span>1</span>,</span>2</span>,</span>3</span>].</span>each</span> do</span> |f|</span></span>
  value</span> =</span> 'hello'</span></span>
  puts</span> f</span></span>
  puts</span> value</span></span>
end</span></span>
puts</span> value</span></span></code></pre>$ ruby index.rb</span></span>
1</span></span>
hello</span></span>
2</span></span>
hello</span></span>
3</span></span>
hello</span></span>
Traceback (most recent call last):</span></span>
index.rb:6:in `<main>': undefined local variable or method `value' for main:Object (NameError)</span></span></code></pre>
ブロックの場合、

ブロック内で定義した変数は、

ブロックの外では参照できません。</strong></p>
これに対して、for文とかの場合、</p>
for</span> i </span>in</span> (</span>1</span>..</span>3</span>)</span></span>
  value</span> =</span> 'hello'</span></span>
  puts</span> value</span></span>
  puts</span> i</span></span>
end</span></span>
puts</span> 'この下はforの外'</span></span>
puts</span> value</span></span></code></pre>$ ruby index.rb</span></span>
hello</span></span>
1</span></span>
hello</span></span>
2</span></span>
hello</span></span>
3</span></span>
この下はforの外</span></span>
hello</span></span></code></pre>
なんと、forの場合は、

forの中で定義した変数valueが、

外でも参照できてしまいました。</strong></p>
スコープが外にまで広がっていますね。

この特徴は、あまり見かけないので、

かなり直感に反すると思います。</p>
一般的にスコープは、内側から外を参照することはできますが、

外から内側を参照できるケース(Rubyのfor)はほとんど無い気がします。</p>
こうなると、内と外で変数が衝突したりと、

意図しない不具合につながるかもしれません。</p>
forを使うことがあまりないのも、

もしかするとこの挙動が関係しているかもしれないですね。</p>
結論、forを使うことはあまりないと思うので、

そこまで重要ではないかもしれませんが、

eachとforには、一応こうした違いがあるということを

念頭に入れておくといいかもしれません。</p>


【Ruby】ハッシュとシンボルについて 省略記法やシンボルと文字列の違い
2023-05-03T00:00:00+00:00
本記事では、Rubyの文法の中でも特徴的な、

ハッシュとシンボルについて紹介します。</p>
特にシンボルについては、他のプログラミング言語では、

あまり見かけないデータ構造かと思います。</p>
こうしたハッシュとシンボルについての解説と、文字列との違い、

省略記法についても言及します。</p>
本記事の動画は下記になります。</p>


  </iframe>
</div>
ハッシュ</h2>
ハッシュというと、

なんぞやって感じる人が多いと思いますが、

これは要するに、他のプログラミング言語で言う、

辞書とか連想配列みたいなもんで、

{'taro' => 100, 'hanako' => 200}みたいなデータ構造です。</p>
irb</span>(main):</span>001</span>:</span>0</span>></span> money </span>=</span> {</span>'taro'</span> =></span> 100</span>,</span> 'hanako'</span> =></span> 200</span>}</span></span>
=> {</span>"taro"</span>=></span>100</span>,</span> "hanako"</span>=></span>200</span>}</span></span>
irb</span>(main):</span>002</span>:</span>0</span>></span> money</span></span>
=> {</span>"taro"</span>=></span>100</span>,</span> "hanako"</span>=></span>200</span>}</span></span></code></pre>
ハッシュもブロックも、

同じ{}で定義するので紛らわしいですね。</p>
要素の取得/追加/変更</h3>
要素の追加などは、

配列のときと似ており、</p>
irb</span>(main):</span>004</span>:</span>0</span>></span> money[</span>'takumi'</span>]</span> =</span> 400</span> #これで追加</span></span>
=></span> 400</span></span>
irb</span>(main):</span>005</span>:</span>0</span>></span> money</span></span>
=> {</span>"taro"</span>=></span>100</span>,</span> "hanako"</span>=></span>200</span>,</span> "takumi"</span>=></span>400</span>}</span></span>
irb</span>(main):</span>006</span>:</span>0</span>></span> money[</span>'taro'</span>]</span> #取得したいキーを指定する</span></span>
=></span> 100</span></span>
irb</span>(main):</span>007</span>:</span>0</span>></span> money[</span>'kyoko'</span>]</span> #存在しないキーならnilを返す</span></span>
=></span> nil</span></span></code></pre>
といった感じです。</p>
Rubyの配列についての解説は、

こちらの記事</a>をご参考ください。</p>
[st-card myclass="st-no-shadow" id="724" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
キーにシンボルを使う</h3>
キーに文字列ではなく、

シンボル(シンボルについては後述)

を使うことのほうがおそらく多いので、

それについても紹介します。</p>
irb</span>(main):</span>026</span>:</span>0</span>></span> money </span>=</span> {</span> :taro</span> =></span> 100</span>,</span> :hanako</span> =></span> 200</span> }</span></span>
=> {</span>:taro</span>=></span>100</span>,</span> :hanako</span>=></span>200</span>}</span></span>
irb</span>(main):</span>027</span>:</span>0</span>></span> money[</span>:taro</span>]</span></span>
=></span> 100</span></span></code></pre>
キーがシンボルの場合は、

省略形もあります。</p>
irb</span>(main):</span>028</span>:</span>0</span>></span> money </span>=</span> {</span> taro: 100</span>,</span> hanako: 200</span> }</span></span>
=> {</span>:taro</span>=></span>100</span>,</span> :hanako</span>=></span>200</span>}</span></span>
irb</span>(main):</span>029</span>:</span>0</span>></span> money</span></span>
=> {</span>:taro</span>=></span>100</span>,</span> :hanako</span>=></span>200</span>}</span></span>
irb</span>(main):</span>030</span>:</span>0</span>></span></span></code></pre>
=> を使わないで、

シンボル: 値という省略した記法が使えます。</p>
そして、おそらくこの省略された記法が

一番良く使われているかと思います。</strong></mark></p>
メソッド呼び出し時の省略</h3>
メソッドの引数の最後がハッシュの場合、

{}を省略できます。</p>
# Railsで見かける例のやつ</span></span>
stylesheet_link_tag </span>'application'</span>, {</span> media:</span> 'all'</span>,</span></span>
                                     'data-turbolinks-track'</span>:</span> 'reload'</span> }</span></span>
# 上は以下のように書いても同じ</span></span>
stylesheet_link_tag </span>'application'</span>,</span> media:</span> 'all'</span>,</span></span>
                                   'data-turbolinks-track'</span>:</span> 'reload'</span></span></code></pre>def</span> print_hello</span>(</span>greet</span>,</span> options</span>)</span></span>
  puts</span> options</span></span>
  puts</span> greet</span></span>
end</span></span>
</span>
print_hello</span>(</span>'hello'</span>, {</span> taro: 100</span>,</span> hanako: 200</span>})</span></span>
print_hello </span>'hello'</span>, {</span> taro: 100</span>,</span> hanako: 200</span>}</span> #メソッド呼び出しの()は省略できる</span></span>
print_hello </span>'hello'</span>,</span> taro: 100</span>,</span> hanako: 200</span> #ハッシュが最後の引数なので{}は省略できる</span></span></code></pre>
Rubyは何をするにも

省略記法があるので、

Dryすぎて、逆に混乱してしまうのが悩みです。</p>
シンボル</h2>
さて、ハッシュの次は、

シンボルについて触れていきます。</p>
シンボルは、結構Ruby独特のものかなと感じており、

他のプログラミング言語ではあまり見たことがないかもしれません。</p>
class Symbol (Ruby 3.2 リファレンスマニュアル) (ruby-lang.org)</a></p>
平たく言えば、文字列と似ているものですが、

文字列とも異なるといった感じです。

:hogeのように表します。</strong></mark></p>
irb</span>(main):</span>009</span>:</span>0</span>></span> :hoge</span></span>
=></span> :hoge</span></span>
irb</span>(main):</span>010</span>:</span>0</span>></span> :hoge</span>.</span>class</span></span>
=> Symbol</span></span>
irb</span>(main):</span>011</span>:</span>0</span>></span> 'hoge'</span>.</span>class</span></span>
=> String</span></span></code></pre>シンボルと文字列の違い</h3>
そもそもシンボルは、文字列っぽいですが、

内部では整数として扱われているようです。</p>

シンボルは、ソース上では文字列のように見え、内部では整数として扱われる、両者を仲立ちするような存在です。</p>
名前を管理するという役割上、シンボルと文字列は一対一に対応します。また、文字列と違い、immutable (変更不可)であり、同値ならば必ず同一です。</p>
Ruby 3.2 リファレンスマニュアル</p>
</blockquote>
そのため、文字列よりも高速に比較ができるようです。</strong></mark></p>
 </mark></p>
加えて、シンボルは同じものなら、

同じオブジェクトという特徴があります。</strong></mark></p>
irb</span>(main):</span>012</span>:</span>0</span>></span> :hoge</span>.</span>object_id</span></span>
=></span> 2039708</span></span>
irb</span>(main):</span>013</span>:</span>0</span>></span> :hoge</span>.</span>object_id</span></span>
=></span> 2039708</span></span>
irb</span>(main):</span>014</span>:</span>0</span>></span> :hoge</span>.</span>object_id</span></span>
=></span> 2039708</span></span>
irb</span>(main):</span>015</span>:</span>0</span>></span> 'hoge'</span>.</span>object_id</span></span>
=></span> 180</span></span>
irb</span>(main):</span>016</span>:</span>0</span>></span> 'hoge'</span>.</span>object_id</span></span>
=></span> 200</span></span>
irb</span>(main):</span>017</span>:</span>0</span>></span> 'hoge'</span>.</span>object_id</span></span>
=></span> 220</span></span></code></pre>
あとは、上記のリファレンスマニュアルにもあったように、

immutable(変更不可)なので、破壊的メソッドなどで書き換えられてしまうという

懸念がないのがメリットかもしれません。</p>
irb</span>(main):</span>018</span>:</span>0</span>></span> a </span>=</span> 'hoge'</span></span>
=></span> "hoge"</span></span>
irb</span>(main):</span>019</span>:</span>0</span>></span> b </span>=</span> :hoge</span></span>
=></span> :hoge</span></span>
irb</span>(main):</span>020</span>:</span>0</span>></span> a.</span>upcase!</span></span>
=></span> "HOGE"</span></span>
irb</span>(main):</span>021</span>:</span>0</span>></span> a </span>#破壊的メソッドによって書き換わっている</span></span>
=></span> "HOGE"</span></span>
irb</span>(main):</span>022</span>:</span>0</span>></span> b.</span>upcase!</span> #破壊的メソッドは呼び出せない</span></span>
Traceback (most recent call last):</span></span>
        4</span>: from </span>/</span>Users</span>/</span>reisuta</span>/</span>.</span>rbenv</span>/</span>versions</span>/</span>2.7</span>.</span>7</span>/</span>bin</span>/</span>irb:23:in</span> `<main>'</span></span>
        3: from /Users/reisuta/.rbenv/versions/2.7.7/bin/irb:23:in `</span>load</span>'</span></span>
        2: from /Users/reisuta/.rbenv/versions/2.7.7/lib/ruby/gems/2.7.0/gems/irb-1.2.6/exe/irb:11:in `<top (required)>'</span></span>
        1</span>: from (irb):</span>22</span></span>
NoMethodError (undefined method </span>`upcase!' for :hoge:Symbol)</span></span>
Did you mean?  upcase</span></span></code></pre>
もちろん、ケースバイケースではあるのですが、

個人的には文字列とシンボルで迷ったら、

可能な限りシンボルを使ったおくのが好ましいのかなと感じます。</p>
シンボルは、シンプルなようで、

意外と奥が深いので使いこなすのは、

案外難しい印象です。</p>
少しづつ慣れて、使いこなせるようになりたいですね。</p>


【Ruby条件分岐if/unless/case】三項演算子やメソッド定義
2023-05-02T00:00:00+00:00
本記事では、Rubyにおける、

条件分岐の文法とメソッドについて解説します。</p>
Rubyの条件分岐やメソッド定義は、

unless文や破壊的メソッドなど、

特徴的な部分も多い印象です。</p>
そこで、本記事ではこれらについても

詳しく触れていきます。</p>
文字ではなく、動画で視聴したいという方は、

下記の動画を御覧ください。</p>


  </iframe>
</div>
条件分岐</h2>
まずは、条件分岐について、

紹介します。</p>
Rubyの場合、unless文などもあるので、

if文から順番に紹介していきます。</p>
if文</h3>
まずは、if文です。

if文とは、毎度おなじみ、条件式がTrueのときに実行する、

いつものやつですよね。</p>
Rubyのif文は、下記のように書きます。</p>
print</span> "数値を入力してください: "</span></span>
num</span> =</span> gets</span>.</span>to_i</span></span>
</span>
if</span> num </span>></span> 0</span></span>
  puts</span> "</span>#{</span>num</span>}</span>は正の数です。"</span></span>
elsif</span> num </span>></span> 100</span></span>
  puts</span> "</span>#{</span>num</span>}</span>は100以上です"</span></span>
else</span></span>
  puts</span> "</span>#{</span>num</span>}</span> は正の数ではありません。"</span></span>
end</span></span></code></pre>
</p>
JavaScriptとかだと、条件式を( )で囲んでいたかと思いますが、

Rubyでは、そんなものは必要ないので、

記述がスッキリしていますね。</p>
記法としては、Pythonが似ているかもしれません。</p>
そして、特徴的なのはやはりelsifの部分でしょうか。</strong>

あまり見かけない記法なので最初は戸惑うかもしれません。</strong>

(else ifとかelifとかは見かけますが)</p>
これは、他の言語でいう、

else ifを指しています。

最初のif文の条件式がfalseで、

else ifの条件式がtrueのときに実行したい処理を

ここに書きます。</p>
elseとかは、他のプログラミング言語と同様ですね。</p>
Rubyの場合かならずendが必要なので、</mark>

忘れずに記述する必要があります。</mark></p>
これもありそうで意外と無い気がしますね。</p>
PythonからRubyに入ると、

記法が似ている文、このendを忘れがちです</p>
ちなみに、elsifやelseは不要なら省略することができます。

このあたりは、特段他のプログラミング言語と変わりありませんね。</p>
後置if</h4>
さて、そんなif文ですが、

Rubyで比較的よくつかう記法に、

後置ifというものがあります。</p>
次のようなコードです。</p>
print</span> "数値を入力してください: "</span></span>
num</span> =</span> gets</span>.</span>to_i</span></span>
puts</span> "</span>#{</span>num</span>}</span>は正の数です。"</span> if</span> num </span>></span> 0</span></span></code></pre>
単にif文を後ろにおいただけなので、

わかりやすいと思います。</p>
簡潔に書くのが好まれるRubyではよく使われる記法です。</p>
ただ、elsifとかelseを交えることはできないので、

複雑な条件分岐には使えません。</p>
unless</h3>
お次はunlessです。</p>
Rubyの場合、

if文だけでなく、unless文というものもあります。</p>
これはif文の真逆の機能でして、</strong>

条件が偽のときに実行されるものになります。</strong></p>
print</span> "数値を入力してください: "</span></span>
num</span> =</span> gets</span>.</span>to_i</span></span>
puts</span> "</span>#{</span>num</span>}</span>は負の数です。"</span> unless</span> num </span>>=</span> 0</span></span></code></pre>
これはすなわち、先程とは異なり、

入力値が負の数の場合に、一番下のputsの命令が実行されます。</p>
入力値が負の場合、num >= 0の条件式が、

falseになるので、unless文が実行されるといった感じです。</p>
unless文でも、elseを使うことができます。

この辺は、if文と同様ですね。</p>
print</span> "数値を入力してください: "</span></span>
num</span> =</span> gets.to_i</span></span>
unless num</span> ></span> 0</span></span>
  puts</span> "#{num}は負の数です。"</span></span>
else</span></span>
  puts</span> "#{num}は正の数です。"</span></span>
end</span></span></code></pre>
この場合、num > 0の条件式がtrueの処理が、

elseに渡されます。</p>
unlessを使う場面としては、

value != 'valid' のように否定演算子を使った条件を、

すっきり見せるために使われたりします。</p>
ただ、unlessやifが乱立したり、</mark>

unlessを多用すると、かえってわかりづらくなるので、</mark>

if文で書いてしまうと、かなり冗長になってしまうという場合を</mark>

のぞいて、基本unless文は使わなくてもいいかなと個人的には感じます。</mark></p>
「条件が偽のときに実行」って地味に、

頭の中の切り替えリソースが消費されますもんね。</p>
case/when</h3>
お次は、caseとwhenです。</p>
これは、JavaScriptで言う、switch構文のようなものとして、

Rubyではcase文がそれに該当します。</p>
これは、複数の値と比較する場合に、

用いられることが多いです。</p>
使い方としては、</p>
print</span> "数値を入力してください: "</span></span>
num</span> =</span> gets</span>.</span>to_i</span></span>
case</span> num</span></span>
when</span> 10</span></span>
  puts</span> "10です。"</span></span>
when</span> 0</span></span>
  puts</span> "0です。"</span></span>
when -</span>10</span></span>
  puts</span> "-10です。"</span></span>
else</span></span>
  puts</span> "10, 0, -10以外の数です"</span></span>
end</span></span></code></pre>
という風に、

caseで対象のオブジェクトなどを指定し、

whenで値を指定して、その値だったときの処理を記述していく感じです。</p>
if文で書くと、

elsifが乱立して見通しが悪くなりがちなときとかには、

case文を用いると便利なことが多いです。</p>
三項演算子</h3>
三項演算子は、Rubyでよく使われる印象があります。

構文としては、</p>
print</span> "数値を入力してください: "</span></span>
num</span> =</span> gets</span>.</span>to_i</span></span>
value</span> =</span> num </span>></span> 0</span> ?</span> 'nは0より大きい'</span> :</span> '0以下'</span></span>
puts</span> value</span></span></code></pre>
条件式 ? 真だった場合 : 偽だった場合

という風になります。</p>
上記の場合、num > 0という条件式がtrueなら、

value変数には、'nは0より大きい'が代入されるという流れです。</p>
Rubyは簡潔に書くことが多いので、

簡単な条件分岐の場合、三項演算子とかで、

一行で済ませてしまうことも多いので、

覚えておくと役立つと思います。</p>
ちなみに、三項演算子自体は、

他のプログラミング言語にもありますし、

Vue.jsとかのマスタッシュ構文とかでは、

めちゃくちゃ三項演算子が使われている印象があります。

(Vue.jsのマスタッシュ構文については、こちらの記事</a>で言及しています。)</p>
なので、三項演算子は、

Rubyでもガンガン使っている印象がありますが、

特段Rubyの特徴というわけでもないかなと思います。</p>
メソッド定義</h2>
条件分岐の文法について、

紹介したので、次はメソッド周りに移ります。</p>
これは個人的な体感ベースでしか有りませんが、

Ruby界隈では、あまり関数という呼び方をしていない印象がありまして、

大抵メソッドと呼んでいるかと思います。</p>
なので、メソッドは、関数のことを指しています。

(関数って何って言う人は、こちらの記事</a>で関数自体について解説しています)</p>
Rubyでのメソッドの定義は、

次のようにします。</p>
def</span> add_numbers</span>(</span>num1</span>,</span> num2</span>)</span></span>
  sum</span> =</span> num1 </span>+</span> num2</span></span>
end</span></span>
</span>
result</span> =</span> add_numbers</span>(</span>5</span>,</span> 7</span>)</span></span>
puts</span> "結果は </span>#{</span>result</span>}</span> です。"</span></span></code></pre>
Pythonと非常に似ていますね。

JavaScriptとかでいうfunctionの記法ではないということですね。</p>
def メソッド名

end</strong></p>
という形式で定義します。

ちなみに、引数がなければ、

()を省略して書くことが多いです。</p>
メソッド名も、変数名と同じ命名ルールで、

通常小文字のスネークケースです。</strong></p>
そして特徴的なのが、Rubyの場合、最後に評価された式が、

戻り値となるのでわざわざreturn文を書きません。</strong></mark></p>
他のプログラミング言語出身の人だと、

ついついreturnを書いてしまいますが、

返り値を返すという目的ではあまりreturnは使わず、

処理を途中で抜けたいときにreturnが使われることの方が多いです。</p>
破壊的メソッドと非破壊的メソッド</h3>
Rubyのメソッドには、

例えば、nil?のように?がつくメソッドや、

upcase!というように!がつくメソッドなどがあります。</p>
基本的に、?がつくメソッドは、

真偽値を返すメソッドにあたります。</strong></p>
Rubyのメソッドで?がついているのを見かけたら、

真偽値を判定しているものと思っていただいて大丈夫です。</p>
これに対して、!がつくメソッドは、

より破壊的なものにあたります。</strong>(破壊的メソッド)</p>
class String (Ruby 3.2 リファレンスマニュアル) (ruby-lang.org)</a></p>
破壊的とは何かというと、

オブジェクトの内容自体を変えてしまうことを言います。</strong></p>
irb</span>(main):</span>001</span>:</span>0</span>></span> a </span>=</span> 'hello'</span></span>
=></span> "hello"</span></span>
irb</span>(main):</span>002</span>:</span>0</span>></span> a.</span>upcase</span></span>
=></span> "HELLO"</span></span>
irb</span>(main):</span>003</span>:</span>0</span>></span> a</span></span>
=></span> "hello"</span></span>
irb</span>(main):</span>004</span>:</span>0</span>></span> a.</span>upcase!</span></span>
=></span> "HELLO"</span></span>
irb</span>(main):</span>005</span>:</span>0</span>></span> a</span></span>
=></span> "HELLO"</span></span></code></pre>
upcaseが非破壊的なのに対し、

upcaseが破壊的メソッドです。</p>
両者の違いとしては、呼び出したときに、

破壊的メソッドのupcase!は、オブジェクトの内容自体を変えてしまうので、

変数aの内容自体が大文字に変わってしまい、

単にaと入力した際、中身が大文字になっています。</p>
ややこしいのが、!がつくのが破壊的メソッドとは限らない</strong>ということです。</p>
例えば、concatメソッドなどは、

!が付きませんが、破壊的メソッドです。</p>
!が付いているメソッドと付いていないメソッドの両方がある際は、

!のほうが破壊的というだけです。</strong></p>
基本的には非破壊的メソッドのほうを使うことがいいとされていますが、

破壊的メソッドを使う場面もそれなりにあるので、

挙動を理解して使えるようになるのがいいと思います。</p>


【Rubyすべてがオブジェクト】変数と真偽値/論理演算子/コメント
2023-04-27T00:00:00+00:00
本記事は、Rubyの基礎文法である、

変数や真偽値、論理演算子に触れると同時に、</mark>

「すべてがオブジェクト」というRubyの特徴的な思想</mark>についても

解説します。</p>
この思想は、Rubyの文法の根幹になっているのと、

Rubyの面白い部分でもあるので、

ぜひともご参考ください。</p>
文章ではなく、動画で視聴したいという方は、

下記の動画を御覧ください。</p>


  </iframe>
</div>
すべてがオブジェクトとは？</h2>
Rubyの代表的な特徴として、

「すべてがオブジェクト」というものがあります。</p>
どういうこと？って感じだと思いますが、

割と文字通りの意味です。</p>
順番に解説していきます。</p>
そもそもオブジェクト指向言語におけるオブジェクトは、

クラス（設計書）の具象化したもののような形で、

例えばCarクラスのオブジェクトは、

実際の車で、走ったり、ブレーキーで止まったりといった振る舞い（メソッド）を

持つといったイメージがありますよね。

(オブジェクト指向について、ちょっと怪しいという人は、

こちらの記事</a>で詳しく解説しているのでご参考ください。)</p>
そのため、他の言語では、

このクラス（設計書）とオブジェクトは別物のはずですが、

Rubyでは少し毛色が変わって、

このクラスもオブジェクトにあたります。</strong>

(別物であることには変わりませんが、

クラス自体が親クラスのインスタンスという側面を持っているという感じです）</p>
例えば、nilオブジェクトから親クラスを追ってみようと思います。

以下は、irbというRubyで使えるサンドバッグ環境です(irbコマンドで起動できます)</strong></p>
irb</span>(main):</span>010</span>:</span>0</span>></span> nil</span>.</span>class</span></span>
=> NilClass</span></span>
irb</span>(main):</span>011</span>:</span>0</span>></span> NilClass</span>.</span>superclass</span></span>
=> Object</span></span>
irb</span>(main):</span>012</span>:</span>0</span>></span> Object</span>.</span>superclass</span></span>
=> BasicObject</span></span>
irb</span>(main):</span>013</span>:</span>0</span>></span> BasicObject</span>.</span>superclass</span></span>
=></span> nil</span></span></code></pre>
上記のclassというのは、

メソッドで、呼び出し元オブジェクトのクラスを返します。</p>
superclassメソッドは、親(継承元)クラスを返します。</p>
それで、上記の返り値を見てみると、

最終的に、BasicObjectを継承していることがわかります。</p>
つまり、文字列とか数値とか、nilといったものは、</mark>

BasicObjectを祖先にに持っているということです。</mark>

(BasicObjectの親クラスは存在しないですね)</p>
「すべてがオブジェクト」というのは、

このことを指しています。</p>
つまり、すべてBasicObjectの子孫ということですね。</p>
さてそんなオブジェクトですが、

オブジェクトは、振る舞い（メソッド）を持っているので、</strong>

値に対してメソッドを呼び出すことができます。</strong></p>
irb</span>(main):</span>014</span>:</span>0</span>></span> nil</span>.</span>to_s</span></span>
=></span> ""</span></span>
irb</span>(main):</span>015</span>:</span>0</span>></span> ''</span>.</span>to_s</span></span>
=></span> ""</span></span>
irb</span>(main):</span>016</span>:</span>0</span>></span> 2</span>.</span>to_s</span></span>
=></span> "2"</span></span></code></pre>
nilも''も2もオブジェクトなので、

to_sというメソッドを呼び出すことができています。</p>
例えば、Pythonとかだと、</p>
int</span>(</span>2</span>)</span></span>
str</span>(</span>2</span>)</span></span></code></pre>
のように、メソッドの引数にオブジェクトなどを渡していますが、

Rubyの場合、オブジェクトに対して、メソッドを呼び出すというのが特徴的ですね。</p>
これは、JavaScriptのラッパーオブジェクトに少し似ている特徴ですね。

JavaScriptのラッパーオブジェクトについては、

下記の記事で解説しています。</p>
[st-card myclass="st-no-shadow" id="23" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
すべてがオブジェクトとは、

何かというと、上記のような特徴のことです。</p>
変数</h2>
変数とは？何って言う人は、

こちらの記事</a>で変数そのものについて、

解説しているので良ければ参考にしてください</p>
さてRubyでの変数定義は、

非常にシンプルな記法で、</p>
greet</span> =</span> 'hello world'</span></span></code></pre>
で足ります。</p>
いれるだけかーいっていうぐらいシンプルな文法ですね(笑)</p>
TypeScriptみたいに、letとかconstみたいなものをつける必要はありません</p>
ただ、Rubyの変数名は、スネークケースで書くのが、</strong>

慣習というかコーディング規約で定められています。</strong></p>
https://www.ruby.or.jp/ja/tech/development/ruby/050_coding_rule.html</a>

https://shugo.net/ruby-codeconv/codeconv.html</a></p>
なので、基本的にはスネークケースで書きます。

ちなみに、スネークケース以外で書いてもエラーにはなりません。</p>
Rubyのちょっと面倒くさいのが、

スネークケース以外の変数も宣言できてしまうので、

コーディング規約でNGとされている記法も、

押し通すことが可能ということです。</p>
irb</span>(main):</span>020</span>:</span>0</span>></span> greetGreet </span>=</span> 'Hello'</span></span>
=></span> "Hello"</span></span></code></pre>
これはすなわち、プロジェクトで、

厳格に記法とかを統一しないと、

コードが荒れやすいともいえますね。</p>
余談ですが、私が以前経験したPJのRubyコードは、

すべての変数がキャメルケースで書かれていて絶望した経験があります。

(これは、あえてそうしているとかではなく、フロントがキャメルケースだから、

無思考でRubyもキャメルケースにしているだけでした。)</p>
Rubyが一面、上級者向けといわれるのは、

こういう側面にあるかもしれませんね。</p>
自由に書くことができる分、

基本的なコーディング規約とか

簡潔で依存性が小さいコードを書くように心がけないと、

簡単に負債化してしまうおそれがあります。</p>
よく元々Java出身のRubyエンジニアが書くコードは綺麗と言われたりしますが、

これも、このあたりに関係しているかもしれないですね。</p>
ちなみに、定数は、すべて大文字として定義します。</p>
</p>
いちおう、警告は出ますが、

Rubyの定数は、再代入できるっちゃできてしまうので、

この辺もちょっと自由すぎる匂いがしますね...</p>
なので、良いコードがどういうものか、</mark>

ある程度自分なりに仮説やインデックスがある人じゃないと、</mark>

コードをカオスにしてしまいやすいというのが、</mark>

Rubyが上級者向けと言われる所以ですかね。</mark></p>
式展開</h3>
文字列の中で、変数の値を展開したいときは、</p>
irb</span>(main):</span>021</span>:</span>0</span>></span> greet </span>=</span> 'hello'</span></span>
=></span> "hello"</span></span>
irb</span>(main):</span>022</span>:</span>0</span>></span> puts</span> "hello</span>#{</span>greet</span>}</span>"</span></span>
hellohello</span></span>
=></span> nil</span></span>
irb</span>(main):</span>024</span>:</span>0</span>></span> puts</span> "hello</span>#{</span>greet.</span>to_s</span>}</span>"</span></span>
hellohello</span></span>
=></span> nil</span></span></code></pre>
という風に、ダブルクオートで、

#{変数や式}という記法で式展開できます。</strong></p>
ちなみに、シングルクオートの場合は、

式展開されず、そのまま表示されます。</p>
irb</span>(main):</span>025</span>:</span>0</span>></span> puts</span> 'hello#{greet}'</span></span>
hello</span>#{greet}</span></span>
=></span> nil</span></span></code></pre>
式展開を使わなければ、

両者の挙動にさして違いはありません。</p>
式展開というと、

変数の値を埋め込むために使う機能と思われがちですが、

下記のように計算することもできます。</p>
irb</span>(main):</span>005</span>:</span>0</span>></span> puts</span> "</span>#{</span>1</span> +</span> 2</span> }</span>"</span></span>
3</span></span>
=></span> nil</span></span></code></pre>真偽値</h2>
次にRubyにおける真偽値を紹介します。</p>
真偽値とは、TrueとFalseというように、

真か偽を表すものですね。

(参考記事</a>)</p>
真偽値に変換した際、

何がTrueになり、

何がFalseになるかというのは、

プログラミング言語によって異なります。</p>
多くのプログラミング言語では、

0などはfalseになることが多いですが、

Rubyにおいては、異なります。</p>
以下詳細に解説していきます。</p>
falseとnil以外真</h3>
Rubyの特徴的なものとして、

真偽値があります。</p>
タイトルの通り、

Rubyの場合、偽(false)になるのは、

falseとnilだけです。</strong></mark></p>
めちゃくちゃシンプルですよね。

なので、他のプログラミング言語だと

偽になりがちな、次の値もすべて真ということになります。</p>
''</span></span>
' '</span></span>
0</span></span>
'false'</span></span></code></pre>
0や空文字列は、

JavaScriptとかでは、falseに認定されるものですが、

Rubyにおいては、trueと認定されます。</p>
以下、確認してみます。</p>
irb</span>(main):</span>030</span>:</span>0</span>> !!</span>' '</span></span>
=></span> true</span></span>
irb</span>(main):</span>031</span>:</span>0</span>> !!</span>' '</span></span>
=></span> true</span></span>
irb</span>(main):</span>032</span>:</span>0</span>> !!</span>''</span></span>
=></span> true</span></span>
irb</span>(main):</span>033</span>:</span>0</span>> !!</span>0</span></span>
=></span> true</span></span>
irb</span>(main):</span>034</span>:</span>0</span>> !!</span>'false'</span></span>
=></span> true</span></span>
irb</span>(main):</span>035</span>:</span>0</span>> !!</span>false</span></span>
=></span> false</span></span>
irb</span>(main):</span>013</span>:</span>0</span>> !!</span>nil</span></span>
=></span> false</span></span></code></pre>
上記の、「!」というのは、</strong>

要素の真偽値を反転させる演算子で、</strong>

例えば、aが真のときは、!aは偽となります。</strong></p>
「!!」というのは、反転させたものをもう一度反転させるので、

結果として、要素の真偽値を返します。</strong></p>
その要素の真偽値を返り値にしたいときは、

たまに使う記法かなと思います。</p>
それを踏まえて、

上記のコードを見ると、

確かに、nilとfalse以外は、

trueになっているのが確認できますね。</p>
論理演算子</h3>
上記で、少し出てきた、

「!」などですが、

これらは論理演算子というものです。</p>
Rubyで頻繁に使うものとして、

&&や||</strong>、**!**などの論理演算子があります。</p>
&&は、

例えば、条件１&& 条件２という風に使用し、

両方とも真なら、全体の式の評価も真を返すというものです。</p>
これに対して、||は、

いずれか一方が真なら真で、両方偽で偽となります。</p>
!は、否定で

真偽値を反転させます。</p>
それぞれ、&&(and)、||(or)、!(not)のイメージに近いかなと思います。</p>
irb</span>(main):</span>036</span>:</span>0</span>></span> true</span> &&</span> true</span></span>
=></span> true</span></span>
irb</span>(main):</span>037</span>:</span>0</span>></span> true</span> &&</span> false</span></span>
=></span> false</span></span>
irb</span>(main):</span>038</span>:</span>0</span>></span> false</span> ||</span> true</span></span>
=></span> true</span></span>
irb</span>(main):</span>039</span>:</span>0</span>></span> false</span> ||</span> false</span></span>
=></span> false</span></span>
irb</span>(main):</span>040</span>:</span>0</span>> !</span>true</span></span>
=></span> false</span></span>
irb</span>(main):</span>041</span>:</span>0</span>> !</span>false</span></span>
=></span> true</span></span></code></pre>
これらの返り値には、

短絡評価というものが使われているので、

短絡評価評価について解説します。</p>
短絡評価</h4>
上記の論理演算子ですが、

Rubyでよく使われるのが、

短絡評価というものがあります。</p>
例えば次のようなコードです。</p>
irb</span>(main):</span>049</span>:</span>1</span>* class</span> </span>User</span></span>
irb</span>(main):</span>050</span>:</span>1</span>*   attr_reader</span> :name</span>,</span> :email</span></span>
irb</span>(main):</span>051</span>:</span>1</span>*</span></span>
irb</span>(main):</span>052</span>:</span>2</span>*   def</span> initialize</span>(</span>name</span>,</span> email</span>)</span></span>
irb</span>(main):</span>053</span>:</span>2</span>*</span>     @name</span> =</span> name</span></span>
irb</span>(main):</span>054</span>:</span>2</span>*</span>     @email</span> =</span> email</span></span>
irb</span>(main):</span>055</span>:</span>1</span>*   end</span></span>
irb</span>(main):</span>056</span>:</span>1</span>*</span></span>
irb</span>(main):</span>057</span>:</span>2</span>*   def</span> email_verified?</span></span>
irb</span>(main):</span>059</span>:</span>2</span>*</span>     true</span></span>
irb</span>(main):</span>060</span>:</span>1</span>*   end</span></span>
irb</span>(main):</span>061</span>:</span>0</span>> end</span></span>
=></span> :email_verified?</span></span>
irb</span>(main):</span>062</span>:</span>0</span>></span></span>
irb</span>(main):</span>063</span>:</span>0</span>></span> user </span>=</span> User</span>.</span>new</span>(</span>"John Doe"</span>,</span> "john.doe@example.com"</span>)</span></span>
=></span> #<User:0x00007fcd178f6bc8 @email="john.doe@example.com", @name="John Doe"></span></span>
irb</span>(main):</span>064</span>:</span>0</span>></span></span>
irb</span>(main):</span>065</span>:</span>1</span>* if</span> user </span>&&</span> user.</span>email_verified?</span></span>
irb</span>(main):</span>066</span>:</span>1</span>*</span>   puts</span> "ユーザーの名前は </span>#{</span>user.</span>name</span>}</span> です。"</span></span>
irb</span>(main):</span>067</span>:</span>1</span>* else</span></span>
irb</span>(main):</span>068</span>:</span>1</span>*</span>   puts</span> "この操作はログイン後にのみ利用可能です。"</span></span>
irb</span>(main):</span>069</span>:</span>0</span>> end</span></span>
ユーザーの名前は John Doe です。</span></span>
=></span> nil</span></span>
irb</span>(main):</span>070</span>:</span>0</span>></span> user</span></span>
=></span> #<User:0x00007fcd178f6bc8 @email="john.doe@example.com", @name="John Doe"></span></span>
irb</span>(main):</span>071</span>:</span>0</span>></span> user </span>&&</span> user.</span>email_verified?</span></span>
=></span> true</span></span>
irb</span>(main):</span>072</span>:</span>0</span>></span> user </span>||</span> user.</span>email_verified?</span></span>
=></span> #<User:0x00007fcd178f6bc8 @email="john.doe@example.com", @name="John Doe"></span></span>
irb</span>(main):</span>073</span>:</span>0</span>></span> false</span> &&</span> user</span></span>
=></span> false</span></span>
irb</span>(main):</span>074</span>:</span>0</span>></span></span></code></pre>
上記では、オブジェクト指向を使用しているので、

オブジェクト指向について確認したい場合は、

こちらの記事をご参考ください。</p>
[st-card myclass="st-no-shadow" id="800" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
上記のコードの着目ポイントですが、userという変数とuserがメソッドを持っているという状況を作りたかっただけなので、

その部分だけ着目してもらえれば大丈夫です。</strong></p>
重要なのは、</p>
irb</span>(main):</span>070</span>:</span>0</span>></span> user</span></span>
=></span> #<User:0x00007fcd178f6bc8 @email="john.doe@example.com", @name="John Doe"></span></span>
irb</span>(main):</span>071</span>:</span>0</span>></span> user </span>&&</span> user.</span>email_verified?</span></span>
=></span> true</span></span>
irb</span>(main):</span>072</span>:</span>0</span>></span> user </span>||</span> user.</span>email_verified?</span></span>
=></span> #<User:0x00007fcd178f6bc8 @email="john.doe@example.com", @name="John Doe"></span></span>
irb</span>(main):</span>073</span>:</span>0</span>></span> false</span> &&</span> user</span></span>
=></span> false</span></span>
irb</span>(main):</span>074</span>:</span>0</span>></span></span></code></pre>
の部分で、||の場合、

どちらかがtrueになればいいので、

userの段階でtrueになることが確定し、

user.email_verified?が実行されず、

返り値がuserオブジェクトになっています。</p>
これに対して、&&の場合、

どちらかがfalseになった段階で、

falseになることが確定するので、

最後のコードのようなfalse && userだと、

falseが最初に来た段階で、userが評価されず、

返り値がfalseになっています。</p>
最初の、user && user.email_verified?は、

どちらもTrueになっているので、

最後のuser.email_verified?の返り値(true)が

返されます。</p>
短絡評価とは、このように、式を評価する際に、最初が条件を満たすかを判定し、

条件を満たす場合にはその後の式を評価せずに処理を終了することです。</strong></mark></p>
これを利用すると、Trueのときには、

変数代入をしたいが、Falseのときは、

したくないみたいな処理を書くこともできます。</p>
短絡評価自体は、他のプログラミング言語にもある機能ですが、

Rubyでは割と頻出なので覚えておくといいでしょう。</p>
コメント</h2>
コメントとは、他のプログラミング言語においても存在するもので、

該当のコードを実行させないように指定することができます。

Rubyにおけるコメントは、#を使います。</p>
puts</span> 'Hello world'</span></span>
# この行は実行されません</span></span>
# puts 'Hello world2'</span></span></code></pre>
コメントについては、シンプルですね。

どういうときにコメントを書くべきかというのは、

意外と難しい議論でして、人によって考え方がわかれます。</p>
ただ、基本的に冗長なコメントは書くべきではないとされているので、

下記のようなコメントは推奨されないでしょう。</p>
puts</span> 'Hello world'</span> # Hello worldと出力する</span></span>
val</span> =</span> 100</span> # valに100を代入する</span></span>
puts</span> val </span>#valを出力する</span></span></code></pre>
こういう逐一コメントは、

冗長なだけでなく、

仮にval変数をval_1とかに修正した場合、

コメントの方も修正する必要が出てくるため、

変更に弱くなります。</p>
個人的には、コメントは書かないことが可能なら、</strong>

書かないほうが良いと思います。</strong></p>
というのも、理想としては、コメントではなく</mark>

コードに語らせることが一番だからです。</mark></p>
けれども、現実問題それが難しいこともあるので、

複雑なコードについては、大まかな処理の概要をコメントで残すという

ことは結構あります。</p>
無思考でコメントを書きそうになってしまったときは、

コメントを書かずにわかりやすいコードを書く方法はないかと検討してみてもいいと思います。</p>
ただ、正直コメントに対する考え方は、

チームによって異なるので、積極的にコメントを残そうという方針のチームもあります。</p>
なので、最終的には、チーム次第なところもありますが、

コメントを書いてしまったら、コメントのメンテナンスと言う作業が増える時点で、

確実に変更に弱くなるので、書かないことが可能なら、書くべきではないということは確かです。</p>


【Ruby環境構築】Rubyとは？rbenvインストールから
2023-04-25T00:00:00+00:00
本記事では、Rubyについて解説します。

プログラミング言語の学習をする際は、

文法なども勉強する必要がありますが、

それ以外にも実行環境を構築する必要があります。</p>
本記事では、Rubyの概要から、

環境構築までを解説します。</p>
文法の詳細については、こちらの記事</a>などをご参考ください。</p>
なお、本記事の動画は、

下記になります。</p>


  </iframe>
</div>
Rubyとは？</h2>
まず、Rubyとは何でしょうか？</p>
Rubyは、日本人のまつもとゆきひろ氏によって開発された、

動的型付け言語です。</strong></p>
すっきりした文法が特徴で、

慣れると書きやすいですが、

最初は癖があると感じるかもしれません。</p>
似ている言語としては、

Pythonなどがありますが、

ところどころで異なる部分も多いため、

あくまで似ているだけです。</p>
Rubyにおいて、

最も特徴的なのは、

「すべてがオブジェクト」という点です。</p>
この点については、

下記の記事で解説しているので、

ご参考ください。</p>
[st-card myclass="st-no-shadow" id="692" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
Rubyのインストール</h2>
macやlinuxの場合、

デフォルトでRubyがインストールされています。</p>
$ ruby -v</span></span>
ruby 2.6.10p210 (2022-04-12 revision 67958) [universal.x86_64-darwin21]</span></span></code></pre>
ただ、のちのちgemとかをインストールする際、

rubyの細かいバージョンがネックになるので、

最初からversionを切り替えられるようにしておくと便利です。</p>
そこでバージョン管理ツールとしてよく使われている

rbenvを導入します。

node.jsでいうnvm的なものです。 [st-card myclass="st-no-shadow" id="13" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
https://github.com/rbenv/rbenv</a></p>
基本は上記のドキュメントどおりに進めます。</p>
macなら</p>
brew install rbenv ruby-build</span></span></code></pre>
linux(Debian, Ubuntu)なら</p>
sudo apt install rbenv</span></span></code></pre>
でインストールできます。</p>
そして</p>
$ rbenv init</span></span>
# Load rbenv automatically by appending</span></span>
# the following to ~/.zshrc:</span></span>
</span>
eval "$(rbenv init - zsh)"</span></span></code></pre>
を走らせます。</p>
使っているシェルにrbenv initの設定を加えます。

ここではzshを想定しています。</p>
eval "$(rbenv init - zsh)"</span></span></code></pre>
そして、.zshrcを再読込します。

（ターミナルを開き直すかsourceコマンドを使って、

再読込します。)</p>
これでrbenvのインストールは完了です。</p>
早速なにかrubyをインストールしてみましょう。

ruby3.0.1をインストールしてみます。</p>
rbenv install 3.0.1</span></span></code></pre>
ただインストールしただけだと

まだ反映されません。</p>
$ rbenv versions</span></span>
* system</span></span>
  3.0.1</span></span></code></pre>
3.0.1を適用させるには、</p>
rbenv global 3.0.1</span></span></code></pre>
を実行します。</p>
たまにこれで切り替わらないときがあるので、

その時は、</p>
$ which ruby</span></span>
/usr/bin/ruby</span></span></code></pre>
上記のように、結果が/usr/bin/rubyになっている場合は、

rbenvのパスに切り替わっていません。</p>
もう一度zshを再読込して、同じのを実行してみます。</p>
$ which ruby</span></span>
/Users/reisuta/.rbenv/shims/ruby</span></span></code></pre>
今度は変わっていますね。

これで反映されました。</p>
irbを試してみる</h3>
irbとは、Rubyの対話型の実行環境で、

Rubyの挙動を手軽に試すことができます。</p>
RailsのRails consoleに似ていますね。</p>
$ irb</span></span>
irb(main):001:0> 1 * 42</span></span>
=> 42</span></span>
irb(main):002:0></span></span></code></pre>
抜けたいときは、exitと打てば抜けられます。</p>
Rubyファイルを実行する</h3>
基本的な文法は、irbだけで

試すことができますが、

ファイルで実行する方法も知っておくべきでしょう。</p>
puts 'Hello world'</span></span></code></pre>
上記の一行をindex.rbというファイルに追加します。

そして実行します。</p>
$ ruby index.rb</span></span>
Hello world</span></span></code></pre>
といった感じです。</p>
基本は、rubyコマンドで実行できます。</p>
ちなみにRubyワンライナーとしていきなりターミナルから実行することもできます。</p>
$ ruby -e 'puts "Hello World"'</span></span></code></pre>
rubyコマンドに-eオプションを渡して

実行します。</p>
Rubyはこのように、

インストールさえしてしまえば、

簡単にコードを実行できるので、

ShellScriptの代わりとして使ったりもできなくはないので、

シェル芸的な側面もあります。

(PythonやPerlとかもでも、よくワンライナーを聞きますが、

手軽さはおそらくRubyが一番か？)</p>
シェル芸の場合、awkとかのプログラミング言語を使うことが多いですが、

awkの代わりにRubyを使ったりするのも可能なので、

一度極めるといろいろな場面で使えるのがRubyの大きなメリットと言えるでしょう。</p>
[st-card myclass="st-no-shadow" id="714" label="あわせて読みたい" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
[st-card myclass="st-no-shadow" id="724" label="あわせて読みたい" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
[st-card myclass="st-no-shadow" id="785" label="あわせて読みたい" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
[st-card myclass="st-no-shadow" id="800" label="あわせて読みたい" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
[st-card myclass="st-no-shadow" id="979" label="あわせて読みたい" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>


【Vue3 props/emit】コンポーネント間通信
2023-04-18T00:00:00+00:00
コンポーネントとは？</h2>
コンポーネントとは、そのままの意味としては、

部品とか、構成要素とかといったものがあります。</p>
Vue.jsにおけるコンポーネントという概念も、

大まかにはそのような意味で、

より具体的に言うと、

ボタンとか、ヘッダーとか、Webページの構成要素を指しています。</p>
具体例を出します。</p>
<</span>script setup lang</span>=</span>"ts"</span>></span></span>
import</span> { ref }</span> from</span> 'vue'</span></span>
import</span> Aim</span> from</span> './Aim.vue'</span></span>
const</span> isShow</span> =</span> ref</span>(</span>true</span>)</span></span>
const</span> change</span> =</span> ()</span> =></span> {</span></span>
  if</span> (isShow.value) {</span></span>
    isShow.value</span> =</span> false</span></span>
  }</span> else</span> {</span></span>
    isShow.value</span> =</span> true</span></span>
  }</span></span>
}</span></span>
</</span>script</span>></span></span>
</span>
<</span>template</span>></span></span>
  <</span>Aim v</span>-if=</span>"isShow"</span> /></span></span>
  <</span>button @click</span>=</span>"change"</span> class</span>=</span>"rounded-lg m-2 p-2 border border-gray-300 bg-gray-100"</span>></span>isShow</span></</span>button</span>></span></span>
</</span>template</span>></span></span></code></pre>
たとえば、このコードの場合、

Aim.vueというコンポーネントをimportして、

使用しています。</p>
</p>
左側のテストと言う部分が、

Aimコンポーネントです。</p>
このように、Webページの構成要素となるものを、

コンポーネントといいます。</strong></p>
通常、コンポーネントは.vueファイルに定義され、

親（コンポーネントを使用する側)でimportをします。</p>
なぜコンポーネントとして切り出すのかというと、

再利用性を高めて、コードの保守性や見通しを良くするためです。</strong></mark></p>
例えば、同じようなボタンが何度も記述されていては、

冗長なので、ボタンのコンポーネントを.vueファイルに定義して、

何度も使い回せるようにするという感じです。</p>
ちなみに、.vueファイルにコンポーネントを定義することを、

単一ファイルコンポーネント（SFC）と言うらしいです。</p>
https://ja.vuejs.org/guide/essentials/component-basics.html</a></p>
コンポネント間通信</h2>
コンポネントのメリットは、これだけではなく、

それぞれが独立していて、親から子へのデータの受け渡し、

通信をすることもできる点があります。</p>
この子から親、親から子のデータの受け渡しの方法として、

Vue.jsには、propsとemitというものがあります。</strong></p>
以下、この2つについて解説します。</p>
props</h3>
propsとは、親コンポーネントから子コンポーネントにデータを

渡す仕組みのことです。</strong></mark></p>
props自体は、Vue.js独自の概念ではなく、

Reactとかにも存在します。</p>
具体例として、子コンポーネントとして、

Child.vueを作成してみます。</p>
<</span>template</span>></span></span>
  <</span>div</span>></span></span>
    <</span>p</span>>Prop A: {{</span>/* propA */</span>}}</span></</span>p</span>></span></span>
    <</span>p</span>>Prop B: {{</span>/* propB */</span>}}</span></</span>p</span>></span></span>
  </</span>div</span>></span></span>
</</span>template</span>></span></span>
</span>
<</span>script setup lang</span>=</span>"ts"</span>></span></span>
const</span> props</span> =</span> defineProps</span>({</span></span>
  propA: {</span></span>
    type: String,</span></span>
    required:</span> true</span></span>
  },</span></span>
  propB: {</span></span>
    type: Number,</span></span>
    default:</span> 100</span></span>
  }</span></span>
})</span></span>
</</span>script</span>></span></span></code></pre>
Vue3のComposition APIでは、</strong>

definePropsという関数を使ってpropsを定義します。</strong></p>
上記の場合、propAとpropBという２つのpropsが定義されています。</p>
これを親から呼び出す場合は、</p>
<</span>script setup lang</span>=</span>"ts"</span>></span></span>
import</span> { ref }</span> from</span> 'vue'</span></span>
import</span> Aim</span> from</span> './Aim.vue'</span></span>
import</span> Child</span> from</span> './Child.vue'</span></span>
const</span> isShow</span> =</span> ref</span>(</span>true</span>)</span></span>
const</span> change</span> =</span> ()</span> =></span> {</span></span>
  if</span> (isShow.value) {</span></span>
    isShow.value</span> =</span> false</span></span>
  }</span> else</span> {</span></span>
    isShow.value</span> =</span> true</span></span>
  }</span></span>
}</span></span>
</</span>script</span>></span></span>
</span>
<</span>template</span>></span></span>
  <</span>Aim v</span>-if=</span>"isShow"</span> /></span></span>
  <</span>Child</span></span>
    prop</span>-</span>a</span>=</span>"hello world"</span></span>
    prop</span>-</span>b</span>=</span>"399"</span></span>
  /></span></span>
  <</span>button @click</span>=</span>"change"</span> class</span>=</span>"rounded-lg m-2 p-2 border border-gray-300 bg-gray-100"</span>></span>isShow</span></</span>button</span>></span></span>
</</span>template</span>></span></span></code></pre>
先程の、TheWelcom.vueに追記しました。

Aimコンポーネントと同様に、Childコンポーネントもインポートしています。</p>
その際、prop-aという感じで、

definePropsで定義されているpropsを渡しています。</strong></p>
この場合、hello worldという文字列をChildコンポーネントに渡しています。</p>
変数をpropsにわたす場合は、

prop-a="hello world"の部分を</p>
  <</span>Child</span></span>
    :prop</span>-</span>a</span>=</span>"greeet"</span></span>
    prop</span>-</span>b</span>=</span>"399"</span></span>
  /></span></span></code></pre>
というように、

v-bindを使用すると渡すことができます。</p>
v-bindとはなんぞや？って言う人は、

こちらの記事</a>で解説しているので、

詳細はこちらを御覧ください。</p>
[st-card myclass="st-no-shadow" id="578" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
emit</h3>
次にemitです。</p>
propsが親から子へのデータの流れに対して、

emitは、その反対の子から親へのデータの流れに対応します。</strong></mark></p>
<!--</span> 親</span> --></span></span>
<</span>script setup lang</span>=</span>"ts"</span>></span></span>
import</span> { ref }</span> from</span> 'vue'</span></span>
import</span> Child</span> from</span> './Child.vue'</span></span>
const</span> greet</span> =</span> 'hello gwge'</span></span>
const</span> print</span> =</span> ()</span>:</span>void =></span> {</span></span>
  console.</span>log</span>(</span>'emit'</span>)</span></span>
}</span></span>
</</span>script</span>></span></span>
</span>
<</span>template</span>></span></span>
  <</span>Child</span></span>
    :prop</span>-</span>a</span>=</span>"greet"</span></span>
    prop</span>-</span>b</span>=</span>"399"</span></span>
    @submit</span>=</span>"print"</span></span>
  /></span></span>
</</span>template</span>></span></span></code></pre><!--</span> 子</span> --></span></span>
<</span>template</span>></span></span>
  <</span>div</span>></span></span>
    <</span>p</span>>Prop A: {{</span>/* propA */</span>}}</span></</span>p</span>></span></span>
    <</span>p</span>>Prop B: {{</span>/* propB */</span>}}</span></</span>p</span>></span></span>
  </</span>div</span>></span></span>
  <</span>button @click</span>=</span>"submit"</span>></span>Submit</span></</span>button</span>></span></span>
</</span>template</span>></span></span>
</span>
<</span>script setup lang</span>=</span>"ts"</span>></span></span>
const</span> props</span> =</span> defineProps</span>({</span></span>
  propA: {</span></span>
    type: String,</span></span>
    required:</span> true</span></span>
  },</span></span>
  propB: {</span></span>
    type: Number,</span></span>
    default:</span> 100</span></span>
  }</span></span>
})</span></span>
const</span> emit</span> =</span> defineEmits</span>([</span>"submit"</span>])</span></span>
const</span> submit</span> =</span> ()</span> =></span> {</span></span>
  emit</span>(</span>"submit"</span>)</span></span>
}</span></span>
</</span>script</span>></span></span></code></pre>
emitは、Vue3 Composition APIの場合、

子の方に、defineEmitsという形で定義し、

emit("submit")で親のv-onディレクティブのsubmitを探しにいき、

そこのメソッドを実行し、printメソッドが走っているという流れです。</strong></mark></p>
propsのときと同じく、

defineEmitsなどは、基本的に子の方で定義します。</p>
emitは、Reactなどには存在せず、

Vue.js独特の機能です。</p>
Vue.jsは双方向データバインディングを特徴に持つため、

このようなpropsとemitという2つのパターンがあります。</p>
チームやPJの方針にもよりますが、

無思考でpropsやemitをたくさん書いてしまうと、

データの流れがカオスになるので、

「こういうときはprops、こういうときはemit」という風に、

大まかな方針を決めておくのがいいかなと思います。</p>


【Vue3ライフサイクルフック】onMountedって何？関数の順序と概念
2023-04-12T00:00:00+00:00
Vue3には、コンポーネントのライフサイクルに関わる

さまざまなフックが用意されています。</p>
これらのフックを適切に使うことで、

コンポーネントの初期化、更新、削除などのタイミングで、

カスタムコードを実行することができます。</p>
本記事では、Vue3のライフサイクルフックについて解説し、</mark>

onMountedフックを中心に具体的な使い方や実行順序を詳しく解説します。</mark></p>
動画で視聴したいという方は、

下記の動画を御覧ください。</p>


  </iframe>
</div>
ライフサイクルフックとは？</h2>
Vue3のライフサイクルフックとは、

コンポーネントの生成、更新、削除などのタイミングで、実行されるカスタム関数のことを指します。</strong></p>
これらのフックを利用することで、

コンポーネントの初期化や、各種処理を実行することができます。</p>
ライフサイクルフックには以下のような種類があります。</p>

</blockquote>

beforeCreate</li>
created</li>
beforeMount</li>
mounted</li>
beforeUpdate</li>
updated</li>
beforeUnmount</li>
unmounted</li>
</ul>
これらのフックは、

コンポーネントの生成、更新、削除などのタイミングで順次実行されます。</p>
ただ、ここにある、すべてのフックを使うのかというと

そうでもなく、よく使うやつとあんまり使わないやつの差が激しい印象があります。</p>
そのため、本記事ではよく使うやつに焦点を当てたいと思いますが、

この中でよく使うのは、mounted、onMountedフックです。</strong></p>
createdも、Vue2のOptions APIだとよく使います。

(mountedよりも使用頻度は高かった)</p>
しかし、Vue3になると、<script setup>構文のComposition APIが主流になるので、

あまり使われなくなりました。</p>
というのも、上記の場合、<script setup>のタイミングが、</mark>

従来のbeforeCreateやcreatedに該当するため、</mark>

これらの関数が不要になっているためです。</mark></p>
そのため、Vue3において、

最も使用頻度が高いフックは、

onMountedフックと言えるでしょう。</p>
ちなみに、ライフサイクルフックの詳しい流れは、

下記のドキュメントが詳しいです。</p>
https://ja.vuejs.org/guide/essentials/lifecycle.html#lifecycle-diagram</a></p>
mounted</h3>
mountedフックは、コンポーネントがDOMにマウントされた後に実行されるフックです。</mark>

このフックを利用することで、DOMにアクセスすることができます。</mark></p>
mountedフックは、以下のように定義します。</p>
<template></span></span>
  <div>...</div></span></span>
</template></span></span>
</span>
<script></span></span>
export default {</span></span>
  mounted() {</span></span>
    // コンポーネントがマウントされた後に実行される処理</span></span>
  },</span></span>
};</span></span>
</script></span></span></code></pre>
mountedフックは、

Options APIで使われるフックで、

ライフサイクルの順序自体は、

Composition APIのonMountedと同様です。</p>
onMounted</h3>
onMountedフックは、Composition APIを利用したコンポーネントで、

先述のようにmountedフックを使用する場合に利用されます。

onMountedフックは、以下のように定義します。</p>
<</span>template</span>></span></span>
  <</span>div</span>></span>...</</span>div</span>></span></span>
</</span>template</span>></span></span>
</span>
<</span>script setup lang</span>=</span>"ts"</span>></span></span>
import</span> { onMounted }</span> from</span> 'vue'</span>;</span></span>
</span>
onMounted</span>(()</span> =></span> {</span></span>
  // コンポーネントがマウントされた後に実行される処理</span></span>
});</span></span>
</</span>script</span>></span></span></code></pre>
Vue3では、Composition APIを使用することが推奨されています。

そのため、onMountedフックを使用することが多いです。</p>
onMountedフックを使用する場合は、

以下のようにimport文で「onMounted」関数を読み込み、関数の中で処理を実装します。

mountedの方は、いちいちimportしなくても

使うことができたので、少々面倒になったかもしれないですね。</p>
<</span>template</span>></span></span>
  <</span>div</span>></span>...</</span>div</span>></span></span>
</</span>template</span>></span></span>
</span>
<</span>script setup lang</span>=</span>"ts"</span>></span></span>
import</span> { onMounted }</span> from</span> 'vue'</span>;</span></span>
</span>
onMounted</span>(()</span> =></span> {</span></span>
  // コンポーネントがマウントされた後に実行される処理</span></span>
});</span></span>
</</span>script</span>></span></span></code></pre>onUpdated</h3>
onUpdatedフックは、リアクティブ変数などによって</strong>

DOMが更新されたときに呼び出されるフックです。</strong></p>
<</span>script setup lang</span>=</span>"ts"</span>></span></span>
import</span> { ref, onUpdated }</span> from</span> 'vue'</span></span>
</span>
const</span> count</span> =</span> ref</span>(</span>0</span>)</span></span>
</span>
onUpdated</span>(()</span> =></span> {</span></span>
  console.</span>log</span>(</span>"onUpdated</span>)</span></span>
})</span></span>
</</span>script</span>></span></span>
</span>
<</span>template</span>></span></span>
  <</span>button id</span>=</span>"count"</span> @click</span>=</span>"count++"</span>></span>{{</span>/* count */</span>}}</span></</span>button</span>></span></span>
</</span>template</span>></span></span></code></pre>
buttonを押すと、リアクティブ変数のcountが更新されて、

onUpdatedが呼ばれます。</p>
onUnmounted</h3>
onUnmountedは、アンマウント、

すなわちコンポネントのDOMが非表示、

アプリケーションの終了時などに呼び出されるフックです</p>
beforeCreateとcreated</h3>
mountの前にcreatedというフックがあるため、

初期化処理などは、こちらのフックでやったほうが良さそうに思えます。</p>
ただ、上記でも軽く触れましたが、Composition APIの場合、

これらのフックはsetupに書くのと同じタイミングにあたるため、

わざわざフックにする必要性がなくなりました。

そのままsetup内に書けばいいというわけです。</p>
そのため、Options APIでおなじみのcreatedフックなどは、

composition APIでは使用する必要がなくなったというわけです。</p>
ライフサイクルフックの実行順序</h2>
ライフサイクルフックは、以下の順序で実行されます。</p>

beforeCreate</li>
created</li>
beforeMount</li>
mounted</li>
beforeUpdate</li>
updated</li>
beforeUnmount</li>
unmounted</li>
</ol>
ドキュメントはこちらです</p>
https://ja.vuejs.org/guide/essentials/lifecycle.html#lifecycle-diagram</a></p>
試しにコードで確認してみます。</p>
<</span>template</span>></span></span>
 <</span>div class</span>=</span>"m-3 p-2 border"</span>></span></span>
  <</span>div</span>>test</span></</span>div</span>></span></span>
  <</span>input class</span>=</span>"mt-2 p-2 rounded border border-blue-300"</span> type</span>=</span>"text"</span> v</span>-</span>model</span>=</span>"text"</span> placeholder</span>=</span>"test"</span> /></span></span>
  <</span>div</span>>{{</span>/* text */</span>}}</span></</span>div</span>></span></span>
 </</span>div</span>></span></span>
</</span>template</span>></span></span>
</span>
<</span>script setup lang</span>=</span>"ts"</span>></span></span>
import</span> { onBeforeMount, onMounted, onBeforeUpdate , onUpdated, onBeforeUnmount, onUnmounted, ref}</span> from</span> 'vue'</span></span>
const</span> text</span> =</span> ref</span>(</span>''</span>)</span></span>
</span>
onBeforeMount</span>(()</span> =></span> {</span></span>
  console.</span>log</span>(</span>"on before mount"</span>)</span></span>
})</span></span>
</span>
onMounted</span>(()</span> =></span> {</span></span>
  console.</span>log</span>(</span>"on mount"</span>)</span></span>
})</span></span>
</span>
onBeforeUpdate</span>(()</span> =></span> {</span></span>
  console.</span>log</span>(</span>"on before update"</span>, text.value)</span></span>
})</span></span>
</span>
onUpdated</span>(()</span> =></span> {</span></span>
  console.</span>log</span>(</span>"on update"</span>, text.value)</span></span>
})</span></span>
</span>
onBeforeUnmount</span>(()</span> =></span> {</span></span>
  console.</span>log</span>(</span>"on before unmounted"</span>)</span></span>
})</span></span>
</span>
onUnmounted</span>(()</span> =></span> {</span></span>
  console.</span>log</span>(</span>"on unmounted"</span>)</span></span>
})</span></span>
</span>
console.</span>log</span>(</span>"on created"</span>)</span></span>
</</span>script</span>></span></span></code></pre>
</p>
console.logを確認すると、

上記の順番になっていそうですね。</p>
unmountedのフックについては、

親コンポネントから、非表示/表示を操作できるように

してみます。</p>
<</span>script setup lang</span>=</span>"ts"</span>></span></span>
import</span> { ref }</span> from</span> 'vue'</span></span>
import</span> Aim</span> from</span> './Aim.vue'</span></span>
const</span> isShow</span> =</span> ref</span>(</span>true</span>)</span></span>
const</span> change</span> =</span> ()</span> =></span> {</span></span>
  if</span> (isShow.value) {</span></span>
    isShow.value</span> =</span> false</span></span>
  }</span> else</span> {</span></span>
    isShow.value</span> =</span> true</span></span>
  }</span></span>
}</span></span>
</</span>script</span>></span></span>
</span>
<</span>template</span>></span></span>
  <</span>Aim v</span>-if=</span>"isShow"</span> /></span></span>
  <</span>button @click</span>=</span>"change"</span> class</span>=</span>"rounded-lg m-2 p-2 border border-gray-300 bg-gray-100"</span>></span>isShow</span></</span>button</span>></span></span>
</</span>template</span>></span></span></code></pre>
これで、親コンポネントから、v-ifで表示・非表示を切り替えた際、

unmountのフックが呼ばれています。</p>


  
  
    
  </div>
  
  
    Vue 3　フロントエンド開発の教科書 [ WINGSプロジェクト　齊藤 新三 ]</p>
    
      Amazonで見る</a>
      楽天市場で見る</a>
    </div>
  </div>
</div>


  
  
    
  </div>
  
  
    これからはじめるVue.js 3実践入門 [ 山田 祥寛 ]</p>
    
      Amazonで見る</a>
      楽天市場で見る</a>
    </div>
  </div>
</div>


  
  
    
  </div>
  
  
    ASP.NET Core and Vue.js Build real-world, scalable, full-stack applications using Vue.js 3, TypeScript, .NET 5, and Azure【電子書籍】[ Devlin Basilan Duldulao ]</p>
    
      Amazonで見る</a>
      楽天市場で見る</a>
    </div>
  </div>
</div>


【Vue3条件分岐ループ】v-if/v-showやv-forのkey
2023-04-10T00:00:00+00:00
本記事では、Vue3におけるv-ifやv-forの使い方、

v-showとの違い、v-forのアンチパターンについて紹介します。</p>
Vue.jsでは、普通のプラグラミング言語のように、

v-ifなどのような条件分岐のコードを書くことができます。</p>
そんな条件分岐のコードとして、

Vue.jsには、v-ifやv-showなどがあります。</p>
本記事では、これらの特徴や違い、

v-forについても解説していきます。</p>
条件付きレンダリング</h2>
Vue.jsにおける、

ifなどの条件分岐の文は、

ドキュメントだと、

条件付きレンダリングとされています。</p>
https://ja.vuejs.org/guide/essentials/conditional.html</a></p>
以下、これら条件付きレンダリングについて、

触れていきます。</p>
v-ifとは？</h3>
v-ifは、条件に応じて要素を表示または非表示にするためのディレクティブです。

(ディレクティブ自体の解説については、こちらの記事</a>をご参考ください。)</p>
v-ifを使用することで、動的に要素を表示/非表示することができます。</mark>

以下は、v-ifを使用したサンプルコードです。</p>
<</span>template</span>></span></span>
  <</span>div</span>></span></span>
    <</span>p v</span>-if=</span>"isDisplayed"</span>></span>表示されます</span></</span>p</span>></span></span>
  </</span>div</span>></span></span>
</</span>template</span>></span></span>
</span>
<</span>script setup lang</span>=</span>"ts"</span>></span></span>
import</span> { ref }</span> from</span> 'vue'</span></span>
</span>
const</span> isDisplayed</span> =</span> ref</span>(</span>true</span>)</span></span>
</</span>script</span>></span></span></code></pre>
上記のコードでは、isDisplayedというrefを使用して、p要素が表示されるかどうかを動的に制御しています。

このように、v-ifを使用することで、条件に応じた要素の表示/非表示を実現することができます。

(ref(リアクティブ)についての参考記事はこちら</a>です)</p>
TypeScriptなどのif文と同様に、

else-ifやelseを使用することもできます。</p>
<</span>template</span>></span></span>
  <</span>div</span>></span></span>
    <</span>p v</span>-if=</span>"isDisplayed >= 80"</span>></span>80以上</span></</span>p</span>></span></span>
    <</span>p v</span>-else-if=</span>"isDisplayed >= 70"</span>></span>70以上</span></</span>p</span>></span></span>
    <</span>p v</span>-else-if=</span>"isDisplayed >= 60"</span>></span>60以上</span></</span>p</span>></span></span>
    <</span>p v</span>-else></span>不明</span></</span>p</span>></span></span>
  </</span>div</span>></span></span>
</</span>template</span>></span></span>
</span>
<</span>script setup lang</span>=</span>"ts"</span>></span></span>
import</span> { computed }</span> from</span> 'vue'</span></span>
</span>
const</span> isDisplayed</span> =</span> computed</span>(()</span> =></span> {</span></span>
  return</span> Math.</span>round</span>(Math.</span>random</span>()</span> *</span> 100</span>)</span></span>
})</span></span>
</</span>script</span>></span></span></code></pre>
ただ、else-ifとかelseを使う場合は、

タグを連続で記述する必要があります。</p>
そのため、下記のようなコードは書けません。</p>
<!--</span> 下記は不可</span> --></span></span>
<</span>template</span>></span></span>
  <</span>div</span>></span></span>
    <</span>p v</span>-if=</span>"isDisplayed >= 80"</span>></span>80以上</span></</span>p</span>></span></span>
    <</span>p</span>>いいね</span></</span>p</span>></span></span>
    <</span>p v</span>-else-if=</span>"isDisplayed >= 70"</span>></span>70以上</span></</span>p</span>></span></span>
    <</span>p v</span>-else-if=</span>"isDisplayed >= 60"</span>></span>60以上</span></</span>p</span>></span></span>
    <</span>p v</span>-else></span>不明</span></</span>p</span>></span></span>
  </</span>div</span>></span></span>
</</span>template</span>></span></span></code></pre>
Vue.jsは、このようにHTML側に

直感的にifとかを書けるので、

わかりやすいですね。</p>
次に、v-ifと似たような条件分岐のディレクティブである、

v-showについて解説します。</p>
v-showとは？</h3>
v-showも、v-ifと似たようなディレクティブで、

条件に合致した場合に、表示するようなものです。</strong></p>
<</span>template</span>></span></span>
  <</span>div</span>></span></span>
    <</span>p v</span>-</span>show</span>=</span>"isDisplayed"</span>></span>表示されます</span></</span>p</span>></span></span>
  </</span>div</span>></span></span>
</</span>template</span>></span></span>
</span>
<</span>script setup lang</span>=</span>"ts"</span>></span></span>
import</span> { ref }</span> from</span> 'vue'</span></span>
</span>
const</span> isDisplayed</span> =</span> ref</span>(</span>true</span>)</span></span>
</</span>script</span>></span></span></code></pre>
さて、これだけ見ると、

v-ifとv-showはほとんど違いがないような気もします。</p>
実際、この2つの違いは、

あるにはありますが、ものすごく大きな差異とまでは

言えないと思います。</p>
v-showとv-ifは何が違うか？</h4>
v-showは、条件に応じて要素を表示または非表示にするためのディレクティブです。</p>
v-ifとの違いは、v-ifは条件に応じてDOM要素を削除するのに対し、</mark>

v-showはdisplayプロパティを制御するため、要素自体は削除されずに表示/非表示が切り替わります。</mark></p>
つまり、v-showは、表示/非表示を切り替える際に、

DOM要素を再描画する必要がないため、より効率的です。</p>
<</span>template</span>></span></span>
  <</span>div</span>></span></span>
    <</span>p v</span>-if=</span>"isDisplayed"</span>></span>表示されます</span></</span>p</span>></span></span>
    <</span>p v</span>-</span>show</span>=</span>"isDisplayed"</span>></span>表示されます</span></</span>p</span>></span></span>
    <</span>p v</span>-if=</span>"isDisplayed2"</span>></span>表示されない</span></</span>p</span>></span></span>
    <</span>p v</span>-</span>show</span>=</span>"isDisplayed2"</span>></span>表示されない</span></</span>p</span>></span></span>
  </</span>div</span>></span></span>
</</span>template</span>></span></span>
</span>
<</span>script setup lang</span>=</span>"ts"</span>></span></span>
import</span> { ref }</span> from</span> 'vue'</span></span>
</span>
const</span> isDisplayed</span> =</span> ref</span>(</span>true</span>)</span></span>
const</span> isDisplayed2</span> =</span> ref</span>(</span>false</span>)</span></span>
</</span>script</span>></span></span></code></pre>
この場合、表示されますの部分だけ画面に表示されます。</p>
</p>
違いは、表示されないと記載している、

pタグ部分にあって、</p>
これをGoogle developer toolsなどで、

HTML構造を確認すると、</p>
<!--v-if--></span></span>
<p style="display: none;">表示されない</p></span></span></code></pre>
とv-showの場合は、

レンダリングされた上で、styleで非表示にしていることがわかります。</p>
なので、表示/非表示の切り替えコストがかかる場合は、</strong>

v-showの方が効率的といった感じです。</strong></p>
しばしば言及される、v-ifとv-showの違い問題ですが、

正直私は、この違いをクリティカルに利用した場面に出会ったことがありません。</p>
面倒くさかったら、基本v-ifを使い、

なんかv-ifだといちいち切り替えるときに重い気がするなってときに、

v-showを使えば良い気がします。</p>
リストレンダリング</h2>
次にv-forなどのループの方に移って行きたいと思います。</p>
上記の、条件付きレンダリングに対して、

forなどの文は、Vue.jsでは、

リストレンダリングと括られています。</p>
https://ja.vuejs.org/guide/essentials/list.html</a></p>
以下、これらリストレンダリングについて触れていきます。</p>
v-forとは？</h3>
v-forは、配列やオブジェクトの各要素に対して、繰り返し処理を行うためのディレクティブです。

以下は、v-forを使用したサンプルコードです。</p>
<</span>template</span>></span></span>
  <</span>div</span>></span></span>
    <</span>ul</span>></span></span>
      <</span>li v</span>-</span>for</span>=</span>"(item, index) in items"</span> :key</span>=</span>"item"</span>></span>{{</span>/* item */</span>}}</span></</span>li</span>></span></span>
    </</span>ul</span>></span></span>
  </</span>div</span>></span></span>
</</span>template</span>></span></span>
</span>
<</span>script setup lang</span>=</span>"ts"</span>></span></span>
import</span> { ref }</span> from</span> 'vue'</span></span>
</span>
const</span> items</span> =</span> ref</span>([</span>'りんご'</span>,</span> 'バナナ'</span>,</span> 'みかん'</span>])</span></span>
</</span>script</span>></span></span></code></pre>
上記のコードでは、itemsという配列の各要素を繰り返し処理し、li要素を生成しています。

v-forを使用することで、配列やオブジェクトを簡単に表示することができます。</p>
構文自体は、item in itemsという風に、inの後にループさせたい変数を持ってきて、</mark>

inの前にループ内部で使用したい変数を格納する感じです。</mark></p>
v-forの文法自体は、

Pythonに似ているので、

比較的わかりやすいですね。</p>
key</h4>
さて、ここまでは意外と素直なv-forですが、

面倒くさいのが、:keyの部分です。</p>
https://ja.vuejs.org/guide/essentials/list.html#v-for-with-v-if</a></p>
Vueの場合、v-forを使う際、

こうしたkeyを指定する必要があります。</p>
さて、これの面倒なところは、

これ実は、指定しなくてもエラーにはならないです。</p>
じゃあ、よくねって思いますよね？

（私は最初そう思いました。)</p>
ただ、v-forでkeyを指定しないのは、明らかなアンチパターンになっており、</strong>

公式ドキュメントでは、なんとしても守ってくださいと言われています。</strong></p>
https://ja.vuejs.org/style-guide/rules-essential.html#use-detailed-prop-definitions</a></p>
じゃあ、そもそもこのkeyってなんなの？って感じだと思いますが、

ぶっちゃけ詳細は現時点では追わなくて大丈夫です。

割とVue内部に関わる話なので、最初のうちは混乱するだけになりがちです。

(私がそうでした)</p>
なので、めちゃくちゃざっくり説明すると、

keyは、v-forのデータ項目が変更とか更新とかされた際に、

Vue側が一意な何かの値で個々の要素を識別するために必要といった感じです。</strong></mark></p>
すみません、これでもまだわかりにくいですよね。

要は、keyは割と文字通りの意味で、一意な値を設定することで、

要素を識別できるようにしているわけです。</p>
なので、keyには一意な値を設定する必要があります。

（そうじゃないと、要素を識別できないですもんね）</p>
まあ、平たく言うと、

Vueのv-forのアルゴリズムが、

要素の順序とかの識別をkeyがある場合とない場合で選り分けていて、

その設計上基本的にはkeyが必要みたいな感じですかね。</p>
https://ja.vuejs.org/api/built-in-special-attributes.html#key</a></p>
たしか、keyを指定しないと、

ESLintとかでも警告が出ていたはずなので、

基本的には指定しましょう。</p>
余談ですが、Vue.jsのアンチパターンという意味では、

v-ifとv-forを一緒に使うというのも存在します。</strong></p>
これも、避けるべきスタイルの一つとして

定義されているので、気をつけたいですね。</p>
https://ja.vuejs.org/style-guide/rules-essential.html#avoid-v-if-with-v-for</a></p>


【Vue3】リアクティブとは？refやcomputed(算出プロパティ)
2023-04-04T00:00:00+00:00
本記事では、Vue.jsの重要な概念である、

リアクティブについて扱います。</p>
その中でも、refやcomputedについて、

詳細に解説します。</p>
動画でご覧になりたい方は、

こちらをご参考ください。</p>


  </iframe>
</div>
リアクティブとは？</h2>
リアクティブとは何でしょうか？

私も最初、この概念がよくわかりませんでした。</p>
記事とかドキュメントを見ても、

いまいちピンと来ませんでした。</p>
リアクティブとは、簡単に言うと、

変数の値が変化すると、view側もそれに応じて変わってくれる流れみたいないものです。</strong></p>
これは、双方向データバインディングを想起するとイメージしやすいと思いますが、

JS → HTML、HTML → JSのように、変更に応じて、

一方に反映させていくような感じですね。</p>
大抵の場合、変数はJS側で定義し、

view側はHTMLになるので、

本質的には、双方向データバインディングの議論と

あまり変わらないかなと思います。

(双方向データバインディングについては、こちらの記事</a>をご参考ください。)</p>
具体的には、下記あたりがそれに該当しますかね。</p>

ref()</li>
reactive()</li>
computed()</li>
</ul>
あとは、JavaScriptプロキシとかも該当するのかもしれません

（混乱するだけだから、特に意識しなくてもいいような気もしますが...)</p>
リアクティブの厳密な定義としては、

変更がview側に検知されて、view側を気にしなくていいメリットがあるみたいな感じだと思いますが、

Vue.jsにおけるリアクティブといったら、ほぼほぼ、

**ref()**のことを言っていると思っても大丈夫だと思います。</p>
同じ種類として、reactive()というのもありますが、

ぶっちゃけ使う頻度は、ref()よりは下がると思います。</p>
computed()も、リアクティブといえば、

リアクティブなのですが、

それよりは算出プロパティという、

関数としての特徴のほうが印象的な気がします。

（算出プロパティはリアクティブな依存関係にもとづきキャッシュされるので、

そういった意味では、リアクティブの関数verみたいな感じですが）</p>
https://ja.vuejs.org/guide/essentials/computed.html</a></p>
ref</h2>
さて、それでは主役のrefとは一体何でしょうか？</p>
まず、リアクティブな変数を作成するには、

ref以外にも、reactive()というのもあります。</p>
https://ja.vuejs.org/guide/essentials/reactivity-fundamentals.html</a></p>
ただ、reactive()は、オブジェクト型にしか使えないため、

文字列とか数値みたいなプリミティブ型には使えないという制限があります。</p>
プリミティブ型って何？という方は、

下記の記事をご参考ください。</p>
[st-card myclass="st-no-shadow" id="23" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
その制限に対処したのが、

ref()という感じです。</strong></p>
そのため、refでリアクティブな変数を作成し、

プリミティブ型にも対処できるという感じですね。</p>
例えば、</p>
<</span>template</span>></span></span>
  <</span>div</span>></span></span>
    <</span>input type</span>=</span>"text"</span> ref</span>=</span>"inputRef"</span>></span></span>
    <</span>button @click</span>=</span>"handleClick"</span>></span>ボタン</span></</span>button</span>></span></span>
  </</span>div</span>></span></span>
</</span>template</span>></span></span>
</span>
<</span>script setup lang</span>=</span>"ts"</span>></span></span>
import</span> { ref }</span> from</span> 'vue'</span>;</span></span>
</span>
const</span> inputRef</span> =</span> ref</span><</span>HTMLInputElement</span>>();</span></span>
</span>
function</span> handleClick</span>() {</span></span>
  if</span> (inputRef.value) {</span></span>
    console.</span>log</span>(inputRef.value.value);</span></span>
  }</span></span>
}</span></span>
</</span>script</span>></span></span></code></pre>
こんな感じのコードがあるとすると、

inputRefという変数がリアクティブになっているので、

inputタグの中身が変われば、

変数の中身も変わっていき、ボタンをクリックすると、

その変わった変数の中身を出力しているといった感じですね。</p>
基本的には、こんな感じで、

HTMLのフォームとかの値をTypeScriptの変数の方にも反映させたいときに、

refとか、v-modelを使用することになるでしょう。</p>
リアクティブじゃないとどうなる？</h3>
リアクティブじゃないコードのサンプルを紹介します。</p>
<</span>template</span>></span></span>
  <</span>div</span>></span></span>
    <</span>p</span>>商品価格: {{</span>/* price */</span>}}円</span></</span>p</span>></span></span>
    <</span>p</span>>消費税込み価格: {{</span>/* priceIncludingTax */</span>}}円</span></</span>p</span>></span></span>
    <</span>button @click</span>=</span>"handleClick"</span>></span>ボタン</span></</span>button</span>></span></span>
  </</span>div</span>></span></span>
</</span>template</span>></span></span>
</span>
<</span>script setup lang</span>=</span>"ts"</span>></span></span>
import</span> { ref, computed }</span> from</span> 'vue'</span>;</span></span>
</span>
let</span> price</span> =</span> 1000</span></span>
</span>
const</span> priceIncludingTax</span> =</span> computed</span>(()</span> =></span> {</span></span>
  const</span> taxRate</span> =</span> 0.1</span>;</span></span>
  return</span> Math.</span>round</span>(price</span> *</span> (</span>1</span> +</span> taxRate));</span></span>
});</span></span>
function</span> handleClick</span>() {</span></span>
  price</span> +=</span> 100</span></span>
  console.</span>log</span>(price)</span></span>
}</span></span>
</</span>script</span>></span></span></code></pre>
</p>
この場合、Typescript側の変数priceの中身と、

html(view側)で表示されている値が食い違っています。</p>
画面に描写されているのは、

初期値の、1000と1100ですが、

console.logでは、ちゃんと100づつ加算されている、

変数priceが出力されています。</p>
リアクティブな場合と比べてみます。

※変数名が手抜きなのは許してください</p>
<</span>template</span>></span></span>
  <</span>div</span>></span></span>
    <</span>p</span>>商品価格: {{</span>/* price */</span>}}円</span></</span>p</span>></span></span>
    <</span>p</span>>ref商品価格: {{</span>/* refprice */</span>}}円</span></</span>p</span>></span></span>
    <</span>p</span>>消費税込み価格: {{</span>/* priceIncludingTax */</span>}}円</span></</span>p</span>></span></span>
    <</span>p</span>>ref消費税込み価格: {{</span>/* refpriceIncludingTax */</span>}}円</span></</span>p</span>></span></span>
    <</span>button @click</span>=</span>"handleClick"</span>></span>ボタン</span></</span>button</span>></span></span>
    <</span>button @click</span>=</span>"refClick"</span>></span>リアクティブボタン</span></</span>button</span>></span></span>
  </</span>div</span>></span></span>
</</span>template</span>></span></span>
</span>
<</span>script setup lang</span>=</span>"ts"</span>></span></span>
import</span> { ref, computed }</span> from</span> 'vue'</span>;</span></span>
</span>
let</span> price</span> =</span> 1000</span></span>
const</span> refprice</span> =</span> ref</span>(</span>1000</span>)</span></span>
</span>
const</span> priceIncludingTax</span> =</span> computed</span>(()</span> =></span> {</span></span>
  const</span> taxRate</span> =</span> 0.1</span>;</span></span>
  return</span> Math.</span>round</span>(price</span> *</span> (</span>1</span> +</span> taxRate));</span></span>
});</span></span>
</span>
const</span> refpriceIncludingTax</span> =</span> computed</span>(()</span> =></span> {</span></span>
  const</span> taxRate</span> =</span> 0.1</span>;</span></span>
  return</span> Math.</span>round</span>(refprice.value</span> *</span> (</span>1</span> +</span> taxRate));</span></span>
});</span></span>
</span>
function</span> handleClick</span>() {</span></span>
  price</span> +=</span> 100</span></span>
  console.</span>log</span>(price)</span></span>
}</span></span>
</span>
function</span> refClick</span>() {</span></span>
  refprice.value</span> +=</span> 100</span></span>
  console.</span>log</span>(refprice.value)</span></span>
}</span></span>
</</span>script</span>></span></span></code></pre>
この場合、リアクティブの方は、

加算されるに従って、画面も反映されていますね。</p>
computed(算出プロパティ)</h2>
上記で少し登場しましたが、

computedは、さっきのコードで言うと、</p>
import</span> { ref, computed }</span> from</span> 'vue'</span>;</span></span>
</span>
const</span> priceIncludingTax</span> =</span> computed</span>(()</span> =></span> {</span></span>
  const</span> taxRate</span> =</span> 0.1</span>;</span></span>
  return</span> Math.</span>round</span>(price</span> *</span> (</span>1</span> +</span> taxRate));</span></span>
});</span></span>
</span>
const</span> refpriceIncludingTax</span> =</span> computed</span>(()</span> =></span> {</span></span>
  const</span> taxRate</span> =</span> 0.1</span>;</span></span>
  return</span> Math.</span>round</span>(refprice.value</span> *</span> (</span>1</span> +</span> taxRate));</span></span>
});</span></span></code></pre>
ここの部分です。

Vue3 Composition APIの場合、importして使用します。</p>
構文的には、computed()の中に、関数処理を書いていく感じです。

基本的には、複雑なロジックを関数として、

htmlの方に表示するために使われるので、

{{/**/}}構文の中に複雑なロジックを書かないための改善策みたいな感じです。</p>
computed()は、普通の関数としても実装はできますが、

少し違いがあります。</p>
<</span>template</span>></span></span>
  <</span>div</span>></span></span>
    <</span>p</span>>ref商品価格: {{</span>/* refprice */</span>}}円</span></</span>p</span>></span></span>
    <</span>p</span>>ref消費税込み価格: {{</span>/* refpriceIncludingTax */</span>}}円</span></</span>p</span>></span></span>
    <</span>p</span>>普通の関数: {{</span> func1</span>() }}</span></</span>p</span>></span></span>
    <</span>button @click</span>=</span>"refClick"</span>></span>リアクティブボタン</span></</span>button</span>></span></span>
    <</span>button @click</span>=</span>"refClick2"</span>></span>リアクティブボタン22</span></</span>button</span>></span></span>
    <</span>p</span>>{{</span>/* omake */</span>}}</span></</span>p</span>></span></span>
  </</span>div</span>></span></span>
</</span>template</span>></span></span>
</span>
<</span>script setup lang</span>=</span>"ts"</span>></span></span>
import</span> { ref, computed }</span> from</span> 'vue'</span>;</span></span>
</span>
const</span> refprice</span> =</span> ref</span>(</span>1000</span>)</span></span>
const</span> omake</span> =</span> ref</span>(</span>10</span>)</span></span>
</span>
const</span> func1</span> =</span> ()</span> =></span> {</span></span>
  console.</span>log</span>(</span>'普通の関数の処理'</span>)</span></span>
  const</span> taxRate</span> =</span> 0.1</span>;</span></span>
  return</span> Math.</span>round</span>(refprice.value</span> *</span> (</span>1</span> +</span> taxRate));</span></span>
}</span></span>
</span>
const</span> refpriceIncludingTax</span> =</span> computed</span>(()</span> =></span> {</span></span>
  console.</span>log</span>(</span>'computedの処理'</span>)</span></span>
  const</span> taxRate</span> =</span> 0.1</span>;</span></span>
  return</span> Math.</span>round</span>(refprice.value</span> *</span> (</span>1</span> +</span> taxRate));</span></span>
});</span></span>
</span>
function</span> refClick</span>() {</span></span>
  refprice.value</span> +=</span> 100</span></span>
  console.</span>log</span>(refprice.value)</span></span>
}</span></span>
</span>
function</span> refClick2</span>() {</span></span>
  omake.value</span> +=</span> 10</span></span>
}</span></span>
</</span>script</span>></span></span></code></pre>
computedは、中のリアクティブな変数の値が更新された際にだけ、</mark>

呼ばれるのに対し、普通の関数は、再描画が起きると毎回呼ばれます。</mark></p>
つまり、computedのほうが、リアクティブなキャッシュを保持しているといった感じです。</p>
上記のコードの場合、

リアクティブボタンを押すと、

computedが感知している、リアクティブなrefprice関数が書き換わるので、

処理が呼ばれますが、自身が感知していない、omake変数がリアクティブ22ボタンで書き換わっても、

computedの方は呼ばれないといった感じです。</p>
まあ、正直この違いをクリティカルに利用したいユースケースは、

そんなにない気がしますが...笑</p>
computedと普通の関数の違いとしては、

このような感じです。</p>


【Vue3/v-model】双方向データバインディングとは？
2023-04-04T00:00:00+00:00
Vue.jsの概念に、

双方向データバインディングというものがあります。</p>
これは、単方向データバインディングに対するものです。</p>
本記事では、双方向データバインディングの解説を通して、</mark>

単方向データバインディングとの違いに触れつつ、</mark>

v-model, v-on, v-bindの関係性や違いについても解説します。</mark></p>
文字ではなく、動画で学習したい方は、

下記の動画御覧ください。</p>


  </iframe>
</div>
双方向データバインディングと単方向データバインディング</h2>
そもそも、データバインディングとは、何かっていうと、

これは、簡単に言うと、JavaScriptのデータと、</strong>

表示されているHTMLのデータとを合わせる仕組みのことです。</strong></p>
バックエンドとかだと、

あまりHTMLと合わせるみたいなシチュエーションがないので、

どちらかというと、フロントエンド技術の用語のような気もします。</p>
さて、そんなデータバインディングですが、

バインディングされていないと、

Javascriptのデータをいくら内部で書き換えても、

画面の表示（HTML）が変わらないので、

データが変わっていることに気づけません。</p>
イメージとしては、

Amazonのサイトとかで、

内部のJavaScriptで、商品の価格を1000円引きしているのに、

データバインディングされていないので、画面上では、

割引されていないように見えるような感じです。

(実際のapi処理では、JavaScriptのデータをバックエンドにわたすので、

仮に決済処理を行えば、割引価格になっているはずです）</p>
そのため、画面を操るフロントエンドでは、

必須の技術なのですが、

こうしたバインディングにも、

単方向と、双方向という種類があります。</strong></p>
これらは、文字通りベクトルの違いです</p>
フロントエンドのデータバインディングの場合、

大まかな流れとして</p>
・JS → HTML</strong>

・HTML → JS</strong></p>
二種類があります。</p>
双方向データバインディングとは、

この両方の流れをサポートしているバインディングのことです。</strong></mark></p>
これに対して、単方向データバインディング、

上記のどちらか一方だけをサポートしているものです。</strong></p>
以下は、双方向データバインディングのサンプルコードです。</p>
<</span>template</span>></span></span>
  <</span>div</span>></span></span>
    <</span>label for</span>=</span>"name"</span>></span>Name:</</span>label</span>></span></span>
    <</span>input id</span>=</span>"name"</span> v</span>-</span>model</span>=</span>"name"</span> /></span></span>
    <</span>p</span>>Hello, {{</span>/* name */</span>}}</span>!</</span>p</span>></span></span>
  </</span>div</span>></span></span>
</</span>template</span>></span></span>
</span>
<</span>script setup lang</span>=</span>"ts"</span>></span></span>
import</span> { ref }</span> from</span> 'vue'</span>;</span></span>
</span>
const</span> name</span> =</span> ref</span>(</span>''</span>);</span></span>
</span>
</</span>script</span>></span></span></code></pre>
これは、<input>タグの中身になにか入れると、

<p>タグの中身も同じものが表示されます。</p>
</p>
これを実現しているのは、

v-modelというディレクティブなのですが、

(ディレクティブについては後で説明します)

流れとしては、下記のような感じです。</p>

<input>タグ(HTML) → name変数(JS)</li>
name変数(JS) → <p>タグ(HTML)</li>
</ol>
このようにして、

双方向にデータがバインディングされています。</p>
イメージとしては、データが一周しているような感じでしょうか。</p>
ディレクティブとは？</h2>
さて次に、ディレクティブとはなんでしょう？</p>
これは、HTMLで記述する、

v-から始まる属性のことです</strong>。</p>
ビルトインのディレクティブについては、

下記に記載があります。</p>
https://ja.vuejs.org/api/built-in-directives.html</a></p>
例えば、以下のようなものがあります。</p>

v-bind</td> バインディング機能</td></tr>
v-on</td> イベント処理</td></tr>
v-model</td> 双方向データバインディング</td></tr>
v-html</td> htmlを表示する</td></tr>
v-if</td> if文</td></tr>
v-for</td> for文</td></tr>
</table>
他にも、v-onceとかv-preみたいなディレクティブもありますが、

使用頻度はあまり高くないので割愛します。

上記のビルトインディレクティブの一覧ドキュメントを御覧ください。</p>
さて、この中で圧倒的によく使うのは、

v-bind、v-on、v-modelの3つで、

特にv-modelはよく使います。</strong></p>
以下、順番に解説します。</p>
v-bind</h3>
先程、v-modelは双方向データバインディングだと説明しましたが、

v-modelの機能は、実はv-bindとv-onの複合で実現できます。</p>
すなわち、v-bind単体だと、単方向データバインディングにあたるわけです。

それも方向的には、</p>
JS → HTMLの方向です。

（v-onはこれの逆で、これらの複合で双方向データバインディングになります）</p>
サンプルコードを紹介します。</p>
<</span>template</span>></span></span>
  <</span>div</span>></span></span>
    <</span>a :href</span>=</span>"linkUrl"</span>></span>{{</span>/* linkText */</span>}}</span></</span>a</span>></span></span>
    <</span>button :class</span>=</span>"buttonClass"</span> @click</span>=</span>"onClick"</span>></span>{{</span>/* buttonText */</span>}}</span></</span>button</span>></span></span>
  </</span>div</span>></span></span>
</</span>template</span>></span></span>
</span>
<</span>script setup lang</span>=</span>"ts"</span>></span></span>
import</span> { ref }</span> from</span> 'vue'</span>;</span></span>
</span>
const</span> linkUrl</span> =</span> ref</span>(</span>'https://example.com'</span>);</span></span>
const</span> linkText</span> =</span> ref</span>(</span>'Example Link'</span>);</span></span>
const</span> buttonClass</span> =</span> ref</span>(</span>'primary'</span>);</span></span>
const</span> buttonText</span> =</span> ref</span>(</span>'Click me!'</span>);</span></span>
</span>
function</span> onClick</span>() {</span></span>
  buttonText.value</span> =</span> 'Clicked!'</span>;</span></span>
}</span></span>
</span>
</</span>script</span>></span></span></code></pre>
:classとか:hrefというのが、

v-bindの省略形の記法で、

v-bind:classとかと同じ意味です。</p>
この場合、JS側で指定した、

linkUrlとかbuttonClass変数の内容が、

href属性やclass属性に適応されます。</p>
v-on</h3>
v-onは、v-bindの逆の方向で、</p>
HTML → JS</p>
の流れです。（正確にはHTMLというよりDOMだが

templateタグからscriptタグという流れの表現的には、

HTMLと言っても良い気がしたのでHTMLとしています）</p>
サンプルコードを紹介します。</p>
<</span>template</span>></span></span>
  <</span>div</span>></span></span>
    <</span>h1</span>>タグ</span></</span>h1</span>></span></span>
    <</span>input type</span>=</span>"text"</span> @input</span>=</span>"onInput"</span> :value</span>=</span>"message"</span> /></span></span>
    <</span>p</span>>{{</span>/* message */</span>}}</span></</span>p</span>></span></span>
  </</span>div</span>></span></span>
</</span>template</span>></span></span>
</span>
<</span>script setup lang</span>=</span>"ts"</span>></span></span>
import</span> { ref }</span> from</span> 'vue'</span>;</span></span>
</span>
const</span> message</span> =</span> ref</span>(</span>''</span>);</span></span>
</span>
function</span> onInput</span>(</span>event</span>:</span> </span>Event</span>) {</span></span>
  const</span> target</span> =</span> event.target</span> as</span> </span>HTMLInputElement</span>;</span></span>
  message.value</span> =</span> target.value;</span></span>
}</span></span>
</span>
</</span>script</span>></span></span></code></pre>
@inputというのは、

v-on:inputと同じ意味の省略形です。</p>
inputイベントは、何かが入力されることをトリガーにします。

つまり、上記のコードは、inputタグ(HTML）に何かが入力されたら、

JS側のonInputメソッドが呼ばれ、message変数が書き換わるという、

バインディングをしています。</p>
v-model</h3>
v-modelは、すでに出てきたv-bindとv-onの融合系みたいな感じです。</p>
例えば、先程紹介した下記のコードですが、</p>
<</span>template</span>></span></span>
  <</span>div</span>></span></span>
    <</span>label for</span>=</span>"name"</span>></span>Name:</</span>label</span>></span></span>
    <</span>input id</span>=</span>"name"</span> v</span>-</span>model</span>=</span>"name"</span> /></span></span>
    <</span>p</span>>Hello, {{</span>/* name */</span>}}</span>!</</span>p</span>></span></span>
  </</span>div</span>></span></span>
</</span>template</span>></span></span>
</span>
<</span>script setup lang</span>=</span>"ts"</span>></span></span>
import</span> { ref }</span> from</span> 'vue'</span>;</span></span>
</span>
const</span> name</span> =</span> ref</span>(</span>''</span>);</span></span>
</span>
</</span>script</span>></span></span></code></pre>
下記のように書き換えられます。</p>
<</span>template</span>></span></span>
  <</span>div</span>></span></span>
    <</span>label for</span>=</span>"name"</span>></span>Name:</</span>label</span>></span></span>
    <</span>input id</span>=</span>"name"</span> :value</span>=</span>"name"</span> @input</span>=</span>"updateName"</span> /></span></span>
    <</span>p</span>>Hello, {{</span>/* name */</span>}}</span>!</</span>p</span>></span></span>
  </</span>div</span>></span></span>
</</span>template</span>></span></span>
</span>
<</span>script setup lang</span>=</span>"ts"</span>></span></span>
import</span> { ref }</span> from</span> 'vue'</span>;</span></span>
</span>
const</span> name</span> =</span> ref</span>(</span>''</span>);</span></span>
</span>
function</span> updateName</span>(</span>event</span>:</span> </span>Event</span>) {</span></span>
  const</span> target</span> =</span> event.target</span> as</span> </span>HTMLInputElement</span>;</span></span>
  name.value</span> =</span> target.value;</span></span>
}</span></span>
</</span>script</span>></span></span></code></pre>
記述が冗長になりましたが、同じことをしています。

イメージとしては、v-bind + v-on = v-modelみたいな感じです。</p>
双方向データバインディングをしたい場合は、

基本的にv-modelを使うことが多いでしょう。</p>
単方向データバインディングと双方向データバインディングどっちがいい？</h2>
これは、正直好みやケース・バイ・ケースの部分もあるのですが、

最近の主流は、やはり単方向データバインディング</strong>でしょうか。</p>
というのも、双方向データバインディングの場合、

小規模のアプリとか、機能が単純なものであれば、

便利な代物ですが、複雑化かつ大規模になると、

データの流れが混戦しがちで、追うのも容易ではなくなってきます。</p>
値があっちこっちにいったりきたりで、

結局どこ行った？状態になりがちなので、

双方向データバインディングは、一般的には、

メリットよりもデメリットのほうに注目されがちです。</p>
また、意図せずデータが書き換わってしまうということも、

双方向データバインディングの場合、

単方向よりも起きやすい気がしています。</p>
これも、あっちこっちにいってしまい、

追うことができなくなってしまうのが原因かと思います。</p>
ただ、このあたりは、保守性が高いコードや設計、厳密なコーディングスタイルなどによって、</strong>

ある程度は解消できるものでもある気がするので、やはり正直チームやプロジェクトによると思います。</strong></p>
Reactは、基本的に単方向データバインディングを採用しており、

Reactと比較したVueのデメリットの一つとして、しばしば双方向データバインディングを

挙げられることも多いので、賛否両論の機能であることは間違いなさそうです。</p>
Vue.jsにおいても、v-modelではなく、

v-bindやv-onだけを使えばいいのではないかという意見もありますが、

正直それだと、Vue.jsを採用するメリットが無い気がします。</p>
また、v-modelを使わないとなると、

かなり記述が冗長になることが予想されます。</p>
そのため、双方向データバインディングのデメリットが気になるのであれば、

Vue.jsの採用には慎重になったほうがいいかもしれません。</p>
v-modelだけでなく、Vue.jsには、propsに加えemitというものもあり、

ここも双方向データバインディングのような動きをします。</p>
しかし、逆にこのような双方向データバインディングのほうが、

記法をすっきりさせたり、柔軟な記述ができるという、

メリットの部分を重視すれば、Vue.jsを採用するのも有りだと思います。</p>
まあ、結局は好き嫌いですね(笑)</p>
ちなみに、Vue.jsのpropsとemitについては、

下記の記事で紹介しているので、よければご参考ください。</p>
[st-card myclass="st-no-shadow" id="638" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>


Vue.jsとChatGPT APIでずんだもんに回答を喋ってもらう
2023-03-31T00:00:00+00:00
ChatGPTとは？</h2>
ChatGPTとは何でしょうか？

本人に聞いてみました。</p>
</p>
おお、模範解答（？）ですね。</p>
このように、ChatGPTとは、

AIの一種で、人間が質問したものに対して、

応答してくれます。</p>
その精度や、回答が人間味があることで

話題になりましたね。</p>
https://chat.openai.com</a></p>
実際に色々試してみると、

面白いと思います。</p>
「夏目漱石風に好きな人に告白してみて」とか、

「東京23区で一番勝ち組なのはどこ？」みたいな

アホみたいな質問にも回答してくれます。</p>
「エッセイを作成して」とか、

しりとりの相手もしてくれます。</p>
すごいですね笑</p>
Vue.jsからChatGPT APIを叩いて話しかけた回答内容をずんだもんに喋ってもらう</h2>
※下記のコードは、Vue.jsの概要で実装したコードをもとに実装しているので、

まずは、こちらの記事</a>でVue.jsのセットアップを済ませてからだと、

同じようにハンズオンできます。</p>
【Vue3/Docker環境構築】Vue.js概要と起動の仕組み</a></p>
まずは、Vue.jsのルーティングに、

ChatGPTにアクセスするページを追加します。</p>
{</span></span>
      path:</span> '/chat'</span>,</span></span>
      name:</span> 'chat'</span>,</span></span>
      component: ()</span> =></span> import</span>(</span>'../components/Chat.vue'</span>)</span></span>
}</span></span></code></pre>
axiosをインストールします。</p>
docker compose exec front yarn add axios</span></span></code></pre>
肝心のChat.vueのファイルの、

コードの全体像は下記のようになります。</p>
<</span>template</span>></span></span>
  <</span>v</span>-</span>row</span>></span></span>
    <</span>v</span>-</span>col cols</span>=</span>"4"</span>></span></span>
      <</span>v</span>-</span>card</span></span>
          class</span>=</span>"mx-auto"</span></span>
          max</span>-</span>width</span>=</span>"344"</span></span>
          variant</span>=</span>"outlined"</span></span>
        ></span></span>
        <</span>v</span>-</span>card</span>-</span>item</span>></span></span>
          <</span>div class</span>=</span>"text-overline mb-1"</span>></span></span>
            入力したものをずんだもんに話してもらう</span></span>
            <</span>v</span>-</span>text</span>-</span>field v</span>-</span>model</span>=</span>"val"</span>></span></</span>v</span>-</span>text</span>-</span>field</span>></span></span>
          </</span>div</span>></span></span>
        </</span>v</span>-</span>card</span>-</span>item</span>></span></span>
</span>
        <</span>v</span>-</span>card</span>-</span>actions</span>></span></span>
          <</span>v</span>-</span>btn variant</span>=</span>"outlined"</span> v</span>-</span>on:click</span>=</span>"buttonClicked"</span>></span></span>
            送信</span></span>
          </</span>v</span>-</span>btn</span>></span></span>
        </</span>v</span>-</span>card</span>-</span>actions</span>></span></span>
      </</span>v</span>-</span>card</span>></span></span>
      <</span>audio class</span>=</span>"audio"</span>></span></</span>audio</span>></span></span>
    </</span>v</span>-</span>col</span>></span></span>
</span>
    <</span>v</span>-</span>col cols</span>=</span>"4"</span>></span></span>
      <</span>v</span>-</span>card</span></span>
          class</span>=</span>"mx-auto"</span></span>
          max</span>-</span>width</span>=</span>"344"</span></span>
          variant</span>=</span>"outlined"</span></span>
        ></span></span>
        <</span>v</span>-</span>card</span>-</span>item</span>></span></span>
          <</span>div class</span>=</span>"text-overline mb-1"</span>></span></span>
            入力したものをChatGPTに飛ばす</span></span>
            <</span>v</span>-</span>text</span>-</span>field v</span>-</span>model</span>=</span>"chatgpt"</span>></span></</span>v</span>-</span>text</span>-</span>field</span>></span></span>
          </</span>div</span>></span></span>
        </</span>v</span>-</span>card</span>-</span>item</span>></span></span>
</span>
        <</span>v</span>-</span>card</span>-</span>actions</span>></span></span>
          <</span>v</span>-</span>btn variant</span>=</span>"outlined"</span> v</span>-</span>on:click</span>=</span>"chatGptClick"</span>></span></span>
            ChatGPTへ送信</span></span>
          </</span>v</span>-</span>btn</span>></span></span>
        </</span>v</span>-</span>card</span>-</span>actions</span>></span></span>
      </</span>v</span>-</span>card</span>></span></span>
      <</span>audio class</span>=</span>"audio"</span>></span></</span>audio</span>></span></span>
    </</span>v</span>-</span>col</span>></span></span>
</span>
    <</span>v</span>-</span>col cols</span>=</span>"4"</span>></span></span>
      <</span>v</span>-</span>card</span></span>
          class</span>=</span>"mx-auto"</span></span>
          max</span>-</span>width</span>=</span>"344"</span></span>
          variant</span>=</span>"outlined"</span></span>
        ></span></span>
        <</span>v</span>-</span>card</span>-</span>item</span>></span></span>
            ずんだもんに話しかける</span></span>
        </</span>v</span>-</span>card</span>-</span>item</span>></span></span>
</span>
        <</span>v</span>-</span>card</span>-</span>actions</span>></span></span>
          <</span>v</span>-</span>btn variant</span>=</span>"outlined"</span> v</span>-</span>on:click</span>=</span>"start"</span>></span></span>
            開始</span></span>
          </</span>v</span>-</span>btn</span>></span></span>
          <</span>v</span>-</span>btn variant</span>=</span>"outlined"</span> v</span>-</span>on:click</span>=</span>"end"</span>></span></span>
            終了</span></span>
          </</span>v</span>-</span>btn</span>></span></span>
        </</span>v</span>-</span>card</span>-</span>actions</span>></span></span>
      </</span>v</span>-</span>card</span>></span></span>
      <</span>audio class</span>=</span>"audio"</span>></span></</span>audio</span>></span></span>
    </</span>v</span>-</span>col</span>></span></span>
  </</span>v</span>-</span>row</span>></span></span>
  <</span>v</span>-</span>row</span>></span></span>
    <</span>v</span>-</span>col cols</span>=</span>"12"</span>></span></span>
      <</span>div class</span>=</span>"output"</span>></span></</span>div</span>></span></span>
    </</span>v</span>-</span>col</span>></span></span>
  </</span>v</span>-</span>row</span>></span></span>
</</span>template</span>></span></span>
</span>
<</span>script setup lang</span>=</span>"ts"</span>></span></span>
import</span> { ref }</span> from</span> 'vue'</span>;</span></span>
import</span> axios</span> from</span> 'axios'</span></span>
</span>
const</span> buttonClicked</span> = async</span> ()</span> =></span> {</span></span>
  await</span> createAudio</span>(val.value);</span></span>
}</span></span>
</span>
const</span> chatGptClick</span> = async</span> ()</span> =></span> {</span></span>
  const</span> responseText</span> = await</span> requestChatAPI</span>(chatgpt.value);</span></span>
  await</span> createAudio</span>(responseText)</span></span>
  const</span> output</span> =</span> document.</span>querySelector</span>(</span>".output"</span>);</span></span>
  output.textContent</span> =</span> responseText;</span></span>
}</span></span>
</span>
const</span> val</span> =</span> ref</span>(</span>'initial'</span>)</span></span>
const</span> chatgpt</span> =</span> ref</span>(</span>'chatGPT initial'</span>)</span></span>
</span>
async</span> function</span> createAudio</span>(</span>text</span>) {</span></span>
  const</span> audio</span> =</span> document.</span>querySelector</span>(</span>".audio"</span>);</span></span>
  audio.src</span> = await</span> getAudioURL</span>(text);</span></span>
  audio.</span>play</span>();</span></span>
}</span></span>
</span>
async</span> function</span> getAudioURL</span>(</span>text</span>) {</span></span>
  const</span> query</span> = await</span> getQuery</span>(text);</span></span>
  const</span> response</span> = await</span> axios.</span>post</span>(</span></span>
    "http://localhost:50021/synthesis?speaker=1"</span>,</span></span>
    query,</span></span>
    { responseType:</span> "blob"</span> }</span></span>
  );</span></span>
  return</span> URL.</span>createObjectURL</span>(response.data);</span></span>
}</span></span>
</span>
async</span> function</span> getQuery</span>(</span>text</span>) {</span></span>
  const</span> response</span> = await</span> axios.</span>post</span>(</span></span>
    `http://localhost:50021/audio_query?speaker=1&text=</span>${</span>text</span>}</span>`</span></span>
  );</span></span>
  return</span> response.data;</span></span>
}</span></span>
</span>
const</span> api_key</span> =</span> "各自のキー"</span>;</span></span>
</span>
async</span> function</span> requestChatAPI</span>(</span>text</span>) {</span></span>
const</span> headers</span> =</span> {</span></span>
  "Content-Type"</span>:</span> "application/json"</span>,</span></span>
  Authorization:</span> `Bearer </span>${</span>api_key</span>}</span>`</span>,</span></span>
};</span></span>
</span>
const</span> messages</span> =</span> [</span></span>
  {</span></span>
    role:</span> "user"</span>,</span></span>
    content: text,</span></span>
  },</span></span>
];</span></span>
</span>
const</span> payload</span> =</span> {</span></span>
  model:</span> "gpt-3.5-turbo"</span>,</span></span>
  max_tokens:</span> 128</span>,</span></span>
  messages: messages,</span></span>
};</span></span>
</span>
const</span> response</span> = await</span> axios.</span>post</span>(</span></span>
  "https://api.openai.com/v1/chat/completions"</span>,</span></span>
  payload,</span></span>
  {</span></span>
    headers: headers,</span></span>
  }</span></span>
);</span></span>
console.</span>log</span>(</span>'ChatGPT送信'</span>)</span></span>
return</span> response.data.choices[</span>0</span>].message.content;</span></span>
}</span></span>
</span>
const</span> recognition</span> = new</span> webkitSpeechRecognition</span>();</span></span>
const</span> language</span> =</span> "ja"</span>;</span></span>
</span>
recognition.lang</span> =</span> language;</span></span>
recognition.interimResults</span> =</span> true</span>;</span></span>
recognition.continuous</span> =</span> true</span>;</span></span>
recognition.onresult</span> =</span> handleResult;</span></span>
</span>
async</span> function</span> handleResult</span>(</span>event</span>) {</span></span>
  let</span> finalTranscript</span> =</span> ''</span>;</span></span>
  </span></span>
  for</span> (</span>let</span> i</span> =</span> event.resultIndex; i</span> <</span> event.results.length; i</span>++</span>) {</span></span>
    const</span> transcript</span> =</span> event.results[i][</span>0</span>].transcript;</span></span>
    console.</span>log</span>(transcript);</span></span>
</span>
    if</span> (event.results[i].isFinal) {</span></span>
      finalTranscript</span> +=</span> transcript;</span></span>
      const</span> responseText</span> = await</span> requestChatAPI</span>(finalTranscript);</span></span>
      await</span> createAudio</span>(responseText);</span></span>
      const</span> output</span> =</span> document.</span>querySelector</span>(</span>".output"</span>);</span></span>
      output.textContent</span> =</span> responseText;</span></span>
    }</span></span>
  }</span></span>
}</span></span>
</span>
const</span> start</span> =</span> ()</span> =></span> {</span></span>
  recognition.</span>start</span>();</span></span>
};</span></span>
const</span> stop</span> =</span> ()</span> =></span> {</span></span>
  recognition.</span>stop</span>();</span></span>
};</span></span>
</</span>script</span>></span></span></code></pre>
</p>
こんな感じになります。</p>
https://platform.openai.com</a></p>
上記のコードは、音声認識をして、

その内容をChatGPTに渡して、

回答結果をずんだもんに話してもらうという流れになっています。</p>
一つずつ解説します。</p>
音声認識をしている部分</h3>
まず、音声認識の部分ですが、

下記のコードです。</p>
const</span> recognition</span> = new</span> webkitSpeechRecognition</span>();</span></span>
const</span> language</span> =</span> "ja"</span>;</span></span>
</span>
recognition.lang</span> =</span> language;</span></span>
recognition.interimResults</span> =</span> true</span>;</span></span>
recognition.continuous</span> =</span> true</span>;</span></span>
recognition.onresult</span> =</span> handleResult;</span></span>
</span>
async</span> function</span> handleResult</span>(</span>event</span>) {</span></span>
  let</span> finalTranscript</span> =</span> ''</span>;</span></span>
  </span></span>
  for</span> (</span>let</span> i</span> =</span> event.resultIndex; i</span> <</span> event.results.length; i</span>++</span>) {</span></span>
    const</span> transcript</span> =</span> event.results[i][</span>0</span>].transcript;</span></span>
    console.</span>log</span>(transcript);</span></span>
</span>
    if</span> (event.results[i].isFinal) {</span></span>
      finalTranscript</span> +=</span> transcript;</span></span>
      const</span> responseText</span> = await</span> requestChatAPI</span>(finalTranscript);</span></span>
      await</span> createAudio</span>(responseText);</span></span>
      const</span> output</span> =</span> document.</span>querySelector</span>(</span>".output"</span>);</span></span>
      output.textContent</span> =</span> responseText;</span></span>
    }</span></span>
  }</span></span>
}</span></span></code></pre>

このコードは、Web Speech API を使用して音声認識を行い、認識されたテキストを使用してチャットボットとの対話を実現するためのものです。</p>
最初に webkitSpeechRecognition() を使用して、新しい SpeechRecognition オブジェクトを作成します。</p>
language 変数を定義し、認識される言語を指定します。この場合は、"ja" (日本語) が指定されています。</p>
recognition.lang を使用して、認識される言語を設定します。</p>
recognition.interimResults が true に設定されており、認識中に中間結果を取得することができます。</p>
recognition.continuous が true に設定されており、ユーザーが話し続けている間に音声認識が継続します。</p>
recognition.onresult には、認識結果が利用可能になったときに呼び出されるコールバック関数 handleResult が設定されています。</p>
handleResult 関数は、event オブジェクトを引数に受け取り、認識されたテキストを使用してチャットボットとの対話を実現します。</p>
音声認識の結果は event.results 配列に格納されており、for ループを使用してその中から認識されたテキストを取得しています。</p>
event.results[i].isFinal が true の場合、認識が終了したことを示し、finalTranscript 変数に認識されたテキストが追加されます。</p>
requestChatAPI() 関数を使用して、finalTranscript のテキストをチャットボット API に送信し、応答を受信します。</p>
createAudio() 関数を使用して、チャットボットの応答を音声合成し、ユーザーに再生します。</p>
最後に、output 変数を使用して、チャットボットの応答を表示します。</p>
ChatGPTさん</p>
</blockquote>
せっかくなので、ChatGPTに処理の内容について説明してもらいました。</p>
ずんだもんと連携している部分</h3>
ずんだもんは、VOICEVOXというアプリで使用できるキャラクターで、

可愛い声が特徴的です。</p>
https://voicevox.hiroshiba.jp/</a></p>
https://github.com/VOICEVOX/voicevox_engine</a></p>
アプリをインストールして、

起動しておけば、localhost:50021にリッスンして、

リクエストを送れるようになります。</p>
該当コードは、</p>
async</span> function</span> createAudio</span>(</span>text</span>) {</span></span>
  const</span> audio</span> =</span> document.</span>querySelector</span>(</span>".audio"</span>);</span></span>
  audio.src</span> = await</span> getAudioURL</span>(text);</span></span>
  audio.</span>play</span>();</span></span>
}</span></span>
</span>
async</span> function</span> getAudioURL</span>(</span>text</span>) {</span></span>
  const</span> query</span> = await</span> getQuery</span>(text);</span></span>
  const</span> response</span> = await</span> axios.</span>post</span>(</span></span>
    "http://localhost:50021/synthesis?speaker=1"</span>,</span></span>
    query,</span></span>
    { responseType:</span> "blob"</span> }</span></span>
  );</span></span>
  return</span> URL.</span>createObjectURL</span>(response.data);</span></span>
}</span></span>
</span>
async</span> function</span> getQuery</span>(</span>text</span>) {</span></span>
  const</span> response</span> = await</span> axios.</span>post</span>(</span></span>
    `http://localhost:50021/audio_query?speaker=1&text=</span>${</span>text</span>}</span>`</span></span>
  );</span></span>
  return</span> response.data;</span></span>
}</span></span></code></pre>

このコードは、与えられたテキストを使用して音声合成して再生する関数 createAudio と、テキストを使用して音声データの URL を取得する関数 getAudioURL 、テキストを使用してチャットボット API に送信するためのクエリを作成する関数 getQuery から構成されています。</p>
createAudio 関数は、与えられたテキストを使用して音声合成して再生する関数です。まず、 document.querySelector を使用して、 HTML 上の audio タグを取得します。次に、 getAudioURL 関数を使用して、与えられたテキストを使用して音声データの URL を取得します。最後に、 audio.play() を呼び出して音声を再生します。</p>
getAudioURL 関数は、与えられたテキストを使用して音声データの URL を取得する関数です。まず、 getQuery 関数を使用して、与えられたテキストを使用してチャットボット API に送信するためのクエリを取得します。次に、axios.post を使用して、API に対してクエリを送信し、Blob データを取得します。最後に、URL.createObjectURL を使用して Blob データから URL を作成し、URL を返します。</p>
getQuery 関数は、与えられたテキストを使用して、チャットボット API に送信するためのクエリを作成する関数です。axios.post を使用して、API に対してテキストを送信し、応答を受信します。そして、API から受け取った応答データを返します。</p>
このコードは、非同期処理を使用して、API からの応答を待ってから次の処理を実行することができます。また、 URL.createObjectURL を使用して Blob データから URL を作成することで、オーディオ再生のための URL を直接取得することができます。</p>
ChatGPTさん</p>
</blockquote>
基本正しいのですが、

getQuery関数は、VOICEBOXのAPIに送信するためのクエリーです

（ChatGPTさん、チャットボットAPIとは何者でしょうか？)</p>
ChatGPT APIを叩いている部分</h3>
さて、いよいよChatGPT APIを叩いている部分ですが、</p>
async</span> function</span> requestChatAPI</span>(</span>text</span>) {</span></span>
const</span> headers</span> =</span> {</span></span>
  "Content-Type"</span>:</span> "application/json"</span>,</span></span>
  Authorization:</span> `Bearer </span>${</span>api_key</span>}</span>`</span>,</span></span>
};</span></span>
</span>
const</span> messages</span> =</span> [</span></span>
  {</span></span>
    role:</span> "user"</span>,</span></span>
    content: text,</span></span>
  },</span></span>
];</span></span>
</span>
const</span> payload</span> =</span> {</span></span>
  model:</span> "gpt-3.5-turbo"</span>,</span></span>
  max_tokens:</span> 128</span>,</span></span>
  messages: messages,</span></span>
};</span></span>
</span>
const</span> response</span> = await</span> axios.</span>post</span>(</span></span>
  "https://api.openai.com/v1/chat/completions"</span>,</span></span>
  payload,</span></span>
  {</span></span>
    headers: headers,</span></span>
  }</span></span>
);</span></span>
console.</span>log</span>(</span>'ChatGPT送信'</span>)</span></span>
return</span> response.data.choices[</span>0</span>].message.content;</span></span>
}</span></span></code></pre>

このコードは、OpenAIのChat APIを使用して、テキストを受け取り、AIが生成したテキストを返すための関数です。</p>
まず、Authorizationヘッダーを設定して、APIキーを含めます。次に、リクエストの本文として、ユーザーが入力したテキストを含むメッセージオブジェクトを作成します。そして、APIの使用モデル、最大トークン数、そしてメッセージオブジェクトを含むペイロードを定義します。</p>
最後に、Axiosを使用して、OpenAIのAPIエンドポイントにPOSTリクエストを送信し、レスポンスを受け取ります。レスポンスには、AIによって生成されたテキストが含まれています。また、送信が成功したことを示すために、"ChatGPT送信"という文字列をコンソールに出力します。最後に、AIが生成したテキストを返します。</p>
ChatGPTさん</p>
</blockquote>
ありがとうございます！ChatGPTさん！</p>


【Vue3/Docker環境構築】Vue.js概要と起動の仕組み
2023-03-27T00:00:00+00:00
Vue3がリリースされ、

Vue.jsは大きく変わりました。</p>
本記事では、Vue.jsの中でも、

この大きく変化したVu3に焦点を当てて解説します。</p>
環境構築として、</mark>

Dockerを使い、TypeScriptと、</mark>

Vue.js界隈では有名な、UIフレームワークの、</mark>

Vuetifyも導入します。</mark></p>
上記の環境構築に加え、Componentなどといった、

フロントエンドの基本用語の解説、</p>
テンプレート構文などのVue.jsの文法、

Vue.jsの起動の仕組みについてまで解説します。</p>
文字ではなく、動画で学習したい方は、

下記を御覧ください。</p>


  </iframe>
</div>
また、Vue3全般について、

フル動画もございますので、

動画一本でVue3をマスターしたい方は、

こちらを御覧ください。</p>


  </iframe>
</div>
Vue.js概要</h2>
Vue.jsとは、Javascriptフレームワークの一種です。

昨今の開発では、実質Vue.jsとReactの二択になっている気がしますが、

よく言われるのは、VueはReactよりも学習コストが低いという点です。

（真偽は定かではありませんが。)</p>
確かに、Vue.jsは、

Reactよりもとっつきやすい印象があり、

デザイナーの方なども、VueとReactなら、</mark>

Vueの方が良いという方は一定数いました。</mark></p>
Reactは、やや関数型言語のような記法のため、

書き方がやや難解になりやすいというのもあるのかもしれません。</p>
そのため、Vue.jsは今でも人気のある

フレームワークの一つです。</p>
そんなVue.jsですが、Vue2とVue3では、

書き方や構成などがかなり大きく変わりました</strong>。</p>
Vue2で広く使われていたライブラリが、

Vue3ではあまり採用されなくなったり、

文法なども変わりました。(ここでは、options api → composition apiへの

デファクトスタンダードの変化について念頭においています)</p>
そのため、その大きな変更や、</strong>

未だVue3に対応していないライブラリがあることなどに、</strong>

戸惑っている方もいるかと思います。</strong></p>
ただ、基本的には、Vue3への変更は良い変更とみなしていいものでして、

Vue3になって、TypeScriptのサポートが強力になり、

Composition ApiというReactに似たような(?)

書き方が主流になったので、

Options Apiの弱点であった、処理が散らばった書き方というものを

克服できるようになりました。</p>
https://ja.vuejs.org/guide/extras/composition-api-faq.html#will-options-api-be-deprecated</a></p>
なので、個人的な印象としては、

Vue3 CompositionAPIの構成であれば、

Reactと遜色はあまりないと感じています。

（ライブラリ等の対応状況は懸念点ではありますが、

やがて対応されて、技術的に枯れることを信じて)</p>
そのため今からVue.jsを学ぶことは、

十分有意義なことだと思います。</strong></p>
Vue.jsについては、案件数も多く、

使用している企業も多いので、

その点でもそこまで心配はいらないと思います。</p>
Vue3ハンズオン</h2>
概要はこれぐらいにして、

実際にコードを書いてみましょう。</p>
Vue3の強みは、何と言っても、

Composition apiとTypeScriptサポート</strong>にあるので、

本記事でもこの2つを採用していきます。</p>
Docker環境の構築</h3>
今回はRailsプロジェクトと同じディレクトリ構成として、

下記のようにします。</p>
Railsの環境構築手順自体は、

こちらで解説しています。</p>
[st-card myclass="st-no-shadow" id="159" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
また、下記ではDockerを使っていきますので、

Dockerの基礎知識に不安がある方は、下記の記事を御覧ください。</p>
[st-card myclass="st-no-shadow" id="1077" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
まずは、docker-compose.ymlファイルです。</p>
version: '3.9'</span></span>
services:</span></span>
  db:</span></span>
    image: postgres</span></span>
    volumes:</span></span>
      - ./api/tmp/db:/var/lib/postgresql/data</span></span>
    environment:</span></span>
      POSTGRES_PASSWORD: password</span></span>
  front:</span></span>
    build: .</span></span>
    working_dir: /app</span></span>
    volumes:</span></span>
      - .:/app</span></span>
    ports:</span></span>
      - "5173:5173"</span></span>
  api:</span></span>
    build: ./api</span></span>
    command: bash -c "rm -f api/tmp/pids/server.pid && bundle exec rails s -p 4000 -b '0.0.0.0'"</span></span>
    stdin_open: true</span></span>
    tty: true</span></span>
    volumes:</span></span>
      - ./api:/myapp</span></span>
    ports:</span></span>
      - "4000:4000"</span></span>
    depends_on:</span></span>
      - db</span></span></code></pre>
ここでは、apiにRailsを使い、

dbにpostgre sqlを使用しています。</p>
この2つのコンテナ構築については、

上記のRuby on Rails環境構築のものを、

基本そのまま使用していますので、

新しいコンテナは、frontになります。</strong></p>
portは5173にし、workdirは、/appにします。

Dockerfileは下記のような感じです。</p>
FROM node:18-slim</span></span>
</span>
WORKDIR /app</span></span>
</span>
RUN apt-get update</span></span></code></pre>
node18系を採用しました。

imageの種類としては、slimを使いました。</p>
あとは、特にこれといった特徴がない、

簡素なコンテナです。</p>
一旦、構成はこのようなシンプルな感じでいきます。

記載したら、buildしましょう。</p>
docker compose build</span></span></code></pre>
その後、コンテナを立ち上げます。

起動終了した後に無駄にコンテナ残したくないので、

--rmオプションも付けまして、npm init vue@latestします。</p>
docker compose run --rm front npm init vue@latest</span></span></code></pre>
これで新規プロジェクトを作成できます。</p>
プロジェクト名は、frontとし、

これで作成すると、ルートにfrontというディレクトリが作成されます。</p>
さて、ここでDockerfileを修正します。

場所もfrontディレクトリ直下に移動します。</p>
FROM node:18-slim</span></span>
</span>
WORKDIR /app</span></span>
</span>
COPY . /app</span></span>
RUN apt-get update</span></span></code></pre>
COPYの命令を付け加えました。</p>
docker-compose.ymlも修正します。</p>
version: '3.9'</span></span>
services:</span></span>
  db:</span></span>
    image: postgres</span></span>
    volumes:</span></span>
      - ./api/tmp/db:/var/lib/postgresql/data</span></span>
    environment:</span></span>
      POSTGRES_PASSWORD: password</span></span>
  front:</span></span>
    build: ./front</span></span>
    working_dir: /app</span></span>
    volumes:</span></span>
      - ./front:/app</span></span>
    ports:</span></span>
      - "5173:5173"</span></span>
  api:</span></span>
    build: ./api</span></span>
    command: bash -c "rm -f api/tmp/pids/server.pid && bundle exec rails s -p 4000 -b '0.0.0.0'"</span></span>
    stdin_open: true</span></span>
    tty: true</span></span>
    volumes:</span></span>
      - ./api:/myapp</span></span>
    ports:</span></span>
      - "4000:4000"</span></span>
    depends_on:</span></span>
      - db</span></span></code></pre>
volumesの設定を付け加え、

buildのディレクトリ階層を加えます。</p>
もう一度、buildします。</p>
docker compose build</span></span></code></pre>
yarn installも走らせます。</p>
docker compose run --rm front yarn install</span></span></code></pre>
くどいですが、

もう一度Dockerfileを修正します。

CMDを加えます。</p>
FROM node:18-slim</span></span>
</span>
WORKDIR /app</span></span>
</span>
COPY . /app</span></span>
RUN apt-get update</span></span>
</span>
CMD ["yarn", "dev", "--host"]</span></span></code></pre>
ここまで来たら、

あとは下記で立ち上げます。</p>
docker compose build</span></span>
docker compose up -d</span></span></code></pre>createApp関数</h3>
さて、環境構築が終わったので、

簡単にVue.jsの起動の仕組みを解説します。</p>
Vue.jsの場合、

createApp関数で、アプリケーションのインスタンスを開始しています。</strong></p>
https://ja.vuejs.org/guide/essentials/application.html</a></p>
作成されたばかりだと、

このように設定されているかと思います。</p>
import</span> { createApp }</span> from</span> 'vue'</span></span>
import</span> { createPinia }</span> from</span> 'pinia'</span></span>
</span>
import</span> App</span> from</span> './App.vue'</span></span>
import</span> router</span> from</span> './router'</span></span>
</span>
import</span> './assets/main.css'</span></span>
</span>
const</span> app</span> =</span> createApp</span>(App)</span></span>
</span>
app.</span>use</span>(</span>createPinia</span>())</span></span>
app.</span>use</span>(router)</span></span>
</span>
app.</span>mount</span>(</span>'#app'</span>)</span></span></code></pre>
vueからcreateAppをimportして、

App.vueをcreateAppの引数に渡しています。</p>
このApp.vueとは何でしょうか？

その前に、フロントエンドの基本用語である、

Componentについて解説します。(App.vueもComponentです)</p>
Componentとは？</h4>
Componentとは、webパーツの構成パーツのことを指します。</strong>

平たく言うと、部品です。</p>
例えば、よくあるWebサイトなどに、

ログインボタンなどがあると思います。

あれも、いわばログインボタンComponentのようにみなすこともできます。</p>
あとは、よくあるお問い合わせフォームなんかも、

Componentといえるでしょう。</p>
これらは、再利用性が特徴で、</mark>

様々な場所でComponentを呼び出すことで、</mark>

共通化することができます</mark>。(いわば共通化の手段ですね)</p>
Component、すなわち部品をどの程度の大きさで分割するかは、

開発者によって、異なるので一概には言えませんが、

例えば下記の画像だと、</p>
</p>
右側にある、Content1とかContent2とかは、

カード形式のコンポネントとみなすことができそうですね。</p>
また、そうした小さいコンポネントをひとまとめにして、

Contentカードが4つあるコンポネントとみなすこともできます。</p>
なので、Componentとは、

再利用が可能な部品のことですね。</p>
ちなみに、このようなCompoent設計には、

Atomic Designという有名な思想がありますので、</strong>

興味がある方は調べてみてください。</strong></p>
mount</h4>
さて、createAppに戻りますが、

createAppに渡しているのは、コンポーネント(App.vue)ですね。</p>
コンポネントは、他のコンポーネントを子要素として保持できるのですが、

App.vueは、そのようなルートコンポネントの役割を果たしています。</p>
そのため、この場合、

デフォルトで作成されている、

App.vueがルートコンポーネントになります。</p>
<</span>script setup lang</span>=</span>"ts"</span>></span></span>
import</span> { RouterLink, RouterView }</span> from</span> 'vue-router'</span></span>
import</span> HelloWorld</span> from</span> './components/HelloWorld.vue'</span></span>
</</span>script</span>></span></span>
</span>
<</span>template</span>></span></span>
  <</span>header</span>></span></span>
    <</span>img alt</span>=</span>"Vue logo"</span> class</span>=</span>"logo"</span> src</span>=</span>"@/assets/logo.svg"</span> width</span>=</span>"125"</span> height</span>=</span>"125"</span> /></span></span>
</span>
    <</span>div class</span>=</span>"wrapper"</span>></span></span>
      <</span>HelloWorld msg</span>=</span>"You did it!"</span> /></span></span>
</span>
      <</span>nav</span>></span></span>
        <</span>RouterLink to</span>=</span>"/"</span>></span>Home</span></</span>RouterLink</span>></span></span>
        <</span>RouterLink to</span>=</span>"/about"</span>></span>About</span></</span>RouterLink</span>></span></span>
      </</span>nav</span>></span></span>
    </</span>div</span>></span></span>
  </</span>header</span>></span></span>
</span>
  <</span>RouterView</span> /></span></span>
</</span>template</span>></span></span></code></pre>
Vue.jsの場合、

Compoentは、一つのVueファイルにまとめることが穂とんです。</p>
App.vueの中身を見ますと、この中で、

HelloWorld.vueのコンポーネントがインポートされているので、

これは子コンポーネントになります。</p>
このように、コンポーネントからコンポーネントを呼び出していって、

アプリケーションが構成されていくイメージですね。</p>
ただ、こうした要素を画面にレンダリングするには、</strong>

mount(紐づけのようなイメージ)する必要があります。</strong></p>
app.</span>mount</span>(</span>'#app'</span>)</span></span></code></pre>
#appは、id=appですが、

この要素は、</p>
<!</span>DOCTYPE</span> html</span>></span></span>
<</span>html</span> lang</span>=</span>"en"</span>></span></span>
  <</span>head</span>></span></span>
  　中略</span></span>
  </</span>head</span>></span></span>
  <</span>body</span>></span></span>
    <</span>div</span> id</span>=</span>"app"</span>></</span>div</span>></span></span>
    <</span>script</span> type</span>=</span>"module"</span> src</span>=</span>"/src/main.ts"</span>></</span>script</span>></span></span>
  </</span>body</span>></span></span>
</</span>html</span>></span></span></code></pre>
の<div id="app">の部分にあります。</p>
そのため、この部分にapp.vueのHTMLが

挿入されていくようなイメージですね。</p>
先程説明した、

App.vueとかHelloWorld.vueみたいなコンポネントは、

この<div>タグ内に表示される仕組みになっており、

そのようにレンダリングさせる実装が、mountといった感じです。</p>
つまり、createAppから、最終的に、

#appの部分にmountされるという流れになっている感じです。</p>
テンプレート構文</h3>
テンプレート構文とは、

その内部を、Javascriptのコードにしてくれるものです。</p>
https://ja.vuejs.org/guide/essentials/template-syntax.html</a></p>
ドキュメントにも書かれていますが、

やや説明が難しいですよね。</p>
要は、vueファイルのhtmlの部分に、</p>
<template></span></span>
    <div class="wrapper"></span></span>
      {{/* ここにJavascriptのコードを実行できる */}}</span></span>
    </div></span></span>
</template></span></span></code></pre>
というふうに、

{{/* */}} のマスタッシュ構文というものを使って、

その中にJavaScriptのコードを埋め込むことができます。</p>
ただ、挿入できるのは式に限られるので、

if文とか、変数代入みたいな、文を実行することはできません。</p>
なので、かわりに三項演算子を使います。</p>
{{/* Boolean('test') ? 1 + 3 : 23 * 4 */}}</span></span></code></pre>
このような感じで、JSのコードを入れることができます。

この場合、三項演算子でtrueになるので、

1 + 3で4が表示されます。</p>
JavaScript/TypeScriptの基本文法については、

下記の記事で紹介しているので、

ご参考ください。</p>
[st-card myclass="st-no-shadow" id="21" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
ただ、上記のようなやや複雑な処理を

何でもかんでもテンプレート構文に詰め込むのは、

コードが肥大化してメンテナンス性が下がるので、

あまり良くはありません。</p>
この場合、算出プロパティを使うのがいいでしょう。

算出プロパティについては、こちらの記事で解説しています。</p>
[st-card myclass="st-no-shadow" id="559" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
Vuetifyインストール</h3>
Vuetifyとは、Vue2でのデファクトスタンダードだった、

UIフレームワークのことです。</p>
Vue3の場合、必ずしもVuetifyがデファクトというわけでもなくなりましたが、

使いやすいので、本記事ではVuetifyを採用します。

(※Vue3だとVuetifyのドキュメントは一部整備中だったりするので、</strong>

企業などでの技術選定は慎重になったほうが良いかもしれません</strong>)</p>
導入方法としては、

まず、yarnをインストールします。</p>
npm install --global yarn</span></span></code></pre>
yarnを入れたら、

下記でプロジェクトを作成してくれます。</p>
yarn create vuetify</span></span></code></pre>
https://vuetifyjs.com/en/getting-started/installation/</a></p>
UIフレームワークで、プロジェクトを作成してくれるのは、

なかなかに感動ものですよね。</p>
ただ、おそらく大抵の場合、

既存のVueプロジェクトにインストールすることになると思うので、

実際は、下記のようなコマンドを実行することになるでしょう。</p>
yarn add vuetify@^3.1.11</span></span></code></pre>
導入したら、

あとはmain.tsをvuetifyを入れるよう書き換えます。</p>
import</span> { createApp }</span> from</span> 'vue'</span></span>
import</span> { createPinia }</span> from</span> 'pinia'</span></span>
</span>
import</span> App</span> from</span> './App.vue'</span></span>
import</span> router</span> from</span> './router'</span></span>
</span>
import</span> './assets/main.css'</span></span>
import</span> 'vuetify/styles'</span></span>
import</span> { createVuetify }</span> from</span> 'vuetify'</span></span>
import</span> *</span> as</span> components</span> from</span> 'vuetify/components'</span></span>
import</span> *</span> as</span> directives</span> from</span> 'vuetify/directives'</span></span>
</span>
const</span> vuetify</span> =</span> createVuetify</span>({</span></span>
  components,</span></span>
  directives,</span></span>
})</span></span>
</span>
const</span> app</span> =</span> createApp</span>(App)</span></span>
</span>
app.</span>use</span>(</span>createPinia</span>())</span></span>
app.</span>use</span>(router)</span></span>
app.</span>use</span>(vuetify)</span></span>
</span>
app.</span>mount</span>(</span>'#app'</span>)</span></span></code></pre>
これでvuetifyを使うことができます。</p>
[st-card myclass="st-no-shadow" id="519" label="あわせて読みたい" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
[st-card myclass="st-no-shadow" id="578" label="あわせて読みたい" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
[st-card myclass="st-no-shadow" id="559" label="あわせて読みたい" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
[st-card myclass="st-no-shadow" id="606" label="あわせて読みたい" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
[st-card myclass="st-no-shadow" id="611" label="あわせて読みたい" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
[st-card myclass="st-no-shadow" id="638" label="あわせて読みたい" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>


【Git/Githubを0から使えるレベルまで】概念と基本コマンド解説
2023-03-21T00:00:00+00:00
プログラミングや開発をする際に、

絶対に使用するツールが存在します。</p>
プログラミング言語やエディターとかではありません。</p>
そうGitです。

(あとはDocker</a>とかもありますが、

Gitに比べると必須とまではいかないかなと思います。)</p>
Gitがなければ、

開発は始まりません。

それぐらい、Gitは重要なものです。</p>
しかし、Gitは概念が複雑だったり、

コマンドが多かったりと学習コストが高いことでも有名です。</p>
そこで本記事では、0からGitが最低限実務で使えるレベルになるまでに、

必要なことを完全解説します。</p>
Gitとは？</h2>
さて、まずGitとは？なんでしょうか。</p>
Gitとは、分散型バージョン管理システムと

定義されることが多いですが、

平たく言うと、ファイルの変更履歴とかを管理してくれるものです。</strong></mark></p>
一人で開発しているとあまり問題にならないかもしれませんが、

チームで開発している場合、

誰がどういう変更をしたのかということはすごく重要なことです。</p>
ある変更によって、

サーバーがエラーによってダウンしてしまったりした大変ですよね。

その際の犯人を炙り出して糾弾するために、</s>

その際のどの変更によってダウンしているのかをすばやく解明するために、

Gitで変更を管理することはものすごく大切なことです。</p>
試しにGitを使わないとどうなるとかいうと、

おそらくDropboxとか、Googleドライブのような、

クラウドサービスを使う羽目になると思います。</p>
しかし、こうなると地獄です。

これらの場合だと、まず誰もが変更しやすいという点と、

変更履歴を管理できないということと、

新規メンバーに対して、いちいち細かいファイルの履歴などを

送る必要があることです。</p>
細かいソースコードのバージョンとかを管理するソフトウェア開発で、

上記のやり方は、実質上不可能に近いです。

(本当にあった怖い話として、Dropboxで開発をしている現場も目撃したことあります。)</p>
Gitを使えば、バージョンを適切に管理できますし、

バージョンを戻すこともできます。</p>
誰がどういう修正を加えたかもわかりますし、

新規メンバーは、リポジトリをcloneすればいいだけなので、

不毛なコミュニケーションコストも発生しません。</p>
Gitはソフトウェア開発の女神様なんです。</p>
さて、早速我らが女神のGitを使ってみましょう。</p>
Gitは基本的にはCLIツールで、</p>
git</span> -v</span></span></code></pre>
でバージョンが表示されたらインストールされています。</p>
MacやLinuxとかなら、

何もしなくてもインストールされているかもしれません。</p>
Gitの便利さは、</mark>

筆舌に尽くしがたいものがあり、</mark>

Gitがない開発は考えられないし、</mark>

考えたくもないレベルで重要なツールです。</mark>

(しつこいですね)</p>
私は、一度だけDropboxを使って開発をしている現場に参画したことが

ありましたが、控えめに言って地獄でした。</p>
開発は、膨大なファイルを複数人の変更履歴とかを詳細に管理することができないと、

成り立たないので、Gitなしの開発は、地獄です。

(しつこいですね)</p>
Gitは学習コストがそれなりに高いので、

最初のうちは導入するメリットは感じにくいかもしれませんが、

そのうちGitの便利さを痛感する日が必ずきます。</p>
絶対にいれましょう。</p>
Githubとは？</h2>
GitがCLIツールなのに対し、

Githubは基本的には、Webサービスのことなので、

GUIツールにあたります。</p>
Gitで管理しているローカルのファイルを、

Githubに反映させることで、

ローカル依存をなくし、誰もが同じディレクトリをダウンロードできるようにしてくれます。</p>
具体的には、こんな感じです。</p>
https://github.com/sindresorhus/fast-cli</a></p>
こうしたGithubのリポジトリに、

開発しているアプリケーションをpushして、

他の開発者がpullしたりcloneしたりすることを可能にしているといった感じです。

(pullやcloneなどについては後ほど解説します。)</p>
pushとは、ローカルのファイルをリモート（すなわちGithub）に

反映させることで、

pullとは、リモート（すなわちGithub)のファイルを

ローカルに保存することにあたります。</p>
昨今の開発では、基本的には、

GitとGithubを別々に使って開発するようなことはないので、

両方使うものと思っていただいて問題ないです。</p>
GitLab</h3>
こうしたリモートのGit管理サービスは、

Githubだけではなく、

GitLabというものもあります。</p>
今のところ(執筆時点)は、

まだGithubのほうが使用者が多い印象ですが、

今後はGitLabも増えてくるかと思います。</p>
GitLabとGithubの両者の差異が、

めちゃくちゃあるというわけではないので、

正直どちらを使っても良い気がします。</p>
Gitの基本の流れ</h2>
さて、GitやGithubがどういうものかについては、

解説したので、Git開発での基本の流れについて

解説していきたいと思います。</p>
Gitを使うにあたって、いくつかの用語が存在するので、

まずはそれを解説していきます。</p>
リポジトリ</h3>
これは、Gitにおいては、基本的にはアプリケーションそのもので、

アプリケーションを起動するのに必要なすべてのファイルを集約した</mark>

単位のような感じです。</mark></p>
基本的に、下記のリンクにあるような

ファイルの集合体みたいなもの（アプリケーションに必要なファイル）を

Githubに登録しておく感じです。</p>
https://github.com/sindresorhus/fast-cli</a></p>
上記のようなものを一般に、

リポジトリと呼びます。</p>
リポジトリをクローンとかって言いますが、

これは、中央のアプリケーションを持ってきて、

開発に参画するための最初のステップです。</p>
クローン</h3>
さて、上記のリポジトリがあったら、

それをローカルに保存したいと思います。</p>
その際、クローンという作業を行います。

これによって、ローカルにGithubのリポジトリと同じファイルを

持ってくることができます。</p>
平たく言うと、複製ですね。</p>
開発(修正など）</h3>
さて、そうしたクローンしたリポジトリになにか変更を加えるとします。

新規機能を追加したり、バグを直したりと。</p>
そうして修正を完了したら、

その修正したやつをリモートのリポジトリにも反映させたいですよね。</p>
そこで、次はpushというのを行って、

ローカルの内容をリモートに反映させます。</p>
これで、リモートの内容が最新になりました。</p>
ややはしょってはいますが、

Git・Githubを使った基本的な開発の流れはこのような感じです。</p>
以上を踏まえて、

具体的に使うコマンドを見てみましょう。</p>
Gitのコマンド</h2>
GitはCLIツールなので、

コマンドが色々あります。</p>
全ては紹介しませんが、

よく使う基本的なものを紹介していきます。</p>
add</h3>
いきなり混乱することを言って恐縮ですが、

pushをする前に、addとcommitをする必要があります。</p>
commitは平たく言うと、

修正した差分をセーブするような感じですね。

commitしないと、どこが変更されたのかを

gitは管理できていないので、

pushしたところで何も変わらないといった感じです。</p>
そして、Gitの場合、

commitをする前に、

このaddという操作をすることが多いです。</p>
これは、ファイルをインデックスに追加する操作です。</strong></p>
https://git-scm.com/docs/git-add/ja</a></p>
とはいっても、この説明だけで

「うんなるほど」って分かる人は、

そんないないと思います。</p>
そもそもGitには、commit前にファイルを置いておくようなモードがあって、

ステージング</strong>って言われることも多いです。</p>
まあ、正確にはファイルを置くモードというよりは、

commitするファイルを登録して、

なんでもかんでもcommitできないようにしているといった感じです。</p>
このgit addしたファイルは、

インデックスに追加されているので、

commitができるようになります。</p>
インデックスに追加されていなければ、

そもそもcommitができない感じですね。</p>
なんで、こんなめんどくさい感じになっているのかというと、

そもそもcommit自体が、ある意味修正の歴史みたいな感じになるので、

同じcommitに含めるのがふさわしくないものが差分に出るかもしれません。</p>
その際、commitに入れる差分と入れない差分を選り分けることが可能なように、

このステージングみたいな、commitの前のモードが存在する感じですね。</p>
まあ、最初のうちは、

よくわかんないと思うので、

とりあえず、**「commit前にaddしないとな！」**って

覚えておけば概ね大丈夫です。</p>
実際、使用する際も、</p>
git</span> add test.txt</span></span></code></pre>
みたいに特定のファイルだけをaddするという使い方よりも、</p>
git</span> add .</span></span></code></pre>
というようにカレントをすべてaddするという

ガバガバな使い方をすることがほとんどです。</p>
addの仕組みがよくわからなければ、

とりあえずcommit前にgit add . ってするんだなぐらいの

理解でも一旦大丈夫です。</p>
commit</h3>
既にaddのところでも、

commitについて簡単に言及しましたが、

commitは、平たく言えばセーブです。</strong></p>
ポケモンとかで、

セーブするみたいなやつあったと思いますが、

まあ、あれです。（概ねあってるはず...w)</p>
Gitは分散型バージョン管理システムと

言いましたが、このcommitはまさに、</mark>

管理しているGitに新しい歴史（修正）を</mark>

刻むような感じです。</mark></p>
すなわち、Gitとは、

この歴史の積み重ね、

commitの積み重ねを管理しているシステム</strong>といっても

過言ではないでしょう。</p>
https://git-scm.com/docs/git-commit</a></p>
そのため、安易にコミットしてしまうと、

現状のリポジトリに新しい歴史を刻んでしまうも

同然なので、よく考えてcommitする必要があります(特大ブーメラン）</p>
コミットには、基本的に

コミットメッセージをつけますが、

やり方としては、</p>
git</span> commit</span> -m</span> "first commit"</span></span></code></pre>
みたいに、-mオプションつけてやるのが

多いでしょう。</p>
このメッセージは、

git logとかでも確認できますし、

pushしたGithubとかでもチェックできます。</p>
他の開発者が、

そのcommitでどういう修正をしたのかが、

簡単にわかるようにできると理想ですね。</p>
ちなみに、このコミットメッセージの付け方や、

commitの単位の切り方とかで、

エンジニアのレベル感を見破られてしまうことがあるので、

気をつけましょう...

（よくない例としては、"Rspecインストール"というコミットメッセージなのに、

実際の修正内容は、FactorybotのインストールでRspecのインストールは別コミットに

なってしまっていたりとかですかね。）</p>
間違っても、</p>
git</span> commit</span> -m</span> "疲れたから一旦commit"</span></span></code></pre>
みたいなコミットメッセージはやめましょう。

恥を刻んでしまいます。（ギャグならいいですが）</p>
あと、理想なら英語でcomitメッセージを書くのがいいですが、

なんだかんだ日本語で書いている現場が多いので、

プロジェクトに合わせれば問題ないと思います。

（みんな日本語で書いているのに英語で書いても

浮く気がするので...)</p>
push</h3>
pushは、CLIのgitのみでは、

使わないコマンドですね。</p>
これは、リモートのGithubに、

ローカルのGitのcommit履歴とかを反映させます。</strong></p>
いくら、ローカルでずっとgit commitしていても、

リモートに反映できなかれば、

他の開発者はその変更を取り込むことができませんからね。</p>
使い方としては、</p>
git</span> push origin main</span></span></code></pre>
みたいな感じですね。</p>
ちなみに、-fオプションは、強制的に

pushするオプションですが、

他の開発者にも影響を与えるリモートのリポジトリを

強制的に書き換えてしまう力技のコマンドなので、

使うときは慎重になりましょう。</p>
下手すると、他の開発者のcommitが消し飛びます...</p>
まあ、rebaseとかでcommitを書き換えたりしたとき以外は、

使うべきではありませんね。rebaseの際も、

他に影響がないか十分考慮してから行うべきです。</p>
pull</h3>
ずっと、ローカルで開発している最中に、

ほかの開発者がリモートにcommitをしたとします。</p>
そうすると、リモートは新しくなっているのに対し、

自分のローカルは古いままという状態になります。</p>
こういった際、リモートの最新の状態を取り込むことができるコマンドが、

このpullです。</p>
branch</h3>
Gitには、ブランチという概念があります。</p>
詳しくは、こちらのドキュメントにも書かれていますが、

平たく言えば、作業領域のことです。</p>
https://git-scm.com/book/ja/v2/Git-%E3%81%AE%E3%83%96%E3%83%A9%E3%83%B3%E3%83%81%E6%A9%9F%E8%83%BD-%E3%83%96%E3%83%A9%E3%83%B3%E3%83%81%E3%81%A8%E3%81%AF</a></p>
gitでは、デフォルトで、

mainやmasterというブランチが存在しますが、

基本的にこのブランチで開発をすることはほとんどありません。</p>
なぜなら、仮にmasterで作業し続けてしまうと、

なにか致命的なバグとかが起きた際、

本番を別のブランチ（バグが起きていないブランチ）に戻すということが

できなくなり、サービスが止まってしまうことになりかねないからです。</p>
仮にブランチを分けて開発を進め、

masterには、バグがない状態をキープして、

最新機能の開発とかは、別のブランチで行っていけば、

仮に別のブランチでバグが起きてもmasterには影響を与えません。</p>
つまり、ブランチを分けることは、

Gitのバージョン管理システムを最大に活かすことであり、

ブランチを分けなければ、実質的にはバージョンを管理できていないようなものです。</p>
masterのような、デフォルトのブランチをずっと使っていると、

他の開発者のコミットが即座に反映されてしまうため、

PRなどを挟むこともできなくなります。</p>
そのため、基本的に

ブランチを切って開発することは必須です。</p>
さて、ブランチの重要性はそんな感じですが、

例えば、何かをインストールするという修正を加えたい場合は、</p>
git</span> checkout</span> -b</span> feature/install-something</span></span></code></pre>
というふうに新しいブランチを作成して、

そこで作業するのが一般的です。</p>
この場合、feature/install-somethingというのがブランチ名です。</p>
そして、ブランチを切って、

リモートにpushするときは、</p>
git</span> push origin feature/install-something</span></span></code></pre>
とブランチ名を指定してpushします。</p>
log</h3>
これは、文字通り、commitの履歴を確認できるコマンドです。</p>
git log</span></span></code></pre>
こちらもよく使う。</p>
git</span> log</span> --oneline</span></span></code></pre>
ちなみにログに関しては、

本記事の後半で紹介する、

lazygitを使うと便利です。</p>
status</h3>
これも、文字通り、現在のgitの状態を確認できるコマンドで、

commitしてないファイルやインデックスされていないファイル、

現在のブランチなどを表示してくれる。</p>
git</span> status</span></span></code></pre>
Linuxのlsコマンドと似たような感じで、

心を一旦落ち着かせたいときに打ったりするコマンドでもある。</p>
clone</h3>
cloneは、Githubのリポジトリのコードを

ローカルに持ってくることができるコマンドである。</p>
新しくチーム開発に加わった際など、

最初に行うのは、このコマンドで、

コードを自分のローカルに持ってくることだろう。</p>
cloneとかする際、

ssh経由でcloneすることがほとんどなので、

後にSSHの設定についても紹介したい。</p>
Git便利ツール</h3>
以上のように、

Gitには、様々なコマンドがあるので、

いちいち打つのが大変なときもあります。</p>
そこで、個人的には、

LazygitというCLIツールがおすすめです。</p>
https://github.com/jesseduffield/lazygit</a></p>


  </iframe>
</div>
上記の動画のような、

視覚的なGit操作を可能にしてくれるので、

いちいち個別のコマンドを打つ必要がなくなります。</p>
</p>
機能が多く、

最初は使いこなすのが大変ですが、

なれると便利なので、試してみてください。</p>
SSH設定</h2>
最後にGitのSSH設定について

触れます。</p>
Gitのpushとかpullなどをする際に、

SSH設定をしておいたほうが便利なケースが多いので、

紹介します。</p>
まずは、sshキーを作ります</p>
ssh-keygen</span></span></code></pre>
次に、作成したsshキーを

クリップボードにコピーします。</p>
macとかなら、pbcopyコマンドが使えます。</p>
pbcopy</span> <</span> ~/.ssh/id_rsa.pub</span></span></code></pre>
あとは、Githubの設定で

sshキーの項目にこれを追加します。</p>
追加したら、</p>
ssh</span> -T</span> git@github.com</span></span></code></pre>
を実行して、Hiと返ってくれば問題ない。</p>
これでgit remote addとかする際、

sshの方を使えます。</p>
git</span> remote add origin git@github.com:example/test.git</span></span></code></pre>
cloneする際は、</p>
git</span> clone git@github.com:sindresorhus/fast-cli.git</span></span></code></pre>
という風に、sshの方でcloneします。</p>


Linux便利コマンド8選 zoxide/bat/exa/fzfなど
2023-03-21T00:00:00+00:00
いつもcdとかcatのように、

お決まりのコマンドを使うと思いますが、

最近だと、こういったコマンドの強化版みたいなやつも熱いので紹介します。</p>
本記事の内容は、</strong>

下記動画でもご紹介したので、</strong>

実際のハンズオンを視聴したい方は、</strong>

併せてご参考ください。</strong></p>


  </iframe>
</div>
Linuxコマンド</h2>
さて、これらの便利コマンドを紹介する前に、

そもそものLinuxの基本コマンドに自信が無い方は、

こちらの記事</a>で詳しく解説しているので、

ご参考ください。</p>
[st-card myclass="st-no-shadow" id="64" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
さて、本記事でご紹介する、

便利コマンドは、多くがRust製というのも

特徴の一つです。</p>
Rust製のツールは、

優秀なものが多く、いつも感動を与えてくれます。

(ターミナルのAlacrittyとかはRust製ですよね。

ターミナルのおすすめ記事はこちら</a>)</p>
以下、順番に紹介していきます。</p>
zoxide</h3>
まずは、zoxideです。</p>
これは、cdの完全上位互換のコマンドで

個人的にはこれは入れないと仕事できないレベルです。</strong></p>
https://github.com/ajeetdsouza/zoxide</a></p>
これに関しては、何も考えずに</mark>

インストールしたら幸せになれます。(例外はありません)</mark></p>
それくらい優秀なコマンドですので、

早速インストールしましょう。</p>
Macなら、いつもどおり、</p>
brew</span> install zoxide</span></span></code></pre>
でインストールできる。

基本的には、公式にインストール手順はすべて書いてあります。</p>
https://github.com/ajeetdsouza/zoxide</a></p>
あとは、シェルごとにパスを通す必要がありそうですね。

zshなら、.zshrcに</p>
eval</span> "$(</span>zoxide</span> init zsh)"</span></span></code></pre>
を追記します。</p>
公式にfzfのインストールも推奨しているので、

このタイミングで入れるのもありです。

(ちなみに、fzfは本記事の後半で個別紹介します。)</p>
brew</span> install fzf</span></span></code></pre>
これでziコマンドが使えるようになります。</p>
ziコマンドは、死ぬほど便利で、

zコマンドとかで行ったディレクトリパスとかを検索して移動できます。</p>
私は、zoxideを入れる前は、

.zshrcとかに、頻繁に行くディレクトリに関しては、

aliasを設定していたのですが、

zoxideがあれば、そんなalias設定もほとんど不要になります。</p>
一度行ったディレクトリは、

ziで検索しながら移動できるので、

これは本当に本当に便利です。</p>
階層が深いディレクトリの行き来も

これがあれば一瞬ですね。</p>
bat</h3>
お次は、batです。</p>
これは、Catコマンドの強化版で、</mark>

Syntaxハイライトと、gitのstatusとかを出力してくれます。</mark></p>
https://github.com/sharkdp/bat</a></p>
</p>
こちらもいつもどおり、</p>
brew</span> install bat</span></span></code></pre>
でインストールできます。</p>
これは、たしかに文句無しで便利なのですが、

正直使うシチュエーションはあまり多くない印象です。</p>
普段からcatを頻繁に使うという人であれば、

嬉しいかもしれませんが、なんだかんだでcatってそんなに使わないコマンドだと

思うので、catの上位互換だとしても、

そのパワーを発揮できないことのほうが多い印象です(あくまで私基準の話)</p>
エディターがcatの人</a>は、

batを死ぬほど使い倒せると思います。</p>
exa</h3>
こちらは、lsの強化コマンド</mark>

ディレクトリとかを色付きで表示してくれます。</mark></p>
https://github.com/ogham/exa</a></p>
こちらもいつもどおり</p>
brew install exa</span></span></code></pre>
でインストールできます。</p>
このコマンドも文句なしに便利です。

しかし、これはいつもインストールしたことを忘れてしまうコマンド

個人的第一位です。</p>
というのも、Linuxコマンドにおいて、

lsの存在感はでかすぎて、

脳死モードだと、基本lsを打っています。</p>
そして、lsのやっかいなところは、

心を鎮めるためにとりあえずlsを打つということもある、

ある種の鎮痛コマンドなので、

なかなかlsからexaに移行できないのが私です。</p>
もう、lsのaliasにexaを設定してしまうのもありかもしれませんが、

個人的には、かの偉大なるlsを消してしまうことは、

あまりしたくありません。</p>
なので、exaは、便利ではありますが、

lsが強すぎて、まだ移行しづらいコマンドかなと思います(あくまで私基準の話です)</p>
procs</h3>
こちらはpsコマンドの上位互換。

色付きで表示してくれたりと、

見やすく表示してくれます。</p>
https://github.com/dalance/procs</a></p>
これも</p>
brew install procs</span></span></code></pre>
でインストールできます。(いい加減くどいですね)</p>
これも確かに便利かとは思うのですが、

正直あんま使わない...笑</p>
ただ、現職がサーバーエンジニアの方とか、

プロセス監視をメインでやるような方なら、

かなりの便利コマンドかと思うので、

紹介しました。</p>
あくまで私環境の話ですが、

procsコマンドは若干重い気がするので、

もしかすると、無難にpsとかのほうが、

いい場合もあるかもしれません。</p>
psとprocsで使い分けられるといいですね。</p>
htop</h3>
こちらは、topコマンドの表示を見やすくしてくれるものです。

非Rust製です。この系のコマンドは、htop以外にもたくさんあるので、

好きなやつを見つけてほしいなと思います。</p>
htopの公式を見ると、

インストール方法がやや煩雑に思えますが、</p>
macなら、</p>
brew</span> install htop</span></span></code></pre>
でインストールできてしまう。

結局いつも通りでした。</p>
改めて、Homebrewは偉大ですね。</p>
https://github.com/htop-dev/htop</a></p>
htopコマンドに慣れると、

普通のtopコマンドに戻れなくなると思うので、

普段からtopコマンドを頻繁に使う人には、

おすすめできます。</p>
まあでも、topコマンドって、

使いそうで、意外と使わないコマンドの代表例なので、

インフラエンジニアとかでないとそこまで

お世話になる機会は少ないかもしれませんが。</p>
pastel</h3>
こちらは、色の操作ができるコマンドです。</strong>

やや他のコマンドとは毛色が違うので紹介しました。</p>
使い所は、若干難しいが、

CSSとかを書く際の参考になるかなと思います。</p>
</p>
https://github.com/sharkdp/pastel</a></p>
色の一覧っぽいのを出すときは、</p>
pastel list</span></span></code></pre>
で出てきます。</p>
ちなみに、色を選ぶこともできるみたいで、

これを使うと、カラーコードがよくわかんなくても、

視覚的にいい感じの色のカラーコードを調べたりすることができます。</p>
 pastel pick</span></span></code></pre>
どちらかというと、

デザイナー向けのツールなので、

どの程度の人に刺さるかわかりませんが、

少なくともCSSを書くエンジニアには、

まあまあ役に立つコマンドかなと思います。</p>
fzf</h3>
こちらは、zoxideのところで

すでにインストールされている方は、

もう入っていると思います。</p>
これは、あいまい検索ができるツールで、</p>
find</span> .</span> |</span> fzf</span></span></code></pre>
とfindの結果をパイプにしたり、

fzfのpreview機能を使って、</p>
fzf</span> --preview</span> 'head -100 {}'</span></span></code></pre>
みたいにして、先頭100行を</mark>

プレビューしながら検索みたいなことができます。</mark></p>
すでに紹介したbatコマンドと組み合わせると、</p>
fzf</span> --preview</span> "bat  --color=always --style=header,grid --line-range :100 {}"</span></span></code></pre>
これは、alias設定するとめちゃくちゃ便利そうですね。</p>
https://github.com/junegunn/fzf</a></p>
fzfは、Vimのプラグイン周り</a>でも

結構お目にかかるCLIツールなので、

知っている方も多いかもしれませんが、

意外と、単体でターミナルで実行したことは無いかなと思い、

紹介しました。</p>
Neovimを使っていると、

telescope.nvimみたいなぶっ壊れプラグインを使うことが

できるので、上記のような死ぬほど便利なコマンドを

使わずとも似たようなことができてしまうのが、

やっぱNeovimの強みですね。</p>
[st-card myclass="st-no-shadow" id="133" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
fast-cli</h3>
最後にちょっとした面白ツールを紹介します。

非Rust製です。</p>
https://github.com/sindresorhus/fast-cli</a></p>
これはCLIツールとしては、

珍しくnpm経由でインストールするようです。

(JavaScript製なので、当然っちゃ当然かもしれませんが)</p>
npm install --global fast-cli</span></span></code></pre>
npmを入れていない人は、

こちらの記事</a>で環境構築について、

解説しているので、よろしければご参考ください。[st-card myclass="st-no-shadow" id="13" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
このツールは何かというと、

光回線とか、ネットワークの速度を測るツールです。</p>
いやここ見れば</a>解決やんって野暮なことは言わないでください。</p>
誰だって、CLIで実行したくなることはあるんですから。</p>


【Mac初期設定完全版】Webエンジニアが最初に導入するアプリや設定を公開
2023-03-19T00:00:00+00:00
Macbookの初期設定</h2>
Macbookを買ったり、初期化した際、

デフォルトのままだと何かと使いにくいと思ったことは無いでしょうか？</p>
下にうざいDockはあるし、

カーソルはめっさ遅いし、

変なアプリはたくさん入っているしと...</p>
なので、インストールするべきアプリとか、

やっておきたい設定とか色々あるかと思います。</p>
ただ、お約束なのが、その設定を毎度忘れてしまうことです。</p>
なので、今度こそ忘れても大丈夫なように</strong>

備忘録がてら、私の設定を公開しようと思います。</strong></p>
Macを使う人は、よろしければ

ご参考ください。</p>
インストールするアプリ</h2>
まずは、インストールするアプリを整理します。</p>
インストールするアプリって、その人の好みがめちゃくちゃ出ますよね。

私は、他人の設定とか、インストールしているアプリがめちゃくちゃ気になるタイプです。</p>
以下は、私がインストールするアプリです。

皆さんの環境と比べてみて、

「俺だったらこれはインストールしない」とか

「これも追加で入れる」とか色々あったら、

X(旧Twitter)とか、コメントで教えてください。</mark></p>
 </mark></p>
ちなみに、私のX(旧Twitter)アカウントは下記になります。</mark></p>
X (Twitter) のアカウントを見る</a></p>
ブラウザ</h3>
まず最初はブラウザです。</p>
いきなり宗教戦争の香りがしてきましたね。</p>
ブラウザは、その人の信条がはっきり出るので、

私は他の人がどういうブラウザを使っているのか、

聞いたりするのが結構好きです。</p>
まあ、そうはいいつつも、

ストレージに余裕があるなら、

有名どころのブラウザはインストールしておいても損はないでしょう。</strong></p>
エンジニアの場合、

ブラウザの互換性とかをチェックしたりすることもありますからね。</p>
具体的には、</p>

</blockquote>

Chrome</li>
Edge</li>
Firefox</li>
Brave</li>
Vivaldi</li>
Sidekick</li>
Opera</li>
</ul>
このあたりですかね？</p>
皆さんは、どれを使っていますか？

まさかChromeだなんてことは無いでしょうね？(煽るスタイル)</p>
Chromeは、素晴らしいブラウザですが、

個人的には、みんなが使っているというメリットしか無いと思います(異論は認める)</p>
詳細は下記のYoutube動画でも

語っているので、暇な人は観てやってください。</p>


  </iframe>
</div>
ブラウザは、宗教戦争になりやすいので、

「こいつは何もわかってない。けしからん」と息巻いて、

アンチコメントするのはやめてください。(なんだかんだで傷ついてますよ)

温かい目で見守ってください。</p>
さて、脱線しましたが、

個人的には、厳選してインストールするなら、</p>

</blockquote>

Firefox</li>
Vivaldi</li>
Brave</li>
Edge</li>
</ul>
の4つですかね。</p>
Firefox</h4>
まず、Firefoxについては、

昨今では、珍しい非Chromium製だということですかね。</p>
あとは、OSSというのも個人的には好きなのですが、

Firefoxでしか使えない、アドオンのツリー型タブ</mark>というやつが、

優秀すぎるというのもあります。</p>
https://addons.mozilla.org/ja/firefox/addon/tree-style-tab/</a></p>
こいつは本当に優秀で、

なんだかんだで他の縦型タブは、まだこいつを超えていないと思っています。</p>
あと、地味にFirefoxは、jsonのアドオンとか入れなくても、

いい感じにjsonを出力してくれるというメリットもあります。</p>
デメリットとしては、良くも悪くも非Chromiumなので、

微妙に勝手が違ったり、あとは一部サービスでは、

対応されていなかったりという、ユーザー数が少ないことによる、

デメリットは正直あります。</p>
著名な例だと、

PayPay銀行がサポート終了していましたね。</p>
https://www.paypay-bank.co.jp/news/2022/0307.html</a></p>
Firefoxが好きな私からしたら、

なんともやりきれないニュースですが、

これが現実なんですね...</p>
一昔前であれば、

メインブラウザはFirefoxでしたが、

今だと、メインブラウザにするのはちょっと難しそうですね。</p>
Vivaldi</h4>
2つ目は、Vivaldiですね。</p>
こいつは、そこまで有名なブラウザでもないですが、

カスタマイズ製が非常に高いことで有名</strong>で、

ありとあらゆるショットカットキーなどを設定できて、

楽しいです。</p>
私はメインブラウザにはしていませんが、

今のメインブラウザに飽きたら、

こちらに移行しようかなとぼんやり考えています。</p>
デメリットとしては、あくまで私の感覚ベースでしかありませんが、

ややもっさりしていたり、動作が重たい印象があります。</p>
今は改善されているのかもしれませんが、

めちゃくちゃサクサク動くブラウザというわけではないかなと思います。</p>
</p>
Brave</h4>
3つ目は、Braveです。

現在の私のメインブラウザです。</p>
こいつの魅力は何と言っても、

デフォルト広告ブロック</mark>にあり、

adblookのような拡張機能が不要になることです。</p>
また、広告を表示して、</strong>

仮想通貨のBATを稼ぐこともできるブラウザ</strong>で、

なんともわくわくさせてくれますよね。</p>
ちょっと前までは、これ以外は対してメリットがなかったのですが、

最近、縦型タブに対応しました。</mark></p>
この縦型タブは、Firefoxのツリー型タブほどの機能性はありませんが、

Chromeの拡張機能にあるような、縦型タブとかよりは、

何百倍も実用的で使いやすい、素晴らしいものでした。</p>
私はこれが搭載された、迷わずメインブラウザにしました。</p>
縦型タブがある前は、Edgeをメインブラウザにしていましたが、

Braveにも縦型タブがある以上、Edgeのメリットは霞んでしまったので、

Braveをメインブラウザに移行しましたね。</p>
Edge</h4>
Edgeの縦型タブも大変優秀で使いやすいです。</p>
Braveのデメリットは、

たまに広告ブロックが強すぎて、

サイトの挙動を変えてしまったりする点ですね。</p>
最近だと、Amazonとかの挙動が相性悪く、

カートに商品を追加する機能で、

だいたいエラーが起きます。</p>
こういうときは、Edgeに頼っています。</p>
私の場合、

メインブラウザはBrave、

サブブラウザはEdgeという感じで運用しています。</p>
Edgeは、Chromeに匹敵するぐらいユーザー数が多いという</strong>

絶大なメリットがあるので、</strong>

サポートされていないということは基本無いという安心感があります。</strong></p>
開発系</h3>
次に、開発系のツールをご紹介します。</p>
ターミナルや、VimとかTmuxといった、

Cliツールなど、エンジニアの仕事道具ですね。</p>
iTerm2</h4>
エンジニアがまず初めに入れるアプリは、

やはりターミナルでしょう。</p>
Macだったら、iTerm2で良いかなと思います。</p>
ちなみに、ターミナルの比較考察とか、

おすすめは下記の記事でも紹介しているので、

ターミナルにこだわりたい人は、下記の記事もご参考ください。</p>
[st-card myclass="st-no-shadow" id="11" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
iTerm2で、やっておきたい設定があります。

まずは、Hotkey</strong>の設定です。</p>
PreferencesのKeysのHotkeyで、

Show/hide all windows with a system-wide hotkeyで、

好きなキーを設定できます。</p>
私はいつも、Ctrl + ; に設定しています。</p>
</p>
これ以外と、

普通じゃんって思われるかもしれませんが、

意外と他のターミナルって、この機能サポートしていないんですよね...</p>
仮にサポートしていても、

うまく呼び出せなかったり、

出現する感じが微妙だったりで、

なかなかiTerm2ほどストレスなく表示・非表示を切り替えられるターミナルは、

多くない印象です。</p>
なので、Macを使うなら、

なんだかんだでiTerm2がベストなんじゃないかなと思います。</p>
DockerデスクトップとOrbStack</h4>
お次は、Docker関係ですね。</p>
こちらも言わずもがな。

インストールしたくなくてもインストールさせられるし、

実際必要なアプリでしょう。</p>
ただ、最近はDockerデスクトップよりも、

OrbStackのようなDockerデスクトップの代替アプリ</mark>のようなものもあるので、

もしかすると、こちらの方がいいかもしれません。</p>
https://orbstack.dev/</a></p>
Dockerデスクトップは、

なんだかんだで重かったり、もっさりしていたり、

クラッシュすることもあるので、

結構restartすることも多いんですよね。</p>
もしかすると、今後はDockerデスクトップは

廃れていってOrbStackのようなもののほうが、

主流になっていくかもしれませんね。</p>
CLIアプリ</h3>
次は、CLIアプリです。</p>
私のブログにも、CLIツールというものがあるように、

この領域でも最初にインストールしたものはたくさんあるので、

順に紹介していきたいと思います。</p>
Homebrew</h4>
これを入れないと何も始まりません。

MacやLinuxのパッケージマネージャーです。</p>
https://brew.sh</a></p>
上記のサイトにあるコマンドを実行すれば、

インストールできるはずです。</p>
/bin/bash</span> -c</span> "$(</span>curl</span> -fsSL</span> https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"</span></span></code></pre>
これで、brew install neovimとかみたいな

コマンドが使えるようになりますね。</p>
余談ですが、M1とかの場合、ターミナルを開く際に、

get infoからRosettaを開くを有効にする必要があるようです。</p>
相変わらずめんどくさいM系チップですね。</p>
</p>
VimやNeovim</h4>
もちろん、いれますね。

私のブログやYoutubeでは、</mark>

VimやNeovimの動画をたくさんあげているので、</mark>

もちろん、これらも環境構築します。</mark></p>
Vimのインストールは、

こちらの記事で紹介しているので、

詳しくはこちらをご参考ください。</p>
[st-card myclass="st-no-shadow" id="11" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
Vimの設定ファイルの、

設定例は、こちらの記事が参考になるかなと思います。</p>
[st-card myclass="st-no-shadow" id="172" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
Tmux</h4>
これも個人的には必須のアプリです。

詳しくは下記の記事をご参考ください。</p>
[st-card myclass="st-no-shadow" id="143" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
oh-my-zsh</h4>
まあ、これは入れなくても

いいかもしれないが、個人的には割と入れたいやつです。</p>
シェルを見やすくいい感じにしてくれます。</p>
https://ohmyz.sh/#install</a></p>
sh</span> -c</span> "$(</span>curl</span> -fsSL</span> https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh)"</span></span></code></pre>
公式にある、上記のようなコマンドを実行すれば

インストールできます。

.zshrcファイルが書き換わるので、

.zshrcファイルの編集をする前に、

インストールするのがおすすめ。</p>
Git</h4>
これも必須ですね。</p>
MacとかLinuxはGitは最初から入っているだろうから、

インストールはしなくてもいいかもしれません。</p>
まずは、ssh設定から行います。</p>
詳細はこちらの記事を御覧ください。

https://qiita.com/reisuta/items/e5dd787bc43b79e1a51b</a></p>
Git自体の使い方は、下記の記事をご参考ください。</p>
[st-card myclass="st-no-shadow" id="179" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
Zoxide</h4>
これは、cdの上位互換コマンドで、

ディレクトリ間の行き来を楽にしてくれます。</p>
このような便利コマンドについては、

下記の記事で詳しく解説しているので、

こちらをご参考ください</p>
[st-card myclass="st-no-shadow" id="156" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
動画編集系</h3>
お次は動画編集系をご紹介します。</p>
エンジニアとしては、必須ではありませんが、

私のようにYoutubeもやっている人は、

必要になってきます。</p>
デフォルトでインストールされている、

iMovieも使いやすいことは使いやすいですが、

やたらとストレージを食うので、

長期的に使うには向いていないです。</p>
また、編集自体も簡単なものしかできません。</p>
DaVinci Resolve</h4>
既に少し触れましたが、MacだとiMovieというそこそこ使えるアプリが入っています。</p>
しかし、Macでしか使えないという点は、Windowsとかに移行するときのネックになるので、

できればクロスプラットフォーム対応のものを使いたいなと思います。</p>
仮にiMovieがめちゃくちゃ優秀なアプリなら、

使う理由はあると思いますが、

iMovieは、クロスプラットフォーム対応を犠牲にしてまで優秀なアプリとは

言い難いかなと思います。（個人的には）</p>
そこで、DaVinci Resolveが、</strong>

個人的には良いなと思います。</strong></p>
これは、クロスプラットフォームだということと、

基本的に無料で使用できること、

プロの現場でも使用されており、

クオリティーの高い編集が可能なことなど、

様々なメリットがあります。</p>
動画編集系では、まっさきにインストールします。</p>
OBS Studio</h4>
こちらは、録画アプリで、

個人的には使いやすいなと感じています。</p>
私も、Youtube動画を作るときは、

OBS Studioを使っています。</p>
業務効率化系</h3>
次に業務効率化系のアプリを紹介したいと思います。</p>
あんまり、エンジニアだからっていうアプリは少ないですが、

こういうアプリの便利さも結構馬鹿にできません。</p>
Rectangle</h4>
Windowsとかだと、

何もしなくても、Windowsキー + 矢印キーで、

画面を最大化したり左右に分けたりできるが、

Macだとできないんですよね。</p>
なので、できるようにするために、

Rectangle</strong>というアプリを入れると解決します。</p>
これは、Ctrl + Enterとかで画面を最大化したり、

commadn + shift + →で右によせたりといった操作が簡単にできるようになるので、

地味に便利ですし、私はこれがないと困ります。</p>
Alfred</h4>
有名ですね。そして、これも必須ですね。

Macを使っていてAlfredを入れていない人は、</strong>

全員入れてほしいレベルで、優秀なアプリです。</strong></p>
Alfredをつかっていない人は、

人生損していると言っても過言ではありません(異論は認めません)</p>
Macのデフォルトのランチャーアプリは、

Spotlightですが、物足りません。</p>
Spotlightで頑張れないこともないですが、

Alfredと比べたら、コイキングとレックウザぐらい違います。</p>
Alfredの魅力は、iTerm2のようなホットキーでいつでもランチャーを呼び出して、

アプリを開くのはもちろん、クリップボード(有料)、

PC制御(sleepなど)、ブックマーク検索など、

様々な機能があります。</p>
正直私もすべての機能を使いこなせているわけではありません。</p>
やはり、Macを使うのであれば、

Alfred</strong>という偉大なアプリを使わなければもったいないと思います。</p>
Karabiner-Elements</h4>
あの宇宙一鬱陶しいキー</mark>

Caps lockを野放しにするわけにはいきません。</mark></p>
 </mark></p>
Caps lockを追放するために、</mark>

我々は今、立ち上がらなければなりません。</mark></p>
その際、役に立つのが、このアプリです。

Karabiner-Elementsです。</p>
これで、好きなキーに変更できます。</p>
デフォルトだと、

プライバシー設定とかを色々許可してあげないと有効にならないので、

許可してあげましょう。</p>
それにしても、

Caps lockって誰得なんでしょう。

使う人いるんでしょうか。</p>
Macの設定</h2>
次は、Macの設定周りに移って行きたいと思います。</p>
トラックパッド</h3>
とりあえず、トラッキングスピードはMaxにします。

デフォルトのスピードは、お前やる気あんのか？っていうぐらい

遅いのでやってられません。</p>
</p>
Dock</h3>
Macのデフォルトだと、

あの宇宙一鬱陶しいDockがついてきます。</p>
Dockが下に並んでいると、

「俺Mac使っているぜ」感出ますが、

そんな幼い時代は、もう私は卒業しました。</p>
Dockがあっても殺意がわくだけです。</p>
</p>
Dockほんといらない</em></p>
Macの仕様では、

このDockを無効化すること自体は

できないみたいです。（誰得なのこれ？）</p>
なので、できるだけ表示させないようにします。</p>
Sizeを一番小さくし、

Automatically hide and show the Dockを有効にします。</p>
</p>
スクリーンショット関係</h3>
次にスクリーンショット関係の設定をいじります。</p>
保存先を変える</h4>
GUIの場合、

cmd + shift + 5でスクリーンショットを起動し、

optionsから、保存先を変えることができます。</p>
ターミナルでやる場合、</p>
defaults</span> write com.apple.screencapture location /保存先のパス</span></span></code></pre>
macだと、上記のような、

defaults writeコマンドがあるので、

これの使い方を学ぶのも面白いかもしれません。</p>
出力ファイル名を変える</h4>
デフォルトだと、余計なスペースとかが入って、

鬱陶しいのでできれば、ファイル名も変えたいですね。</p>
defaults</span> write com.apple.screencapture name 保存したい名前</span></span></code></pre>
これで変更できます。</p>
ただこれだけだと、日付が入るので、</p>
defaults</span> write com.apple.screencapture "include-date"</span> 0</span></span></code></pre>
で日付を消します。</p>


【Ruby on Rails概念思想】 使い方やコマンド・Gemチートシート
2023-03-16T00:00:00+00:00
Railsの概念思想</h2>
Ruby on Railsに限らず、

技術には何らかの思想があることがほとんどです。</p>
特にRailsはその中でも

その傾向が強く、

いわゆるRails wayを遵守しないと、</mark>

なかなかRailsのパワーを引き出せません。</mark></p>
以下、Railsの概念思想を解説します。</p>
本記事は、どちらかというと、

Railsまとめのような記事なので、

具体的なRailsの環境構築などは、

こちらの記事</a> を参照ください。</p>
MVC</h3>
Railsの概念でもっとも重要なものといえば、

やはりMVCでしょう。</p>
MVCは、Rails専門の概念というわけではなく、

例えばLaravelとかもたしかMVCだったと思います。</p>
MVCもがちで学ぶと結構複雑で、

奥が深いのですが、とりあえず、

Railsを使うだけなら細かいことは気にしなくても大丈夫かなと思います。</p>
平たく言うと、Model View Controllerの三つがあって、

アプリケーションの責務をこの三つに分割しているのがMVCの概要です。</strong></mark></p>
よくRailsのMVCの説明で、

「モデルを介して、ビューにわたされて」みたいな

それっぽい理屈を聞かされるかもしれませんが、

正直私は初学者のときに、こんなことを言われても

混乱しただけでした。</strong></p>
少なくとも、とりあえず、Railsを使えるようになるレベルであれば、

MVCの深い理解はなくてもいいと思います。</p>
重要な流れは、

Controller → Viewにあるかなと思います。</strong></p>
なぜなら、Controllerで必ずModelの呼び出しをするとは限らないので、

MVCの説明であたかもController層で必ずModelを経由するみたいな説明は混乱を招く気がします。

（私がそうでした）</p>
それにMVCは、責務の分割、保守性の向上のための、

アーキテクチャーであり、流れを教科書的に、

定義するものでもない気がするので、上記のような説明でも

そこまで外れていないかなと思っています。

(MVCガチ勢の人からすると「ちげえよ」って感じかもしれませんが)</p>
</p>
Railsを使うにあたって、最低限抑えたい事項は、

Routingを張ったエンドポイントに対し、

Controllerのメソッドが呼ばれ、そのメソッドの行き先が、

同じディレクトリのviews配下に進んでいくということだけです。</strong></p>
よくRailsは覚えゲーって言われますが、

確かにこのあたりは割と覚えゲーですかね。</p>
モデルうんたらは、考えなくても、

要は、Controllerでの処理でModelの呼び出しをしているだけで、

上記の流れに、かならずModelの経由が組み込まれるととらえるのは、

どうも逆に素直じゃない気がするなと個人的には感じます。</p>
ちなみに、MVCの詳細は、

下記のドキュメントに記載があります。</p>
https://railsguides.jp/getting_started.html#mvc%E3%82%92%E7%90%86%E8%A7%A3%E3%81%99%E3%82%8B</a></p>
モデルは、DBの疎通を担当し、

Viewは、画面の見た目を担当し、

Controllerは、両者の仲介をするという感じです。</p>
つまり、DBのデータをViewにまで

渡す一連の流れみたいな感じですかね。</p>
本来のRailsであれば、

こんな感じですが、

最近は、Rails + ReactみたいなSPA開発が主流なので、

Railsがビューを担当するということは少なくなっています。</p>
ただ、それでもRailsのビューは、

フロント(Reactなど)にわたすJsonを定義するので、

そういう意味では、MVCになってはいると思いますが。</p>
以下、用語について、

詳しくみていきます。</p>
model</h3>
MVCのところで、

modelについてちょっと軽視するような説明をしましたが、

model自体は、Railsにおいて重要な概念です。</p>
modelとは何ぞ？って感じだと思いますが、

面倒くさいことは考えなくて大丈夫です。</p>
要は、DBのテーブルです。</strong>

（厳密には違うのですが、最低限Railsを使うだけならこの理解でも十分でしょう。）</p>
まあ、Rails特製の、便利なDBテーブルとでも

思ってくれれば大丈夫です。</p>
事実、Controllerとかの処理では、

このModelを使ってDBにアクセスをします。

つまり、面倒くさいSQLを書かなくても、DBと会話してくれる、</mark>

便利な通訳みたいな役割をしてるのが、このmodelというわけです。</mark></p>
これが便利すぎて、SQLをかけなくなる、

事象が多発しているので、気をつけたいところですね。</p>
まあ、こういったORMは、

Rails以外にもあるので、

特段Railsの強みというわけではありませんが。

(そうはいっても、Railsのモデルがわかりやすく使いやすいのは事実です)</p>
migration</h3>
次によく聞く用語として、

migrationがあります。</p>
migrationは、ほかのフレームワークでも聞くかと思います。</p>
LaravelやPrismaとかでも、

migrationコマンドがあったと思います。</p>
これは平たく言うと、

migrationファイルという、DBの設計書というか、</mark>

「こんな感じのテーブルつくりたいんだけど」みたいな、</mark>

設計を定義したファイルを実際にDBに反映させることをいいます。</mark></p>
DBにテーブルおを作る方法として、

いきなりSQLでcreate tableとかでも

作れないわけでも有りませんが、

メンテナンス性にかけますし、

いきなり本番実行はtypoなどのリスクも大きいです。</p>
そこでいきなり作る前に、

確認するフェーズみたいなものを挟めたら理想だと思います。</p>
それが、migrationにあたりまして、DBにテーブルとかを作る前に、</strong>

設計書を作って、反映させるというワンクッションを置いた感じです。</strong></p>
migrationは、歴史の側面もあります。</mark>

というのも、migraitonファイルを生成して積み重ねていけば、</mark>

過去にどういうテーブルを作ったり修正したのかということが、</mark>

migrationファイルを見ればわかるからです。</mark></p>
Gitの歴史に通ずる部分がありますね。

Git管理下に置けば、メンテナンス性は上がりますが、

管理下から外せば、どのタイミングで編集されたりとか、

過去の設定に戻したいとかがやりづらくなってしまいますよね。</p>
migrationは、このGitのように、

DBテーブルの作成・修正の歴史を積み上げていくような側面もあるというわけです。</p>
それにmigrationのメリットは、ロールバックのように、

migrationを反映する前に戻すこともできるということで、

DBの構造を歴史をさかのぼるようにして変えることができます。</p>
この点も、Gitに似ていますね。</p>
ルーティング</h3>
次の用語は、ルーティングです。</p>
ルーティングも、ほかのフレームワークとかでも

普通に登場する言葉で、Railsでの意味も大して変わりません。</p>
基本的に、Railsの場合、config/routes.rbに、

エンドポイントを設定して、呼ばれるControllerの処理を指定します。</p>
イメージとしては、蜘蛛の巣を張り巡らす感じです。</strong></p>
Railsを使いたてのころ、

私はルーティングは、なんとなく、

resourcesで指定して、controllerに行って、

viewに行ってみたいな感じで、

機械的に覚えていました。</p>
まあ、これはこれで間違えでもない気もしますが、

ルーティングは、基本的には結構自由です。

（できればresourcesを使いたいが）</p>
そして、呼ばせるControllerをルーティングで指定し、

Controllerのメソッドで処理を書いていくことは、

あたかも、用意した蜘蛛の巣（メソッド）に、

誘い込む（ルーティングのエンドポイントにアクセスさせる）みたいな

イメージのような気がしています。</p>
私は、ファイルエクスポートとか、インポートの処理を、

ルーティングで指定しているのをみて、

ルーティングの意味が腑に落ちました。</p>
ドキュメントのページは下記ですね。</p>
https://railsguides.jp/routing.html</a></p>
ただ、ルーティングも好き勝手やっていいということはなく、

やはり適切なapi設計というものがあります。</p>
ただ、これは、Railsというよりは、

API設計の話になると思うので、

割愛します。</p>
余談ですが、私が以前経験したプロジェクトでは、

ルーティングが、config/routes.rbにまとまっておらず、

別ファイルとかに個別に定義されていれ、

DockerのNginx経由でルーティングの上書きのようなことが行われていて、

控えめに言って地獄でした。</p>
Rails wayを軽んじて好き勝手やり始めると、

一気に負債化するので、Railsを採用するからには、

しっかり道をあるきましょう。</p>
RailsのGem</h2>
Ruby on Railsにおける、</strong>

外部ライブラリをGemと呼びます</strong>が、

Railsは、割と何をするにも、

Gemに頼る文化？みたいなものがある気がしています。</p>
その中には、外部ライブラリだけど、

実質標準ライブラリでしょっていうぐらい毎回使うものもあります。</p>
なので、そういったGemなどについてまとめてみようと思います。</p>
ちなみに、Railsもgemです。

Ruby on Railsを使う時点で、

使いますね。</p>
ほどんど毎回使うGem</h3>
まずは、スタメンを紹介しましょう。</p>

rucocop</td> Lintツール</td></tr>
rspec</td> テストツール。minitest派もいるだろうが、なんだかんだrspecのほうが使われている気がするし使いやすい。</td></tr>
byebug</td> デバッグツール。pry-railsとかでもいい。</td></tr>
factory_bot_rails</td> テスト時のダミーデータを作成してくれる。rspecとハッピーセット</td></tr>
</table>
※railsやDBやアプリケーションサーバーのgemみたいにデフォルトで入っているやつは除外してます。</em></p>
正直、これ以外にもスタメンチックなgemはあるのですが、

明示的にそのGemの機能を使うというよりは、

Railsの仕組みのために使われていて、

Rails wayに乗っかれば、そこは隠蔽されるみたいなGemも多い気がするので、

そういうのは省略しています。</p>
場合によって使う機会が多いおなじみのGem</h3>
次にベンチ入りメンバーを紹介しましょう。</p>

ransack</td> 検索機能を簡単に作れるGem。検索機能が必要な際は、ransackを入れるかどうかを検討することがほどんど。</td></tr>
kaminari</td> ページネーションを簡単に作れるGem。こちらもページネーションと聞いたらまっさきに思い浮かぶGem</td></tr>
jbuilder</td> view層でjsonを返す、主にAPIとして使用するときに必須になるGem。一応jbuiler以外にも、代わりとなるgemはたくさんあるが、知名度はこいつが圧倒的</td></tr>
dotenv-raiils</td> 環境変数を使うときは、使うことを検討するgem</td></tr>
capistrano</td> デプロイするときにお世話になるgem。Railsデプロイのデファクトはこいつなので、事実上、毎回使うかもしれない。</td></tr>
whenever</td> cron機能を使いたいときに使うgem</td></tr>
sidekiq</td> こいつは実務だったらスタメン。個人開発ならベンチ入りメンバーというところでしょうか。</td></tr>
redis</td> sidekiqと一緒に使われることが多いgem。使っている企業は多そうだが、使っていない企業も多そう</td></tr>
enum_help</td> enumを使う際は入れることが多いと思う</td></tr>
cancancan</td> 権限管理系では、割と有名かと</td></tr>
carrierwave</td> ファイルアップロード系は俺にまかせろっていう感じのgem</td></tr>
</table>
これ以外にもあると思いますが、

ぱっと思いつくのはこのあたりですかね。</p>
テストでよく使うgemとか、

Google apiのgemとかも場合によっては、

かなり使用頻度高い気がします。</p>
Railsの場合、ページネーションや検索機能なども

gemで実装したりすることが多いのが印象的ですね。</p>
PHPとかだと、このあたりの機能は、

自分で書いていたような気がします。</p>
基本的にライブラリのコントリビューターの方は、

優秀なエンジニアばかりなので、

その方たちにメンテナンスされているのであれば、

自分で書くよりも絶対に良いですね。</p>
ただ、更新が止まっていたり、

自分で書き換えたりする場合は、

そのライブラリのコードが読めないといけないので、

大変になる場合もありますが。</p>
Railsコマンド</h2>
Ruby on Railsはフルスタックフレームワークなので、

コマンドなども色々あります。</p>
そして、そのようなコマンドの中でも、

よく使うやつとそうでもないやつなど、

色々あります。</p>
ここでは、よく使うやつをご紹介します。</p>
よく使うコマンド</h3>

rails c</td> Railsコンソールに入るコマンド。Railsコンソールは、バックエンドにRailsを採用する一つの理由になるぐらいの便利ツールで、正直Railsを使うならこれを使わないことは考えられないレベル。コンソールといいつつも、サンドバッグモードとかにしない限り、ここでのデータの追加とか削除は、すべて反映される。</td></tr>
rails db:migrate</td> migrationファイルのmigrationを実行する</td></tr>
rails db:migrate:status</td> migrationの状況を確認する。upとかdownとかがわかる。railsの場合、migrationがpendingになるとエラーになるので、migrationの状況を確認することは意外とある。</td></tr>
rails routes</td> 現在設定されているルーティングを確認できる。パイプでgrepをかけることも多い</td></tr>
rspec</td> rspecのgemがあるときに使うコマンド。事実上のデファクトのテスト実行コマンドであり、ファイル名とかを指定して実行することも多い。</td></tr>
rubocop</td> rubocopのgemがあるときに使うコマンド。RailsのデファクトのLintツール</td></tr>
rails generate model</td> モデル生成コマンド</td></tr>
rails generate controller</td> コントローラー作成コマンド</td></tr>
rails generate migration</td> migration作成コマンド</td></tr>
</table>
これ以外にも、よく使うと感じるコマンドは、

あるかなと思います。(rails db:rollbackとか？)</p>
ここでは、本当によく使うわというやつを

上記に記述しました。</p>
Rails Consoleは本当に便利なので

いつもお世話になっております。</p>
[st-card myclass="st-no-shadow" id="679" label="あわせて読みたい" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
[st-card myclass="st-no-shadow" id="1019" label="あわせて読みたい" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>


【Ruby on Rails CRUD作成】Partialとテストコード実装
2023-02-16T00:00:00+00:00
CRUDとは？</h2>
CRUDとは、データの作成(Create)、読み出し(Read)、</mark>

更新(Update)、削除(Delete)の頭文字を繋げたもので、</mark>

ソフトウェアの基本機能のことを言います。</mark>

(※本記事では、Delete機能はまだ実装しません)</p>
例えば、TODOアプリとかだと、

タスクを作成して、その作ったタスクを確認して(読み出し)、

タスクの期限を修正して(更新)、タスクを終えたら削除するというように、

ほとんどのアプリケーションには、こうしたCRUDがあります。</p>
Ruby on Railsでは、ドキュメント</a>にあるような、

resourcesの7つのアクションがまさに、

これらのCRUDのどれかに該当しているので、

RailsだとCRUDはわかりやすいかもしれません。</p>
一般的に、CRUDの実装は、

Web開発の基本とされており、

first taskにされることが多かったりします。</p>
本記事では、このCRUDの実装をPartialという共通化を

行って実装します。</p>
その際、テストコードも実装します。</p>
Ruby on Railsの開発環境をまだ構築していない人は、

こちらの記事</a>で構築してから本記事を読むと、

一層理解が深まるかと思います。</p>
Partialとは？</h3>
さて、CRUD実装に際し、

まず、Partialについて触れます。</p>
Partialは、簡単に言えばテンプレートのことであり、

辞書で調べたら部分的と訳されていました。</p>
Ruby on Railsにおける、Partilaは、

主にviewファイルで使い回すことができる、

テンプレートであり、

共通化された部分が記述されたファイルです。</strong></mark></p>
Partilaファイルを呼び出すには、

renderという関数を使って、</p>
<%=</span> render </span>partial:</span> "form"</span>,</span> locals:</span> {</span>action:</span> 'new'</span>}</span> %></span></span></code></pre>
という風にします。</p>
Rails Guideも詳しいです。

https://railsguides.jp/layouts_and_rendering.html</a></p>
この場合は、actionという変数に、

'new'という文字列を代入しています。</p>
Rails Guideの場合は、

form_withのmodelにわたす変数を

ローカル変数にすることで、

インスタンス変数への依存をなくしています。</p>
form_with</h3>
railsのview層をjbuilderとかではなく、

上記のようなhtml.erbとかは使う場合は、

データの作成を画面上で行うことが想定されるため、

そうしたデータを入力できるformが必要になるでしょう。

(ちなみに、jbuilderはjsonを返すGemでして、

主にRailsをapiサーバーとして使う際に使用します。)</p>
そこで、使用頻度が高いメソッドが、form_withです。

使用例としては、次のような感じです。</p>
<%=</span> form_with</span>(</span>model:</span> @aim,</span> local: true</span>)</span> do</span> |f|</span> %></span></span>
  <%= render "shared/error_messages", model: @aim %></span></span>
  <</span>div </span>class=</span>"form-group mb-3"</span>></span></span>
    <%=</span> f.</span>label</span> :title</span>,</span> '目標名'</span>,</span> class:</span> 'form-label background-color' %></span></span>
    <%= f.text_field :title, class: 'form-control', readonly: action==='show' %></span></span>
  </</span>div</span>></span></span>
</span>
  <</span>div </span>class=</span>"form-group mb-3"</span>></span></span>
    <%=</span> f.</span>label</span> :reason</span>,</span> '理由'</span>,</span> class:</span> 'form-label background-color' %></span></span>
    <%= f.text_area :reason, class: 'form-control', readonly: action==='show' %></span></span>
  </</span>div</span>></span></span>
</span>
  <</span>div </span>class=</span>"form-group mb-3"</span>></span></span>
    <%=</span> f.</span>label</span> :advantage</span>,</span> '得られるもの'</span>,</span> class:</span> 'form-label background-color' %></span></span>
    <%= f.text_area :advantage, class: 'form-control', readonly: action==='show' %></span></span>
  </</span>div</span>></span></span>
</span>
  <</span>div </span>class=</span>"form-group mb-3"</span>></span></span>
    <%=</span> f.</span>label</span> :difficulty</span>,</span> '難易度'</span>,</span> class:</span> 'form-label background-color' %></span></span>
    <%= f.text_field :difficulty, class: 'form-control', readonly: action==='show' %></span></span>
  </</span>div</span>></span></span>
</span>
  <</span>div </span>class=</span>"form-group mb-3"</span>></span></span>
    <% if</span> action</span>===</span>'show' %></span></span>
      <%= link_to '編集', edit_aim_path(@aim.id), class: 'btn btn-primary' %></span></span>
    <% else</span> %></span></span>
      <%= f.submit "</span>#{</span> @aim.</span>new_record?</span> ?</span> '新規作成'</span> :</span> '更新'</span> }</span>", class: 'mt-3 btn btn-primary' %></span></span>
    <% end</span> %></span></span>
  </div></span></span>
<% end</span> %></span></span></code></pre>
form_withのちょっと癖のある挙動としては、

一行目の、</p>
<%=</span> form_with</span>(</span>model:</span> @aim,</span> local: true</span>)</span> do</span> |f|</span> %></span></span></code></pre>
の(model: @aim)の部分があります。</p>
これは、@aimのデータを作成したりしたい場合に指定しますが、@aimの中身が空の場合は、</mark>

自動的にcreateアクションに飛ばされ、</mark>

中身が存在する場合は、updateアクションに飛ばされるという点です。</mark></strong></p>
そのため、newやeditによって、

インスタンス変数を分ける必要がないのは、

メリットである反面、よしなに処理してくれている部分なので、

直感的ではないかもしれません。</p>
フォームの各々は、</p>
  <%=</span> f.</span>label</span> :title</span>,</span> '目標名'</span>,</span> class:</span> 'form-label background-color' %></span></span>
  <%= f.text_field :title, class: 'form-control', readonly: action==='show' %></span></span></code></pre>
のようにします。</p>
fは、一行目のform_withをdoで回している部分で、

それにtitleのラベルとして、目標名を指定しています。

classは、ちょっとしたデザインを付けているだけです。</p>
text_fieldは、その名の通りtext_fieldを生成してくれて、

それと@aimのtitleが紐付いています。</p>
そのため、@aim.titleが存在する場合は、その値が初期値として入力されている。

readonlyオプションは、編集や入力をできなくします。</p>
この場合、先ほどのpartilaのローカル変数actionがshowという値だったときのみ、

readonlyオプションが適用されます。</p>
</p>
こんな感じになる。</em></p>
昨今の開発では、

フロントエンドはReact、バックエンドはRailsという、

SPA構成が多いので、このようにerbを使ってRailsだけで

フロントエンドもバックエンドも完結させるという構成は少なくなっている印象です。</p>
そのため、以前ほどは、

form_withの出番は減っている気もしますが、

erbなどを使う際は、かなり使用頻度が高いので、

大まかにでも覚えておくと役に立つと思います。</p>
テストコード</h2>
Railsでは、TDD（テスト駆動開発）が推奨されているため、

ベストプラクティスとしては、上記のCRUD処理のコードを書く前に、

テストを書くことでしょう。</p>
テストを書く方法としては、

デフォルトのminitestというライブリを使う方法もありますが、

実務では、これではなくRspecというGemを使うケースが多いので、

本記事でもこちらを使用して解説します。</p>
Rspec</h3>
早速Rspecでのテストコードを書いていきます。</p>
aimのcreateやupdateのformを作ったので、

そちらのテストを書いてみます。</p>
テストの簡単なコード例としては、

次のような感じです。</p>
require</span> 'rails_helper'</span></span>
</span>
RSpec</span>.</span>describe</span> 'Aims'</span>,</span> type: :request</span> do</span></span>
  let!</span>(</span>:aim1</span>) {</span> create</span>(</span>:aim</span>) }</span></span>
  let</span>(</span>:aim_params</span>) { {</span> title:</span> 'aim1'</span>,</span> reason:</span> 'test'</span>,</span> advantage:</span> 'test2'</span> } }</span></span>
</span>
  describe </span>'GET /new'</span> do</span></span>
    it </span>'returns http success'</span> do</span></span>
      get </span>"/aims/new"</span></span>
      expect</span>(response).</span>to have_http_status</span>(</span>:success</span>)</span></span>
    end</span></span>
  end</span></span>
</span>
  describe </span>'GET /edit'</span> do</span></span>
    it </span>'returns http success'</span> do</span></span>
      get </span>"/aims/</span>#{</span>aim1.</span>id</span>}</span>/edit</span></span>
      expect(response).to have_http_status(:success)</span></span>
    end</span></span>
  end</span></span>
</span>
  describe 'POST /create' do</span></span>
    it 'returns http success' do</span></span>
      post "</span>/</span>aims</span>", params: { aim: aim_params }</span></span>
      expect(response).to have_http_status(302)</span></span>
    end</span></span>
</span>
    context '正常系' do</span></span>
      it 'レコードの数が一つ増える' do</span></span>
        expect do</span></span>
          post "</span>/</span>aims</span>", params: { aim: aim_params }</span></span>
        end.to change { Aim.count }.by(1)</span></span>
      end</span></span>
</span>
      it '一覧画面にリダイレクトされる' do</span></span>
        post "</span>/</span>aims</span>", params: { aim: aim_params }</span></span>
        expect(response).to redirect_to(aims_path)</span></span>
      end</span></span>
    end</span></span>
</span>
    context '異常系' do</span></span>
      before do</span></span>
        aim_params[:title] = ''</span></span>
      end</span></span>
</span>
      it 'レコードの数が増えない' do</span></span>
        expect do</span></span>
          post "</span>/</span>aims</span>", params: { aim: aim_params }</span></span>
        end.to change { Aim.count }.by(0)</span></span>
      end</span></span>
</span>
      it '新規作成画面にレンダリングされる' do</span></span>
        post "</span>/</span>aims</span>", params: { aim: aim_params }</span></span>
        expect(response).to render_template :new</span></span>
      end</span></span>
    end</span></span>
  end</span></span>
</span>
  describe 'PATCH /update' do</span></span>
    it 'returns http success' do</span></span>
      patch "/aims/</span>#{aim1.id}", params: { aim: aim_params }</span></span>
      expect</span>(response).</span>to have_http_status</span>(</span>302</span>)</span></span>
    end</span></span>
</span>
    context </span>'正常系'</span> do</span></span>
      it </span>'レコードの値が変更されている'</span> do</span></span>
        patch </span>"/aims/</span>#{</span>aim1.</span>id</span>}</span>"</span>,</span> params:</span> {</span> aim:</span> aim_params }</span></span>
        expect</span>(aim1.</span>reload</span>[</span>:title</span>]).</span>to</span> eq </span>'aim1'</span></span>
      end</span></span>
</span>
      it </span>'一覧画面にリダイレクトされる'</span> do</span></span>
        patch </span>"/aims/</span>#{</span>aim1.</span>id</span>}</span>"</span>,</span> params:</span> {</span> aim:</span> aim_params }</span></span>
        expect</span>(response).</span>to redirect_to</span>(</span>aim_path</span>(aim1.</span>id</span>))</span></span>
      end</span></span>
    end</span></span>
</span>
    context </span>'異常系'</span> do</span></span>
      before </span>do</span></span>
        aim_params[</span>:title</span>]</span> =</span> ''</span></span>
      end</span></span>
</span>
      it </span>'レコードの値が変更されていない'</span> do</span></span>
        patch </span>"/aims/</span>#{</span>aim1.</span>id</span>}</span>"</span>,</span> params:</span> {</span> aim:</span> aim_params }</span></span>
        expect</span>(aim1.</span>reload</span>[</span>:title</span>]).</span>to</span> eq </span>'Golang取得'</span></span>
      end</span></span>
</span>
      it </span>'新規作成画面にレンダリングされる'</span> do</span></span>
        patch </span>"/aims/</span>#{</span>aim1.</span>id</span>}</span>"</span>,</span> params:</span> {</span> aim:</span> aim_params }</span></span>
        expect</span>(response).</span>to</span> render_template </span>:edit</span></span>
      end</span></span>
    end</span></span>
  end</span></span>
end</span></span></code></pre>
これは、割と簡素なパターンだが、

レコードの値が、リクエストを送ることによって、

変化しているかどうかを主にテストしています。</p>
expectというマッチャーと、

postやpatchというリクエストを送るメソッドを使って、

テストをしているという感じです。</p>
Controllerのコード</h3>
さて、上記のようなテストがあるとしたら、

最初は、controllerをまだ実装していないので、

Redになるでしょう。</p>
このテストをGreenにしていこうと思います。</p>
作成処理としては、

こんな感じのコードになります。。</p>
class</span> </span>AimsController</span> <</span> </span>ApplicationController</span></span>
  before_action </span>:set_aim</span>,</span> only:</span> [</span>:show</span>,</span> :edit</span>,</span> :update</span>]</span></span>
</span>
  def</span> index</span></span>
    @q</span> =</span> Aim</span>.</span>ransack</span>(params[</span>:q</span>])</span></span>
    @aims</span> =</span> @q.</span>result</span>.</span>page</span>(params[</span>:page</span>]).</span>per</span>(</span>5</span>)</span></span>
  end</span></span>
</span>
  def</span> show</span></span>
  end</span></span>
</span>
  def</span> new</span></span>
    @aim</span> =</span> Aim</span>.</span>new</span></span>
  end</span></span>
</span>
  def</span> create</span></span>
    @aim</span> =</span> Aim</span>.</span>new</span>(aim_params)</span></span>
    if</span> @aim.</span>save</span></span>
      flash[</span>:success</span>]</span> =</span> '目標を作成しました'</span></span>
      redirect_to aims_path</span></span>
    else</span></span>
      render </span>'new'</span>,</span> status: :unprocessable_entity</span></span>
    end</span></span>
  end</span></span>
</span>
  def</span> edit</span></span>
  end</span></span>
</span>
  def</span> update</span></span>
    if</span> @aim.</span>update</span>(aim_params)</span></span>
      flash[</span>:success</span>]</span> =</span> '目標を更新しました'</span></span>
      redirect_to </span>aim_path</span>(@aim.</span>id</span>)</span></span>
    else</span></span>
      render </span>'edit'</span>,</span> status: :unprocessable_entity</span></span>
    end</span></span>
  end</span></span>
</span>
  private</span></span>
    def</span> set_aim</span></span>
      @aim</span> =</span> Aim</span>.</span>find</span>(params[</span>:id</span>])</span></span>
    end</span></span>
</span>
    def</span> aim_params</span></span>
      params.</span>require</span>(</span>:aim</span>).</span>permit</span>(</span>:title</span>,</span> :reason</span>,</span> :advantage</span>,</span> :difficulty</span>)</span></span>
    end</span></span>
end</span></span></code></pre>
before_actionによって、

それぞれ、show, edit, updateアクションが実行される前に、

該当メソッド、この場合privateメソッドのset_aimが呼ばれます。</p>
showアクションと、editアクションが空なのは、

このbefore_actionのset_aim関数の処理だけで足りているからです。</p>
残りの、createやupdateは、

ほとんどRails Tutorialと同じようなコードだが、

aim_paramsを割り当てて、

DBへの保存が成功したら、

flash messageを出し、

失敗したら、それぞれの作成画面に戻し、

status 422を返すという感じです。</p>
ストロングパラメータ</h3>
さて、上記のコードの

aim_paramsの部分だが、

これは、俗に言うストロングパラメータの部分です。</p>
ストロングパラメータとは、

送られてくるparamsの値で</strong>

どれを許可するのか設定することです。</strong></p>
https://railsguides.jp/action_controller_overview.html</a></p>
例えば、userモデルの作成において、

adminという、管理者かどうかというカラムが存在した場合、

ストロングパラメータで、許可するパラメータを指定しないと、

誰でも管理者になることができてしまうという、

脆弱性につながります。</p>
そのため、ストロングパラメータで、

許可するパラメータを指定する必要があるのですが、

その書き方は、上記のように、</p>
 def</span> aim_params</span></span>
   params.</span>require</span>(</span>:aim</span>).</span>permit</span>(</span>:title</span>,</span> :reason</span>,</span> :advantage</span>,</span> :difficulty</span>)</span></span>
 end</span></span></code></pre>
のように、permitを使って、

この場合、title, reason, advantage, difficultyだけを許可するという感じです。</p>


【Ruby on Rails7環境構築】Dockerでrails newする
2023-01-29T00:00:00+00:00
rails newとは？</h2>
rails newとは、

文字通り、新しいrailsアプリケーションを作成するコマンドです。</strong></p>
rails new | Railsドキュメント (railsdoc.com)</a></p>
本記事では、Dockerを使うので、

ローカル環境にrailsをインストールしませんが、

Dockerを使わない場合は、

railsをインストールしないと、

上記のコマンドは使えません。</p>
個人開発であれば、

rails newする機会はたくさんあると思いますが、

実務だと、rails newコマンドは、

新規開発プロジェクトの立ち上げになりますので、

一定レベルのエンジニアかつ立ち位置でないと触れる機会が少ないコマンドです。</p>
その点、ある意味伝説のコマンドです(笑)</p>
ちなみに、私は新入社員チームの発表会のようなときに、

リーダーとして、rails newした経験がありますが、

これも正確には、実務ではないので、

私も実務でrails newした経験はまだありません。</p>
若干脱線しましたが、

rails newコマンドには、

ドキュメントに記載があるように、

オプションが色々あり、</mark>

DBの指定や、apiモードの指定など、</mark>

rails newの時点で行えます。</mark></p>
PostgreSQLを使う場合(サンプルコマンド)</h3>
rails</span> new</span> <</span>appnam</span>e</span>></span> -d</span> postgresql</span></span></code></pre>
-dオプションでDBを指定します。

デフォルトでは、sqlite3が使われますが、

実務ではほとんど使わないので、

実質上のデフォルトは、postgresqlと言っても過言ではありません。</p>
もういい加減、

sqliteをデフォルトにするのやめませんか？って

思いますが、何か理由があるんでしょうかね。</p>
他に有名なDBとしては、

mysqlなどもありますが、

どういうわけか、Rails界隈では、

postgresqlが人気があるので、

mysqlが採用されているケースは、

postgresqlよりは少ない印象です。

(ないわけではありません)</p>
さて、書式については、

-database=DATABASEという書式でも同様です。</strong></p>
ちなみに、特定のバージョンのrailsでrails newしたい場合は、</p>
rails</span> _6.1.4_ new</span> <</span>appnam</span>e</span>></span></span></code></pre>
とすることで実行できます。</p>
上記だと、6.1.4のrailsがインストールされます。</p>
Railsは、5系、6系、7系で、

微妙に挙動が違ったりするので、

上記のようにバージョン指定でインストールする場面もあるかもしれません。</strong></p>
Ruby on Railsのドキュメント</h2>
ちなみに、Ruby on Railsでよく参照するドキュメントは、

上記のRailsドキュメントや、Rails ガイドが多いです。</p>
https://railsdoc.com/</a></p>
https://railsguides.jp/</a></p>
いや、それにしてもRailsの場合、

日本語で公式ドキュメントが読むことができるのが素晴らしいですね。</mark></p>
これに慣れすぎると、

英語のドキュメントが読めなくなってしまいます。(震え声)</p>
一応、Railsにも英語のドキュメントがあり、

稀ですが、上記の2つのドキュメントには記載がない、

メソッドなどについて、調べたいときに参照したりします。</p>
https://api.rubyonrails.org/</a></p>
強強エンジニアに、Railsについて、

質問すると、一定の確率で、

上記の英語のドキュメントが返ってきます(笑)</p>
あと、Railsは普通にGithubにもコードがあるので、

ドキュメントどころか、コードを読めって言ってくる仙人エンジニアもいます。</p>
https://github.com/rails/rails</a></p>
最初のうちは、

私が推奨した、日本語の2つのドキュメントだけ参照する形でも

十分かと思います。</p>
というか、上記の日本語の2つのドキュメントすら読まずに、

rails触っているエンジニアも、多いのが現状なので、

上の2つをしっかり読むだけで、意外と平均以上行ける気がします...

(真偽はわかりません)</p>
いずれにしろ、Ruby on Railsは、

公式ドキュメントがしっかりしているので、

この点は大きな魅力ですね。</p>
Docker環境でrails new</h2>
いよいよ、環境構築に入ります。</p>
ローカルでrails newしてもいいのですが、

その場合、rbenvとかrailsとかインストールするものが、

多くなり、環境構築が煩雑になりがちです。

(加えてM1だとエラーが起こりがち)</p>
railsはM1とかだと上手く動かなかったりするので、

Dockerでrails newを行います。</p>
まずはDockerfileを作成します。</p>
FROM</span> ruby:3.0-alpine</span></span>
RUN</span> apk update</span> &&</span> \</span></span>
    apk</span> upgrade</span> &&</span> \</span></span>
    apk</span> add</span> --no-cache</span> gcompat</span> &&</span> \</span></span>
    apk</span> add</span> --no-cache</span> linux-headers libxml2-dev make gcc libc-dev nodejs tzdata postgresql-dev postgresql git bash</span> &&</span> \</span></span>
    apk</span> add</span> --virtual</span> build-packages</span> --no-cache</span> build-base curl-dev</span></span>
RUN</span> mkdir /myapp</span></span>
WORKDIR</span> /myapp</span></span>
ADD</span> Gemfile /myapp/Gemfile</span></span>
ADD</span> Gemfile.lock /myapp/Gemfile.lock</span></span>
RUN</span> bundle install</span></span>
RUN</span> apk del build-packages</span></span>
ADD</span> . /myapp</span></span>
EXPOSE</span> 4000</span></span>
CMD</span> [</span>"rails"</span>,</span> "server", "-b", "0.0.0.0"]</span></span></code></pre>
ドキュメントの内容を参考に修正しました。

https://docs.docker.jp/compose/rails.html</a></p>
alpine系のイメージを使ったのと、

apk add --no-cache gcompat && \</code>の部分は、

m1macに必要なので、入れております。</p>
M1以外の人は、

省略して大丈夫です。</p>
上記のDockerfileの大まかな処理内容としては、

必要なライブラリのインストールを行い、

GemfileとGemfile.lockをコンテナのディレクトリ内にコピーし、

bundle installコマンドを実行している感じです。</p>
bundle installは、</mark>

railsで使うコマンドで、</mark>

必要なライブラリ(gem)をインストールするコマンドです。</mark></p>
あとは、rails serverという、

ローカルサーバーを立ち上げるコマンドをCMDに設定しています。</p>
なお、Dockerの基本知識に不安がある人は、

下記の記事もご参考ください。</p>
[st-card myclass="st-no-shadow" id="1077" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
GemfileとGemfile.lock</h3>
Dockerfileを記述したので、

次にGemfileを記載します。</p>
rails7系にしたいので、</p>
source </span>'https://rubygems.org'</span></span>
gem </span>'rails'</span>,</span> '~>7.0.3'</span></span></code></pre>
のようにします。</p>
Gemfileのバージョンの記法ですが、

いくつかパターンがありまして、

上記の ~>のような場合だと、</p>
7.0.3以上、7.1未満というように、</strong>

最終桁が繰り上がった数値未満という感じになります。</strong></p>
なので、

gem 'rails', '>=7.0.3', '<7.1'

と記載しても同じ意味になります。</p>
Gemfileのバージョン指定の記法については、

ドキュメントとかのわかりやすい箇所に載っていないので、

混乱しがちですが、下記記事がわかりやすかったです。</p>
https://autovice.jp/articles/118</a></p>
ちなみに、Gemについては、

下記のようなGemの一覧サイトのようなものがあり、

バージョンを指定するのがよく分からなければ、

下記のサイトのサンプルコードをそのまま貼り付けるというやり方でも、

最初のうちは意外となんとかなります。</p>
https://rubygems.org/</a></p>
あと、そもそもバージョンを指定しないで、

インストールすることもできます。(推奨ではありませんが)</p>
railsもgemの一種ですが、

railsのようにversionによって、

センシティブに挙動が変わるgemは、

バージョン指定にナーバスになるべきですが、

それ以外のgemとかだと、意外と、

バージョン指定なしで運用されていることもあります。</p>
なので、最初のうちは、

そこまで神経質にならなくて大丈夫です。</p>
さてGemfileがそんな感じでして、

次に、空のGemfile.lockも作成します。</strong></p>
Gemfile.lockは、JavaScriptにおける、

yarn.lockのようなインストールされているライブラリのバージョンを管理するファイルです。</p>
基本的に手動では編集しません。

bundle installでインストールされると、

自動的に書き換えられます。</p>
touch</span> Gemfile.lock</span></span></code></pre>docker-compose.yml作成とbuild</h3>
最後にdocker-compose.ymlを作成します。</p>
version:</span> '3.9'</span></span>
services:</span></span>
  db:</span></span>
    image:</span> postgres</span></span>
    volumes:</span></span>
      -</span> ./tmp/db:/var/lib/postgresql/data</span></span>
    environment:</span></span>
      POSTGRES_PASSWORD:</span> password</span></span>
  web:</span></span>
    build:</span> .</span></span>
    command</span>: bash</span> -c</span> "rm -f tmp/pids/server.pid && bundle exec rails s -p 4000 -b '0.0.0.0'"</span></span>
    stdin_open:</span> true</span></span>
    tty:</span> true</span></span>
    volumes:</span></span>
      -</span> .:/myapp</span></span>
    ports:</span></span>
      -</span> "4000:4000"</span></span>
    depends_on:</span></span>
      -</span> db</span></span></code></pre>
これは、公式ドキュメントを参考にしている部分が多いです。</p>
https://docs.docker.jp/compose/rails.html</a></p>
ここまで来たら、

いよいよrails newします。</p>
docker-compose</span> run web rails new .</span> --force --database=postgresql</span></span></code></pre>
新しいGemfileが作成されるので、

buildします。</p>
docker</span> compose build</span></span></code></pre>
これで雛形ができますが、

DBの設定がまだなので、

そちらを行います。</p>
database.ymlの設定とコンテナ立ち上げ</h3>
下記はrailsプロジェクト配下の

config/database.ymlというファイルです。</p>
defaultで設定されている部分に、

DBのusernameやpasswordなどといったことを設定します。</p>
default:</span> &</span>default</span></span>
  adapter:</span> postgresql</span></span>
  encoding:</span> unicode</span></span>
  host:</span> db</span></span>
  username:</span> postgres</span></span>
  password:</span> password</span></span>
  pool:</span> 5</span></span>
</span>
development:</span></span>
  <<</span>:</span> *default</span></span>
  database: myapp_development</span></span>
</span>
test:</span></span>
  <<: *default</span></span>
  database: myapp_test</span></span></code></pre>
最後にコンテナを立ち上げます。</p>
docker</span> compose up</span> -d</span></span></code></pre>
ただおそらく、これで、

localhost:4000にアクセスしても、

ActiveRecord::NoDatabaseErrorというエラーが出るかなと思います。</p>
</p>
そのまんまのエラーなので、

DBを作成します。</p>
docker-compose</span> run web rails db:create</span></span></code></pre>
このあとは、出ない場合もありますが、

もし、pending migration errorというのが出たら、</p>
docker-compose</span> run web rails db:migrate</span></span></code></pre>
で治るかなと思います。</p>


VimとNeovimの違いについて init.vimサンプル公開
2023-01-29T00:00:00+00:00
本記事では、VimとNeovimの違いについて、

解説します。</p>
VimとNeovimの違いについては、

普段頻繁にVimなどを使う方でなければ、

正直、あまり気にしなくてもいいかなと思います。</p>
ただ、VimやNeovimを本格的に使用していくことを考えると、</mark>

やはりこの2つについて、大まかに違いを知っておきたいもの。</mark></p>
本記事では、この2つの違いについてまとめました。</p>
Vimの基本操作や、プラグイン、知っておきたい使い方など、

Vimの入門については、下記のYoutube動画でまとめて解説しております。</p>
これからVimを触るという方でも、

VimでVSCode並の開発ができることを目指した

動画なので、VimやNeovimに興味がある方はぜひ御覧ください。


  </iframe>
</div>

https://www.youtube.com/channel/UCsQKboXGGHPtITUO2i0B8gQ</a></p>
Neovimとは何か？</h2>
Neovimは、Vimをフォークしたものの一つで、

基本的には、Vimを改良したものとされています。</p>
細かい思想の違いなども、あるようですが、

平たく言えば進化系</strong>だと思ってもらって大丈夫です。

(進化の方向性としては、個人的にはよりリッチで操作性が良いIDEのようなイメージです)</p>
https://neovim.io/</a></p>
そもそもVim自体がViのクローンなので、

NeoVimは、クローンのクローンみたいな感じかもしれません。</p>
最近だと、Viに触れる機会はかなり減っている印象ですが、

Viは、Vimよりも操作感やUIが玄人向け、

悪く言えば、使いにくい印象でした。</p>
なので、Vimも、今のNeovimのように、

ある種の進化系といえそうです。

(Neovimはその進化系なので、Viとはかなり違います)</p>
最近だと、AstroNvim</a> のような、

デフォルトで使いやすく設定された、</mark>

ある種の完成版Neovimのようなものもあります。</mark></p>
ただ、ここまで来ると、

初期のVi信者とかからすると、

「これはViじゃない」と怒り狂いそうなぐらい、

良く言えば、進化してます。（悪く言えば本流から外れています。)</p>
Neovimだと、Telescope.nvimのような

便利なNeovim製のプラグインが使えるというメリットが有るので、

特にこだわりなければ、Neovim一択のような気もします。</p>
設定ファイルについては、.vimrcではなく、

~/.config/nvim/init.vim または、init.luaとかに</strong>なります。</p>
Vimで使っていたプラグインについても、

Neovimで使えます。</p>
そのため、やはり特にこだわりがなければ、

今ならいきなりNeovimから使い始めて問題ないと思います。</p>
NeovimとVimの違い</h2>
早速本題です。

両者の違いですが、</p>
正直、Vimをたまに使うぐらいであれば、

Neovimだろうと、Vimだろうと大差ありません。</strong></p>
使いやすい方を使えばいいと思います。

(そこまで操作性に違いはないと思いますが...)</p>
ただ、前述のように、

Neovimは、よりリッチで、IDEっぽくできる(Vimでもできるといえばできますが)ので、</mark>

今から入門するなら、個人的にはNeovimをおすすめします。</mark></p>
これらを踏まえて、

詳細な違いについて触れていきます。</p>
INSERTモード時のカーソル</h3>
INSERTモードに入ったときに表示される、

カーソルがNeovimとVimでは異なります。</p>
</p>
左がVim、右がNeovim</em></p>
Vimの場合、NORMALモードのときと、

カーソルの形が変わりませんが、

Neovimの場合、| に変化します。</strong></p>
この点は、おそらくNeovimの方が

見やすくて便利でしょう。</p>
Vimは、カーソルだけなので、

今のモードがなにかわかりにくいです。</p>
カーソルの前に文字が入るのか後ろに入るのか、

直感的ではないでしょう。</p>
ただ、慣れの範疇の気もするので、

割りと些末な違いになるかもしれません。</p>
ターミナルモード</h3>
ターミナルモードに入ったときも、

挙動が異なります。</p>
ちなみに、ターミナルモードとは、

INSERTモードとかと同様のモードの一種で、

:termで入ることができます。</p>
</p>
Vimの場合、splitしてから、

ターミナルモードに入ります。</p>
これに対し、Neovimはカレントバッファーをまるごと、

ターミナルにしてしまい、デフォルトで

ノーマルモードになっています。</p>
これは、好みが分かれそうですが、

個人的にはVimの方が、

すぐにコマンドが打てるのと、

Ctrl + wで移動しやすいので、便利かなと思いました。</strong>

(人によっては、Neovimのほうが便利という人もいます。)</p>
ただ、Neovimの方でも、iを押せば、

すぐにコマンドが打てますし、

戻りたいときは、Ctrl + \ Ctrl + nで戻ることができます。</strong></p>
しかし、デフォルトのキーバインドだとめちゃくちゃ押しづらいので、

キーマップを設定するのが良いでしょう。</p>
tnoremap</span> <</span>spac</span>e</span>></span>jj</span> <</span>C-</span>\></span><</span>C-</span>n</span>></span></span></code></pre>
これで、spaceとjjを押せば、

簡単にフォーカスを外すことができます。</p>
キーマップの詳細については、こちらの記事</a>を御覧ください。</p>
[st-card myclass="st-no-shadow" id="119" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
デフォルトだと、若干Vimのほうが使いやすそうなものの、

Neovimでも設定はできるので、

そこまで大差ないとみなして大丈夫そうです。</strong></p>
ちなみに、Neovimには、toggleterm.nvimという

便利なプラグインも存在するので、

これを使えば、むしろNeovimのほうが良いぐらいでしょう。


  </iframe>
</div>
</p>
Neovimは設定をLuaで書ける</h3>
通常、Vimの設定とかカスタマイズは、

Vim scriptで行いますが、

Neovimは、Luaでもできます。</strong></p>
Vim scriptとLuaの2つ選択肢があるのは、

素敵ですね。</p>
「Vim scriptは書きにくい！」という意見は、

ちらほら聞くので、Luaでも書けるというのは、

メリットとみなしていいでしょう。</p>
しかし、Neovim使い始めでいきなりluaで書く必要はない気もします。

というのも、なんだかんだでVim scriptの資産は多いので、

そちらの知識も多少は持っておいたほうが役に立つことが多いからです。</p>
まあそうは言っても、Neovim製のイケてるプラグインは、基本Luaで記載されているので、

これからは、徐々にVimScriptからLuaに切り替わっていくような気もしますが...</p>
既にVim scriptで、膨大な設定ファイルを持っている方は、

移行コストがかかると思うので、無理して移行する必要はないと思います。</p>
それに、Vim scriptからLuaを呼び出すこともできるので、

ベースは、Vim scriptで、Luaをサブで呼び出すみたいにすれば、

ほとんど移行コストもかからないと思います。

（個人的にはLua完全移行が推奨ではありますが...)</mark></p>
ちなみに、LuaからVim scriptを呼び出すという逆パターンもできるので、

設定ファイルだけ、init.luaにしては、中身はVim scriptという、

荒業もできなくはないでしょう。</p>
Vim scriptからLuaへの移行については、

下記が詳しいです。</p>
https://github.com/willelz/nvim-lua-guide-ja</a></p>
Vim scriptからLuaを呼び出す記法としては、</p>
lua</span> <<</span> EOF</span></span>
require('gitsigns').setup {</span></span>
-- 中略</span></span>
}</span></span>
EOF</span></span></code></pre>
のように、ヒアドキュメントのように、

先頭にluaと宣言し、EOFとかの中に閉じ込めれば、

Vim scriptの中でLuaが使えます。</p>
最近では、プラグインのREADMEに、

Vim scriptの場合での説明がなかったりするので、

プラグインとかをNeovimに寄せていくのであれば、

Luaに移行した方が良さそうです。</p>
あくまで、Vimベースでいくのであれば、

Luaにしなくてもいいかもしれません。</p>
Vimでしか動かないプラグインなども

確かあったと思うので、どっちがどっちというわけでもないと思うので。</p>
Vimの方がインストールされている環境は多い</h3>
Unix系であれば、Vimはデフォルトで

インストールされていることが多いのに対し、

Neovimは自分でインストールすることがほとんどです。</p>
ただ、本番サーバとかは、

極力余計なものをインストールしないようにするのが、

普通だと思うので、気軽にNeovimとかはインストールできないでしょう。

(それと複数人がsshする、本番サーバーで、個人の趣味でNeovimを入れてしまったら、

宗教戦争になります。)</p>
なので、本番サーバーとかでは、

Vim(それもプラグインとかなしの素のVim)を使うことを余儀なくされると思うので、</mark>

Neovimの便利さに慣れすぎると、その時、結構困るかもしれませんね。</mark></p>
もともとVimはシンプルなことをやるエディターで、

AstroNvimみたいに、VSCode顔負けに設定することは、

本流から外れているみたいな思想もあると思います。</p>
そういう意味では、あえてNeovimにせず、

素のVimを極めるという方向性も面白いと思います。

(素のVimだけでもできることはかなりあります。)</p>
Neovimもデフォルトでインストールされているように

なっていけば、状況も変わるかもしれませんが、

現時点ではViやVimが圧倒的です。</p>
設定ファイルのディレクトリ階層が異なる</h3>
先述しましたが、

Neovimだと、/.config/nvim/init.vimになります。

Vimだと、</del>/.vimrcなので、

Neovimのほうが階層深めですね。</p>
まあ、requireとかで分けて呼び出すこともできるので、

これは正直どっちでも良いような気もしますし、

慣れのような気もします。</p>
ちなみに、私はやっていませんが、

NeovimとVimで設定を使い分けていたりすると、</mark>

楽しいかもしれません。</mark>

(NeovimはIDE寄り、Viｍは素の設定寄りのように)</mark></p>
設定例については、本記事の最後でサンプルコードを掲載しております。</p>
アンドゥコマンドの挙動</h3>
</p>
左がNeovim、右がvim</em></p>
アンドゥコマンド(u)の挙動が微妙に異なります。</p>
上記の画像のとおりですが、履歴のみなし方が、</strong>

VimとNeovimでは異なります。</strong></p>
これは、正直好みでしょうね。

もう慣れている方が使いやすいに尽きると思います。</p>
私は、Neovimのほうが長いので、

Neovimの挙動のほうが直感的に感じます。</p>
init.vimと.tmux.confのサンプルコード</h2>
せっかくなので、

私のinit.vimをさらします。</p>
細かい設定や、キーマップとかは不十分なのと、

そこまでおすすめでもないプラグインもまざっているので、

こだわる人は、自分なりにカスタマイズしてください</p>
特にこだわりなければ、下記の設定でも、

VSCode不要で開発できるぐらいには、</strong>

NeovimやVimを使うことができます。</strong></p>
let</span> mapleader = "\<space>"</span></span>
set</span> shiftwidth=</span>2</span></span>
syntax</span>=</span>on</span></span>
set</span> showmode</span></span>
set</span> number</span></span>
set</span> tabstop=</span>2</span></span>
set</span> incsearch</span></span>
set</span> clipboard=unnamed</span></span>
set</span> cursorline</span></span>
highlight</span> CursorLine ctermfg=Blue ctermbg=Green</span></span>
set</span> cursorcolumn</span></span>
set</span> autoindent</span></span>
set</span> expandtab</span></span>
set</span> autowrite</span></span>
set</span> laststatus=</span>0</span></span>
set</span> list " 不可視文字を表示</span></span>
"set foldmethod=indent</span></span>
</span>
abbr</span> _sh</span> #!/bin/bash</span></span>
call</span> plug#begin</span>()</span></span>
Plug</span> 'ntk148v/vim-horizon'</span></span>
Plug</span> 'preservim/nerdtree'</span></span>
Plug</span> 'lambdalisue/fern.vim'</span></span>
Plug</span> 'nathanaelkane/vim-indent-guides'</span></span>
Plug</span> 'lambdalisue/fern-git-status.vim'</span></span>
Plug</span> 'neoclide/coc.nvim', {'branch': 'release'}</span></span>
Plug</span> 'junegunn/fzf', { 'do': {</span> -</span>></span> fzf#install</span>()</span> } }</span></span>
Plug</span> 'yuki-yano/fzf-preview.vim', { 'branch': 'release/rpc' }</span></span>
Plug</span> 'https://github.com/PhilRunninger/nerdtree-visual-selection.git'</span></span>
Plug</span> 'b4b4r07/vim-shellutils'</span></span>
Plug</span> 'https://github.com/alvan/vim-closetag.git'</span></span>
Plug</span> 'easymotion/vim-easymotion'</span></span>
Plug</span> 'preservim/nerdtree'</span> |</span></span>
            \</span> Plug 'Xuyuanp/nerdtree-git-plugin'</span></span>
Plug</span> 'https://github.com/posva/vim-vue.git'</span></span>
Plug</span> 'https://github.com/tyru/open-browser.vim.git'</span></span>
Plug</span> 'https:/github.com/lambdalisue/gina.vim.git'</span></span>
Plug</span> 'https://github.com/tpope/vim-commentary.git'</span></span>
Plug</span> 'https://github.com/tpope/vim-surround.git'</span></span>
Plug</span> 'https://github.com/simeji/winresizer.git'</span></span>
Plug</span> 'https://github.com/easymotion/vim-easymotion.git'</span></span>
Plug</span> 'junegunn/goyo.vim'</span></span>
Plug</span> 'https://github.com/Shougo/unite.vim.git'</span></span>
Plug</span> 'https://github.com/Shougo/neomru.vim.git'</span></span>
Plug</span> 'https://github.com/ctrlpvim/ctrlp.vim.git'</span></span>
Plug</span> 'https://github.com/vimplugin/project.vim'</span></span>
Plug</span> 'https://github.com/Quramy/tsuquyomi'</span></span>
Plug</span> 'https://github.com/vim-syntastic/syntastic'</span></span>
Plug</span> 'Shougo/vimproc.vim', {'do' : 'make'}</span> </span></span>
Plug</span> 'https://github.com/ycm-core/YouCompleteMe'</span></span>
Plug</span> 'vim-test/vim-test'</span></span>
Plug</span> 'https://github.com/vim-scripts/ScrollColors'</span></span>
Plug</span> 'kyazdani42/blue-moon'Plug 'https://github.com/AlessandroYorba/Breve.git'</span></span>
Plug</span> 'vim-jp/vimdoc-ja'</span></span>
Plug</span> 'https://github.com/leafgarland/typescript-vim.git'</span></span>
Plug</span> 'peitalin/vim-jsx-typescript'</span></span>
Plug</span> 'nvim-treesitter/nvim-treesitter', {'do': ':TSUpdate'}</span> </span></span>
call</span> plug#end</span>()</span></span>
let</span> g:ctrlp_user_command =</span> [</span>'.git'</span>,</span> 'cd %s && git ls-files']</span></span>
let</span> g:typescript_indent_disable =</span> 1</span></span>
inoremap</span> { {}</span><</span>LEF</span>T</span>></span></span>
inoremap</span> [ []</span><</span>LEFT</span>></span></span>
inoremap</span> ( ()<LEFT></span></span>
inoremap</span> " ""<LEFT></span></span>
inoremap ' ''<LEFT></span></span>
inoremap jj <ESC></span></span>
nnoremap <silent> un :<C-u>Unite buffer<CR></span></span>
nnoremap <silent> unf :<C-u>Unite file<CR></span></span>
nnoremap <silent> ufr :<C-u>Unite file_rec<CR></span></span>
nnoremap <silent> ub :<C-u>Unite bookmark<CR></span></span>
nnoremap <silent> umru :<C-u>Unite file_mru<CR></span></span>
nnoremap <silent> ur :<C-u>Unite -buffer-name=register register<CR></span></span>
nnoremap <ESC><ESC> :nohlsearch<CR></span></span>
noremap ss ^</span></span>
noremap ;; $</span></span>
nnoremap <C-n> :NERDTree<CR></span></span>
nnoremap <C-t> :NERDTreeToggle<CR></span></span>
command! -nargs=0 Format :call CocAction('format')</span></span>
command! Solitary :echo '人生字を識るは憂患の始まり'</span></span>
command! SS :so ~/.config/nvim/init.vim</span></span>
command! Svs :source ~/.vimrc</span></span>
command! Co :colorscheme</span></span>
command  Eve :colorscheme evening</span></span>
clet mapleader = "</span>\<</span>spac</span>e</span>></span>"ommand! Bre :colorscheme breve</span></span>
command  Horizon :colorscheme horizon</span></span>
nmap <silent> <space>fmt <Plug>(coc-format)</span></span>
nmap gx <Plug>(openbrowser-smart-search)</span></span>
vmap gx <Plug>(openbrowser-smart-search)</span></span>
nnoremap <Leader>o :<C-u>execute "OpenBrowser" "file:///" . expand('%:p:gs?</span>\\</span>?/?')<CR></span></span>
let g:indent_guides_enable_on_vim_startup = 1</span></span>
let g:gitgutter_highlight_lines = 1</span></span>
let g:closetag_filenames = '*.html,*.xhtml,*.phtml,*.ctp,*.php,*.vue'</span></span>
set helplang=ja,en " vim help日本語化のため</span></span>
set</span> termguicolors</span></span>
" colorscheme slate</span></span>
"</span> colorscheme horizon</span></span>
" colorscheme hybrid</span></span>
"</span> colorscheme blue</span></span>
" colorscheme evening</span></span>
colorscheme blue-moon</span></span>
let g:lightline = { 'colorscheme': 'blue-moon' }</span></span>
</span>
"</span> Rubyの文法チェック"</span></span>
augroup rbsyntaxcheck</span></span>
  autocmd!</span></span>
  autocmd BufWrite *.rb w !ruby -c</span></span>
augroup END</span></span>
</span>
" ファイル名表示</span></span>
set</span> statusline=%F</span></span>
</span>
let</span> g:syntastic_always_populate_loc_list =</span> 1</span></span>
let</span> g:syntastic_auto_loc_list =</span> 1</span></span>
let</span> g:syntastic_check_on_open =</span> 1</span></span>
let</span> g:syntastic_check_on_wq =</span> 0</span></span></code></pre>
基本的には、

.vimrcでも同様に作用するはずです。</p>
プラグインのインストールは、

上記では、vim-plugを使っているので、

:PlugInstallで導入できます。</p>
詳しい導入手順については、

下記の記事をご参考ください。</p>
[st-card myclass="st-no-shadow" id="93" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
あと、これは完全におまけですが、

Neovim(IDE寄り)を使う際は、

個人的には、Tmuxも必須なので、

そちらも一旦さらします。(そこまで凝った設定はしておりません)</p>
set</span> -g</span> prefix C-s</span></span>
unbind</span> C-b</span></span>
</span>
bind</span> d split-window</span> -h</span></span>
bind</span> v split-window</span> -v</span></span>
bind</span> s choose-tree</span> -Zw</span></span>
bind</span> r source-file ~/.tmux.conf</span> \;</span> display "Reloaded!"</span></span>
bind</span> h select-pane</span> -L</span></span>
bind</span> j select-pane</span> -D</span></span>
bind</span> k select-pane</span> -U</span></span>
bind</span> l select-pane</span> -R</span></span>
</span>
set</span> -g</span> base-index</span> 1</span></span>
set-option</span> -g</span> mouse on</span></span>
</span>
set-window-option</span> -g</span> mode-keys vi</span></span>
set-option</span> -g</span> status-right-length</span> 190</span></span>
</span>
set</span> -g</span> status-bg "colour52"</span></span>
set</span> -g</span> status-fg "colour93"</span></span>
set-option</span> -g</span> status-left  "</span>\</span></span>
#[bg=colour129]#[fg=colour255] #S:#I.#P "</span></span>
</span>
set-option</span> -g</span> status-interval</span> 1</span></span>
set-option</span> -g</span> status-justify centre</span></span>
</span>
set-option</span> -g</span> status-right "</span>\</span></span>
#[fg=colour93]#[bg=colour52]</span>\</span></span>
 #h #(echo '嗟嘆') </span>\</span></span>
#[fg=colour255]#[bg=colour52]</span>\</span></span>
%Y/%m/%d(%a) %H:%M:%S"</span></span>
</span>
setw</span> -g</span> window-status-current-format '\</span></span>
#[fg=colour249]#[bg=colour234]#[bg=colour239]#[fg=colour119]\</span></span>
#I#[fg=colour220]:#[fg=colour255]#W#[fg=colour249]\</span></span>
#F#[fg=colour239]#[bg=colour234]'</span></span>
</span>
bind</span> -T</span> copy-mode-vi v send-keys</span> -X</span> begin-selection</span></span>
bind</span> -T</span> copy-mode-vi V send-keys</span> -X</span> select-line</span></span>
bind</span> -T</span> copy-mode-vi C-v send-keys</span> -X</span> rectangle-toggle</span></span>
bind</span> -T</span> copy-mode-vi y send-keys</span> -X</span> copy-selection</span></span>
bind</span> -T</span> copy-mode-vi Y send-keys</span> -X</span> copy-line</span></span>
bind-key</span> -n</span> WheelUpPane if-shell</span> -F -t</span> = "#{mouse_any_flag}" "send-keys -M" "if -Ft= '#{pane_in_mode}' 'send-keys -M' 'select-pane -t=; copy-mode -e; send-keys -M'"</span></span></code></pre>
Tmuxの詳細については、下記の記事でも紹介しています。</p>
[st-card myclass="st-no-shadow" id="143" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
vimやNeovimについて本格的に勉強したい方は、

書籍もおすすめです。</p>


  
  
    
  </div>
  
  
    マスタリングVim [ Ruslan Osipov 著、大倉 雅史 訳 ]</p>
    
      Amazonで見る</a>
      楽天市場で見る</a>
    </div>
  </div>
</div>


  
  
    
  </div>
  
  
    【中古】Vimテクニックバイブル 作業効率をカイゼンする150の技 /技術評論社/Vimサポ-タ-ズ（単行本（ソフトカバー））</p>
    
      Amazonで見る</a>
      楽天市場で見る</a>
    </div>
  </div>
</div>


  
  
    
  </div>
  
  
    実践Vim　思考のスピードで編集しよう！【電子書籍】[ Drew　Neil ]</p>
    
      Amazonで見る</a>
      楽天市場で見る</a>
    </div>
  </div>
</div>


【Tmux入門】インストールから操作設定まで完全解説
2023-01-24T00:00:00+00:00
本ブログでは、

主にVim/Neovim系の記事が多いのですが、

Vim/Neovimには、どんなときにも一緒に戦う相棒が存在します。</p>
それがTmuxです。</strong></p>
Tmuxだけでもダメですし、

Vimだけでもだめです。</p>
Tmux +Vimでこそ、</mark>

真のターミナルVim環境が完成します。</mark></p>
本記事では、そんなVimの相棒のTmuxについて、

インストールから設定の詳細まで解説します。</p>
動画でご覧になりたい方は、

下記をご参考ください。</p>


  </iframe>
</div>
Tmuxとは?</h2>
まず、Tmuxとは何者でしょうか？

よく端末多重化ソフトウェアと称されることが多い、Tmux。</p>
ぶっちゃけよくわかんないですよね。

平たく言うと、ターミナルを便利にしてくれるもので、

分割とか、新しいウインドウとかの管理を楽にしてくれ、

使いこなせば、ディレクトリごとにターミナルを管理といったことも容易にしてくれます。</strong></mark></p>
https://github.com/tmux/tmux/wiki/Getting-Started</a></p>
VimはVSCodeみたいに、

簡単にターミナルをマウスでぐにゅっと引っ張り出してくる機能はないので、

ターミナルの相棒みたいなやつが便利です。

(プラグインのtoggletermで近いことはできますが。参考記事</a>)</p>
このターミナルの相棒がTmuxなのですが、

これを入れると、Vim単体ではできないことも実現できるようになり、

統合的なターミナルVim環境が完成します。</p>
以下、インストールから操作まで解説していきます。</p>
Tmuxのインストールから起動</h2>
Macの場合、Homebrewでインストールできます。</p>
brew install tmux</span></span></code></pre>
Homebrewについては、

下記の記事でも言及しているので、

よろしければご参考ください。</p>
[st-card myclass="st-no-shadow" id="295" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
さて、インストールしたら、

早速起動してみます。</p>
そのままtmuxというコマンドを打ちます。</p>
tmux</span></span></code></pre>
</p>
下にステータスバーが追加されました。

もう、私は何年もTmuxを使用しない生活をしていません。</p>
このステータスバーで優しく包み込んでくれるターミナルじゃないと、

ダダをこねるようになってしまいました。</p>
さて、具体的な使い方です。

試しに下記のコマンドを打ってみます。</p>
tmux</span> ls</span></span></code></pre>
</p>
こんな感じで、

windowsの一覧が表示されていれば、tmuxが起動できています。</p>
ちなみに、tmux lsコマンドは、

セッションの一覧を表示するコマンドです。</strong>

(セッションについては、後で解説します)</p>
Tmuxの設定ファイルは、

~/.tmux.confというもので、

設定したら、</p>
tmux</span> source-file ~/.tmux.conf</span></span></code></pre>
で設定を読み込むことができます。</p>
以下、細かい概念の解説や、

設定について深掘りしていきます。</p>
Tmuxの概念</h2>
TmuxもVimと同じで、

奥が深く、極めようとするとそこそこ学習コストがかかります。</p>
ただ、最低限便利なものを使うだけであれば、</mark>

そこまでハードルは高くありません。</mark></p>
Tmuxの概念も、全部を覚えるよりは、

必要最低限知っておけばおそらく十分かと思います。</p>
下記では、必要最低限知っておきたい概念を解説します。</p>
セッション</h3>
これは、平たく言うとウインドウの集合体のようなものです。

イメージとしては、ターミナルのウインドウを複数開いているような感じです。</p>
先程、tmux lsコマンドを紹介しましたが、

これはこのセッションを確認するコマンドです。</p>
</p>
上記の画像だと、0セッション、

3セッション、5セッションの3つのセッションがあることがわかります。</p>
セッション名は、それぞれ0、3、5ですね。</p>
デフォルトだと、このように数字がセッション名になるので、

ちょっとわかりにくいですよね。変更することもできます。</p>
変更方法としては、いくつかありますが、

よく使うのは、プレフィックスキー(後で解説します) + $です。</strong></p>
これを押すと、

下記のように名前を変更できるモードに入ります。</p>
</p>
あとは、好きなセッション名を入力して

エンターを押せば変更できます。</p>
コマンドで変更することも可能で、</p>
tmux</span> rename-session</span> -t</span> 古いセッション名 新しいセッション名</span></span></code></pre>
のような感じでも変更できます。</p>
あとは、プレフィックスキー + :でTmuxのコマンドを打つことができるモードに入れますが、

そこで、</p>
:rename-session</span> <</span>nam</span>e</span>></span></span></code></pre>
でも変更できます。

(ちなみに、:renameと省略することもできます)</p>
使いやすいものを使えばいいかなと思います。</p>
さて、こうしたセッションですが、

Tmuxで一度に入ることができる(アタッチ)、セッションは一つのみです。</p>
なので、セッションを複数作っても、</strong>

そのターミナルに表示できるのは、</strong>

一つのセッションのみという特徴があります。</strong></p>
ターミナルのウインドウ集合体に似ているとはいえ、

ターミナルのウインドウは、複数ひらっきぱなしにできますが、

Tmuxは一つしかひらっきぱなしにできないので、

(あくまで一つのターミナルウインドウに対してという意味)</p>
ウインドウの集合体とは少々異なる側面もあります。</p>
ただ、セッションによって、

例えば、セッション名 Rubyでは、

Rubyの案件の環境を構築し、

セッション名 Pythonでは、

Pythonの案件の環境を構築し、

分けることができるのが大きなメリットです。</p>
Rubyのセッションに接続しているときは、

Pythonの環境は全く見えません。

独立しているのがメリットですね。</p>
イメージとしては、

それぞれのプライベートターミナル環境を作っていくような感じです。</p>
ウインドウ</h3>
お次は、ウインドウです。</p>
ややこしいのですが、Tmuxでのウインドウは、

一般的なイメージのウインドウとは異なり、</mark>

タブのようなイメージです。</mark></p>
平たく言うとペインの集合体のようなものでして、

ターミナルのタブを複数開いているというのが近い状態だと思います。</p>
まあ、一つの画面のような感じですかね。</p>
ウインドウの一覧は、

プレフィックスキー + wで確認できます。</p>
</p>
上記の場合、4windowあることが確認できます。</p>
イメージとしては、VSCodeでファイルを開きすぎたときに、

そうしたファイルの一覧がウインドウみたいな感じですね。</p>
ウインドウ名を変えたいときは、

プレフィックスキー + ,で変更するモードに入れます。</p>
デフォルトだと、zshのような、

シェルの名前になっていることが多いかと思うので、

気に入らなかったら変更しましょう。</p>
ペイン</h3>
これは、平たく言うと、ウインドウの中にある個々のターミナル画面のことです。</p>
</p>
例えば、このように、4分割された</strong>

ターミナルがあるとすると、この4分割された一つ一つ、</strong>

すなわち4つの画面がペインであり、</strong>

このウインドウは4つのペインを持っているということになります。</p>
中央下のstatus lineにある、

1:zsh 2:zshとかは、ウインドウで、

この4分割のやつは、ウインドウ3になります。</p>
つまり、セッションの場合は、

4つのウインドウをもっていますね。</p>
アタッチ</h3>
さて、Tmuxの画面に関する用語は、

上記のような感じです。

次に操作の用語です。</p>
まずは、アタッチですね。

既に少し出てきましたが、

これは、セッションに接続することを指します。</mark></p>
最初にターミナルを開いた状態だと、

tmuxに接続していないかと思うので、

tmux lsで現在のセッションを確認して、

入りたいセッションに対して、</p>
tmux a -t セッション名</span></span></code></pre>
を実行すると、そのセッションに接続して、

いつものようにtmuxのステータスバーにお会いできるというわけです。</p>
デタッチ</h3>
これに対して、セッションから抜ける用語もあります。

デタッチです。</p>
デタッチとは、セッションを破壊することなく、セッションから抜けることです。</mark>

本来であれば、プレフィックスキー + dでできますが、

私の場合、そこまで頻繁にデタッチするわけではないので、

画面分割のショットカットキーに割り当ててしまっています。</p>
そのような場合、プレフィックスキー + dと打ってもデタッチできないので、

プレフィックスキー + : detach-clientと入力してデタッチします。</p>
余談ですが、tmuxのメリットの一つとして、

ターミナルクラッシュに強いというのがあります。</p>
tmuxを使っていなければ、

突然ターミナルがクラッシュした場合、

カレントディレクトリの場所や、Neovimとかもすべて閉じられてしまいますが、

tmuxだと、上記のクラッシュはデタッチになるので、

開き直して、アタッチすれば、

すぐ復元できるというメリットがあります。</p>
なので、デタッチに関しては、

ターミナルを終了するでも、

概ね似たような結果になるかなと思います。

(ターミナルクラッシュに関して言えば、

稀にセッションが吹き飛んで、復元できないこともないわけではないので過信は禁物だが)</p>
プレフィックスキー</h3>
「さっきから、当然のようにプレフィックスキーって

出てくるけど、これって何なん？」

申し遅れました。説明していなかったですね。</p>
プレフィックスキーとは、tmuxの各種操作をする上で必要となるキーのことで、</mark>

ショットカットみたいなものです。</mark></p>
基本的に、Tmuxの場合、先程のデタッチのように、

プレフィックスキー + 何かというのがほとんどで、

プレフィックスキーと何を押すかで適用する操作を変えていきます。</p>
そのため、このプレフィックスキーは、

tmuxを使う上では一番操作するキーになるのですが、

デフォルトだと、プレフィックスキーは、

Ctrl + bになっています。</p>
ただ、これはめちゃくちゃ押しづらいので、変更したほうが良いかなと思います。</p>
変更方法としては、</p>
set</span> -g</span> prefix C-s</span></span>
unbind</span> C-b</span></span></code></pre>
このような記述を、tmuxの設定ファイルに書き込みます。</p>
tmuxの設定ファイルは、ホームディレクトリ直下の、

.tmux.confです。</p>
上記の場合、プレフィックスキーをCtrl + sに変更しています。

C-の部分は、Ctrlということですね。</p>
Tmuxで最低限覚えておきたい概念は、

これぐらいでしょうか。</p>
あとは、使って覚えましょう。</p>
Tmuxチートシート</h2>
tmuxで頻繁に使う操作は、

実はそこまで多くはないので、

一旦、ここにあるやつだけ使うでも</strong>

かなり便利になります。</strong></p>

操作</td> キーバインド</td></tr>
新規ウインドウの作成</td> プレフィックスキー + c</td></tr>
次のウインドウに移動</td> プレフィックスキー + n</td></tr>
前のウインドウに移動</td> プレフィックスキー + p</td></tr>
指定した番号のウインドウに移動</td> プレフィックスキー + ウインドウ番号</td></tr>
ウインドウ一覧表示</td> プレフィックスキー + w</td></tr>
ウインドウ名変更</td> プレフィックスキー + ,</td></tr>
コピーモード開始</td> プレフィックスキー + [</td></tr>
デタッチ</td> プレフィックスキー + : detach-client</td></tr>
セッション名変更</td> プレフィックスキー + $</td></tr>
現在のペインを一時的に最大化(戻すときも同様のキー)</td> プレフィックスキー + z</td></tr>
ペインのサイズ変更(上は-U、下は-D、右は-R、左は-L)</td> プレフィックスキー + :resize-pane -U(D,R,L) 数字</td></tr>
サスペンド</td> プレフィックスキー + Ctrl + z</td></tr>
時計を表示</td> プレフィックスキー + t</td></tr>
</table>
あとは、ペイン関係のキーがありますが、

デフォルトのキーバインドは、

ちょっと押しづらいので、

私は変更しています。</p>
bind</span> d split-window</span> -h</span></span>
bind</span> v split-window</span> -v</span></span>
bind</span> s choose-tree</span> -Zw</span></span>
bind</span> r source-file ~/.tmux.conf</span> \;</span> display "Reloaded!"</span></span>
# vimのキーバインドでペインを移動します。</span></span>
bind</span> h select-pane</span> -L</span></span>
bind</span> j select-pane</span> -D</span></span>
bind</span> k select-pane</span> -U</span></span>
bind</span> l select-pane</span> -R</span></span></code></pre>
bind dは、プレフィックスキー + d</strong>のことで、

上記の場合、縦に分割します。</p>
bind vは横に分割し、

bind sは、ウインドウ一覧を表示します。</p>
bind rは、.tmux.confファイルを再読み込みします。</p>
あとは、vimのおなじみのキーバインドで、

ペインを移動できるように設定しました。</p>
[st-card myclass="st-no-shadow" id="11" label="あわせて読みたい" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
[st-card myclass="st-no-shadow" id="873" label="あわせて読みたい" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>


【Vim/NeoVimプラグイン】これだけは入れておきたいプラグイン10選
2023-01-23T00:00:00+00:00
プラグインをどれだけ入れるかは、

その人の思想なども関係するので、

一概にこれがいいというのはないかもしれません。</p>
プラグインを全く入れない人もいれば、

100個以上入れる人もいます。</p>
ただそれでも、これだけは入れておきたいプラグインというのも存在すると思います。</strong></p>
本記事では、そんなプラグインをいくつか紹介します。

プラグインを使いこなせれば、冗談抜きでVSCodeを超えることもできます。</p>
プラグインに頼りすぎると、

管理が複雑になったり、素のVimの機能を疎かにしてしまったりという、

デメリットもありますが、使わないプラグインをいれすぎなければ、

大丈夫だと思います。</p>
Vimにプラグインを導入するのは、

初めてという方は、まず本記事で紹介したプラグインを</strong>

導入してみるのをおすすめします。</strong></p>
プラグインの導入方法</h2>
早速、プラグインを導入していきたいと思います。</p>
導入方法としては、私は執筆時点では、

vim-plugを使ってインストールをしています。</p>
プラグインマネージャーは色々あるので、

vim-plugじゃないとだめということはありません。

各々お好きなプラグインマネージャーをご使用ください。</p>
プラグインを導入するのが初めてで、

プラグインマネージャーって？という方は、

こちらの記事</a>で、解説と導入方法を解説しているので、

御覧ください。</p>

</blockquote>
Vim系のプラグイン</h2>
さて、そんなプラグインですが、

プラグインにも色々ありまして、

主にVim scriptで書かれており、

昔から使われている歴史の長いプラグイン。

(私はこれらをVim系のプラグインと呼んでいます)</p>
これに対して、ここ数年で登場し、

リッチな操作性やモダンなUIが魅力の、

lua製のプラグイン。

(私はこれらは、Neovim系のプラグインと呼んでいます。)</p>
一概にどちらがいいということは、

ありません。</p>
ただ、パフォーマンス面では、

Neovim系が、安定感ではVim系に

軍配があがることが多いかと思います。</p>
同じようなことを実現するプラグインにも、

種類が色々あったりするので、

自分が最もしっくりくるプラグインを見つけられるのがベストですよね。</p>
大まかに私が考えるプラグインの種類としては、</p>
[st-mybox title="ポイント" webicon="st-svg-check-circle" color="#FFD54F" bordercolor="#FFD54F" bgcolor="#FFFDE7" borderwidth="2" borderradius="5" titleweight="bold" fontsize="" myclass="st-mybox-class" margin="25px 0 25px 0"]</p>

ファイラー系(代表例 NERDTree、Fern、Telescope.nvim)</li>
文法系 (代表例 coc.nvim、nvim-treesitter</li>
ファイル検索系(代表例 Unite.vim、Ctrlp.vim、Telescope.nvim)</li>
見た目系プラグイン(代表例 ScrollColors、Winresizer.vim、tokyonight.nvim)</li>
Git系 (代表例 vim-fugitive、gitsigns.nvim)</li>
ターミナル系プラグイン (代表例 toggleterm.nvim、vim-quickrun)</li>
その他便利系 (代表例 vim-commentary、open-browser.vim)</li>
</ul>
このような感じですかね。</p>
ジャンルの分け方は、

人によって違う気もしますが、

私の場合は、だいたい上記のような感じです。</p>
基本的に、上記のジャンルのプラグインを一つずつ設定していけば、

VSCodeは簡単に超えられると思います。</p>
下記で、いくつかまずは、

Vim系のプラグインをご紹介します。</p>
NERDTree</h3>
前回の記事を御覧頂いた方は、

またかよって感じかもしれませんが、

すみません、また</strong>です。</p>
NERDTreeです。</p>
下記の記事で詳細に解説しました。</p>
[st-card myclass="st-no-shadow" id="93" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
詳細は、上記の記事に

譲りますが、ファイラー系プラグインの中では、

私はもっとも気に入っています。</p>
FernやNeovim系でも、

良いプラグインはたくさんあるのですが、

私は、NERDTreeの操作性に馴染みすぎてしまったのと、

今更移行するのが面倒なので、

NERDTreeを使っています。</p>
Vim系プラグインでは、自信を持っておすすめできます。</p>
Unite.vim</h3>
1つ目は、unite.vimというプラグインです。

https://github.com/Shougo/unite.vim</a></p>
こちらは、結構有名なプラグインで、

統合ユーザーインターフェースと呼ばれることが多い、

要はなんでもできるプラグインです。</p>
call</span> plug#begin</span>()</span></span>
Plug</span> 'https://github.com/Shougo/unite.vim.git'</span></span>
call</span> plug#end</span>()</span></span>
nnoremap</span> <</span>silen</span>t</span>></span> un :</span><</span>C-</span>u</span>></span>Unite buffer</span><</span>C</span>R</span>></span></span>
nnoremap</span> <</span>silen</span>t</span>></span> unf :</span><</span>C-</span>u</span>></span>Unite file</span><</span>C</span>R</span>></span></span>
nnoremap</span> <</span>silen</span>t</span>></span> ufr :</span><</span>C-</span>u</span>></span>Unite file_rec</span><</span>C</span>R</span>></span></span>
nnoremap</span> <</span>silen</span>t</span>></span> ub :</span><</span>C-</span>u</span>></span>Unite bookmark</span><</span>C</span>R</span>></span></span>
nnoremap</span> <</span>silen</span>t</span>></span> umru :</span><</span>C-</span>u</span>></span>Unite file_mru</span><</span>C</span>R</span>></span></span>
nnoremap</span> <</span>silen</span>t</span>></span> ur :</span><</span>C-</span>u</span>></span>Unite</span> -buffer-name=register</span> register</span><</span>C</span>R</span>></span></span></code></pre>
使用頻度が高いのは、

上記でのUnite bufferコマンドで、

これは、バッファー一覧を表示してくれます。</p>
</p>
画面上部に表示されている</em></p>
これの何が便利かいうと、

一度開いたファイルなどを、

簡単に開き直すことができる点にあります。</strong></p>
これにより、複数のファイルの行き来が楽になるので、

一気にIDE感が出てきます。</p>
Unite.vimの設定は、結構奥が深く、

こんなのはまだ序の口です。

だが、その序の口のレベルでも格段に便利になるので、

必須のプラグインと言えるでしょう。</p>
Unite.vimを極めたい人は、

ぜひ本家のリポジトリのコードを熟読してみてください。</p>
ただ、最近は更新が止まっているっぽいので、

その点は、少々残念なところですね。</p>
Neovim系のtelescope.nvimでも、

Unite.vimと似たようなことができるので、

最近は、こちらを採用している人も、

増えてきている気がしますね。

(まあ、両方使うとかでもいいと思いますよ)</p>
Vim-commentary</h3>
お次は、vim-commentaryです。</p>
こちらは、選択した行とかをコメントアウトできるという、</mark>

シンプルなプラグインです。</mark></p>
https://github.com/tpope/vim-commentary</a></p>
シンプル故に使いやすいです。

基本は、ノーマルモードでgccでコメントアウトし、

ビジュアルモードとかでgcで選択範囲を一気にコメントアウトできます。</p>
細かい使い方の説明は、こちらを御覧ください

https://github.com/tpope/vim-commentary/blob/master/doc/commentary.txt</a></p>
多くの言語に対応してはいるのですが、

たまにVue.jsとかみたいにjsとhtmlが混ざったようなパターンとかだと、

上手く置換してくれなかったりします。</p>
その場合は、プラグインに頼るというより、

Vimのマクロとかを使えば解決できるので、

まあ大きな問題というわけではないでしょう。</p>
ちなみに、マクロについては、

下記の記事で解説しています。</p>
[st-card myclass="st-no-shadow" id="873" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
なんだかんだで、

普段使うプログラミング言語って、

多くても3 ~ 6種類ぐらいかと思うので、

それぐらいのパターンであれば、</mark>

自分でマクロとか関数を組んでしまうということも正直可能かと思います。</mark></p>
なので、このプラグインについては、

必須で導入したいというほどのものではないのですが、</p>
コード量も少なく、

Vim scriptの参考リポジトリとしても

使えると思ったので、ご紹介しました。</p>
Vue.jsとかでうまく補完されないとは言いつつも、

それでもほとんどの場合これで十分で、

コメントアウトに関してはもうVSCodeと遜色ない感じになるかと思います。</p>
Ctrlp.vim</h3>
これは、VSCodeでいう、

command + pでできるファイル検索ツールみたいなものです。</p>
https://github.com/ctrlpvim/ctrlp.vim</a></p>
もともとVSCode出身の人は、

あの検索を必ずやっているかと思うので、

Vimでも似たような機能はほしいと思うはずです。</p>
正直、似たようなことは、

telescope.nvimでもできるのですが、

シンプルなVim系プラグインとしては、

このCtrlp.vimもおすすめです。

(telescope.nvim強すぎる)</p>
ノーマルモードでCtrl + pを押せば、</strong>

起動し、早速検索できます。</strong></p>
</p>
例えばviewと検索してみたら、このように表示されました。</p>
起動して、ctrl + fとかを押すと、

検索対象をバッファーとかに切り替えられるので、

先程のUnite.vimと似たようなこともできます。</p>
概ね使いやすいプラグインでは、ありますが、

稀に新規で作成したばっかのファイルとかは、

検索対象に出てこなかったりするので、

その辺は、少々物足りないかもしれないですね。</p>
Winresizer.vim</h3>
お次は、winresizer.vimです。</p>
こちらは、シンプルなプラグインで、

ウインドウのサイズ調整を簡単にできるプラグインです。</p>
https://github.com/simeji/winresizer</a></p>
もともと、Vimはシンプルなことをやるエディタで、

UNIXの思想も、小さいソフトウェアのような感じなので、

このような機能が限定的なプラグインは、

ある意味本流のような気もします。</p>
それにVimの場合、

GUIエディタじゃないので、

こういう画面幅を調整するって、

地味に苦戦するんですよね。

(VSCodeだと、マウスでぐにゅっとするだけなので、

ここに関しては、VSCodeのほうが優れています。)</p>
なので、たかがウインドウサイズの調整、

されど、ウインドウサイズの調整という感じです。</p>
ウインドウサイズの調整をバカにする者は、</strong>

ウインドウサイズの調整に泣きます。</strong>

(私です。上司とペアプロしているとき、画面幅の調整の仕方が

分からず爆死しました。その日は家で大泣きしました。)</p>
さて、使い方ですが、

デフォルトだと、Ctrl + Eで起動し、</mark>

そのまま、j,k,l,hとおなじみのvimの方向キーマップで、</mark>

直感的にサイズ調整できます。</mark></p>
</p>
こんな感じに、VSCodeみたいな、

2ファイル開いて、下にターミナルみたいな構成も、

ラクラク実現可能になります。</p>
ちなみに、このVSCodeのような、

UIは、toggletermというターミナルのプラグインと、

素のvimのvsコマンドとかでも実現できます。</p>
これで、VSCode勢に絡まれても、

「わいだって、VSCode構成できるもん」って

対抗できますね。</p>
Vim-indent-guides</h3>
お次は、vim-indent-guidesです。</p>
こちらもシンプルで、

インデントを見やすくしてくれるプラグインです。

(さっきからシンプル系しか紹介していないですね。)</p>
https://github.com/nathanaelkane/vim-indent-guides</a></p>
IndentGuidesEnableみたいなコマンドを打つことで、

見やすくしてくれますが、

基本的に常時オンにしておいたほうがいいと思うので、</p>
let</span> g:indent_guides_enable_on_vim_startup =</span> 1</span></span></code></pre>
を記述して、vim起動時に有効になるようにしておくと便利です。</p>
こういうインデント系のプラグインも、

色々あるので、これが必ず良いというわけではありません。</p>
最近は、Neovim系の方でも、

良いプラグインが出てきているので、

そっちを使うのもありだと思います。</p>
ただ、良くも悪くも、

Neovim系のプラグインは、

Vimでは使えないかと思うので、

Vim script製で同じことが実現できるプラグインを知っておくことも</strong>

悪くはないと思い、紹介しました。</strong></p>
(試しに、toggleterm.nvimを.vimrcに導入してみましたが、

そもそもlua 記法が.vimrcでは使えないので、

設定を読み込めずに使えませんでした。

なので、lua記法の設定が不要なプラグインなら、

もしかしたら使えるものもあるかも？いずれにしろ、

ベースがluaなので、何かと厳しそうですが。基本は使えないと

思っていた方が良さそうです。相性が悪いのは間違いないです。

ただ、絶対に使えないというわけではない気もしていて、

何らかのやり方はあるのかもしれないです。)</p>
Neovim系のプラグイン</h2>
Vim系のプラグインをいくつか紹介したので、

お次にNeovim系をいくつかご紹介したいと思います。</p>
Neovimの一つの大きなメリットとして、

Neovim製のプラグインも使えるということがあります。</strong></p>
当たり前だろって思うかもしれませんが、

先述のように、Vimではtoggleterm.nvimとかは

使えません。</p>
けれどもNeovimなら、上記でご紹介した、

Vim scriptベースのVim系プラグインはすべて使用できます。

(極稀にVimでしか使えないVim系プラグインもありますが、

かなり少ないです。)</p>
なので、プラグインについては、

正直Neovimの方に軍配が上がります。</p>
このようなNeovimとVimの違いについては、

下記の記事をご参考ください。</p>
[st-card myclass="st-no-shadow" id="172" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
Telescope.nvim</h3>
Neovim系で、最初にご紹介するのは、

telescope.nvimです。</p>
https://github.com/nvim-telescope/telescope.nvim</a></p>
これは、完全にチートプラグインで、

Neovimを乗っ取ります</p>
このプラグインでできないことを探すことの方が難しい、

数々の他のプラグインを葬ってきた、</strong>

万能型プラグインです。</strong></p>
正直、このレベルのプラグインは、

私の管見ではVim系には存在しない気がするので、

これを入れるためだけにNeovimを使うのも有りだと思います。</p>
ただ、あまりにいろんなことをやりすぎていて、

シンプルなことをやる、小さいソフトウェアである、

UNIX的思想から外れまくっているので、

生粋のVim教徒の方は、邪道と感じるかもしれません。</p>
実際に、こういうのばっか使っていると、

Vimのマクロとか、素のVimに搭載されている機能とかも

使わなくなっていく気もします。</p>
そう考えると、文字通り、

Vimを乗っ取る可能性があるプラグインなので、

恐ろしいですね。</p>
「は、Vimの思想なんかどうだっていいよ、

便利ならいいだろ」っていう方も

多いと思うので、その場合は、

ガンガン使いましょう。</p>
ちなみに、下記の動画で、

telescope.nvimのハンズオンをしています。</p>


  </iframe>
</div>
今まで紹介してきた、

unite.vimとかctrlp.vimはなんだったんだって思わせるぐらいの

破壊力ですよね...</p>
coc.nvim</h3>
お次は、coc.nvimです。</p>
https://github.com/neoclide/coc.nvim</a></p>
これもtelescope.nvimに負けておりません。</p>
文法系プラグインの最高峰です。

Vimは、VSCodeとかに比べると、

文法の補完がいまいちと言われがちですが、

coc.nvimを入れれば、そんなことは言わせません。</p>
デメリットは、設定が難しいことです。</p>
巨大なプラグインなので、

使いこなすのは簡単ではありません。</p>
TypeScript環境のCoc.nvimでの構築は、

下記の記事で詳細に解説しています。</p>
https://qiita.com/reisuta/items/725e3d88a48b09376dd1</a></p>
正直、私もまだ完全に使いこなせているわけではありません。

機能が多すぎます。</p>
恐ろしや。けれども便利なので、

いれてしまうんですよね。</p>
toggleterm.nvim</h3>
恐ろしいプラグインが続いたので、

少々シンプルなプラグインを紹介します。

(それでもまあまあ多機能)</p>
toggleterm.nvimです。</p>
これは、Neovimを開いている際に、</mark>

ターミナルを簡単に召喚できるプラグインです。</mark></p>
個人的には、こういうプラグインをずっと探していたので、

初めて見つけたときは、感動しました。</p>
これで、Neovimで開発しているときに、

いちいちTmuxの別のペインに移動しなくても良くなりますね。</p>
Railsとかだと、やれRubocopだ、Rspecだ、

Gitだと、実行するコマンドが地味に色々あるので、

サクッと召喚して実行できるプラグインは、

ものすごく便利です。</p>
詳細な解説は、下記の動画でハンズオンしているので、

ぜひとも御覧ください。


  </iframe>
</div>
</p>
gitsigns.nvim</h3>
お次は、gitsigns.nvimです。</p>
https://github.com/lewis6991/gitsigns.nvim</a></p>
こちらは、文字通り、

Git系のプラグインでして、

差分を色付きで見やすくしてくれたりと、</mark>

VSCodeで当たり前にやっていることを</mark>

Vimでもできるようにするプラグインです。</mark></p>
個人的なイチオシ、Git blameの常時表示ができるので、

かなり便利だなと思いました。</p>
こちらについても、

詳細なハンズオンは、

下記の動画でご紹介しております。</p>
このプラグインについては、

割と詳細に解説しているので、

ぜひとも御覧ください。


  </iframe>
</div>
</p>
追記: barbar.nvim</h3>
こちら、追記プラグインです。</p>
https://github.com/romgrk/barbar.nvim</a></p>
これは、タブを見やすくしてくれるプラグインです。</p>
オプションでgitsigns.nvimなどを入れると、

Gitのハイライトなどを加えることもできます。</p>
README.mdによると、

いつものように、vim-plugなどでインストールすれば、

良さそうです。</p>
しかし、公式に載っているマッピングだと、

一部機能しないものがありました。</p>
どうも<A-1>とかを<C-1>とかに修正しても反映されなかったのですが、

他の、<C-t>とかはしっかり有効になっているので、

現状、この不具合はまだよくわかっておりません（プラグイン側のエラー?)</p>
lua製のプラグインなので、

vim-scriptベースではなく、

luaで書き直したら解決する不具合かもしれません。</p>
ちなみに、<A-とかではなく、

bufのように、シンプルなキーにしたら、

反映されました。</p>
プラグイン自体は、素晴らしいので、

この不具合は解決したいですね。</p>
VimやNeovimを極めるために</h3>
VimやNeovimを本格的に勉強するのにおすすめの

書籍を紹介します。</p>
Vimの本はあまり多くありませんが、

これらの本を読むと、

新しい発見があったりするので、

Vimを極めたい人にはおすすめです。</p>


  
  
    
  </div>
  
  
    実践Vim　思考のスピードで編集しよう！【電子書籍】[ Drew　Neil ]</p>
    
      Amazonで見る</a>
      楽天市場で見る</a>
    </div>
  </div>
</div>


  
  
    
  </div>
  
  
    【中古】Vimテクニックバイブル 作業効率をカイゼンする150の技 /技術評論社/Vimサポ-タ-ズ（単行本（ソフトカバー））</p>
    
      Amazonで見る</a>
      楽天市場で見る</a>
    </div>
  </div>
</div>


  
  
    
  </div>
  
  
    マスタリングVim [ Ruslan Osipov 著、大倉 雅史 訳 ]</p>
    
      Amazonで見る</a>
      楽天市場で見る</a>
    </div>
  </div>
</div>


【Vim/Neovimキーマップ】map/noremapやLeaderキー
2023-01-20T00:00:00+00:00
VimやNeovimを使っていくにあたって、

どのようなキーマップを設定するかは、

その人の個性であり、答えのない探求です。</p>
それぐらい、キーマップの設定は、</mark>

Vimを使いこなす上で必須の設定と言えます。</mark></p>
しかし、そうした探求をするためにも、

そもそもどのようにしてキーマップを設定するのか知る必要があるでしょう。</p>
本記事では、.vimrcやinit.vimのキーマップの設定方法は、</strong>

もちろん、map系やのnoremap系など基本的なマッピングの種類についても解説します。</p>
また、キーマップを設定する上で、Leaderキー</strong>というものを設定することも

多いので、そちらについても併せて解説します。</p>
それ以外にも、ユーザ定義コマンドなど、短縮入力に役立つ設定方法も解説します。</strong></p>
記事ではなく、動画で視聴したいという人は、

下記が本記事の該当動画です。</p>


  </iframe>
</div>
また、Vimの基本的な操作がまだ良くわからないという人や、

これからVimに入門するという人は、

下記の動画でVimについて完全解説しているので、

よろしければご覧ください。</p>


  </iframe>
</div>
VimやNeovimのマッピングの種類</h2>
VimやNeovimには、

マッピングコマンドが複数存在しています。</p>
そして、意外と複雑です。

軽く表にまとめてみますと、下記のようになります。</p>

map系</td> noremap系</td> モード</td></tr>
map</td> noremap</td> ノーマルモード、ビジュアルモード</td></tr>
nmap</td> nnoremap</td> ノーマルモード</td></tr>
vmap</td> vnoremap</td> ビジュアルモード</td></tr>
imap</td> inoremap</td> インサートモード</td></tr>
cmap</td> cnoremap</td> コマンドラインモード</td></tr>
tmap</td> tnoremap</td> ターミナルモード</td></tr>
</table>
上記の表の説明としては、

mapとか、noremapというのがコマンドであり、</mark>

それぞれ、表に対応するモードにおいて、</mark>

設定したマッピングが有効になるという感じです。</mark></p>
例えば、</p>
map</span> tt i</span></span></code></pre>
と設定すると、

ノーマルモードか、ビジュアルモードのどちらかで、

ttと入力すると、iが入力されたことになるという感じです。</p>
この文法自体は、他のマッピングコマンドでも同様で、

左に入力するもの、右に実行するものという風にします。</strong></p>
※ちなみに、上記の表はやや簡易版で、他のモードとして選択、オペレータ待機などが

ありますが、使用頻度は高くない気がしたので、省略しています。気になる人は、

こちらのサイトが詳しいので参考にしてください。

map - Vim日本語ドキュメント (vim-jp.org)</a></p>
map系とnoremap系の違い</h2>
さて、説明ではmapで説明しましたが、

例えばmapコマンドには、対応するものとして、

noremapがありました。</p>
これらの違いは、再帰的なマッピングかどうかということです。</strong></p>
はい、これじゃ意味分かんないですよね。

具体例をあげると、</p>
map</span> o i</span></span>
map</span> ss o " ssを入力するとiが入力されたことになり、挿入モードに</span></span>
</span>
noremap o i</span></span>
noremap ss o " ssを入力するとoが入力されたことになり、新しい行を追加し挿入モードに</span></span></code></pre>
つまり、map系の場合、

実行コマンドのマッピングも再帰的にたどっていくのに対し、

noremap系は辿らず、設定されたコマンド文字通りの意味で解釈されるということですね。</strong></p>
おそらく、noremap系の方が挙動としては直感的だと思うので、

基本的には、noremap系を使えばいいかなと思います。</p>
私の感覚では、このmapとnoremapの特徴の違いをクリティカルに利用して、

キーマップの設定をする機会は、あまりない気がするので、

ややこしければ、片方だけ使うとかでも良いと思います。</mark></p>
マッピングの設定例</h3>
試しにマッピングの設定例について、

紹介したいと思います。</p>
inoremap</span> { {}</span><</span>LEF</span>T</span>></span> </span></span>
inoremap</span> [ []</span><</span>LEFT</span>></span></span>
inoremap</span> ( ()<LEFT></span></span>
inoremap</span> " ""<LEFT></span></span>
inoremap ' ''<LEFT></span></span>
inoremap jj <ESC></span></span>
nnoremap <ESC><ESC> :nohlsearch<CR></span></span>
noremap ss ^</span></span>
noremap ;; $</span></span>
nnoremap <C-t> :NERDTreeToggle<CR></span></span></code></pre>
<LEFT>は、矢印キーで、

<Up>,<Down>,<Right>などもあります。</p>
上記の場合、{ などと入力したあと、{}の左矢印なので、

{}の中に入るという感じだ。</p>
つまり、{ と入力したら、</strong>

自動的に閉じカッコも補完するようにするマッピングという感じですね。</strong></p>
<C-t>は、Control + tで、

<CR>はenterです。</p>
<C-でControlを表すので、

たとえば、<C-s>とかは、

Control + sになります。</p>
このあたりは、NerdTreeの解説のときにも説明したので、

こちらの記事</a>も参考にしていただけると。</p>
[st-card myclass="st-no-shadow" id="93" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
現時点では、まだ10行ほどですが、

プラグインを導入した際などは、

いやでもキーマップを設定したくなると思うので、

キーマップの設定は徐々に増えていくでしょう。</p>
自分だけのカスタムキーマップを定義してみてください。</p>
Leaderキーとユーザー定義コマンド</h2>
上記で、基本的なキーマップについて、

紹介しましたが、今度は上記以外で、

キー入力を楽にする手伝いをしてくれるものを

2つ紹介します。</p>
Leaderキー</h3>
Leaderキーとは、自分で好きなキーを設定して、</mark>

マッピング定義などの際に使用できる、</mark>

いわばカスタムキーのようなものです。</mark></p>
例えば、</p>
map</span> <</span>leade</span>r</span>></span>p i</span></span></code></pre>
という風にして、

設定の自由度を上げることができます。</p>
デフォルトでは、Leaderキーはバックスラッシュ( \ )ですが、

めちゃくちゃ押しづらいので、基本変更するでしょう。</p>
変更の仕方としては、</p>
let</span> mapleader = "\<space>"</span></span></code></pre>
のようにします。</p>
この場合、spaceキーがleaderキーに割り当てられます。</strong></p>
これで、上記のマッピングでは、

spaceキーとpで挿入モードに入ることになります。</p>
Leader キーにどのキーが設定されているか調べたいときは、</p>
:echo mapleader</span></span></code></pre>
でも確認できます。</p>
デフォルトのままで、何も設定していない場合は、

undefined variable mapleaderのようなエラーが出るかと思います。</p>
上記のように、spaceキーにLeaderキーを設定した場合は、

echo 空白のような感じになるので、実際にはなにも表示されないような感じになるかと思います。</p>
spaceキーに設定した場合、空白文字がechoされて、

ちゃんと設定できているか、わかりにくいので、

適当にleaderキーのマッピングを設定して試した方が手っ取り早い気もします。</p>
ユーザ定義コマンド</h3>
キーマップに関連したものとして、

leaderキー以外にも、

ユーザー定義コマンドというものがあります。</p>
皆さんは、コマンドラインモードで、

いつでも自分の好きな言葉を呼び出せたらいいと思ったことはないでしょうか？

ちなみに、私が好きな言葉は、人生字を識るは憂患の始まりという、言葉です。</p>
Vimで作業しているとき、

ふとこの文字が見たくなったとき、

コマンドラインモードでいちいち</p>
:echo</span> '人生字を識るは憂患の始まり'</span></span></code></pre>
などと打つのは、あまりにもかったるいですよね。</p>
もちろん、上記で設定したキーマップを設定して、

例えば、Leaderキーで、</p>
nmap</span> <</span>Leade</span>r</span>></span>a :echo '人生字を識るは憂患の始まり'</span><</span>C</span>R</span>></span></span></code></pre>
のように設定するのもありでしょう。</p>
ただ、このようにして、

好きな言葉を無数にキーマップしていたら、

名前が衝突したり、デフォルトのキーバインドと重複したりと、

メンテナンスが大変になります。</p>
その場合、キーマップにするよりも、

コマンドラインモードで直接呼び出せた方が便利だったりします。</p>
そこで、コマンドのショットカット的なものを設定したいとき、

Vimだとどうするのか、</p>
command!を使えば解決です。</strong></p>
command</span>! Solitary :echo '人生字を識るは憂患の始まり'</span></span></code></pre>
これで、コマンドラインモードでSolitaryと打てば、

いつでも我が座右の銘を召喚できます。</p>
あとは、もっと実用的なコマンドとしては、.vimrcをいちいち再読み込みするのが

面倒なので、そちらもコマンドにしてしまうのもいいでしょう。</p>
command</span>! SS :so ~/.vimrc</span></span></code></pre>
:soは:sourceの略であり、.vimrcを再読み込みする。

ちなみに、すでに.vimrcを開いているときは、

:so %でも同様。</p>
キーマップの設定のサンプルコード(.vimrc)</h2>
最後に前回までの記事とと本記事の設定を反映した、

.vimrcを紹介します。</p>
前回の記事は下記で、

setのオプションについての記事です。</p>
[st-card myclass="st-no-shadow" id="104" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
下記の部分で、setの詳しい意味について、

知りたい方は、上記の前回の記事をご参考ください。</p>
let</span> mapleader = "\<space>"</span></span>
set</span> number</span></span>
set</span> showmode</span></span>
set</span> shiftwidth=</span>2</span></span>
set</span> cursorline</span></span>
set</span> cursorcolumn</span></span>
set</span> incsearch</span></span>
set</span> hlsearch</span></span>
map</span> <</span>leade</span>r</span>></span>p i</span></span>
inoremap</span> { {}</span><</span>LEF</span>T</span>></span></span>
inoremap</span> [ []</span><</span>LEFT</span>></span></span>
inoremap</span> ( ()<LEFT></span></span>
inoremap</span> " ""<LEFT></span></span>
inoremap ' ''<LEFT></span></span>
inoremap jj <ESC></span></span>
nnoremap <ESC><ESC> :nohlsearch<CR></span></span>
noremap ss ^</span></span>
noremap ;; $</span></span>
nnoremap <C-t> :NERDTreeToggle<CR></span></span>
command! Solitary :echo '人生字を識るは憂患の始まり'</span></span>
command! SS :so ~/.vimrc</span></span>
call plug#begin()</span></span>
  Plug 'https://github.com/preservim/nerdtree'</span></span>
call plug#end()</span></span></code></pre>


【Vim/Neovimオプション】setコマンドとオプション一覧
2023-01-16T00:00:00+00:00
Vimを使うにあたって、.vimrcの設定は欠かせないが、

まず始めに設定したいのは、setのオプション関係でしょう。</p>
本記事では、Vimを使い始めたら、</mark>

まずは、設定したいオプションの紹介とsetの使い方などを解説します。</mark></p>
文字より動画で視聴したい方は、

下記が本記事の内容を解説した動画になります。</p>


  </iframe>
</div>
Vimの導入をまだしていない方は、

下記の動画で完全解説しているので、

ご参考ください。</p>
下記動画一本で、Vimの基本事項はマスターできます。</p>


  </iframe>
</div>
setコマンドとは何か？</h2>
setとは、コマンドの一種で、vimに様々な設定を適用させることができるものです。</strong>

そして、この適用可能な設定をoptionと呼び、</strong>

setは、optionを設定するコマンドです。</strong></p>
オプションの一覧は、

下記のサイトなどが詳しいです。</p>
options - Vim日本語ドキュメント (vim-jp.org)</a></p>
上記のドキュメントを見るとわかりますが、

笑っちゃうぐらいたくさんのオプションがあります。</p>
中には、いつ使うねんって言う感じの

オプションもあって、面白いので、

暇な人は読んで見てください。</p>
さて、脱線しましたが、

具体的な使い方としては、</p>
:se[t]</span> {option}</span> </span></span>
:se[t]</span> no{option}</span></span></code></pre>
のようにコマンドモードで使用すると、

そのオプションが有効になります。</p>
なお、setと打たないで、

seだけでも適用できます。</p>
また、設定を無効にしたい場合h、

上記にあるように、noをoptionの前につけるとできます。</p>
optionの末尾に、?をつけると、

その設定が有効かどうかの確認ができます。</p>
代表的なオプション</h2>
number</h3>
まず最初に設定したいのは、

やはりこれでしょう。</p>
:set numberとすることで、

行番号を付与することができる。</p>
</p>
コーディングをする以上、

行番号はやはりないと不便なもの。</p>
このように常に適用したいやつとかに関しては、

上記のようにいちいちコマンドラインモードで有効にするのではなく、

.vimrcに記載してしまいましょう。</strong></p>
set</span> number</span></span></code></pre>
ちなみに、カーソルからの相対番号にする設定も可能で、

その場合は、</p>
:set number rnu</span></span></code></pre>
のようにすると有効にできる。</p>
</p>
なんか、グラフ理論っぽい、番号配置になっている気がします。</p>
ちなみに、numberについては、

省略形としてnuも使えます。</p>
showmode</h3>
これを設定すると、

現在のモードがステータス行に表示されるようになる。</p>
:set</span> showmode</span></span></code></pre>
</p>
下にINSERTと表示されているのがわかります。</p>
こちらの設定も適用させないメリットはないと思うので、

ぜひとも設定したいですね。</p>
まあそうは言っても、Vimの場合、

デフォルトでONになっているオプションではありますが。</p>
省略形はsmdになります。</p>
set cursorline</h3>
カーソル行をハイライトします。</p>
</p>
15行目がハイライトされていますね。</p>
設定しておいた方が、便利で見やすいと

推奨です。</p>
省略形は、culですね。</p>
set cursorcolumn</h3>
こちらは、cursorlineの列バージョンです。</p>
カーソル列をハイライトします。

上記の画像だと、setのeの列、二列目がハイライトされていますね。</p>
省略形は、cucです。</p>
set incsearch</h3>
何も設定していない状態で検索をしても、

マッチしている部分がハイライトされないため、

検索ができているのかわかりにくい。</p>
ちなみに、検索は、

コマンドモードで/を入力して、

検索したい文字を入力してエンターで検索できます。</p>
そこで、下記のように</p>
:set</span> incsearch</span></span></code></pre>
と設定すると、</p>
</p>
/setと検索した際にハイライトされる。</em></p>
見やすくなるかと思います。</p>
またこちらは、検索したい文字を入力している最中でも</strong>

ハイライトされるため、検索を多用する際は、</strong>

非常に便利です。</strong></p>
省略形は、isです。</p>
ハイライトされているときに、CTRL-L を押すと、その後ろの文字が

コマンドラインへ入力されます。</p>
上記の画像の場合、一度CTRL-Lを押すと、

スペースがコマンドラインへ入力され、もう一度押すと、

s、その次は、hというふうに入力されます。</p>
set hlsearch</h3>
上記の、incsearchだけだと、

マッチした部分すべてをハイライトしてくれないため、

こちらの設定で検索にマッチした部分をすべてハイライトしてくれる。</p>
</p>
Plugと検索したら、マッチしている部分がすべてハイライトされた</em></p>
人によるかもしれませんが、

やはりこちらの方が見やすいですかね？</p>
set shiftwidth</h3>
vimでは、>>や<<と入力すると

インデントを適用することができる。

その際に、デフォルトでどれぐらいインデントさせるかを設定するのが、

このshiftwidthになる。</p>
</p>
set shiftwidth=2で設定して>>を実行すると二文字ずれるのがわかる</em></p>
デフォルト設定だと8になっているが、

ほとんどの場合、8個分もインデントを入れたいケースはないかと思われる。</p>
なので、こちらも2などで設定することが多い印象です。</strong></p>
オプションを.vimrcにまとめる</h2>
さて、色々のオプションを紹介しましたが、

numberのところで触れた通り、

いちいちコマンドラインモードで有効にするなんていう、

かったるいことはできません。</p>
なので、.vimrcに記載して、

デフォルト設定にしてしまいましょう。</p>
set</span> number</span></span>
set</span> showmode</span></span>
set</span> shiftwidth=</span>2</span></span>
set</span> incsearch</span></span>
set</span> hlsearch</span></span>
set</span> cursorline</span></span>
set</span> cursorcolumn</span></span></code></pre>
となる。</p>
ちなみに、色々なオプションを有効にしていると、

たまには素のVimで修行したくなるときがあります。</p>
そんなときは、</p>
vim -u NONE .vimrc</span></span></code></pre>
のようにすると、

例えば上記で設定したオプションなどは、</strong>

無効にされた初期状態で開けます。</strong></p>
本記事では、やや素のVimよりの話でしたが、

こちらの記事</a>のようなプラグインの紹介なども行っているので、

ご参考ください。</p>
[st-card myclass="st-no-shadow" id="133" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>


Vim/NeoVimプラグインのNERDTree導入でVSCode化
2023-01-11T00:00:00+00:00
本記事では、主にプラグインの導入方法を解説します。</strong>

導入するプラグインとしては、NERDTreeという、</mark>

ファイルエクスプローラープラグインをインストールします</mark>。</p>
NERDTreeは使用者も多く、

導入すると、劇的にVimが変化するので、

お試しプラグインとしておすすめできます。</p>
対象読者としては、</p>
こんな方におすすめ</p>

Vimを使えるようになりたいけど、とっかかりが見つからない人</li>
VSCodeからVimやNeovimに移行して、使えるようになりたい人</li>
プラグインを導入方法が知りたい人</li>
</ul>
などが主です。</p>
慣れれば、NERDTree以外のプラグインも、

自分なりにカスタマイズして導入できるようになります。</p>
**本記事では、**Vimの設定を何もしていない状態から、

NERDTreeというプラグインをインストールして、

プラグイン導入の初めの一歩を踏み出します。</mark></p>
併せて、NERDTreeの基本操作についても

解説します。</p>
記事ではなく、動画で観たい方は、

下記をご参考ください。


  </iframe>
</div>

また、Vim全般について、0から解説している、

総集編動画もありますので、

併せて御覧ください。


  </iframe>
</div>
</p>
プラグイン導入方法</h2>
Vim設定ファイルの場所</h3>
まず、Vimの設定ファイルは、

~/.vimrc</strong> にあります。</p>
</p>
ホームディレクトリ直下ですね。</p>
もしこのファイルがなければ、

作成しましょう</p>
touch</span> ~/.vimrc</span></span></code></pre>
Vimの設定は、

基本的にすべてこのファイルに記述していきます。</p>
ちなみに、NeoVimの場合は、

~/.config/nvim/init.vimに記述します。</strong></p>
Neovimの場合は、Luaの設定ファイルである、

init.luaで記述することも可能です。</p>
プラグインマネージャーのインストール</h3>
さて、設定ファイルが見つかったところで、

早速プラグインを導入していきます。</p>
一個一個ダウンロードして、

自分で管理するという方法もありますが、

それだと、Updateや依存関係なども、

割りと綿密に管理する必要があるので、

面倒です。</p>
なので、基本的には、プラグインマネージャー</strong>という

プラグインをまとめて管理してくれるツールを使用するのが無難でしょう。</p>
有名なプラグインマネージャーとしては、

vim-plug、dein.vim、Vundleなど色々あります。</strong></p>
使いやすいものや気に入ったものを使って管理するのが

いいと思います。(ちなみにNeovimだと、luaで書くために、

これらとは別のプラグインマネージャーを使うことが多いです。)</p>
私は、vim-plugを使っているので、

本記事では、vim-plugの導入方法で進めていきます。</strong></p>
vim-plugは、使用者も多く、

直感的に使用できるので、

初めて使うプラグインマネージャーとしておすすめできます。</p>
Vim-plug</a></p>
vim-plugのインストール</h4>
vim-plugのインストール方法は、

基本的に上記のgithubに則って行えばいいのですが、

一応貼っておきます。</p>
curl</span> -fLo</span> ~/.vim/autoload/plug.vim</span> --create-dirs \</span></span>
    https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim</span></span></code></pre>
記法としては、

call plug#begin()とcall plug#end()で</mark>

使用するプラグインを挟み込むようにして記述します。</mark></p>
call</span> plug#begin</span>()</span></span>
Plug</span> 'junegunn/vim-easy-align'</span></span>
call</span> plug#end</span>()</span></span></code></pre>
上記だと、vim-easy-alignというプラグインをインストールします。</p>
このあと、:PlugInstallを実行すれば

間に記載したプラグインをインストールしてくれます。</p>
基本的な使い方としては、

これだけなので、シンプルで使いやすいかなと思います。</p>
NERDTreeインストール</h3>
プラグインマネージャーも導入したので、

早速NERDTreeをインストールしてみたいと思います。</p>
NERDTreeとは、

ファイルエクスプローラプラグインで、

ディレクトリなどをツリー上に表示できたり、

ファイルにアクセスしやすくするプラグインです。</strong></p>
</p>
こんな感じに左側にファイルのリスト並べて、ファイルを開くのが直感的になる。</em></p>
NERDTreeのような、ファイルエクスプローラプラグインを使うと、

一気にVSCodeのように、ファイルの移動が楽になります。</p>
NERDTree</a></p>
NERDTreeだけでも、十分VSCodeっぽくなりますが、

他に、unite.vimやctrlp.vimなども入れると、

より検索性が上がって便利になります。</p>
詳しくはこちらの記事</a>で紹介しております。</p>
[st-card myclass="st-no-shadow" id="133" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
さて、NERDTreeのインストールは、

基本的には、上記のgithubの手順に従いインストールします。</p>
といっても、やることはシンプルで、</p>
call</span> plug#begin</span>()</span></span>
  Plug</span> 'preservim/nerdtree'</span></span>
call</span> plug#end</span>()</span></span></code></pre>
を記述するだけです。</p>
先程のvim-plugの記法の説明に戻りますと、

上記のように、Plugという風に使用したいプラグインを指定します。

githubのURLを指定しても問題ないので、</p>
call</span> plug#begin</span>()</span></span>
  Plug</span> 'https://github.com/preservim/nerdtree'</span></span>
call</span> plug#end</span>()</span></span></code></pre>
としても大丈夫です。</p>
余談ですが、urlを指定してインストールすれば、

open-browser.vimというプラグインで、

URLを開く際に、すぐにプラグインのgithubに飛ぶことができるというメリットがあります。</p>
https://github.com/tyru/open-browser.vim</a></p>
さて、少し脱線しましたが、

記述したら、先述のように

vim-plugの場合、:PlugInstall</strong>を実行する必要があります。</p>
一旦、.vimrcを保存して、

vimを再度開いて、</p>
:PlugInstall</span></span></code></pre>
</p>
こんな感じですね。

実行すれば、インストールできるはずです。</p>
あとは、上記のPlugInstallコマンドと同じように、</p>
:NERDTree</span></span></code></pre>
でファイルが表示されます。</p>
NERDTreeの設定</h2>
いちおうここまでで、

NERDTreeを使うことができるようになりましたが、

毎回:NERDTreeなどと打つのは面倒です。</p>
なので、keymapに設定してしまうのが</mark>

便利だと思います。</mark></p>
やり方としては、公式でも紹介されていますが、</p>
nnoremap</span> <</span>C-</span>t</span>></span> :NERDTreeToggle</span><</span>C</span>R</span>></span></span></code></pre>
のようにすると、良いかなと思います。</p>
これで、Ctrl + tでNERDTreeを表示したり、

非表示にしたりできます。</strong></p>
nnoremapは、キーマップの設定で、

<C-t>を :NERDTreeToggle<CR>と打ったのと同じことにします。</p>
<C-t>は、Ctrl + tで、<C-でCtrlと何かという風になります。

最後の<CR>はenterと同じ意味です。</p>
上記のnnoremapのようなキーマップの詳細については、

下記の記事で解説しているので、詳しくはこちらを御覧ください。</p>
[st-card myclass="st-no-shadow" id="119" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
NERDTreeで覚えておきたい操作チートシート</h2>
これで、基本的なNERDTreeの使い方としては、

十分かと思います。</p>
最後に、NERDTreeのチートシートを掲載しておきます。</strong></p>

コマンド</td> 内容</td></tr>
o または enter</td> ファイルやフォルダを開く</td></tr>
O</td> 再帰的にディレクトリをすべて開く</td></tr>
x</td> 親ディレクトリを閉じる</td></tr>
X</td> 再帰的にディレクトリを閉じる</td></tr>
go</td> ファイルを開く(カーソルはツリーのまま)</td></tr>
t</td> タブでファイルを開く</td></tr>
i</td> 水平分割でファイルを開く</td></tr>
s</td> 垂直分割でファイルを開く</td></tr>
C</td> ツリーのルートを選択したディレクトリにする</td></tr>
u</td> ツリーのルートを上の階層にする</td></tr>
r</td> 選択したディレクトリを再読み込み</td></tr>
m</td> メニューを表示(ファイルやディレクトリの追加削除などができる)</td></tr>
I</td> 隠しファイルの表示、非表示</td></tr>
</table>
この中でも、よく使うのは、

mコマンドからのファイルの追加・削除ですね。</p>
あとは、Vimの場合、VSCodeのように、

リアルタイムに変更が検出されるわけでもなかったりするので、

rコマンドの再読み込みも、そこそこ使います。</p>
oコマンドは、ファイルやフォルダを開くコマンドですが、</strong>

正直enterしか使ったことありません。</strong></p>
あと、Cやuは、現在のディレクトリ階層を変えられるので、

地味に便利なコマンドなのですが、使用シーンはやや少なめなので、

毎回忘れて、「どうやるんだっけ」ってなるコマンドです。</p>
地味に、.gitとか.gitignoreを見たいときもあるので、

Iコマンドもよく使います。</p>
最初のうちは、どれがどれだっけってなると思うので、

慣れないうちは上記の表を見ながら操作になれると良いと思います。</p>
NERDTree以外のプラグインがいい人へ</h2>
ファイラーのプラグインとしては、

NERDTreeが、おそらく一番有名かと思います。</p>
そして、NERDTreeが、一番直感的かつ、

シンプルで使いやすいプラグインだと思うので、

本記事でもこちらのインストールを紹介しました。</p>
しかし、昨今だと、

ややNERDTreeはレガシーな部類に入ってくる印象があります。

(全然普通に使えるんですけどね。)</p>
なので、必ずしも万人にNERDTreeが適しているかと言われると、

微妙かもしれません。</p>
他にもファイラー系のプラグインで、

良いものはたくさんあると思います。</p>
Neovim製の、似たようなプラグインとしては、

Telescope.nvimのようなものもあります。


  </iframe>
</div>

※ 正確にはTelescope.nvimはファジーファインダーなので、NERDTreeとは、

少しタイプが違うのですが、大まかなジャンルが同じなので、紹介しております。</p>
これ以外だと、Fernなども有名かなと思います。</p>
https://github.com/lambdalisue/fern.vim</a></p>
ファイラーについては、正直個人の好みもあると思うので、

一概にどれがいいとも言えません。</p>
私は、NERDTreeの操作性に慣れてしまったのて、

今更移行するのが面倒で、半ば惰性で使っています...</p>
ただ、NERDTreeは、まあまあ無難な選択だとも思います。</p>
結論、まずはNERDTreeで色々試してみて、

慣れてきたら、いろんなプラグインに挑戦してみると、

面白いのでおすすめです。</p>


お問い合わせ
2023-01-03T00:00:00+00:00
当サイトへのご連絡は、以下の窓口で受け付けています。</p>
記事の誤り・技術的な指摘</h2>
技術記事の内容に誤りを見つけた場合や、動作しないコードがあった場合は、GitHub の
Issue でご指摘いただけると確実です。</p>

GitHub: reisuta</a></li>
</ul>
その他のご連絡</h2>
記事の内容に関する質問、執筆・仕事のご相談などは X（Twitter）のダイレクトメッセージ
でお願いします。</p>

X (Twitter): @xileng4</a></li>
</ul>
お返事について</h2>
個人で運営しているため、すべてのご連絡にお返事できるとは限りません。あらかじめ
ご了承ください。内容によっては、返信の代わりに記事の修正という形で反映することが
あります。</p>
当サイトの内容について</h2>
掲載している情報は執筆時点のものです。ソフトウェアのバージョン差異などにより、
現在は当てはまらない記述が含まれる場合があります。免責事項については
プライバシーポリシー</a>をご覧ください。</p>


Linuxコマンド基礎編 これだけは知っておきたい基本コマンド11選
2022-12-27T00:00:00+00:00
コマンドとは何か？</h2>
コマンドとは、コンピュータに対する命令のことです。</strong>

ブラウザのアイコンとかをクリックすると、ブラウザが起動しますが、

あれも内部的にはコンピュータに対してブラウザを起動させる命令となっています。</p>
コマンドも基本的にはそれと同様ですが、

命令を行う場所が、GUI(グラフィカルな部分。普段見ている画面)から</strong>

CUI(コマンドライン、ターミナルなどの黒い画面)に変わるようなイメージです。</strong></p>
「ターミナルってなんやねん」っていう人は、

下記記事を読むとわかりやすいかもしれません。</p>

</blockquote>
例えば、同じことを実現するにしても、

ChromeのアイコンをクリックするとChromeが開く(GUI)のに対し、

openコマンドというものを使って、

コンピュータにfirefoxを開けと命令する(CUI)など、

アプローチの仕方がそれぞれあります。

</p>
コマンドとは、上記のopenコマンドのような

CUIの方ですね。</p>
コマンドを実行するには、terminalというアプリが必要ですが、

普段GUIで作業していたことなどは、実はCUIのterminalからでも

行うことができます。</p>
そうした、様々な命令を行うものがコマンドで、

コマンドには色々種類があります。</p>
コマンドは、OSのタイプによっても、

微妙に異なっており、

最も一般的なLinuxコマンドです。</p>
Windowsなどにもコマンドがありますが、

Linuxとは異なるコマンドであることが多いです。

(例えば、dir(windows)とls(linux)のように)</p>
Macは、UNIX系のOSなので、

コマンドは、Linuxのものとほとんど同様です。</p>
なので、Linuxコマンドを学んでおけば、

Macの操作に関しては、楽勝ですね。</p>
以下、このLinuxコマンドについて詳しく触れていきます。</p>
Linuxコマンド基礎</h2>
Linuxコマンドも種類はたくさんありまして、

マイナーなものから有名なものまで様々です。</p>
また、使用頻度が高いものもあれば、

そこまで使わないものもあります。</p>
専門のサーバーエンジニアを目指すのであれば、

割りと幅広いコマンドを学ぶ必要がありますが、

Webエンジニアとかであれば、

とりあえず、最低限のコマンドさえ覚えれば一旦十分です。

(勉強しなくていいという意味ではなく、優先度を下げても

いいという意味です)</p>
下記では、「これは知らないと恥ずかしい」という

常識コマンドを紹介していきます。</p>
ちなみに、こういったLinuxコマンドとか、</mark>

Linuxの知識を体系的に勉強する手段としては、</mark>

資格試験のLPICとかもおすすめです。</mark></p>
私は執筆時点で、LPIC level2まで取得していますが、

特に、LPIC level1については、

重要かつよく使うコマンドが体系的にまとめられているので、

おすすめです。

(ネットワークのCCNAのような位置づけの資格試験ですね)</p>
ls</h3>
さて、少し脱線しましたが、

早速コマンドを紹介します。</p>
まず、1つ目に紹介するコマンドは、

おそらく一番使う機会が多いであろう、

lsコマンドです。</strong></p>
これは、カレントディレクトリ内のファイルやディレクトリを表示するコマンドです。</p>
カレントディレクトリとは、ユーザが現在作業中のディレクトリのことを指します。</strong></p>
ディレクトリとは、

フォルダのようなものと思っていただければ、

大丈夫です。</p>
WindowsのようなGUIのOSだと、

フォルダーという呼び方が一般的ですが、

Linuxとかだと、ディレクトリという呼び方が一般的です。</p>
Downloadsフォルダのことは、

Downloadsディレクトリという風に呼んだりしますね。</p>
コマンドの使用例としては、

下記のように、ターミナルにlsと打ち込みます。</p>
$</span> ls</span></span>
Desktop</span>          Downloads        Movies           Pictures         Public</span></span>
Documents</span>        Library          Music            Project          index.html</span></span></code></pre>
上記の場合、DesktopディレクトリやDownloadsディレクトリなどが、

カレントディレクトリにあることが、lsコマンドで確認できますね。</p>
ちなみに、「ユーザーが現在作業中のディレクトリ」とは、

どういうことかというと、

なにかのコマンドや操作をする際の基準となるディレクトリになるという感じです。</p>
例えば、冒頭のopenコマンドなどは、

そのカレントディレクトリのファイルを開くというようなイメージです。</p>
基本的に下記で紹介するコマンドは、

カレントディレクトリを基準として実行されるという点では、同様です。</p>
pwd</h3>
こちらのコマンドは、

カレントディレクトリの絶対パスを表示します。</strong></p>
絶対パスとは、ルートディレクトリからのフルパスのことを指します。</mark></p>
そもそもコンピュータの構造には、

ルートディレクトリというものがあり、

/ と表します。

すべてのファイルは、このディレクトリの下の階層に存在するので、

もっとも上の階層ということになります。</p>
例えば、Desktopディレクトリの絶対パスは、

Macとかだと、/Users/tarou/Desktop ような感じになります。</p>
これは、/ ディレクトリ配下にUsersというディレクトリがあり、

その下にtarouというディレクトリがあり、

その下にDesktopがあるという構造です。</p>
絶対パスは、カレントディレクトリがどこであろうと、

同一です。</p>
このような絶対パスに対して、

相対パスというものも存在します。</p>
こちらは、カレントディレクトリからのパスになります。</strong></p>
なので、/Users/tarouディレクトリに存在する場合、

(このようにユーザー名のディレクトリで、ターミナルを開いて

最初の位置のディレクトリをホームディレクトリと呼びます。)</p>
Desktopは、./Desktopというパスで表せます。

. という記法は、カレントディレクトリという意味です。

カレントディレクトリの下にDesktopがあるということですね。</p>
ちなみに、.. とすると、

ひとつ上のディレクトリを表します。</p>
以上、踏まえて、

pwdを使うと、</p>
$</span> pwd</span></span>
/Users/user1</span></span></code></pre>
のようになります。</p>
これは、ホームディレクトリのことですね。</p>
cd</h3>
これもlsと同じぐらい使う機会が多いコマンドで、

change directoryの略でcdです。

ディレクトリを変更するという名称そのまんまで、

カレントディレクトリを変更したいときに使います。</p>
カレントディレクトリの変更とはどういうことかというと、

適用させる場所を変えるという感じです。

(openコマンドで開くフォルダを変えるようなイメージです)</p>
カレントディレクトリを変えれば、

もちろん、絶対パスも変わるので、

pwdコマンドの挙動も変わってきます。</p>
vimとかで開きたいファイルが、

カレントディレクトリにない場合は、

そのディレクトリまで移動する方法(cdコマンド)と、

相対パスや絶対パスを指定して開く方法など、

色々ありますが、cdコマンドはそうしたまさに一手段ですね。</p>
実行例としては、</p>
$</span> pwd</span></span>
/Users/user1/desktop</span></span>
$</span> cd</span></span>
$</span> pwd</span></span>
/Users/user1</span></span>
$</span> cd /Users/user1/Downloads</span></span>
$</span> pwd</span></span>
/Users/user1/Downloads</span></span></code></pre>
cdでディレクトリを変更して、

pwdコマンドのパスが変わっているのが、

わかるかと思います。</p>
ちなみに、cdに何も引数を与えなければ、</mark>

ホームディレクトリに移動します。</mark></p>
source</h3>
上記の3つは、本当に常識レベルのコマンドです。

現役エンジニアで知らない人はいないレベルというか、

知らなかったら、かなりやばいレベルです。</p>
これらに比べると、sourceコマンドは、

ほんの少しだけマイナーです

(一ミリもマイナーじゃないですし、常識コマンドですが、

上記の3つよりはという相対比較です)</p>
このコマンドは、引数に与えられたファイルに書かれたコマンドを現在のシェルで実行するコマンドです。</strong>

.zshrcなど、シェルの設定ファイルをターミナルを再起動させずに適用したいときや、

シェルスクリプトを実行したいときなどに使います。</p>
シェルスクリプトとは、

これらのLinuxコマンドをプログラムに落とし込めるプログラミング言語でして、

より複雑な条件のもと(if文とか)で、

特定のLinuxコマンドを実行したいときなどに使用するものです。</p>
例えば、下記のように

.shという拡張子で作成します。</p>
#!/bin/bash</span></span>
echo</span> 'testシェルスクリプトです'</span></span></code></pre>
上記のシェルスクリプトは、

'testシェルスクリプトです'と表示してくれます</p>
上記のファイルにlsとかを記載したら、

lsが実行されます。</p>
このようにシェルスクリプトの実行のために、

sourceコマンドを使用することがあります。</p>
下記のようにして、実行します。</p>
$</span> ls</span></span>
test</span>.sh</span></span>
$</span> source test.sh</span></span>
testシェルスクリプトです</span></span></code></pre>
上記の3つに比べると、

使用頻度は少ないですが、

シェルスクリプトをゴリゴリ書くようになると、

使用頻度が上がるコマンドです。</p>
cp</h3>
こちらはコピーコマンドです。</strong>

ファイルやディレクトリをコピーできます。</strong></p>
第一引数にコピーされるファイルを、

第二引数にコピー先のファイルを指定します。</p>
例えば、下記の例だと、

test.shファイルをコピーした、

test1.shというファイルを作成します。</p>
$</span> ls</span></span>
test</span>.sh</span></span>
$</span> cp test.sh test1.sh</span></span>
$</span> ls</span></span>
test</span>.sh test1.sh</span></span></code></pre>
GUI上で、ファイルをクリックして、

コピーとかってやるんじゃなくて、

ターミナルでさくっとコピーできるようになったら、

エンジニア感出せますよ(笑)</p>
mkdir</h3>
こちらは、ディレクトリを作成するコマンドです。

基本的なコマンドではあるのですが、

最近は、IDEとか、プラグイン経由でファイルを作成できるので、

使用頻度は減ってきている印象があります。</p>
VimとかTmuxの設定ファイルを作成したりする際は、

意外と使うかもしれません。</p>
使用例は下記のような感じです。</p>
$</span> ls</span></span>
test</span>.sh</span></span>
$</span> mkdir test</span></span>
$</span> ls</span></span>
test</span>.sh test</span></span></code></pre>rm</h3>
ファイルやディレクトリを削除するコマンドです。</strong>

rmコマンドで削除してしまったものは、

復元ができないので、注意して実行する必要があります。</p>
GUI上のファイル削除となると、

ゴミ箱に入れるとかになると思うので、

仮に間違って削除しても

復元できますが、

rmコマンドで削除したら、基本的には、

もう復元できません。</p>
なので、不安な場合は

無理して使わなくても良いかもしれません。</p>
使用例としては、</p>
$</span> ls</span></span>
test</span>.sh test</span></span>
$</span> rm test.sh</span></span>
$</span> ls</span></span>
test</span></span></code></pre>
という感じです。</p>
ちなみに、下記のようなコマンドを使うと、

すべてのファイルを削除してしまうので、

絶対に実行してはいけません。(見るだけにしてください)

冗談抜きでPCが死にます。</p>
rm -rf /*</span></span></code></pre>
OSの破壊と同義なので、

繰り返しになりますが、実行しないでください。</p>
(どうしても実行したい変態の人は、

仮想環境など壊れてもいい環境で実行してください)</p>
ちなみに、下記の記事で、

上記コマンドを実行したらどうなるのかという、

なかなかにドMな取り組みをしていて面白かったので、

変態志向の人はご参考ください。</p>
https://dev.classmethod.jp/articles/tried-rm-rf-root-on-amazon-linux-2/</a></p>
touch</h3>
ファイルのタイムスタンプを更新するコマンドです。</p>
けれどもこのコマンドの面白いところは、

そうした正規の使い方で使うことがほとんどなく、

副作用のほうを目的として実行することです。</p>
というのも、引数で指定したファイルが存在しない場合、その空ファイルを作成するという副次効果が</mark>

あるので、その用途で使われることが多いです。</mark>(というか私はその用途以外で使ったことがありません。)</p>
実行例としては、下記のような感じで、

引数に作成したいファイル名を指定します。</p>
$</span> ls</span></span>
test</span></span>
$</span> touch test.sh</span></span>
$</span> ls</span></span>
test</span> test.sh</span></span></code></pre>cat</h3>
お、猫か？

って思うかもしれません、

こちらのコマンドは、ファイルの内容を表示するコマンドです。</p>
内容というのは、中身ですね。

たとえば、テキストファイルで、</mark>

こんにちはと書かれているファイルがあったとすると、</mark>

こんいちはとターミナルの標準出力に表示されます。</mark></p>
Vimとかでいちいち開くのが面倒なときに、

サクッと中身を確認したいときとかに使います。</p>
Linuxの基礎的な本とかだと、

割りと序盤に出てくるコマンドなので、

わりかし、初心者向けのコマンドみたいに思われがちですが、

catエディタ(後述)のような使い方も可能なため、

結構Linuxの本質的なコマンドの一つで、奥深いなと個人的には感じています。</p>
実行例としては、下記のような感じです。</p>
$</span> ls</span></span>
test</span>.sh</span></span>
$</span> cat test.sh</span></span>
#!/bin/bash</span></span>
echo</span> 'testシェルスクリプトです'</span></span></code></pre>
ちなみにcatは、パイプやリダイレクトといったシェルの機能をフル活用して、

中身を追記したりすることもできます。</p>
</p>
上記のようなのは、まだ序の口ですが、

これをめちゃくちゃフル活用して、

catエディタみたいな使い方をしている方もいるそうです。

(いるそうですというか、いたそうですの方が正しいかもしれません)</p>
エディタというのは、文字通りVimとかみたいに、

catでプログラミングするということですね。(笑)</p>
お使いのエディタはなんですか？って聞かれたら、

一度でいいからcatですって答えたいですね。</p>
grep</h3>
grepは、独学のときに使うことがなく、

実務に入ってから使うようになるコマンドの筆頭ともいえるもので、

簡単に言うと、ファイルやテキストなどの検索をするコマンドです。</strong></p>
grepは奥が深いので、

ここでは概要しか紹介しませんが、

気になる人は、grepの詳細解説の記事も御覧ください。

(※準備中です...)</p>
使い方を紹介します。

下記は、binという文字列をtest.shファイルから検索しています。</p>
$</span> ls</span></span>
test</span>.sh</span></span>
$</span> grep 'bin' test.sh</span></span>
#!/bin/bash</span></span></code></pre>
binが含まれている、

#!/bin/bashが表示されていますね。</p>
基本的に、grep 検索したい文字 対象ファイルという書式で

使用します。</p>
実務でよく使うパターンとしては、

メソッドや関数がどのへんで呼ばれているか目星をつけたりする際に

使用されることが多い気がします。</p>
例えば下記は、srcディレクトリ配下のすべてを検索対象として、

fetchApiFuncという文字列を検索します。</p>
$</span> grep 'fetchApiFunc' src/</span>*</span></span></code></pre>
grepは、git grepとかvim grepのような、

派生したgrepとかもたくさんあるので、

使いこなせるようになりたいコマンドの一つです。</p>
ちなみに、grepとかlsのような</mark>

基本コマンドは、最近ではripgrepとかexaのような、</mark>

上位互換コマンドもあり、そちらも熱いので、</mark>

興味がある方は、下記の記事もご参考ください。</mark></p>
[st-card myclass="st-no-shadow" id="156" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
less</h3>
こちらのコマンドは、

catに若干似ていますが、

ファイルの内容を確認できるコマンドです。</strong></p>
ただ、こちらはターミナルの標準出力に出すのではなく、

Vimとかのようにターミナルウインドウをまるごとファイルの内容を表示するという特徴があります。</p>
catもいいですが、

個人的にはlessのほうが手っ取り早いことも多いですね。</p>
less test.txt</span></span></code></pre>
</p>
lessの中での操作は、

Vimの基本操作とほぼ同様で、

抜けるときは、qを押します。</p>
Vimの基本的な使用方法については、

下記の記事を御覧ください。</p>
[st-card myclass="st-no-shadow" id="11" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
その他の有名コマンド</h2>
本記事では、代表的なコマンドと、

使い方の例を掲載しましたが、

各コマンドには、オプションも存在するため、

それらも合わせて知っておく必要がある。

(覚えることが多いですね)</p>
オプションとは、コマンドに与える、</mark>

フラグのようなものでして、</mark>

例えば、今回紹介した中だと、</mark>

rm -rfコマンドの、-rfの部分がオプションになります。</mark></p>
上記の場合は、ディレクトリも再帰的に、

確認無しでというオプションになります。</p>
他には、lsコマンドとかだと、

-aオプションを指定すると、

隠しファイルも表示してくれます。</p>
このようにオプションは、

コマンドに何らかの効果を与えるフラグのようなものですね。</p>
また、コマンドでも、

まだまだ重要なコマンドは、

残っていて、ぱっと思いつく限りでも、</p>
[st-mybox title="参考" webicon="st-svg-file-text-o" color="#757575" bordercolor="" bgcolor="#fafafa" borderwidth="0" borderradius="5" titleweight="bold" fontsize="" myclass="st-mybox-class" margin="25px 0 25px 0"]</p>

ping</li>
dig</li>
curl</li>
mv</li>
chmod</li>
which</li>
</ul>
などがあります。</p>
各コマンドのオプションの解説や、

上記コマンドの解説などについても、

また後に記事にしようと考えています。</p>
[st-card myclass="st-no-shadow" id="295" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>


プライバシーポリシー
2022-12-27T00:00:00+00:00
このサイトが収集する個人データと収集の理由</h2>
当サイトには、個人情報を入力していただくフォームはありません。

お問い合わせ</a>は GitHub および X（Twitter）を通じて受け付けており、これらの外部サービス上でのやりとりで得た情報は、そのご連絡への回答のためにのみ利用します。各サービスにおける個人情報の取り扱いは、それぞれの運営者のプライバシーポリシーに従います。</p>
基本方針</h2>
当サイトは、個人情報の重要性を認識し、個人情報を保護することが社会的責務であると考え、個人情報に関する法令を遵守し、当サイトで取扱う個人情報の取得、利用、管理を適正に行います。</p>
適用範囲</h2>
本プライバシーポリシーは、お客様の個人情報もしくはそれに準ずる情報を取り扱う際に、当サイトが遵守する方針を示したものです。</p>
個人情報の利用目的</h2>
当サイトは、お客様からご提供いただく情報を以下の目的の範囲内において利用します。</p>

ご本人確認のため</li>
お問い合わせ等の確認・回答のため</li>
メールマガジン・DM・各種お知らせ等の配信・送付のため</li>
キャンペーン・アンケート・モニター・取材等の実施のため</li>
サービスの提供・改善・開発・マーケティングのため</li>
お客さまの承諾・申込みに基づく、提携事業者・団体等への個人情報の提供のため</li>
利用規約等で禁じている行為などの調査のため</li>
その他個別に承諾いただいた目的</li>
</ul>
個人情報の管理</h2>
当サイトは、個人情報の正確性及び安全確保のために、セキュリティ対策を徹底し、個人情報の漏洩、改ざん、不正アクセスなどの危険については、必要かつ適切なレベルの安全対策を実施します。</p>
当サイトは、第三者に重要な情報を読み取られたり、改ざんされたりすることを防ぐために、SSLによる暗号化を使用しております。</p>
個人情報の第三者提供</h2>
当サイトは、以下を含む正当な理由がある場合を除き、個人情報を第三者に提供することはありません。</p>

ご本人の同意がある場合</li>
法令に基づく場合</li>
人の生命・身体・財産の保護に必要な場合</li>
公衆衛生・児童の健全育成に必要な場合</li>
国の機関等の法令の定める事務への協力の場合（税務調査、統計調査等）</li>
</ul>
当サイトでは、利用目的の達成に必要な範囲内において、他の事業者へ個人情報を委託することがあります。</p>
個人情報に関するお問い合わせ</h2>
開示、訂正、利用停止等のお申し出があった場合には、所定の方法に基づき対応致します。具体的な方法については、個別にご案内しますので、お問い合わせください。</p>
Cookie（クッキー）</h2>
Cookie（クッキー）は、利用者のサイト閲覧履歴を、利用者のコンピュータに保存しておく仕組みです。

利用者はCookie（クッキー）を無効にすることで収集を拒否することができますので、お使いのブラウザの設定をご確認ください。ただし、Cookie（クッキー）を拒否した場合、当サイトのいくつかのサービス・機能が正しく動作しない場合があります。</p>
広告について</h2>
当ブログでは、第三者配信の広告サービス（Googleアドセンス）を利用しており、ユーザーの興味に応じた商品やサービスの広告を表示するため、クッキー（Cookie）を使用しております。

クッキーを使用することで当サイトはお客様のコンピュータを識別できるようになりますが、お客様個人を特定できるものではありません。</p>
Cookieを無効にする方法やGoogleアドセンスに関する詳細は「広告 – ポリシーと規約 – Google</a>」をご確認ください。</p>
また、当ブログは、Amazon.co.jpを宣伝しリンクすることによってサイトが紹介料を獲得できる手段を提供することを目的に設定されたアフィリエイトプログラムである、Amazonアソシエイト・プログラムの参加者です。</p>
アナリティクス・アクセス解析ツールについて</h2>
当ブログでは、Googleによるアクセス解析ツール「Googleアナリティクス」を利用しています。このGoogleアナリティクスはトラフィックデータの収集のためにクッキー（Cookie）を使用しております。トラフィックデータは匿名で収集されており、個人を特定するものではありません。</p>
免責事項</h2>
当サイトからのリンクやバナーなどで移動したサイトで提供される情報、サービス等について一切の責任を負いません。

また当サイトのコンテンツ・情報について、できる限り正確な情報を提供するように努めておりますが、正確性や安全性を保証するものではありません。情報が古くなっていることもございます。</p>
当サイトに掲載された内容によって生じた損害等の一切の責任を負いかねますのでご了承ください。</p>
著作権・肖像権</h2>
当サイトで掲載しているすべてのコンテンツ（文章、画像、動画、音声、ファイル等）の著作権・肖像権等は当サイト所有者または各権利所有者が保有し、許可なく無断利用（転載、複製、譲渡、二次利用等）することを禁止します。また、コンテンツの内容を変形・変更・加筆修正することも一切認めておりません。</p>
各権利所有者におかれましては、万一掲載内容に問題がございましたら、ご本人様よりお問い合わせください。迅速に対応いたします。</p>
リンク</h2>
当サイトは原則リンクフリーです。リンクを行う場合の許可や連絡は不要です。引用する際は、引用元の明記と該当ページへのリンクをお願いします。</p>
ただし、画像ファイルへの直リンク、インラインフレームを使用したHTMLページ内で表示する形でのリンクはご遠慮ください。</p>
本プライバシーポリシーの変更</h2>
当サイトは、本プライバシーポリシーの内容を適宜見直し、その改善に努めます。

本プライバシーポリシーは、事前の予告なく変更することがあります。

本プライバシーポリシーの変更は、当サイトに掲載された時点で有効になるものとします。</p>


【TypeScript関数】アロー関数やコールバック関数とオプショナル引数
2022-12-27T00:00:00+00:00
関数とは何か？</h2>
TypeScriptに限らず、

プログラミング言語のほとんどには、

関数という概念があります。</p>
変数が、値</strong>を使いまわしたり、名付けをしたりすることができる箱であるなら、</mark>

関数は、処理</strong>を使いまわしたり、名付けをしたりすることができる箱です。</mark></p>
変数について、

詳しく知りたい方は、

下記の記事をご参考ください。</p>
[st-card myclass="st-no-shadow" id="21" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
関数は、プログラムをわかりやすく分割して、

処理ごとに命名をして見通しをよくすることができます。</p>
そのため、特に大規模のプロジェクトなどでは、

関数を使うことはもはや必須とも言えるでしょう。</p>
実は、高校とか中学の授業とかで習う、

関数のy=2xとかも、</strong>

プログラミング言語でいう、関数のような特徴を持っています。</strong></p>
上記は、 xに5とかを代入したら、

10を返却する関数なので、</p>
function</span> linear_func</span>(</span>x</span>:</span> number</span>)</span>:</span> number</span> {</span></span>
  return</span> 2</span> *</span> x</span></span>
}</span></span></code></pre>
のようにコードで表すこともできます。</p>
つまり、何らかの値を与えて、</strong>

何らかの値を返すものが関数と考えることができるので、</strong>

概ね、高校とか中学に習った関数のイメージとは外れていません</strong></p>
ただ、プログラミング言語でいう、関数は、

値を返さずに処理だけを行う場合もあるという特徴はあります。

(このように値を返さない関数の返り値の型はvoidと表現します。)</p>
</p>
TypeScriptでの関数定義方法</h2>
TypeScriptの関数宣言は、

function 関数名(引数リスト): 返り値の型 { 処理の中身 }という形の構文で 表されます。</strong></p>
function</span> test</span>(</span>arg1</span>:</span> number</span>,</span> arg2</span>:</span> number</span>)</span>:</span> number</span>[] {</span></span>
    const</span> val</span> =</span> [];</span></span>
    val.</span>push</span>(arg1);</span></span>
    val.</span>push</span>(arg2);</span></span>
    return</span> val</span></span>
}</span></span>
</span>
console.</span>log</span>(</span>test</span>(</span>10</span>,</span> 30</span>))</span> // [10, 30] と表示される</span></span></code></pre>
引数の型を間違えたり、引数の数を間違えると、

コンパイルエラーとなります。</p>
//下記の2つはエラー</span></span>
test</span>(</span>"10"</span>,</span> "30"</span>)</span></span>
test</span>(</span>10</span>)</span></span></code></pre>
returnによって、

関数の実行が終了して与えられた式が関数の返り値となります。</p>
そのため、returnよりあとに書かれた部分は、

実行されません。</strong></mark></p>
function</span> test</span>(</span>arg1</span>:</span> number</span>,</span> arg2</span>:</span> number</span>)</span>:</span> number</span>[] {</span></span>
    const</span> val</span> =</span> [];</span></span>
    val.</span>push</span>(arg1);</span></span>
    val.</span>push</span>(arg2);</span></span>
    return</span> val</span></span>
    console.</span>log</span>(</span>'test'</span>)</span> // 実行されない</span></span>
}</span></span>
</span>
console.</span>log</span>(</span>test</span>(</span>10</span>,</span> 30</span>))</span> // [10, 30] と表示される</span></span></code></pre>
そして、返り値にも型チェックが行われ、

test関数の返り値は、number[]でなければなりません。</p>
返り値がない関数の宣言は、

void型を設定します。</p>
function</span> test</span>(</span>arg1</span>:</span> number</span>,</span> arg2</span>:</span> number</span>)</span>:</span> void</span> {</span></span>
    const</span> val</span> =</span> [];</span></span>
    val.</span>push</span>(arg1);</span></span>
    val.</span>push</span>(arg2);</span></span>
    console.</span>log</span>(</span>'test'</span>)</span></span>
}</span></span>
</span>
test</span>(</span>10</span>,</span> 30</span>)</span></span></code></pre>
関数の定義の仕方としては、

上記の他に、変数に入れる方法もあります。</p>
const</span> functest</span> =</span> function</span> (</span>arg1</span>:</span> number</span>,</span> arg2</span>:</span> number</span>)</span>:</span> void</span> {</span></span>
    const</span> val</span> =</span> [];</span></span>
    val.</span>push</span>(arg1);</span></span>
    val.</span>push</span>(arg2);</span></span>
    console.</span>log</span>(</span>'test'</span>)</span></span>
}</span></span>
</span>
functest</span>(</span>10</span>,</span> 30</span>)</span></span></code></pre>
変数に代入する場合は、function (引数): 返り値の型 {}というふうに定義します。</strong>

関数名は省略できます。</p>
実際の使用ケースでは、

上記のように変数に入れる記法のほうが多い気がしますかね。</p>
アロー関数</h3>
TypeScriptとかJavaScriptの関数定義において、

正直functionなどと書いて定義することは稀で、

ほとんどの場合こちらのアロー関数の形式で定義されているかと思われます。</p>
構文としては、(引数): 返り値の型 => {}</strong> とします。</mark></p>
const</span> functest</span> =</span> (</span>arg1</span>:</span> number</span>,</span> arg2</span>:</span> number</span>)</span>:</span> void =></span> {</span></span>
    const</span> val</span> =</span> [];</span></span>
    val.</span>push</span>(arg1);</span></span>
    val.</span>push</span>(arg2);</span></span>
    console.</span>log</span>(</span>'test'</span>)</span></span>
}</span></span>
</span>
functest</span>(</span>10</span>,</span> 30</span>)</span></span></code></pre>
返り値をいきなり返すような、

簡単なアロー関数であれば、更に省略することもできます。</p>
const</span> simplefunc</span> =</span> (</span>arg1</span>:</span> number</span>,</span> arg2</span>:</span> number</span>)</span>:</span> number =></span> arg1</span> +</span> arg2</span></span>
console.</span>log</span>(</span>simplefunc</span>(</span>10</span>,</span> 30</span>))</span></span></code></pre>
これは、(arg1: number, arg2: number): number => { return arg1 + arg2 }</strong> と同様です。</p>
オブジェクトを返す場合は、{}と書いても、

アロー関数の中身を囲む{}とみなされてしまうので、

()で囲む必要があります。</p>
type</span> </span>simpleObj</span> =</span> {</span></span>
    val1</span>:</span> number</span></span>
}</span></span>
//正しい</span></span>
const</span> simplefunc</span> =</span> (</span>arg1</span>:</span> number</span>,</span> arg2</span>:</span> number</span>)</span>:</span> </span>simpleObj</span> =></span> ({ val1: arg1</span> +</span> arg2 })</span></span>
</span>
//エラー</span></span>
const</span> simplefunc</span> =</span> (</span>arg1</span>:</span> number</span>,</span> arg2</span>:</span> number</span>)</span>:</span> </span>simpleObj</span> =></span> { val1: arg1</span> +</span> arg2 }</span></span>
</span>
console.</span>log</span>(</span>simplefunc</span>(</span>10</span>,</span> 30</span>))</span></span></code></pre>オプショナル引数</h3>
通常の関数定義の場合、

引数に定義されたものを渡さなければエラーとなりますが、

場合によっては、何も渡さずに処理したいこともあります。</p>
その際に使用するのが、</mark>

オプショナル引数やデフォルト値の指定です。</strong></mark></p>
 </mark></p>
オプショナル引数は、引数名?: 型</strong>と定義します。</mark></p>
const</span> simplefunc</span> =</span> (</span>arg1</span>:</span> number</span>,</span> arg2</span>?:</span> number</span>)</span>:</span> number =></span> {</span></span>
    console.</span>log</span>(arg1)</span></span>
    console.</span>log</span>(arg2)</span></span>
    return</span> arg1</span></span>
}</span></span>
</span>
console.</span>log</span>(</span>simplefunc</span>(</span>10</span>))</span></span></code></pre>
これを実行してみるとわかるが、

オプショナル引数が省略された場合、

その引数にはundefinedが入ります。</p>
そのため、undefinedが混入することを避けたい場合、

デフォルト値を使ったほうがいいでしょう。</p>
デフォルト値は、引数名: 型 = 値</strong>と定義します。</p>
const</span> simplefunc</span> =</span> (</span>arg1</span>:</span> number</span>,</span> arg2</span>:</span> number</span> =</span> 20</span>)</span>:</span> number =></span> {</span></span>
    console.</span>log</span>(arg1)</span></span>
    console.</span>log</span>(arg2)</span></span>
    return</span> arg1</span> +</span> arg2</span></span>
}</span></span>
</span>
console.</span>log</span>(</span>simplefunc</span>(</span>10</span>))</span></span></code></pre>
ちなみに、上記のコードをオプショナル引数として、

実行すると、arg2がundefinedになる可能性があると、

エラーになります。</p>
デフォルト値を指定した場合、

引数にundefinedを渡すこともできるが、

その場合、デフォルト値に変換されます。</p>
const</span> simplefunc</span> =</span> (</span>arg1</span>:</span> number</span>,</span> arg2</span>:</span> number</span> =</span> 20</span>)</span>:</span> number =></span> {</span></span>
    console.</span>log</span>(arg1)</span></span>
    console.</span>log</span>(arg2)</span> //20と表示される</span></span>
    return</span> arg1</span> +</span> arg2</span></span>
}</span></span>
</span>
console.</span>log</span>(</span>simplefunc</span>(</span>10</span>,</span> undefined</span>))</span></span></code></pre>コールバック関数</h3>
コールバック関数とは、関数の引数として渡される関数のことで、</mark>

これに対しコールバック関数を引数として受け取る関数を高階関数といいます。</mark></p>
代表的な高階関数としては、mapやfilterなどがありますね。</p>
https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Global_Objects/Array/map</a></p>
type</span> </span>User</span> =</span> { name</span>:</span> string</span>, email</span>:</span> string</span> }</span></span>
const</span> users</span>:</span> </span>User</span>[]</span> =</span> [</span></span>
    { name:</span> "Alice"</span>, email:</span> "alice@test.com"</span> },</span></span>
    { name:</span> "Mike"</span>, email:</span> "mike@test.com"</span> }</span></span>
]</span></span>
const</span> callbackfunc</span> =</span> (</span>user</span>:</span> </span>User</span>)</span>:</span> string =></span> {</span></span>
    return</span> user.name</span></span>
}</span></span>
const</span> func1</span> =</span> users.</span>map</span>(callbackfunc)</span></span>
console.</span>log</span>(func1)</span>//["Alice", "Mike"] と表示される</span></span></code></pre>
map関数に渡されている、callbackfuncがコールバック関数にあたり、

高階関数のmapは、与えられた関数を配列のすべての要素に対して呼び出して、

新しい配列を生成しています。</p>
ジェネリクス</h3>
ジェネリクスとは、何かと考えると、

下記の記事にあるような感じの説明が適当かと思われます。</p>

使われるまで型が決まらないようないろいろな型の値を受け入れられる機能を作るときに使います。ジェネリクスは日本語で総称型と呼ばれることもあります

https://future-architect.github.io/typescript-guide/generics.html</p>
</blockquote>
型引数のように、呼び出す側で型とかを指定できるような記法で、

関数の場合、<型引数>(引数): 返り値というふうに定義します。</p>
function</span> func1</span><</span>T</span>>(</span>arg1</span>:</span> </span>T</span>)</span>:</span> </span>T</span>[] {</span></span>
    const</span> arr</span>:</span> </span>T</span>[]</span> =</span> []</span></span>
    arr.</span>push</span>(arg1)</span></span>
    return</span> arr</span></span>
}</span></span>
</span>
console.</span>log</span>(</span>func1</span><</span>number</span>>(</span>10</span>))</span> //[10]と表示される</span></span></code></pre>
呼び出すときは、関数<型引数>(引数)で呼び出します。

呼び出すときに、型を指定できるので、</p>
function</span> func1</span><</span>T</span>>(</span>arg1</span>:</span> </span>T</span>)</span>:</span> </span>T</span>[] {</span></span>
    const</span> arr</span>:</span> </span>T</span>[]</span> =</span> []</span></span>
    arr.</span>push</span>(arg1)</span></span>
    return</span> arr</span></span>
}</span></span>
</span>
console.</span>log</span>(</span>func1</span><</span>string</span>>(</span>'arr'</span>))</span> //['arr']と表示される</span></span></code></pre>
とかもできます。</p>
ジェネリクスについては、

下記の記事でも触れているので、

良ければご参考ください。</p>
[st-card myclass="st-no-shadow" id="25" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>


文系未経験からWebエンジニアに就職するまでに行ったこと
2022-12-25T00:00:00+00:00
本記事では、私がどのようにエンジニアになったのかについて、

ご紹介しようと思います。</p>
私は現在は自社サービス企業で、</mark>

フロントバックエンド問わず開発をしている、</mark>

Web系のエンジニアをやっています</mark>が、

ここに来るまでに色々な変遷がありました。</p>
ちなみに、以前下記のようなツイートをしましたが、

この状態は、割と最後の方で、

最初はもっとひどい状態からスタートしていました。</p>
https://twitter.com/xileng4/status/1703241846904996128</p>
こういった、どうやってエンジニアになったのかということについて、

一つのサンプルとして、ご紹介したいと思います。</p>
未経験でエンジニアを目指されている方の、

参考になる部分もあるかと思うので、

ぜひとも最後まで読んでくださると嬉しいです。</p>
文系未経験の既卒独学スタート</h2>
私は、文系未経験で独学で勉強して、

先述の通り、現在自社開発企業のソフトウェアエンジニアとして勤務しています。</p>
今でこそエンジニアですが、

最初にエンジニアを志したときは、

かなりひどい状況(レベルが低すぎる)でした。</p>
具体的には、</p>

</blockquote>

Gmailではなく、キャリアメールしか使えなかった。</strong></li>
PCを開くのは、大学のレポート提出のときのみ</strong></li>
エクセルやWordの使い方があまりわからない。</strong></li>
エクセルを使える人すげえって思っていた</strong></li>
履歴書をPCで作成するやり方がわからない</strong></li>
大学の情報の授業は、ついていけずトラウマレベル</strong></li>
もちろん、キーボードを打つのも超絶遅くタッチタイピングもできなかった。</strong></li>
</ul>
[/st-square-checkbox]</p>
「いや嘘だろ盛っているだろ」って

よく言われますが、</p>
ガチです。</strong></p>
我ながら恥ずかしいですが、

平たく言えば、おばあちゃんのITリテラシーですね。

（いや下手したらおばあちゃんにも負けていましたね)</p>
とまあ、エンジニアどころか、

一般的な社会人に必要なITスキルすら持ちわせていないレベルでした。

(この話をするとたいてい信じてもらえないのですが、本当にこのレベルでした)</p>
多分未経験からエンジニア勢で、

私より酷いステータスでスタートしている人、

いないんじゃないかっていうぐらいの状況でした。

(いたら教えてください、語り合いましょう。)</p>
大学時代は、文学専攻だったので、

これだけひどいITリテラシーでも学生時代はそこまで困りませんでした。

(卒論は、紙で提出しました)</p>
ただ、この状態なので、就活はやはりうまくいくはずもなく、

どこからも内定をもらえず卒業することになりました。</strong></p>
いわゆる既卒というやつです。</p>
私がエンジニアを志したのは、

ちょうど既卒になったばかりぐらいのことです。</p>
一応大学4年次に、少しだけITスキルを学んだので、

上記のようなひどいITリテラシーの状態は多少は脱してはいましたが、

それでもプログラミングは一ミリもやったことない状態からスタートしたのは事実です。</p>
既卒独学期間</h2>
独学期間は、およそ半年ありました。</p>
最初はHTML/CSSから始め、

JavaScript,PHP,Pythonなど色々な言語に手を出すという

典型的な良くない学習で遠回りをしていました。</p>
よくHTMLは簡単と言われますが、

最初にHTMLを学んだときは、

「どこが簡単なんだ」と強く思ったのを今でも覚えています。</p>
そして、JavaScriptなどを学んでも全然わからず、

PHPをやって、やっと少しプログラミングのコツがつかめるようになりました。

ここまでに、大体3,4ヶ月はかかった気がします。</p>
今思うと、JavaScriptって地味に面倒くさい概念がたくさん出てくるので、

オーソドックスのようでいてオーソドックスでもないんですよね。

(非同期処理、コールバック関数、オブジェクト(クラスじゃない方)などなど。そもそも

JavaScriptだけフロントエンドという点でも他の言語と違いが出るのは当然といえば当然だが。)</p>
その点、PHPは比較的素直で、とっつきやすいなというのが、

当時の印象でした。正直私の場合は、ずっとJavaScriptだけやっていたら、

よくわからなくて挫折していたかもしれません。

独学で、自分の好きな言語を学べたので、PHPに手を出すことができたのは、</strong>

今思うと良かったなと思います。</strong></p>
PHPに関しては、易しい入門書があったのも大きかったです。

下記の記事でも紹介しましたが、

「気づけばプロ並みPHP」という本は、

この時期では最もわかりやすく理解できた本でした。</p>
[st-card myclass="st-no-shadow" id="1271" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
独学は、挫折率が高いと言われていますが、

私の場合、最短ルートにこだわらず、

あえてJavaScriptからPHPに寄り道したのが、</mark>

結果的に良かったなと思います。</mark></p>
https://www.sejuku.net/blog/109190</a></p>
なんだかんだで、プログラミング言語との相性もあると思うので、

合わないなと感じたら、他の言語に手を出してみるのも手段の一つだと思います。</p>
ドットインストール</h3>
このとき、私が主に使っていた、

学習ツールは、書籍とドットインストールというサイトでした。</p>
https://dotinstall.com/</a></p>
ドットインストールは、

色々な分野を、浅く勉強できるのが最大の魅力です。

よくProgateなども、未経験の人は、

使っていることが多いと思いますが、

Progateは環境構築を学べないので、

個人的には微妙かなと思います。</p>
ドットインストールは、

動画をただぼーっと見ているだけでは、

身につきませんが、自分で手を動かして、

環境構築とかもすれば、Progateよりも実践的だと思うので、

おすすめです。</p>
私も当時は、ドットインストールで

色々勉強していました。</p>
私の場合、ドットインストールで少し勉強したぐらいの状態で、

何回か面接を受けたのですが、

コーディングテストで落ちまくりました。</p>
あの超簡単なコーディングテストで有名な、

Fizzbuzzでさえ、落ちました(笑)</p>
その時、まだ一つの言語もマスターしておらず、

つまみ食いばかりしていては、

太刀打ちできないなと感じたのを覚えています。</p>
そこで、そうしたコーディングテスト対策として、

次は、競技プログラミングをやることにしました。</p>
競技プログラミング</h3>
競技プログラミングでいえば、

AtCoderがいちばん有名かと思います。</p>
https://atcoder.jp/</a></p>
私も、例にもれずAtCoderをやりました。</p>
AtCoderにある、最初はC++のチュートリアルを進めましたが、</strong>

さっぱりわかりませんでした笑</strong></p>
C++って、シンプルに難しいんですよね。

今学習したとしてもしっかり理解できるか怪しいです。</p>
なので、実務未経験者が手を出す言語ではないですね。</p>
それでC++ではだめだと感じ、

二番目に人気があった、Pythonで競技プログラミングに取り組むことにしました。</p>
Pythonは文法がシンプルだったので、実務未経験の当時の私でも、</strong>

比較的とっつきやすかったです。</strong></p>
それからは、Pythonの学習に的を絞り、

競技プログラミングの学習と並行して、

Djangoと、Pythonの文法、アルゴリズムなども学んでいたりしました。</p>
競技プログラミングをやると、

周りの人のレベルが高すぎて結構心が折れそうになりました。</p>
ネット上だと、コンテスト5回目ぐらいで、

茶色になったとか、文系未経験数学苦手だけど、

6回目で茶色になったとか、そういう方が多い印象でした。</p>
私は、コンテスト12回ぐらい参加しても、

レーティングは、200ぐらいまでしかいかず、

結局ずっと灰色でした。</p>
こういう現実に直面すると、

「自分はやはり向いていないのかな」と思うことも、

結構ありました。</p>
しかし、実務を経験した今だからこそ、

はっきりわかるのは、

競技プログラミングのスキルと実務でのプログラミングスキルは、</mark>

必ずしも一致しないということです。</mark></p>
競技プログラミングの場合、地味に国語力も求められますし、

計算量の見積もりや、いかに解法を思いつくかみたいなスキルが必要なのに対し、

実務では、フレームワークをクリーンコードで記述できるかのような側面が

重要になっていきます。</p>
</p>
正直、現役エンジニアで競技プログラミングを

やっていない人の方が多いです(笑)</p>
なので、競技プログラミングで良い成績を出せないからといって、</strong>

エンジニアを諦める必要は全く無いです。</strong></p>
競技プログラミングのスキルは、

基本的にアルゴリズム、国語力、数学力、

解法ひらめき力、最後に実装力のような感じかなと思うので、

実務とは、なんだかんだ違います。</p>
そんな競技プログラミングですが、

これに取り組んだこと自体は間違いなく役に立ちました。</strong></p>
まず、コーディングテストには落ちなくなりました。

実務未経験の状態で、チームラボのプログラミングテストを受けましたが、

普通に通りました。(チームラボは二次面接で落ちましたが)</p>
あとは、Paizaとかのスキルチェックでも、

Aぐらいまでは出せるようになったので、

応募できる企業が増えたという利点もあります。</p>
それに最大の利点は、Pythonという一つの言語を使って、

取り組んだので、一つの言語をマスターするというかねてからの目的を</mark>

達成できたことです</mark>(マスターというのは、実務未経験のレベル感でのことです)</p>
また、実務に入ってからも、

競技プログラミングを才能がないながらも、

ゴリゴリやっていたおかげで、

同じ未経験入社の人よりも、

実装力やプログラムを書く力があるねと、

先輩エンジニアに褒めてもらうことができました。</p>
正直、ネット上にいる、

競技プログラミングの猛者たちが、

頭良すぎるだけで、

大半の人は灰色レベルなんじゃないかなと思います。</p>
現職で、情報系の学部を出た、

輝かしい経歴の新卒の子が書いたコードなどを見ても、

競技プログラミングをやっている自分からしたら、

信じられない部分でつまづいているなと感じたこともありました。</p>
当時灰色の私ですら、こう感じるのですから、

緑以上のひとは、どうなってしまうのでしょう(笑)</p>
いずれにしろ、実務未経験のときに、</strong>

競技プログラミングをやっていたことは、</strong>

基本的なプログラミングスキルを磨く上で</strong>

大変役に立ちました。</strong></p>
資格取得 LPIC level1とITパスポート</h3>
競技プログラミング以外に、

実務未経験のときに行ったことの中に、

資格取得があります。</p>
この実務未経験のときに、

LPIC level1とITパスポートを取得しました。</p>
ITパスポートは、正直対して意味なかったですが、

LPIC level1は、とても勉強になりました。</p>
ITパスポートは、会社で取らされることが多いと思いますが、

私も、内定辞退した会社の最終課題で、

ITパスポートの取得が命じられ、やむなく取得しました。</p>
今思うと、ITパスポートを取得しないと、

入社させないというスタンスだったので、

まあまあのブラック企業かつ、体制が古い企業だったと思います。</p>
LPIC level 1も同じ会社に命じられた資格だったのですが、

こちらは奇しくも、めちゃくちゃ役に立ちました。</strong></p>
結局、資格取得を命じた会社自体は、

とっとと内定辞退しましたが、

LPIC level1の取得は、

私の世界を大きく広げてくれたのを今でも覚えています。</p>
まず、Linuxの世界にハマりました。</p>
私のブログ名が、フルスタックLinuxプログラミングとあるのも、

実は、原点にLinuxに感動したからというのもあります。</p>
私がVimと出会ったのも、</strong>

このLPIC level1の学習の際です。</strong></p>
Vimに惚れて、Linuxに惚れて、

一気に私は、Linuxの世界が楽しくなりました。</p>
なので、就職するときに、

Linuxのサーバーエンジニアの方面に進もうかとも結構迷いました。</p>
ただ、競技プログラミングをやっていたのもあり、

私は、プログラミングスキルとLinuxの両方をやっていきたいという思いもあり、

開発系に進むことにしました。</p>
今思うと、この選択は正しかったと思います。

サーバー系に進んでいたら、

Linux自体には詳しくなれたかもしれませんが、

NeovimのようなモダンなVimで開発などすることもなかったでしょうし、

プログラミングを続けることもなかったと思います。</p>
それに、サーバーエンジニアは、

クラウドなどを除くと、

割とレガシー化もしているので、

転職リスクも企業によってはあるなと思います。</p>
特に、実務未経験の状態で入社する、

サーバーエンジニアは、大半は保守運用などに回されることが多く、

スキルを伸ばしにくいキャリアになっていたかもしれません。</p>
その点でも、私は開発系に進んでよかったと思います。</p>
Linuxは、Webエンジニアにとっても、</strong>

必須の知識です。</strong></p>
LPIC level1は、これだけは知っておきたいLinuxの基本を学べるので、

未経験の人は、取得を検討してみてもいいのかなと思います。</p>
ポートフォリオ作成</h3>
さて、そんなこんなで、

私は資格取得をしたり、

競技プログラミングをしたりと執心していましたが、

肝心のポートフォリオを作っていませんでした。</p>
ポートフォリオの作成よりも、

競技プログラミングや、Linuxの方が楽しかったというのが本音です。</p>
ただ、ポートフォリオがないと、

未経験だと何かと厳しいので、

8月ぐらいに作成に取り掛かりました。</p>
私は、Pythonでゴリゴリ競技プログラミングをやっていたので、

ポートフォリオもPythonでやりたいという思いが強かったので、

Python WebフレームワークのDjangoで作成しました。</strong></p>
簡単な性格診断アプリのようなものを作りました。</p>
今振り返ると、かなりクオリティ低かったと思います。</p>
JSフレームワークは、

使いませんでしたし、もちろん

Dockerなんかも使っていません。</p>
まあそれでも、無いよりはマシだっと思います。</p>
私のときは、これぐらいのクオリティでも、

ギリギリ滑り込めましたが、最近は、

実務未経験者に対するハードルが高くなっているようで、

ポートフォリオに求められる水準も上がっていると聞きました。</p>
なので、私は運が良かったです。

今わたしが未経験だとして、

就活していたら、果たして就職できていたかどうかと

感じます。</p>
内定先との面接</h3>
さてそんなこんなで、

内定をもらうことになる会社の面接を受けました。</p>
ここは、私が入社したところですが、

Web系の自社受託開発の会社でした。</strong></p>
これだけ聞くと、まあまあ入社難易度高そうですが、

ここは、未経験者も採用するというスタンスのところでした。</p>
この会社を受けているときは、

まだポートフォリオは完成していなかったんですが、</p>
結局ポートフォリオが完成しないまま、

内定をもらうことができました。</p>
入社したここの企業の面接では、一度もポートフォリオを

掲示せずに終わりました(笑)</p>
決めては、面接官との相性と、</mark>

技術に対する興味でした。</mark></p>
というのも、その会社の一次面接の際に、

色々技術的な質問をされたのですが、

釈然とした回答ができませんでした。</p>
もう落ちたなと思っていました。</p>
</p>
ただ、面接終了間際に、

「何か趣味はありますか？」と聞かれて、

音楽の話をしたら、その面接官の方と打ち解けて

最終面接に進むことができました。</p>
超絶ラッキーでした。

もし違う面接官なら落ちていたでしょう。</p>
ぶっちゃけ実務未経験の状態だと、</strong>

運とかの要素も大きいかもしれません</strong></p>
最終面接は、技術が好きかどうかを聞かれ、

私の場合は、Linuxを普段使いしている旨と、

今まで独学でプログラミングをやってきたことを

色々話したら熱意が伝わったようで、

ギリギリで採用してもらえました。</p>
ギリギリの理由としては、

一週間半ぐらい音沙汰がなく、

こっちから「どうでしょうか？」と連絡をしたら、

「選考に時間を要しましたが、たった今通過として決定しました」と、

なんとも悩ましい採用だったからです。</p>
ポートフォリオは正直あんま関係なかったです笑</p>
こうして、ギリギリでエンジニアの世界にすべりこめました。</p>
自社サービスに挑戦</h3>
そうして、内定をもらうことはできたのですが、

このあたりから、自惚れ始めて、

「自社サービスも受かるんじゃね」と思うようになりました。</p>
正直、同時進行で自社サービスもいくつか受けていたのもあり、

そちらの結果を見てから、内定承諾をしようと思いました。</p>
ポートフォリオは、この自社サービスの面接で、</strong>

使用しました。</strong></p>
一社目は、まあまあ有名な某メガベンチャーですが、

採用難易度はそこまで高くない、あそこです。</p>
二次面接まで行きましたが、

企業風土とのアンマッチと、

技術面接で、同社のレベルに達していないと

判断され、落ちました。</p>
まあ今思うと、あのポートフォリオなら、

そりゃそうだなという感じです。</p>
二社目は、正確には事業会社ではありませんが、

某イケイケWeb系受託開発をしているメガベンチャーです。</p>
ここも二次面接で落ちました。

まあ、ここは、もちろん技術水準に達していないという

点もあったと思いますが、面接官との相性が悪かったというのも

あったと思います。</p>
全く話が盛り上がりませんでしたし、

どうにもとっつきにくい感じの人でした。</p>
というわけで、見事に両方落ちたので、

最初に内定をもらった会社に入社しました。</p>
実務に入ってみて</h2>
そうして、就職したのですが、

当然といえば当然ですが、

実務のレベルは高かったです。</strong></p>
私がそのとき、就職したのは、

Web系の受託開発企業でした。</p>
実務未経験にしては、良い環境で

プライム案件も多く、しっかり開発の経験を積める上に、

週四リモートワークができる、自由な社風の会社でした。</p>
とはいえ、最初の研修の時点から躓くことが多くて、

わからないことだらけでした。</p>
研修ではRubyとRailsをみっちりやらされたのですが、

どちらも独学のときにやっていなかったので、

初めての部分が多く結構苦労しました。</p>
あと、地味にGitなどについても、

改めて学習して、かなり勉強になりました。</p>
あと、PR形式でレビューを先輩エンジニアにお願いするという形式も

独学ではなかなか経験できないものだったので、</strong>

**大変刺激的でした。**特にテストコードなどは、

このとき存在自体も、書き方自体も初めて学びました。</p>
研修なので、厳密には実務ではないですが、

後にも先にも、あそこまでみっちりコードレビュしてくれたことは、

ないような気がします。</p>
この研修で、実務のプログラミングと、

独学のプログラミングの大きな違いを学ぶことができました。</p>
具体的には、</p>

</td> 独学</td> 実務</td></tr>
スタンス</td> なんとなく動いたで書いている</td> 挙動を説明できないコードを書いてはいけない</td></tr>
テストコード</td> もちろん書いてない</td> 書くのが一般的</td></tr>
参照のスタンス</td> Qiitaとか、調べて一番最初に出てきたものを理解しないまま片っ端から試す</td> 公式ドキュメントを参照し、理解出来ないコードを安易にコピペしない</td></tr>
使う技術</td> プログラミング言語とフレームワークとgitなど限定的</td> プログラミング言語、フレームワーク以外にも、様々な周辺技術を使い、管理する。</td></tr>
コード</td> 命名などが汚く、冗長な部分が多い</td> 命名を洗練させ、冗長な部分をクラスや関数などにする</td></tr>
</table>
これ以外にもたくさんあるでしょうが、

こういった独学から実務へのマインドチェンジをこの研修で

行うことができたのは、かなり大きい成長だったなと今でも思います。</p>
独学のときは、それはそれで大変でしたが、</mark>

実務を経験して、いかに自分がひどいコードを書いていたのか痛感しますね。</mark></p>
この研修のときに、

メンターをしてくれたエンジニアの方の

教えてくれたことは、本当に勉強になりました。</p>
やはり誰かに教えてもらえるって最高ですね。

今思うと、プログラミングスクールも全然ありだし、</strong>

近道なのかもしれないと思うぐらいです。</strong></p>
ちなみに、おすすめのプログラミングスクールについては、

下記の記事で紹介しているので、興味がある方は、

ご参考ください。</p>
[st-card myclass="st-no-shadow" id="1139" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
文系未経験なら最低でも半年はほしい</h2>
さて、ざっと独学期間から最初の企業の転職まで振り返りましたが、

いざ文系未経験からエンジニアを目指すなら、

最低でも半年の学習期間がほしいと考えます。</p>
なぜなら、</p>
[st-mybox title="注意ポイント" webicon="st-svg-exclamation-circle" color="#ef5350" bordercolor="#ef9a9a" bgcolor="#ffebee" borderwidth="2" borderradius="5" titleweight="bold" fontsize="" myclass="st-mybox-class" margin="25px 0 25px 0"]</p>

最低半年勉強しないとプログラミングに慣れようがない</li>
試行錯誤した経験が必要</li>
学習分野が多いのと、半年未満では短すぎる</li>
そもそも技術が好きなのかどうか見極める期間としても重要</li>
</ul>
実務未経験の場合、

ポテンシャルを感じさせることが重要です。</p>
そのため、ポートフォリオよりも、

「この人はいずれエンジニアとして戦力になってくれる」と

面接官に思わせなくてはいけません。</p>
そのためには、半年ぐらいは、

技術に向き合って、それに対する熱意を語れるぐらいにならないと

難しいでしょう。</p>
ただ、長すぎても、

実務デビューが遅れるだけなので、

せいぜい半年から一年ぐらいがベストでしょう。</p>
ただ、今思うと、必ずしも独学でエンジニアを目指すよりも、</strong>

就職難易度が低いSESなどに就職して、</strong>

手っ取り早く実務経験を積んでしまうのも戦略の一つだなと思うようになりました。</strong></p>
エンジニアになるために必要なマインド</h3>
エンジニアは、働きやすい環境が多いので、

それに魅力を感じて、目指している人も多いかと思います。</p>
ただ、エンジニアは、想像以上に一日中PCと向き合って、</strong>

プログラムと向き合う仕事です。</strong></p>
そういうことが苦にならない人じゃないと、

続けるのは難しいかもしれません。</p>
それに、長期的には、

技術に対する興味がないと、

続けられないと思います。</p>
なので、エンジニアを目指している方は、

「自分はどういう技術を極めていきたいか」</mark>ということを

しっかり答えられるようにしておくべきだと思います。</p>
面接でも、どのような技術が好きか聞かれることもあるかと思います。</p>
もちろん、企業のスタンスによっても異なるので、

未経験の場合、技術に対する熱意よりも、

論理的思考とかを重視するという企業もあります。</p>
ただ、自社サービスとか、技術に強い会社に就職しようと思ったら、

何らかの形で技術に対する質問はしてくるはずです。

（そして大抵、そういう企業が働きやすい企業だったりします。)</p>
好きな技術とか、

今興味がある技術はありますか？という質問に対し、

「AIとか自動運転に興味があります」みたいに答えてしまうと、

「それは大抵の人が興味があるって答えるし、誰でも知っている技術なんだよな」

という印象を与えかねません。</p>
もちろん、AIや自動運転について、

専門的に研究されている方であれば、

上記のように答えても問題ありませんが、

そうでない場合は、避けておいた方が良いでしょう。</p>
もちろん、正解などない質問ですが、

私だったら、「LinuxやVimなどが好きなので、最近はWindows PCに

ubuntu desktopをインストールして、この面接もこのubuntuで受けています。プログラム開発に際し、

Vimを使用しているのですが、より開発効率を探求するために、AstroNvimや、プラグインなどの

模索にハマっております。」</p>
のように答えます。</p>
中途採用の面接だったら、上記だとそこまで好印象でもないかもしれませんが、

実務未経験者に対する質問の回答としては、十分な回答だと思います。</p>
重要なことは、好きな技術が好きで、どういうことをしているのか、

語れるとベストです。みんな自分の好きなことであれば、</strong>

一心不乱に語り始めると思いますが、それと同じことができれば、</strong>

完璧です。</strong></p>
技術フリークな人は、歓迎されるので、

それっぽく見せましょう。（まあ見抜かれることも多いので、

ほどほどが一番ですが)</p>
勉強するべき分野</h3>
さて、最後に具体的に、

どういう勉強をしたらいいのか触れます。</p>
例えば</p>
[st-square-checkbox bgcolor="" bordercolor="" fontweight="" borderwidth="3"]</p>

プログラミング言語一つ</li>
フレームワーク</li>
HTML/CSS JavaScript</li>
Linux</li>
Git</li>
Docker</li>
SQL</li>
</ul>
[/st-square-checkbox]</p>
絞ったらこれぐらいですが、

これ以外にも勉強しておくに越したことはないものは、

たくさんあります。</p>
私の場合、Vimとかも勉強していました。

(Vimの解説記事は、たくさんあげているので、

良ければご参考ください。)</p>
https://reisuta.com/category/cli-tool/</a></p>
これらをちゃんとまなぼうとしたら余裕で

半年以上はかかると思われる。</p>
どのようなエンジニアを目指すかによっても、

変わってくると思いますが、

上記の勉強は必要になるでしょう。</p>
未経験からエンジニアを目指すのに必要な勉強の詳細については、

既に紹介しましたが、下記の記事でも言及しているので、

こちらもご参考ください。</p>
[st-card myclass="st-no-shadow" id="1139" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>


【M1 Macbook AirでUbuntu】リモートデスクトップ経由で接続
2022-12-24T00:00:00+00:00
皆さんは、M1Macとかで、

LinuxtのGUIを開いてみたいと思ったことはないでしょうか？</p>
M1だと、以前のintel製Macのように、

気軽にデュアルブートでLinuxを入れるなんていうことができなくなってしまったので、

悲しみにくれている人も多いのではないでしょうか？(わたしです)</p>
そこで、本記事では、M1でUbuntuデスクトップを開くために、</mark>

Dockerコンテナとリモートデスクトップを使って、</mark>

検証してみようと思います。</mark></p>
どちらかというと、

お遊びの検証なので、

一ミリも実践的じゃないので、

ご了承ください。</p>
ちなみに、記事の内容上、

動画の方がわかりやすいかもしれないので、

同内容の動画を貼っておきます。</p>


  </iframe>
</div>
M1での前準備</h2>
さて、早速取り掛かっていきたいのですが、

本記事ではDockerを使うので、

Dockerの基礎知識や環境構築を済ませていない方は、

先にこちらの記事</a>を読んでからのほうが、

理解しやすいかと思います。</p>
[st-card myclass="st-no-shadow" id="1077" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
以下、Dockerの環境がある前提で

進めていきます。</p>
Ubuntuコンテナを立てる</h3>
公式のubuntuのイメージを取得し、

コンテナを立ち上げます。</p>
docker</span> pull ubuntu</span></span>
docker</span> run</span> -itd --privileged -p</span> 13389:3389</span> --name</span> ubuntu-desktop ubuntu</span></span></code></pre>
コンテナに入ります。</p>
docker</span> exec</span> -it</span> ubuntu-desktop /bin/bash</span></span></code></pre>
コンテナに入ったら、

色々インストールしていきます。</p>
必要なライブラリ等インストール</h3>
色々必要なやつをインストールしていきます。</p>
今回は、xrdpとubuntu-desktopを

apt経由でインストールします。</p>
xrdpとは、リモートデスクトップを実現するために必要なプロトコルである、

RDPの機能を提供するOSSです。</p>
ubuntu-desktopは、その名の通り、

ubuntuのデスクトップ環境ですね。</p>
そのためxrdpとデスクトップ環境である、</mark>

ubuntu-desktopを入れないと始まらないので、</mark>

以下コマンドでインストールします。</mark></p>
apt</span> -y</span> update</span></span>
apt</span> install</span> -y</span> init</span></span>
apt</span> install systemd</span></span>
apt</span> -y</span> install xrdp</span></span>
apt</span> -y</span> install ubuntu-desktop</span></span></code></pre>
入れ終わったら、

一旦コンテナからexitします。</p>
コンテナを停止しないと、

Bind for 0.0.0.0:13389 failed: port is already allocated.

のようにすでにポートが埋まっているというエラー にこの先出くわすので、

一旦止めます。</p>
docker</span> stop ubuntu-desktop</span></span></code></pre>
</p>
イメージを保存する</h3>
今色々インストールしたコンテナをイメージとしてコミットし、

そのイメージ経由で立ち上げてみます。</p>
docker</span> commit  6a77e56ccb22 ubuntu-desktop:ubuntu</span></span>
docker</span> run</span> -itd --privileged -p</span> 13389:3389</span> --name</span> ubuntu-test ubuntu-desktop:ubuntu /sbin/init</span></span>
docker</span> exec</span> -it</span> ubuntu-test /bin/bash</span></span></code></pre>
あとは、デフォルトだとrootユーザのパスワードはないようなので、

passwdコマンドで設定します。</p>
passwd</span></span></code></pre>
</p>
さてこれで準備完了です。</p>
リモートデスクトップでUbuntuに接続</h2>
次に、リモートデスクトップが必要なので、

インストールしておきましょう。</p>
app storeとかで、

Microsoftリモートデスクトップって検索すれば、

出てくると思うので、インストールします。

(他のリモートデスクトップでも行けると思いますが、

本記事では、Microsoftリモートデスクトップを使用します。)</p>
Microsortリモートデスクトップで、

localhost:13389にアクセスします。</p>
</p>
ユーザ名:rootで、

パスワード:設定したもので接続します。</p>
</p>
いけたっぽいです。</p>
</p>
最初の状態だと、なぜかfirefoxが入っていないので、

リモートデスクトップ先でインストールしてみます。</p>
</p>
私の環境では結構時間かかりましたが、

インストールできました。</p>
やってみた感想</h3>
正直体感としては、やや重くて</strong>

実用に堪えるものではない気がしました。</strong></p>
Ubuntuを使いたいならおとなしく、

PCにそのまんまインストールしたほうがいいかもしれないですね。</p>
そうなると、やはりMacではなくWindowsという

例の宗教戦争に突入するので、

ここではこれ以上踏み込みません。</p>
なお、ここまでやっておいてあれですが、、

こういうやつもあるので、

こっちのほうがサクッと作れるかもしれないので、

興味がある方は、ご参考ください。</p>
https://github.com/uphy/ubuntu-desktop-jp</a></p>


TypeScriptのオブジェクトとは何か？型の付け方とジェネリクス
2022-12-24T00:00:00+00:00
オブジェクトとは何か？</h2>
下記の記事で紹介したプリミティブ型という基本的な7つの型以外のものを、

オブジェクトといいます。</p>
[st-card myclass="st-no-shadow" id="23" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
具体的には、string、number</mark>

bigint、boolean、undefined</mark>

symbol、null以外の型のことですね。</mark></p>
他の言語だと、オブジェクト = クラスなどに結び付けられがちですが、

TypeScriptの場合、クラスだけにとどまらない、広い範囲を含むのが特徴です。</strong></p>
これは、JavaScriptやTypeScriptの大きな特徴かなと思いまして、

最初はまあまあ戸惑うかなとおもいます。</p>
代表的なものとしては、</p>
const</span> val</span> =</span> {</span></span>
    obj1:</span> 123</span>,</span></span>
    obj2:</span> 'hello'</span></span>
}</span></span>
console.</span>log</span>(val.obj1)</span> // 123と表示される</span></span></code></pre>
こんな感じのコードがあげられます。</p>
定義方法としては、

{}の中に、プロパティ名(キー):値</strong>と定義します。</p>
オブジェクトの中身(プロパティ)を得ている、

console.log(val.obj1)の部分は、</strong>

プロパティアクセスに当たります。</strong></p>
ちなみにプロパティアクセスの方法としては、</p>
console.</span>log</span>(val[</span>"obj1"</span>])</span> // 123と表示される</span></span></code></pre>
のような記法もあります。</p>
いくつかのデータをまとめて管理したいときなどに、

オブジェクトが利用されることが多いです。</p>
なお、省略記法もあり、

例えば次のようにかけます。</p>
//省略しない書き方</span></span>
const</span> hello</span> =</span> 'Hello World'</span></span>
const</span> user1</span> =</span> {</span></span>
    hello: hello,</span></span>
    age:</span> 28</span>,</span></span>
}</span></span>
console.</span>log</span>(user1.hello)</span></span></code></pre>//省略記法</span></span>
const</span> hello</span> =</span> 'Hello World'</span></span>
const</span> user1</span> =</span> {</span></span>
    hello,</span></span>
    age:</span> 28</span>,</span></span>
}</span></span>
console.</span>log</span>(user1.hello)</span></span></code></pre>
変数名とプロパティ名が同じ場合、

: 変数名</strong>の部分を省略できます。</p>
ただ、上記のような省略記法については、

何だかんだでそんなに遭遇したことがないので、

どこまで浸透しているのかは微妙なところです。</p>
可読性という観点では、

正直どちらがいいとは断定しづらいですね。</p>
オブジェクトの型</h2>
オブジェクトの型は、

例えば次のように記述します。</p>
const</span> val</span>:</span> { </span></span>
    obj1</span>:</span> number</span>,</span></span>
    obj2</span>:</span> string</span></span>
}</span> =</span> {</span></span>
    obj1:</span> 123</span>,</span></span>
    obj2:</span> 'hello'</span></span>
}</span></span>
console.</span>log</span>(val.obj1)</span> // 123と表示される</span></span></code></pre>
「うん？どれが型だ？

うじゃうじゃしているな」って思った方もいるかもしれません。</p>
この場合、変数valの型は、</strong>

{ obj1: number, obj2: string }型となります。</strong></p>
複数の値に対してそれぞれ型を定義しているだけで、

一つ一つについては、プリミティブのときと同様ではあります。</p>
すなわち、上記のvalオブジェクトは、</mark>

obj1がnumberで、obj2がstringの構造をもつ、</mark>

オブジェクトだということで、</mark>

上記のような型になっています。</mark></p>
ただ、記述が長くなるので、

type文を使うことが実際には多いです。</p>
type文とは、自分で

カスタムの型を宣言する文法記法のようなものです。</p>
type</span> </span>valobj</span> =</span> {</span></span>
    obj1</span>:</span> number</span>,</span></span>
    obj2</span>:</span> string</span></span>
}</span></span>
const</span> val</span>:</span> </span>valobj</span> =</span> {</span></span>
    obj1:</span> 123</span>,</span></span>
    obj2:</span> 'hello'</span></span>
}</span></span>
console.</span>log</span>(val.obj1)</span></span></code></pre>
type文で宣言した型は、

上記のように型注釈に記載できます。</p>
これだとvalの定義自体は簡潔になった感じがしますよね。</p>
type文は、上記のように、

型を宣言する構文です</p>
すでに存在する型に対して、</strong>

別名をつけることができます。</strong></p>
よくある使い方としては、

typeの宣言を別のtypesディレクトリのようなものに切り出して、

まとめて宣言して、各ファイルでそれぞれの型を呼び出すようにすると、

見通しが良くなるかなと思います。</p>
型引数(ジェネリクス)</h2>
上記のtype文と関連して、

型引数という、type文の中でだけ有効な型として

扱えるものがあります。</p>
type</span> </span>valobj</span><</span>T</span>></span> =</span> {</span></span>
    obj1</span>:</span> number</span>,</span></span>
    obj2</span>:</span> </span>T</span></span>
}</span></span></code></pre>
このような型引数を持つ型は、

ジェネリック型といいます。</strong></p>
上記の型を実際に使う場合は、

引数に型を指定します。</p>
const</span> val</span>:</span> </span>valobj</span><</span>string</span>></span> =</span> {</span></span>
    obj1:</span> 123</span>,</span></span>
    obj2:</span> 'hello'</span></span>
}</span></span></code></pre>
この場合、

stringが引数に渡されているので、

valobj型のTはstringとなり、

{ obj1: number, obj2: string }型と同様になります。</p>
このあたりは、関数の引数と

似ていますね。</p>
なお型引数を指定した場合、

呼び出し側で引数を指定しないと、

コンパイルエラーになります。</p>
//型引数なしでは呼び出せない。</span></span>
const</span> val</span>:</span> </span>valobj</span> =</span> {</span></span>
    obj1:</span> 123</span>,</span></span>
    obj2:</span> 'hello'</span></span>
}</span></span></code></pre>
そのため、省略可能なオプショナルな型引数にする場合は、

予めデフォルト値を定義しておく必要があります。</p>
type</span> </span>valobj</span><</span>T</span> =</span> string</span>></span> =</span> {</span></span>
    obj1</span>:</span> number</span>,</span></span>
    obj2</span>:</span> </span>T</span></span>
}</span></span>
const</span> val</span>:</span> </span>valobj</span> =</span> {</span></span>
    obj1:</span> 123</span>,</span></span>
    obj2:</span> 'hello'</span></span>
}</span></span></code></pre>
この場合、型引数が指定されないと、

Tはstring型になります。</p>
配列</h2>
配列は、[]で定義される、</mark>

複数のデータをまとめたデータ構造で、</mark>

オブジェクトの一種です。</mark></p>
配列については、他のプログラミング言語でも

嫌というほど見ていると思うので、

イメージしやすいかと思います。</p>
平たく言えば、複数のデータが入っている箱のような感じですね。</p>
TypeScriptだと、下記のように配列定義します。</p>
const</span> arr</span> =</span> [</span>'hello'</span>,</span> 'alice'</span>,</span> 123</span>]</span></span>
console.</span>log</span>(arr)</span></span></code></pre>
arrという変数に['hello', 'alice', 123]というものが代入されていますね。</p>
これは、'hello'、'alice'、123の3つの値が、

arrという配列の変数に格納されている感じです。</p>
通常の変数であれば、

一対一に対応していましたが、

オブジェクトのように、一対複数のように定義できるのが、

配列の特徴です。</p>
配列の値にアクセスするには、</p>
arr[0]</span></span></code></pre>
と番号を指定します。</p>
0始まりからなので、先頭の要素は、

arr[0]というふうに取得します。</p>
arr[0]だと、上記の場合、

'hello'の文字列が取得できます。</p>
ちなみに、プログラミング言語によっては、

0ではなく、1スタートだったりすることもありますが、

基本的には0スタートの言語が多いです。</p>
TypeScriptにおける配列は、上記の番号、</mark>

0とか1といったプロパティ名を持つ、</mark>

オブジェクトともいえるので、</mark>

実は、配列はオブジェクトの一種でもあります。</mark></p>
オブジェクトのプロパティアクセスの方法で

値を取得することができますもんね。</p>
</p>
プログラミング言語によっては、

上記のオブジェクトのようなデータ構造と、

配列は全く別のものだったりするので、

これもTypeScript、JavaScriptの大きな特徴ですね。</p>
配列の型</h3>
さて、TypeScriptの特徴は型ですが、

配列の型は、</p>
const</span> arr</span>:</span> string</span>[]</span> =</span> [</span>'hello'</span>,</span> 'alice'</span>]</span></span></code></pre>
というふうに、型名[]と記述します。</strong></p>
上記の場合、stringの要素を持つ配列とわかりますね。</p>
もう一つの記法として、</p>
const</span> arr</span>:</span> </span>Array</span><</span>string</span>></span> =</span> [</span>'hello'</span>,</span> 'alice'</span>]</span></span></code></pre>
というのも存在します。</p>
こちらは組み込みのジェネリック型にあたります。

(すなわち、stringというものを型引数として渡している感じですね)</p>
どちらの記法が良いというわけではありませんが、

最初の方が、スッキリ書けるので、

私は前者の記法のほうが好きです。</p>
ジェネリクスっぽく書きたい場合は、

後者にすると良いと思います。</p>
また、最初に定義したような、

複数の型が混ざった配列の場合は、

ユニオン型というものを使って、</p>
const</span> arr</span>:</span> (</span>string</span> |</span> number</span>)[]</span> =</span> [</span>'hello'</span>,</span> 'alice'</span>,</span> 123</span>]</span></span></code></pre>
というふうに記述することもできます。</p>
ユニオン型とは、上記の | の部分ですね。</strong>

stringまたはnumberという感じです。</strong></p>
https://typescriptbook.jp/reference/values-types-variables/union</a></p>


【TypeScript基礎】プリミティブ型、基本的な型の種類について
2022-12-24T00:00:00+00:00
TypeScriptの特徴は何と言っても、

型にありますが、そんな型の中でも、

中心的な役割を占める、</mark>

プリミティブ型について、詳しく解説します。</mark></p>
文字ではなく、動画で観たい方は、

下記をご参考ください。</p>


  </iframe>
</div>
また、TypeScriptについては、</mark>

一通りの基礎文法を一動画で解説した、</mark>

総集編もありますので、</mark>

よろしければ、こちらもご参考ください。</p>


  </iframe>
</div>
プリミティブ型とは何か？</h2>
プリミティブとは、原始的なという意味を表す英単語で、

ここでは、最も基本的なデータ型を指します。</strong></p>
もっと、専門的に言うと、

オブジェクトではなく、メソッドやプロパティを持たないデータ型のこと指すようですね。</p>
https://developer.mozilla.org/en-US/docs/Glossary/Primitive</a></p>
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#data_property</a></p>
オブジェクトは、プリミティブ以外のもので、

代表的なコードとしては、</p>
const</span> obj</span> =</span> {name:</span> 'obj'</span>, age:</span> 19</span>}</span> //jsの場合</span></span>
const</span> obj</span>:</span> { name</span>:</span> string</span>, age</span>:</span> number</span>}</span> =</span> {name:</span> 'obj'</span>,age:</span> 19</span>}</span> //tsの場合</span></span></code></pre>
のような感じです。</p>
本記事はプリミティブ型の解説を主軸とするので、

オブジェクトには深入りしませんが、

オブジェクトは、nameやageのようなプロパティを持っています。</p>
プロパティとは、上記のname(キー),'obj'(value)を合わせたものを指しています。</p>
https://developer.mozilla.org/ja/docs/Web/JavaScript/Guide/Working_with_Objects</a></p>
つまり、プリミティブ型は、

平たく言うと、今まで使ってきた'hello'といった文字列や、

100といった数字型のように、その値しかないものと言えそうですね。</strong></p>
変数とかに定義された際に、

呼び出し方によって、値が変わる、

つまり複数の値が予め備わっていないものと考えれば概ね問題ないでしょう。</p>
さて、そんなプリミティブ型は、全部で7種類存在します。

(本記事では、bitint型とシンボル型は、基礎からはやや外れるので割愛します。)</p>
number型</h3>
これはその名の通り、

数値を表す型ですね。</p>
const</span> num</span> =</span> 5</span></span></code></pre>
ただ、TypeScript独特の仕様として、

number型には整数と小数の区別がありません。</strong>

下記では、整数しか定義していないが、

計算結果は、小数になっています。</p>
const</span> num1</span>:</span> number</span> =</span> 5</span></span>
const</span> num2</span>:</span> number</span> =</span> 8</span></span>
const</span> num3</span>:</span> number</span> =</span> 3</span></span>
</span>
const</span> ans</span>:</span> number</span> =</span> (num1</span> +</span> num2)</span> *</span> num3</span> /</span>2</span></span>
console.</span>log</span>(ans)</span> //19.5と表示される</span></span></code></pre>
これは、好き嫌いも分かれる部分かと思いますが、

静的型付け言語の型としては、ちょっと大雑把な印象があります。</p>
以前、下記のようなツイートをしましたが、

同じ静的型付け言語のC++とかとはかなり異なっていますね。</p>
X (Twitter) でポストを見る</a></p>
それと、一般的に数値などは、

integerとかintという記法が多いのですが、

TypeScriptでは、numberとなっているので、

このあたりも微妙に混乱しますね。</p>
string型</h3>
こちらも、基本的な型で、

'hello'のような文字列の型ですね。</p>
文字列の作り方として、

""と''で囲うやり方があり、

基本的には大差ないかと思います。</p>
書き方としては、下記のような感じです。</p>
const</span> hello</span>:</span> string</span> =</span> 'hello'</span></span>
const</span> hello1</span>:</span> string</span> =</span> "hello"</span></span></code></pre>
文字列の話に関連すると、

テンプレートリテラルという記法も存在するので、

そちらにも言及します。</p>
テンプレートリテラル</h4>
これは、文字列の中に変数を入れることができるというメリットがある記法でして、

``とバッククオートで囲んで記述します。</p>
Rubyとかでの式展開に近いものでして、

変数を埋め込みたい時に重宝します。</p>
記法としては、下記のような感じです。</p>
const</span> str1</span>:</span> string</span> =</span> 'hello world'</span></span>
const</span> str2</span>:</span> string</span> =</span> 'HELLO WORLD'</span></span>
console.</span>log</span>(</span>`</span>${</span>str1</span>}</span>, </span>${</span>str2</span>}</span>`</span>)</span>// "hello world, HELLO WORLD" と表示される</span></span>
console.</span>log</span>(</span>'${str1}, str2'</span>)</span> // "${str1}, str2"と表示される </span></span>
//テンプレートリテラルでないと、変数名そのものが文字列になる。</span></span></code></pre>
このような変数名の埋め込みに関しては、

+演算子でも似たようなことができるので、

人によって、どちらの記法が良いかと好き嫌いが分かれることもあります。</p>
ただ、個人的には、このテンプレートリテラルのほうが、

簡潔になるので、おすすめです。</p>
boolean型</h3>
boolean型とは、真偽値のことで、

trueまたはfalseの2種類だけの値からなる型のことです。</p>
const</span> bool1</span>:</span> boolean</span> =</span> false</span></span>
const</span> bool2</span>:</span> boolean</span> =</span> true</span></span></code></pre>
trueとかfalseという概念は、

最初はピンとこないかもしれませんが、

命題の真か偽かと考えてもらえるとわかりやすいかもしれません。</p>
プログラムでは、「こういう条件のときだけ、こういうことをしたい」みたいな場面が</mark>

たくさんあるのですが、まさに「こういう条件のとき」を表す際に、</mark>

「こういう条件 が真」→ こういう条件 === 真(true)というふうに表現して、</mark>

記述していきます。</mark></p>
boolean型は、こういうときに大活躍します。</p>
以上のように、boolean型は条件分岐と交えて使用することがほとんで、

trueのときと、falseのときで実行したい処理を分けたいif文などでよく使われます。</p>
真偽値変換の結果</h4>
実はわざわざtrueとかfalseと書かなくても、

どんな値も真偽値に変換されれば、この二種類のどちらかとなります。</p>
そして、どういう値が、trueになりfalseになりというのは、

プログラミング言語ごとに異なるため、

これは、プログラミング言語の個性とみなされることが多いです。</p>
条件分岐では、

値がそのまま入れられることも多いです。</p>
if</span> (</span>0</span>) console.</span>log</span>(</span>0</span>)</span> //0はfalseなので実行されない。</span></span>
if</span> (</span>1</span>) console.</span>log</span>(</span>1</span>)</span> //1はtrueなので実行される。</span></span>
if</span> (</span>'hello'</span>)</span> //'hello'はtrueなので実行される</span></span>
if</span> (num1</span> <</span> num2)</span> //num1の方がnum2未満なら実行され、そうでないと実行されない条件分岐</span></span></code></pre>
ちなみに、falseに判定されるものは、 false, ""(空文字列), 0, NaN, null, undefinedで、</strong>

それ以外はすべてtrueと判定される。</strong></p>
多くの言語は、0をfalseと判定していますが、

例えばRubyとかは、0もtrueと判定しており、

Rubyにおける、falseは、nilとfalseだけというシンプルさ。</p>
プログラミング言語によって、かなり違いますね。</p>
ちなみに、Rubyにも興味がある方は、

こちらの記事</a>で紹介しているので、

ご参考ください。</p>
[st-card myclass="st-no-shadow" id="692" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
null型とundefined型</h3>
null型は、その名のとおり、</strong>

nullという値だけをもつ型です。</strong></p>
プログラムでは値が存在しないというものを、

このようなnullとかで表すことが多いのですが、

バグの原因になったりするので、

nullについては、慎重に扱う必要があります。

(※TypeScriptの場合、null安全のような議論もあるので、

一般的なnullに対するイメージとは必ずしも一致しないこともありますが、

ここではややこしくなるので、そこには言及しません)</p>
ちなみに、0とかとは何が違うのかというと、

0は、number型で値が存在します。

その証拠に、0 + 1 = 1というように、

0に足したりできます。</p>
これに対して、nullは、値が存在しないので、

上記のようなことはできません。</p>
イメージとしては、0は、0という存在があるけど、

nullは存在自体がないことを表す概念という感じです。</p>
ややこしいですね。

最初のうちはピンとこないかもしれませんが、

要するに、値が存在しないものと思っていただければ大丈夫です。</mark></p>
undefined型も似たようなもので、

undefinedという値だけを持つ型です。</p>
const</span> num</span>:</span> null</span> =</span> null</span></span>
const</span> num2</span>:</span> undefined</span> =</span> undefined</span></span></code></pre>
これらは、データがないということを表すものです。</p>
他のRubyなどの言語では、

こういったデータがないという型は、

nilなどのように一種類のことが多いのですが、

TypeScriptでは、このように二種類存在します。</strong></p>
これは、TypeScriptやJavaScriptの大きな特徴なのですが、

一体どちらを使うべきなのかというと、

個人的にはundefinedの方が良いのかと思います。</p>
undefinedは、オプショナルプロパティなどに出現するので、

null型よりは、遭遇機会も多く、下手なバグに遭遇しにくい印象があります。

(ただ、チームの方針によるので、もう正直どちらでも良いと思います。

どちらが絶対にだめという類のものではないです。)</p>
基本的に、こういった型は、自分で定義するものではなく、

メソッドや関数などの返り値がデータがない、

null型とかだった場合に、別の処理を記述するといったようにして、

null型を減らすよう努める類のものです。</p>
なので、この2つが出てきたら、

データがないと捉えれば問題ないです。</p>
ラッパーオブジェクト</h2>
プリミティブ型は、オブジェクトと違って、

メソッドを持ちません。

しかし、あたかもメソッドを持つかのように振る舞います。</strong></p>
例えば、"hello"というのは、

文字列でプリミティブ型なので、

本来メソッドを持ちません。

けれども、下記のようにincludesメソッドを実行できます。</p>
"hello"</span>.</span>includes</span>(</span>"h"</span>)</span></span></code></pre>
これは、"hello"という文字列のラッパ−オブジェクト,Stringに変換され、

そのラッパーオブジェクト経由でメソッドが呼び出せれているので、

あたかもオブジェクトのように振る舞っているということです。</strong></p>
ラッパーオブジェクトとは、

そのプリミティブ型の大本のクラスのインスタンスですね。

型注釈に振る型と思っていただければ大丈夫です。</p>
すなわち、</p>
new</span> String</span>(</span>"hello"</span>).</span>includes</span>(</span>"h"</span>)</span></span></code></pre>
と同義です。</p>
typeofを使うとわかるのですが、

"hello"は文字列なのに対し、

new String("hello")は

オブジェクトになります。</p>
const</span> str1</span> = new</span> String</span>(</span>"hello"</span>)</span></span>
const</span> str2</span> =</span> "hello"</span></span>
</span>
console.</span>log</span>(</span>typeof</span> str1);</span> // object</span></span>
console.</span>log</span>(</span>typeof</span> str2);</span> // string</span></span></code></pre>
メソッドはオブジェクトでないと、呼び出せないのに、

プリミティブ型からも呼び出せるように見えるのは、こういう仕掛けがあるからです。</p>
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String</a></p>
ちなみに、数値型は、Number、真偽値は、Booleanといった

ラッパーオブジェクトがあります。</p>
詳細は、下記に書かれてあります。</p>
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures</a></p>
なぜ、長々とこんなことを説明したのかというと、

冒頭でプリミティブ型は、プロパティやメソッドを持たないと言った意味が、

上記のラッパーオブジェクトに関わっているからです。</p>
プリミティブ型とは何かという定義に対し、

ドキュメントもラッパーオブジェクトに言及して説明しています。</p>
これで下記のドキュメントで言っている意味がわかるようになるはずです。</p>
https://developer.mozilla.org/en-US/docs/Glossary/Primitive</a></p>
プリミティブ型は、nullとundefined以外、

ラッパーオブジェクトを持っています。</p>
それはすなわち、ラッパーオブジェクトがないと、

メソッドなどを実行できないからです。</p>
nullとundefinedには当てはまらないが、

この2つはやや特殊なのでプリミティブ型とは何かという問いに対し、

対応するラッパーオブジェクトを持ち、

メソッドを実行する際、それに変換されるもの</strong>と考えた方が、

わかりやすいかもしれないですね。</p>


【TypeScriptの変数】let/constと変数として使えないもの
2022-12-24T00:00:00+00:00
TS Playground</h2>
TS Playgroundは、

TypeScriptを試すことができるサンドバッグ的環境。</p>
通常、プログラミング言語の学習などをする際は、

自分のPCに実行環境を構築する必要があるのですが、

この作業が割りと最初の関門だったりします。</p>
なので、クラウド上で、手軽にTypeScriptを試すことができると、

便利なわけですが、TS playgroundは、それに該当します。</p>
こんな感じです。</p>
</p>
このようなplaygroundは、

TypeScriptに限らず、様々な言語にあり、

有名所でいうと、Rust Playgroundでしょうか。</p>
静的型付け言語の場合、

コンパイルという作業が必要になるのですが、

たかが文法の学習にそのような実行環境を作るのは、

面倒なときもあります。</p>
TypeScriptも静的型付け言語なので、</strong>

TypeScriptの文法を試す際、</strong>

playgroundを使うと手軽で便利かなと思うので、</strong>

最初にご紹介します。</strong></p>
https://www.typescriptlang.org/play</a></p>
変数とは？</h2>
変数とは、

よく箱に例えられることが多いので、

値などを格納することができる名付けの役割を果たします。</strong></p>
例えば、TypeScriptだと下記のように変数を定義するのですが、</p>
const</span> box</span> =</span> '何かが入っている箱です'</span></span></code></pre>
この場合、boxというの変数名で、

箱のような感じです。</p>
以降、このboxを呼び出すと、

値が'何かが入っている箱です'に書き換えられて使用できるので、

boxというのは、ある種の名付けのようになっているという感じです。</p>
さて、そもそも素朴な疑問としてなぜ箱が必要なのか思うかもしれません。</p>
変数は確かに値が入っている箱ではありますが、

そうした箱を使う理由は、先述のように

値などに名前をつけたいからと考えれば大丈夫です。</strong></p>
例えば、

ラーメン屋の売上が100000円で、

曜日によって、

ラーメン屋の売上から1000円引いたり、

300円引いたりと、売上額に対して色々計算をする場合、

変数を使わないと、</p>
console.</span>log</span>(</span>100000</span> -</span> 1000</span>)</span></span>
console.</span>log</span>(</span>100000</span> -</span> 300</span>)</span></span></code></pre>
のように、パット見上の数字が何を表しているのかよくわかりません。</p>
そこで変数を使って、

それぞれをいわゆる箱に入れると、

変数名に好きな名前をつけることができるので、

(※変数名にできないものもあるがそれは後ほど解説します。)</p>
const</span> uriage</span> =</span> 100000</span></span>
console.</span>log</span>(uriage</span> -</span> 300</span>)</span></span>
console.</span>log</span>(uriage</span> -</span>1000</span>)</span></span></code></pre>
というふうすれば、売上から何かを引いているということがわかります。</p>
実際は、上記のような処理の際は関数を使うのがいいのですが、

(関数も名前をつけられる)

変数の名付けの特徴としては、上記のような感じです。</p>
変数の利点はこれ以外にも色々ありますが、

一旦、名付け機能が強力だからという印象で問題ありません。</mark></p>
ちなみにですが、変数の名付けは、とても奥が深く、

難しいものです。</p>
というのも、上記のコードで、

uriageの変数名が下記に変わっていたとするとどうでしょう？</p>
const</span> sio-ramen </span>=</span> 1000000</span></span>
console.</span>log</span>(sio</span>-</span>ramen</span> -</span> 100</span>)</span></span>
console.</span>l0g</span>(sio</span>-</span>ramen</span> -</span> 1000</span>)</span></span></code></pre>
あれ、塩ラーメンって、1000000円もするの？

どんだけ高級なんだよ！って感じですよね。</p>
ただ、これはsio-ramenという名付けが悪くて、

実際の処理は、uriageから引いている処理です。</p>
ただ、上記のコードだけ見たら、

「塩ラーメンの値段から何か引いているんだな」と

読み取れます。</p>
つまり、変数名は、自由に命名ができるにも関わらず、</mark>

そのままの意味で読み取られてしまうので、</mark>

嘘の変数名など書いてしまうと、一気にコードが意味不明になります。</mark></p>
さすがに、上記のような命名はしないかもしれませんが、

例えば、</p>
const</span> uriage1</span> =</span> 100000</span></span>
const</span> uriage2</span> =</span> 100000</span></span>
console.</span>log</span>(uriage1</span> -</span> 300</span>)</span></span>
console.</span>log</span>(uriage1</span> -</span>10000</span></span></code></pre>
のような感じだとどうでしょう？</p>
uriage1とuriage2どう違うねん！って思いませんでした？</p>
ただ、こういう命名は最初のうちは

意外とやってしまいがちです。</p>
「いや、自分はわかりますよ」って思うかもしれませんが、

プログラム開発においては、それではだめで、</strong>

他の人が読んでも誤解なく受け取ってもらえるかを</strong>

意識する必要があります。</strong></p>
コーディングの意図がわからない、他人が上記のコードを読んだら、

uriage1とuriage2の違いはわかりませんし、

なぜ、uriage1からしか引いていないのかもわかりません。</p>
つまり、変数名にコーディングの意図を語らせる必要があるのですが、

命名な自由なだけ、そのあたりは腕の見せどころになります。</p>
変数の名付けが難しく、奥深い理由はこのような感じです。</p>
TypeScriptの変数</h2>
TypeScriptのベースは、</strong>

JavaScriptなので、型以外は、</strong>

基本的に変数宣言のやり方は同じです。</strong></p>
とはいっても、

JavaScriptがあんま良く知らんっていう人も

いるかと思います。</p>
その場合でも、いきなりTypeScriptから勉強しても</mark>

良いかと思います。</mark></p>
JavaScriptは、TypeScriptで型を振らない状態のようなものなので、

TypeScriptの基本文法を学んでおけば、

JavaScriptも基本的な部分は十分でしょう。</p>
さて、ではそんなTypeScriptの変数宣言ですが、

型をつけないで、変数宣言をすることもできるので、

下記のようにJavaScriptと同じ文法で変数定義もできます。</p>
下記は、JavaScriptでもあり、TypeScriptでもあるコードです。</p>
const</span> hello</span> =</span> 'Hello'</span></span>
console.</span>log</span>(hello)</span> // 'Hello'と表示される</span></span></code></pre>
ちなみに、

一行コメントは、//で行い、 複数行コメントは、/…</em>/で行います</strong></p>
これをTypeScriptにすると、</p>
const</span> hello</span>:</span> string</span> =</span> 'Hello'</span></span>
console.</span>log</span>(hello)</span></span></code></pre>
というふうに型をつけることができます。</p>
Helloは、文字列なので、

stringを型として指定します。</p>
ちなみに、上記のような場合は、

型推論がきくはずなので、

stringの型注釈をする必要もないかもしれません。</p>
https://typescriptbook.jp/reference/values-types-variables/type-inference</a></p>
ただ、型注釈はある種のドキュメント(コードの可読性を上げる)の役割も果たせるので、

基本的には型を振っておいても損はないかなと思います。</p>
ちなみに、下記のようにany型というのを振ることもできますが、

これは、型注釈を無視して、TypeScriptの利点を放棄することに等しいので、

実質的にはJavaScriptと同等です。</p>
const</span> hello</span>:</span> any</span> =</span> 'Hello'</span></span>
console.</span>log</span>(hello)</span></span></code></pre>
上記の場合は、any型を振らなければ、

型推論がきくのに、わざわざany型にしてそのメリットを放棄しているので、

通常ならありえないコードですね。</p>
any型は、JavaScriptからTypeScriptに移行するために

暫定的に使うぐらいでしょうか。</p>
ちなみに、ESLintとかでも、

any型があると警告が出たりします。</p>
こういった型の詳細については、

下記の記事もご参考ください。</p>
[st-card myclass="st-no-shadow" id="23" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
変数名としてつかえないもの</h3>
さて、そんな変数ですが、

何でも好きな名前をつければいいというわけでもありません。</p>
まず予約語</strong>は変数名には使えません。

予約語とは、ifやforなど、TypeScriptのなかで予め用意されているものです。</p>
基本的には、JavaScriptの予約語と変わらないはずです。

ここにJavaScriptの予約語が書かれています。</p>
https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Lexical_grammar</a></p>
ただ、変数の名付けは、基本的に他のプログラマーがわかるような変数にするため、

正直予約語と衝突することはあまりありません。

(予約語を変数名に使っている時点で変数名としては良く傾向があるので)</p>
ただ、例えば教育関連のシステムで、

学校のクラスの変数名を使いたいときは、

予約後で衝突するので、衝突したからと悪いともかぎりません。</p>
こういう場合は、変数名を考えるのが大変ですが、

別のものにする必要があります。</p>
JavaScriptの話ではありませんが、

以前、Ruby on Railsを使用している際、

テーブルのカラムにsequece(順番)というものが有りましたが、

これがライブラリのFactory botのメソッドと衝突するということが有りました。</p>
予約後の衝突というわけでもありませんが、

衝突すると、エラーになってしまうので、

避けましょう。</p>
変数名の話に戻りますが、

一応、日本語も変数名にすることは、

可能っちゃ可能です。</p>
けれども、基本的に変数名に日本語を使用することは</strong>ありません。</p>
そもそもコンピュータと日本語の相性はあまり良くなく、

文字コード関連で余計なエラーを招く可能性があるので、

日本語じゃなきゃだめという強い理由がないと変数名に採用するのは、

避けるべきかなと思います。</p>
数字に関しては、先頭以外であれば、

変数名に含めても問題ありません。</p>
記号系に関しては、基本的にNGだが、

_とかは比較的よく使われます。</p>
変数の命名規則に、

パスカルケースや、ケバブケース、スネークケースなどありますが、</strong>

_などは、スネークケースとかで用いられますね。</strong></p>
TypeScriptの場合、スネークケースが採用されるケースは

殆どないと思いますが、Rubyとかだとスネークケースで記載することが

増えてきます。</p>
https://typescript-jp.gitbook.io/deep-dive/styleguide</a></p>
TypeScriptの変数名の良い例を紹介すると、</p>
const</span> greeting</span> =</span> 'hello'</span></span>
const</span> uriage1</span> =</span> 10000</span></span>
const</span> kyounoUriage</span> =</span> 1000</span></span></code></pre>
反対に変数名の悪い例を紹介すると、</p>
const</span> あいさつ</span> =</span> 'hello'</span> //エラーにはならない</span></span>
const</span> 1uriage</span> =</span> 1000</span></span>
const</span> if</span> =</span> 1999</span> //予約語を変数名にしている</span></span>
const</span> kyouno uriage </span>=</span> 1000</span> //変数名に空白が入っている</span></span>
const</span> kyouno_uriage</span> =</span> 1000</span> //エラーにはならないが、JavaScriptの変数でスネークケースはスタイルガイド的に良くない</span></span></code></pre>
のような感じになるかなと思います。</p>
まあ、正直な話、

バックエンドRuby、フロントエンドJavaScriptの構成とかだと、

api側の変数の命名規則に併せて、フロント側でもスネークケースで受け取るみたいなことは、

全然あるかなとも思いますので、スネークケースについては、

一概に悪いとも断定できませんが。</p>
変数に型を与える</h3>
さて、上記までの話は、

TypeScriptというより、

JavaScript寄りの話でしたが、

TypeScriptの特徴はなんといっても、型にあります。</strong></p>
先程、ちらっと触れましたが、

TypeScriptは変数に型注釈を加えて書きます。</p>
const</span> greet</span>:</span> string</span> =</span> 'hello'</span></span></code></pre>
上記の: stringの部分が型注釈です。</p>
stringというのは、文字列のことで、

変数greetに代入されているのは、

'hello'という文字列です。</p>
なので、この場合は問題ないコードです。</p>
const greet: stringと書いた時点で、</strong>

greetという変数にはstring型しかいれることができないというのが、 上記のコードの意味で</strong>す。</p>
試しにstring型以外を入れてみましょう。</p>
const</span> greet</span>:</span> string</span> =</span> 100</span></span></code></pre>
すると、</p>
Type 'number' is not assignable to type 'string'.</span></span></code></pre>
となります。</p>
これは、100がnumber型なのに対し、

greetという変数がstring型になっているので、

型が一致しないよというコンパイルエラーです。</p>
「エラーが出るんだったら、

JavaScriptのほうがいいんじゃね？」

って思うかもしれませんが、

実はそうではないのです。</p>
型があることによる恩恵は、偉大ということを解説します。</p>
型の恩恵</h3>
先程変数は箱と言ったように、

まさしく、変数は処理されたあとの値を待ち受ける箱のように使うことがあるでしょう。</p>
その際、JavaScriptだと、型を宣言することはできないので、

箱は渡された値をそのまま入れるしかありません。</p>
イメージとしては、毒を渡されても、</strong>

それが毒ですとは教えてくれず、</strong>

黙って箱の中にしまってしまうのが、 JavaScript</strong>です。</p>
おとなしい人が、嫌といえずに溜め込んでしまって、

最後に爆発してしまうのに似ているかと思います。

(この場合、爆発はJavaScriptの場合だと本番コードでの

エラーでインシデントになることですかね。)</p>
それに対して、TypeScriptは待ち受ける箱に予め型をつけることができるので、

渡されてきた値が型と違っていれば、違うよというコンパイルエラーを出してくれます。</p>
すなわち、毒を渡されても、 それが毒です、受け付けられませんとエラーを出してくれるのが、 TypeScript</strong>です。

本番コードに上げる前に、まずい部分を指摘してくれるので、

本番でのインシデントの軽減に一役かってくれているという感じです。</p>
コンパイルエラーと言われると身構えてしまいますが、

要は不適切な値を事前に弾いてくれているため、

非常にありがたい代物と思っていただければ大丈夫です。</p>
JavaScriptとかだと、毒が全身に回って、死亡するまで

(ソフトウェア的には、バグが複雑化して手がつけられなくなるまで)

気づかない恐ろしさがあるともいえます。</p>
まあ、何が言いたかったのかというと、</strong>

とりあえず、コンパイルエラーは喜ぼうっていうことで</strong>す。</p>
よく、「エラーが怖くなくなる本」みたいな書籍を

見かけることがありますが、

ああいう本の趣旨も、だいたいこのような感じなのかなと思っています。</p>
エラーは親切に教えてくれているんですよ(笑)</p>
letとconst</h3>
上記までの具体例では、

変数宣言の際、基本的にconstを使用してきました。</p>
これに加えて、letというものもあります。</strong>

(varというのもありますが、非推奨なので紹介しません。

昔のレガシーコードでは遭遇することもあるかもしれませんが、

基本的に使うべきではありません。)</p>
let</span> greet</span>:</span> string</span> =</span> 'hello'</span></span></code></pre>
書き方は、constの部分をletに置き換えるだけです。</p>
letとconstの違いは再代入可能かどうか</strong>です。</p>
const</span> hello</span> =</span> 'hello'</span></span>
hello</span> =</span> 'namasute'</span> //Cannot assign to 'hello' because it is a constant.というエラーにな</span></span>
</span>
let</span> greet</span> =</span> 'hello'</span></span>
greet</span> =</span> 'namasute'</span> //エラーなし</span></span>
console.</span>log</span>(greet)</span> // namasuteと表示される</span></span></code></pre>
再代入できるletの方が柔軟で良さげと思うかもしれませんが、 可能な限りletを使うのは避けるべきです。</strong></p>
なぜなら、再代入可能ということは、

最初に宣言された値とは変わる可能性があるからです。</p>
先程の、TypeScriptとJavaScriptの話に似ていますね(笑)</p>
つまり、letで宣言された変数の場合、

いま現時点でletの変数になんの値が入っているのか正しい状態なのかを

判断しなければなりません。</p>
let</span> greet</span> =</span> 'hello'</span></span>
greet</span> =</span> 'hello1'</span></span>
let</span> greet1</span> =</span> 'hello1'</span></span>
greet</span> =</span> 'hello'</span></span>
greet1</span> =</span> 'hello'</span></span>
greet</span> =</span> greet1</span></span>
greet</span> =</span> greet</span>  +</span> greet1</span></span>
greet</span> =</span> greet</span> +</span> greet</span></span>
console.</span>log</span>(greet)</span></span></code></pre>
実際には、こんなコードは嫌がらせのとき以外は書かないが、

文法上は、こういうコードも許してしまうということになります。</p>
console.logで何が出力されるのか、

いちいち処理を追って行かないとよくわかりません。</p>
つまり、letの使用は読み手に負担を与える可能性があるというこ</strong>とです。</mark></p>
そのため、ifやforなどの複雑なロジックで、

やむをえずletを使うしかない場面以外は基本はletを使わないようにするべきかなと思います。</p>
入門書とかのサンプルコードを見ると、

letのほうが使用頻度が多いので、

letを使っておけばいいだろうみたいない思う方もいるかもしれませんが、

上記の理由で、基本はconstです。</p>
letで書いてしまったら、なんとかしてconstに書き換えできないか、

コードを見直すサインともいえるかもしれないですね。</p>


【TypeScript環境構築手順】nvm経由でのNode.jsインストール
2022-12-23T00:00:00+00:00
TypeScriptの実行環境を作るには、

Node.jsを入れる必要がありますが、

意外とNode.jsを入れたりするのは、

面倒だったりします。</p>
なので、本記事では、</mark>

Node.jsのインストールからTypeScriptの</mark>

実行ができるまでを目指して、解説します。</mark></p>
Node.jsインストール</h2>
公式サイト(https://nodejs.org</a>) で推奨版を

ダウンロードするやり方もありますが、

Node.jsはバージョンを切り替えることが割とあるので、

最初からバージョンマネージャーを入れてしまったほうが早いかと思います。</p>
個人的な印象ですが、Node.jsは

バージョンによるエラーが出たり出なかったりということが

割りと多い印象があり、スピーディにバージョンを切り替えられるかどうかは、

開発体験にも影響するでしょう。</p>
Node.jsバージョンマネージャーは色々ありますが、

ここでは、nvmを使います。</p>
nvm</h3>
公式サイト(https://github.com/nvm-sh/nvm</a>) を見ると、

下記のコマンドでインストールできるようです。</p>
curl</span> -o-</span> https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.2/install.sh</span> |</span> bash</span></span></code></pre>
執筆時点のコマンドなので、

うまく行かない場合は、公式の方のコマンドも試してみてください。</p>
インストールしただけだとPATHが通っていないので、

PATHも公式に従って通してみます。</p>
export</span> NVM_DIR</span>=</span>"$([</span> -z</span> "${</span>XDG_CONFIG_HOME-</span>}" ] &&</span> printf</span> %s "${</span>HOME</span>}/.nvm"</span> ||</span> printf</span> %s "${</span>XDG_CONFIG_HOME</span>}/nvm")"</span></span>
[</span> -s</span> "</span>$NVM_DIR</span>/nvm.sh"</span> ] &&</span> \.</span> "</span>$NVM_DIR</span>/nvm.sh"</span></span></code></pre>
ちゃんとインストールされたか確認する場合は、

下記のコマンドを打ちます。</p>
nvm</span> -v</span></span></code></pre>
インストールされたversionが返ってくれば問題ありません。</p>
早速、nvm経由でNode.jsをインストールしたいので、

まずはインストール可能なversionの一覧を見てみたいと思います。</strong></p>
下記コマンドで確認できます。</p>
nvm</span> ls-remote</span></span></code></pre>
</p>
たくさん出てきますね。</p>
LTSと横に書いているやつは、

Long Term Supportの略なので、

メンテンスがしっかりしているかと思います。</p>
なので、基本的にはこのLTS系を</mark>

インストールすることが望ましいです。</mark>

(あえて不安定なversionでバグを見つけたりして、

遊びたい人を除く)</p>
とりあえず、LTSで一番最新の

v18.12.1をインストールしてみます。</p>
あるバージョンのnode.jsをインストールする場合は、

下記のようなフォーマットでコマンドを実行します。</p>
nvm</span> install v18.12.1</span></span></code></pre>
ちゃんとインストールできたか確認します。</p>
nvm</span> ls</span></span></code></pre>
</p>
こんなふうに、

システムの上らへんに、

今インストールしたversionが出ていれば、

インストールされている。</p>
上記の図だと、v18.12.1と表示されていますね。</p>
ちなみに、->で指しているところが、

現在のNode.jsのversionになります。</p>
最後にNode.jsのバージョン確認で、

定番の下記コマンドを実行してみます。</p>
node</span> -v</span></span></code></pre>
上記を実行すると、同じversionになっているはずです。</p>
以上で、Node.jsをインストールすることができました。</p>
ただ、nvmの強みは、

様々なバージョンを管理できることにあるので、

他のバージョンに切り替えられなきゃ意味はありません。</p>
使うversionを切り替えたいときは、</p>
nvm</span> use v18.12.1</span></span>
nvm</span> use system</span></span></code></pre>
のようにuseを使えば切り替えることができます。</p>
TypeScript環境構築</h2>
Node.jsの導入ができたので、

次にTypeScriptの環境構築をしようと思います。</p>
まずは、package.jsonを作ります。</p>
npm</span> init</span> -yes</span></span></code></pre>
上記は、package.jsonを作成してくれるコマンドです。</p>
作成したら早速、

TypeScriptをインストールしてみます。</p>
npm</span> install</span> --save-dev</span> typescript @types/node</span></span></code></pre>
※なぜかはわからないが、コピペしたやつをそのまま実行しても上手く行かないときがあるので、

その際は、直打ちして試してください。</p>
TypeScriptがインストールできたら、

コンパイラに関する設定ファイルである、

tsconfig.jsonを作成します。</p>
npx</span> tsc</span> -init</span></span></code></pre>
tsconfig.jsonの設定の詳細はさておき、

一旦これでもうTypeScriptを動かすことはできます。</p>
適当なTypeScriptのファイルを作ってみます。</p>
TypeScriptの詳細な文法については、

下記のような記事もご参考ください。</p>
[st-card myclass="st-no-shadow" id="21" label="参考" pc_height="" name="" bgcolor="#cccccc" color="#ffffff" webicon="st-svg-file-text-o" readmore="on" thumbnail="on" type="text"]</p>
const</span> hello</span>:</span> string</span> =</span> "Hello World"</span></span>
console.</span>log</span>(hello)</span></span></code></pre>
このファイルをコンパイルします。</p>
npx</span> tsc</span></span></code></pre>
index.jsというファイルがあれば、

それがコンパイルされたファイルになるので、</p>
node</span> index.js</span></span></code></pre>
とすれば、Hello Worldと表示されるはずです。</p>
ちなみに、いきなりtsファイルを実行するには、

ts-nodeを使います。</p>
npm</span> install</span> --save</span> ts-node</span></span></code></pre>
インストールできたら、</p>
./node_modules/.bin/ts-node index.ts</span></span></code></pre>
でHello Worldと表示されます。</p>
フルスタックLinuxプログラミング

【2025年最新版】おすすめ技術書や買ってよかったもの24選

技術書系</h2> コーディングを支える技術</h3> </div> コーディングを支える技術 ～成り立ちから学ぶプログラミング作法 （WEB＋DB press plusシリーズ） [ 西尾泰和 ]</p>

コーディングを支える技術</h3> </div> コーディングを支える技術 ～成り立ちから学ぶプログラミング作法 （WEB＋DB press plusシリーズ） [ 西尾泰和 ]</p>

Webフロントエンドハイパフォーマンスチューニング</h3> </div> Webフロントエンドハイパフォーマンスチューニング Webサイト・アプリケーションを徹底的に高速化／久保田光則【1000円以上送料無料】</p>

生成AI時代の新プログラミング実践ガイド</h3> 生成AI時代の新プログラミング実践ガイド Pythonで学ぶGPTとCopilotの活用ベストプラクティス [ 松本 直樹 ]</p>

実務で使えるメール技術の教科書</h3> </div> 実務で使える メール技術の教科書 基本のしくみからプロトコル・サーバー構築・送信ドメイン認証・添付ファイル・暗号化・セキュリティ対策まで [ 増井 敏克 ]</p>

パケットキャプチャの教科書</h3> </div> パケットキャプチャの教科書／みやたひろし【3000円以上送料無料】</p>

Pythonでできる 株価データ分析</h3> Pythonでできる！ 株価データ分析 [ 片渕彼富 ]</p>

Flutter実践開発</h3> </div> Flutter実践開発 iPhone/Android両対応アプリ開発のテクニック／渡部陽太【3000円以上送料無料】</p>

プログラミングTypeScript</h3> </div> プログラミングTypeScript スケールするJavaScriptアプリケーション開発／BorisCherny／今村謙士／原隆文【3000円以上送料無料】</p>

研鑽Rubyプログラミング</h3> </div> 研鑽Rubyプログラミング 実践的なコードのための原則とトレードオフ</p>

JavaScript 第7版</h3> </div> JavaScript 第7版 [ David Flanagan ]</p>

金融・ビジネス書系</h2>

「技術書」の読書術</h3> </div> 「技術書」の読書術 達人が教える選び方・読み方・情報発信&共有のコツとテクニック [ IPUSIRON ]</p>

ウォール街のランダム・ウォーカー</h3> ウォール街のランダム・ウォーカー＜原著第13版＞ 株式投資の不滅の真理 [ バートン・マルキール ]</p>

トイレスマホで「無限10倍株」 3年9カ月で5975万円を稼いだ投資</h3> </div> トイレスマホで「無限10倍株」 3年9カ月で5975万円を稼いだ投資術【電子書籍】[ テンバガー投資家X ]</p>

アルトコイン ナビ</h3> </div> アルトコイン ナビ【電子書籍】[ 双葉社 ]</p>

DIE WITH ZERO 人生が豊かになりすぎる究極のルール</h3> </div> DIE WITH ZERO 人生が豊かになりすぎる究極のルール [ ビル・パーキンス ]</p>

ガジェット・その他買ってよかったもの</h2>

SHURE SE215</h3> 【最大1,000円クーポン！1/9 20:00 -1/16 01:59】SHURE シュア SE215 クリア Pro Line 有線イヤホン カナル型 イヤホン 有線 リケーブル対応 MMCX 耳掛け プロ仕様 メーカー保証2年 長期保証加入可 送料無料 国内正規品</p>

Sin チラシお断りステッカー</h3> Sin(シン) チラシ お断り ステッカー 30mm x 150mm 勧誘印刷物の無断投函防止に</p>

東洋佐々木ガラス テイスティンググラス</h3> 東洋佐々木ガラス テイスティンググラス 190ml 36320 ウイスキーグラス タンブラー ビールグラス</p>

HUANUO PCモニターアーム デュアル液晶ディスプレイアーム</h3> </div> HUANUO PCモニターアーム デュアル 液晶ディスプレイアーム 2画面 13～30インチ対応 耐荷重2～9kg ガススプリング式 グロメット</p>

【JavaScriptオブジェクト】プロトタイプの仕組みと配列

プロトタイプ</h3> JavaScriptのオブジェクトは、 プロトタイプと大きな関係を持っています。</p>

【JavaScriptの非同期処理】async/await/Promise

async/await</h3> さて、そんな便利なPromiseですが、 実はもっとモダンな構文があります。</p> それがasync/await</code> です</p> async/awaitを使えば、Promiseチェーンとかをもっとすっきり書くことができます。</strong></p>

Chainguardイメージとよく使用されるDockerイメージとの違い

各イメージの脆弱性スキャン</h2> さて、各イメージの環境構築をしたので、 脆弱性スキャンやイメージサイズを比較してみます。</p> まず、イメージのサイズを比較してみます。</p>

trivyを使った脆弱性スキャン</h3> 次に、trivyを使用して、イメージのセキュリティスキャンも実行してみます trivyがなければ、homebrewとかでインストールしておきます。</p>

【JavaScript概要】環境構築と変数について

変数と定数</h2> さて、JavaScriptの概要説明が長引いてしまったので、 ここらで一旦、シンプルに文法の話をしようと思います。</p> まずは、定番ですが、変数と定数について解説します。</p>

エンジニアにおけるプロダクト志向と技術志向について

【コードを記述するコード】Rubyのメタプログラミングという黒魔術

【SQLテーブル結合(JOIN)とDDL】DBの制約と主キー/外部キー

外部結合(OUTER JOIN)</h3> 内部結合であれば、 行が消滅してしまうようなものを、</strong> 出力するのを外部結合</strong>と総称し、 下記のような種類があります。</p>

【SQL グループ化】GROUP BY/HAVING句とWITH ROLLUP

【SQL基礎】DISTINCTやORDER BYなどの検索結果の加工と関数

SELECTにおける検索結果の加工</h2> 早速、検索した結果を加工するための文法として、 DISTINCT、ORDER BY、OFFSET-FETCHについて 取り上げます。</p> 特に、前2つはよく使うので、 覚えておくと便利かと思います。</p>

【SQLデータ型】Where句と条件式における演算子

日時データ型</h3> 次に日時データ型です。 主なものとしては、</p>

演算子</h3> 上記のクエリーで出てきた、 Where句内の、>のように、 条件式で使う演算子には様々なものがあります。</p>

比較演算子</h4> まず>のような演算子は、 比較演算子といい、 下記のようなものがあります。</p>

【Docker DBコンテナ構築】データベースの種類やSQLの概要解説

外部結合(OUTER JOIN)</h3>
内部結合であれば、
行が消滅してしまうようなものを、</strong>
出力するのを外部結合</strong>と総称し、
下記のような種類があります。</p>

SELECTにおける検索結果の加工</h2>
早速、検索した結果を加工するための文法として、
DISTINCT、ORDER BY、OFFSET-FETCHについて
取り上げます。</p>
特に、前2つはよく使うので、
覚えておくと便利かと思います。</p>

演算子</h3>
上記のクエリーで出てきた、
Where句内の、>のように、
条件式で使う演算子には様々なものがあります。</p>
