Help us understand the problem. What is going on with this article?

Ruby Miniature Book

More than 3 years have passed since last update.

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

Why do not you register as a user and use Qiita more conveniently?
  1. We will deliver articles that match you
    By following users and tags, you can catch up information on technical fields that you are interested in as a whole
  2. you can read useful information later efficiently
    By "stocking" the articles you like, you can search right away
Comments
Sign up for free and join this conversation.
If you already have a Qiita account
Why do not you register as a user and use Qiita more conveniently?
You need to log in to use this function. Qiita can be used more conveniently after logging in.
You seem to be reading articles frequently this month. Qiita can be used more conveniently after logging in.
  1. We will deliver articles that match you
    By following users and tags, you can catch up information on technical fields that you are interested in as a whole
  2. you can read useful information later efficiently
    By "stocking" the articles you like, you can search right away