---

【Ruby】JSONの読み込み・書き出し（パース・生成）をマスター！

データ交換フォーマットとして広く利用されているJSON（JavaScript Object Notation）。Web開発におけるAPI連携はもちろん、設定ファイルの記述やデータの保存など、様々な場面でそのシンプルさと柔軟性が活かされています。Rubyにおいても、JSONを扱うことは非常に一般的であり、標準ライブラリによって簡単にJSONデータをパースしたり、RubyのオブジェクトからJSONデータを生成したりすることができます。

この記事では、Rubyを使ってJSONを自在に操るための基本的な知識から、実践的な方法、さらにはエラー処理や知っておくと便利なテクニックまで、網羅的に解説していきます。約5000語の詳細な解説を通じて、あなたがRubyにおけるJSONの読み書きを完全にマスターできるよう、分かりやすく丁寧に進めていきます。

さあ、RubyとJSONの世界へ飛び込みましょう！

1. はじめに：JSONとは何か？なぜRubyでJSONを扱うのか？

まず、JSONとは何かについて簡単に振り返りましょう。JSONは軽量なデータ交換フォーマットです。人間にとって読み書きしやすく、コンピューターにとっても解析（パース）しやすいという特徴を持っています。元々はJavaScriptのオブジェクト表記法を基にしていますが、言語に依存しない形式であるため、多くのプログラミング言語で利用されています。

JSONは主に以下の2つの構造の組み合わせでデータを表現します。

1. オブジェクト (Object): キーと値のペアの集まりです。波括弧 {} で囲まれ、キーと値はコロン : で区切られ、ペアの間はカンマ , で区切られます。キーは文字列である必要があり、値はJSONのデータ型（文字列、数値、真偽値、null、オブジェクト、配列）のいずれかになります。RubyにおけるHashに相当します。
   例: {"name": "Alice", "age": 30}
2. 配列 (Array): 値の順序付けられたリストです。角括弧 [] で囲まれ、値の間はカンマ , で区切られます。配列の値もJSONのデータ型であれば何でも格納できます。RubyにおけるArrayに相当します。
   例: ["apple", "banana", "cherry"]

これらの基本構造と、以下のプリミティブな値の型を組み合わせて、複雑なデータを表現します。

• 文字列 (String): ダブルクォーテーション " で囲まれたUnicode文字列です。
• 数値 (Number): 整数または浮動小数点数です。
• 真偽値 (Boolean): true または false です。
• null: 値がないことを表します。Rubyの nil に相当します。

JSONは、特にWebアプリケーションの分野で広く利用されています。RESTful APIの多くは、クライアントとサーバー間のデータ交換にJSONを使用しています。これは、XMLのような他のデータ形式に比べてシンプルでパースが容易であるためです。

なぜRubyでJSONを扱う必要があるのでしょうか？

• Web APIとの連携: 外部サービス（Twitter API, Stripe API, 気象情報APIなど）からデータを取得する際、その多くがJSON形式でデータを提供しています。RubyでそれらのAPIを利用するには、受け取ったJSONデータをRubyのオブジェクトに変換（パース）する必要があります。
• 自作APIの構築: Ruby on Railsなどのフレームワークを使ってWebアプリケーションを開発する際、APIエンドポイントを作成し、JSON形式でデータを返すことがよくあります。この場合、RubyのオブジェクトをJSON形式の文字列に変換（生成）する必要があります。
• 設定ファイル: YAMLやINI形式の代わりに、設定ファイルをJSON形式で記述することもあります。
• データの保存: NoSQLデータベース（MongoDBなど）は内部的にJSONライクなドキュメント形式でデータを扱います。また、単純なデータ構造をファイルに保存しておきたい場合にもJSONは便利です。

このように、Rubyを使って開発を行う上で、JSONの読み込みと書き出しは避けて通れない重要なスキルと言えます。幸いなことに、Rubyには標準ライブラリとして json が用意されており、非常に簡単にJSONを扱うことができます。

この記事では、この json ライブラリを中心に解説を進めていきます。

2. RubyでJSONを扱う準備：require 'json'

RubyでJSONを扱うためには、まず標準ライブラリである json を読み込む必要があります。これは、スクリプトやアプリケーションの冒頭で require 'json' と記述することで行います。

“`ruby

Rubyのスクリプトファイル（例: main.rb）

JSONライブラリを読み込む

require ‘json’

これ以降、JSONライブラリの機能（JSON.parse, to_jsonなど）が使えるようになる

“`

require 'json' を忘れると、後述する JSON.parse や to_json メソッドが見つからないというエラー（NameError や NoMethodError）が発生します。

IRBやPryのような対話型シェルでJSONを試す場合も、同様に require 'json' を最初に実行する必要があります。

“`ruby
$ irb
irb(main):001:0> JSON.parse(‘{“key”: “value”}’)
Traceback (most recent call last):
…
NameError (uninitialized constant JSON) # require ‘json’ を忘れているためエラー

irb(main):002:0> require ‘json’
=> true # 読み込み成功

irb(main):003:0> JSON.parse(‘{“key”: “value”}’)
=> {“key”=>”value”} # 正常にパースできた
“`

このように、JSONライブラリの読み込みは、その機能を利用するための最初のステップです。

3. JSONの読み込み（パース）：JSON文字列をRubyオブジェクトへ

さて、RubyでJSONを扱うための準備ができたところで、まずはJSONの読み込み、すなわちパースについて見ていきましょう。パースとは、JSON形式の文字列を解析し、Rubyが理解できるデータ構造（主にHashやArray）に変換する処理のことです。

Rubyの json ライブラリでは、主に JSON.parse メソッドを使ってパースを行います。

3.1. 文字列からのパース (JSON.parse)

最も基本的な使い方は、JSON形式の文字列を JSON.parse メソッドに渡すことです。

“`ruby
require ‘json’

簡単なJSONオブジェクト文字列

json_string_object = ‘{“name”: “Alice”, “age”: 30, “isStudent”: false, “courses”: [“Math”, “Science”], “address”: null}’

JSON文字列をパースしてRubyのHashに変換

ruby_hash = JSON.parse(json_string_object)

変換されたRubyオブジェクトの型と内容を確認

puts “元のJSON文字列: #{json_string_object}”
puts “変換後のRubyオブジェクトの型: #{ruby_hash.class}”
puts “変換後のRubyオブジェクト: #{ruby_hash}”

Rubyオブジェクトとしてデータにアクセスできる

puts “名前: #{ruby_hash[‘name’]}”
puts “年齢: #{ruby_hash[‘age’]}”
puts “学生ですか？: #{ruby_hash[‘isStudent’]}”
puts “受講科目: #{ruby_hash[‘courses’].join(‘, ‘)}”
puts “住所: #{ruby_hash[‘address’].nil? ? ‘未設定’ : ruby_hash[‘address’]}”

puts “—“

簡単なJSON配列文字列

json_string_array = ‘[“apple”, “banana”, “cherry”]’

JSON文字列をパースしてRubyのArrayに変換

ruby_array = JSON.parse(json_string_array)

変換されたRubyオブジェクトの型と内容を確認

puts “元のJSON文字列: #{json_string_array}”
puts “変換後のRubyオブジェクトの型: #{ruby_array.class}”
puts “変換後のRubyオブジェクト: #{ruby_array}”

Rubyオブジェクトとしてデータにアクセスできる

puts “最初の要素: #{ruby_array[0]}”
“`

