Ruby Miniature Book

  • 20
    いいね
  • 0
    コメント

Ruby の互換性を確認する資料を編集して豆本を作成しました。
まつもとゆきひろ直伝 組込Ruby「mruby」のすべて 総集編ほぼ互換性があることを目指しています
記載どおりで、基本的なところは互換性があります。
(この豆本は、Rubymruby の両方で利用することができます。)


コメント

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

バージョン

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

変数・定数

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

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

数値

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

文字列

"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: 非互換

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

ヒアドキュメント

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

シンボル

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

配列

[]                      # 空の配列
[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]     (%記法)

配列 (読み書き)

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]       (範囲指定)

ハッシュ

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

ハッシュ (シンボル)

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

正規表現

:warning: 非互換

/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)

if 条件1 [then]
  処理1 ...
[elsif 条件2 [then]
  処理2 ... ]
...
[else
  処理 ... ]
end
  • 条件1 が 真 なら 処理1 を実行
  • 条件2 が 真 なら 処理2 を実行
  • 条件n が 真 なら 処理n を実行
  • 全ての条件が 偽 なら else の 処理 を実行
処理 if 条件
  • 条件 が 真 なら 処理 を実行

条件分岐 (unless)

unless 条件1 [then]
  処理1 ...
...
[else
  処理2 ... ]
end
  • 条件1 が 偽 なら 処理1 を実行
  • 条件1 が 真 なら 処理2 を実行
処理 unless 条件
  • 条件 が 偽 なら 処理 を実行

条件分岐 (case)

case [比較対象]
[when 条件1 [, 条件2 ...] [then]
  処理1 ... ] ...
[else
  処理 ... ]
end
  • 条件1 が 真 なら 処理1 を実行
  • 条件n が 真 なら 処理n を実行
  • 全ての条件が 偽 なら else の 処理 を実行

繰り返し (while, until)

while 条件 [do]
  処理
end
  • 条件 が 真 なら 処理 を繰り返し実行
until 条件 [do]
  処理
end
  • 条件 が 偽 なら 処理 を繰り返し実行

繰り返し (each)

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

例外処理

begin
  処理
[rescue [例外クラス1 [, 例外クラス2 ...]] [=> 変数] [then]
  処理1] ...
[else
  処理2]
[ensure
  処理3]
end
  • begin の 処理 を実行した例外を捕捉
  • 例外クラス1 の例外が発生すれば 処理1 を実行
  • 例外クラスn の例外が発生すれば 実行n を実行
  • 例外が発生しなければ else の 処理2 を実行
  • begin 処理 を終了する直前に 処理3 を実行

raise は例外を発生させる


メソッド

def メソッド名 [引数1 [, 引数2 ...]]
  処理
[rescue [例外クラス1 [, 例外クラス2 ...]] [=> 変数] [then]
  処理1] ...
[else
  処理2]
[ensure
  処理3]
end
  • 引数=値 (引数を省略するとデフォルト値が使われる)
  • *引数 (残りの引数を配列として引数に格納する)
  • &引数 (ブロックとして引数に格納する)

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


クラス

class クラス名 [< 基底クラス名]
  [処理] ...
end
  • 基底クラスのサブクラスを作成

メソッド (private)

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

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

豆本の原稿なので情報量を極力抑えて表現しています。もっと知りたい方は、
たのしいRuby などご参照ください

enjoy ruby & mruby

この投稿は mruby Advent Calendar 20161日目の記事です。