Ruby チートシート

message = "こんにちは"
_internal_val = 10

class User
  def initialize(name)
    @name = name
  end
end

class Counter
  @@count = 0
  def initialize
    @@count += 1
  end
  def self.count
    @@count
  end
end

$program_status = "running"

PI = 3.14159
AppName = "MyApp"

[1, 2, 3, 4, 5].each do |n|
  break if n == 3
  puts n # 1, 2 が出力される
end
puts "ループ終了"

[1, 2, 3, 4, 5].each do |n|
  next if n.even? # 偶数はスキップ
  puts n # 1, 3, 5 が出力される
end

attempts = 0
data = [1, 2, 'stop', 3]
data.each do |item|
  begin
    puts "Processing: #{item}"
    raise "Error on stop" if item == 'stop' && attempts == 0
    attempts = 0 # 成功したらリセット
  rescue
    attempts += 1
    puts "Retry attempt: #{attempts}"
    redo # 同じ item で再試行
  end
end

s1 = "Hello"
s2 = " World"
puts s1 + s2      # "Hello World" (新しい文字列)
puts s1 << s2     # "Hello World" (s1自体を変更)
s1.concat("!")    # "Hello World!" (s1自体を変更)
name = "Ruby"
puts "Lang: #{name}" # "Lang: Ruby"

puts "Go! " * 3 # "Go! Go! Go! "

str = "abc"
puts str.length  # 3
puts "".empty?   # true

str = "abcdef"
puts str[0]    # "a"
puts str[1..3] # "bcd"
puts str[-1]   # "f"
puts str.slice(2, 3) # "cde"

text = "apple orange apple"
puts text.sub("apple", "banana") # "banana orange apple" (最初のみ)
puts text.gsub("apple", "banana") # "banana orange banana" (全て)
# `!` 付きは自身を変更

str = "Ruby Programming"
puts str.include?("Pro")   # true
puts str.index("gram")     # 8
puts str.start_with?("Ruby") # true
puts str.match?(/Pro(gram)+/) # true
puts str.scan(/\w+/) # ["Ruby", "Programming"]

csv = "a,b,c"
parts = csv.split(',') # ["a", "b", "c"]
puts parts.join('-')   # "a-b-c"

str = "hELLo WoRLd"
puts str.upcase    # "HELLO WORLD"
puts str.downcase  # "hello world"
puts str.capitalize # "Hello world"
puts str.swapcase  # "Hello wOrlD"

str = "  text  "
puts str.strip  # "text" (両端)
puts str.lstrip # "text  " (左端)
puts str.rstrip # "  text" (右端)

# UTF-8 から EUC-JP へ
# utf8_str = "こんにちは"
# euc_str = utf8_str.encode("EUC-JP")

query = <<SQL
SELECT *
FROM users
WHERE age > 20;
SQL

# <<- は終端識別子前のインデントを無視
message = <<-MSG
  This is a message.
  Indentation is kept.
  MSG

# <<~ は先頭のインデントと終端識別子前のインデントを無視
code = <<~CODE
      def example
        puts "Indented code"
      end
    CODE
# code は "def example\n  puts \"Indented code\"\nend" になる

arr1 = [1, 2, 3]
arr2 = Array.new(3, "a") # ["a", "a", "a"]
arr3 = %w[red green blue] # ["red", "green", "blue"] (文字列の配列)
arr4 = %i[x y z]        # [:x, :y, :z] (シンボルの配列)

arr = [:a, :b, :c, :d]
puts arr[0]      # :a
puts arr[-1]     # :d
puts arr[1..2]   # [:b, :c]
arr[1] = :B      # arr は [:a, :B, :c, :d]
puts arr.first   # :a
puts arr.last    # :d
puts arr.fetch(1) # :B
# puts arr.fetch(10) # エラー (IndexError)
puts arr.fetch(10, "default") # "default" (デフォルト値指定)

arr = [1, 2]
arr.push(3)    # [1, 2, 3] (末尾に追加)
arr << 4       # [1, 2, 3, 4] (同上)
arr.unshift(0) # [0, 1, 2, 3, 4] (先頭に追加)
arr.insert(2, 1.5) # [0, 1, 1.5, 2, 3, 4] (指定位置に追加)

arr = [0, 1, nil, 2, 1, nil]
puts arr.pop      # nil (末尾を削除して返す) arr は [0, 1, nil, 2, 1]
puts arr.shift    # 0 (先頭を削除して返す) arr は [1, nil, 2, 1]
arr.delete(1)     # arr は [nil, 2] (指定した値を全て削除)
arr.delete_at(0)  # arr は [2] (指定インデックスを削除)
arr = [1, nil, 2, nil]
arr.compact!      # arr は [1, 2] (nil要素を削除, `!`は自身を変更)
arr = [1, 2, 2, 3, 1]
arr.uniq!         # arr は [1, 2, 3] (重複要素を削除, `!`は自身を変更)