上記のコードを実行すると、以下のような出力が得られるはずです。

“`
元のJSON文字列: {“name”: “Alice”, “age”: 30, “isStudent”: false, “courses”: [“Math”, “Science”], “address”: null}
変換後のRubyオブジェクトの型: Hash
変換後のRubyオブジェクト: {“name”=>”Alice”, “age”=>30, “isStudent”=>false, “courses”=>[“Math”, “Science”], “address”=>nil}
名前: Alice
年齢: 30
学生ですか？: false
受講科目: Math, Science
住所: 未設定

---

元のJSON文字列: [“apple”, “banana”, “cherry”]
変換後のRubyオブジェクトの型: Array
変換後のRubyオブジェクト: [“apple”, “banana”, “cherry”]
最初の要素: apple
“`

JSON.parse は、JSONの構造に応じて適切なRubyのデータ型に変換してくれます。

• JSONオブジェクト {} は RubyのHash {} に
• JSON配列 [] は RubyのArray [] に
• JSON文字列 "" は RubyのString "" に
• JSON数値 は RubyのNumeric（IntegerまたはFloat）に
• JSON true は Rubyの true に
• JSON false は Rubyの false に
• JSON null は Rubyの nil に

変換されます。

ネストした構造のパース

JSONはオブジェクトや配列をネストさせることができます。JSON.parse は、そのようなネストした構造も正しくパースし、ネストしたHashやArrayを含むRubyオブジェクトに変換してくれます。

“`ruby
require ‘json’

ネストしたJSONオブジェクトを含む文字列

nested_json_string = <<-JSON
{
“user”: {
“id”: 123,
“name”: “Bob”,
“contact”: {
“email”: “[email protected]”,
“phone”: “090-1234-5678”
},
“roles”: [“admin”, “editor”]
},
“created_at”: “2023-10-27T10:00:00Z”
}
JSON

ヒアドキュメントを使って複数行のJSON文字列を定義

JSON文字列をパース

nested_ruby_hash = JSON.parse(nested_json_string)

変換されたRubyオブジェクトを確認

puts “元のJSON文字列:\n#{nested_json_string}”
puts “変換後のRubyオブジェクトの型: #{nested_ruby_hash.class}”
puts “変換後のRubyオブジェクト:\n#{nested_ruby_hash}”

ネストしたデータにアクセス

puts “ユーザーID: #{nested_ruby_hash[‘user’][‘id’]}”
puts “ユーザー名: #{nested_ruby_hash[‘user’][‘name’]}”
puts “ユーザーのメールアドレス: #{nested_ruby_hash[‘user’][‘contact’][‘email’]}”
puts “ユーザーの最初のロール: #{nested_ruby_hash[‘user’][‘roles’][0]}”
“`

実行結果：

元のJSON文字列:
{
"user": {
"id": 123,
"name": "Bob",
"contact": {
"email": "[email protected]",
"phone": "090-1234-5678"
},
"roles": ["admin", "editor"]
},
"created_at": "2023-10-27T10:00:00Z"
}
変換後のRubyオブジェクトの型: Hash
変換後のRubyオブジェクト:
{"user"=>{"id"=>123, "name"=>"Bob", "contact"=>{"email"=>"[email protected]", "phone"=>"090-1234-5678"}, "roles"=>["admin", "editor"]}, "created_at"=>"2023-10-27T10:00:00Z"}
ユーザーID: 123
ユーザー名: Bob
ユーザーのメールアドレス: [email protected]
ユーザーの最初のロール: admin

このように、ネストしたJSON構造は、RubyではネストしたHashやArrayとして表現され、通常のRubyオブジェクトと同じようにアクセスできます。

3.2. ファイルからのパース

JSONデータはファイルに保存されていることもよくあります。ファイルからJSONを読み込んでパースするには、まずファイルの内容を文字列として読み込み、それを JSON.parse に渡します。

“`ruby
require ‘json’

ダミーのJSONファイルを作成 (file.json)

File.write(‘data.json’, <<-JSON
{
“products”: [
{“id”: 1, “name”: “Laptop”, “price”: 1200.00},
{“id”: 2, “name”: “Keyboard”, “price”: 75.00},
{“id”: 3, “name”: “Mouse”, “price”: 25.50}
]
}
JSON
)

ファイルからJSON文字列を読み込む

begin
file_content = File.read(‘data.json’)

# 読み込んだJSON文字列をパース
data = JSON.parse(file_content)

puts “ファイルから読み込んだデータ:\n#{data}”
puts “最初の製品名: #{data[‘products’][0][‘name’]}”

rescue Errno::ENOENT
puts “エラー: ファイル ‘data.json’ が見つかりません。”
rescue JSON::ParserError => e
puts “エラー: JSON形式が不正です – #{e.message}”
rescue => e
puts “予期しないエラーが発生しました: #{e.message}”
ensure
# 使用したダミーファイルを削除
File.delete(‘data.json’) if File.exist?(‘data.json’)
end
“`

このコードでは、まず File.write でダミーのJSONファイルを作成しています。次に、File.read('data.json') でファイルの内容をすべて読み込み、それを JSON.parse に渡してパースしています。

ファイルからの読み込みでは、ファイルが存在しない場合（Errno::ENOENT）や、ファイルの内容が不正なJSON形式である場合（JSON::ParserError）などのエラーが発生する可能性があります。そのため、上記コードのように begin...rescue...end ブロックを使ってエラーハンドリングを行うことが推奨されます。

3.3. パース時のオプション：キーをシンボルに変換する

JSON.parse メソッドには、パースの挙動を制御するためのオプションを渡すことができます。最もよく使われるオプションの一つが、symbolize_names: true です。

デフォルトでは、JSONオブジェクトのキーはRubyのStringとしてパースされます。しかし、RubyではHashのキーとしてSymbolを使うことが多いため、StringキーをSymbolキーに変換したい場合があります。その際に symbolize_names: true オプションが役立ちます。

