初心者向け: 概要と特徴、学習順ガイド

Ruby（ルビー）は、まつもとゆきひろさん（Matz）が1995年に公開した日本生まれのプログラミング言語です。設計思想の中心にあるのは「プログラマの幸福」。書いていて楽しいと感じられる言語を目指して作られました。

Rubyはスクリプト言語に分類され、シンプルな文法と高い表現力を持ちます。Webアプリケーションフレームワーク「Ruby on Rails」の登場（2004年）によって世界中に広まり、特にWebバックエンド開発で広く使われています。

Rubyの誕生

Rubyはパールやリスプ、Smalltalkなど複数の言語に影響を受けて設計されました。「最小限の驚き（Principle of Least Surprise）」という原則のもと、プログラマが直感的に書けることを重視しています。

全てがオブジェクト

Rubyの大きな特徴は、数値や文字列を含む全ての値がオブジェクトであることです。他の言語では「プリミティブ型（原始型）」として特別扱いされる数値も、Rubyではメソッドを持つオブジェクトです。

42.times { puts "hello" }   # 数値にメソッドが呼べる
"hello".upcase              # => "HELLO"
-5.abs                      # => 5（絶対値）
3.14.ceil                   # => 4（切り上げ）

動的型付け

Rubyは動的型付け言語です。変数に型を宣言する必要がなく、実行時に型が決まります。同じ変数に数値と文字列を入れ替えることもできます。

name = "Yagami Iori"   # 型の宣言は不要
name = 20              # 数値を代入してもエラーにならない
name = [1, 2, 3]       # 配列を代入することも可能

手軽に書ける一方で、型に起因するバグが実行してみるまで分からないという面もあります。

メタプログラミング

Rubyはメタプログラミングに優れた言語です。メタプログラミングとは「プログラムがプログラムを書く（動的にコードを生成・変更する）」技術のことです。クラスを実行時に拡張したり、存在しないメソッドへの呼び出しを動的に処理したりできます。Ruby on Railsはこの機能を活用して構築されています。

特徴の比較

Rubyを使うと得られること

• シンプルで読みやすいコードが書きやすい
• 型宣言が不要なので、手軽にプロトタイプを作れる
• ブロックやイテレータで、配列操作などを簡潔に書ける
• Ruby on Railsとの相性が良く、Webアプリを素早く作れる
• 対話的実行環境（irb）で試しながら学習を進めやすい

Rubyを使うことで生じること

• 動的型付けのため、型の不一致によるバグが実行時まで検出されないことがある
• 同じことを複数の方法で書けるため、コードスタイルが人によって異なりやすい
• 実行速度はコンパイル言語（C / Java）と比べると遅い傾向がある
• マジック（暗黙の挙動）が多く、内部で何が起きているか分かりにくいことがある

Rubyはインタプリタ型言語です。コードをファイルに書いて 『ruby』 コマンドで実行するか、対話型の 『irb』 で1行ずつ試せます。コンパイルという事前変換の手順は不要です。

.rb ファイルを実行する

コードを 『.rb』 拡張子のファイルに保存し、『ruby』 コマンドで実行します。

sample_hello.rb

puts "Hello, Iori!"

ruby sample_hello.rb
Hello, Iori!

irb — 対話型実行環境

irb（Interactive Ruby）は、1行ずつRubyコードを入力して即座に結果を確認できる対話環境です。学習や動作確認に便利です。

irb
irb(main):001> 1 + 1
=> 2
irb(main):002> "hello".upcase
=> "HELLO"
irb(main):003> exit

『=>』 の右側が評価結果です。

.rbファイルの作成と実行の詳細は.rbファイルの作成と実行方法で解説しています。

Rubyの変数は、名前の先頭の記号で種類が決まります。

型宣言は不要です。代入した値によって型が決まります。

name    = "Kusanagi Kyo"   # 文字列（String）
age     = 20               # 整数（Integer）
height  = 1.80             # 浮動小数点数（Float）
active  = true             # 真偽値（TrueClass）
nothing = nil              # 値なし（NilClass）