nums = [10, 20, 30]
nums.each { |n| puts n }
nums.reverse_each { |n| puts n } # 30, 20, 10
nums.each_with_index { |n, i| puts "#{i}: #{n}" }
# nums.cycle(2) { |n| puts n } # 10, 20, 30, 10, 20, 30

nums = [1, 2, 3, 4, 5]
squares = nums.map { |n| n * n }     # [1, 4, 9, 16, 25]
evens = nums.select { |n| n.even? } # [2, 4]
odds = nums.reject { |n| n.even? }  # [1, 3, 5]
first_even = nums.find { |n| n.even? } # 2
words = ["apple", "banana", "apricot"]
a_words = words.grep(/^a/) # ["apple", "apricot"] (正規表現にマッチ)

nums = [1, 2, 3, 4]
sum = nums.inject(0) { |result, n| result + n } # 10 (初期値0)
product = nums.inject(1) { |result, n| result * n } # 24 (初期値1)
# シンボルで演算子を指定も可能
sum_short = nums.inject(:+) # 10
product_short = nums.inject(:*) # 24

a1 = [1, 2]
a2 = [2, 3]
puts (a1 + a2).inspect    # [1, 2, 2, 3] (単純結合)
a1.concat(a2)             # a1 は [1, 2, 2, 3] (破壊的)
a1 = [1, 2]; a2 = [2, 3]
puts (a1 | a2).inspect    # [1, 2, 3] (和集合、重複削除)
puts (a1 & a2).inspect    # [2] (積集合)
puts ([1, 2, 3] - [2, 4]).inspect # [1, 3] (差集合)

arr = [3, 1, 4, 1, 5, 9]
puts arr.sort.inspect     # [1, 1, 3, 4, 5, 9]
arr.sort!                 # 自身をソート
words = ["banana", "apple", "cherry"]
puts words.sort_by { |w| w.length }.inspect # ["apple", "banana", "cherry"] (長さ順)
puts arr.reverse.inspect  # 元の配列の逆順 (ソートではない)

arr = ["a", "b", "c"]
puts arr.include?("b") # true
puts arr.index("c")    # 2
nums = [1, 2, 3, 4]
puts nums.any? { |n| n > 3 } # true (一つでも条件を満たすか)
puts nums.all? { |n| n > 0 } # true (全て条件を満たすか)
puts nums.none? { |n| n < 0 } # true (一つも条件を満たさないか)

nested = [1, [2, 3], [4, [5]]]
puts nested.flatten.inspect # [1, 2, 3, 4, 5] (一次元化)
chars = ["R", "u", "b", "y"]
puts chars.join         # "Ruby" (文字列に結合)
a = [1, 2]; b = [3, 4]
puts a.zip(b).inspect   # [[1, 3], [2, 4]] (対応する要素でペア配列作成)
matrix = [[1, 2], [3, 4], [5, 6]]
puts matrix.transpose.inspect # [[1, 3, 5], [2, 4, 6]] (行列転置)
puts [1,2,3,4,5].sample # ランダムに1要素取得
puts [1,2,3,4,5].sample(2).inspect # ランダムに2要素取得

h1 = { "key1" => "value1", :key2 => 2 }
h2 = { key1: "value1", key2: 2 } # Ruby 1.9以降のシンボルキー記法
h3 = Hash.new("default") # 存在しないキーアクセス時のデフォルト値

h = { name: "Alice", age: 30 }
puts h[:name]      # "Alice"
h[:city] = "Tokyo" # ハッシュに新しいキーと値を追加
puts h.fetch(:age) # 30
# puts h.fetch(:country) # エラー (KeyError)
puts h.fetch(:country, "Unknown") # "Unknown"
puts h.values_at(:name, :city).inspect # ["Alice", "Tokyo"]

h = { a: 1, b: 2 }
puts h.keys.inspect   # [:a, :b]
puts h.values.inspect # [1, 2]
puts h.to_a.inspect   # [[:a, 1], [:b, 2]] (キーと値のペアの配列)

h = { a: 10, b: 20, c: 30 }
h.delete(:b) # h は { a: 10, c: 30 }
h.delete_if { |key, value| value < 15 } # h は { c: 30 }
h = { a: 10, b: 20, c: 30 }
h.keep_if { |key, value| value > 15 } # h は { b: 20, c: 30 }

h = { name: "Bob", age: 25 }
h.each do |key, value|
  puts "#{key} is #{value}"
end
h.each_key { |key| puts "Key: #{key}" }
h.each_value { |value| puts "Value: #{value}" }

h = { a: 1, b: 2, c: 3 }
arr = h.map { |k, v| "#{k}-#{v}" } # ["a-1", "b-2", "c-3"]
selected = h.select { |k, v| v > 1 } # { b: 2, c: 3 }
rejected = h.reject { |k, v| k == :a } # { b: 2, c: 3 }
up_keys = h.transform_keys { |k| k.to_s.upcase } # { "A"=>1, "B"=>2, "C"=>3 }
val_sq = h.transform_values { |v| v * v } # { a: 1, b: 4, c: 9 }