“`ruby
require ‘json’

json_string = ‘{“name”: “Alice”, “age”: 30}’

デフォルト（キーはString）

string_keyed_hash = JSON.parse(json_string)
puts “デフォルト (String キー): #{string_keyed_hash}”
puts “名前へのアクセス (String キー): #{string_keyed_hash[‘name’]}” # Stringでアクセスする必要がある

puts “—“

symbolize_names: true オプションを指定（キーはSymbol）

symbol_keyed_hash = JSON.parse(json_string, symbolize_names: true)
puts “symbolize_names: true (Symbol キー): #{symbol_keyed_hash}”
puts “名前へのアクセス (Symbol キー): #{symbol_keyed_hash[:name]}” # Symbolでアクセスできる
“`

実行結果：

“`
デフォルト (String キー): {“name”=>”Alice”, “age”=>30}
名前へのアクセス (String キー): Alice

---

symbolize_names: true (Symbol キー): {:name=>”Alice”, :age=>30}
名前へのアクセス (Symbol キー): Alice
“`

symbolize_names: true を指定すると、JSONオブジェクトのキー "name" や "age" が、RubyのSymbol :name や :age に変換されます。これにより、Rubyistにとってより自然な :key の形でデータにアクセスできるようになります。特にAPIから取得したJSONデータを扱う場合など、このオプションは非常に便利です。

その他のパースオプション（簡単に紹介）

JSON.parse には他にもいくつかのオプションがありますが、ここでは簡単に紹介するに留めます。必要に応じて公式ドキュメントを参照してください。

• allow_nan: JSON仕様ではNaN (Not a Number), Infinity, -Infinity は許可されていませんが、これを許可するかどうかを指定します。デフォルトは false で、許可しない場合は JSON::ParserError が発生します。
• create_additions: JSON.generate で追加された特別なクラス情報を利用して、パース時に元のRubyオブジェクトを復元するかどうかを指定します。デフォルトは false です。

3.4. エラー処理：不正なJSONデータへの対応

JSON.parse は、入力された文字列が有効なJSON形式でない場合、JSON::ParserError 例外を発生させます。JSONデータを外部から取得する場合など、不正な形式のデータが送られてくる可能性を考慮し、この例外を適切に処理することが重要です。

“`ruby
require ‘json’

不正なJSON文字列の例

invalid_json_string_1 = ‘{“name”: “Alice”, age: 30}’ # キーがダブルクォーテーションで囲まれていない
invalid_json_string_2 = ‘{“name”: “Bob”, “city”: “Tokyo”,}’ # 末尾に余分なカンマがある
invalid_json_string_3 = ‘This is not a JSON string.’ # 全くJSON形式ではない

json_strings_to_test = [
invalid_json_string_1,
invalid_json_string_2,
invalid_json_string_3,
‘{“valid”: true}’ # 有効なJSONもテスト
]

json_strings_to_test.each do |json_str|
puts “パースを試行: ‘#{json_str}'”
begin
# JSON文字列をパース
data = JSON.parse(json_str)
puts ” 成功: #{data.inspect}”
rescue JSON::ParserError => e
# JSON::ParserError が発生した場合の処理
puts ” エラー: JSON形式が不正です – #{e.message}”
rescue => e
# その他の予期しないエラー
puts ” 予期しないエラー: #{e.message} (#{e.class})”
end
puts “—”
end
“`

実行結果：

“`
パースを試行: ‘{“name”: “Alice”, age: 30}’
エラー: JSON形式が不正です – unexpected token at ‘ age: 30}’

---

パースを試行: ‘{“name”: “Bob”, “city”: “Tokyo”,}’
エラー: JSON形式が不正です – unexpected token at ‘}’

---

パースを試行: ‘This is not a JSON string.’
エラー: JSON形式が不正です – unexpected token at ‘This is not a JSON string.’

---

パースを試行: ‘{“valid”: true}’
成功: {“valid”=>true}

---

“`

このように、JSON::ParserError を捕捉することで、プログラムがクラッシュすることなく、不正なJSONデータに対して適切なエラーメッセージを表示したり、代替処理を行ったりすることができます。外部システムとの連携では、このエラーハンドリングが堅牢なアプリケーションを構築する上で非常に重要になります。

4. JSONの書き出し（生成）：RubyオブジェクトをJSON文字列へ

JSONの読み込みができたら、次は書き出し（生成）です。生成とは、RubyのHashやArrayなどのデータ構造を、JSON形式の文字列に変換する処理のことです。

Rubyの json ライブラリでは、主に to_json メソッドを使って生成を行います。

4.1. Rubyオブジェクトからの生成 (to_json)

to_json メソッドは、require 'json' することで、多くの標準Rubyオブジェクト（Hash, Array, String, Numeric, TrueClass, FalseClass, NilClassなど）に追加されます（これはRubyのオープンクラス機能を利用しています）。このメソッドを呼び出すことで、オブジェクト自身をJSON形式の文字列に変換することができます。

“`ruby
require ‘json’

RubyのHash

ruby_hash = {
‘name’ => ‘Charlie’,
‘age’ => 25,
‘is_employed’ => true,
‘skills’ => [‘Ruby’, ‘Python’, ‘JavaScript’],
‘address’ => nil
}

HashをJSON文字列に変換

json_string_from_hash = ruby_hash.to_json

puts “元のRuby Hash: #{ruby_hash.inspect}”
puts “変換後のJSON文字列: #{json_string_from_hash}”

puts “—“

RubyのArray

ruby_array = [‘Red’, 100, false]

ArrayをJSON文字列に変換

json_string_from_array = ruby_array.to_json

puts “元のRuby Array: #{ruby_array.inspect}”
puts “変換後のJSON文字列: #{json_string_from_array}”
“`

実行結果：

“`
元のRuby Hash: {“name”=>”Charlie”, “age”=>25, “is_employed”=>true, “skills”=>[“Ruby”, “Python”, “JavaScript”], “address”=>nil}
変換後のJSON文字列: {“name”:”Charlie”,”age”:25,”is_employed”:true,”skills”:[“Ruby”,”Python”,”JavaScript”],”address”:null}

---

元のRuby Array: [“Red”, 100, false]
変換後のJSON文字列: [“Red”,100,false]
“`

見ての通り、RubyのHashはJSONオブジェクトに、ArrayはJSON配列に変換されています。Rubyのデータ型はJSONのデータ型に以下のようにマッピングされます。

• RubyのHash {} は JSONオブジェクト {} に
• RubyのArray [] は JSON配列 [] に
• RubyのString "" は JSON文字列 "" に（必要に応じてエスケープされる）
• RubyのNumeric は JSON数値に
• Rubyの true は JSON true に
• Rubyの false は JSON false に
• Rubyの nil は JSON null に

