Ruby Miniature Book

[<img src=https://www.ruby-lang.org/images/header-ruby-logo.png width=20px> Ruby](https://www.ruby-lang.org/) と [<img src=https://mruby.org/images/mruby_header.png width=80px>](https://mruby.org/) の互換性を確認する資料を編集して豆本を作成しました。
[まつもとゆきひろ直伝 組込Ruby「mruby」のすべて 総集編](http://tatsu-zine.com/books/mruby) に *ほぼ互換性があることを目指しています* の
記載どおりで、基本的なところは互換性があります。
(この豆本は、`Ruby` と `mruby` の両方で利用することができます。)

----

## コメント

```ruby
# ← から行末までがコメント
```

----

## バージョン

```ruby
RUBY_VERSION            # => "2.3.1"
MRUBY_VERSION           # => "1.2.0" (mruby のみ)
```

----

## 変数・定数

```ruby
foo = 'foo'             # ローカル変数
@foo = 'foo'            # インスタンス変数
@@foo = 'foo'           # クラス変数
$foo = 'foo'            # グローバル変数
Foo = 'foo'             # 定数

name = 'Matz'           # (豆本の例で使う変数)
```

----

## 数値

```ruby
1                       # => 1      (整数)
0x30                    # => 48     (16進数)
0b1011                  # => 11     (2進数)
0755                    # => 493    (8進数)
10_000                  # => 10000  (_ は無視)
3.14                    # => 3.14   (浮動小数点)
314e-2                  # => 3.14
```

----

## 文字列

```ruby
"hello"                 # => "hello"
'hello'                 # => "hello"
"Hi, #{name}!"          # => "Hi, Matz!"      (式展開)
'Hi, #{name}!'          # => "Hi, \#{name}!"  (式展開しない)

%(Hi, #{name}!)         # => "Hi, Matz!"      (%記法)
%q(Let's play.)         # => "Let's play."
%Q(alt="Ruby")          # => "alt=\"Ruby\""
```

### コマンド出力

:warning: **非互換** <img src=https://mruby.org/images/mruby_header.png width=80px>

```ruby
`echo Hi!`              # => "Hi!\n"
%x(echo Hi!)            # => "Hi!\n"
```

----

## ヒアドキュメント

```ruby
<<"FOO"                 # => "Hi, Matz!\n"
Hi, #{name}!
FOO
```

----

## シンボル

```ruby
:foo                    # => :foo
"foo".to_sym            # => :foo
:"hello world"          # => :"hello world"
%s(hello world)         # => :"hello world" (%記法)
```

----

## 配列

```ruby
[]                      # 空の配列
[1, 2, 3]               # 3要素の配列
[1, [2, 3]]             # 配列の入れ子
[1, 2.0, "3rd"]         # 要素の型は自由

%w[foo bar baz]         # => ["foo", "bar", "baz"]  (%記法)
%W[foo bar #{name}]     # => ["foo", "bar", "Matz"] (%記法)
%i[foo bar baz]         # => [:foo, :bar, :baz]     (%記法)
```

----

## 配列 (読み書き)

```ruby
a = [:a, :b, :c, :d]
a[0]                    # => :a   (0 オリジン)
a[1]                    # => :b
a[4]                    # => nil  (範囲外は nil)
a[-1]                   # => :d   (後ろから数える)
a[-4]                   # => :a
a[-5]                   # => nil  (範囲外は nil)

a[1] = :B               # (書き込み)
a                       # => [:a, :B, :c, :d]
a[5] = :f               # (範囲外に書き込み)
a                       # => [:a, :B, :c, :d, nil, :f]

a[0, 2]                 # => [:a, :B]       (範囲指定)
a[0..2]                 # => [:a, :B, :c]   (範囲指定)
a[0...2]                # => [:a, :B]       (範囲指定)
```

----

## ハッシュ

```ruby
{}
h = {"foo"=>1, "bar" => 2}
h["foo"]                # => 1
h["bar"]                # => 2
h["baz"]                # => nil
h["baz"] = 3            # (書き込み)
h                       # => {"foo"=>1, "bar"=>2, "baz"=>3}
```

----

## ハッシュ (シンボル)

```ruby
h = {foo: 1, bar: 2}    # => {:foo=>1, :bar=>2} (シンボル記法)
h[:foo]                 # => 1
h["foo"]                # => nil
```

----

## 正規表現

:warning: **非互換** <img src=https://mruby.org/images/mruby_header.png width=80px>


```ruby
/ruby/io                # => /ruby/i
/#{name}/               # => /Matz/   (式展開)
%r(ruby)i               # => /ruby/i  (%記法)

/ruby/i =~ "Try Ruby!"  # => 4      (4文字目にマッチ)

/foo./ =~ "food"        # => 0      (先頭にマッチ)
/foo./ =~ "foo"         # => nil    (アンマッチ)
/foo./ !~ "bar"         # => true   (アンマッチ)

/no (\w+)/i =~ "No Ruby, No Life"
$1                      # => "Ruby"
```

----

## 条件分岐 (if)

```ruby
if 条件1 [then]
  処理1 ...
[elsif 条件2 [then]
  処理2 ... ]
...
[else
  処理 ... ]
end
```

* 条件1 が 真 なら 処理1 を実行
* 条件2 が 真 なら 処理2 を実行
* 条件n が 真 なら 処理n を実行
* 全ての条件が 偽 なら else の 処理 を実行

```ruby
処理 if 条件
```

* 条件 が 真 なら 処理 を実行

----

## 条件分岐 (unless)

```ruby
unless 条件1 [then]
  処理1 ...
...
[else
  処理2 ... ]
end
```

* 条件1 が 偽 なら 処理1 を実行
* 条件1 が 真 なら 処理2 を実行

```ruby
処理 unless 条件
```

* 条件 が 偽 なら 処理 を実行

----

## 条件分岐 (case)

```ruby
case [比較対象]
[when 条件1 [, 条件2 ...] [then]
  処理1 ... ] ...
[else
  処理 ... ]
end
```

* 条件1 が 真 なら 処理1 を実行
* 条件n が 真 なら 処理n を実行
* 全ての条件が 偽 なら else の 処理 を実行

----

## 繰り返し (while, until)

```ruby
while 条件 [do]
  処理
end
```

* 条件 が 真 なら 処理 を繰り返し実行

```ruby
until 条件 [do]
  処理
end
```

* 条件 が 偽 なら 処理 を繰り返し実行

----

## 繰り返し (each)

```ruby
[1, 2, 3].each do |n|
  print n
end                           # >> 123
[1, 2, 3].each { |n| print n} # >> 123
```

```ruby
3.times { |n| print n}        # >> 012
```

----

## 例外処理

```ruby
begin
  処理
[rescue [例外クラス1 [, 例外クラス2 ...]] [=> 変数] [then]
  処理1] ...
[else
  処理2]
[ensure
  処理3]
end
```

* begin の 処理 を実行した例外を捕捉
* 例外クラス1 の例外が発生すれば 処理1 を実行
* 例外クラスn の例外が発生すれば 実行n を実行
* 例外が発生しなければ else の 処理2 を実行
* begin 処理 を終了する直前に 処理3 を実行

> raise は例外を発生させる

----

## メソッド

```ruby
def メソッド名 [引数1 [, 引数2 ...]]
  処理
[rescue [例外クラス1 [, 例外クラス2 ...]] [=> 変数] [then]
  処理1] ...
[else
  処理2]
[ensure
  処理3]
end
```

* 引数=値 (引数を省略するとデフォルト値が使われる)
* *引数   (残りの引数を配列として引数に格納する)
* &引数   (ブロックとして引数に格納する)

> ブロックは call で実行させる

----

## クラス

```ruby
class クラス名 [< 基底クラス名]
  [処理] ...
end
```

* 基底クラスのサブクラスを作成

### メソッド (private)

```ruby
attr_accessor :foo  # @foo の読み取り・書き込みメソッド
attr_reader :bar    # @bar の読み取りメソッド
attr_writer :baz    # @baz の書き込みメソッド (bar=)

def initialize [引数1 [, 引数2 ...]]
  処理
end
```

----

豆本の原稿なので情報量を極力抑えて表現しています。もっと知りたい方は、
[たのしいRuby](http://tatsu-zine.com/books/tanoshii-ruby5) などご参照ください

*enjoy ruby & mruby*