7章まで

Author: na-trium-144

app/pagesList.ts

@@ -28,9 +28,9 @@ export const pagesList = [
       { id: 1, title: "rubyの世界へようこそ" },
       { id: 2, title: "基本構文とデータ型" },
       { id: 3, title: "制御構造とメソッド定義" },
-      { id: 4, title: "ブロックとイテレータ" },
-      { id: 5, title: "すべてがオブジェクト" },
-      { id: 6, title: "コレクション (Array, Hash, Range)" },
+      { id: 4, title: "すべてがオブジェクト" },
+      { id: 5, title: "コレクション (Array, Hash, Range)" },
+      { id: 6, title: "ブロックとイテレータ" },
       { id: 7, title: "クラスとオブジェクト" },
       { id: 8, title: "モジュールとMix-in" },
       { id: 9, title: "Proc, Lambda, クロージャ" },

app/terminal/runtime.tsx

@@ -102,6 +102,7 @@ export function langConstants(lang: RuntimeLang | AceLang): LangConstants {
         tabSize: 2,
         // TODO: 実際のirbのプロンプトは静的でなく、(main)や番号などの動的な表示がある
         prompt: "irb> ",
+        promptMore: "irb* ",
         returnPrefix: "=> ",
       };
     case "javascript":

public/docs/ruby-4.md

@@ -1,246 +1,180 @@
-# 第4章: ブロックとイテレータ - Rubyの最重要機能
+# 第4章: すべてがオブジェクト
 
-Rubyの学習において、**ブロック (Block)** は最も重要で強力な機能の一つです。他言語の経験者にとって、これはラムダ式や無名関数、クロージャに似た概念ですが、Rubyではこれが言語構文の核に深く組み込まれています。
+Rubyの設計思想における最も重要かつ強力なコンセプトの一つは、「すべてがオブジェクトである」という点です。他の言語、例えばJavaやC++では、数値（int, double）や真偽値（boolean）は「プリミティブ型」として扱われ、オブジェクトとは区別されます。
 
-この章では、ブロックの使い方と、ブロックを活用する「イテレータ」と呼ばれるメソッドを学びます。
+しかしRubyでは、`5` のような数値も、`"hello"` のような文字列も、そして `nil` さえも、すべてがメソッド（振る舞い）を持つオブジェクトです。
 
-## ブロック構文： do...end と {}
+## 🎯 Rubyの核心: 5.times の衝撃
 
-ブロックとは、メソッド呼び出しに渡すことができる**コードの塊**です。メソッド側は、受け取ったそのコードの塊を好きなタイミングで実行できます。
-
-ブロックには2種類の書き方があります。
-
-1.  **`{ ... }` (波括弧)**: 通常、1行で完結する場合に使われます。
-2.  **`do ... end`**: 複数行にわたる処理を書く場合に使われます。
-
-どちらも機能的にはほぼ同じです。最も簡単な例は、指定した回数だけブロックを実行する `times` メソッドです。
+他の言語の経験者がRubyに触れて最初に驚くことの一つが、以下のようなコードが動作することです。
 
 ```ruby-repl:1
-irb(main):001:0> 3.times { puts "Hello!" }
-Hello!
-Hello!
-Hello!
-=> 3
-
-irb(main):002:0> 3.times do
-irb(main):003:1* puts "Ruby is fun!"
-irb(main):004:1> end
-Ruby is fun!
-Ruby is fun!
-Ruby is fun!
-=> 3
+irb(main):001:0> 5.times do
+irb(main):002:1* print "Ruby! "
+irb(main):003:1> end
+Ruby! Ruby! Ruby! Ruby! Ruby! => 5
 ```
 
-`3.times` というメソッド呼び出しの後ろに `{ ... }` や `do ... end` で囲まれたコードブロックを渡しています。`times` メソッドは、そのブロックを3回実行します。
-
-## 代表的なイテレータ
-
-Rubyでは、コレクション（配列やハッシュなど）の各要素に対して処理を行うメソッドを**イテレータ (Iterator)** と呼びます。イテレータは通常、ブロックを受け取って動作します。
+`5` という数値リテラルが `.times` というメソッドを呼び出しています。これは、`5` が単なる値ではなく、`Integer` クラスのインスタンス（オブジェクト）だからです。
 
-代表的なイテレータを見ていきましょう。
-
-### each
-
-`each` は、コレクションの各要素を順番に取り出してブロックを実行します。他言語の `foreach` ループに最も近いものです。
-
-`|n|` の部分は**ブロック引数**と呼ばれ、イテレータが取り出した要素（この場合は配列の各要素）を受け取ります。
+同様に、文字列もオブジェクトです。
 
 ```ruby-repl:2
-irb(main):001:0> numbers = [1, 2, 3]
-=> [1, 2, 3]
-
-irb(main):002:0> numbers.each do |n|
-irb(main):003:1* puts "Current number is #{n}"
-irb(main):004:1> end
-Current number is 1
-Current number is 2
-Current number is 3
-=> [1, 2, 3]
+irb(main):001:0> "hello, world".upcase
+=> "HELLO, WORLD"
+irb(main):002:0> "hello, world".length
+=> 12
 ```
 
-> **Note:** `each` メソッドの戻り値は、元の配列 (`[1, 2, 3]`) 自身です。`each` はあくまで「繰り返すこと」が目的であり、ブロックの実行結果は利用しません。
-
-### map (collect)
+`"hello, world"` という `String` オブジェクトが、`upcase` や `length` というメソッド（メッセージ）に応答しています。
 
-`map` は、各要素に対してブロックを実行し、その**ブロックの戻り値**を集めた**新しい配列**を返します。
+`.class` メソッドを使うと、そのオブジェクトがどのクラスに属しているかを確認できます。
 
 ```ruby-repl:3
-irb(main):005:0> numbers = [1, 2, 3]
-=> [1, 2, 3]
-
-irb(main):006:0> doubled = numbers.map { |n| n * 2 }
-=> [2, 4, 6]
-
-irb(main):007:0> puts doubled.inspect
-[2, 4, 6]
-=> nil
-
-irb(main):008:0> puts numbers.inspect # 元の配列は変更されない
-[1, 2, 3]
-=> nil
+irb(main):001:0> 5.class
+=> Integer
+irb(main):002:0> "hello".class
+=> String
+irb(main):003:0> 3.14.class
+=> Float
 ```
 
-`map` は、元の配列を変換した新しい配列が欲しい場合に非常に便利です。
+## 👻 nil オブジェクト: 無ですらオブジェクト
 
-### select (filter)
+Rubyには「何もない」「無効」な状態を示す `nil` という特別な値があります。これは他の言語における `null` や `None` に相当します。
 
-`select` は、各要素に対してブロックを実行し、ブロックの戻り値が**真 (true)** になった要素だけを集めた**新しい配列**を返します。
+しかし、Rubyの哲学を徹底している点は、この `nil` ですらオブジェクトであるということです。
 
 ```ruby-repl:4
-irb(main):009:0> numbers = [1, 2, 3, 4, 5, 6]
-=> [1, 2, 3, 4, 5, 6]
-
-irb(main):010:0> evens = numbers.select { |n| n.even? } # n.even? は n % 2 == 0 と同じ
-=> [2, 4, 6]
+irb(main):001:0> nil.class
+=> NilClass
 ```
 
-### find (detect)
-
-`find` は、ブロックの戻り値が**真 (true)** になった**最初の要素**を返します。見つからなければ `nil` を返します。
+`nil` は `NilClass` という専用クラスの唯一のインスタンスです。オブジェクトであるため、`nil` もメソッドを持ちます。
 
 ```ruby-repl:5
-irb(main):011:0> numbers = [1, 2, 3, 4, 5, 6]
-=> [1, 2, 3, 4, 5, 6]
-
-irb(main):012:0> first_even = numbers.find { |n| n.even? }
-=> 2
-
-irb(main):013:0> over_10 = numbers.find { |n| n > 10 }
-=> nil
-```
-
-## for ループとの比較
-
-他言語経験者の方は、`for` ループを使いたくなるかもしれません。
-
-```c
-// C や Java の for ループ
-for (int i = 0; i < 3; i++) {
-    printf("Hello\n");
-}
+irb(main):001:0> nil.nil?
+=> true
+irb(main):002:0> "hello".nil?
+=> false
+irb(main):003:0> nil.to_s
+=> ""
+irb(main):004:0> nil.to_i
+=> 0
 ```
 
-Rubyにも `for` 構文は存在します。
+`nil` がメソッドを持つことで、`null` チェックに起因するエラー（例えば `null.someMethod()` のような呼び出しによるエラー）を避けやすくなり、より安全で流暢なコードが書ける場合があります。
 
-```ruby-repl:6
-irb(main):014:0> numbers = [1, 2, 3]
-=> [1, 2, 3]
-
-irb(main):015:0> for num in numbers
-irb(main):016:1* puts num
-irb(main):017:1> end
-1
-2
-3
-=> [1, 2, 3]
-```
+## 📨 メソッド呼び出しの仕組み: メッセージパッシング
 
-しかし、Rubyの世界では `for` ループは**ほとんど使われません**。なぜなら、`for` は内部的に `each` メソッドを呼び出しているに過ぎないからです。
+Rubyのメソッド呼び出し `オブジェクト.メソッド名(引数)` は、厳密には「**メッセージパッシング**」という概念に基づいています。
 
-Rubyプログラマは、`for` よりも `each` などのイテレータをブロックと共に使うことを圧倒的に好みます。イテレータの方が、何をしているか（単なる繰り返し、変換、選択など）がメソッド名 (`each`, `map`, `select`) から明確であり、コードが読みやすくなるためです。
+`5.times` というコードは、以下のように解釈されます。
 
-## ブロック引数とブロックの戻り値
+1.  レシーバ（受信者）: `5` という `Integer` オブジェクト
+2.  メッセージ: `:times` というシンボル（メソッド名）
+3.  `5` オブジェクトに `:times` というメッセージを送る。
+4.  `5` オブジェクト（の所属する `Integer` クラス）は、そのメッセージを解釈し、関連付けられた処理（ブロックを5回実行する）を実行する。
 
-すでに出てきたように、ブロックは `| ... |` を使って引数を受け取ることができます。
+この考え方は、オブジェクト指向の「カプセル化（オブジェクトが自身の振る舞いを決定する）」を強力にサポートします。`+` などの演算子でさえ、実際にはメソッド呼び出しのシンタックスシュガー（糖衣構文）です。
 
-```ruby-repl:7
-irb(main):018:0> ["Alice", "Bob"].each do |name|
-irb(main):019:1* puts "Hello, #{name}!"
-irb(main):020:1> end
-Hello, Alice!
-Hello, Bob!
-=> ["Alice", "Bob"]
+```ruby-repl:6
+irb(main):001:0> 10 + 3
+=> 13
+irb(main):002:0> 10.+(3) # 内部的にはこれと同じ
+=> 13
 ```
 
-また、ブロックも（Rubyのすべての式と同様に）戻り値を持ちます。ブロックの戻り値とは、**ブロック内で最後に評価された式の値**です。
-
-  * `each` はブロックの戻り値を**無視**します。
-  * `map` はブロックの戻り値を**集めて新しい配列**にします。
-  * `select` はブロックの戻り値が**真か偽か**を判定に使います。
-
-```ruby-repl:8
-irb(main):021:0> result = [1, 2].map do |n|
-irb(main):022:1* m = n * 10       # mは 10, 20
-irb(main):023:1* m + 5            # ブロックの戻り値 (15, 25)
-irb(main):024:1> end
-=> [15, 25]
-```
+## 🛠️ よく使う組み込みクラスのメソッド
 
-## yield：ブロックを受け取るメソッド
+すべてがオブジェクトであるため、Rubyは基本的なデータ型に対して非常に多くの便利なメソッドを標準で提供しています。
 
-では、どうすればブロックを受け取るメソッドを自分で作れるのでしょうか？
-それには `yield` というキーワードを使います。
+### String (文字列)
 
-メソッド内で `yield` が呼び出されると、そのメソッドに渡されたブロックが実行されます。
+`String` クラスには、テキスト操作のための豊富なメソッドが用意されています。
 
-```ruby:yield_basic.rb
-def simple_call
-  puts "メソッド開始"
-  yield # ここでブロックが実行される
-  puts "メソッド終了"
-end
+```ruby:string_methods.rb
+text = " ruby is convenient "
 
-simple_call do
-  puts "ブロック内の処理です"
-end
-```
+# 先頭と末尾の空白を除去
+cleaned_text = text.strip
+puts "Strip: '#{cleaned_text}'"
 
-```ruby-exec:yield_basic.rb
-メソッド開始
-ブロック内の処理です
-メソッド終了
-```
+# 先頭の文字を大文字に
+puts "Capitalize: #{cleaned_text.capitalize}"
 
-`yield` はブロックに引数を渡すこともできます。
+# "convenient" を "powerful" に置換
+puts "Gsub: #{cleaned_text.gsub("convenient", "powerful")}"
 
-```ruby:yield_with_args.rb
-def call_with_name(name)
-  puts "メソッド開始"
-  yield(name) # ブロックに "Alice" を渡す
-  yield("Bob") # ブロックに "Bob" を渡す
-  puts "メソッド終了"
-end
+# "ruby" という文字列で始まっているか？
+puts "Start with 'ruby'?: #{cleaned_text.start_with?("ruby")}"
 
-call_with_name("Alice") do |n|
-  puts "ブロックが #{n} を受け取りました"
-end
+# 単語に分割 (配列が返る)
+words = cleaned_text.split(" ")
+p words # p はデバッグ用の表示メソッド
 ```
 
-```ruby-exec:yield_with_args.rb
-メソッド開始
-ブロックが Alice を受け取りました
-ブロックが Bob を受け取りました
-メソッド終了
+```ruby-exec:string_methods.rb
+Strip: 'ruby is convenient'
+Capitalize: Ruby is convenient
+Gsub: ruby is powerful
+Start with 'ruby'?: true
+["ruby", "is", "convenient"]
 ```
 
-`each` や `map` のようなイテレータは、内部でこの `yield` を使って、コレクションの各要素をブロックに渡しながら実行しているのです。
-
-## この章のまとめ
+### Integer / Float (数値)
 
-  * **ブロック**は、メソッドに渡せるコードの塊で、`{}`（1行）または `do...end`（複数行）で記述します。
-  * **イテレータ**は、ブロックを受け取り、要素の繰り返し処理を行うメソッドです（`each`, `map`, `select` など）。
-  * Rubyでは `for` ループよりもイテレータが好まれます。
-  * ブロックは `|arg|` で引数を受け取ることができ、ブロックの最後の式の値が戻り値となります。
-  * 自作メソッド内で `yield` を使うと、渡されたブロックを実行できます。
+数値クラス (総称して `Numeric`) も便利なメソッドを持っています。
 
-### 練習問題1
-
-数値の配列 `[1, 2, 3, 4, 5]` があります。`map` イテレータとブロックを使って、各要素を文字列に変換し（例: `1` → `"1"`）、 `"1"`, `"2"`, `"3"`, `"4"`, `"5"` という文字列の配列を作成してください。
+```ruby-repl:7
+irb(main):001:0> # Integer
+irb(main):002:0> 10.even?
+=> true
+irb(main):003:0> 10.odd?
+=> false
+irb(main):004:0> 5.to_s
+=> "5"
+irb(main):005:0> 5.to_f
+=> 5.0
+
+irb(main):006:0> # Float
+irb(main):007:0> 10.5.round
+=> 11
+irb(main):008:0> 10.5.floor # 切り捨て
+=> 10
+irb(main):009:0> 10.5.ceil # 切り上げ
+=> 11
+irb(main):010:0> (10.5).to_i
+=> 10
+```
+
+## 📜 この章のまとめ
+
+  * Rubyでは、数値、文字列、`nil` を含むすべてが **オブジェクト** です。
+  * すべてのオブジェクトは **クラス** に属しています（例: `5` は `Integer` クラス）。
+  * オブジェクトであるため、すべての値は **メソッド** を持つことができます（例: `5.times`, `"hello".upcase`）。
+  * メソッド呼び出しは、オブジェクトへの **メッセージパッシング** として理解されます。
+  * `nil` も `NilClass` のオブジェクトであり、メソッドを持ちます。
+
+### 練習問題1: 文字列の操作
+変数 `sentence = " Welcome to the Ruby World! "` があります。`String` のメソッドを組み合わせて、最終的に `"WELCOME, RUBY"` という文字列をコンソールに出力してください。
+
+  * ヒント: `strip`, `upcase`, `gsub` (または `sub`), `slice` (またはインデックスアクセス `[]`) などが使えます。
 
 ```ruby:practice4_1.rb
-array = [1, 2, 3, 4, 5]
-
+sentence = " Welcome to the Ruby World! "
 ```
 
 ```ruby-exec:practice4_1.rb
 ```
 
-### 練習問題2
-文字列の配列 `["apple", "banana", "cherry", "date"]` があります。`select` イテレータとブロックを使って、文字数が5文字以上の果物だけを抽出した新しい配列（`["apple", "banana", "cherry"]`）を作成してください。
 
-```ruby:practice4_2.rb
-array = ["apple", "banana", "cherry", "date"]
+### 練習問題2: 数値と判定
 
+`Float` の値 `123.456` があります。この値を四捨五入して整数（`Integer`）にした後、その整数が偶数(even)か奇数(odd)かを判定して、`"Result is even"` または `"Result is odd"` と出力するコードを書いてください。
+
+```ruby:practice4_2.rb
+value = 123.456
 ```
 
 ```ruby-exec:practice4_2.rb