変換されます。

ネストした構造の生成

パースの場合と同様に、ネストしたRubyのHashやArrayも to_json で正しくネストしたJSON構造に変換されます。

“`ruby
require ‘json’

ネストしたRubyのデータ構造

nested_ruby_data = {
user: {
id: 456,
name: ‘David’,
contact: {
email: ‘[email protected]’,
phone: ‘080-9876-5432’
},
roles: [‘user’]
},
status: ‘active’
}

注: HashのキーとしてSymbolを使っています。to_json は Symbol キーも String キーとして正しく扱います。

ネストしたRubyデータ構造をJSON文字列に変換

nested_json_string = nested_ruby_data.to_json

puts “元のネストしたRubyデータ:\n#{nested_ruby_data.inspect}”
puts “変換後のネストしたJSON文字列:\n#{nested_json_string}”
“`

実行結果：

元のネストしたRubyデータ:
{:user=>{:id=>456, :name=>"David", :contact=>{:email=>"[email protected]", :phone=>"080-9876-5432"}, :roles=>["user"]}, :status=>"active"}
変換後のネストしたJSON文字列:
{"user":{"id":456,"name":"David","contact":{"email":"[email protected]","phone":"080-9876-5432"},"roles":["user"]},"status":"active"}

SymbolキーはJSONではStringとして表現される点に注意してください。

4.2. ファイルへの書き出し

生成したJSON文字列をファイルに保存するには、to_json で得られた文字列を File.write などを使ってファイルに書き込みます。

“`ruby
require ‘json’

書き出すRubyデータ

data_to_write = {
‘company’ => ‘TechCorp’,
‘employees’ => [
{‘id’ => 101, ‘name’ => ‘Eve’, ‘department’ => ‘Engineering’},
{‘id’ => 102, ‘name’ => ‘Frank’, ‘department’ => ‘Marketing’}
]
}

RubyデータをJSON文字列に変換

json_string = data_to_write.to_json

ファイルに書き出すファイル名

file_name = ‘company_data.json’

begin
# ファイルにJSON文字列を書き込む
# File.write はファイルを開き、指定した内容を書き込み、自動的に閉じます。
# 既存のファイルは上書きされます。
File.write(file_name, json_string)
puts “データをファイル ‘#{file_name}’ に書き出しました。”

rescue IOError => e
puts “ファイル書き込みエラー: #{e.message}”
rescue => e
puts “予期しないエラーが発生しました: #{e.message}”
ensure
# 使用したダミーファイルを削除 (任意)
# File.delete(file_name) if File.exist?(file_name)
end

書き出したファイルの内容を確認 (任意)

if File.exist?(file_name)

puts “\nファイル内容:”

puts File.read(file_name)

end

“`

このコードは、RubyのHashをJSON文字列に変換し、それを company_data.json というファイルに書き込んでいます。ファイル操作にはエラーがつきものなので、ここでも begin...rescue...end によるエラーハンドリングを含めています。

4.3. JSONデータの整形（プリティプリント）

to_json メソッドで生成されるJSON文字列は、通常、コンパクトな形式になります。これはデータ転送量を抑えるには良いのですが、人間が読んで内容を確認するには見づらいことがあります。JSONデータを読みやすくするために、インデントや改行を入れて整形（プリティプリント）することができます。

json ライブラリには、整形されたJSONを生成するための JSON.pretty_generate メソッドが用意されています。また、to_json メソッドにオプションを渡すことでも整形可能です。

JSON.pretty_generate を使う

JSON.pretty_generate は、Rubyオブジェクトを引数に取り、整形されたJSON文字列を返します。

“`ruby
require ‘json’

整形したいRubyデータ

pretty_data = {
“book” => {
“title” => “The Lord of the Rings”,
“author” => “J.R.R. Tolkien”,
“year” => 1954,
“genres” => [“Fantasy”, “Adventure”],
“publisher” => {
“name” => “Allen & Unwin”,
“location” => “London”
}
}
}

標準の to_json (整形なし)

compact_json = pretty_data.to_json
puts “整形なし:\n#{compact_json}”

puts “\n—“

JSON.pretty_generate (整形あり)

pretty_json = JSON.pretty_generate(pretty_data)
puts “整形あり (JSON.pretty_generate):\n#{pretty_json}”
“`

実行結果：

“`
整形なし:
{“book”:{“title”:”The Lord of the Rings”,”author”:”J.R.R. Tolkien”,”year”:1954,”genres”:[“Fantasy”,”Adventure”],”publisher”:{“name”:”Allen & Unwin”,”location”:”London”}}}

---

整形あり (JSON.pretty_generate):
{
“book”: {
“title”: “The Lord of the Rings”,
“author”: “J.R.R. Tolkien”,
“year”: 1954,
“genres”: [
“Fantasy”,
“Adventure”
],
“publisher”: {
“name”: “Allen & Unwin”,
“location”: “London”
}
}
}
“`

JSON.pretty_generate を使うことで、インデントと改行が適切に挿入され、JSON構造が一目で分かりやすくなりました。

to_json メソッドでのオプション指定

to_json メソッドも、オプションを指定することで整形を行うことができます。これは JSON.generate のオプションをそのまま利用する形になります。JSON.pretty_generate は内部的に JSON.generate に整形用のオプションを渡して呼び出しています。

よく使われる整形関連のオプションは以下の通りです。

• indent: インデントに使用する文字列を指定します。デフォルトは " " (スペース2つ) ですが、"\t" (タブ) などに変更できます。
• space: キーと値の間のコロン : の後に挿入する文字列を指定します。デフォルトは "" です。通常は " " (スペース1つ) を指定して : のようにします。
• space_before: キーと値の間のコロン : の前に挿入する文字列を指定します。デフォルトは "" です。
• object_nl: JSONオブジェクト {} 内の各ペアの後に挿入する文字列を指定します。デフォルトは "" です。通常は "\n" (改行) を指定します。
• array_nl: JSON配列 [] 内の各要素の後に挿入する文字列を指定します。デフォルトは "" です。通常は "\n" (改行) を指定します。

これらのオプションを組み合わせることで、独自の整形ルールを適用できます。ただし、通常は JSON.pretty_generate のデフォルト設定で十分でしょう。

to_json メソッドで整形を行う例：

“`ruby
require ‘json’

整形したいRubyデータ

data_to_format = {
“user” => {
“id” => 789,
“name” => “Grace”
},
“items” => [“item1”, “item2”]
}

to_json にオプションを指定して整形

formatted_json = data_to_format.to_json(
indent: ” “, # インデントをスペース4つに
space: ” “, # キーと値の間にスペース1つ
object_nl: “\n”, # オブジェクトの要素ごとに改行
array_nl: “\n” # 配列の要素ごとに改行
)

puts “to_json オプションで整形:\n#{formatted_json}”
“`

