## 対象読者

- NvimユーザーでLuaを使いたい型
- Lua初心者

## セットアップ

以下のコマンドでインストールできる。

```bash
sudo apt update
sudo apt install -y lua5.4
```

ドキュメントは以下を参照
> <https://www.lua.org/docs.html>

## Hello World

拡張子は`.lua`。

```lua
echo 'print("Hello, World!")' > hello.lua
lua hello.lua
```

## 対話モードでの注意点

**対話モードで`local`をつけると次の行で使えないので注意**

```lua
> local arr = 1
> print(arr)
nil
```

コピペして1行に収めると使える。

```lua
> local x = io.read()
print(x)
x
x
```

## 変数

何もつけなければグローバル変数、localをつけるとローカル変数になる。

```lua
x = 5
local x = 10
```

0除算してもエラーにならないので注意

```lua
> 1/0
inf
```

## コメント

luaのコメントは`--`で始まる。

複数行コメントは`--[[`で始まり`]]`で終わる。
複数行コメントの場合は、--の後にスペースを入れてはいけない。

```lua
-- comment
--[[
 multi line comment]]
```

## 基本データ型

- nil: null
- Boolean: true, false
- number: 数値
- string: 文字列
- userdata: C言語で定義されたデータ型
- function: 関数
- thread: スレッド
- table: 連想配列

型の確認は`type()`関数で行う。

```lua
type("Hello, World!")
type(print)
```

## 条件分岐

else以外は都度`then`をつける。

```lua
if x > 10 then
    print("x is greater than 10")
elseif x < 10 then
    print("x is less than 10")
else
    print("x is 10")
end
```

### 比較演算子

不一致は!=ではなく`~=`。

- `==`
- `~=`
- `>`
- `<`
- `>=`
- `<=`

### 論理演算子

`&`や`|`は使えない。

- `and`
- `or`
- `not`

## IO

標準入力

```lua
local x = io.read()
print(x)
```

標準出力

改行あり

```lua
print("Hello, World!")
```

改行なし

```lua
io.write("Hello, World!")
```

## 繰り返し

### while

```lua
local i = 0
while i < 10 do
    print(i)
    i = i + 1
end
```

### for

```lua
for i = 0, 10, 1 do
    print(i)
end
```

stepはデフォルトで1。

```lua
for i = 0, 10 do
    print(i)
end
```

始まりの数と終わりの数どっちも含む

```txt
0
1
2
3
4
5
6
7
8
9
10
```

### break

```lua
for i = 0, 10 do
    if i == 5 then
        break
    end
    print(i)
end
```

### continue

continueはgotoで実現する。

```lua
for i = 0, 10 do
    if i == 5 then
        goto continue
    end
    print(i)
    ::continue::
end
```

## 連想配列

**Luaの連想配列の添え字は1から始まる。**

初期化

```lua
local arr = {1, 2, 3}
print(arr[1])
```

```lua
local arr = {
    name = "Jack",
    age = 30,
}
```

連想配列の長さは`#`で取得できる。

```lua
print(#arr) -- 3
```

連想配列のメモリは共有されている。

```lua
local arr = {}
arr["key"] = "value"
arr["key2"] = "value2"
arr["key3"] = "value3"
local another_arr = arr
print(another_arr["key"]) -- value
another_arr["key"] = "new value"
print(arr["key"]) -- new value
```

`.`で値を設定することも出来る

```lua
local arr = {}
arr.x = 10 -- arr["x"] = 10
print(arr.x) -- 10
```

for文で取得
ipairsではなく、pairsを使う。

```lua
local arr = {}
arr["key"] = "value"
arr["key2"] = "value2"
arr["key3"] = "value3"
arr[1] = "value"
arr["a"] = "value"
for k, v in pairs(arr) do
    print(k, v)
end
```

```txt
1       value
key     value
a       value
key2    value2
key3    value3
```

ipairsに渡すとイテレーターが回らない。

```lua
local arr = {}
arr["key"] = "value"
arr["key2"] = "value2"
arr["key3"] = "value3"
for i, k, v in ipairs(arr) do
    print(i, k, v)
end
```

こうすれば回る。

```lua
local arr = {}
arr["key"] = "value"
arr["key2"] = "value2"
arr["key3"] = "value3"
arr[1] = "value"
for i, k, v in ipairs(arr) do
    print(i, k, v) -- 1 value nil
end
```

存在しない値を取得しようとしてもエラーにならない。

```lua
> arr = {}
> arr[1]
nil
```

### ipairsとpairsの違い

- ipairs: 連続した整数のキーを持つ要素を順番に取得する
  - 1から始まる
  - 配列的な使い方をしたい場合に使う
- pairs: すべてのキーと値を順不同で取得する
  - 連想配列的な使い方をしたい場合に使う

## 関数

関数名には、英数字とアンダースコアが使える。

```lua
function add(x, y)
    return x + y
end

print(add(1, 2))
```

さすがにグローバルは優先されない

```lua
x = 5
y = 3
function add(x, y)
    return x + y
end

print(add(1, 2)) -- 3
```

戻り値が複数の場合

**受け取り側の変数が少ない場合は無視される。**
pythonみたいにTupleで受け取ることは出来ない。
受け取り側の変数が多い場合はnilが入る。

```lua
function add_sub(x, y)
    return x + y, x - y
end

local a, b = add_sub(1, 2)
print(a, b) -- 3, -1
local a = add_sub(1, 2)
print(a) -- 3
local a, b, c = add_sub(1, 2)
print(a, b, c) -- 3, -1, nil
```

可変長引数

ipairsは1から始まる。
pythonのenumerateみたいなもの。

```lua
function add(...)
    local sum = 0
    for i, v in ipairs{...} do
        sum = sum + v
    end
    return sum
end

print(add(3, 3, 3)) -- 9
print(add(1, 2, 3, 4)) -- 10
```

ipairsにいれてイテレーターにしないとエラーになる。

```lua
function add(...)
    local sum = 0
    for v in ... do
        sum = sum + v
    end
    return sum
end
```

独自のイテレーターを作ることも出来る。
return function()でイテレーターを返す。
return から end までがイテレーターの中身。

```lua
function my_ipairs(arr)
    local i = 0
    return function()
        i = i + 1
        if arr[i] then
            return arr[i]
        end
    end
end

function add(...)
    local sum = 0
    for v in my_ipairs{...} do
        sum = sum + v
    end
    return sum
end

print(add(3, 3, 3)) -- 9
print(add(1, 2, 3, 4)) -- 10
```

## 二次元配列

初期化

```lua
local matrix = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9},
}
```

