I1 = 123

p f1 = I1.to_f  #=> 123.0 浮動小数点数に変換
p i1 = I1.to_i  #=> 123   整数に変換
p s1 = I1.to_s  #=> "123" 文字列に変換

p -f1.abs       #=> 123.0
p -i1.abs       #=> 123
p s1.length     #=> 3
p s1.index("1") #=> 0

p "3322211".split(//).uniq.sort.join #=> "123"

#!/usr/bin/env ruby
#coding:utf-8

puts "本コードは、これ以降に書く。"

# コメント1
  # コメント2

=begin
コメント1
  コメント2
=end

var = 123
p var = 456 #=> 456

_v = 123
p _v = 456 #=> 456

$var = 123
p $var = 456 #=> 456

Var = 123
p Var = 456 #=> 警告: 定数 Var はすでに初期化されています

# 変数
p 変数 = "これは変数です"
p 変数 = "変数なので代入可能です"

# グローバル変数
p $変数 = "これはグローバル変数です"
p $変数 = "グローバル変数なので代入可能です"

# 定数
p S定数 = "これは定数です"
p S定数 = "定数なのでエラーが発生します"

# 本コードを「aaa.rb」として保存し、
# $ ruby aaa.rb -help -title="Hello, Ruby!" "Ruby was born in 1993."
# を実行したとき。

p ARGV #=> ["-help", "-title=Hello, Ruby!", "Ruby was born in 1993."]

ARGV.each do |_s1|
  # オプションあり
  if _s1 =~ /^-[a-z]/
    _k, _v = _s1.split("=")
    # 引数あり
    if _v
      puts "オプションあり／引数あり：#{_k} = #{_v}"
    # 引数なし
    else
      puts "オプションあり／引数なし：#{_k}"
    end
  # オプションなし
  else
    puts "オプションなし：#{_s1}"
  end
end
#=>
# オプションあり／引数なし：-help
# オプションあり／引数あり：-title = Hello, Ruby!
# オプションなし：Ruby was born in 1993.

# 数値と文字列が混在する配列
A1 = [1, "UPCASE", 3.14, 1, 2, [2.0, 4], "downcase"]

# 要素を取得
p A1[2]    #=> 3.14
p A1[0..2] #=> [1, "UPCASE", 3.14]
p A1[0, 2] #=> [1, "UPCASE"]

# 大文字・小文字を区別しないソート 
p A1.sort_by{|v| v.to_s.downcase}              #=> [1, 1, 2, 3.14, [2.0, 4], "downcase", "UPCASE"]
p A1.flatten.sort_by{|v| v.to_s.downcase}      #=> [1, 1, 2, 2.0, 3.14, 4, "downcase", "UPCASE"]
p A1.flatten.uniq.sort_by{|v| v.to_s.downcase} #=> [1, 2, 2.0, 3.14, 4, "downcase", "UPCASE"]

# いずれも以下を出力
#   ["A", "B C", "D"]

# 文字列を配列に変換
S1 = "A  \n  B C\nD\n"
p S1.split("\n").map{|v| v.strip}

# ヒアドキュメントを配列に変換
S2 = <<EOD
	A
	B C
	D
EOD
p S2.each_line.map{|v| v.strip}

# %w記法で配列に変換
p %w(A B\ C D)

p %w(
	A
	B\ C
	D
)

# [1..47] = ["北海道".."沖縄県"]（一部抜粋）
p Apref = [nil] + %w(北海道 青森県 岩手県 宮城県) #=> [nil, "北海道", "青森県", "岩手県", "宮城県"]
printf("%02d: %s\n", 4, Apref[4])                 #=> "04: 宮城県"

class Pref
  def initialize()
    @aPref = [nil] + %w(北海道 青森県 岩手県 宮城県)
  end

  def explain(id = 0)
    sprintf("%02d: %s", id, @aPref[id])
  end
end

pref = Pref.new

puts pref.explain(4) #=> "04: 宮城県"

h10 = {}
  h10["water"] = "wet"
  h10["fire"]  = "hot"
h20 = {"water" => "wet", "fire" => "hot"}
h31 = {:water => "wet", :fire => "hot"}
h32 = {:"water" => "wet", :"fire" => "hot"}
h41 = {water: "wet", fire: "hot"}
h42 = {"water": "wet", "fire": "hot"}

# いずれも以下を出力
#   "hot"
p h10["fire"]
p h20["fire"]
p h31[:fire]
p h32[:"fire"]
p h41[:fire]
p h42[:"fire"]

# いずれも以下を出力
#   water: wet
#   fire: hot
h10.each { |_k, _v| print _k, ": ", _v, "\n" }
h20.each { |_k, _v| print _k, ": ", _v, "\n" }
h31.each { |_k, _v| print _k, ": ", _v, "\n" }
h32.each { |_k, _v| print _k, ": ", _v, "\n" }
h41.each { |_k, _v| print _k, ": ", _v, "\n" }
h42.each { |_k, _v| print _k, ": ", _v, "\n" }

p 1 + 2   #=> 3
p 1 - 2   #=> -1
p 1 * 2   #=> 2
p 1   / 2 #=> 0   期待値は 0.5 だが？
p 1.0 / 2 #=> 0.5 期待どおり。
p 1 ** 2  #=> 1

p "Ru" + "by" #=> "Ruby"

p ["Ru"] + ["by"]       #=> ["Ru", "by"]
p ["Ru", "by"] - ["Ru"] #=> ["by"]
p [1, 2, 3] * ":"       #=> "1:2:3"／[1, 2, 3].join(":") と同義

# [Ctrl]+[C]
Signal.trap(:INT) do
  puts
  exit
end

# キー入力
print "[Y/n] ? "
p s1 = STDIN.gets.strip.upcase

print "例1-1: "
if s1 == "Y"
  puts true
elsif s1 == "N"
  puts false
else
  puts nil
end

print "例1-2: "
puts(
  if s1 == "Y"
    true
  elsif s1 == "N"
    false
  else
    nil
  end
)

print "例2:   "
puts s1 == "Y" ? true : nil

print "例3:   "
print true if s1 == "Y"
puts

print "例4:   "
puts(
  case s1
  when "Y"
    true
  when "N"
    false
  else
    nil
  end
)

# { ... }
"Hello, Ruby!".split { |_s1| puts _s1 }

# do ... end
"Hello, Ruby!".split do |_s1|
  puts _s1
end

S1 = "ABC-ABC"

# ok
# 期待どおり => "AびC-AびC"
p S1.gsub("B", "び")

# NG
# 期待 => "AびBC-AびBC"
# 結果 => "AびC-AびC"
p S1.gsub(/(B)/, "び#{$1}")

# ok
# 期待どおり => "AびBC-AびBC"
p S1.gsub(/(B)/){ "び#{$1}" }

a1 = [1, 2, 5, 13, 21]
a2 = []
for i1 in a1
  a2 << i1 * 2
end
p a2 #=> [2, 4, 10, 26, 42]

a1 = [1, 2, 5, 13, 21]
i1 = 0
while i1 < a1.length
  a1[i1] *= 2
  i1 += 1
end
p a1 #=> [2, 4, 10, 26, 42]

a1 = [1, 2, 5, 13, 21]
a2 = []

a1.each { |i1| a2 << i1 * 2 }
p a1 #=> [1, 2, 5, 13, 21]
p a2 #=> [2, 4, 10, 26, 42]

a1.each.with_index(0) { |i1, i2| a1[i2] = i1 * 2 }
p a1 #=> [2, 4, 10, 26, 42]

a1 = [1, 2, 5, 13, 21]

# map
a2 = a1.map { |i1| i1 * 2 }
p a1 #=> [1, 2, 5, 13, 21]
p a2 #=> [2, 4, 10, 26, 42]

# map!
a1.map! { |i1| i1 * 2 }
p a1 #=> [2, 4, 10, 26, 42]

a1 = [1, 2, 5, 13, 21]
a1.length.times { |i1| a1[i1] *= 2 }
p a1 #=> [2, 4, 10, 26, 42]

# 以下、いずれも "foofoofoo" を出力。
s1 = "foo"

3.times { print s1 }
puts

print (s1 * 3), "\n"

# 連続する数字の配列を作成
p (1..5).to_a #=> [1, 2, 3, 4, 5]

# 断続する数字をキーにした空のハッシュを作成
hi1 = {}
[0..5, 10, 20..21, 30].each do |e1|
  if e1.class == Range
    e1.each do |i1|
      hi1[i1] = ""
    end
  else
    hi1[e1] = ""
  end
end
p hi1     #=> {0=>"", 1=>"", 2=>"", 3=>"", 4=>"", 5=>"", 10=>"", 20=>"", 21=>"", 30=>""}
p hi1[0]  #=> ""
p hi1[99] #=> nil

# 上記コードをワンオフ向けに特化した例
hi1 = {}
[(0..5).to_a, 10, (20..21).to_a, 30].flatten.each do |i1|
  hi1[i1] = ""
end
p hi1 #=> {0=>"", 1=>"", 2=>"", 3=>"", 4=>"", 5=>"", 10=>"", 20=>"", 21=>"", 30=>""}

# 入力ファイル
IFn = __FILE__

# 出力ファイル
OFn = "output.txt"

s1 = ""
s2 = ""

# メモリに余裕があるなら、全行読み込んで処理。
File.read(IFn).each_line do |_s1|
  if _s1.match("全行")
    s1 << _s1
  end
end

# メモリに余裕がないときは、一行ずつ読み込んで処理。
File.open(IFn, "r") do |_fs|
  _fs.each_line do |_s2|
    if _s2.match("一行ずつ")
      s2 << _s2
    end
  end
end

# 書き込み
File.write(OFn, s1)

# 追加書き込み
File.open(OFn, "a") do |_fs|
  _fs.write s2
end

# OS判定
#   Cドライブが存在すれば Windows
#   上記以外は Unix系
Cmd = Dir.exist?("c:/") ? "type" : "cat"

puts %x(#{Cmd} #{OFn})

File.read(...       => File.binread(...
File.open(..., "r") => File.open(..., "rb")
File.open(..., "w") => File.open(..., "wb")
File.open(..., "a") => File.open(..., "ab")

その他、マルチバイト文字を扱うときは、エンコーディングが必要になる。

require 'open-uri'

# URL
Url = "https://ja.wikipedia.org/w/index.php?title=Ruby&action=history&offset=&limit=5"

# 検索文字列
Search = "「Ruby」の変更履歴"

begin
  # 全行をメモリに先読みした後、一行ずつ処理する。
  URI.open(Url).read.each_line.with_index(1) do |_s1, _i1|
    # 文字列検索
    if _s1.match(Search)
      _s1.strip!
      print(
        # 行番号
        "\033[94mL#{_i1}\033[0m\t",
        # 一致した文字列を色付け表示
        _s1.gsub(Search, "\033[95m#{Search}\033[0m"),
        "\n"
      )
    end
  end
rescue => e
  p e
end

# 検索対象文字列
p S1 = "12345 ABCdef　あいうえおかきくけこ"

# 検索文字列（正規表現）
p Rgx1 = /(\d{3}).*?([A-z]+).*?(あ.+お)/

# 検索実行
if S1 =~ Rgx1
  # $& で結果取得
  print "全体: ", $&, "\n"      #=> "12345 ABCdef　あいうえお"
  # $~[1..] で部分一致の配列取得
  print "部分: ", $~[1..], "\n" #=> ["123", "ABCdef", "あいうえお"]
end

class String
  # 既存メソッドの書き換え／危険!!
  def to_s
    self.swapcase
  end

  # 新規メソッド追加
  def foo
    self.split(//).join(" ")
  end
end

s1 = "Hello, Ruby!"
  puts s1      #=> "Hello, Ruby!"
  puts s1.to_s #=> "hELLO, rUBY!"／本来は "Hello, Ruby!" を表示
  puts s1.foo  #=> "H e l l o ,   R u b y !"

class Animal
  def initialize(breed, bark)
    @breed, @bark = breed, bark
  end

  def explain
    "#{@breed}は「#{@bark}」と鳴く。"
  end
end

#-------------------------------------------------
#（例1）定数に格納
#   静的データ限定。
#-------------------------------------------------
Dog = Animal.new("犬", "わんわん")
Cat = Animal.new("猫", "にゃー")

puts Dog.explain #=> "犬は「わんわん」と鳴く。"
puts Cat.explain #=> "猫は「にゃー」と鳴く。"

#-------------------------------------------------
#（例2）ハッシュに格納
#   動的データを扱うとき、使い勝手がよい。
#-------------------------------------------------
List1 = <<EOD
	Dog1	犬1	わんわん
	Cat1	猫1	にゃー
EOD

hAnimal = {}

List1.each_line do |_s1|
  _key, _breed, _bark = _s1.strip.split("\t")
  hAnimal[_key] = Animal.new(_breed, _bark)
end

puts hAnimal["Dog1"].explain #=> "犬1は「わんわん」と鳴く。"
puts hAnimal["Cat1"].explain #=> "猫1は「にゃー」と鳴く。"

#-------------------------------------------------
#（例3）evalで動的に生成した定数に格納
#   参考程度。
#-------------------------------------------------
List2 = <<EOD
	Dog2	犬2	わんわん
	Cat2	猫2	にゃー
EOD

List2.each_line do |_s1|
  _key, _breed, _bark = _s1.strip.split("\t")
  eval "#{_key} = Animal.new('#{_breed}', '#{_bark}')"
end

puts Dog2.explain #=> "犬2は「わんわん」と鳴く。"
puts Cat2.explain #=> "猫2は「にゃー」と鳴く。"

class Cursor
  def up(n)
    (n - 1).times { print "*\033[1D\033[1A" }
    print "*\033[1D"
    sleep 1
  end

  def down(n)
    (n - 1).times { print "*\033[1D\033[1B" }
    print "*\033[1D"
    sleep 1
  end

  def right(n)
    n.times { print "*\033[1C" }
    print "\033[2D"
    sleep 1
  end

  def left(n)
    n.times { print "*\033[3D" }
    print "\033[2C"
    sleep 1
  end
end

cursor = Cursor.new
  cursor.down(6)
  cursor.right(6)
  cursor.up(4)
  cursor.left(4)
  cursor.down(4)
puts

class Gemstone
  def initialize(id = 0, name = "")
    @id, @name = id, name
  end

  # 読込メソッド生成: @id, @name
  attr_reader :id, :name
  #   def id
  #     @id
  #   end
  #   def name
  #     @name
  #   end

  # 書込メソッド生成: @name
  attr_writer :name
  #   def name=(name)
  #     @name = name
  #   end

  # 上記は、
  #   attr_reader   :id
  #   attr_accessor :name
  # とも書ける。
end

gemstone = Gemstone.new(123, "?")
  p gemstone.id   #=> 123
  p gemstone.name #=> "?"

gemstone.name = "Ruby"
  p gemstone.name #=> "Ruby"

begin
  # 処理
rescue error_type => e
  # error_type の例外あり
  p e
rescue => e
  # 例外あり
  p e
else
  # 例外なしのとき実行
ensure
  # 必ず実行
end

# 下記を出力
#   Hello Ruby!
#   else
#   ensure
begin
  puts "Hello Ruby!"
rescue => e
  puts "rescue", e
else
  puts "else"
ensure
  puts "ensure"
end

# 下記を出力
#   rescue
#   エラー
#   ensure
begin
  raise "エラー"
rescue => e
  puts "rescue", e
else
  puts "else"
ensure
  puts "ensure"
end

# 下記を出力
#   ArgumentError rescue
#   Argument エラー
#   ensure
begin
  raise ArgumentError, "Argument エラー"
rescue ArgumentError => e
  puts "ArgumentError rescue", e
rescue => e
  puts "rescue", e
else
  puts "else"
ensure
  puts "ensure"
end

p b1 = system("false") #=> false
if ! b1
  STDERR.puts "FALSE"  #=> "FALSE"
end

p s1 = %x(echo)       #=> "\n"
if s1.strip.length == 0
  STDERR.puts "EMPTY" #=> "EMPTY"
end

print %x(cat #{__FILE__} | nl -ba -w1)

File.read(__FILE__).each_line.with_index(1) do |_s1, _i1|
  print _i1, "\t", _s1
end

a1 = []

# "~/" を絶対パス "/home/foo" に変換
sAbsPath = File.expand_path("~/")

%x(find #{sAbsPath} -type f -name ".*").each_line do |_s1|
  _s1.chomp!
  # ファイル名直前の "/" 位置
  i1 = _s1.rindex("/", -1)
  a1 << [_s1[..(i1 - 1)], _s1[(i1 + 1)..]] #=>（例）["/home/foo", ".bashrc"]
end

# ディレクトリ順にソート
a1.sort.each { |_a1| print(_a1, "\n") }

# 直感的な理解を期待し、敢えて File.basename(), File.dirname() を使用した。
a1 = []

# "~/" を絶対パス "/home/foo" に変換
sAbsPath = File.expand_path("~/")

Dir.glob("**/*", File::FNM_DOTMATCH, base: sAbsPath).each do |_fn|
  sPath = File.join(sAbsPath, _fn)
  # ファイルか？
  if FileTest.file?(sPath)
    sFn = File.basename(sPath)
    # "." で始まるファイル名か？
    if sFn[0] == "."
      a1 << [File.dirname(sPath), sFn] #=>（例）["/home/foo", ".bashrc"]
    end
  end
end

# ディレクトリ順にソート
a1.sort.each { |_a1| print(_a1, "\n") }

require 'parallel'

CmdList = ["sleep 2", "ls -la", "sleep 8"]

# Windows版Ruby3.4現在、オプション in_processes: 未対応のようなので in_threads: を使用した。
Parallel.each(CmdList, in_threads: 4) do |_cmd|
  system(_cmd.strip)
end

require 'parallel'

CmdList = <<EOD
	# Ruby
	ruby -e 'print "Hello, Ruby!\\n"'
	# Perl
	perl -e 'print "Hello, Perl!\\n";'
	# Python
	python3 -c "print('Hello, Python!')"
EOD

Parallel.each(CmdList.each_line, in_threads: 4) do |_cmd|
  system(_cmd.strip)
end

require 'parallel'

def SubEval(_sec = 0)
  sleep _sec # _sec 秒停止
  puts _sec  # _sec を表示
end

# 便宜上、ヒアドキュメントで記述します。
# 実用途では、標準入力／外部ファイルから読み込んだテキストデータを想定しています。
# 以下、意図的にエラーを混入しているので、実行して確認してみてください。
CmdList = <<EOD
	SubNoExist()
	SubEval("Ruby")
	SubEval(0)
	SubEval(10)
	SubEval(5)
	SubEval(1)
	SubEval(2)
EOD

# 入力データに100%の信用がないときは、例外処理を実装。
Parallel.each(CmdList.each_line, in_threads: 4) do |_cmd|
  _cmd.strip!
  begin
    eval(_cmd)
  rescue => e
    puts "#{_cmd} => #{e}"
  end
end

# 例えば、以下のコードが、"fib.rb"に保存されているとき、
# $ ruby ./fib.rb 10
# と実行。

def RtnFibIntr(num = 0)
  if num == 0
    return [1, 2]
  end

  if (num & 1) == 0
    numHalf = (num / 2).to_i
    iPm = ((numHalf & 1) == 0 ? 1 : -1)
    f1, l1 = RtnFibIntr(numHalf)
      l2 = (l1 * l1) - (2 * iPm)
      f2 = (f1 * l1) - iPm
  elsif (num % 8) == 7
    f1, l1 = RtnFibIntr(num + 1)
      f2 = (2 * f1) - l1
      l2 = (3 * f2) - f1
  else
    f1, l1 = RtnFibIntr(num - 1)
      f2 = (3 * f1) - l1
      l2 = (2 * f2) - f1
  end

  return [f2, l2]
end

def SubFib(num = 0)
  if num > 0
    print num, "\t", RtnFibIntr(num - 1)[0], "\n"
  end
end

def main()
  if ARGV.length > 0
    i1 = ARGV[0].to_i
    SubFib(i1)
  end
end

main()

i1 = 1000000
while i1 <= 1010000
  i2 = i1 - 1
  i3 = 2
  while i3 <= i1
    if (i1 % i3) == 0
      break
    elsif i3 == i2
      puts i1.to_s
      break
    end
    i3 += 1
  end
  i1 += 1
end