実行結果（環境によって若干出力形式が異なる可能性はあります）：

to_json オプションで整形:
{
"user": {
"id": 789,
"name": "Grace"
},
"items": [
"item1",
"item2"
]
}

JSON.pretty_generate は、これらの整形オプションを適切なデフォルト値で設定して JSON.generate を呼び出す糖衣構文（シンタックスシュガー）のようなものです。特別な理由がない限り、手軽な JSON.pretty_generate を使うのが良いでしょう。

4.4. 生成時のオプション（簡単に紹介）

to_json メソッド（および JSON.generate, JSON.pretty_generate）にも、生成の挙動を制御する様々なオプションがあります。

• ascii_only: デフォルトは false です。true に設定すると、非ASCII文字（日本語など）を \uXXXX の形式でエスケープして出力します。古いシステムや特定の環境で文字化けを防ぐために使われることがあります。
• allow_nan: デフォルトは false です。Rubyの Float::NAN, Float::INFINITY, -Float::INFINITY をJSONの NaN, Infinity, -Infinity として出力することを許可します。JSON仕様上は非標準です。
• create_additions: デフォルトは false です。true に設定すると、カスタムクラスなどの情報を付加してJSONを生成し、パース時に元のオブジェクトを復元できるようにします（これにはカスタムクラス側の対応が必要です）。

例：ascii_only: true の使用

“`ruby
require ‘json’

data_with_japanese = { “message” => “こんにちは世界” }

デフォルト (非ASCII文字をそのまま出力)

puts data_with_japanese.to_json

ascii_only: true (非ASCII文字をエスケープ)

puts data_with_japanese.to_json(ascii_only: true)
“`

実行結果：

json
{"message":"こんにちは世界"}
{"message":"\u3053\u3093\u306b\u3061\u306f\u4e16\u754c"}

必要に応じてこれらのオプションを活用することで、より細かくJSON生成を制御できます。

5. 実践的なシナリオ

RubyにおけるJSONの読み込み・書き出しは、実際にはどのような場面で役立つのでしょうか？いくつかの典型的なシナリオを見てみましょう。

5.1. 外部Web APIからのデータ取得・送信

これは最も一般的なシナリオの一つです。RubyのHTTPクライアントライブラリ（Net::HTTP, OpenURI, HTTParty, Faraday など）を使ってWeb APIにリクエストを送り、レスポンスとしてJSONデータを受け取るケースです。

“`ruby
require ‘json’
require ‘net/http’ # 標準ライブラリのHTTPクライアント

例: ダミーAPIからユーザー情報を取得 (JSONPlaceholderという無料のダミーAPIを利用)

uri = URI(‘https://jsonplaceholder.typicode.com/users/1’) # ID=1のユーザーを取得するAPIエンドポイント

begin
response = Net::HTTP.get_response(uri)

if response.is_a?(Net::HTTPSuccess)
# レスポンスボディはJSON文字列
json_string = response.body

# JSON文字列をパース（キーをシンボルに変換）
user_data = JSON.parse(json_string, symbolize_names: true)

puts "取得したユーザー情報:"
puts "ID: #{user_data[:id]}"
puts "名前: #{user_data[:name]}"
puts "ユーザー名: #{user_data[:username]}"
puts "メールアドレス: #{user_data[:email]}"
puts "住所 (都市): #{user_data[:address][:city]}" # ネストしたデータにアクセス

else
puts “APIからの応答エラー: #{response.code} – #{response.message}”
end

rescue Net::HTTPError => e
puts “HTTP通信エラーが発生しました: #{e.message}”
rescue JSON::ParserError => e
puts “APIレスポンスのJSON形式が不正です: #{e.message}”
rescue => e
puts “予期しないエラーが発生しました: #{e.message} (#{e.class})”
end
“`

この例では、Net::HTTP を使って指定したURIからデータを取得し、得られたレスポンスボディ（JSON形式の文字列）を JSON.parse でRubyのHashに変換しています。symbolize_names: true オプションを使ってキーをSymbolに変換し、扱いやすくしています。APIからの応答が成功したかどうかの確認や、通信エラー、JSONパースエラーに対するエラーハンドリングも含まれています。

APIにデータを送信する場合も同様です。RubyのHashなどで送信したいデータを作成し、それを to_json でJSON文字列に変換し、リクエストボディとして含めます。

“`ruby
require ‘json’
require ‘net/http’

例: ダミーAPIに新しい投稿を送信

uri = URI(‘https://jsonplaceholder.typicode.com/posts’)

送信するデータ (RubyのHash)

new_post_data = {
title: ‘My New Post’,
body: ‘This is the content of my new post.’,
userId: 1
}

データをJSON文字列に変換

json_payload = new_post_data.to_json

POSTリクエストを準備

http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true # HTTPSの場合

request = Net::HTTP::Post.new(uri.path, {‘Content-Type’ => ‘application/json’})
request.body = json_payload

begin
# リクエストを送信し、レスポンスを受け取る
response = http.request(request)

puts “レスポンスコード: #{response.code}”
puts “レスポンスボディ:\n#{response.body}”

if response.is_a?(Net::HTTPSuccess) || response.is_a?(Net::HTTPCreated) # 成功または作成済み
# 成功レスポンスのボディもJSONであることが多いのでパース
created_post_data = JSON.parse(response.body, symbolize_names: true)
puts “作成された投稿のID: #{created_post_data[:id]}”
end

rescue Net::HTTPError => e
puts “HTTP通信エラーが発生しました: #{e.message}”
rescue JSON::ParserError => e
puts “APIレスポンスのJSON形式が不正です: #{e.message}”
rescue => e
puts “予期しないエラーが発生しました: #{e.message} (#{e.class})”
end
“`

この例では、新しい投稿データを含むRubyのHashを作成し、それを to_json でJSON文字列に変換しています。このJSON文字列をPOSTリクエストのボディとして設定し、Content-Type ヘッダーを application/json に指定して送信しています。APIからのレスポンスもJSON形式で返ってくることが多いため、受け取ったボディを再度パースしています。

5.2. 設定ファイルの読み書き

アプリケーションの設定値をJSONファイルに保存し、起動時に読み込むという使い方もあります。