for文での初期化

```lua
local matrix = {}
for i = 1, 3 do
    matrix[i] = {}
    for j = 1, 3 do
        matrix[i][j] = i * j
    end
end
```

for文で取得

```lua
for i = 1, #matrix do
    for j = 1, #matrix[i] do
        print(matrix[i][j])
    end
end
```

## Stack

```lua
local stack = {}

function push(x, stack)
    table.insert(stack, x)
end

function pop(stack)
    return table.remove(stack)
end

function top(x)
    return x[#x]
end

function is_empty(x)
    return #x == 0
end

push(1, stack)
push(2, stack)
push(3, stack)
print(top(stack)) -- 3
print(pop(stack)) -- 3
print(top(stack)) -- 2
print(is_empty(stack)) -- false
```

## Queue

```lua
local queue = {}

function push(x, queue)
    table.insert(queue, x)
end

function pop(queue)
    return table.remove(queue, 1)
end

function front(x)
    return x[1]
end

function is_empty(x)
    return #x == 0
end

push(1, queue)
push(2, queue)
push(3, queue)
print(front(queue)) -- 1
print(pop(queue)) -- 1
print(front(queue)) -- 2
print(is_empty(queue)) -- false
```

## Set

値をtrueにすることでsetを実現する。

```lua
function newSet()
    local set = {}
    setmetatable(set, {__index = table})
    return set
end

function set_insert(set, x)
    set[x] = true
end

function set_remove(set, x)
    set[x] = nil
end

function set_contains(set, x)
    return set[x] == true
end

local set = newSet()
set_insert(set, 1)
set_insert(set, 2)
set_insert(set, 3)
print(set_contains(set, 1)) -- true
print(set_contains(set, 4)) -- false
set_remove(set, 1)
print(set_contains(set, 1)) -- false
```

## クラス

__indexを使ってクラスを実現する。

__indexはメタテーブルと呼ばれる特殊なテーブルで、メタテーブルの種類は以下の通り。

- `__index`: テーブルに存在しないキーアクセス時に呼ばれる。
- `__newindex`: 新しいキー/値のペアがテーブルに追加されるときに呼ばれる。
- `__tostring`: `tostring`関数または`print`関数がテーブルを引数にとる場合に呼ばれる。
- `__add`: `+`演算子の動作を定義する。
- `__mul`: `*`演算子の動作を定義する。
- `__call`: テーブルが関数として呼び出されたときに呼ばれる。

setmetatableでクラスを作成する。

`.`は通常テーブル要素にアクセスするための演算子だが、`:`はメソッド呼び出しのための演算子。
`:`を使うと、メソッドに暗黙的にselfを渡す。
`.`を使ってメソッドを呼び出す場合には、selfを明示的に渡す必要がある。

```lua
local Person = {}
Person.__index = Person

function Person.new(name, age)
    local self = setmetatable({}, Person)
    self.name = name
    self.age = age
    return self
end

function Person:print()
    print(self.name, self.age)
end

local person = Person.new("Jack", 30)
person:print()
local person2 = Person.new("John", 40)
person2:print()
```

## 二分木

```lua
local Node = {}
Node.__index = Node

function Node.new(value)
    local self = setmetatable({}, Node)
    self.value = value
    self.left = nil
    self.right = nil
    return self
end

local root = Node.new(1)
root.left = Node.new(2)
root.right = Node.new(3)
root.left.left = Node.new(4)
root.left.right = Node.new(5)
root.right.left = Node.new(6)
root.right.right = Node.new(7)
print(root.value) -- 1
print(root.left.value) -- 2
print(root.right.value) -- 3
print(root.left.left.value) -- 4
```

## グラフ

```lua
local Graph = {}
Graph.__index = Graph

function Graph.new()
    local self = setmetatable({}, Graph)
    self.adj = {}
    return self
end

function Graph:add_edge(u, v)
    if not self.adj[u] then
        self.adj[u] = {}
    end
    table.insert(self.adj[u], v)
end

function Graph:print()
    for k, v in pairs(self.adj) do
        print(k, table.concat(v, " "))
    end
end

local graph = Graph.new()

graph:add_edge(1, 2)
graph:add_edge(1, 3)
graph:add_edge(2, 3)

graph:print()
```

## インポート

### dofile

外部ファイルを実行する。
読み込んだ関数を何度も実行する場合は毎回ファイルを読み込むため、パフォーマンスが悪い。

```lua title="minimum.lua"
function minimum(x, y)
    if x < y then
        return x
    else
        return y
    end
end
```

```lua title="main.lua"
dofile("minimum.lua")
print(minium(1, 2)) -- 1
```

### require

外部ファイルを読み込む。
一度読み込まれたモジュールはキャッシュされ、次回以降の呼び出しでは再読み込みを行わないため、パフォーマンスが向上する。

モジュールにしたい場合は、グローバルで対象をreturnする。
jsのexport defaultみたいなもの。

```lua title="minimum.lua"
local function minimum(x, y)
    if x < y then
        return x
    else
        return y
    end
end
return minimum
```

```lua title="main.lua"
local minimum = require("minimum")
print(minium(1, 2)) -- 1
```

```bash
lua main.lua
```

### ファイルシステムについて

Luaでは`lua`ディレクトリがある場所がカレントディレクトリになる。