h1 = { a: 1, b: 2 }
h2 = { b: 3, c: 4 }
merged = h1.merge(h2) # { a: 1, b: 3, c: 4 } (h2の値が優先)
# ブロックで衝突時の処理を定義可能
merged_block = h1.merge(h2) { |key, old_val, new_val| old_val + new_val }
# merged_block は { a: 1, b: 5, c: 4 }
h1.merge!(h2) # h1 が { a: 1, b: 3, c: 4 } になる (破壊的)

h = { x: 100, y: 200 }
puts h.key?(:x)     # true
puts h.value?(300)  # false
puts {}.empty?      # true
puts h.size         # 2

h = { a: 1, b: 2 }
puts h.invert.inspect # { 1=>:a, 2=>:b } (キーと値を反転)
data = { user: { address: { city: "Kyoto" } } }
puts data.dig(:user, :address, :city) # "Kyoto"
puts data.dig(:user, :name)           # nil (途中でキーがなくてもエラーにならない)

File.open("output.txt", "w") do |file|
  file.puts "これは最初の行です。"
  file.write "これは2行目です。(改行なし)"
  file.print "これも2行目。\n" # printは改行しない
end

File.open("output.txt", "a") do |file|
  file.puts "これは追記された行です。"
end

# 注意: 使い方によっては複雑になる
File.open("data.txt", "r+") do |file|
  content = file.read
  file.seek(0, IO::SEEK_SET) # ファイルポインタを先頭に移動
  file.write("Overwritten!\n" + content)
end

File.open("temp.txt", "w+") do |file|
  file.puts "Line 1"
  file.rewind # ポインタを先頭に戻す
  puts file.read # "Line 1\n" が出力される
end

File.open("log.txt", "a+") do |file|
  file.puts "New log entry at #{Time.now}"
  file.rewind
  puts "Current log content:\n#{file.read}"
end

puts File.exist?("my_file.txt")
puts Dir.exist?("/tmp")

puts File.size("my_file.txt") rescue 0
puts File.basename("/path/to/file.rb") # "file.rb"
puts File.dirname("/path/to/file.rb")  # "/path/to"
puts File.extname("/path/to/file.rb")  # ".rb"

# Dir.mkdir("new_dir") unless Dir.exist?("new_dir")
puts Dir.entries(".").inspect # カレントディレクトリの内容
puts Dir.glob("*.rb").inspect # カレントの .rb ファイル一覧
puts Dir.pwd # カレントディレクトリ表示

require 'fileutils'
# FileUtils.cp("source.txt", "destination.txt") # コピー
# FileUtils.mv("old_name.txt", "new_name.txt") # 移動/リネーム
# FileUtils.rm("temp.txt")                     # 削除 (ファイル)
# FileUtils.rm_r("dir_to_remove")              # 削除 (ディレクトリとその中身)
# FileUtils.mkdir_p("path/to/nested/dir")      # 再帰的にディレクトリ作成

status = :pending
puts status == :pending # true
config = { db_host: "localhost", db_port: 5432 }

numbers = 1..5   # 1, 2, 3, 4, 5
exclusive = 1...5 # 1, 2, 3, 4
puts numbers.include?(3) # true
puts exclusive.include?(5) # false
('a'..'d').each { |c| print c } # abcd

# Proc生成
my_proc = Proc.new { |x| puts "Proc: #{x}" }
my_lambda = lambda { |x| puts "Lambda: #{x}" }
stabby = ->(x) { puts "Stabby: #{x}" }

# 呼び出し
my_proc.call(10)
my_lambda.call(20)
stabby.(30) # .() でも呼び出せる

# lambdaは引数の数に厳密、Procは寛容
# my_lambda.call # エラー
# my_proc.call # エラーにならない (nil が渡される)

# & ブロック引数
def run_block(&block)
  puts "Running block..."
  block.call("from method") if block
end

run_block { |msg| puts "Block executed: #{msg}" }
run_block(&my_proc) # Procオブジェクトをブロックとして渡す

require 'date'

now = Time.now
puts "Time: #{now}"
puts "Year: #{now.year}"

today = Date.today
puts "Date: #{today}"
puts "Next day: #{today + 1}"

dt_now = DateTime.now
puts "DateTime: #{dt_now}"
puts "Hour: #{dt_now.hour}"

# 書式設定
puts now.strftime("%Y-%m-%d %H:%M:%S") # "2025-04-03 09:12:00" (例)

require 'set' # 標準ライブラリのSetクラスを使う
# require_relative 'my_module' # 同じディレクトリ内のmy_module.rbを読み込む

# load 'config.rb' # config.rbを読み込む (実行するたびに再読み込み)

# each メソッドにブロックを渡す
[1, 2, 3].each do |n|
  puts n * 10
end

# map メソッドにブロックを渡す (一行なので {} を使用)
squares = [1, 2, 3].map { |n| n**2 }
puts squares.inspect # [1, 4, 9]