変数の詳細はself / インスタンス変数 / クラス変数で解説しています。

Rubyの文字列はダブルクォート（『"』）とシングルクォート（『'』）の2種類で作れます。

name = "Terry Bogard"
greeting = "Hello, #{name}!"   # 式展開（ダブルクォートのみ）
no_expand = 'Hello, #{name}!'  # シングルクォートは式展開されない

puts greeting   # => Hello, Terry Bogard!
puts no_expand  # => Hello, #{name}!

『#{}』 の中にRubyの式を書くことで文字列に値を埋め込めます（式展開）。これはダブルクォートの文字列だけで有効です。

puts "hello".length         # => 5
puts "hello".upcase         # => HELLO
puts "HELLO".downcase       # => hello
puts "hello".include?("ll") # => true
puts "hello".reverse        # => olleh

文字列メソッドの詳細は、文字列.length / size、文字列.upcase / downcaseなどで解説しています。

配列（Array）

配列は順番のある値の集まりです。インデックスは0から始まります。

fighters = ["Yagami Iori", "Kusanagi Kyo", "Terry Bogard"]

puts fighters[0]        # => Yagami Iori
puts fighters[-1]       # => Terry Bogard（最後の要素）
puts fighters.length    # => 3
fighters.push("Shiranui Mai")   # 末尾に追加

ハッシュ（Hash）

ハッシュはキーと値のペアで管理するデータ構造です。他の言語では「辞書型」「マップ」とも呼ばれます。

fighter = {
  name: "Yagami Iori",
  age: 20,
  team: "None"
}

puts fighter[:name]   # => Yagami Iori
puts fighter[:age]    # => 20
fighter[:bgm] = "Arashi no Saxophone 5"   # キーを追加

ハッシュのキーにはシンボル（『:name』 のような値）がよく使われます。シンボルは文字列に似ていますが、同じ名前なら常に同一のオブジェクトを参照するため、ハッシュのキーに向いています。

配列の詳細はarray.push / pop / shift / unshiftで、ハッシュの詳細はhash.keys / values / has_key?で解説しています。

Rubyの大きな特徴のひとつがブロックです。ブロックとは、メソッドに渡せるコードのかたまりで、『do...end』 または 『{ }』 で書きます。

fighters = ["Yagami Iori", "Kusanagi Kyo", "Terry Bogard"]

fighters.each do |name|
  puts "Hello, #{name}!"
end

Hello, Yagami Iori!
Hello, Kusanagi Kyo!
Hello, Terry Bogard!

『each』 は配列の全要素に対してブロック内の処理を繰り返すメソッドです。『|name|』 はブロック変数で、各要素が順番に渡されます。

よく使うイテレータ

scores = [80, 55, 90, 70, 45]

# map: 全要素を変換した新しい配列を返す
doubled = scores.map { |s| s * 2 }
# => [160, 110, 180, 140, 90]

# select: 条件に合う要素だけを取り出す
passed = scores.select { |s| s >= 60 }
# => [80, 90, 70]

# reject: 条件に合う要素を除外する
failed = scores.reject { |s| s >= 60 }
# => [55, 45]

# reduce: 全要素を畳み込む（合計など）
total = scores.reduce(0) { |sum, s| sum + s }
# => 340

ブロックの詳細はブロック / yieldで、イテレータの詳細はarray.map / collectで解説しています。

Rubyではメソッドを 『def』 で定義します。戻り値は 『return』 を書かなくても、最後に評価された式が自動的に返されます。

def greet(name)
  "Hello, #{name}!"   # return を書かなくても返る
end

puts greet("Iori")    # => Hello, Iori!

デフォルト引数

def greet(name, greeting = "Hello")
  "#{greeting}, #{name}!"
end

puts greet("Kyo")          # => Hello, Kyo!
puts greet("Kyo", "Hey")   # => Hey, Kyo!