実例があった方が分かりやすいため、[Lazy](https://lazy.folke.io/)でVimプラグインを管理することを例としてファイルシステムを解説すると、

```txt
your_project
├── init.lua
└── lua
    ├── custom
    │   └── default.lua
    ├── default
    │   └── default.lua
    └── lazy-plugins.lua
```

上記のようなフォルダ構成をとっている場合、`lua/default/init.lua`から`lua/default/default.lua`を読み込む場合は以下のように記述する。

```lua title="lua/default/default.lua"
return {
    "fuga/hoge"
}
```

```lua title="lua/custom/default.lua"
return {
    "hoge/fuga",
    event = "BufEnter",
    dependencies = {
        "hogehoge/hoge"
    }
}
```

以下のようにすれば、Lazyの機能の`import`を使用すれば、`lua/default/*.lua`と`lua/custom/*.lua`を読み込むことができる。

```lua title="lua/lazy-plugins.lua"
require('lazy').setup({
    spec={
    {import="default"},
    {import="custom"},
    }
})
```

luaディレクトリの外にあるが、基準がluaディレクトリであるため、`init.lua`から`lua/lazy-plugins.lua`を読み込む場合は以下のように記述する。

```lua title="init.lua"
require 'lazy-plugins'
```

また、Lazyのimport機能があるので、あまりやる意味はないが、以下のようにしても読み込むことができる。

```lua title="lua/lazy-plugins.lua"
require('lazy').setup({
    spec={
        require('default.default'),
        require('custom.default'),
    }
})
```

## まとめ

- 対話モードで`local`をつけると次の行で使えないので注意
- 何もつけなければグローバル変数、localをつけるとローカル変数になる
- continueなんて文はない
- 不一致は!=ではなく`~=`
- 論理演算子は`and`, `or`, `not`
- 連想配列の添え字は`1`から始まる
- 連想配列しかない
- クラスはメタテーブルを使って実現する
- モジュールにしたい場合は、グローバルで対象をreturnする
- 可変長引数は`...`
- 関数は`:`を使うと暗黙的にselfを渡すが、`.`を使う場合は明示的にselfを渡す
- イテレーターを自作する場合は、`return function() end`を関数内で定義する
- 基本的にエラーは出ない、nilが返る

使ってみた感想としては、制約が緩すぎ+エラーが出ない+クラスの定義がめんどくさいので、好んで使うことはないと思った。


neovim.svg

速成 Lua

## 対象読者

- N|Solidについてざっくり知りたい方

## 経緯

PPA経由でNode.jsをアップデートしていたら、以下のメッセージが表示され、気になったので調査した。

```txt
To install Node.js, run: apt-get install nodejs -y
You can use N|solid Runtime as a node.js alternative
To install N|solid Runtime, run: apt-get install nsolid -
```

公式ドキュメント
> <https://docs.nodesource.com/nsolid/5.0/docs>

## N|Solidとは

NODESOURCE®の提供しているOSSのJSのランタイムでC++コンポーネントのN|Solid AgentがバンドルされたNode.jsのビルド。
N|Solid Angentはアプリケーション内の独自のスレッドで実行され、Node.js, libuv, V8に直接アクセスできる。

## N|Solidの特徴

- 詳細なメトリックスへのアクセスが出来る
- 信頼できないモジュールからの保護
- Node.jsとの互換性
  - N|Solid 5.xはNode.js v18.x Hydrogen LTSまたはNode.js v20.x Iron LTSのどちらかをベースにしている
  - 付加機能をつけただけなので、全てのNode.jsアプリケーションがN|Solidで動作するらしい
- OpenTelemetryのサポート
- 機械学習モデルを使用したカスタムイベントの起動
- Webhookのサポート

## デモ実行

以下のURLからアカウントを作成することで、N|Solidを試すことができる。
> <https://accounts.nodesource.com/>

登録が完了したら、N|Solidのダッシュボードにアクセスでき、N|Solidセットアップからデモプロジェクトのセットアップが出来る。

NODE.JS APPLICATIONSとSERVERLESS FUNCTIONのどちらかを選択し、デモプロジェクトをセットアップする。

今回はNODE.JS APPLICATIONSを選択し、QUICKSTART DEMOを選択すると以下のコマンドが表示されので、ローカルで実行する。

```bash
npx nsolid-quickstart --lts=iron --saas=$NSOLID_SASS --demo
```

実行するとブラウザがページが遷移し、N|Solidのダッシュボードが表示される。
ダッシュボードのヘッダーのSHOW DEMOからデモを起動できる。

メトリックスでは以下の情報を取得できる。

- Node.js プロセスのホスト システム
- プロセス自体
- Node.js の内部動作
- V8 JavaScript エンジンの内部動作

また、機械学習モデルを作成してメトリックス情報を使用してトレーニングすることもでき、カスタムイベントを作成してWebhookを使用して通知することもできる。

## まとめ

メトリックスはGrafanaやPrometheusなどのツールで取得できるが、N|Solidはそれらのツールを使わずにメトリックスを取得できるので、フロントのみでの運用やフロント、バックがともにJSの場合はN|Solidでモニタリング環境を楽に構築できるので、使ってみる価値はあると思う。


JSのランタイムエンジンであるN|Solidについてのまとめ

nsolid-logo.svg

N|Solidについてまとめてみた

## 対象読者

- プログラミング初心者
- JavaScript の基本構文を学びたい方
- 今すぐ JavaScript の文法を思い出さないといけない方

## 関数応用

### 関数の定義方法

関数の定義方法は以下の4つがある。

一番オーソドックスな定義方法

```javascript
function 関数名(引数1, 引数2, ...) {
    処理
}
```

```javascript
function add(a, b) {
    return a + b
}
```

アロー関数を使用した定義方法(ES6)
最近のJavaScriptでは、アロー関数を使用した定義方法が主流。

```javascript
const 関数名 = (引数1, 引数2, ...) => {
    処理
}
```

```javascript
const add = (a, b) => {
    return a + b
}
```

戻り値が1つの場合、処理が1行の場合は、以下のようにreturn文を省略することができる。

```javascript
const 関数名 = (引数1, 引数2, ...) => 処理
```

```javascript
const add = (a, b) => a + b
```

functionキーワードを使用した定義方法
現場ではあまり使わない

```javascript
const 関数名 = function(引数1, 引数2, ...) {
    処理
}
```

Functionコンストラクタを使用した定義方法(引数を文字列で指定)
現場ではあまり使わない

```javascript
const 関数名 = new Function('引数1', '引数2', '...', '処理')
```

### 関数の戻り値

関数の戻り値は、return文を使用して指定する。

```javascript
function 関数名(引数1, 引数2, ...) {
    return 戻り値
}
```

戻り値は呼び出し元で受け取ることができる。

```javascript
const add = (a, b) => {
    return a + b
}
const result = add(1, 2)
console.log(result) // 3
```

## 関数の応用

### 標準組み込みオブジェクト

String, Number, Array, Objectなどのオブジェクトは、JSの標準組み込みオブジェクトと呼ばれる。

各詳細については以下を参照

<https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/GlobalObjects>

### Stringオブジェクト

Stringオブジェクトの詳細は以下を参照
<https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/GlobalObjects/String>

Stringオブジェクトのプロパティ

- length: 文字列の長さを取得する(プロパティ)

```javascript
const str = "Hello"
console.log(str.length) // 5
```

Stringオブジェクトのメソッド

JSのStringオブジェクトには、文字列を操作するためのメソッドがある。

- toUpperCase: 文字列を大文字に変換する

```javascript
const str = "Hello"
console.log(str.toUpperCase()) // HELLO
```

- toLowerCase: 文字列を小文字に変換する

```javascript
const str = "Hello"
console.log(str.toLowerCase()) // hello
```

- charAt: 指定した位置の文字を取得する

```javascript
const str = "Hello"
console.log(str.charAt(0)) // H
```

- indexOf: 指定した文字列が最初に現れる位置を取得する

```javascript
const str = "Hello World"
console.log(str.indexOf("o")) // 4
```

- substring: 指定した位置の文字列を取得する

```javascript
const str = "Hello World"
console.log(str.substring(0, 5)) // Hello
```

## Numberオブジェクト

Numberオブジェクトの詳細は以下を参照
<https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/GlobalObjects/Number>

Numberオブジェクトのプロパティ

- MAXVALUE: JSで表現できる最大の数

```javascript
console.log(Number.MAXVALUE) // 1.7976931348623157e+308
```

- MINVALUE: JSで表現できる最小の数

```javascript
console.log(Number.MINVALUE) // 5e-324
```

Numberオブジェクトのメソッド

- toFixed: 指定した桁数で数値を丸める

```javascript
const num = 1.234
console.log(num.toFixed(2)) // 1.23
```

- parseInt: 文字列を整数に変換する

```javascript
const str = "123"
console.log(parseInt(str)) // 123
```

- parseFloat: 文字列を浮動小数点数に変換する

```javascript
const str = "123.45"
console.log(parseFloat(str)) // 123.45
```

- isNaN: 数値がNaNかどうかを判定する

NaNはNot a Numberの略で、数値ではないことを表す特殊な値。

```javascript
console.log(isNaN(1)) // false
console.log(isNaN(10 / "abc")) // true
```

### Arrayオブジェクト

Arrayオブジェクトの詳細は以下を参照
<https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/GlobalObjects/Array>

Arrayオブジェクトのプロパティ

- length: 配列の要素数を取得する(プロパティ)

```javascript
const arr = [1, 2, 3]
console.log(arr.length) // 3
```

Arrayオブジェクトのメソッド

- push: 配列の末尾に要素を追加する

```javascript
const arr = [1, 2, 3]
arr.push(4)
console.log(arr) // [1, 2, 3, 4]
```

- pop: 配列の末尾の要素を削除する

```javascript
const arr = [1, 2, 3]
arr.pop()
console.log(arr) // [1, 2]
```

- shift: 配列の先頭の要素を削除する

```javascript
const arr = [1, 2, 3]
arr.shift()
console.log(arr) // [2, 3]
```

- unshift: 配列の先頭に要素を追加する

```javascript
const arr = [1, 2, 3]
arr.unshift(0)
console.log(arr) // [0, 1, 2, 3]
```

- splice: 配列の要素を追加または削除する

```javascript
const arr = [1, 2, 3]
arr.splice(1, 0, 4)
console.log(arr) // [1, 4, 2, 3]
```

- slice: 配列の一部を取得する

```javascript
const arr = [1, 2, 3]
arr.slice(1, 2)
console.log(arr) // [2]
```

- concat: 配列を結合する

```javascript
const arr1 = [1, 2]
const arr2 = [3, 4]
console.log(arr1.concat(arr2)) // [1, 2, 3, 4]
```

- join: 配列を結合して文字列に変換する

```javascript
const arr = [1, 2, 3]
console.log(arr.join("-")) // 1-2-3
```

- reverse: 配列を逆順にする

```javascript
const arr = [1, 2, 3]
console.log(arr.reverse()) // [3, 2, 1]
```

- sort: 配列をソートする

```javascript
const arr = [3, 1, 2]
console.log(arr.sort()) // [1, 2, 3]
```

### Callback関数

Callback関数とは、関数を引数として渡す関数のこと。

```javascript
const add = (a, b) => {
    return a + b
}
const sub = (a, b) => {
    return a - b
}
const calc = (a, b, callback) => {
    return callback(a, b)
}
console.log(calc(1, 2, add)) // 3
console.log(calc(1, 2, sub)) // -1
```

Callback関数の例

- map: 各要素に対してCallback関数を適用する

```javascript
const arr = [1, 2, 3]
arr.map((value) => {
    return value * 2
})
console.log(arr) // [2, 4, 6]
```

- filter: 配列の要素をCallback関数でフィルタリングする

```javascript
const arr = [1, 2, 3]
arr.filter((value) => {
    return value > 1
})
console.log(arr) // [2, 3]
```

- reduce: 配列の要素をCallback関数で集計する

```javascript
const arr = [1, 2, 3]
arr.reduce((accumulator, value) => {
    return accumulator + value
}, 0)
console.log(arr) // 6
```

### 再帰関数

再帰関数とは、関数内で自分自身を呼び出す関数のこと。
再帰関数を使用する場合は、無限ループにならないように終了条件を設定する必要がある。

以下は再帰関数を使用して、階乗を求める例。

```javascript
const factorial = (n) => {
    if (n === 0) {
        return 1
    }
    return n * factorial(n - 1)
}
console.log(factorial(5)) // 120
```

### クロージャ

クロージャとは、関数とその関数が定義されたスコープの組み合わせのこと。

以下はクロージャを使用して、カウンターを実装する例。

```javascript
const counter = () => {
    let count = 0
    return () => {
        count++
        console.log(count)
    }
}
const c = counter()
console.log(c()) // 1
console.log(c()) // 2
console.log(c()) // 3
```

## クラス

クラスとは、オブジェクト指向プログラミングにおいて、オブジェクトの設計図のこと。
クラスは抽象的な概念であり、クラスを作成する際には、その概念が共通している属性、動作を定義する。

用語集

- オブジェクト指向プログラミング: プログラムをオブジェクト(データ)とそのオブジェクトの操作(メソッド)によって構成するプログラミング手法
- プロパティ: クラスの属性を表すもの(変数)
- メソッド: クラスの動作を表すもの(関数)
- クラス: オブジェクトの設計図
- インスタンス(=オブジェクト): クラスを実体化したもの
- インスタンス変数: インスタンスに紐づく変数
- インスタンスメソッド: インスタンスに紐づくメソッド
- コンストラクタ: インスタンスを作成する際に呼び出される特別なメソッド
- this: インスタンス変数にアクセスするためのキーワード
- new: インスタンスを作成するためのキーワード

車を例にクラスを作成する。

```javascript
class Car {
    constructor(color, price) {
        // インスタンス変数
        this.color = color
        this.price = price
        this.brand = "Toyota"
        this.model = "Prius"
    }
    run() {
        // インスタンスメソッド
        console.log("走る")
    }
    staus() {
        console.log(`色: ${this.color}, 価格: ${this.price}, ブランド: ${this.brand}, モデル: ${this.model}`)
    }
}
```

上記のように、色や価格などの属性はプロパティとして定義し、走るという動作はメソッドとして定義している。

クラスを使用する際は、インスタンスを作成する。
インスタンスとは、クラスを実体化したもの。
つまり、設計書(クラス)を基に作成された車1台分のこと。

以下のように、newキーワードを使用してインスタンスを作成する。
以下の例では、プリウス、アクア、フィットの3台の車を作成している。

```javascript
const prius = new Car("white", 2000000, "Toyota", "Prius")
const aqua = new Car("blue", 1500000, "Toyota", "Aqua")
const fit = new Car("red", 1000000, "Honda", "Fit")
```

### コンストラクタ

コンストラクタとは、クラスをインスタンス化する際に呼び出される特別なメソッド。

コンストラクタは、インスタンス変数を初期化するために使用される。

以下のように、constructorメソッドを使用してコンストラクタを定義する。

```javascript
class Car {
    constructor(color, price, brand, model) {
        this.color = color
        this.price = price
        this.brand = brand
        this.model = model
    }
}
```

コンストラクタを使用してインスタンス変数に値を設定する場合は、this.プロパティ名 = 値とする。

```javascript
this.color = color
this.price = price
this.brand = brand
this.model = model
```

### プロパティへのアクセス方法

クラスの外では、以下のようにインスタンス変数.プロパティ名でプロパティの値を取得することができる。

```javascript
console.log(prius.color) // white
console.log(prius.price) // 2000000
console.log(prius.brand) // Toyota
console.log(prius.model) // Prius
console.log(aqua.color) // blue
console.log(aqua.price) // 1500000
console.log(aqua.brand) // Toyota
console.log(aqua.model) // Aqua
console.log(fit.color) // red
console.log(fit.price) // 1000000
console.log(fit.brand) // Honda
console.log(fit.model) // Fit
```

クラスの内では、以下のようにthis.プロパティ名でプロパティの値を取得することができる。

```javascript
this.color
this.price
this.brand
this.model
```

### プロパティへの値の設定方法

コンストラクタで指定した引数を使用して、プロパティに値を設定する。

```javascript
class Car {
    constructor(color, price, brand, model) {
        this.color = color
        this.price = price
        this.brand = brand
        this.model = model
    }
}
```

thisキーワードを使用して、インスタンス変数にアクセスする。

```javascript
class Car {
    constructor(color, price, brand, model) {
        this.color = color
        this.price = price
        this.brand = brand
        this.model = model
    }
    status() {
        console.log(`色: ${this.color}, 価格: ${this.price}, ブランド: ${this.brand}, モデル: ${this.model}`)
    }
}
```

thisキーワードはクラス内(class クラス名{}の中)でのみ使用できるキーワード。

値を代入する場合は、クラスのメソッド内で以下のようにthis.プロパティ名 = 値とする。

```javascript
this.color = color
```

値を取得する場合は、クラスのメソッド内で以下のようにthis.プロパティ名でアクセスする。

```javascript
this.color
```

### プロパティの変更方法

クラス外では、以下のようにインスタンス変数.プロパティ名 = 値でプロパティの値を変更することができる。

```javascript
prius.color = "black"
aqua.price = 1800000
```

クラス内で以下のようにthis.プロパティ名 = 値でプロパティの値を変更することができる。

```javascript
this.color = "black"
```

### メソッドの呼び出し方法

以下のように、インスタンス変数.メソッド名()で呼び出すことができる。

```javascript
prius.status() // 色: white, 価格: 2000000, ブランド: Toyota, モデル: Prius
aqua.status() // 色: blue, 価格: 1500000, ブランド: Toyota, モデル: Aqua
fit.status() // 色: red, 価格: 1000000, ブランド: Honda, モデル: Fit
```

また、以下のようにクラスの中にクラスを格納することも可能。

```javascript
class CreditCard {
    constructor() {
        this.creditCardNumber = "1234567890";
        this.cvv = "123";
        this.expirationDate = "12/2022";
    }
}


class User {
    constructor(name, age, email, password) {
        this.name = name;
        this.age = age;
        this.email = email;
        this.password = password;
        this.credit = new CreditCard();
    }
    register() {
        insertdb(this.name, this.age, this.email)
    }
    login() {
        getdb(this.email, this.password)
    }
}
```

### 継承

継承とは、あるクラスを基にして新しいクラスを作ること
継承をすることで、既存のクラスのメソッドやプロパティを再利用できる
継承元のクラスを親クラス、継承先のクラスを子クラスと呼ぶ

```javascript
class Animal {
  constructor(name) {
    this.name = name;
  }

  makeSound() {
    console.log("Some generic sound");
  }
}

class Lion extends Animal {
  roar() {
    console.log("Roar!");
  }

  makeSound() {
    console.log("Roar sound");
  }
}
```

### ポリモーフィズム

ポリモーフィズムとは、同じ名前のメソッドを複数のクラスで定義すること

```javascript
class Animal {
    constructor(name) {
        this.name = name;
    }

    bark() {
        console.log("Generic bark");
    }

    // ポリモーフィズムの例
    makeSound() {
        console.log(`${this.name} make some generic sound`);
    }
}

class Lion extends Animal {
    roar() {
        console.log("Roar!");
    }

    // ポリモーフィズムの例
    makeSound() {
        console.log("Roar sound");
    }
}

class Dog extends Animal {
    bark() {
        console.log(`${this.name} make a woof sound`);
    }

    // ポリモーフィズムの例
    makeSound() {
        console.log("Bark sound");
    }
}

// ラッパー関数
const performSound = (animal) => {
    animal.makeSound();
}

const animal = new Animal("Generic animal");
const lion = new Lion("Simba");
const dog = new Dog("Buddy");

performSound(animal); // "Some generic sound"
performSound(lion); // "Roar sound"
performSound(dog);  // "Bark sound"

class CreditCard {
    constructor(name, number, expirationDate) {
        this.name = name;
        this.number = number;
        this.expirationDate = expirationDate;
    }
}

class Visa extends CreditCard {
    dbconnect() {
        // connectVisaDB()
        console.log("connectVisaDB")
    }
}

class MasterCard extends CreditCard {
    dbconnect() {
        // connectMasterDB()
        console.log("connectMasterDB")
    }
}

class User {
    constructor(name, age, email, credit) {
        this.name = name;
        this.age = age;
        this.email = email;
        this.creditCard = credit
    }

    pay() {
        this.creditCard.dbconnect()
    }
}

let johnvisa = new User("John", 30, "john@example.com", new Visa("rakuten", "111", "12/2022"))
let johnmaster = new User("John", 20, "bob@example.com", new MasterCard("amazon", "222", "12/2022"))
let bobmaster = new User("Bob", 20, "bob@example.com", new MasterCard("amazon", "222", "12/2022"))

johnvisa.pay()
johnmaster.pay()
```


JavaScriptの関数、クラスの応用について学ぶ

javascript-logo.svg

速成 JavaScript Part2

## 対象読者

- DockerComposeでセルフホストランナーを構築しようと思っている方
- DockerComposeでRootUserを使用していない方
- Docker in Dockerの挙動を知りたい方

## TL;DR

GithubActionsのセルフホストランナーのイメージは以下のものを使用することを前提とする。

> <https://hub.docker.com/r/myoung34/github-runner>

このイメージは、`runner`ユーザーで実行されるようになっている。
そのため、DockerComposeでセルフホストランナーを構築する際には、`runner`ユーザーで実行するように設定する必要がある。

上記のイメージを使用するには、`docker.sock`をマウントしてDocker in Dockerをする必要があるため、ホストのdockerのGIDとコンテナ内のGIDを合わせる必要がある。

そのため、DockerComposeとDockerfileは以下のように設定する。

```yaml title="docker-compose.yml"
services:
  runner:
    build:
      context: ./runner
      dockerfile: Dockerfile
      args:
        DOCKER_GID: $DOCKER_GID
        RUNNER_WORKDIR: $RUNNER_WORKDIR
    user: runner
    tty: true
    env_file:
      - .env
    volumes:
      - type: bind
        source: /var/run/docker.sock
        target: /var/run/docker.sock
      - type: volume
        source: runnerData
        target: /tmp/runner
```

```Dockerfile title="Dockerfile"
FROM myoung34/github-runner:latest

ARG DOCKER_GID
ARG RUNNER_WORKDIR

USER root

RUN groupmod -g ${DOCKER_GID} docker && \
    chown root:docker /usr/bin/docker && \
    chown runner:docker /usr/bin/docker && \
    chown -R runner:runner /actions-runner && \
    mkdir -p ${RUNNER_WORKDIR} && \
    chown -R runner:runner ${RUNNER_WORKDIR} /opt/hostedtoolcache

USER runner
```

## イメージを構築して躓いた点

私の環境では、runner以外に複数のサービスがあり、それらのサービスはRootUserでの実行をさけるために、ホストマシンのUIDとGIDをビルド時に渡して、新しくユーザーとグループを作成することで合わせるようにしていた。
そのため、runnerも同様に、ホストマシンのUIDとGIDで新しくユーザーとグループを作成しようとしたが、`docker.sock`の権限がないため、エラーが発生した。

ホストマシンのDocker環境はDockerDesktopを使用しており、これはRootlessではないため、`docker.sock`の権限が以下のものになっていた。

- User: Root
- Group: Docker

そのため、`docker.sock`をマウントするためには、コンテナ内の自作ユーザーにホストマシンのDockerのGIDを合わせる必要があったため、DockerfileのARGで渡すようにした。

ただ、これだと不十分でworkflow実行時に再度`docker.sock`のPermissionエラーが発生した。

この原因としては、**workflowはrunnerユーザーで実行される**ため、自作ユーザーに権限を設定しても意味がないということだった。
DockerComposeとDockerfileのuserの指定で自作ユーザーを指定していたので過信していたが、workflowはrunnerユーザーで実行される。

原因が分かったため、自作ユーザーの作成をやめて、`runner`ユーザーにホストマシンのDockerのGIDを合わせるように設定することで解決した。

## ワークフロー定義時に躓いた点

前述の通り、上記の方法だとDocker in Dockerになるため、ホストマシンのコンテナの起動状況とコンテナ内のコンテナの起動状況がバインドされている。

そのため、ワークフローが実行される際に、ホストマシンで開発用のコンテナなどが動いていると、コンテナが重複したり、コンテナを不用意に落としたりしてしまってエラーを吐くことがある。
具体的には、以下の2ケースが確認できた。

- ワークフローでのdocker compose up(これはrunnerのコンテナを2重起動させてしまうため、注意)
- ワークフローでのdocker compose down(これはrunnerのコンテナも落としてしまうため、注意)
- docker-compose.ymlに`container_name`を指定している場合

また、runnerにdepends_onで他のコンテナを指定している場合は、runnerの起動に他コンテナが引っ張られることがあるため、注意が必要である。

解決方としては、面倒ではあるが、以下のように個別でコンテナを起動するようにするか、docker-compose.ymlをdevやprodなどで分割することで解決できる。

```bash
docker compose rm -fsv db proxy back front; \
docker compose up -d db proxy back front
```


DockerComposeでセルフホストランナーを構築する際に、`docker.sock`のPermissionエラーが発生する問題について解決方法を記載する。

octocat-1720113531003.webp

DockerComposeでのセルフホストランナー(GithubActions)を使った場合のPermissionについて

## 対象読者

- プログラミング初心者
- JavaScript の基本構文を学びたい方
- 今すぐ JavaScript の文法を思い出さないといけない方

## JavaScript

JavaScript(JS)は、ウェブページを動的にするためのプログラミング言語
HTMLとCSSとともに、ウェブページの設計に使用されるJavaScriptは、ウェブページに動的なコンテンツを追加したり、ユーザーの操作に応じてページを変更したりするために使用される
ECMAScriptという標準仕様に基づいているため、ブラウザに依存しない
ES5以前は、ブラウザによって動作が異なることがあったが、ES6以降は、ブラウザに依存しない動作が可能になった

### JavaScriptの基本構文

### 変数

変数は、データを格納するための箱のようなもの

- var: 古いバージョンのJavaScriptで使用される(非推奨)
- let: 変数の再宣言ができない
- const: 再宣言も再代入もできない

```javascript
const x = 10;
```

### データ型

JavaScriptには、以下のデータ型がある

- string: 文字列
- number: 数値
- boolean: 真偽値
- object: オブジェクト
- function: 関数
- undefined: 未定義
- null: 空

型は以下のようにして確認できる

```javascript
console.log(typeof "Hello World"); // string
```

JavaScriptは動的型付け言語であるため、変数の型を宣言する必要はない

### 演算子

JavaScriptには、以下の演算子がある

- 算術演算子
  - +: 加算
  - -: 減算
  - *: 乗算
  - /: 除算
  - %: 剰余
- 代入演算子
  - =: 代入
  - +=: 加算代入
  - -=: 減算代入
  - *=: 乗算代入
  - /=: 除算代入
- 比較演算子
  - ==: 等しい
  - ===: 厳密に等しい
  - !=: 等しくない
  - !==: 厳密に等しくない
  - \>=: 以上
  - <=: 以下
  - \>: より大きい
  - <: より小さい
- 論理演算子
  - &&: 両方がtrueの場合にtrue
  - ||: どちらかがtrueの場合にtrue
  - !: trueをfalseに、falseをtrueに変換
- 三項演算子: (条件) ? trueの場合 : falseの場合
  - 条件分岐の短縮形

比較演算子には、==と===があるが、==は型の比較を行わないため、===を使用することが推奨される

==は、型の比較を行わないため、以下のような結果になる

```javascript
console.log(1 == "1"); // true
```

===は、型の比較を行うため、以下のような結果になる

```javascript
console.log(1 === "1"); // false
```

### 条件分岐

条件分岐は、if文を使用する
条件には、比較演算子を使用する

```javascript
if (条件) { 
    条件がtrueの場合に実行される処理 
} else { 
    条件がfalseの場合に実行される処理 
}
```

else ifを使用することで、複数の条件を指定することができる

```javascript
const x = 10;
if (x > 10) {
    console.log("xは10より大きい");
} else if (x < 10) {
    console.log("xは10より小さい");
} else {
    console.log("xは10");
}
```

### 繰り返し処理

繰り返し処理は、for文やwhile文を使用する

for文は、指定した回数だけ処理を繰り返す

```javascript
for (let i = 0; i < 10; i++) {
    console.log(i);
}
```

while文は、条件がtrueの間、処理を繰り返す

```javascript
while (条件) {
    処理
}
```

### 配列

配列は、複数のデータを格納するための箱のようなもの

```javascript
const fruits = ["apple", "banana", "orange"];
```

配列の要素には、インデックスを指定することでアクセスできる

```javascript
console.log(fruits[0]); // apple
```

配列の要素数は、lengthプロパティを使用することで確認できる
配列の要素数は、0から始まるため、length - 1が最後の要素のインデックスになる
配列の要素数を使用して、for文を使用することで、配列の要素を繰り返し処理することができる

```javascript
for (let i = 0; i < fruits.length; i++) {
    console.log(fruits[i]);
}
```


速成 JavaScript Part1

## HTML

HTML(HyperText Markup Language)はWebページの構造を記述するための言語

### HTMLの書き方

以下のように、開始タグと終了タグで囲むことで要素を記述する

```html
<!DOCTYPE html>
<html>
  <head>
      <title>タイトル</title>
  </head>
  <body>
      <h1>見出し1</h1>
      <p>段落</p>
  </body>
</html>
```

### HTMLの代表的な要素

- h1~h6: 見出し
- p: 段落
- a: リンク
- img: 画像
- ul: 箇条書きリスト
- ol: 番号付きリスト
- li: リストの要素
- table: テーブル
- tr: 行
- th: ヘッダー
- td: セル
- form: フォーム
- input: フォームの入力欄
- button: ボタン
- div: ブロック要素
- span: インライン要素
- br: 改行
- hr: 水平線
- meta: メタ情報
- link: CSSやファビコンの読み込み
- script: JavaScriptの読み込み
- style: CSSの記述
- head: ページの情報
- body: 表示されるコンテンツ
- html: HTMLのルート要素
- title: タイトル
- header: ヘッダー
- footer: フッター

### Metaタグについて

Metaタグはページの情報を記述するためのタグ
SEO対策では特に重要

Metaタグの代表的なものは以下の通り

- charset: 文字コード
- description: ページの説明
- keywords: キーワード
- viewport: ビューポート
- X-UA-Compatible: IEのバージョン
- robots: クローラーの動作
- author: 著者
- generator: 生成ツール
- format-detection: 電話番号のリンク
- theme-color: テーマカラー

#### Open Graph Protocolについて

Open Graph ProtocolはSNSでのシェア時に表示される情報を記述するためのプロトコル

以下のように記述することでSNSでのシェア時に表示される情報を設定できる

```html
<meta property="og:title" content="タイトル">
<meta property="og:description" content="説明">
<meta property="og:image" content="画像">
<meta property="og:url" content="URL">
<meta property="og:type" content="種類">
<meta property="og:site_name" content="サイト名">
<meta property="og:locale" content="言語">
<meta property="og:locale:alternate" content="言語(複数)">
<meta property="og:video" content="動画">
```

## CSS

CSS(Cascading Style Sheets)はWebページのデザインを記述するための言語

### CSSの書き方

pをセレクタ、colorをプロパティ、redを値という

```css
p {
    color: red;
}
```

各プロパティについては以下のMDNのReference`properties`を参照

- <https://developer.mozilla.org/ja/docs/Web/CSS>

### CSSの各場所

- インラインスタイル: HTMLのstyle属性に記述(本記事では記述量削減のため、この方法で記載する)
- ページスタイル: HTMLのheadタグ内のstyleタグに記述

```html
<!DOCTYPE html>
<html>
  <head>
      <style>
          p {
              color: red;
          }
      </style>
  </head>
  <body>
      <p style="color: red;">Hello, World!</p>
  </body>
</html>
```

- 外部ファイル: CSSファイルに記述

index.html

```html
<!DOCTYPE html>
<html>
  <head>
      <link rel="stylesheet" href="style.css">
  </head>
  <body>
      <p>Hello, World!</p>
  </body>
</html>
```

style.css(index.htmlと同じディレクトリに配置)

```css
p {
    color: red;
}
```

実務では外部ファイルに記述することが多い

### 代表的なプロパティ

代表的なプロパティは以下の通り

- color: 文字色
- background-color: 背景色
- font-size: フォントサイズ
- font-weight: フォントの太さ
- text-align: テキストの配置
- border: 枠線
- border-radius: 枠線の角の丸み
- width: 幅
- height: 高さ
- margin: 外側の余白
- padding: 内側の余白
- display: 要素の表示方法
- flex: 要素の並び方
- grid: 要素の配置方法
- media query: 画面サイズに応じたCSSの変更
- position: 要素の配置方法
- z-index: 要素の重なり順
- transition: アニメーション
- transform: 要素の変形
- filter: 要素のフィルター
- box-shadow: 要素の影
- text-shadow: テキストの影
- background-image: 背景画像
- background-size: 背景画像のサイズ
- background-position: 背景画像の位置
- background-repeat: 背景画像の繰り返し

### CSS要素の余白について

- margin: 要素の外側の余白
- padding: 要素の内側の余白
- border: マージンとパディングの間にある線

- margin,padding=0

```html
<div style="background-color: red;border: solid 3px black;width:100px;height:100px; margin:0;padding:0;">
    <div style="background-color: blue;border: solid 3px yellow;width:50px;height:50px; margin:0;padding:0;">
    </div>
</div>
```

- margin=10px
外側の余白が10pxになるになっているため、0の時より親要素の中央に寄っている

```html
<div style="background-color: red;border: solid 3px black;width:100px;height:100px; margin:0;padding:0;">
    <div style="background-color: blue;border: solid 3px yellow;width:50px;height:50px; margin:10px;padding:0;">
    </div>
</div>
```

- padding=10px

```html
<div style="background-color: red;border: solid 3px black;width:100px;height:100px; margin:0;padding:0;">
    <div style="background-color: blue;border: solid 3px yellow;width:50px;height:50px; margin:0;padding:10px;">
    </div>
</div>
```

### CSSのレイアウトについて

CSSのレイアウトはdisplayプロパティを利用することで実現できる

変化を見やすくするために以下を設定

```css
.child {
  width: 100px;
  height: 100px;
  background: linear-gradient(-45deg, #788cff, #b4c8ff);
}
```

#### display: block

要素に改行が入る
幅と高さが指定できる
代表的なタグ(div, p, h1, h2, h3, h4, h5, h6)

```html
<div id="example-element" style="display: block; border: solid 3px;">
    <div class="child">Child 1</div>
    <div class="child">Child 2</div>
    <div class="child">Child 3</div>
</div>
```

#### display: inline

要素に改行が入らない
幅と高さが指定できない
代表的なタグ(span, a, img)

```html
<div id="example-element1" style="display: block; border: solid 3px;">
    <span class="child">Child 1</span>
    <span class="child">Child 2</span>
    <span class="child">Child 3</span>
</div>
```

#### display: inline-block

要素に改行が入らない
幅と高さが指定できる

```html
<div id="example-element1" style="display: inline-block; border: solid 3px;">
    <span class="child">Child 1</span>
    <span class="child">Child 2</span>
    <span class="child">Child 3</span>
</div>
```

#### display: none

ブラウザ上に表示されない

```html
<div id="example-element2" style="display: none; border: solid 3px; border: solid 3px;">
    <div class="child">Child 1</div>
    <div class="child">Child 2</div> 
    <div class="child">Child 3</div>
</div>
```

#### display: flex

並列に要素を配置することができる
要素数が可変の際によく利用する

flexの詳細は以下のMDNのReferenceを参照

- <https://developer.mozilla.org/en-US/docs/Web/CSS/flex>

```html
<div id="example-element3" style="display: flex; border: solid 3px;">
    <div class="child">Child 1</div>
    <div class="child">Child 2</div>
    <div class="child">Child 3</div>
</div>
```

#### flexを親要素に持つ要素の中央寄せ

要素の中央寄せはjustify-content: centerを指定する

```html
<div id="example-element3" style="display: flex; border: solid 3px;justify-content: center;">
    <div class="child">Child 1</div>
    <div class="child">Child 2</div>
    <div class="child">Child 3</div>
</div>
```

#### flexを親要素に持つ要素を列方向の並び替え

列方向に並び替える場合はflex-direction: columnを指定する

```html
<div id="example-element3" style="display: flex; border: solid 3px;flex-direction: column;">
    <div class="child">Child 1</div>
    <div class="child">Child 2</div>
    <div class="child">Child 3</div>
</div>
```

#### display: grid

格子(grid)状に要素を配置することができる
要素数が固定の際によく利用する

gridの詳細は以下のMDNのReferenceを参照

- <https://developer.mozilla.org/en-US/docs/Web/CSS/grid>

単位frについては以下の記事を参照

- <https://kumonosublog.com/coding/css/gridlayoutfrauto/>

```html
<div class="wrapper" style="display: grid;
  grid-template-columns: 1fr 1fr 1fr; border: solid 3px;">
  <div class="child">One</div>
  <div class="child">Two</div>
  <div class="child">Three</div>
  <div class="child">Four</div>
  <div class="child">Five</div>
</div>
```

#### gridを親要素に持つ要素の中央寄せ

要素の中央寄せはjustify-items: centerを指定する

```html
<div class="wrapper" style="display: grid;
  grid-template-columns: 1fr 1fr 1fr; border: solid 3px; justify-items: center;">
  <div class="child">One</div>
  <div class="child">Two</div>
  <div class="child">Three</div>
  <div class="child">Four</div>
  <div class="child">Five</div>
</div>
```

#### gridを親要素に持つ要素を列方向の並び替え

列方向に並び替える場合は`grid-auto-flow: column;`を指定する

```html
<div class="wrapper" style="display: grid;
  grid-template-columns: 1fr 1fr 1fr; border: solid 3px; justify-items: center; grid-auto-flow: column;">
  <div>One</div>
  <div>Two</div>
  <div>Three</div>
  <div>Four</div>
  <div>Five</div>
</div>
```

### メディアクエリ

画面サイズに応じてCSSを変更することができる

メディアクエリの詳細は以下のMDNのReferenceを参照

- <https://developer.mozilla.org/ja/docs/Web/CSS/MediaQueries/Usingmediaqueries>

以下の例では画面サイズが600px以下の場合に背景色を変更している

- index.html

```html
<!DOCTYPE html>
<html>
  <head>
      <link rel="stylesheet" href="style.css">
  </head>
  <body>
      <p>Hello, World!</p>
  </body>
</html>
```

- style.css

```css
@media screen and (max-width: 600px) {
  body {
    background-color: lightblue;
  }
}
```

### アニメーション

アニメーションはtransitionプロパティを利用することで実現できる
また、keyframesを利用することでアニメーションの詳細を設定できる

アニメーションの詳細は以下のMDNのReferenceを参照

- <https://developer.mozilla.org/ja/docs/Web/CSS/CSS_Transitions/Using_CSS_transitions>

以下の例では、div要素を回転させるアニメーションを実装している

- index.html

```html
<!DOCTYPE html>
<html>
  <head>
      <link rel="stylesheet" href="style.css">
  </head>
  <body>
    <div class="child"></div>
  </body>
</html>
```

- style.css

```css
.child {
  width: 100px;
  height: 100px;
  background: linear-gradient(-45deg, #788cff, #b4c8ff);
  animation: rotate 2s linear infinite;
}

@keyframes rotate {
  from {
    transform: rotate(0deg);
  }
  to {
    transform: rotate(360deg);
  }
}
```



脱・人海戦術

Author

Ryo Arai

Jobs

AI Engineer

Full Stack Engineer

SNS

カテゴリ

タグ

PlayGround