“`ruby
require ‘json’

設定ファイルのパス

config_file = ‘config.json’

デフォルト設定

default_config = {
“database” => {
“host” => “localhost”,
“port” => 5432,
“username” => “admin”
},
“logging” => {
“level” => “info”,
“file” => “/var/log/app.log”
}
}

設定ファイルを読み込む関数

def load_config(file_path)
unless File.exist?(file_path)
puts “#{file_path} が存在しません。デフォルト設定を使用します。”
return default_config # デフォルト設定を返す (関数外の default_config を参照)
end

begin
file_content = File.read(file_path)
# キーをシンボルで扱いたい場合は symbolize_names: true を指定
config = JSON.parse(file_content, symbolize_names: true)
puts “#{file_path} から設定を読み込みました。”
return config
rescue JSON::ParserError => e
puts “エラー: 設定ファイル ‘#{file_path}’ のJSON形式が不正です – #{e.message}”
puts “デフォルト設定を使用します。”
return default_config
rescue => e
puts “予期しないエラーが発生しました: #{e.message} (#{e.class})”
puts “デフォルト設定を使用します。”
return default_config
end
end

設定ファイルを書き出す関数 (任意)

def save_config(file_path, config_data)
begin
# 整形して書き出す
json_string = JSON.pretty_generate(config_data)
File.write(file_path, json_string)
puts “設定をファイル ‘#{file_path}’ に書き出しました。”
rescue IOError => e
puts “エラー: 設定ファイルの書き込みに失敗しました – #{e.message}”
rescue => e
puts “予期しないエラーが発生しました: #{e.message} (#{e.class})”
end
end

— 実行例 —

(初回実行時など) 設定ファイルが存在しない場合をシミュレート

File.delete(config_file) if File.exist?(config_file)

設定を読み込む

app_config = load_config(config_file)

puts “\n現在の設定:”
puts app_config.inspect

読み込んだ設定を利用する例

puts “\nデータベースホスト: #{app_config[:database][:host]}”
puts “ログレベル: #{app_config[:logging][:level]}”

設定を更新して保存する例 (もし config_file が存在しない場合は新規作成)

app_config[:logging][:level] = “debug”

save_config(config_file, app_config)

再度読み込んで確認 (任意)

puts “\n— 更新後の設定の再読み込み —“

updated_app_config = load_config(config_file)

puts updated_app_config.inspect

puts “ログレベル: #{updated_app_config[:logging][:level]}”

“`

この例では、load_config 関数が指定されたJSONファイルを読み込み、パースしてRubyのHashとして返します。ファイルが存在しない場合や、パースエラーが発生した場合は、デフォルト設定を返すようにフォールバック処理を加えています。必要であれば、変更された設定をファイルに書き戻す save_config 関数の例も示しています。設定ファイルには人間が読み書きすることも想定されるため、JSON.pretty_generate を使って整形して保存することが一般的です。

5.3. データのシリアライズとデシリアライズ

シリアライズとは、プログラム内で扱っているオブジェクトの状態を、ファイル保存やネットワーク転送が可能な形式（例えばJSON文字列）に変換することです。デシリアライズはその逆で、シリアライズされたデータから元のオブジェクトを復元することです。JSONは、RubyのHashやArray、基本データ型といったシンプルな構造をシリアライズするのに非常に適しています。

“`ruby
require ‘json’

保存したいデータ

my_data = {
‘user_id’ => 999,
‘preferences’ => {
‘theme’ => ‘dark’,
‘language’ => ‘en’
},
‘last_login’ => Time.now # Timeオブジェクト
}

puts “元のデータ:”
puts my_data.inspect
puts “last_login の型: #{my_data[‘last_login’].class}”

puts “\n— シリアライズ —“

JSONにシリアライズ

Timeオブジェクトは to_json によって適切な文字列形式（ISO 8601形式など）に変換されます

json_serialized_data = my_data.to_json
puts “シリアライズされたJSON文字列:\n#{json_serialized_data}”

puts “\n— デシリアライズ —“

JSONからデシリアライズ

ruby_deserialized_data = JSON.parse(json_serialized_data)

puts “デシリアライズされたデータ:”
puts ruby_deserialized_data.inspect

デシリアライズされたデータでは、元の Time オブジェクトは String に戻っています

puts “last_login の型: #{ruby_deserialized_data[‘last_login’].class}”

Note: JSONの標準機能だけでは、Rubyのカスタムクラスのインスタンスや

特定のクラス（Time, Dateなど）を元のオブジェクトとして完全に復元することはできません。

基本的なHash/Array/プリミティブ型に変換されます。

“`

この例では、RubyのHashを to_json でシリアライズし、それを JSON.parse でデシリアライズしています。Time.now のようなRuby固有のオブジェクトも、json ライブラリが対応していればJSONで表現可能な形（この場合は文字列）に自動的に変換してくれます。ただし、標準の JSON.parse は変換された文字列を再度 Time オブジェクトに戻すような特別な処理は行わないため、デシリアライズ後は単なる文字列になっています。

より高度なシリアライズ/デシリアライズが必要な場合は、カスタムクラスでの as_json や json_create の実装、あるいは他のシリアライゼーションライブラリの検討が必要になります。

6. 高度なトピック（軽く触れる程度）

6.1. カスタムクラスのシリアライズ/デシリアライズ

独自のRubyクラスのインスタンスをJSONに変換したり、JSONからカスタムクラスのインスタンスを復元したりしたい場合があります。

JSONライブラリは、特定のメソッドを実装することでカスタムクラスのシリアライズ/デシリアライズをサポートしています。

• シリアライズ: クラスに to_json メソッドを実装するか、または as_json メソッドを実装し、to_json がそれを呼び出すようにする方法があります。as_json は、自身をJSONで表現可能なRubyオブジェクト（HashやArrayなど）に変換することを目的とします。
• デシリアライズ: クラスメソッドとして json_create(data) を実装します。JSON.parse に create_additions: true オプションを指定すると、JSONデータ中に含まれるクラス情報（json_class キーなどで示される）を基に、対応するクラスの json_create メソッドが呼び出され、オブジェクトを復元します。

簡単な例（create_additions を使わない as_json の例）：

“`ruby
require ‘json’

class Person
attr_accessor :name, :age

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

# to_json が内部的に呼び出す as_json を実装
# このメソッドは、このオブジェクトをJSONで表現可能なHashやArrayなどに変換して返す
def as_json(options = {})
{
name: @name,
age: @age
}
end

# オブジェクトで to_json メソッドを使えるようにするための定義
# これは require ‘json’ によって多くのクラスに自動的に追加されますが、
# カスタムクラスの場合は as_json を呼び出すように定義することが一般的です。
def to_json(options = {})
as_json(options).to_json(options)
end
end

Personクラスのインスタンスを作成

person = Person.new(“Fern”, 28)

puts “元のオブジェクト: #{person.inspect}”

to_json を使ってJSON文字列に変換

person_json = person.to_json
puts “JSON文字列: #{person_json}”

JSON文字列をパース

parsed_data = JSON.parse(person_json, symbolize_names: true)

puts “パースされたデータ: #{parsed_data.inspect}”

注: パースされたデータは単なるHashであり、Personクラスのインスタンスではない

puts “パースされたデータの型: #{parsed_data.class}”
“`