? と ! の慣習

Rubyでは、メソッド名に 『?』 や 『!』 を付ける慣習があります。

• 『?』 で終わるメソッド — 真偽値を返す（例: 『include?』, 『empty?』, 『nil?』）
• 『!』 で終わるメソッド — 破壊的な操作をする（例: 『sort!』, 『reverse!』, 『upcase!』）

names = ["Terry", "Iori", "Kyo"]

puts names.include?("Iori")   # => true
puts names.empty?             # => false

names.sort!                   # 元の配列を変更（!あり）
puts names.inspect            # => ["Iori", "Kyo", "Terry"]

Rubyではクラスを 『class』 で定義します。インスタンスを作るときは 『.new』 を使います。

class Fighter
  def initialize(name, team)
    @name = name   # インスタンス変数
    @team = team
  end

  def introduce
    "I am #{@name} from #{@team}."
  end
end

iori = Fighter.new("Yagami Iori", "Yagami Team")
puts iori.introduce
# => I am Yagami Iori from Yagami Team.

attr_accessor — ゲッターとセッターを自動生成

class Fighter
  attr_accessor :name, :team   # @name と @team の読み書きを自動生成

  def initialize(name, team)
    @name = name
    @team = team
  end
end

kyo = Fighter.new("Kusanagi Kyo", "Hero Team")
puts kyo.name       # => Kusanagi Kyo
kyo.name = "Kyo"    # 書き換え可能
puts kyo.name       # => Kyo

継承

class SNKFighter < Fighter   # Fighter を継承
  def initialize(name, team, bgm)
    super(name, team)        # 親クラスの initialize を呼ぶ
    @bgm = bgm
  end

  def introduce
    super + " BGM: #{@bgm}."
  end
end

terry = SNKFighter.new("Terry Bogard", "Fatal Fury Team", "Big Shot!")
puts terry.introduce
# => I am Terry Bogard from Fatal Fury Team. BGM: Big Shot!.

クラスの詳細はclass / initialize / attr_accessorで、継承の詳細は継承 / superで解説しています。

モジュールは、関連するメソッドや定数をひとまとめにする仕組みです。Rubyは多重継承をサポートしていませんが、モジュールを 『include』 することで複数のクラスに機能を追加できます（ミックスイン）。

module Greetable
  def greet
    "Hello, I am #{@name}."
  end
end

class Fighter
  include Greetable   # モジュールをミックスイン

  def initialize(name)
    @name = name
  end
end

ryo = Fighter.new("Ryo Sakazaki")
puts ryo.greet   # => Hello, I am Ryo Sakazaki.

モジュールの詳細はmodule / include / extendで解説しています。

Rubyの例外処理は 『begin / rescue / ensure』 で書きます。

begin
  result = 10 / 0   # ZeroDivisionError が発生
rescue ZeroDivisionError => e
  puts "Error: #{e.message}"
ensure
  puts "This runs no matter what"
end

Error: divided by 0
This runs no matter what

• 『begin』 — エラーが起こりうる処理を囲む
• 『rescue』 — エラーが発生したときの処理を書く
• 『ensure』 — エラーの有無にかかわらず必ず実行される

例外処理の詳細はbegin / rescue / ensureで、カスタム例外クラスは例外クラスで解説しています。

Rubyでのファイル読み書きは 『File』 クラスを使います。『File.open』 にブロックを渡すと、ブロックを抜けたときに自動でファイルが閉じられます。

# ファイルに書き込む
File.open("output.txt", "w") do |f|
  f.puts "Name: Yagami Iori"
  f.puts "Team: Yagami Team"
end

# ファイルを読み込む
File.open("output.txt", "r") do |f|
  f.each_line { |line| puts line }
end

Name: Yagami Iori
Team: Yagami Team

ファイル操作の詳細はFile.read / write / openで解説しています。

Rubyは正規表現を言語レベルでサポートしています。正規表現（regular expression）とは、文字列のパターンを表す記法です。『/パターン/』 と書きます。

