## 対象読者

- 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が返る

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


脱・人海戦術

Author

Ryo Arai

Jobs

AI Engineer

Full Stack Engineer

SNS

カテゴリ

タグ

PlayGround