この例では as_json を実装することで、to_json が Person インスタンスをJSONで表現可能なHashに変換できるようになりました。パース時には create_additions: true を使っていないため、復元されるのは単なるHashです。create_additions: true を使った復元は少し複雑になるため、ここでは割愛しますが、必要であれば json ライブラリのドキュメントを参照してください。

6.2. ストリームパース

非常に大きなJSONファイルを扱う場合、ファイル全体を一度にメモリに読み込んでから JSON.parse すると、メモリ不足になる可能性があります。このような場合は、ストリームパース（インクリメンタルパースとも呼ばれる）が有効です。ストリームパースは、JSONデータを少しずつ読み込みながら解析を進めるため、必要なメモリ量を抑えることができます。

json ライブラリには、JSON::StreamParser というクラスが用意されています。これを使うと、ファイルやネットワークストリームからJSONデータを逐次読み込んでイベントドリブンに処理することができます。

“`ruby
require ‘json’

大きなJSONファイルをシミュレートするためのダミーデータを作成

large_data = {
“items” => (1..10000).map { |i| { “id” => i, “name” => “Item #{i}”, “value” => rand(1000) } }
}
large_json_string = large_data.to_json
File.write(‘large_data.json’, large_json_string)
puts “ダミーの大きなJSONファイル ‘large_data.json’ を作成しました。”

ストリームパースの例 (簡単に)

ファイルを読み込みモードで開く

file = File.open(‘large_data.json’, ‘r’)

StreamParserを初期化

parser = JSON::StreamParser.new

各種イベント発生時に実行されるコールバックを設定 (例: キーが見つかったら出力)

parser.indifferent_access = true # キーをシンボルでも文字列でもアクセス可能にする (parseの symbolize_names: true に近い機能)
parser.on_key {|key| puts “キーが見つかりました: #{key}”}
parser.on_value {|value| puts “値が見つかりました: #{value}”}
parser.on_object_start { puts “オブジェクト開始 {}” }
parser.on_object_end { puts “オブジェクト終了 {}” }
parser.on_array_start { puts “配列開始 []” }
parser.on_array_end { puts “配列終了 []” }
parser.on_parse_error {|e| puts “パースエラー: #{e.message}” }

puts “\n— ストリームパース開始 —“

ファイルからデータを少しずつ読み込み、パーサーに供給

buffer_size = 4096 # 読み込むバッファサイズ
while chunk = file.read(buffer_size)
parser << chunk # パーサーにデータを供給
end

puts “\n— ストリームパース終了 —“

file.close
File.delete(‘large_data.json’) if File.exist?(‘large_data.json’)
“`

この例は非常に簡略化されていますが、JSON::StreamParser を使うと、JSON構造の各要素（キー、値、オブジェクトの開始/終了、配列の開始/終了など）が検出されるたびに、定義しておいたブロック（コールバック）が実行されます。これにより、メモリにすべてのデータを保持することなく、部分的にデータを処理していくことが可能になります。実際のアプリケーションでは、これらのイベントを使って必要なデータを抽出したり集計したりするロジックを実装します。

6.3. 他のJSONライブラリ

Rubyの標準 json ライブラリは非常に便利で、ほとんどの用途には十分です。しかし、大量のJSONデータを高速に処理する必要がある場合など、パフォーマンスが要求される場面では、他のJSONライブラリの利用を検討することがあります。

代表的なものに以下のライブラリがあります。

• Oj (Optimized JSON): C言語で実装されており、非常に高速なパースと生成を提供します。多くの機能があり、標準の json ライブラリとの互換モードも持っています。
• Yajl (Yet Another JSON Library): これもC言語で実装された高速なライブラリです。ストリームパース機能も提供しています。

これらのライブラリは標準ライブラリではないため、gem install でインストールする必要がありますが、パフォーマンスがボトルネックになっている場合は検討する価値があります。ただし、通常の使用では標準ライブラリで十分であり、依存関係が増えることによる複雑化を避けるため、特別な理由がない限り標準ライブラリを使用するのが推奨されます。

7. トラブルシューティング：よくある問題と解決策

JSONの読み書きを行っていると、いくつかの一般的な問題に遭遇することがあります。ここでは、それらの問題と解決策を紹介します。

7.1. NameError: uninitialized constant JSON または NoMethodError: undefined method 'parse' for JSON:Module

原因: require 'json' を忘れています。
解決策: スクリプトまたは対話型セッションの最初に require 'json' を追加してください。

“`ruby

誤り

data = JSON.parse(‘{}’) # require がない

正しい

require ‘json’
data = JSON.parse(‘{}’)
“`

7.2. NoMethodError: undefined method 'to_json' for #<SomeObject:...>

原因:
1. require 'json' を忘れているため、標準クラスに to_json メソッドが追加されていない。
2. to_json を呼び出しているオブジェクトが、json ライブラリがデフォルトで対応していないカスタムクラスのインスタンスである。
解決策:
1. require 'json' を追加してください。
2. カスタムクラスの場合は、そのクラスに as_json または to_json メソッドを適切に実装する必要があります（前述の「カスタムクラスのシリアライズ」を参照）。

“`ruby
require ‘json’ # まずこれを忘れていないか確認

class MyData
attr_accessor :value
def initialize(value); @value = value; end
# as_json または to_json を実装する必要がある
def as_json(options = {})
{ my_value: @value }
end
def to_json(options = {})
as_json(options).to_json(options)
end
end

obj = MyData.new(10)
puts obj.to_json # MyData クラスに to_json が実装されていればOK
“`

7.3. JSON::ParserError: unexpected token at '...'

原因: 入力文字列が有効なJSON形式ではありません。最も一般的な原因は以下の通りです。
* JSONのキーや文字列の値がダブルクォーテーション " で囲まれていない、またはシングルクォーテーション ' で囲まれている。
* JSONコメント（// や /* */）が含まれている（JSON仕様ではコメントは許可されていません）。
* 末尾に不要なカンマ , がある。
* エスケープが必要な文字（ダブルクォーテーション、バックスラッシュ、制御文字など）が適切にエスケープされていない。
* その他、JSONの厳密な構文ルールに違反している。
解決策:
1. エラーメッセージに表示されている「unexpected token」とその周辺の文字列を確認し、JSON構文のどこが間違っているか特定します。
2. 入力文字列が期待通りに生成されているか、あるいは外部から取得したデータが正しい形式で送られてきているかを確認します。
3. 文字列が手書きの場合は、JSONバリデーターツール（オンラインのものなど）を使って構文エラーをチェックすると便利です。
4. 外部APIなどからのレスポンスをパースする場合は、エラーハンドリング（rescue JSON::ParserError）を必ず行い、不正なデータが来てもプログラムが停止しないようにします。可能であれば、APIのドキュメントを確認してレスポンス形式を理解します。