text = "Hello, Iori! Hello, Kyo!"

# マッチ確認（=~ 演算子）
if text =~ /Iori/
  puts "Iori found!"
end

# scan: マッチした全ての文字列を配列で返す
matches = text.scan(/Hello, \w+!/)
puts matches.inspect
# => ["Hello, Iori!", "Hello, Kyo!"]

# gsub: 全ての一致箇所を置換
result = text.gsub(/Hello/, "Hi")
puts result
# => Hi, Iori! Hi, Kyo!

正規表現の詳細は正規表現 / matchで解説しています。

NoMethodError: undefined method 'xxx' for nil:NilClass

変数が 『nil』 の状態でメソッドを呼び出したときに発生します。変数が確実に値を持っているか確認します。

name = nil
puts name.upcase   # NoMethodError

name = nil
puts name.upcase if name   # nil のときは実行しない
puts name&.upcase          # &. （セーフナビゲーション演算子）でも回避できる

NameError: undefined local variable or method 'xxx'

定義されていない変数やメソッドを呼び出したときに発生します。スペルミスや変数のスコープ外での参照が原因であることが多いです。

def show_name
  name = "Iori"
end

puts name   # NameError — name はメソッド内のローカル変数

ArgumentError: wrong number of arguments

メソッドに渡した引数の数が定義と一致しないときに発生します。

def greet(name, greeting)
  "#{greeting}, #{name}!"
end

greet("Iori")   # ArgumentError: wrong number of arguments (1 for 2)

TypeError: no implicit conversion of Integer into String

文字列に数値を 『+』 で結合しようとすると発生します。『to_s』 で文字列に変換してから結合します。

age = 20
puts "Age: " + age          # TypeError
puts "Age: " + age.to_s     # OK: => Age: 20
puts "Age: #{age}"          # OK: 式展開を使う方がシンプル

SyntaxError: unexpected end-of-input

『def』, 『do』, 『class』, 『if』 などに対応する 『end』 が足りないときに発生します。インデントを整理してブロックの対応を確認します。

このページで全体像を把握したら、以下の順番でRuby辞典の各ページを読み進めると効率的に学べます。

Ruby = 楽しさを重視して設計された、全てがオブジェクトのスクリプト言語

実行の仕組み

• 『.rb』 ファイルに書いて 『ruby』 コマンドで実行（インタプリタ、コンパイル不要）
• irb（対話型実行環境）で1行ずつ確認しながら学習できる

変数

• 型宣言不要。代入した値によって型が決まる（動的型付け）
• 先頭の記号で種類が決まる（ローカル変数 / @インスタンス変数 / @@クラス変数 / $グローバル変数 / 大文字=定数）

Rubyらしい書き方

• ブロック（『do...end』 / 『{ }』）をメソッドに渡してイテレータを使う
• 『map』, 『select』, 『reduce』 などで配列操作を簡潔に書く
• 最後の式が自動的に戻り値になる（『return』 を省略できる）
• 『?』 で終わるメソッドは真偽値を返す慣習

オブジェクト指向

• 『class』 でクラスを定義、『def initialize』 でコンストラクタを書く
• 『attr_accessor』 でゲッター / セッターを自動生成できる
• 『class Child < Parent』 で継承、『super』 で親メソッドを呼ぶ
• 『module』 と 『include』 でミックスイン（多重継承の代替）

Rubyが向いている場面

• Ruby on Railsを使ったWebアプリケーション開発
• 手軽なスクリプトやファイル処理の自動化
• テストフレームワーク（RSpec）を使ったテスト駆動開発
• プロトタイプを素早く作って試す場面

Rubyが得意でない場面

• 高速な数値計算（C / Rust などのコンパイル言語が適している）
• 型の安全性を重視する大規模チーム開発（型注釈を追加するRBSという仕組みはあるが、TypeScriptほど一般的ではない）
• モバイルアプリ開発やシステムプログラミング