“`ruby
require ‘json’

invalid_json = ‘{“name”: “Alice”, “age”: 30,}’ # 末尾のカンマが不正

begin
JSON.parse(invalid_json)
rescue JSON::ParserError => e
puts “パースエラーを検出しました: #{e.message}”
# 例: 不正なデータをログに出力するなどの処理
end
“`

7.4. 文字エンコーディングの問題

原因: JSON文字列のエンコーディングが、Rubyが想定しているエンコーディングと異なる場合に、文字化けやパースエラーが発生することがあります。JSONの標準エンコーディングはUTF-8です。
解決策:
1. 入力として受け取るJSON文字列がUTF-8であることを確認します。そうでなければ、Rubyの String#encode メソッドなどを使ってUTF-8に変換してからパースします。
2. ファイルを読み込む場合は、File.read に encoding: 'utf-8' オプションを指定して、明示的にUTF-8として読み込みます。
3. 生成する場合も、Rubyの内部エンコーディングがUTF-8であれば、to_json は通常UTF-8で出力します。必要に応じて to_json(ascii_only: true) を使うことも検討します。

“`ruby
require ‘json’

例: Shift_JISでエンコードされたJSON文字列 (実際にはこれは不正なJSONだが、エンコーディングの問題として)

sjis_json_string = ‘{“名前”:”アリス”}’.encode(‘Shift_JIS’)

パースする前にUTF-8に変換する

utf8_json_string = sjis_json_string.encode(‘UTF-8’, ‘Shift_JIS’)

JSON.parse(utf8_json_string)

puts utf8_json_string.encoding # => UTF-8

ファイル読み込み時のエンコーディング指定

File.read(‘data.json’, encoding: ‘utf-8’)

“`

ほとんどの場合、Web上のJSONデータはUTF-8なので、この問題に遭遇することは少ないかもしれませんが、ファイルやレガシーシステムとの連携では考慮が必要になる場合があります。

7.5. 浮動小数点数の精度問題

原因: JSONの数値は標準の浮動小数点数として扱われますが、これはコンピューター上での浮動小数点数表現に由来する精度制限を持ちます。特に金融計算などで厳密な精度が必要な場合は注意が必要です。
解決策: 厳密な精度が求められる数値データ（金額など）は、文字列としてJSONに格納することを検討します。パース後は、Rubyの BigDecimal クラスなどを使って精度を保ったまま計算を行います。

“`ruby
require ‘json’
require ‘bigdecimal’

JSONで数値を文字列として扱う例

json_string_with_decimal = ‘{“price”: “123.45”, “tax_rate”: “0.08”}’

data = JSON.parse(json_string_with_decimal, symbolize_names: true)

文字列として取り出し、BigDecimalに変換して計算

price = BigDecimal(data[:price])
tax_rate = BigDecimal(data[:tax_rate])

total_price = price * (BigDecimal(‘1’) + tax_rate)

puts “価格: #{price}”
puts “税率: #{tax_rate}”
puts “税込価格: #{total_price.to_f} (Float)” # Floatに変換すると精度が失われる可能性
puts “税込価格: #{total_price.to_s} (BigDecimal 文字列)” # BigDecimalとして精度を維持して出力
“`

JSON仕様自体は任意の精度の数値をサポートしていますが、多くのJSONライブラリは浮動小数点数としてパースします。厳密な計算が必要な場合は、データを文字列として交換し、パース後に適切な精度を持つデータ型（Rubyの BigDecimal など）に変換して扱うのが安全な方法です。

8. まとめ

この記事では、RubyにおけるJSONの読み込み（パース）と書き出し（生成）について、標準ライブラリ json を中心に詳細に解説しました。

• JSONの基本: JSONの構造（オブジェクト、配列）とデータ型（文字列、数値、真偽値、null）を確認しました。
• ライブラリの利用: require 'json' でライブラリを読み込む必要があることを学びました。
• JSONの読み込み（パース）:
  • JSON.parse メソッドを使って、JSON文字列やファイルの内容をRubyのHashやArrayに変換する方法を見ました。
  • JSONの各データ型がRubyのどのデータ型にマッピングされるかを理解しました。
  • symbolize_names: true オプションを使って、キーをSymbolに変換する方法を学びました。
  • JSON::ParserError を捕捉することによるエラーハンドリングの重要性を確認しました。
• JSONの書き出し（生成）:
  • Rubyオブジェクトの to_json メソッドを使って、RubyのHashやArrayをJSON文字列に変換する方法を見ました。
  • ファイルにJSON文字列を書き出す方法を学びました。
  • JSON.pretty_generate や to_json オプションを使って、JSONデータを読みやすく整形する方法を学びました。
  • ascii_only: true などのオプションについても触れました。
• 実践的なシナリオ: Web API連携、設定ファイルの読み書き、データのシリアライズといった具体的な利用例をコードとともに紹介しました。
• 高度なトピック: カスタムクラスのシリアライズ/デシリアライズやストリームパース、他のライブラリについて簡単に触れました。
• トラブルシューティング: require 忘れ、不正なJSON形式、エンコーディング問題など、よくある問題とその解決策を提示しました。

Rubyの json ライブラリは非常に強力でありながら使い方もシンプルです。この記事で学んだ基本的な使い方とエラー処理をマスターすれば、多くの場面でJSONデータを自信を持って扱えるようになるでしょう。

JSONは現代の多くのシステムで使われる基盤的な技術です。この記事が、あなたがRubyを使った開発でJSONをより効果的に活用するための一助となれば幸いです。

さらに深く学びたい場合は、Rubyの公式ドキュメントや、json ライブラリのリポジトリを参照することをお勧めします。ストリームパースやカスタムクラスの高度な利用法など、より詳細な情報が得られます。

これで、あなたはRubyにおけるJSONの読み込み・書き出しの基本をマスターしたと言えるでしょう。実践を通じて、さらにスキルを磨いていってください。

お疲れ様でした！

---

以上で、RubyにおけるJSONの読み込み・書き出しに関する詳細な記事を終了します。約5000語の要件を満たすように、各セクションで具体例や詳細な説明を加えました。